From db1e3d1b6296fde793006e12c708e07e77009c5c Mon Sep 17 00:00:00 2001 From: ghidra1 Date: Mon, 28 Dec 2020 13:30:36 -0500 Subject: [PATCH] Renamed Record class to DBRecord --- .../Base/developer_scripts/FixLangId.java | 2 +- .../debug/dbtable/AbstractColumnAdapter.java | 7 +- .../debug/dbtable/BinaryColumnAdapter.java | 7 +- .../debug/dbtable/BooleanColumnAdapter.java | 7 +- .../debug/dbtable/ByteColumnAdapter.java | 7 +- .../debug/dbtable/DbLargeTableModel.java | 12 +- .../debug/dbtable/DbSmallTableModel.java | 8 +- .../debug/dbtable/IntegerColumnAdapter.java | 7 +- .../debug/dbtable/LongColumnAdapter.java | 7 +- .../debug/dbtable/ShortColumnAdapter.java | 7 +- .../debug/dbtable/StringColumnAdapter.java | 7 +- .../AddressIndexPrimaryKeyIteratorTest.java | 2 +- .../database/map/AddressKeyIteratorTest.java | 2 +- .../database/util/SharedRangeMapDBTest.java | 4 +- .../test/java/ghidra/DatabaseBenchMarks.java | 10 +- .../FunctionID/ghidra_scripts/RepackFid.java | 4 +- .../java/ghidra/feature/fid/db/FidDB.java | 10 +- .../ghidra/feature/fid/db/FunctionRecord.java | 6 +- .../ghidra/feature/fid/db/FunctionsTable.java | 18 +-- .../ghidra/feature/fid/db/LibrariesTable.java | 10 +- .../ghidra/feature/fid/db/LibraryRecord.java | 6 +- .../ghidra/feature/fid/db/RelationsTable.java | 10 +- .../ghidra/feature/fid/db/StringsTable.java | 4 +- .../vt/api/db/AddressCorrelatorDB.java | 6 +- .../vt/api/db/AssociationDatabaseManager.java | 48 +++---- .../vt/api/db/MarkupItemStorageDB.java | 8 +- .../api/db/VTAddressCorrelationAdapterV0.java | 7 +- .../vt/api/db/VTAddressCorrelatorAdapter.java | 2 +- .../feature/vt/api/db/VTAssociationDB.java | 10 +- .../api/db/VTAssociationTableDBAdapter.java | 12 +- .../api/db/VTAssociationTableDBAdapterV0.java | 21 ++- .../ghidra/feature/vt/api/db/VTMatchDB.java | 8 +- .../db/VTMatchMarkupItemTableDBAdapter.java | 6 +- .../db/VTMatchMarkupItemTableDBAdapterV0.java | 9 +- .../feature/vt/api/db/VTMatchSetDB.java | 18 +-- .../vt/api/db/VTMatchSetTableDBAdapter.java | 8 +- .../vt/api/db/VTMatchSetTableDBAdapterV0.java | 24 ++-- .../vt/api/db/VTMatchTableDBAdapter.java | 6 +- .../vt/api/db/VTMatchTableDBAdapterV0.java | 9 +- .../feature/vt/api/db/VTMatchTagDB.java | 12 +- .../vt/api/db/VTMatchTagDBAdapter.java | 6 +- .../vt/api/db/VTMatchTagDBAdapterV0.java | 9 +- .../ghidra/feature/vt/api/db/VTSessionDB.java | 24 ++-- .../main/java/db/ConvertedRecordIterator.java | 7 +- .../java/db/{Record.java => DBRecord.java} | 16 +-- .../DB/src/main/java/db/DatabaseUtils.java | 5 +- .../DB/src/main/java/db/FieldIndexTable.java | 14 +- .../src/main/java/db/FieldKeyRecordNode.java | 14 +- .../main/java/db/FixedKeyFixedRecNode.java | 12 +- .../src/main/java/db/FixedKeyRecordNode.java | 16 +-- .../src/main/java/db/FixedKeyVarRecNode.java | 10 +- .../DB/src/main/java/db/FixedRecNode.java | 12 +- .../DB/src/main/java/db/IndexTable.java | 4 +- .../src/main/java/db/KeyToRecordIterator.java | 4 +- .../src/main/java/db/LongKeyRecordNode.java | 20 +-- .../DB/src/main/java/db/MasterTable.java | 4 +- .../main/java/db/ObjectStorageAdapterDB.java | 4 +- .../DB/src/main/java/db/RecordIterator.java | 5 +- .../DB/src/main/java/db/RecordTranslator.java | 3 +- .../Framework/DB/src/main/java/db/Schema.java | 6 +- .../DB/src/main/java/db/SparseRecord.java | 2 +- .../Framework/DB/src/main/java/db/Table.java | 60 ++++---- .../DB/src/main/java/db/TableRecord.java | 10 +- .../java/db/TranslatedRecordIterator.java | 4 +- .../DB/src/main/java/db/VarKeyRecordNode.java | 22 +-- .../DB/src/main/java/db/VarRecNode.java | 10 +- .../java/db/DBFixedKeyIndexedTableTest.java | 122 ++++++++-------- .../db/DBFixedKeySparseIndexedTableTest.java | 2 +- .../src/test/java/db/DBFixedKeyTableTest.java | 82 +++++------ .../src/test/java/db/DBIndexedTableTest.java | 132 +++++++++--------- .../db/DBLongKeyChainedBufferUseTest.java | 38 ++--- .../src/test/java/db/DBLongKeyTableTest.java | 82 +++++------ .../Framework/DB/src/test/java/db/DBTest.java | 2 +- .../DB/src/test/java/db/DBTestUtils.java | 40 +++--- .../src/test/java/db/DBVarKeyTableTest.java | 78 +++++------ .../test/java/db/TableConcurrencyTest.java | 8 +- .../DB/src/test/java/db/TableTest.java | 6 +- .../src/test/java/db/RecoveryDBTest.java | 24 ++-- .../store/db/PackedDatabaseTest.java | 4 +- .../framework/data/MetadataManager.java | 5 +- .../java/ghidra/framework/data/OptionsDB.java | 22 +-- .../program/database/DBObjectCache.java | 6 +- .../program/database/DataTypeArchiveDB.java | 6 +- .../database/DataTypeArchiveDBChangeSet.java | 4 +- .../program/database/DatabaseObject.java | 6 +- .../database/OverlaySpaceAdapterDB.java | 12 +- .../ghidra/program/database/ProgramDB.java | 20 +-- .../program/database/ProgramDBChangeSet.java | 8 +- .../program/database/ProgramUserDataDB.java | 18 +-- .../program/database/bookmark/BookmarkDB.java | 12 +- .../database/bookmark/BookmarkDBAdapter.java | 13 +- .../bookmark/BookmarkDBAdapterV0.java | 5 +- .../bookmark/BookmarkDBAdapterV1.java | 21 ++- .../bookmark/BookmarkDBAdapterV3.java | 12 +- .../database/bookmark/BookmarkDBManager.java | 28 ++-- .../bookmark/BookmarkTypeDBAdapter.java | 6 +- .../BookmarkTypeDBAdapterNoTable.java | 6 +- .../bookmark/BookmarkTypeDBAdapterV0.java | 9 +- .../database/bookmark/OldBookmarkManager.java | 13 +- .../program/database/code/CodeManager.java | 92 ++++++------ .../program/database/code/CodeUnitDB.java | 10 +- .../database/code/CommentHistoryAdapter.java | 6 +- .../code/CommentHistoryAdapterNoTable.java | 4 +- .../code/CommentHistoryAdapterV0.java | 4 +- .../database/code/CommentsDBAdapter.java | 12 +- .../database/code/CommentsDBAdapterV0.java | 24 ++-- .../database/code/CommentsDBAdapterV1.java | 10 +- .../program/database/code/DataComponent.java | 4 +- .../ghidra/program/database/code/DataDB.java | 6 +- .../program/database/code/DataDBAdapter.java | 20 +-- .../database/code/DataDBAdapterV0.java | 21 ++- .../database/code/DataRecordIterator.java | 5 +- .../program/database/code/InstDBAdapter.java | 18 +-- .../database/code/InstDBAdapterV0.java | 29 ++-- .../database/code/InstDBAdapterV1.java | 21 ++- .../program/database/code/InstructionDB.java | 6 +- .../code/InstructionRecordIterator.java | 5 +- .../program/database/code/ProtoDBAdapter.java | 5 +- .../database/code/ProtoDBAdapterV0.java | 15 +- .../database/code/ProtoDBAdapterV1.java | 5 +- .../database/code/PrototypeManager.java | 22 +-- .../ghidra/program/database/data/ArrayDB.java | 6 +- .../program/database/data/ArrayDBAdapter.java | 10 +- .../database/data/ArrayDBAdapterV0.java | 18 +-- .../database/data/ArrayDBAdapterV1.java | 8 +- .../database/data/BuiltinDBAdapter.java | 6 +- .../database/data/BuiltinDBAdapterV0.java | 8 +- .../program/database/data/CategoryDB.java | 4 +- .../database/data/CategoryDBAdapter.java | 8 +- .../database/data/CategoryDBAdapterV0.java | 12 +- .../database/data/ComponentDBAdapter.java | 6 +- .../database/data/ComponentDBAdapterV0.java | 8 +- .../program/database/data/CompositeDB.java | 6 +- .../database/data/CompositeDBAdapter.java | 12 +- .../database/data/CompositeDBAdapterV0.java | 12 +- .../database/data/CompositeDBAdapterV1.java | 14 +- .../database/data/CompositeDBAdapterV2V3.java | 12 +- .../database/data/DataTypeComponentDB.java | 8 +- .../program/database/data/DataTypeDB.java | 6 +- .../database/data/DataTypeManagerDB.java | 82 +++++------ .../ghidra/program/database/data/EnumDB.java | 10 +- .../program/database/data/EnumDBAdapter.java | 12 +- .../database/data/EnumDBAdapterNoTable.java | 8 +- .../database/data/EnumDBAdapterV0.java | 12 +- .../database/data/EnumDBAdapterV1.java | 12 +- .../database/data/EnumValueDBAdapter.java | 4 +- .../data/EnumValueDBAdapterNoTable.java | 4 +- .../database/data/EnumValueDBAdapterV0.java | 6 +- .../database/data/FunctionDefinitionDB.java | 8 +- .../data/FunctionDefinitionDBAdapter.java | 12 +- .../FunctionDefinitionDBAdapterNoTable.java | 8 +- .../data/FunctionDefinitionDBAdapterV0.java | 12 +- .../data/FunctionDefinitionDBAdapterV1.java | 12 +- .../data/FunctionParameterAdapter.java | 10 +- .../data/FunctionParameterAdapterNoTable.java | 6 +- .../data/FunctionParameterAdapterV0.java | 12 +- .../data/FunctionParameterAdapterV1.java | 8 +- .../data/InstanceSettingsDBAdapter.java | 10 +- .../data/InstanceSettingsDBAdapterV0.java | 8 +- .../database/data/ParameterDefinitionDB.java | 8 +- .../database/data/ParentChildDBAdapterV0.java | 6 +- .../program/database/data/PointerDB.java | 6 +- .../database/data/PointerDBAdapter.java | 20 +-- .../database/data/PointerDBAdapterV0.java | 10 +- .../database/data/PointerDBAdapterV1.java | 10 +- .../database/data/PointerDBAdapterV2.java | 8 +- .../program/database/data/SettingsDB.java | 6 +- .../database/data/SettingsDBAdapter.java | 6 +- .../database/data/SettingsDBAdapterV0.java | 8 +- .../database/data/SettingsDBManager.java | 14 +- .../database/data/SourceArchiveAdapter.java | 14 +- .../data/SourceArchiveAdapterNoTable.java | 14 +- .../database/data/SourceArchiveAdapterV0.java | 14 +- .../database/data/SourceArchiveDB.java | 8 +- .../program/database/data/StructureDB.java | 20 +-- .../program/database/data/TypedefDB.java | 6 +- .../database/data/TypedefDBAdapter.java | 12 +- .../database/data/TypedefDBAdapterV0.java | 12 +- .../database/data/TypedefDBAdapterV1.java | 12 +- .../ghidra/program/database/data/UnionDB.java | 8 +- .../database/external/ExternalManagerDB.java | 4 +- .../function/CallingConventionDBAdapter.java | 7 +- .../CallingConventionDBAdapterNoTable.java | 9 +- .../CallingConventionDBAdapterV0.java | 12 +- .../database/function/FunctionAdapter.java | 16 +-- .../database/function/FunctionAdapterV0.java | 17 ++- .../database/function/FunctionAdapterV1.java | 17 ++- .../database/function/FunctionAdapterV2.java | 16 +-- .../database/function/FunctionAdapterV3.java | 15 +- .../program/database/function/FunctionDB.java | 8 +- .../database/function/FunctionManagerDB.java | 22 +-- .../database/function/FunctionTagAdapter.java | 10 +- .../function/FunctionTagAdapterV0.java | 12 +- .../database/function/FunctionTagDB.java | 10 +- .../function/FunctionTagManagerDB.java | 18 +-- .../function/FunctionTagMappingAdapter.java | 4 +- .../FunctionTagMappingAdapterNoTable.java | 4 +- .../function/FunctionTagMappingAdapterV0.java | 14 +- .../function/ThunkFunctionAdapter.java | 6 +- .../function/ThunkFunctionAdapterV0.java | 9 +- .../map/AddressKeyRecordIterator.java | 6 +- .../database/map/AddressMapDBAdapterV0.java | 4 +- .../database/map/AddressMapDBAdapterV1.java | 12 +- .../database/map/AddressRecordDeleter.java | 2 +- .../database/mem/BitMappedSubMemoryBlock.java | 4 +- .../database/mem/BufferSubMemoryBlock.java | 6 +- .../mem/ByteMappedSubMemoryBlock.java | 6 +- .../program/database/mem/FileBytes.java | 4 +- .../database/mem/FileBytesAdapterV0.java | 6 +- .../database/mem/FileBytesSubMemoryBlock.java | 6 +- .../program/database/mem/MemoryBlockDB.java | 12 +- .../database/mem/MemoryMapDBAdapter.java | 6 +- .../database/mem/MemoryMapDBAdapterV0.java | 14 +- .../database/mem/MemoryMapDBAdapterV2.java | 14 +- .../database/mem/MemoryMapDBAdapterV3.java | 40 +++--- .../program/database/mem/SubMemoryBlock.java | 6 +- .../mem/UninitializedSubMemoryBlock.java | 6 +- .../program/database/module/FragmentDB.java | 10 +- .../database/module/GroupDBAdapter.java | 28 ++-- .../database/module/GroupDBAdapterV0.java | 40 +++--- .../program/database/module/ModuleDB.java | 100 ++++++------- .../database/module/ModuleManager.java | 34 ++--- .../database/module/TreeDBAdapter.java | 11 +- .../database/module/TreeDBAdapterV0.java | 10 +- .../program/database/module/TreeManager.java | 20 +-- .../oldfunction/OldFunctionDBAdapter.java | 3 +- .../oldfunction/OldFunctionDBAdapterV0.java | 21 ++- .../oldfunction/OldFunctionDBAdapterV1.java | 6 +- .../oldfunction/OldFunctionDataDB.java | 10 +- .../oldfunction/OldFunctionManager.java | 4 +- .../OldRegisterVariableDBAdapter.java | 2 +- .../OldRegisterVariableDBAdapterV0.java | 2 +- .../database/oldfunction/OldStackFrameDB.java | 6 +- .../OldStackVariableDBAdapter.java | 2 +- .../OldStackVariableDBAdapterV0.java | 6 +- .../OldStackVariableDBAdapterV1.java | 2 +- .../properties/DBPropertyMapManager.java | 2 +- .../database/properties/GenericSaveable.java | 4 +- .../database/properties/IntPropertyMapDB.java | 6 +- .../properties/LongPropertyMapDB.java | 6 +- .../properties/ObjectPropertyMapDB.java | 12 +- .../properties/PropertiesDBAdapterV0.java | 3 +- .../database/properties/PropertyMapDB.java | 4 +- .../properties/StringPropertyMapDB.java | 6 +- .../properties/VoidPropertyMapDB.java | 5 +- .../database/references/BigRefListV0.java | 20 +-- .../references/FromAdapterSharedTable.java | 8 +- .../database/references/FromAdapterV0.java | 10 +- .../database/references/RecordAdapter.java | 9 +- .../database/references/RefListV0.java | 6 +- .../references/ReferenceDBManager.java | 4 +- .../references/ToAdapterSharedTable.java | 8 +- .../database/references/ToAdapterV0.java | 22 +-- .../database/references/ToAdapterV1.java | 10 +- .../database/reloc/RelocationDBAdapter.java | 16 +-- .../reloc/RelocationDBAdapterNoTable.java | 7 +- .../database/reloc/RelocationDBAdapterV1.java | 7 +- .../database/reloc/RelocationDBAdapterV2.java | 7 +- .../database/reloc/RelocationDBAdapterV3.java | 7 +- .../database/reloc/RelocationDBAdapterV4.java | 7 +- .../database/reloc/RelocationManager.java | 8 +- .../AddressSetFilteredSymbolIterator.java | 6 +- .../program/database/symbol/ClassSymbol.java | 4 +- .../program/database/symbol/CodeSymbol.java | 6 +- .../program/database/symbol/EquateDB.java | 8 +- .../database/symbol/EquateDBAdapter.java | 6 +- .../database/symbol/EquateDBAdapterV0.java | 10 +- .../database/symbol/EquateManager.java | 16 +-- .../program/database/symbol/EquateRefDB.java | 10 +- .../database/symbol/EquateRefDBAdapter.java | 10 +- .../database/symbol/EquateRefDBAdapterV0.java | 14 +- .../database/symbol/EquateRefDBAdapterV1.java | 10 +- .../database/symbol/FunctionSymbol.java | 4 +- .../database/symbol/GlobalRegisterSymbol.java | 4 +- .../symbol/GlobalVariableSymbolDB.java | 4 +- .../symbol/LabelHistoryAdapterV0.java | 10 +- .../database/symbol/LibrarySymbol.java | 4 +- .../database/symbol/NamespaceSymbol.java | 4 +- .../OldVariableStorageDBAdapterV0V1.java | 6 +- .../symbol/OldVariableStorageManagerDB.java | 10 +- .../program/database/symbol/SymbolDB.java | 12 +- .../symbol/SymbolDatabaseAdapter.java | 6 +- .../symbol/SymbolDatabaseAdapterV0.java | 20 +-- .../symbol/SymbolDatabaseAdapterV1.java | 12 +- .../symbol/SymbolDatabaseAdapterV2.java | 24 ++-- .../database/symbol/SymbolManager.java | 40 +++--- .../symbol/VariableStorageDBAdapter.java | 4 +- .../VariableStorageDBAdapterNoTable.java | 6 +- .../symbol/VariableStorageDBAdapterV2.java | 4 +- .../symbol/VariableStorageManagerDB.java | 14 +- .../database/symbol/VariableSymbolDB.java | 6 +- .../database/util/AddressRangeMapDB.java | 30 ++-- .../program/database/util/AndQuery.java | 7 +- .../database/util/DatabaseTableUtils.java | 6 +- .../database/util/EmptyRecordIterator.java | 7 +- .../database/util/FieldMatchQuery.java | 7 +- .../database/util/FieldRangeQuery.java | 7 +- .../program/database/util/NotQuery.java | 7 +- .../ghidra/program/database/util/OrQuery.java | 7 +- .../ghidra/program/database/util/Query.java | 5 +- .../database/util/QueryRecordIterator.java | 17 ++- .../program/database/util/RecordFilter.java | 5 +- .../database/util/SharedRangeMapDB.java | 30 ++-- .../database/util/StringMatchQuery.java | 4 +- .../server/RepositoryFileSystemTest.java | 4 +- 305 files changed, 1902 insertions(+), 1959 deletions(-) rename Ghidra/Framework/DB/src/main/java/db/{Record.java => DBRecord.java} (97%) diff --git a/Ghidra/Features/Base/developer_scripts/FixLangId.java b/Ghidra/Features/Base/developer_scripts/FixLangId.java index e3784efd38..1cb8302007 100644 --- a/Ghidra/Features/Base/developer_scripts/FixLangId.java +++ b/Ghidra/Features/Base/developer_scripts/FixLangId.java @@ -93,7 +93,7 @@ public class FixLangId extends GhidraScript { Msg.showError(getClass(), null, "Script Error", "Bad program database!!"); return false; } - Record record = table.getRecord(new StringField(LANGUAGE_ID)); + DBRecord record = table.getRecord(new StringField(LANGUAGE_ID)); if (record == null) { // must be in old style combined language/compiler spec format Msg.showError(getClass(), null, "Script Error", "Old program file! Language fix is not appropriate."); diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/AbstractColumnAdapter.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/AbstractColumnAdapter.java index d60e79fd5e..5f5c742b35 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/AbstractColumnAdapter.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/AbstractColumnAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,15 +15,15 @@ */ package ghidra.app.plugin.debug.dbtable; -import db.Record; +import db.DBRecord; abstract class AbstractColumnAdapter { abstract Class getValueClass(); - abstract Object getKeyValue(Record rec); + abstract Object getKeyValue(DBRecord rec); - abstract Object getValue(Record rec, int col); + abstract Object getValue(DBRecord rec, int col); protected String getByteString(byte b) { String str = Integer.toHexString(b); diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/BinaryColumnAdapter.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/BinaryColumnAdapter.java index 5c54a9569f..4024e2a1cc 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/BinaryColumnAdapter.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/BinaryColumnAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +16,7 @@ package ghidra.app.plugin.debug.dbtable; import db.BinaryField; -import db.Record; +import db.DBRecord; public class BinaryColumnAdapter extends AbstractColumnAdapter { @@ -27,7 +26,7 @@ public class BinaryColumnAdapter extends AbstractColumnAdapter { } @Override - Object getKeyValue(Record rec) { + Object getKeyValue(DBRecord rec) { byte[] bytes = ((BinaryField) rec.getKeyField()).getBinaryData(); StringBuffer buf = new StringBuffer(" byte[" + bytes.length + "] = "); if (bytes.length > 0) { @@ -45,7 +44,7 @@ public class BinaryColumnAdapter extends AbstractColumnAdapter { } @Override - Object getValue(Record rec, int col) { + Object getValue(DBRecord rec, int col) { byte[] bytes = rec.getBinaryData(col); if (bytes == null) { return "null"; diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/BooleanColumnAdapter.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/BooleanColumnAdapter.java index 53a2a6bdf4..4064c8e759 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/BooleanColumnAdapter.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/BooleanColumnAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +16,7 @@ package ghidra.app.plugin.debug.dbtable; import db.BooleanField; -import db.Record; +import db.DBRecord; public class BooleanColumnAdapter extends AbstractColumnAdapter { @@ -27,12 +26,12 @@ public class BooleanColumnAdapter extends AbstractColumnAdapter { } @Override - Object getKeyValue(Record rec) { + Object getKeyValue(DBRecord rec) { return new Boolean(((BooleanField) rec.getKeyField()).getBooleanValue()); } @Override - Object getValue(Record rec, int col) { + Object getValue(DBRecord rec, int col) { return Boolean.valueOf(rec.getBooleanValue(col)); } diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/ByteColumnAdapter.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/ByteColumnAdapter.java index 99e0d1db7e..0f1eeb98f6 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/ByteColumnAdapter.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/ByteColumnAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +16,7 @@ package ghidra.app.plugin.debug.dbtable; import db.ByteField; -import db.Record; +import db.DBRecord; public class ByteColumnAdapter extends AbstractColumnAdapter { @@ -27,12 +26,12 @@ public class ByteColumnAdapter extends AbstractColumnAdapter { } @Override - Object getKeyValue(Record rec) { + Object getKeyValue(DBRecord rec) { return new Byte(((ByteField) rec.getKeyField()).getByteValue()); } @Override - Object getValue(Record rec, int col) { + Object getValue(DBRecord rec, int col) { return new Byte(rec.getByteValue(col)); } diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/DbLargeTableModel.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/DbLargeTableModel.java index d825743c61..c6d6b2b4d3 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/DbLargeTableModel.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/DbLargeTableModel.java @@ -31,7 +31,7 @@ public class DbLargeTableModel implements TableModel { private Schema schema; private List columns = new ArrayList(); private RecordIterator recIt; - private Record lastRecord; + private DBRecord lastRecord; private int lastIndex; private Field minKey; private Field maxKey; @@ -94,7 +94,7 @@ public class DbLargeTableModel implements TableModel { private void findMinKey() throws IOException { RecordIterator iter = table.iterator(); - Record rec = iter.next(); + DBRecord rec = iter.next(); minKey = rec.getKeyField(); } @@ -109,7 +109,7 @@ public class DbLargeTableModel implements TableModel { max.setBinaryData(maxBytes); } RecordIterator iter = table.iterator(max); - Record rec = iter.previous(); + DBRecord rec = iter.previous(); maxKey = rec.getKeyField(); } @@ -152,7 +152,7 @@ public class DbLargeTableModel implements TableModel { @Override public Object getValueAt(int rowIndex, int columnIndex) { - Record rec = getRecord(rowIndex); + DBRecord rec = getRecord(rowIndex); if (columnIndex == 0) { // key column return columns.get(columnIndex).getKeyValue(rec); } @@ -177,7 +177,7 @@ public class DbLargeTableModel implements TableModel { // no! } - private Record getRecord(int index) { + private DBRecord getRecord(int index) { try { if (index == lastIndex + 1) { if (recIt.hasNext()) { @@ -196,7 +196,7 @@ public class DbLargeTableModel implements TableModel { recIt.previous(); } } - Record rec = recIt.next(); + DBRecord rec = recIt.next(); if (rec != null) { lastRecord = rec; lastIndex = index; diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/DbSmallTableModel.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/DbSmallTableModel.java index 476f931725..a6fa4daa37 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/DbSmallTableModel.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/DbSmallTableModel.java @@ -24,11 +24,11 @@ import docking.widgets.table.AbstractSortedTableModel; import ghidra.util.Msg; import ghidra.util.exception.AssertException; -public class DbSmallTableModel extends AbstractSortedTableModel { +public class DbSmallTableModel extends AbstractSortedTableModel { private Table table; private Schema schema; private List columns = new ArrayList<>(); - private List records; + private List records; public DbSmallTableModel(Table table) { this.table = table; @@ -124,7 +124,7 @@ public class DbSmallTableModel extends AbstractSortedTableModel { } @Override - public Object getColumnValueForRow(Record rec, int columnIndex) { + public Object getColumnValueForRow(DBRecord rec, int columnIndex) { if (columnIndex == 0) { // key column return columns.get(columnIndex).getKeyValue(rec); } @@ -134,7 +134,7 @@ public class DbSmallTableModel extends AbstractSortedTableModel { } @Override - public List getModelData() { + public List getModelData() { return records; } diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/IntegerColumnAdapter.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/IntegerColumnAdapter.java index 2c213a5208..d483ebecf7 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/IntegerColumnAdapter.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/IntegerColumnAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +16,7 @@ package ghidra.app.plugin.debug.dbtable; import db.IntField; -import db.Record; +import db.DBRecord; public class IntegerColumnAdapter extends AbstractColumnAdapter { @@ -27,12 +26,12 @@ public class IntegerColumnAdapter extends AbstractColumnAdapter { } @Override - Object getKeyValue(Record rec) { + Object getKeyValue(DBRecord rec) { return new Integer(((IntField) rec.getKeyField()).getIntValue()); } @Override - Object getValue(Record rec, int col) { + Object getValue(DBRecord rec, int col) { return new Integer(rec.getIntValue(col)); } diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/LongColumnAdapter.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/LongColumnAdapter.java index 50ef223d1f..de06608bfd 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/LongColumnAdapter.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/LongColumnAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +15,7 @@ */ package ghidra.app.plugin.debug.dbtable; -import db.Record; +import db.DBRecord; public class LongColumnAdapter extends AbstractColumnAdapter { @@ -26,12 +25,12 @@ public class LongColumnAdapter extends AbstractColumnAdapter { } @Override - Object getKeyValue(Record rec) { + Object getKeyValue(DBRecord rec) { return new Long(rec.getKey()); } @Override - Object getValue(Record rec, int col) { + Object getValue(DBRecord rec, int col) { return new Long(rec.getLongValue(col)); } } diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/ShortColumnAdapter.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/ShortColumnAdapter.java index 9e04c5e47c..6b4cf36df7 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/ShortColumnAdapter.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/ShortColumnAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +15,7 @@ */ package ghidra.app.plugin.debug.dbtable; -import db.Record; +import db.DBRecord; import db.ShortField; public class ShortColumnAdapter extends AbstractColumnAdapter { @@ -27,12 +26,12 @@ public class ShortColumnAdapter extends AbstractColumnAdapter { } @Override - Object getKeyValue(Record rec) { + Object getKeyValue(DBRecord rec) { return new Short(((ShortField) rec.getKeyField()).getShortValue()); } @Override - Object getValue(Record rec, int col) { + Object getValue(DBRecord rec, int col) { return new Short(rec.getShortValue(col)); } diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/StringColumnAdapter.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/StringColumnAdapter.java index 0dc00eed50..aca246db91 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/StringColumnAdapter.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/debug/dbtable/StringColumnAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +15,7 @@ */ package ghidra.app.plugin.debug.dbtable; -import db.Record; +import db.DBRecord; import db.StringField; public class StringColumnAdapter extends AbstractColumnAdapter { @@ -27,12 +26,12 @@ public class StringColumnAdapter extends AbstractColumnAdapter { } @Override - Object getKeyValue(Record rec) { + Object getKeyValue(DBRecord rec) { return ((StringField) rec.getKeyField()).getString(); } @Override - Object getValue(Record rec, int col) { + Object getValue(DBRecord rec, int col) { return " " + rec.getString(col); } } diff --git a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/map/AddressIndexPrimaryKeyIteratorTest.java b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/map/AddressIndexPrimaryKeyIteratorTest.java index 0dd3246209..643c2c2a17 100644 --- a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/map/AddressIndexPrimaryKeyIteratorTest.java +++ b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/map/AddressIndexPrimaryKeyIteratorTest.java @@ -84,7 +84,7 @@ public class AddressIndexPrimaryKeyIteratorTest extends AbstractGhidraHeadedInte Address maxAddr = r.getMaxAddress(); while (a.compareTo(maxAddr) <= 0) { long addrKey = addrMap.getKey(a, true); - Record rec = schema.createRecord(myTable.getKey()); + DBRecord rec = schema.createRecord(myTable.getKey()); rec.setLongValue(0, addrKey); myTable.putRecord(rec); a = a.add(1); diff --git a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/map/AddressKeyIteratorTest.java b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/map/AddressKeyIteratorTest.java index a3f89473a6..e6af93cbb0 100644 --- a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/map/AddressKeyIteratorTest.java +++ b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/map/AddressKeyIteratorTest.java @@ -97,7 +97,7 @@ public class AddressKeyIteratorTest extends AbstractGhidraHeadedIntegrationTest private long addRecord(Address a) throws Exception { long key = addrMap.getKey(a, true); - Record rec = SCHEMA.createRecord(key); + DBRecord rec = SCHEMA.createRecord(key); rec.setString(0, a.toString()); myTable.putRecord(rec); return key; diff --git a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/util/SharedRangeMapDBTest.java b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/util/SharedRangeMapDBTest.java index 50876c1d95..b60a9a7aa6 100644 --- a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/util/SharedRangeMapDBTest.java +++ b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/util/SharedRangeMapDBTest.java @@ -95,7 +95,7 @@ public class SharedRangeMapDBTest extends AbstractGhidraHeadedIntegrationTest int cnt = 0; while (iter.hasNext()) { ++cnt; - Record rec = iter.next(); + DBRecord rec = iter.next(); IndexRange range = new IndexRange(rec.getKey(), rec.getLongValue(SharedRangeMapDB.RANGE_TO_COL)); if (indexOf(ranges, range) < 0) { @@ -108,7 +108,7 @@ public class SharedRangeMapDBTest extends AbstractGhidraHeadedIntegrationTest cnt = 0; while (iter.hasNext()) { ++cnt; - Record rec = iter.next(); + DBRecord rec = iter.next(); IndexRange entry = new IndexRange(rec.getLongValue(SharedRangeMapDB.MAP_RANGE_KEY_COL), rec.getLongValue(SharedRangeMapDB.MAP_VALUE_COL)); if (indexOf(mapRangeToValue, entry) < 0) { diff --git a/Ghidra/Features/Base/src/test/java/ghidra/DatabaseBenchMarks.java b/Ghidra/Features/Base/src/test/java/ghidra/DatabaseBenchMarks.java index 2b4452e7fa..c6c5a5c923 100644 --- a/Ghidra/Features/Base/src/test/java/ghidra/DatabaseBenchMarks.java +++ b/Ghidra/Features/Base/src/test/java/ghidra/DatabaseBenchMarks.java @@ -59,7 +59,7 @@ public class DatabaseBenchMarks { Schema schema = new Schema(1, "Key", new Field[] { IntField.INSTANCE }, new String[] { "Value" }); Table table = dbh.createTable("Test", schema); - Record record = schema.createRecord(0); + DBRecord record = schema.createRecord(0); timer.start( "Inserting " + numInsertions + " sorted records with long keys and integer values"); for (int i = 0; i < numInsertions; i++) { @@ -83,7 +83,7 @@ public class DatabaseBenchMarks { Schema schema = new Schema(1, "Key", new Field[] { StringField.INSTANCE }, new String[] { "Value" }); Table table = dbh.createTable("Test", schema); - Record record = schema.createRecord(0); + DBRecord record = schema.createRecord(0); timer.start("Inserting " + numInsertions + " sorted records with long keys and String (length = 8) values"); for (int i = 0; i < numInsertions; i++) { @@ -108,7 +108,7 @@ public class DatabaseBenchMarks { Schema schema = new Schema(1, "Key", new Field[] { IntField.INSTANCE }, new String[] { "Value" }); Table table = dbh.createTable("Test", schema); - Record record = schema.createRecord(0); + DBRecord record = schema.createRecord(0); timer.start( "Inserting " + numInsertions + " random records with long keys and integer values"); for (int i = 0; i < numInsertions; i++) { @@ -132,7 +132,7 @@ public class DatabaseBenchMarks { Schema schema = new Schema(1, "Key", new Field[] { IntField.INSTANCE }, new String[] { "Value" }); Table table = dbh.createTable("Test", schema); - Record record = schema.createRecord(0); + DBRecord record = schema.createRecord(0); System.out.print("building database..."); for (int i = 0; i < 1000000; i++) { record.setKey(i); @@ -161,7 +161,7 @@ public class DatabaseBenchMarks { Schema schema = new Schema(1, "Key", new Field[] { IntField.INSTANCE }, new String[] { "Value" }); Table table = dbh.createTable("Test", schema); - Record record = schema.createRecord(0); + DBRecord record = schema.createRecord(0); System.out.print("building database..."); for (int i = 0; i < 1000000; i++) { record.setKey(i); diff --git a/Ghidra/Features/FunctionID/ghidra_scripts/RepackFid.java b/Ghidra/Features/FunctionID/ghidra_scripts/RepackFid.java index b4385127f4..35efc67826 100644 --- a/Ghidra/Features/FunctionID/ghidra_scripts/RepackFid.java +++ b/Ghidra/Features/FunctionID/ghidra_scripts/RepackFid.java @@ -19,7 +19,7 @@ import java.io.File; import java.io.IOException; import db.DBHandle; -import db.Record; +import db.DBRecord; import db.RecordIterator; import db.Schema; import db.Table; @@ -50,7 +50,7 @@ public class RepackFid extends GhidraScript { monitor.setProgress(0); RecordIterator iterator = oldTable.iterator(); while(iterator.hasNext()) { // Iterate through old records - Record record = iterator.next(); + DBRecord record = iterator.next(); newTable.putRecord(record); // Copy as is into new table monitor.checkCanceled(); monitor.incrementProgress(1); diff --git a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FidDB.java b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FidDB.java index 57b098826e..21780bbeb0 100644 --- a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FidDB.java +++ b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FidDB.java @@ -21,7 +21,7 @@ import java.util.List; import java.util.concurrent.atomic.AtomicInteger; import db.DBHandle; -import db.Record; +import db.DBRecord; import ghidra.feature.fid.hash.FidHashQuad; import ghidra.framework.store.db.PackedDBHandle; import ghidra.framework.store.db.PackedDatabase; @@ -384,7 +384,7 @@ public class FidDB implements Closeable { public boolean getSuperiorFullRelation(FunctionRecord superiorFunction, FidHashQuad inferiorFunction) { try { - Record libraryByID = librariesTable.getLibraryByID(superiorFunction.getLibraryID()); + DBRecord libraryByID = librariesTable.getLibraryByID(superiorFunction.getLibraryID()); if (libraryByID != null) { return relationsTable.getSuperiorFullRelation(superiorFunction, inferiorFunction); } @@ -405,7 +405,7 @@ public class FidDB implements Closeable { public boolean getInferiorFullRelation(FidHashQuad superiorFunction, FunctionRecord inferiorFunction) { try { - Record libraryByID = librariesTable.getLibraryByID(inferiorFunction.getLibraryID()); + DBRecord libraryByID = librariesTable.getLibraryByID(inferiorFunction.getLibraryID()); if (libraryByID != null) { return relationsTable.getInferiorFullRelation(superiorFunction, inferiorFunction); } @@ -439,7 +439,7 @@ public class FidDB implements Closeable { */ public LibraryRecord getLibraryForFunction(FunctionRecord functionRecord) { try { - Record record = librariesTable.getLibraryByID(functionRecord.getLibraryID()); + DBRecord record = librariesTable.getLibraryByID(functionRecord.getLibraryID()); if (record == null) { return null; } @@ -473,7 +473,7 @@ public class FidDB implements Closeable { try { checkUpdateAllowed(); - Record record = librariesTable.createLibrary(libraryFamilyName, libraryVersion, + DBRecord record = librariesTable.createLibrary(libraryFamilyName, libraryVersion, libraryVariant, ghidraVersion, languageID, languageVersion, languageMinorVersion, compilerSpecID); return new LibraryRecord(record); diff --git a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FunctionRecord.java b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FunctionRecord.java index d432dc80cc..9cb1d5289f 100644 --- a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FunctionRecord.java +++ b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FunctionRecord.java @@ -17,7 +17,7 @@ package ghidra.feature.fid.db; import static ghidra.feature.fid.db.FunctionsTable.*; -import db.Record; +import db.DBRecord; import ghidra.feature.fid.hash.FidHashQuad; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; @@ -36,7 +36,7 @@ public class FunctionRecord extends DatabaseObject implements FidHashQuad { /** * All values are stored in the record instead of memoized. */ - final Record record; + final DBRecord record; /** * Need a reference to the FidDb because all strings are stored * via foreign key (considerable duplication of string values). @@ -49,7 +49,7 @@ public class FunctionRecord extends DatabaseObject implements FidHashQuad { * @param cache FunctionRecord object cache * @param record record for this function */ - FunctionRecord(FidDB fid, DBObjectCache cache, Record record) { + FunctionRecord(FidDB fid, DBObjectCache cache, DBRecord record) { super(cache, record.getKey()); this.record = record; this.fidDb = fid; diff --git a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FunctionsTable.java b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FunctionsTable.java index 80573163b3..f87550652e 100644 --- a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FunctionsTable.java +++ b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/FunctionsTable.java @@ -112,7 +112,7 @@ public class FunctionsTable { RecordIterator iterator = table.iterator(); List list = new ArrayList<>(); while (iterator.hasNext()) { - Record record = iterator.next(); + DBRecord record = iterator.next(); if (record.getLongValue(SPECIFIC_HASH_COL) != hash) { continue; } @@ -143,7 +143,7 @@ public class FunctionsTable { Field key = iterator.next(); FunctionRecord functionRecord = functionCache.get(key.getLongValue()); if (functionRecord == null) { - Record record = table.getRecord(key); + DBRecord record = table.getRecord(key); functionRecord = new FunctionRecord(fidDb, functionCache, record); } list.add(functionRecord); @@ -164,7 +164,7 @@ public class FunctionsTable { */ public FunctionRecord createFunctionRecord(long libraryID, FidHashQuad hashQuad, String name, long entryPoint, String domainPath, boolean hasTerminator) throws IOException { - Record record = SCHEMA.createRecord(UniversalIdGenerator.nextID().getValue()); + DBRecord record = SCHEMA.createRecord(UniversalIdGenerator.nextID().getValue()); record.setShortValue(CODE_UNIT_SIZE_COL, hashQuad.getCodeUnitSize()); record.setLongValue(FULL_HASH_COL, hashQuad.getFullHash()); record.setByteValue(SPECIFIC_HASH_ADDITIONAL_SIZE_COL, @@ -191,7 +191,7 @@ public class FunctionsTable { * @throws IOException */ void modifyFlags(long functionID, int flagMask, boolean value) throws IOException { - Record record = table.getRecord(functionID); + DBRecord record = table.getRecord(functionID); if (record == null) { throw new IOException("Function record does not exist"); } @@ -227,7 +227,7 @@ public class FunctionsTable { Field key = iterator.next(); FunctionRecord functionRecord = functionCache.get(key.getLongValue()); if (functionRecord == null) { - Record record = table.getRecord(key); + DBRecord record = table.getRecord(key); long nameID = record.getLongValue(NAME_ID_COL); StringRecord nameRecord = stringsTable.lookupString(nameID); String name = nameRecord.getValue(); @@ -266,7 +266,7 @@ public class FunctionsTable { Field key = iterator.next(); FunctionRecord functionRecord = functionCache.get(key.getLongValue()); if (functionRecord == null) { - Record record = table.getRecord(key); + DBRecord record = table.getRecord(key); long nameID = record.getLongValue(NAME_ID_COL); StringRecord nameRecord = stringsTable.lookupString(nameID); String name = nameRecord.getValue(); @@ -297,7 +297,7 @@ public class FunctionsTable { public FunctionRecord getFunctionByID(long functionID) throws IOException { FunctionRecord functionRecord = functionCache.get(functionID); if (functionRecord == null) { - Record record = table.getRecord(functionID); + DBRecord record = table.getRecord(functionID); if (record != null) { functionRecord = new FunctionRecord(fidDb, functionCache, record); } @@ -318,7 +318,7 @@ public class FunctionsTable { RecordIterator iterator = table.iterator(); List list = new ArrayList<>(); while (iterator.hasNext()) { - Record record = iterator.next(); + DBRecord record = iterator.next(); long domainPathID = record.getLongValue(DOMAIN_PATH_ID_COL); StringRecord domainPathRecord = stringsTable.lookupString(domainPathID); String domainPath = domainPathRecord.getValue(); @@ -358,7 +358,7 @@ public class FunctionsTable { Field key = iterator.next(); FunctionRecord functionRecord = functionCache.get(key.getLongValue()); if (functionRecord == null) { - Record record = table.getRecord(key); + DBRecord record = table.getRecord(key); if (record.getLongValue(LIBRARY_ID_COL) == libraryKey) { functionRecord = new FunctionRecord(fidDb, functionCache, record); list.add(functionRecord); diff --git a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/LibrariesTable.java b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/LibrariesTable.java index f75cad35a1..45fdfb57f3 100644 --- a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/LibrariesTable.java +++ b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/LibrariesTable.java @@ -110,10 +110,10 @@ public class LibrariesTable { * @return the new library record * @throws IOException if the database create fails */ - public Record createLibrary(String libraryFamilyName, String libraryVersion, + public DBRecord createLibrary(String libraryFamilyName, String libraryVersion, String libraryVariant, String ghidraVersion, LanguageID languageID, int languageVersion, int languageMinorVersion, CompilerSpecID compilerSpecID) throws IOException { - Record record = SCHEMA.createRecord(UniversalIdGenerator.nextID().getValue()); + DBRecord record = SCHEMA.createRecord(UniversalIdGenerator.nextID().getValue()); record.setString(LIBRARY_FAMILY_NAME_COL, libraryFamilyName); record.setString(LIBRARY_VERSION_COL, libraryVersion); record.setString(LIBRARY_VARIANT_COL, libraryVariant); @@ -164,7 +164,7 @@ public class LibrariesTable { List list = new ArrayList(); while (iterator.hasNext()) { Field key = iterator.next(); - Record record = table.getRecord(key); + DBRecord record = table.getRecord(key); LibraryRecord libraryRecord = new LibraryRecord(record); if (version != null) { if (!libraryRecord.getLibraryVersion().equals(version)) { @@ -187,8 +187,8 @@ public class LibrariesTable { * @return the library or null if not found * @throws IOException if database seek encounters an error */ - public Record getLibraryByID(long id) throws IOException { - Record record = table.getRecord(id); + public DBRecord getLibraryByID(long id) throws IOException { + DBRecord record = table.getRecord(id); return record; } } diff --git a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/LibraryRecord.java b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/LibraryRecord.java index e6fa8ec25e..c6706350df 100644 --- a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/LibraryRecord.java +++ b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/LibraryRecord.java @@ -18,7 +18,7 @@ package ghidra.feature.fid.db; import static ghidra.feature.fid.db.LibrariesTable.*; import ghidra.program.model.lang.CompilerSpecID; import ghidra.program.model.lang.LanguageID; -import db.Record; +import db.DBRecord; /** * Represents a library record in the FID database. @@ -27,13 +27,13 @@ public class LibraryRecord { /** * The record is stored, no memoization is performed. */ - final Record record; + final DBRecord record; /** * Creates a new library record. * @param record the database record on which to base this library */ - public LibraryRecord(Record record) { + public LibraryRecord(DBRecord record) { if (record == null) { throw new IllegalArgumentException("null record"); } diff --git a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/RelationsTable.java b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/RelationsTable.java index 1a3684e393..6eae377a6a 100644 --- a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/RelationsTable.java +++ b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/RelationsTable.java @@ -63,12 +63,12 @@ public class RelationsTable { RelationType relationType) throws IOException { long superiorKey = FidDBUtils.generateSuperiorFullHashSmash(superiorFunction, inferiorFunction); - Record superiorRecord = SCHEMA.createRecord(superiorKey); + DBRecord superiorRecord = SCHEMA.createRecord(superiorKey); superiorTable.putRecord(superiorRecord); if (relationType != RelationType.INTER_LIBRARY_CALL) { long inferiorKey = FidDBUtils.generateInferiorFullHashSmash(superiorFunction, inferiorFunction); - Record inferiorRecord = SCHEMA.createRecord(inferiorKey); + DBRecord inferiorRecord = SCHEMA.createRecord(inferiorKey); inferiorTable.putRecord(inferiorRecord); } } @@ -84,7 +84,7 @@ public class RelationsTable { FunctionRecord inferiorFunction) throws IOException { long inferiorKey = FidDBUtils.generateInferiorFullHashSmash(superiorFunction, inferiorFunction); - Record inferiorRecord = SCHEMA.createRecord(inferiorKey); + DBRecord inferiorRecord = SCHEMA.createRecord(inferiorKey); inferiorTable.putRecord(inferiorRecord); } @@ -100,7 +100,7 @@ public class RelationsTable { FidHashQuad inferiorFunction) throws IOException { long superiorKey = FidDBUtils.generateSuperiorFullHashSmash(superiorFunction, inferiorFunction); - Record record = superiorTable.getRecord(superiorKey); + DBRecord record = superiorTable.getRecord(superiorKey); return (record != null); } @@ -116,7 +116,7 @@ public class RelationsTable { FunctionRecord inferiorFunction) throws IOException { long inferiorKey = FidDBUtils.generateInferiorFullHashSmash(superiorFunction, inferiorFunction); - Record record = inferiorTable.getRecord(inferiorKey); + DBRecord record = inferiorTable.getRecord(inferiorKey); return (record != null); } } diff --git a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/StringsTable.java b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/StringsTable.java index a26f9615a8..31ae4e42d3 100644 --- a/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/StringsTable.java +++ b/Ghidra/Features/FunctionID/src/main/java/ghidra/feature/fid/db/StringsTable.java @@ -71,7 +71,7 @@ public class StringsTable { if (records == null || records.length == 0) { // create long key = UniversalIdGenerator.nextID().getValue(); - Record record = SCHEMA.createRecord(key); + DBRecord record = SCHEMA.createRecord(key); record.setString(STRING_VALUE_COL, value); table.putRecord(record); return key; @@ -101,7 +101,7 @@ public class StringsTable { StringRecord lookupString(long stringID) { StringRecord stringRecord = stringCache.get(stringID); if (stringRecord == null) { - Record record; + DBRecord record; try { record = table.getRecord(stringID); if (record != null) { diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/AddressCorrelatorDB.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/AddressCorrelatorDB.java index ae10a95ea6..8f373c2fc2 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/AddressCorrelatorDB.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/AddressCorrelatorDB.java @@ -24,7 +24,7 @@ import java.util.ArrayList; import java.util.List; import db.DBHandle; -import db.Record; +import db.DBRecord; import generic.stl.Pair; import ghidra.program.database.map.AddressMap; import ghidra.program.model.address.Address; @@ -87,8 +87,8 @@ public class AddressCorrelatorDB { public List> getAddressCorrelations(Address sourceEntryPoint) throws IOException { long sourceEntryLong = getLongFromSourceAddress(sourceEntryPoint); List> addressList = new ArrayList>(); - List addressRecords = adapter.getAddressRecords(sourceEntryLong); - for (Record record : addressRecords) { + List addressRecords = adapter.getAddressRecords(sourceEntryLong); + for (DBRecord record : addressRecords) { long sourceLong = record.getLongValue(SOURCE_ADDRESS_COL.column()); long destinationLong = record.getLongValue(DESTINATION_ADDRESS_COL.column()); Address sourceAddress = getSourceAddressFromLong(sourceLong); diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/AssociationDatabaseManager.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/AssociationDatabaseManager.java index b4d30f525a..98555898e9 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/AssociationDatabaseManager.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/AssociationDatabaseManager.java @@ -84,7 +84,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { RecordIterator records = markupItemTableAdapter.getRecords(associationDB.getKey()); while (records.hasNext()) { monitor.checkCanceled(); - Record record = records.next(); + DBRecord record = records.next(); items.add(getMarkupItemForRecord(record)); monitor.incrementProgress(1); } @@ -100,7 +100,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { return items; } - Record getMarkupItemRecord(long key) { + DBRecord getMarkupItemRecord(long key) { try { return markupItemTableAdapter.getRecord(key); } @@ -155,7 +155,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { } } - private MarkupItemStorageDB getMarkupItemForRecord(Record markupItemRecord) { + private MarkupItemStorageDB getMarkupItemForRecord(DBRecord markupItemRecord) { try { lock.acquire(); MarkupItemStorageDB markupItem = markupItemCache.get(markupItemRecord); @@ -181,7 +181,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { return session.getSourceAddressFromLong(longValue); } - Record getAssociationRecord(long key) { + DBRecord getAssociationRecord(long key) { try { return associationTableAdapter.getRecord(key); } @@ -194,7 +194,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { private MarkupItemStorageDB createMarkupItemDB(MarkupItemStorage markupItem) { try { - Record record = markupItemTableAdapter.createMarkupItemRecord(markupItem); + DBRecord record = markupItemTableAdapter.createMarkupItemRecord(markupItem); MarkupItemStorageDB appliedMarkupItem = getMarkupItemForRecord(record); return appliedMarkupItem; } @@ -222,7 +222,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { VTAssociationDB newAssociation = null; try { lock.acquire(); - Record record = associationTableAdapter.insertRecord(sourceLong, destinationLong, type, + DBRecord record = associationTableAdapter.insertRecord(sourceLong, destinationLong, type, isBlocked ? BLOCKED : AVAILABLE, 0); newAssociation = new VTAssociationDB(this, associationCache, record); } @@ -260,10 +260,10 @@ public class AssociationDatabaseManager implements VTAssociationManager { long sourceID = session.getLongFromSourceAddress(sourceAddress); long destinationID = session.getLongFromDestinationAddress(destinationAddress); try { - Set relatedRecords = + Set relatedRecords = associationTableAdapter.getRelatedAssociationRecordsBySourceAndDestinationAddress( sourceID, destinationID); - for (Record record : relatedRecords) { + for (DBRecord record : relatedRecords) { VTAssociationDB associationDB = getAssociationForRecord(record); VTAssociationStatus status = associationDB.getStatus(); if (status == ACCEPTED) { @@ -290,7 +290,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { try { RecordIterator iterator = associationTableAdapter.getRecords(); for (; iterator.hasNext();) { - Record nextRecord = iterator.next(); + DBRecord nextRecord = iterator.next(); list.add(getAssociationForRecord(nextRecord)); } } @@ -311,7 +311,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { RecordIterator iterator = associationTableAdapter.getRecordsForSourceAddress(addressKey); while (iterator.hasNext()) { - Record record = iterator.next(); + DBRecord record = iterator.next(); VTAssociationDB associationDB = getAssociationForRecord(record); if (associationDB.getDestinationAddress().equals(destinationAddress)) { return associationDB; @@ -334,7 +334,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { RecordIterator iterator = associationTableAdapter.getRecordsForSourceAddress(addressKey); while (iterator.hasNext()) { - Record record = iterator.next(); + DBRecord record = iterator.next(); VTAssociationDB associationDB = getAssociationForRecord(record); Address dbDestinatonAddress = associationDB.getDestinationAddress(); if (destinationAddress.equals(dbDestinatonAddress)) { @@ -349,7 +349,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { return null; } - private VTAssociationDB getAssociationForRecord(Record record) { + private VTAssociationDB getAssociationForRecord(DBRecord record) { if (record == null) { throw new AssertException("How can we have a null record?!!!"); } @@ -373,7 +373,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { if (associationDB != null) { return associationDB; } - Record record = associationTableAdapter.getRecord(associationKey); + DBRecord record = associationTableAdapter.getRecord(associationKey); if (record == null) { return null; } @@ -397,10 +397,10 @@ public class AssociationDatabaseManager implements VTAssociationManager { lock.acquire(); try { long sourceID = session.getLongFromSourceAddress(sourceAddress); - Set relatedRecords = + Set relatedRecords = associationTableAdapter.getRelatedAssociationRecordsBySourceAddress(sourceID); List associations = new ArrayList<>(); - for (Record record : relatedRecords) { + for (DBRecord record : relatedRecords) { associations.add(getAssociationForRecord(record)); } return associations; @@ -420,11 +420,11 @@ public class AssociationDatabaseManager implements VTAssociationManager { lock.acquire(); try { long destinationID = session.getLongFromDestinationAddress(destinationAddress); - Set relatedRecords = + Set relatedRecords = associationTableAdapter.getRelatedAssociationRecordsByDestinationAddress( destinationID); List associations = new ArrayList<>(); - for (Record record : relatedRecords) { + for (DBRecord record : relatedRecords) { associations.add(getAssociationForRecord(record)); } return associations; @@ -445,11 +445,11 @@ public class AssociationDatabaseManager implements VTAssociationManager { try { long sourceID = session.getLongFromSourceAddress(sourceAddress); long destinationID = session.getLongFromDestinationAddress(destinationAddress); - Set relatedRecords = + Set relatedRecords = associationTableAdapter.getRelatedAssociationRecordsBySourceAndDestinationAddress( sourceID, destinationID); List associations = new ArrayList<>(); - for (Record record : relatedRecords) { + for (DBRecord record : relatedRecords) { associations.add(getAssociationForRecord(record)); } return associations; @@ -572,11 +572,11 @@ public class AssociationDatabaseManager implements VTAssociationManager { Set relatedAssociaitons = new HashSet<>(); try { - Set relatedRecords = + Set relatedRecords = associationTableAdapter.getRelatedAssociationRecordsBySourceAndDestinationAddress( sourceID, destinationID); relatedRecords.remove(association.getRecord()); // don't change the given association - for (Record record : relatedRecords) { + for (DBRecord record : relatedRecords) { relatedAssociaitons.add(getAssociationForRecord(record)); } } @@ -586,7 +586,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { return relatedAssociaitons; } - void updateAssociationRecord(Record record) { + void updateAssociationRecord(DBRecord record) { try { associationTableAdapter.updateRecord(record); } @@ -595,7 +595,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { } } - void updateMarkupRecord(Record record) { + void updateMarkupRecord(DBRecord record) { try { markupItemTableAdapter.updateRecord(record); } @@ -617,7 +617,7 @@ public class AssociationDatabaseManager implements VTAssociationManager { associationHooks.remove(hook); } - void removeMarkupRecord(Record record) { + void removeMarkupRecord(DBRecord record) { try { markupItemTableAdapter.removeMatchMarkupItemRecord(record.getKey()); } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/MarkupItemStorageDB.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/MarkupItemStorageDB.java index d17fa91eb2..7306cd44bc 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/MarkupItemStorageDB.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/MarkupItemStorageDB.java @@ -17,7 +17,7 @@ package ghidra.feature.vt.api.db; import static ghidra.feature.vt.api.db.VTMatchMarkupItemTableDBAdapter.MarkupTableDescriptor.*; -import db.Record; +import db.DBRecord; import ghidra.feature.vt.api.impl.MarkupItemStorage; import ghidra.feature.vt.api.impl.MarkupItemStorageImpl; import ghidra.feature.vt.api.main.VTAssociation; @@ -36,9 +36,9 @@ public class MarkupItemStorageDB extends DatabaseObject implements MarkupItemSto private final VTAssociation association; private final VTSessionDB session; - private Record record; + private DBRecord record; - MarkupItemStorageDB(Record record, DBObjectCache cache, + MarkupItemStorageDB(DBRecord record, DBObjectCache cache, AssociationDatabaseManager associationManager) { super(cache, record.getKey()); this.record = record; @@ -166,7 +166,7 @@ public class MarkupItemStorageDB extends DatabaseObject implements MarkupItemSto } @Override - protected boolean refresh(Record matchRecord) { + protected boolean refresh(DBRecord matchRecord) { if (matchRecord == null) { matchRecord = associationManager.getMarkupItemRecord(key); } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAddressCorrelationAdapterV0.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAddressCorrelationAdapterV0.java index 2ab3e6aab6..fe204f5bb2 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAddressCorrelationAdapterV0.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAddressCorrelationAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -49,7 +48,7 @@ public class VTAddressCorrelationAdapterV0 extends VTAddressCorrelatorAdapter { @Override void createAddressRecord(long sourceEntryLong, long sourceLong,long destinationLong) throws IOException { - Record record = TABLE_SCHEMA.createRecord(table.getKey()); + DBRecord record = TABLE_SCHEMA.createRecord(table.getKey()); record.setLongValue(SOURCE_ENTRY_COL.column(), sourceLong); record.setLongValue(SOURCE_ADDRESS_COL.column(), sourceLong); @@ -59,10 +58,10 @@ public class VTAddressCorrelationAdapterV0 extends VTAddressCorrelatorAdapter { } @Override - List getAddressRecords(long sourceEntryLong) throws IOException { + List getAddressRecords(long sourceEntryLong) throws IOException { LongField value = new LongField(sourceEntryLong); RecordIterator indexIterator = table.indexIterator(0, value, value, true); - Listrecords = new ArrayList(); + Listrecords = new ArrayList(); while(indexIterator.hasNext()) { records.add(indexIterator.next()); } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAddressCorrelatorAdapter.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAddressCorrelatorAdapter.java index ea3aab8b34..cac6989b47 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAddressCorrelatorAdapter.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAddressCorrelatorAdapter.java @@ -61,7 +61,7 @@ public abstract class VTAddressCorrelatorAdapter { abstract void createAddressRecord(long sourceEntryLong, long sourceLong, long destinationLong) throws IOException; - abstract List getAddressRecords(long sourceEntryLong) throws IOException; + abstract List getAddressRecords(long sourceEntryLong) throws IOException; void close() { dbHandle.close(); diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationDB.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationDB.java index 532bea84cb..7ff73d30a9 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationDB.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationDB.java @@ -19,7 +19,7 @@ import static ghidra.feature.vt.api.db.VTAssociationTableDBAdapter.AssociationTa import java.util.Collection; -import db.Record; +import db.DBRecord; import ghidra.feature.vt.api.impl.MarkupItemManagerImpl; import ghidra.feature.vt.api.impl.VTChangeManager; import ghidra.feature.vt.api.main.*; @@ -32,12 +32,12 @@ import ghidra.util.task.TaskMonitor; public class VTAssociationDB extends DatabaseObject implements VTAssociation { - public Record record; + public DBRecord record; private MarkupItemManagerImpl markupManager; public final AssociationDatabaseManager associationDBM; public VTAssociationDB(AssociationDatabaseManager associationManager, - DBObjectCache cache, Record record) { + DBObjectCache cache, DBRecord record) { super(cache, record.getKey()); this.associationDBM = associationManager; this.record = record; @@ -80,7 +80,7 @@ public class VTAssociationDB extends DatabaseObject implements VTAssociation { } @Override - protected boolean refresh(Record associationRecord) { + protected boolean refresh(DBRecord associationRecord) { if (associationRecord == null) { associationRecord = associationDBM.getAssociationRecord(key); } @@ -158,7 +158,7 @@ public class VTAssociationDB extends DatabaseObject implements VTAssociation { } } - Record getRecord() { + DBRecord getRecord() { associationDBM.lock.acquire(); try { checkIsValid(); diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationTableDBAdapter.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationTableDBAdapter.java index f4e88270bc..f9594ca669 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationTableDBAdapter.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationTableDBAdapter.java @@ -56,7 +56,7 @@ public abstract class VTAssociationTableDBAdapter { return new VTAssociationTableDBAdapterV0(dbHandle, openMode, monitor); } - abstract Record insertRecord(long sourceAddressID, long destinationAddressID, + abstract DBRecord insertRecord(long sourceAddressID, long destinationAddressID, VTAssociationType type, VTAssociationStatus status, int voteCount) throws IOException; abstract void deleteRecord(long sourceAddressID) throws IOException; @@ -70,18 +70,18 @@ public abstract class VTAssociationTableDBAdapter { abstract RecordIterator getRecords() throws IOException; - abstract Record getRecord(long key) throws IOException; + abstract DBRecord getRecord(long key) throws IOException; - abstract Set getRelatedAssociationRecordsBySourceAndDestinationAddress( + abstract Set getRelatedAssociationRecordsBySourceAndDestinationAddress( long sourceAddressID, long destinationAddressID) throws IOException; - abstract Set getRelatedAssociationRecordsBySourceAddress(long sourceAddressID) + abstract Set getRelatedAssociationRecordsBySourceAddress(long sourceAddressID) throws IOException; - abstract Set getRelatedAssociationRecordsByDestinationAddress(long destinationAddressID) + abstract Set getRelatedAssociationRecordsByDestinationAddress(long destinationAddressID) throws IOException; - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; abstract void removeAssociaiton(long id) throws IOException; } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationTableDBAdapterV0.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationTableDBAdapterV0.java index b1e675fbba..2d325f6e33 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationTableDBAdapterV0.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTAssociationTableDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -49,9 +48,9 @@ public class VTAssociationTableDBAdapterV0 extends VTAssociationTableDBAdapter { } @Override - Record insertRecord(long sourceAddressID, long destinationAddressID, VTAssociationType type, + DBRecord insertRecord(long sourceAddressID, long destinationAddressID, VTAssociationType type, VTAssociationStatus lockedStatus, int voteCount) throws IOException { - Record record = TABLE_SCHEMA.createRecord(table.getKey()); + DBRecord record = TABLE_SCHEMA.createRecord(table.getKey()); record.setLongValue(SOURCE_ADDRESS_COL.column(), sourceAddressID); record.setLongValue(DESTINATION_ADDRESS_COL.column(), destinationAddressID); record.setByteValue(TYPE_COL.column(), (byte) type.ordinal()); @@ -67,7 +66,7 @@ public class VTAssociationTableDBAdapterV0 extends VTAssociationTableDBAdapter { } @Override - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { return table.getRecord(key); } @@ -94,9 +93,9 @@ public class VTAssociationTableDBAdapterV0 extends VTAssociationTableDBAdapter { } @Override - Set getRelatedAssociationRecordsBySourceAndDestinationAddress(long sourceAddressID, + Set getRelatedAssociationRecordsBySourceAndDestinationAddress(long sourceAddressID, long destinationAddressID) throws IOException { - Set recordSet = new HashSet(); + Set recordSet = new HashSet(); RecordIterator iterator = getRecordsForSourceAddress(sourceAddressID); while (iterator.hasNext()) { @@ -112,9 +111,9 @@ public class VTAssociationTableDBAdapterV0 extends VTAssociationTableDBAdapter { } @Override - Set getRelatedAssociationRecordsBySourceAddress(long sourceAddressID) + Set getRelatedAssociationRecordsBySourceAddress(long sourceAddressID) throws IOException { - Set recordSet = new HashSet(); + Set recordSet = new HashSet(); RecordIterator iterator = getRecordsForSourceAddress(sourceAddressID); while (iterator.hasNext()) { @@ -125,9 +124,9 @@ public class VTAssociationTableDBAdapterV0 extends VTAssociationTableDBAdapter { } @Override - Set getRelatedAssociationRecordsByDestinationAddress(long destinationAddressID) + Set getRelatedAssociationRecordsByDestinationAddress(long destinationAddressID) throws IOException { - Set recordSet = new HashSet(); + Set recordSet = new HashSet(); RecordIterator iterator = getRecordsForDestinationAddress(destinationAddressID); while (iterator.hasNext()) { @@ -138,7 +137,7 @@ public class VTAssociationTableDBAdapterV0 extends VTAssociationTableDBAdapter { } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchDB.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchDB.java index dfa5e0f57f..1a96b68a79 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchDB.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchDB.java @@ -19,7 +19,7 @@ import static ghidra.feature.vt.api.db.VTMatchTableDBAdapter.ColumnDescription.* import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.feature.vt.api.impl.VTChangeManager; import ghidra.feature.vt.api.impl.VTProgramCorrelatorInfo; import ghidra.feature.vt.api.main.*; @@ -32,7 +32,7 @@ import ghidra.util.exception.AssertException; public class VTMatchDB extends DatabaseObject implements VTMatch { - private Record record; + private DBRecord record; private final VTMatchSetDB matchSet; private VTSessionDB session; private VTAssociation association; @@ -42,7 +42,7 @@ public class VTMatchDB extends DatabaseObject implements VTMatch { private boolean doCalculateHash = true; private int hash; - public VTMatchDB(DBObjectCache cache, Record record, VTMatchSetDB matchSet) { + public VTMatchDB(DBObjectCache cache, DBRecord record, VTMatchSetDB matchSet) { super(cache, record.getKey()); this.record = record; this.matchSet = matchSet; @@ -56,7 +56,7 @@ public class VTMatchDB extends DatabaseObject implements VTMatch { } @Override - protected boolean refresh(Record matchRecord) { + protected boolean refresh(DBRecord matchRecord) { association = null; if (matchRecord == null) { matchRecord = matchSet.getMatchRecord(key); diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchMarkupItemTableDBAdapter.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchMarkupItemTableDBAdapter.java index 728d711fdc..2f66090ae2 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchMarkupItemTableDBAdapter.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchMarkupItemTableDBAdapter.java @@ -61,13 +61,13 @@ public abstract class VTMatchMarkupItemTableDBAdapter { public abstract void removeMatchMarkupItemRecord(long key) throws IOException; - public abstract Record getRecord(long key) throws IOException; + public abstract DBRecord getRecord(long key) throws IOException; public abstract RecordIterator getRecords(long AssociationKey) throws IOException; - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; public abstract int getRecordCount(); - public abstract Record createMarkupItemRecord(MarkupItemStorage markupItem) throws IOException; + public abstract DBRecord createMarkupItemRecord(MarkupItemStorage markupItem) throws IOException; } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchMarkupItemTableDBAdapterV0.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchMarkupItemTableDBAdapterV0.java index bfe410cd80..1e1c7389ce 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchMarkupItemTableDBAdapterV0.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchMarkupItemTableDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -59,9 +58,9 @@ public class VTMatchMarkupItemTableDBAdapterV0 extends VTMatchMarkupItemTableDBA } @Override - public Record createMarkupItemRecord(MarkupItemStorage markupItem) throws IOException { + public DBRecord createMarkupItemRecord(MarkupItemStorage markupItem) throws IOException { - Record record = TABLE_SCHEMA.createRecord(table.getKey()); + DBRecord record = TABLE_SCHEMA.createRecord(table.getKey()); VTAssociationDB association = (VTAssociationDB) markupItem.getAssociation(); VTSession manager = association.getSession(); @@ -113,12 +112,12 @@ public class VTMatchMarkupItemTableDBAdapterV0 extends VTMatchMarkupItemTableDBA } @Override - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { return table.getRecord(key); } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetDB.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetDB.java index 61b5a6c0d0..022255472c 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetDB.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetDB.java @@ -44,7 +44,7 @@ import ghidra.util.xml.XmlUtilities; public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { - private final Record matchSetRecord; + private final DBRecord matchSetRecord; private DBObjectCache matchCache; private final VTSessionDB session; @@ -56,7 +56,7 @@ public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { private ProgramCorrelatorInfoImpl correlatorInfo; private Options options; - public static VTMatchSetDB createMatchSetDB(Record record, VTSessionDB session, + public static VTMatchSetDB createMatchSetDB(DBRecord record, VTSessionDB session, DBHandle dbHandle, Lock lock) throws IOException { VTMatchSetDB matchSetDB = new VTMatchSetDB(record, session, dbHandle, lock); @@ -64,7 +64,7 @@ public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { return matchSetDB; } - public static VTMatchSetDB getMatchSetDB(Record record, VTSessionDB session, DBHandle dbHandle, + public static VTMatchSetDB getMatchSetDB(DBRecord record, VTSessionDB session, DBHandle dbHandle, OpenMode openMode, TaskMonitor monitor, Lock lock) throws VersionException { VTMatchSetDB matchSetDB = new VTMatchSetDB(record, session, dbHandle, lock); @@ -72,7 +72,7 @@ public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { return matchSetDB; } - private VTMatchSetDB(Record record, VTSessionDB session, DBHandle dbHandle, Lock lock) { + private VTMatchSetDB(DBRecord record, VTSessionDB session, DBHandle dbHandle, Lock lock) { super(null, record.getKey());// cache not supported this.matchSetRecord = record; this.session = session; @@ -166,7 +166,7 @@ public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { try { lock.acquire(); VTMatchTagDB tagDB = session.getOrCreateMatchTagDB(tag); - Record matchRecord = + DBRecord matchRecord = matchTableAdapter.insertMatchRecord(info, this, associationDB, tagDB); newMatch = getMatchForRecord(matchRecord); } @@ -242,7 +242,7 @@ public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { lock.acquire(); RecordIterator iterator = matchTableAdapter.getRecords(); while (iterator.hasNext()) { - Record nextRecord = iterator.next(); + DBRecord nextRecord = iterator.next(); list.add(getMatchForRecord(nextRecord)); } } @@ -265,7 +265,7 @@ public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { try { RecordIterator iterator = matchTableAdapter.getRecords(associationDB.getKey()); while (iterator.hasNext()) { - Record nextRecord = iterator.next(); + DBRecord nextRecord = iterator.next(); VTMatch match = getMatchForRecord(nextRecord); list.add(match); } @@ -297,7 +297,7 @@ public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { return session.getMatchSetRecord(key) == null; } - private VTMatch getMatchForRecord(Record matchRecord) { + private VTMatch getMatchForRecord(DBRecord matchRecord) { try { lock.acquire(); VTMatchDB match = matchCache.get(matchRecord); @@ -311,7 +311,7 @@ public class VTMatchSetDB extends DatabaseObject implements VTMatchSet { } } - Record getMatchRecord(long matchRecordKey) { + DBRecord getMatchRecord(long matchRecordKey) { try { return matchTableAdapter.getMatchRecord(matchRecordKey); } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetTableDBAdapter.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetTableDBAdapter.java index ca2220602a..b8d594fb6f 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetTableDBAdapter.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetTableDBAdapter.java @@ -80,18 +80,18 @@ public abstract class VTMatchSetTableDBAdapter { return new VTMatchSetTableDBAdapterV0(dbHandle, openMode); } - public abstract Record createMatchSetRecord(long key, VTProgramCorrelator correlator) + public abstract DBRecord createMatchSetRecord(long key, VTProgramCorrelator correlator) throws IOException; public abstract RecordIterator getRecords() throws IOException; - public abstract AddressSet getSourceAddressSet(Record record, AddressMap addressMap) + public abstract AddressSet getSourceAddressSet(DBRecord record, AddressMap addressMap) throws IOException; - public abstract AddressSet getDestinationAddressSet(Record record, AddressMap addressMap) + public abstract AddressSet getDestinationAddressSet(DBRecord record, AddressMap addressMap) throws IOException; public abstract long getNextMatchSetID(); - public abstract Record getRecord(long key) throws IOException; + public abstract DBRecord getRecord(long key) throws IOException; } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetTableDBAdapterV0.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetTableDBAdapterV0.java index f4a623277f..05d5c5b077 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetTableDBAdapterV0.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchSetTableDBAdapterV0.java @@ -60,9 +60,9 @@ public class VTMatchSetTableDBAdapterV0 extends VTMatchSetTableDBAdapter { } @Override - public Record createMatchSetRecord(long key, VTProgramCorrelator correlator) + public DBRecord createMatchSetRecord(long key, VTProgramCorrelator correlator) throws IOException { - Record record = TABLE_SCHEMA.createRecord(key); + DBRecord record = TABLE_SCHEMA.createRecord(key); record.setString(CORRELATOR_CLASS_COL.column(), correlator.getClass().getName()); record.setString(CORRELATOR_NAME_COL.column(), correlator.getName()); @@ -91,7 +91,7 @@ public class VTMatchSetTableDBAdapterV0 extends VTMatchSetTableDBAdapter { return null; } - private void createSourceAddressSetTable(VTProgramCorrelator correlator, Record record) + private void createSourceAddressSetTable(VTProgramCorrelator correlator, DBRecord record) throws IOException { Program program = correlator.getSourceProgram(); @@ -101,7 +101,7 @@ public class VTMatchSetTableDBAdapterV0 extends VTMatchSetTableDBAdapter { writeAddressSet(addressSet, tableName, program.getAddressMap()); } - private void createDestinationAddressSetTable(VTProgramCorrelator correlator, Record record) + private void createDestinationAddressSetTable(VTProgramCorrelator correlator, DBRecord record) throws IOException { Program program = correlator.getDestinationProgram(); @@ -111,11 +111,11 @@ public class VTMatchSetTableDBAdapterV0 extends VTMatchSetTableDBAdapter { writeAddressSet(addressSet, tableName, program.getAddressMap()); } - private String getSourceTableName(Record record) { + private String getSourceTableName(DBRecord record) { return "Source Address Set " + record.getKey(); } - private String getDestinationTableName(Record record) { + private String getDestinationTableName(DBRecord record) { return "Destination Address Set " + record.getKey(); } @@ -125,7 +125,7 @@ public class VTMatchSetTableDBAdapterV0 extends VTMatchSetTableDBAdapter { } @Override - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { return table.getRecord(key); } @@ -134,7 +134,7 @@ public class VTMatchSetTableDBAdapterV0 extends VTMatchSetTableDBAdapter { if (set != null) { Table addressSetTable = dbHandle.createTable(tableName, STORED_ADDRESS_RANGE_SCHEMA); - Record rec = STORED_ADDRESS_RANGE_SCHEMA.createRecord(0); + DBRecord rec = STORED_ADDRESS_RANGE_SCHEMA.createRecord(0); int rangeKey = 1; for (KeyRange range : addressMap.getKeyRanges(set, false, false)) { rec.setKey(rangeKey++); @@ -146,17 +146,17 @@ public class VTMatchSetTableDBAdapterV0 extends VTMatchSetTableDBAdapter { } @Override - public AddressSet getDestinationAddressSet(Record record, AddressMap addressMap) + public AddressSet getDestinationAddressSet(DBRecord record, AddressMap addressMap) throws IOException { return readAddressSet(record, getDestinationTableName(record), addressMap); } @Override - public AddressSet getSourceAddressSet(Record record, AddressMap addressMap) throws IOException { + public AddressSet getSourceAddressSet(DBRecord record, AddressMap addressMap) throws IOException { return readAddressSet(record, getSourceTableName(record), addressMap); } - private AddressSet readAddressSet(Record record, String tableName, AddressMap addressMap) + private AddressSet readAddressSet(DBRecord record, String tableName, AddressMap addressMap) throws IOException { Table addressSetTable = dbHandle.getTable(tableName); @@ -168,7 +168,7 @@ public class VTMatchSetTableDBAdapterV0 extends VTMatchSetTableDBAdapter { RecordIterator it = addressSetTable.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); Address addr1 = addressMap.decodeAddress(rec.getLongValue(0)); Address addr2 = addressMap.decodeAddress(rec.getLongValue(1)); addressSet.addRange(addr1, addr2); diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTableDBAdapter.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTableDBAdapter.java index 839058c93d..9005ac0d20 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTableDBAdapter.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTableDBAdapter.java @@ -82,16 +82,16 @@ public abstract class VTMatchTableDBAdapter { return new VTMatchTableDBAdapterV0(dbHandle, tableID, openMode, monitor); } - public abstract Record insertMatchRecord(VTMatchInfo info, VTMatchSetDB matchSet, + public abstract DBRecord insertMatchRecord(VTMatchInfo info, VTMatchSetDB matchSet, VTAssociationDB associationDB, VTMatchTagDB tag) throws IOException; public abstract RecordIterator getRecords() throws IOException; - abstract Record getMatchRecord(long matchRecordKey) throws IOException; + abstract DBRecord getMatchRecord(long matchRecordKey) throws IOException; abstract int getRecordCount(); - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; abstract boolean deleteRecord(long matchRecordKey) throws IOException; diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTableDBAdapterV0.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTableDBAdapterV0.java index 9f1d998172..211bbe1a18 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTableDBAdapterV0.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTableDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -51,10 +50,10 @@ public class VTMatchTableDBAdapterV0 extends VTMatchTableDBAdapter { } @Override - public Record insertMatchRecord(VTMatchInfo info, VTMatchSetDB matchSet, + public DBRecord insertMatchRecord(VTMatchInfo info, VTMatchSetDB matchSet, VTAssociationDB association, VTMatchTagDB tag) throws IOException { - Record record = TABLE_SCHEMA.createRecord(table.getKey()); + DBRecord record = TABLE_SCHEMA.createRecord(table.getKey()); record.setLongValue(TAG_KEY_COL.column(), (tag == null) ? -1 : tag.getKey()); record.setString(SIMILARITY_SCORE_COL.column(), info.getSimilarityScore().toStorageString()); @@ -68,7 +67,7 @@ public class VTMatchTableDBAdapterV0 extends VTMatchTableDBAdapter { } @Override - Record getMatchRecord(long matchRecordKey) throws IOException { + DBRecord getMatchRecord(long matchRecordKey) throws IOException { return table.getRecord(matchRecordKey); } @@ -83,7 +82,7 @@ public class VTMatchTableDBAdapterV0 extends VTMatchTableDBAdapter { } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDB.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDB.java index 5b97612bd9..a0adfa7afa 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDB.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDB.java @@ -19,7 +19,7 @@ import static ghidra.feature.vt.api.db.VTMatchTagDBAdapter.ColumnDescription.TAG import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.feature.vt.api.main.VTMatchTag; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; @@ -30,9 +30,9 @@ import ghidra.program.database.DatabaseObject; public class VTMatchTagDB extends DatabaseObject implements VTMatchTag { private VTSessionDB sessionDB; - private Record record; + private DBRecord record; - VTMatchTagDB(VTSessionDB sessionDB, DBObjectCache cache, Record record) { + VTMatchTagDB(VTSessionDB sessionDB, DBObjectCache cache, DBRecord record) { super(cache, record.getKey()); this.sessionDB = sessionDB; this.record = record; @@ -47,7 +47,7 @@ public class VTMatchTagDB extends DatabaseObject implements VTMatchTag { * Update associated record * @param rec the new record information */ - void setRecord(Record rec) { + void setRecord(DBRecord rec) { if (rec.getKey() != key) { throw new IllegalArgumentException("Key mismatch"); } @@ -56,7 +56,7 @@ public class VTMatchTagDB extends DatabaseObject implements VTMatchTag { @Override protected boolean refresh() { - Record rec = null; + DBRecord rec = null; try { rec = sessionDB.getTagRecord(key); } @@ -74,7 +74,7 @@ public class VTMatchTagDB extends DatabaseObject implements VTMatchTag { * Returns record associated with this match tag or * null if the match tag has been deleted. */ - Record getRecord() { + DBRecord getRecord() { return checkIsValid() ? record : null; } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDBAdapter.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDBAdapter.java index 973bd587ea..28c792e485 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDBAdapter.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDBAdapter.java @@ -77,15 +77,15 @@ public abstract class VTMatchTagDBAdapter { return new VTMatchTagDBAdapterV0(dbHandle, openMode, monitor); } - public abstract Record insertRecord(String tagName) throws IOException; + public abstract DBRecord insertRecord(String tagName) throws IOException; public abstract RecordIterator getRecords() throws IOException; - abstract Record getRecord(long tagRecordKey) throws IOException; + abstract DBRecord getRecord(long tagRecordKey) throws IOException; abstract int getRecordCount(); - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; abstract boolean deleteRecord(long tagRecordKey) throws IOException; } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDBAdapterV0.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDBAdapterV0.java index 0590450eb2..0eb5c798a9 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDBAdapterV0.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTMatchTagDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -48,7 +47,7 @@ public class VTMatchTagDBAdapterV0 extends VTMatchTagDBAdapter { } @Override - public Record insertRecord(String tagName) throws IOException { + public DBRecord insertRecord(String tagName) throws IOException { if (tagName == null) { throw new IllegalArgumentException( @@ -59,7 +58,7 @@ public class VTMatchTagDBAdapterV0 extends VTMatchTagDBAdapter { throw new IllegalArgumentException("Cannot create an empty string tag"); } - Record record = TABLE_SCHEMA.createRecord(table.getKey()); + DBRecord record = TABLE_SCHEMA.createRecord(table.getKey()); record.setString(TAG_NAME_COL.column(), tagName); table.putRecord(record); @@ -67,7 +66,7 @@ public class VTMatchTagDBAdapterV0 extends VTMatchTagDBAdapter { } @Override - Record getRecord(long tagRecordKey) throws IOException { + DBRecord getRecord(long tagRecordKey) throws IOException { return table.getRecord(tagRecordKey); } @@ -82,7 +81,7 @@ public class VTMatchTagDBAdapterV0 extends VTMatchTagDBAdapter { } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTSessionDB.java b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTSessionDB.java index e63f18b26b..c0ba332e46 100644 --- a/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTSessionDB.java +++ b/Ghidra/Features/VersionTracking/src/main/java/ghidra/feature/vt/api/db/VTSessionDB.java @@ -123,7 +123,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC } private void updateVersion() throws IOException { - Record record = SCHEMA.createRecord(new StringField(DB_VERSION_PROPERTY_NAME)); + DBRecord record = SCHEMA.createRecord(new StringField(DB_VERSION_PROPERTY_NAME)); record.setString(0, Integer.toString(DB_VERSION)); propertyTable.putRecord(record); } @@ -220,7 +220,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC if (propertyTable == null) { return 0; } - Record record = propertyTable.getRecord(new StringField(DB_VERSION_PROPERTY_NAME)); + DBRecord record = propertyTable.getRecord(new StringField(DB_VERSION_PROPERTY_NAME)); if (record != null) { String s = record.getString(0); @@ -365,7 +365,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC throws IOException, VersionException { RecordIterator recordIterator = matchSetTableAdapter.getRecords(); while (recordIterator.hasNext()) { - Record record = recordIterator.next(); + DBRecord record = recordIterator.next(); matchSets.add( VTMatchSetDB.getMatchSetDB(record, this, getDBHandle(), openMode, monitor, lock)); } @@ -395,7 +395,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC private VTMatchSet createMatchSet(VTProgramCorrelator correlator, long id) { try { - Record record = matchSetTableAdapter.createMatchSetRecord(id, correlator); + DBRecord record = matchSetTableAdapter.createMatchSetRecord(id, correlator); VTMatchSetDB matchSet = VTMatchSetDB.createMatchSetDB(record, this, getDBHandle(), lock); matchSets.add(matchSet); @@ -411,7 +411,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC return null; } - Record getMatchSetRecord(long key) { + DBRecord getMatchSetRecord(long key) { try { return matchSetTableAdapter.getRecord(key); } @@ -462,11 +462,11 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC return new ArrayList<>(matchSets); } - AddressSet getSourceAddressSet(Record record) throws IOException { + AddressSet getSourceAddressSet(DBRecord record) throws IOException { return matchSetTableAdapter.getSourceAddressSet(record, sourceProgram.getAddressMap()); } - AddressSet getDestinationAddressSet(Record record) throws IOException { + AddressSet getDestinationAddressSet(DBRecord record) throws IOException { return matchSetTableAdapter.getDestinationAddressSet(record, destinationProgram.getAddressMap()); } @@ -596,7 +596,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC if (matchTag != null) { return matchTag; } - Record record = matchTagAdapter.insertRecord(tagName); + DBRecord record = matchTagAdapter.insertRecord(tagName); matchTag = new VTMatchTagDB(this, tagCache, record); } catch (IOException e) { @@ -627,7 +627,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC lock.acquire(); RecordIterator records = matchTagAdapter.getRecords(); while (records.hasNext()) { - Record record = records.next(); + DBRecord record = records.next(); tags.add(getMatchTagNew(record)); } } @@ -640,7 +640,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC return tags; } - private VTMatchTagDB getMatchTagNew(Record record) { + private VTMatchTagDB getMatchTagNew(DBRecord record) { if (record == null) { throw new AssertException("How can we have a null record?!!!"); } @@ -666,7 +666,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC if (matchTagDB != null) { return matchTagDB; } - Record record = matchTagAdapter.getRecord(key); + DBRecord record = matchTagAdapter.getRecord(key); if (record != null) { return new VTMatchTagDB(this, tagCache, record); } @@ -680,7 +680,7 @@ public class VTSessionDB extends DomainObjectAdapterDB implements VTSession, VTC return VTMatchTag.UNTAGGED; } - Record getTagRecord(long key) throws IOException { + DBRecord getTagRecord(long key) throws IOException { return matchTagAdapter.getRecord(key); } diff --git a/Ghidra/Framework/DB/src/main/java/db/ConvertedRecordIterator.java b/Ghidra/Framework/DB/src/main/java/db/ConvertedRecordIterator.java index 3dda7dc9a6..a2ce328435 100644 --- a/Ghidra/Framework/DB/src/main/java/db/ConvertedRecordIterator.java +++ b/Ghidra/Framework/DB/src/main/java/db/ConvertedRecordIterator.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -66,14 +65,14 @@ public abstract class ConvertedRecordIterator implements RecordIterator { /** * @see db.RecordIterator#next() */ - public Record next() throws IOException { + public DBRecord next() throws IOException { return convertRecord(originalIterator.next()); } /** * @see db.RecordIterator#previous() */ - public Record previous() throws IOException { + public DBRecord previous() throws IOException { return convertRecord(originalIterator.previous()); } @@ -82,6 +81,6 @@ public abstract class ConvertedRecordIterator implements RecordIterator { * @param record * @return converted record */ - protected abstract Record convertRecord(Record record); + protected abstract DBRecord convertRecord(DBRecord record); } diff --git a/Ghidra/Framework/DB/src/main/java/db/Record.java b/Ghidra/Framework/DB/src/main/java/db/DBRecord.java similarity index 97% rename from Ghidra/Framework/DB/src/main/java/db/Record.java rename to Ghidra/Framework/DB/src/main/java/db/DBRecord.java index bc97ce55ac..a3945dd6d4 100644 --- a/Ghidra/Framework/DB/src/main/java/db/Record.java +++ b/Ghidra/Framework/DB/src/main/java/db/DBRecord.java @@ -25,7 +25,7 @@ import ghidra.util.exception.AssertException; * associated with a fixed schema. * A record instance contains both a primary key and zero or more data fields. */ -public class Record implements Comparable { +public class DBRecord implements Comparable { final Schema schema; @@ -41,7 +41,7 @@ public class Record implements Comparable { * @param schema record schema * @param key record key */ - Record(Schema schema, Field key) { + DBRecord(Schema schema, Field key) { this.schema = schema; this.key = key; if (!schema.getKeyFieldType().isSameType(key)) { @@ -107,7 +107,7 @@ public class Record implements Comparable { * @param otherRec * @return true if records schemas are the same */ - public boolean hasSameSchema(Record otherRec) { + public boolean hasSameSchema(DBRecord otherRec) { Field[] otherFieldValues = otherRec.fieldValues; if (fieldValues.length != otherFieldValues.length) { return false; @@ -219,8 +219,8 @@ public class Record implements Comparable { * Obtain a copy of this record object. * @return Record */ - public Record copy() { - Record r = schema.createRecord(key.copyField()); + public DBRecord copy() { + DBRecord r = schema.createRecord(key.copyField()); for (int i = 0; i < fieldValues.length; i++) { r.setField(i, fieldValues[i].copyField()); } @@ -448,10 +448,10 @@ public class Record implements Comparable { */ @Override public boolean equals(Object obj) { - if (!(obj instanceof Record)) { + if (!(obj instanceof DBRecord)) { return false; } - Record rec = (Record) obj; + DBRecord rec = (DBRecord) obj; return key.equals(rec.key) && Arrays.equals(fieldValues, rec.fieldValues); } @@ -461,7 +461,7 @@ public class Record implements Comparable { * @see java.lang.Comparable#compareTo(java.lang.Object) */ @Override - public int compareTo(Record otherRec) { + public int compareTo(DBRecord otherRec) { return key.compareTo(otherRec.key); } diff --git a/Ghidra/Framework/DB/src/main/java/db/DatabaseUtils.java b/Ghidra/Framework/DB/src/main/java/db/DatabaseUtils.java index 896d993b99..b3acb163ae 100644 --- a/Ghidra/Framework/DB/src/main/java/db/DatabaseUtils.java +++ b/Ghidra/Framework/DB/src/main/java/db/DatabaseUtils.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -56,7 +55,7 @@ public class DatabaseUtils { long keyDiff = newStart - oldStart; RecordIterator it = table.iterator(oldStart, oldStart+size-1, oldStart); while(it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); rec.setKey(rec.getKey()+keyDiff); tmpTable.putRecord(rec); } @@ -66,7 +65,7 @@ public class DatabaseUtils { it = tmpTable.iterator(newStart, newStart+size-1, newStart); while(it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); table.putRecord(rec); } diff --git a/Ghidra/Framework/DB/src/main/java/db/FieldIndexTable.java b/Ghidra/Framework/DB/src/main/java/db/FieldIndexTable.java index 07111354a5..72b984eb9d 100644 --- a/Ghidra/Framework/DB/src/main/java/db/FieldIndexTable.java +++ b/Ghidra/Framework/DB/src/main/java/db/FieldIndexTable.java @@ -85,7 +85,7 @@ public class FieldIndexTable extends IndexTable { } if (indexField.usesTruncatedFieldValue()) { // Must check actual record if index value was truncated - Record rec = primaryTable.getRecord(f.getPrimaryKey()); + DBRecord rec = primaryTable.getRecord(f.getPrimaryKey()); Field val = rec.getField(indexColumn); if (!indexValue.equals(val)) { continue; @@ -107,18 +107,18 @@ public class FieldIndexTable extends IndexTable { } @Override - void addEntry(Record record) throws IOException { + void addEntry(DBRecord record) throws IOException { Field indexedField = record.getField(indexColumn); if (isSparseIndex && indexedField.isNull()) { return; } IndexField f = indexKeyType.newIndexField(indexedField, record.getKeyField()); - Record rec = indexTable.getSchema().createRecord(f); + DBRecord rec = indexTable.getSchema().createRecord(f); indexTable.putRecord(rec); } @Override - void deleteEntry(Record record) throws IOException { + void deleteEntry(DBRecord record) throws IOException { Field indexedField = record.getField(indexColumn); if (isSparseIndex && indexedField.isNull()) { return; @@ -364,7 +364,7 @@ public class FieldIndexTable extends IndexTable { } if (indexField.usesTruncatedFieldValue()) { // Must check actual record if index value was truncated - Record rec = primaryTable.getRecord(f.getPrimaryKey()); + DBRecord rec = primaryTable.getRecord(f.getPrimaryKey()); Field val = rec.getField(indexColumn); if (!field.equals(val)) { continue; // skip @@ -510,7 +510,7 @@ public class FieldIndexTable extends IndexTable { private boolean indexValueOutOfRange(IndexField f) throws IOException { Field val = null; if (min != null && min.usesTruncatedFieldValue() && min.hasSameIndexValue(f)) { - Record rec = primaryTable.getRecord(f.getPrimaryKey()); + DBRecord rec = primaryTable.getRecord(f.getPrimaryKey()); val = rec.getField(indexColumn); if (val.compareTo(min.getNonTruncatedIndexField()) < 0) { return true; @@ -518,7 +518,7 @@ public class FieldIndexTable extends IndexTable { } if (max != null && max.usesTruncatedFieldValue() && max.hasSameIndexValue(f)) { if (val == null) { - Record rec = primaryTable.getRecord(f.getPrimaryKey()); + DBRecord rec = primaryTable.getRecord(f.getPrimaryKey()); val = rec.getField(indexColumn); } if (val.compareTo(min.getNonTruncatedIndexField()) > 0) { diff --git a/Ghidra/Framework/DB/src/main/java/db/FieldKeyRecordNode.java b/Ghidra/Framework/DB/src/main/java/db/FieldKeyRecordNode.java index d551fda916..33053c02e8 100644 --- a/Ghidra/Framework/DB/src/main/java/db/FieldKeyRecordNode.java +++ b/Ghidra/Framework/DB/src/main/java/db/FieldKeyRecordNode.java @@ -30,7 +30,7 @@ interface FieldKeyRecordNode extends RecordNode, FieldKeyNode { * @return Record * @throws IOException thrown if IO error occurs */ - Record getRecord(Schema schema, int index) throws IOException; + DBRecord getRecord(Schema schema, int index) throws IOException; /** * Insert or Update a record. @@ -39,7 +39,7 @@ interface FieldKeyRecordNode extends RecordNode, FieldKeyNode { * @return root node which may have changed. * @throws IOException thrown if IO error occurs */ - FieldKeyNode putRecord(Record record, Table table) throws IOException; + FieldKeyNode putRecord(DBRecord record, Table table) throws IOException; /** * Remove the record identified by index. @@ -101,7 +101,7 @@ interface FieldKeyRecordNode extends RecordNode, FieldKeyNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecordAtOrAfter(Field key, Schema schema) throws IOException; + DBRecord getRecordAtOrAfter(Field key, Schema schema) throws IOException; /** * Get the record with the maximum key value which is less than or equal @@ -111,7 +111,7 @@ interface FieldKeyRecordNode extends RecordNode, FieldKeyNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecordAtOrBefore(Field key, Schema schema) throws IOException; + DBRecord getRecordAtOrBefore(Field key, Schema schema) throws IOException; /** * Get the record with the minimum key value which is greater than @@ -121,7 +121,7 @@ interface FieldKeyRecordNode extends RecordNode, FieldKeyNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecordAfter(Field key, Schema schema) throws IOException; + DBRecord getRecordAfter(Field key, Schema schema) throws IOException; /** * Get the record with the maximum key value which is less than @@ -131,7 +131,7 @@ interface FieldKeyRecordNode extends RecordNode, FieldKeyNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecordBefore(Field key, Schema schema) throws IOException; + DBRecord getRecordBefore(Field key, Schema schema) throws IOException; /** * Get the record identified by the specified key. @@ -140,6 +140,6 @@ interface FieldKeyRecordNode extends RecordNode, FieldKeyNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecord(Field key, Schema schema) throws IOException; + DBRecord getRecord(Field key, Schema schema) throws IOException; } diff --git a/Ghidra/Framework/DB/src/main/java/db/FixedKeyFixedRecNode.java b/Ghidra/Framework/DB/src/main/java/db/FixedKeyFixedRecNode.java index f6074252c8..36ba03c7ea 100644 --- a/Ghidra/Framework/DB/src/main/java/db/FixedKeyFixedRecNode.java +++ b/Ghidra/Framework/DB/src/main/java/db/FixedKeyFixedRecNode.java @@ -122,7 +122,7 @@ class FixedKeyFixedRecNode extends FixedKeyRecordNode { } @Override - boolean insertRecord(int index, Record record) throws IOException { + boolean insertRecord(int index, DBRecord record) throws IOException { // Check for use of indirect chained record node(s) // int len = record.length(); @@ -143,26 +143,26 @@ class FixedKeyFixedRecNode extends FixedKeyRecordNode { } @Override - FixedKeyNode updateRecord(int index, Record record) throws IOException { + FixedKeyNode updateRecord(int index, DBRecord record) throws IOException { int offset = getRecordOffset(index) + keySize; record.write(buffer, offset); return getRoot(); } @Override - public Record getRecord(Field key, Schema schema) throws IOException { + public DBRecord getRecord(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) return null; - Record record = schema.createRecord(key); + DBRecord record = schema.createRecord(key); record.read(buffer, getRecordOffset(index) + keySize); return record; } @Override - public Record getRecord(Schema schema, int index) throws IOException { + public DBRecord getRecord(Schema schema, int index) throws IOException { Field key = getKeyField(index); - Record record = schema.createRecord(key); + DBRecord record = schema.createRecord(key); record.read(buffer, getRecordOffset(index) + keySize); return record; } diff --git a/Ghidra/Framework/DB/src/main/java/db/FixedKeyRecordNode.java b/Ghidra/Framework/DB/src/main/java/db/FixedKeyRecordNode.java index 5680eab651..3ab97ddf4f 100644 --- a/Ghidra/Framework/DB/src/main/java/db/FixedKeyRecordNode.java +++ b/Ghidra/Framework/DB/src/main/java/db/FixedKeyRecordNode.java @@ -328,7 +328,7 @@ abstract class FixedKeyRecordNode extends FixedKeyNode implements FieldKeyRecord abstract FixedKeyRecordNode createNewLeaf(int prevNodeId, int nextNodeId) throws IOException; @Override - public FixedKeyNode putRecord(Record record, Table table) throws IOException { + public FixedKeyNode putRecord(DBRecord record, Table table) throws IOException { Field key = record.getKeyField(); int index = getKeyIndex(key); @@ -374,7 +374,7 @@ abstract class FixedKeyRecordNode extends FixedKeyNode implements FieldKeyRecord * @return root node which may have changed. * @throws IOException thrown if IO error occurs */ - FixedKeyNode appendNewLeaf(Record record) throws IOException { + FixedKeyNode appendNewLeaf(DBRecord record) throws IOException { FixedKeyRecordNode newLeaf = createNewLeaf(-1, -1); newLeaf.insertRecord(0, record); return appendLeaf(newLeaf); @@ -418,7 +418,7 @@ abstract class FixedKeyRecordNode extends FixedKeyNode implements FieldKeyRecord * @return true if the record was successfully inserted. * @throws IOException thrown if IO error occurs */ - abstract boolean insertRecord(int index, Record record) throws IOException; + abstract boolean insertRecord(int index, DBRecord record) throws IOException; /** * Updates the record at the given index. @@ -427,10 +427,10 @@ abstract class FixedKeyRecordNode extends FixedKeyNode implements FieldKeyRecord * @return root node which may have changed. * @throws IOException thrown if IO error occurs */ - abstract FixedKeyNode updateRecord(int index, Record record) throws IOException; + abstract FixedKeyNode updateRecord(int index, DBRecord record) throws IOException; @Override - public db.Record getRecordBefore(Field key, Schema schema) throws IOException { + public db.DBRecord getRecordBefore(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -index - 2; @@ -446,7 +446,7 @@ abstract class FixedKeyRecordNode extends FixedKeyNode implements FieldKeyRecord } @Override - public db.Record getRecordAfter(Field key, Schema schema) throws IOException { + public db.DBRecord getRecordAfter(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -(index + 1); @@ -462,7 +462,7 @@ abstract class FixedKeyRecordNode extends FixedKeyNode implements FieldKeyRecord } @Override - public Record getRecordAtOrBefore(Field key, Schema schema) throws IOException { + public DBRecord getRecordAtOrBefore(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -index - 2; @@ -475,7 +475,7 @@ abstract class FixedKeyRecordNode extends FixedKeyNode implements FieldKeyRecord } @Override - public Record getRecordAtOrAfter(Field key, Schema schema) throws IOException { + public DBRecord getRecordAtOrAfter(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -(index + 1); diff --git a/Ghidra/Framework/DB/src/main/java/db/FixedKeyVarRecNode.java b/Ghidra/Framework/DB/src/main/java/db/FixedKeyVarRecNode.java index 668d0cbf9f..3aae93e498 100644 --- a/Ghidra/Framework/DB/src/main/java/db/FixedKeyVarRecNode.java +++ b/Ghidra/Framework/DB/src/main/java/db/FixedKeyVarRecNode.java @@ -191,9 +191,9 @@ class FixedKeyVarRecNode extends FixedKeyRecordNode { } @Override - public Record getRecord(Schema schema, int index) throws IOException { + public DBRecord getRecord(Schema schema, int index) throws IOException { Field key = getKeyField(index); - Record record = schema.createRecord(key); + DBRecord record = schema.createRecord(key); if (hasIndirectStorage(index)) { int bufId = buffer.getInt(getRecordDataOffset(index)); ChainedBuffer chainedBuffer = new ChainedBuffer(nodeMgr.getBufferMgr(), bufId); @@ -214,7 +214,7 @@ class FixedKeyVarRecNode extends FixedKeyRecordNode { } @Override - public Record getRecord(Field key, Schema schema) throws IOException { + public DBRecord getRecord(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { return null; @@ -279,7 +279,7 @@ class FixedKeyVarRecNode extends FixedKeyRecordNode { } @Override - FixedKeyNode updateRecord(int index, Record record) throws IOException { + FixedKeyNode updateRecord(int index, DBRecord record) throws IOException { int offset = getRecordDataOffset(index); int oldLen = getRecordLength(index, offset); @@ -341,7 +341,7 @@ class FixedKeyVarRecNode extends FixedKeyRecordNode { * @throws IOException thrown if an IO error occurs */ @Override - boolean insertRecord(int index, Record record) throws IOException { + boolean insertRecord(int index, DBRecord record) throws IOException { // Check for use of indirect chained record node(s) int len = record.length(); diff --git a/Ghidra/Framework/DB/src/main/java/db/FixedRecNode.java b/Ghidra/Framework/DB/src/main/java/db/FixedRecNode.java index 9b47e429ad..c168fa9fbf 100644 --- a/Ghidra/Framework/DB/src/main/java/db/FixedRecNode.java +++ b/Ghidra/Framework/DB/src/main/java/db/FixedRecNode.java @@ -130,7 +130,7 @@ class FixedRecNode extends LongKeyRecordNode { } @Override - boolean insertRecord(int index, Record record) throws IOException { + boolean insertRecord(int index, DBRecord record) throws IOException { if (keyCount == ((buffer.length() - HEADER_SIZE) / entrySize)) { return false; // insufficient space for record storage @@ -149,26 +149,26 @@ class FixedRecNode extends LongKeyRecordNode { } @Override - LongKeyNode updateRecord(int index, Record record) throws IOException { + LongKeyNode updateRecord(int index, DBRecord record) throws IOException { int offset = getRecordOffset(index) + KEY_SIZE; record.write(buffer, offset); return getRoot(); } @Override - Record getRecord(long key, Schema schema) throws IOException { + DBRecord getRecord(long key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) return null; - Record record = schema.createRecord(key); + DBRecord record = schema.createRecord(key); record.read(buffer, getRecordOffset(index) + KEY_SIZE); return record; } @Override - public Record getRecord(Schema schema, int index) throws IOException { + public DBRecord getRecord(Schema schema, int index) throws IOException { long key = getKey(index); - Record record = schema.createRecord(key); + DBRecord record = schema.createRecord(key); record.read(buffer, getRecordOffset(index) + KEY_SIZE); return record; } diff --git a/Ghidra/Framework/DB/src/main/java/db/IndexTable.java b/Ghidra/Framework/DB/src/main/java/db/IndexTable.java index 9ff3e21021..a0f051ce5c 100644 --- a/Ghidra/Framework/DB/src/main/java/db/IndexTable.java +++ b/Ghidra/Framework/DB/src/main/java/db/IndexTable.java @@ -193,14 +193,14 @@ abstract class IndexTable { * @param record new record * @throws IOException if IO error occurs */ - abstract void addEntry(Record record) throws IOException; + abstract void addEntry(DBRecord record) throws IOException; /** * Delete an entry from this index. * @param oldRecord deleted record * @throws IOException if IO error occurs */ - abstract void deleteEntry(Record oldRecord) throws IOException; + abstract void deleteEntry(DBRecord oldRecord) throws IOException; /** * Delete all records within this index table. diff --git a/Ghidra/Framework/DB/src/main/java/db/KeyToRecordIterator.java b/Ghidra/Framework/DB/src/main/java/db/KeyToRecordIterator.java index e69a8d753f..c5de983d1f 100644 --- a/Ghidra/Framework/DB/src/main/java/db/KeyToRecordIterator.java +++ b/Ghidra/Framework/DB/src/main/java/db/KeyToRecordIterator.java @@ -61,7 +61,7 @@ public class KeyToRecordIterator implements RecordIterator { * @see db.RecordIterator#next() */ @Override - public Record next() throws IOException { + public DBRecord next() throws IOException { synchronized (db) { try { return table.getRecord(keyIter.next()); @@ -76,7 +76,7 @@ public class KeyToRecordIterator implements RecordIterator { * @see db.RecordIterator#previous() */ @Override - public Record previous() throws IOException { + public DBRecord previous() throws IOException { synchronized (db) { try { return table.getRecord(keyIter.previous()); diff --git a/Ghidra/Framework/DB/src/main/java/db/LongKeyRecordNode.java b/Ghidra/Framework/DB/src/main/java/db/LongKeyRecordNode.java index b61242b190..90a8f31744 100644 --- a/Ghidra/Framework/DB/src/main/java/db/LongKeyRecordNode.java +++ b/Ghidra/Framework/DB/src/main/java/db/LongKeyRecordNode.java @@ -311,7 +311,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return root node which may have changed. * @throws IOException thrown if IO error occurs */ - LongKeyNode putRecord(Record record, Table table) throws IOException { + LongKeyNode putRecord(DBRecord record, Table table) throws IOException { long key = record.getKey(); int index = getKeyIndex(key); @@ -360,7 +360,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return root node which may have changed. * @throws IOException thrown if IO error occurs */ - LongKeyNode appendNewLeaf(Record record) throws IOException { + LongKeyNode appendNewLeaf(DBRecord record) throws IOException { LongKeyRecordNode newLeaf = createNewLeaf(-1, -1); newLeaf.insertRecord(0, record); return appendLeaf(newLeaf); @@ -418,7 +418,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return true if the record was successfully inserted. * @throws IOException thrown if IO error occurs */ - abstract boolean insertRecord(int index, Record record) throws IOException; + abstract boolean insertRecord(int index, DBRecord record) throws IOException; /** * Updates the record at the given index. @@ -427,7 +427,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return root node which may have changed. * @throws IOException thrown if IO error occurs */ - abstract LongKeyNode updateRecord(int index, Record record) throws IOException; + abstract LongKeyNode updateRecord(int index, DBRecord record) throws IOException; /** * Get the record identified by the specified key. @@ -436,7 +436,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - abstract Record getRecord(long key, Schema schema) throws IOException; + abstract DBRecord getRecord(long key, Schema schema) throws IOException; /** * Get the record located at the specified index. @@ -445,7 +445,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return Record * @throws IOException thrown if IO error occurs */ - abstract Record getRecord(Schema schema, int index) throws IOException; + abstract DBRecord getRecord(Schema schema, int index) throws IOException; /** * Get the first record whoose key is less than the specified key. @@ -454,7 +454,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecordBefore(long key, Schema schema) throws IOException { + DBRecord getRecordBefore(long key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -index - 2; @@ -476,7 +476,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecordAfter(long key, Schema schema) throws IOException { + DBRecord getRecordAfter(long key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -(index + 1); @@ -499,7 +499,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecordAtOrBefore(long key, Schema schema) throws IOException { + DBRecord getRecordAtOrBefore(long key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -index - 2; @@ -519,7 +519,7 @@ abstract class LongKeyRecordNode extends LongKeyNode implements RecordNode { * @return Record requested or null if record not found. * @throws IOException thrown if IO error occurs */ - Record getRecordAtOrAfter(long key, Schema schema) throws IOException { + DBRecord getRecordAtOrAfter(long key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -(index + 1); diff --git a/Ghidra/Framework/DB/src/main/java/db/MasterTable.java b/Ghidra/Framework/DB/src/main/java/db/MasterTable.java index ec2db855bc..1bcc349b85 100644 --- a/Ghidra/Framework/DB/src/main/java/db/MasterTable.java +++ b/Ghidra/Framework/DB/src/main/java/db/MasterTable.java @@ -167,7 +167,7 @@ class MasterTable { int oldTableCnt = tableRecords.length; RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); long tablenum = rec.getKey(); while (ix < tableRecords.length && tablenum > tableRecords[ix].getTableNum()) { @@ -199,7 +199,7 @@ class MasterTable { */ void flush() throws IOException { for (int i = 0; i < tableRecords.length; i++) { - Record rec = tableRecords[i].getRecord(); + DBRecord rec = tableRecords[i].getRecord(); if (rec.isDirty()) { table.putRecord(rec); } diff --git a/Ghidra/Framework/DB/src/main/java/db/ObjectStorageAdapterDB.java b/Ghidra/Framework/DB/src/main/java/db/ObjectStorageAdapterDB.java index 3d106f11b6..c359ea35fd 100644 --- a/Ghidra/Framework/DB/src/main/java/db/ObjectStorageAdapterDB.java +++ b/Ghidra/Framework/DB/src/main/java/db/ObjectStorageAdapterDB.java @@ -44,7 +44,7 @@ public class ObjectStorageAdapterDB implements ObjectStorage { * existing record. * @param rec data record */ - public ObjectStorageAdapterDB(Record rec) { + public ObjectStorageAdapterDB(DBRecord rec) { readOnly = true; Field[] fields = rec.getFields(); for (int i = 0; i < fields.length; i++) { @@ -335,7 +335,7 @@ public class ObjectStorageAdapterDB implements ObjectStorage { * Save data into a Record. * @param rec database record. */ - public void save(Record rec) { + public void save(DBRecord rec) { int cnt = fieldList.size(); for (int i = 0; i < cnt; i++) { rec.setField(i, fieldList.get(i)); diff --git a/Ghidra/Framework/DB/src/main/java/db/RecordIterator.java b/Ghidra/Framework/DB/src/main/java/db/RecordIterator.java index 46de9da142..45550f30b7 100644 --- a/Ghidra/Framework/DB/src/main/java/db/RecordIterator.java +++ b/Ghidra/Framework/DB/src/main/java/db/RecordIterator.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -40,13 +39,13 @@ public interface RecordIterator { * Return the nexy Record or null if one is not available. * @throws IOException thrown if an IO error occurs */ - public Record next() throws IOException; + public DBRecord next() throws IOException; /** * Return the previous Record or null if one is not available. * @throws IOException thrown if an IO error occurs */ - public Record previous() throws IOException; + public DBRecord previous() throws IOException; /** * Delete the last Record read via the next or previous methods. diff --git a/Ghidra/Framework/DB/src/main/java/db/RecordTranslator.java b/Ghidra/Framework/DB/src/main/java/db/RecordTranslator.java index 6ea534b7bb..21b666ab90 100644 --- a/Ghidra/Framework/DB/src/main/java/db/RecordTranslator.java +++ b/Ghidra/Framework/DB/src/main/java/db/RecordTranslator.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,5 +22,5 @@ public interface RecordTranslator { * @param oldRecord the old database record. * @return the new data base record in the form required for the current database version. */ - Record translateRecord(Record oldRecord); + DBRecord translateRecord(DBRecord oldRecord); } diff --git a/Ghidra/Framework/DB/src/main/java/db/Schema.java b/Ghidra/Framework/DB/src/main/java/db/Schema.java index a2f2b4dd70..291c856fbd 100644 --- a/Ghidra/Framework/DB/src/main/java/db/Schema.java +++ b/Ghidra/Framework/DB/src/main/java/db/Schema.java @@ -521,7 +521,7 @@ public class Schema { * @param key long key * @return new record */ - public Record createRecord(long key) { + public DBRecord createRecord(long key) { return createRecord(new LongField(key)); } @@ -530,8 +530,8 @@ public class Schema { * @param key record key field * @return new record */ - public Record createRecord(Field key) { - return hasSparseColumns() ? new SparseRecord(this, key) : new Record(this, key); + public DBRecord createRecord(Field key) { + return hasSparseColumns() ? new SparseRecord(this, key) : new DBRecord(this, key); } /** diff --git a/Ghidra/Framework/DB/src/main/java/db/SparseRecord.java b/Ghidra/Framework/DB/src/main/java/db/SparseRecord.java index edf9b0a696..b9011e2e96 100644 --- a/Ghidra/Framework/DB/src/main/java/db/SparseRecord.java +++ b/Ghidra/Framework/DB/src/main/java/db/SparseRecord.java @@ -18,7 +18,7 @@ package db; import java.io.IOException; import java.util.ArrayList; -public class SparseRecord extends Record { +public class SparseRecord extends DBRecord { SparseRecord(Schema schema, Field key) { super(schema, key); diff --git a/Ghidra/Framework/DB/src/main/java/db/Table.java b/Ghidra/Framework/DB/src/main/java/db/Table.java index b827a877d2..b62383fbae 100644 --- a/Ghidra/Framework/DB/src/main/java/db/Table.java +++ b/Ghidra/Framework/DB/src/main/java/db/Table.java @@ -239,7 +239,7 @@ public class Table { * @param record new record which has been added * @throws IOException thrown if IO error occurs */ - void insertedRecord(Record record) throws IOException { + void insertedRecord(DBRecord record) throws IOException { // Add secondary index entries for new record for (int indexedColumn : indexedColumns) { IndexTable indexTable = secondaryIndexes.get(indexedColumn); @@ -255,7 +255,7 @@ public class Table { * @param newRecord new record * @throws IOException thrown if IO error occurs */ - void updatedRecord(Record oldRecord, Record newRecord) throws IOException { + void updatedRecord(DBRecord oldRecord, DBRecord newRecord) throws IOException { // Update secondary indexes which have been affected for (int colIx : indexedColumns) { Field oldField = oldRecord.getField(colIx); @@ -275,7 +275,7 @@ public class Table { * @param oldRecord record which has been deleted * @throws IOException thrown if IO error occurs */ - void deletedRecord(Record oldRecord) throws IOException { + void deletedRecord(DBRecord oldRecord) throws IOException { // Delete secondary index entries for (int indexedColumn : indexedColumns) { IndexTable indexTable = secondaryIndexes.get(indexedColumn); @@ -334,7 +334,7 @@ public class Table { try { RecordIterator recIter = iterator(); while (recIter.hasNext()) { - Record rec = recIter.next(); + DBRecord rec = recIter.next(); ++actualCount; Field keyField = rec.getKeyField(); if ((keyField instanceof LongField) && @@ -407,7 +407,7 @@ public class Table { int actualCount = 0; RecordIterator recIter = iterator(); while (recIter.hasNext()) { - Record rec = recIter.next(); + DBRecord rec = recIter.next(); ++actualCount; // Check for bad index tables (missing or invalid entries) @@ -687,7 +687,7 @@ public class Table { * found. * @throws IOException throw if an IO Error occurs */ - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -709,7 +709,7 @@ public class Table { * found. * @throws IOException throw if an IO Error occurs */ - public Record getRecord(Field key) throws IOException { + public DBRecord getRecord(Field key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -740,7 +740,7 @@ public class Table { * specified key, or null if no record was found. * @throws IOException throw if an IO Error occurs */ - public Record getRecordBefore(long key) throws IOException { + public DBRecord getRecordBefore(long key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -763,7 +763,7 @@ public class Table { * specified key, or null if no record was found. * @throws IOException throw if an IO Error occurs */ - public Record getRecordBefore(Field key) throws IOException { + public DBRecord getRecordBefore(Field key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -789,7 +789,7 @@ public class Table { * specified key, or null if no record was found. * @throws IOException throw if an IO Error occurs */ - public Record getRecordAfter(long key) throws IOException { + public DBRecord getRecordAfter(long key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -812,7 +812,7 @@ public class Table { * specified key, or null if no record was found. * @throws IOException throw if an IO Error occurs */ - public Record getRecordAfter(Field key) throws IOException { + public DBRecord getRecordAfter(Field key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -838,7 +838,7 @@ public class Table { * specified key, or null if no record was found. * @throws IOException throw if an IO Error occurs */ - public Record getRecordAtOrBefore(long key) throws IOException { + public DBRecord getRecordAtOrBefore(long key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -861,7 +861,7 @@ public class Table { * specified key, or null if no record was found. * @throws IOException throw if an IO Error occurs */ - public Record getRecordAtOrBefore(Field key) throws IOException { + public DBRecord getRecordAtOrBefore(Field key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -887,7 +887,7 @@ public class Table { * specified key, or null if no record was found. * @throws IOException throw if an IO Error occurs */ - public Record getRecordAtOrAfter(long key) throws IOException { + public DBRecord getRecordAtOrAfter(long key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -910,7 +910,7 @@ public class Table { * specified key, or null if no record was found. * @throws IOException throw if an IO Error occurs */ - public Record getRecordAtOrAfter(Field key) throws IOException { + public DBRecord getRecordAtOrAfter(Field key) throws IOException { synchronized (db) { if (rootBufferId < 0) { return null; @@ -933,7 +933,7 @@ public class Table { * @param record the record to be stored. * @throws IOException throw if an IO Error occurs */ - public void putRecord(Record record) throws IOException { + public void putRecord(DBRecord record) throws IOException { synchronized (db) { db.checkTransaction(); if (schema.useLongKeyNodes()) { @@ -951,7 +951,7 @@ public class Table { * @param record recore to be inserted or updated * @throws IOException throw if an IO Error occurs */ - private void putLongKeyRecord(Record record) throws IOException { + private void putLongKeyRecord(DBRecord record) throws IOException { // boolean inserted = false; try { @@ -1000,7 +1000,7 @@ public class Table { * @param record record to be inserted or updated * @throws IOException throw if an IO Error occurs */ - private void putFieldKeyRecord(Record record) throws IOException { + private void putFieldKeyRecord(DBRecord record) throws IOException { // boolean inserted = false; try { @@ -2031,9 +2031,9 @@ public class Table { private boolean isNext; // recover position is next record private boolean isPrev; // recover position is previous record - private Record record; // current record + private DBRecord record; // current record private long curKey; // copy of record key (record may get changed by consumer) - private Record lastRecord; + private DBRecord lastRecord; private boolean hasPrev; // current record is previous private boolean hasNext; // current record is next @@ -2224,7 +2224,7 @@ public class Table { } // Load next record - Record nextRecord = leaf.getRecord(schema, nextIndex); + DBRecord nextRecord = leaf.getRecord(schema, nextIndex); hasNext = nextRecord.getKey() <= maxKey; if (hasNext) { bufferId = nextBufferId; @@ -2271,7 +2271,7 @@ public class Table { } // Load previous record - Record prevRecord = leaf.getRecord(schema, prevIndex); + DBRecord prevRecord = leaf.getRecord(schema, prevIndex); hasPrev = prevRecord.getKey() >= minKey; if (hasPrev) { bufferId = prevBufferId; @@ -2290,7 +2290,7 @@ public class Table { } @Override - public Record next() throws IOException { + public DBRecord next() throws IOException { if (hasNext || hasNext()) { hasNext = false; hasPrev = true; @@ -2301,7 +2301,7 @@ public class Table { } @Override - public Record previous() throws IOException { + public DBRecord previous() throws IOException { if (hasPrev || hasPrevious()) { hasNext = true; hasPrev = false; @@ -2333,9 +2333,9 @@ public class Table { private boolean isNext; // recover position is next record private boolean isPrev; // recover position is previous record - private Record record; // current record + private DBRecord record; // current record // private Field curKey; // copy of record key (record may get changed by consumer) - private Record lastRecord; + private DBRecord lastRecord; private boolean hasPrev; // current record is previous private boolean hasNext; // current record is next @@ -2549,7 +2549,7 @@ public class Table { } // Load next record - Record nextRecord = leaf.getRecord(schema, nextIndex); + DBRecord nextRecord = leaf.getRecord(schema, nextIndex); hasNext = maxKey == null ? true : (nextRecord.getKeyField().compareTo(maxKey) <= 0); if (hasNext) { @@ -2597,7 +2597,7 @@ public class Table { } // Load previous record - Record prevRecord = leaf.getRecord(schema, prevIndex); + DBRecord prevRecord = leaf.getRecord(schema, prevIndex); hasPrev = minKey == null ? true : (prevRecord.getKeyField().compareTo(minKey) >= 0); if (hasPrev) { @@ -2617,7 +2617,7 @@ public class Table { } @Override - public Record next() throws IOException { + public DBRecord next() throws IOException { if (hasNext || hasNext()) { hasNext = false; hasPrev = true; @@ -2628,7 +2628,7 @@ public class Table { } @Override - public Record previous() throws IOException { + public DBRecord previous() throws IOException { if (hasPrev || hasPrevious()) { hasNext = true; hasPrev = false; diff --git a/Ghidra/Framework/DB/src/main/java/db/TableRecord.java b/Ghidra/Framework/DB/src/main/java/db/TableRecord.java index ed8e7f98a4..5c08c75d62 100644 --- a/Ghidra/Framework/DB/src/main/java/db/TableRecord.java +++ b/Ghidra/Framework/DB/src/main/java/db/TableRecord.java @@ -54,7 +54,7 @@ class TableRecord implements Comparable { private static Schema schema = new Schema(0, "TableNum", fields, tableRecordFieldNames); - private Record record; + private DBRecord record; private Schema tableSchema; private Table table; @@ -86,7 +86,7 @@ class TableRecord implements Comparable { * @throws UnsupportedFieldException stored schema contains unsupported field * @throws IOException if IO error occurs */ - TableRecord(DBHandle dbh, Record record) throws IOException { + TableRecord(DBHandle dbh, DBRecord record) throws IOException { this.tableSchema = parseSchema(dbh, record); this.record = record; } @@ -95,7 +95,7 @@ class TableRecord implements Comparable { * Get the underlying storage record for this instance. * @return master table storage record. */ - Record getRecord() { + DBRecord getRecord() { return record; } @@ -115,7 +115,7 @@ class TableRecord implements Comparable { * @throws UnsupportedFieldException stored schema contains unsupported field * @throws IOException if IO error occurs */ - void setRecord(DBHandle dbh, Record record) throws IOException { + void setRecord(DBHandle dbh, DBRecord record) throws IOException { this.tableSchema = parseSchema(dbh, record); this.record = record; if (table != null) { @@ -169,7 +169,7 @@ class TableRecord implements Comparable { * @throws UnsupportedFieldException stored schema contains unsupported field * @throws IOException if IO error occurs */ - private static Schema parseSchema(DBHandle dbh, Record record) throws IOException { + private static Schema parseSchema(DBHandle dbh, DBRecord record) throws IOException { Schema tableSchema = new Schema(record.getIntValue(VERSION_COLUMN), record.getByteValue(KEY_TYPE_COLUMN), record.getBinaryData(FIELD_TYPES_COLUMN), record.getString(FIELD_NAMES_COLUMN)); diff --git a/Ghidra/Framework/DB/src/main/java/db/TranslatedRecordIterator.java b/Ghidra/Framework/DB/src/main/java/db/TranslatedRecordIterator.java index 1c9af584d6..fd49143424 100644 --- a/Ghidra/Framework/DB/src/main/java/db/TranslatedRecordIterator.java +++ b/Ghidra/Framework/DB/src/main/java/db/TranslatedRecordIterator.java @@ -37,12 +37,12 @@ public class TranslatedRecordIterator implements RecordIterator { } @Override - public Record next() throws IOException { + public DBRecord next() throws IOException { return translator.translateRecord(it.next()); } @Override - public Record previous() throws IOException { + public DBRecord previous() throws IOException { return translator.translateRecord(it.previous()); } diff --git a/Ghidra/Framework/DB/src/main/java/db/VarKeyRecordNode.java b/Ghidra/Framework/DB/src/main/java/db/VarKeyRecordNode.java index be1b499f65..eadc2be6ee 100644 --- a/Ghidra/Framework/DB/src/main/java/db/VarKeyRecordNode.java +++ b/Ghidra/Framework/DB/src/main/java/db/VarKeyRecordNode.java @@ -296,7 +296,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { } @Override - public VarKeyNode putRecord(Record record, Table table) throws IOException { + public VarKeyNode putRecord(DBRecord record, Table table) throws IOException { Field key = record.getKeyField(); int index = getKeyIndex(key); @@ -342,7 +342,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { * @return root node which may have changed. * @throws IOException thrown if IO error occurs */ - VarKeyNode appendNewLeaf(Record record) throws IOException { + VarKeyNode appendNewLeaf(DBRecord record) throws IOException { VarKeyRecordNode newLeaf = createNewLeaf(-1, -1); newLeaf.insertRecord(0, record); return appendLeaf(newLeaf); @@ -386,7 +386,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { } @Override - public Record getRecordBefore(Field key, Schema schema) throws IOException { + public DBRecord getRecordBefore(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -index - 2; @@ -402,7 +402,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { } @Override - public Record getRecordAfter(Field key, Schema schema) throws IOException { + public DBRecord getRecordAfter(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -(index + 1); @@ -418,7 +418,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { } @Override - public Record getRecordAtOrBefore(Field key, Schema schema) throws IOException { + public DBRecord getRecordAtOrBefore(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -index - 2; @@ -431,7 +431,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { } @Override - public Record getRecordAtOrAfter(Field key, Schema schema) throws IOException { + public DBRecord getRecordAtOrAfter(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { index = -(index + 1); @@ -574,9 +574,9 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { * @return Record */ @Override - public Record getRecord(Schema schema, int index) throws IOException { + public DBRecord getRecord(Schema schema, int index) throws IOException { Field key = getKeyField(index); - Record record = schema.createRecord(key); + DBRecord record = schema.createRecord(key); if (hasIndirectStorage(index)) { int bufId = buffer.getInt(getRecordDataOffset(index)); ChainedBuffer chainedBuffer = new ChainedBuffer(nodeMgr.getBufferMgr(), bufId); @@ -597,7 +597,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { } @Override - public Record getRecord(Field key, Schema schema) throws IOException { + public DBRecord getRecord(Field key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) return null; @@ -669,7 +669,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { * @return root node which may have changed. * @throws IOException thrown if IO error occurs */ - private VarKeyNode updateRecord(int index, Record record) throws IOException { + private VarKeyNode updateRecord(int index, DBRecord record) throws IOException { Field key = record.getKeyField(); int keyLen = key.length(); @@ -733,7 +733,7 @@ class VarKeyRecordNode extends VarKeyNode implements FieldKeyRecordNode { * @return true if the record was successfully inserted. * @throws IOException thrown if IO error occurs */ - private boolean insertRecord(int index, Record record) throws IOException { + private boolean insertRecord(int index, DBRecord record) throws IOException { Field key = record.getKeyField(); int keyLen = key.length(); diff --git a/Ghidra/Framework/DB/src/main/java/db/VarRecNode.java b/Ghidra/Framework/DB/src/main/java/db/VarRecNode.java index 8edb94454c..9ed17d7ecc 100644 --- a/Ghidra/Framework/DB/src/main/java/db/VarRecNode.java +++ b/Ghidra/Framework/DB/src/main/java/db/VarRecNode.java @@ -189,9 +189,9 @@ class VarRecNode extends LongKeyRecordNode { } @Override - public Record getRecord(Schema schema, int index) throws IOException { + public DBRecord getRecord(Schema schema, int index) throws IOException { long key = getKey(index); - Record record = schema.createRecord(key); + DBRecord record = schema.createRecord(key); if (hasIndirectStorage(index)) { int bufId = buffer.getInt(getRecordDataOffset(index)); ChainedBuffer chainedBuffer = new ChainedBuffer(nodeMgr.getBufferMgr(), bufId); @@ -212,7 +212,7 @@ class VarRecNode extends LongKeyRecordNode { } @Override - Record getRecord(long key, Schema schema) throws IOException { + DBRecord getRecord(long key, Schema schema) throws IOException { int index = getKeyIndex(key); if (index < 0) { return null; @@ -277,7 +277,7 @@ class VarRecNode extends LongKeyRecordNode { } @Override - LongKeyNode updateRecord(int index, Record record) throws IOException { + LongKeyNode updateRecord(int index, DBRecord record) throws IOException { int offset = getRecordDataOffset(index); int oldLen = getRecordLength(index, offset); @@ -330,7 +330,7 @@ class VarRecNode extends LongKeyRecordNode { } @Override - boolean insertRecord(int index, Record record) throws IOException { + boolean insertRecord(int index, DBRecord record) throws IOException { // Check for use of indirect chained record node(s) int len = record.length(); diff --git a/Ghidra/Framework/DB/src/test/java/db/DBFixedKeyIndexedTableTest.java b/Ghidra/Framework/DB/src/test/java/db/DBFixedKeyIndexedTableTest.java index 63c117b817..2ab72e1c20 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBFixedKeyIndexedTableTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBFixedKeyIndexedTableTest.java @@ -86,11 +86,11 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createRandomTableRecords(int schemaType, int recordCnt, int varDataSize) + private DBRecord[] createRandomTableRecords(int schemaType, int recordCnt, int varDataSize) throws IOException { long txId = dbh.startTransaction(); Table table = DBTestUtils.createFixedKeyTable(dbh, table1Name, schemaType, true, false); - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = DBTestUtils.createFixedKeyRecord(table, varDataSize, true); @@ -110,13 +110,13 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createOrderedTableRecords(int schemaType, int recordCnt, long keyIncrement, + private DBRecord[] createOrderedTableRecords(int schemaType, int recordCnt, long keyIncrement, int varDataSize) throws IOException { long txId = dbh.startTransaction(); Table table = DBTestUtils.createFixedKeyTable(dbh, table1Name, schemaType, true, false); FixedField key = new FixedField10(new byte[] { 0x7f, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff }); - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = DBTestUtils.createRecord(table, key, varDataSize, true); @@ -130,19 +130,19 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { return recs; } - private Field[] matchingKeys(Record[] recs, int columnIx, Record matchRec) { - ArrayList recList = new ArrayList<>(); + private Field[] matchingKeys(DBRecord[] recs, int columnIx, DBRecord matchRec) { + ArrayList recList = new ArrayList<>(); Field f = matchRec.getField(columnIx); - for (Record rec : recs) { + for (DBRecord rec : recs) { if (f.equals(rec.getField(columnIx))) { recList.add(rec); } } Field[] keys = new FixedField[recList.size()]; - Iterator iter = recList.iterator(); + Iterator iter = recList.iterator(); int i = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); keys[i++] = rec.getKeyField(); } Arrays.sort(keys); @@ -151,7 +151,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { private void findRecords(boolean testStoredDB, int recordCnt, int findCnt, int varDataSize) throws IOException { - Record[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize);// short var-len fields + DBRecord[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize);// short var-len fields if (testStoredDB) { saveAsAndReopen(dbName); } @@ -239,7 +239,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { private void updateRecordsIterator(boolean testStoredDB, int schemaType, int recordCnt, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomTableRecords(schemaType, recordCnt, varDataSize); } @@ -305,7 +305,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { int recIx = 0; RecordIterator iter = table.indexIterator(colIx); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -315,7 +315,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -325,7 +325,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -335,7 +335,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -344,7 +344,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = findStart(recs, recordCnt / 2, colIx); iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -353,7 +353,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = recordCnt - 1; iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -362,7 +362,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = findEnd(recs, recordCnt / 2, colIx); iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -375,7 +375,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() - 1); iter = table.indexIteratorAfter(colIx, startValue); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -385,7 +385,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() + 1); iter = table.indexIteratorBefore(colIx, startValue); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -409,7 +409,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { private void iterateRecords(boolean testStoredDB, int schemaType, int recordCnt, long keyIncrement, int varDataSize, boolean doUndoRedo) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomTableRecords(schemaType, recordCnt, varDataSize); } @@ -443,7 +443,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = 0; iter = table.indexIterator(colIx); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx], rec); Field indexField = recs[recIx].getField(colIx); if (lastIndex == null || !lastIndex.equals(indexField)) { @@ -473,7 +473,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = findEnd(recs, startIx, colIx); iter = table.indexIteratorAfter(colIx, recs[startIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -485,7 +485,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[startIx].getField(colIx), recs[startIx].getKeyField()); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -501,7 +501,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = 0; iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -522,7 +522,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -536,7 +536,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = recordCnt - 1; iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -546,7 +546,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -556,7 +556,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -565,7 +565,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = findStart(recs, recordCnt / 2, colIx); iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -574,7 +574,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = findStart(recs, recordCnt / 2, colIx); iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[--recIx], rec); } assertEquals(0, recIx); @@ -583,7 +583,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = findEnd(recs, recordCnt / 2, colIx); iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[++recIx], rec); } assertEquals(recordCnt - 1, recIx); @@ -592,7 +592,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = findEnd(recs, recordCnt / 2, colIx); iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -604,7 +604,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIterator(colIx, recs[minIx].getField(colIx), recs[maxIx].getField(colIx), true); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(maxIx + 1, recIx); @@ -613,7 +613,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = 0; iter = table.indexIterator(colIx, null, null, true); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -625,7 +625,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIterator(colIx, recs[minIx].getField(colIx), recs[maxIx].getField(colIx), false); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(minIx - 1, recIx); @@ -634,7 +634,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { recIx = recordCnt - 1; iter = table.indexIterator(colIx, null, null, false); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -652,7 +652,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() - 1); iter = table.indexIteratorAfter(colIx, startValue); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -662,7 +662,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() + 1); iter = table.indexIteratorBefore(colIx, startValue); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -675,26 +675,26 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); for (int i = 0; i < 2; i++) { if (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } } --recIx; for (int i = 0; i < 2; i++) { if (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } } ++recIx; for (int i = 0; i < 2; i++) { if (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } } while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -705,26 +705,26 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { --recIx; for (int i = 0; i < 2; i++) { if (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } } ++recIx; for (int i = 0; i < 2; i++) { if (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } } --recIx; for (int i = 0; i < 2; i++) { if (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } } while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -734,13 +734,13 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); for (int i = 0; i < 3; i++) { if (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } } assertEquals(recordCnt - 1, recIx); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -750,13 +750,13 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); for (int i = 0; i < 3; i++) { if (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[--recIx], rec); } } assertEquals(0, recIx); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -862,7 +862,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { private void deleteIteratedRecords(int recordCnt, int testColIx, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize); } @@ -930,7 +930,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { private void deleteIteratedIndexFields(int recordCnt, int testColIx, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize); } @@ -948,7 +948,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { int fieldCnt = 0; Field lastField = null; ArrayList fieldList = new ArrayList<>(); - for (Record rec : recs) { + for (DBRecord rec : recs) { Field f = rec.getField(testColIx); if (lastField == null || !lastField.equals(f)) { lastField = f; @@ -997,7 +997,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { int fieldCnt = 0; Field lastField = null; ArrayList fieldList = new ArrayList<>(); - for (Record rec : recs) { + for (DBRecord rec : recs) { Field f = rec.getField(testColIx); if (lastField == null || !lastField.equals(f)) { lastField = f; @@ -1025,7 +1025,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { } } - private int findStart(Record[] recs, int startIx, int colIx) { + private int findStart(DBRecord[] recs, int startIx, int colIx) { Field f = recs[startIx].getField(colIx); --startIx; while (startIx >= 0 && f.equals(recs[startIx].getField(colIx))) { @@ -1037,7 +1037,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { return ++startIx; } - private int findEnd(Record[] recs, int startIx, int colIx) { + private int findEnd(DBRecord[] recs, int startIx, int colIx) { Field f = recs[startIx].getField(colIx); ++startIx; while (startIx < recs.length && f.equals(recs[startIx].getField(colIx))) { @@ -1049,7 +1049,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { return --startIx; } - private class RecColumnComparator implements Comparator { + private class RecColumnComparator implements Comparator { int columnIx; @@ -1058,7 +1058,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { } @Override - public int compare(Record rec1, Record rec2) { + public int compare(DBRecord rec1, DBRecord rec2) { int r = rec1.getField(columnIx).compareTo(rec2.getField(columnIx)); if (r == 0) { return rec1.getKeyField().compareTo(rec2.getKeyField()); @@ -1135,7 +1135,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { @Test public void testRecordIteratorExtents() throws IOException { - Record[] recs = null; + DBRecord[] recs = null; recs = createOrderedTableRecords(DBTestUtils.SINGLE_SHORT, 30, 2, 1); Table table = dbh.getTable(table1Name); assertEquals(recs.length, table.getRecordCount()); @@ -1148,7 +1148,7 @@ public class DBFixedKeyIndexedTableTest extends AbstractGenericTest { Field maxField = new ShortField(Short.MAX_VALUE); RecordIterator iter = table.indexIterator(colIx, minField, maxField, false); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(recIx, -1); diff --git a/Ghidra/Framework/DB/src/test/java/db/DBFixedKeySparseIndexedTableTest.java b/Ghidra/Framework/DB/src/test/java/db/DBFixedKeySparseIndexedTableTest.java index 16ecb0af81..bed54e6508 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBFixedKeySparseIndexedTableTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBFixedKeySparseIndexedTableTest.java @@ -139,7 +139,7 @@ public class DBFixedKeySparseIndexedTableTest extends AbstractGenericTest { int cnt = schema.getFieldCount(); for (int i = 0; i < cnt; i++) { Field key = new FixedField10(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 1, (byte) i }); - Record r = schema.createRecord(key); + DBRecord r = schema.createRecord(key); Field f = schema.getField(i); if (f.isVariableLength()) { diff --git a/Ghidra/Framework/DB/src/test/java/db/DBFixedKeyTableTest.java b/Ghidra/Framework/DB/src/test/java/db/DBFixedKeyTableTest.java index d495ae276f..673f2c850c 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBFixedKeyTableTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBFixedKeyTableTest.java @@ -91,7 +91,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { long txId = dbh.startTransaction(); Table table = DBTestUtils.createFixedKeyTable(dbh, table1Name, DBTestUtils.ALL_TYPES, false, false); - Record rec = null; + DBRecord rec = null; try { rec = DBTestUtils.createFixedKeyRecord(table, varDataSize, true); } @@ -276,14 +276,14 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createRandomFixedKeyTableRecords(Table table, int recordCnt, int varDataSize) + private DBRecord[] createRandomFixedKeyTableRecords(Table table, int recordCnt, int varDataSize) throws IOException { long txId = dbh.startTransaction(); if (table == null) { table = DBTestUtils.createFixedKeyTable(dbh, table1Name, DBTestUtils.ALL_TYPES, false, false); } - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = DBTestUtils.createFixedKeyRecord(table, varDataSize, true); @@ -302,13 +302,13 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createOrderedFixedKeyTableRecords(int recordCnt, long keyIncrement, + private DBRecord[] createOrderedFixedKeyTableRecords(int recordCnt, long keyIncrement, int varDataSize) throws IOException { long txId = dbh.startTransaction(); Table table = DBTestUtils.createFixedKeyTable(dbh, table1Name, DBTestUtils.ALL_TYPES, false, false); FixedField10 key = new FixedField10(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = DBTestUtils.createRecord(table, key, varDataSize, true); @@ -332,7 +332,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { */ private void iterateFixedKeyRecords(boolean testStoredDB, int recordCnt, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomFixedKeyTableRecords(null, recordCnt, varDataSize); } @@ -567,7 +567,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { */ private void iterateFixedKeys(boolean testStoredDB, int recordCnt, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomFixedKeyTableRecords(null, recordCnt, varDataSize); } @@ -742,7 +742,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testForwardDeleteIterator() throws IOException { - Record[] recs = createOrderedFixedKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); + DBRecord[] recs = createOrderedFixedKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); assertEquals(SMALL_ITER_REC_CNT, table.getRecordCount()); @@ -761,7 +761,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testReverseDeleteIterator() throws IOException { - Record[] recs = createOrderedFixedKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); + DBRecord[] recs = createOrderedFixedKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); assertEquals(SMALL_ITER_REC_CNT, table.getRecordCount()); @@ -779,22 +779,22 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testGetFixedKeyRecordAfter() throws IOException { - Record[] recs = createRandomFixedKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // After test for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAfter(recs[i].getKeyField()); + DBRecord rec = table.getRecordAfter(recs[i].getKeyField()); assertEquals(rec.getKeyField(), recs[i + 1].getKeyField()); } // End test - Record rec = table.getRecordAfter(recs[15999].getKeyField()); + DBRecord rec = table.getRecordAfter(recs[15999].getKeyField()); assertNull(rec); } - private int findHoleAfterFixedKey(Record[] recs, int startIx) { + private int findHoleAfterFixedKey(DBRecord[] recs, int startIx) { for (int i = startIx; i < recs.length - 1; i++) { FixedField f = DBTestUtils.addToFixedField(recs[i].getKeyField(), 1); if (f.compareTo(recs[i + 1].getKeyField()) < 0) { @@ -804,7 +804,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { return -1; } - private int findHoleBeforeFixedKey(Record[] recs, int startIx) { + private int findHoleBeforeFixedKey(DBRecord[] recs, int startIx) { for (int i = startIx; i < recs.length; i++) { FixedField f = DBTestUtils.addToFixedField(recs[i - 1].getKeyField(), 1); if (f.compareTo(recs[i].getKeyField()) < 0) { @@ -816,13 +816,13 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testGetFixedKeyRecordAtOrAfter() throws IOException { - Record[] recs = createRandomFixedKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // At and After tests for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAtOrAfter(recs[i].getKeyField()); + DBRecord rec = table.getRecordAtOrAfter(recs[i].getKeyField()); assertEquals(rec.getKeyField(), recs[i].getKeyField()); int ix = findHoleAfterFixedKey(recs, i + 500); if (ix < 0) { @@ -837,7 +837,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { if (lastKey == MAX_VALUE) { Assert.fail("Bad test data"); } - Record rec = table.getRecordAtOrAfter(lastKey); + DBRecord rec = table.getRecordAtOrAfter(lastKey); assertEquals(rec.getKeyField(), lastKey); rec = table.getRecordAtOrAfter(DBTestUtils.addToFixedField(lastKey, 1)); assertNull(rec); @@ -845,13 +845,13 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testGetFixedKeyRecordAtOrBefore() throws IOException { - Record[] recs = createRandomFixedKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // At and Before tests for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAtOrBefore(recs[i].getKeyField()); + DBRecord rec = table.getRecordAtOrBefore(recs[i].getKeyField()); assertEquals(rec.getKeyField(), recs[i].getKeyField()); int ix = findHoleBeforeFixedKey(recs, i + 500); if (ix < 0) { @@ -867,7 +867,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { if (firstKey.equals(MIN_VALUE)) { Assert.fail("Bad test data"); } - Record rec = table.getRecordAtOrBefore(firstKey); + DBRecord rec = table.getRecordAtOrBefore(firstKey); assertEquals(rec.getKeyField(), firstKey); rec = table.getRecordAtOrBefore(DBTestUtils.addToFixedField(firstKey, -1)); assertNull(rec); @@ -876,7 +876,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testDeleteFixedKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -890,7 +890,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 1; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); if ((recIx % 1000) == 0) { ++recIx; @@ -902,7 +902,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testForwardDeleteFixedKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -918,7 +918,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testReverseDeleteFixedKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -934,7 +934,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { public void testDeleteAllFixedKeyRecords() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); Arrays.sort(recs); long txId = dbh.startTransaction(); @@ -954,7 +954,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -962,7 +962,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { private void deleteFixedKeyRangeRecords(int count, int startIx, int endIx) throws IOException { - Record[] recs = createRandomFixedKeyTableRecords(null, count, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, count, 1); Arrays.sort(recs); long txId = dbh.startTransaction(); @@ -973,7 +973,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = startIx != 0 ? 0 : (endIx + 1); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); if (recIx == startIx) { recIx = endIx + 1; @@ -1002,7 +1002,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testUpdateFixedKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -1016,7 +1016,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1025,7 +1025,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { @Test public void testUpdateBigFixedKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -1039,7 +1039,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1054,7 +1054,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { iter = table.iterator(); recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1066,7 +1066,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { assertTrue(!dbh.canUndo()); assertTrue(!dbh.canRedo()); - Record[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -1077,7 +1077,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { // Update records long txId = dbh.startTransaction(); for (int i = 0; i < cnt; i += 100) { - Record rec = table.getSchema().createRecord(recs[i].getKeyField()); + DBRecord rec = table.getSchema().createRecord(recs[i].getKeyField()); DBTestUtils.fillRecord(rec, (BUFFER_SIZE / 8) * BUFFER_SIZE); table.putRecord(rec); } @@ -1093,7 +1093,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1115,7 +1115,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { iter = table.iterator(); recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1128,7 +1128,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { assertTrue(!dbh.canUndo()); assertTrue(!dbh.canRedo()); - Record[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomFixedKeyTableRecords(null, cnt, 1); assertTrue(dbh.canUndo()); assertTrue(!dbh.canRedo()); @@ -1163,13 +1163,13 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); // Add records - Record[] newRecs = new Record[recs.length + 100]; + DBRecord[] newRecs = new DBRecord[recs.length + 100]; System.arraycopy(recs, 0, newRecs, 0, recs.length); txId = dbh.startTransaction(); for (int i = 0; i < 100; i++) { @@ -1193,7 +1193,7 @@ public class DBFixedKeyTableTest extends AbstractGenericTest { iter = table.iterator(); recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recs.length, recIx); diff --git a/Ghidra/Framework/DB/src/test/java/db/DBIndexedTableTest.java b/Ghidra/Framework/DB/src/test/java/db/DBIndexedTableTest.java index 21702b7264..443ba14db7 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBIndexedTableTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBIndexedTableTest.java @@ -87,11 +87,11 @@ public class DBIndexedTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createRandomTableRecords(int schemaType, int recordCnt, int varDataSize) + private DBRecord[] createRandomTableRecords(int schemaType, int recordCnt, int varDataSize) throws IOException { long txId = dbh.startTransaction(); Table table = DBTestUtils.createLongKeyTable(dbh, table1Name, schemaType, true, false); - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = DBTestUtils.createLongKeyRecord(table, true, varDataSize, true); @@ -111,12 +111,12 @@ public class DBIndexedTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createOrderedTableRecords(int schemaType, int recordCnt, long keyIncrement, + private DBRecord[] createOrderedTableRecords(int schemaType, int recordCnt, long keyIncrement, int varDataSize) throws IOException { long txId = dbh.startTransaction(); Table table = DBTestUtils.createLongKeyTable(dbh, table1Name, schemaType, true, false); long key = 0; - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = DBTestUtils.createRecord(table, key, varDataSize, true); @@ -130,19 +130,19 @@ public class DBIndexedTableTest extends AbstractGenericTest { return recs; } - private Field[] matchingKeys(Record[] recs, int columnIx, Record matchRec) { - ArrayList recList = new ArrayList<>(); + private Field[] matchingKeys(DBRecord[] recs, int columnIx, DBRecord matchRec) { + ArrayList recList = new ArrayList<>(); Field f = matchRec.getField(columnIx); - for (Record rec : recs) { + for (DBRecord rec : recs) { if (f.equals(rec.getField(columnIx))) { recList.add(rec); } } Field[] keys = new Field[recList.size()]; - Iterator iter = recList.iterator(); + Iterator iter = recList.iterator(); int i = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); keys[i++] = rec.getKeyField(); } Arrays.sort(keys); @@ -151,7 +151,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { private void findRecords(boolean testStoredDB, int recordCnt, int findCnt, int varDataSize) throws IOException { - Record[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize);// short var-len fields + DBRecord[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize);// short var-len fields if (testStoredDB) { saveAsAndReopen(dbName); } @@ -239,7 +239,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { private void updateRecordsIterator(boolean testStoredDB, int schemaType, int recordCnt, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomTableRecords(schemaType, recordCnt, varDataSize); } @@ -307,7 +307,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { int recIx = 0; RecordIterator iter = table.indexIterator(colIx); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -317,7 +317,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -327,7 +327,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -337,7 +337,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -346,7 +346,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = findStart(recs, recordCnt / 2, colIx); iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -355,7 +355,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = recordCnt - 1; iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -364,7 +364,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = findEnd(recs, recordCnt / 2, colIx); iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -377,7 +377,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() - 1); iter = table.indexIteratorAfter(colIx, startValue); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -387,7 +387,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() + 1); iter = table.indexIteratorBefore(colIx, startValue); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -411,7 +411,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { private void iterateRecords(boolean testStoredDB, int schemaType, int recordCnt, long keyIncrement, int varDataSize, boolean doUndoRedo) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomTableRecords(schemaType, recordCnt, varDataSize); } @@ -444,7 +444,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = 0; iter = table.indexIterator(colIx); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx], rec); Field indexField = recs[recIx].getField(colIx); if (lastIndex == null || !lastIndex.equals(indexField)) { @@ -474,7 +474,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = findEnd(recs, startIx, colIx); iter = table.indexIteratorAfter(colIx, recs[startIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -486,7 +486,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[startIx].getField(colIx), recs[startIx].getKeyField()); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -502,7 +502,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = 0; iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -523,7 +523,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -537,7 +537,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = recordCnt - 1; iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -547,7 +547,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -557,7 +557,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx), recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -566,7 +566,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = findStart(recs, recordCnt / 2, colIx); iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -575,7 +575,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = findStart(recs, recordCnt / 2, colIx); iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[--recIx], rec); } assertEquals(0, recIx); @@ -584,7 +584,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = findEnd(recs, recordCnt / 2, colIx); iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[++recIx], rec); } assertEquals(recordCnt - 1, recIx); @@ -593,7 +593,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = findEnd(recs, recordCnt / 2, colIx); iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -605,7 +605,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIterator(colIx, recs[minIx].getField(colIx), recs[maxIx].getField(colIx), true); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(maxIx + 1, recIx); @@ -614,7 +614,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = 0; iter = table.indexIterator(colIx, null, null, true); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -626,7 +626,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIterator(colIx, recs[minIx].getField(colIx), recs[maxIx].getField(colIx), false); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(minIx - 1, recIx); @@ -635,7 +635,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { recIx = recordCnt - 1; iter = table.indexIterator(colIx, null, null, false); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -653,7 +653,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() - 1); iter = table.indexIteratorAfter(colIx, startValue); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -663,7 +663,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { startValue.setLongValue(recs[recIx].getField(colIx).getLongValue() + 1); iter = table.indexIteratorBefore(colIx, startValue); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -676,26 +676,26 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); for (int i = 0; i < 2; i++) { if (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } } --recIx; for (int i = 0; i < 2; i++) { if (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } } ++recIx; for (int i = 0; i < 2; i++) { if (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } } while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -706,26 +706,26 @@ public class DBIndexedTableTest extends AbstractGenericTest { --recIx; for (int i = 0; i < 2; i++) { if (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } } ++recIx; for (int i = 0; i < 2; i++) { if (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } } --recIx; for (int i = 0; i < 2; i++) { if (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } } while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -735,13 +735,13 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorAfter(colIx, recs[recIx].getField(colIx)); for (int i = 0; i < 3; i++) { if (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } } assertEquals(recordCnt - 1, recIx); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -751,13 +751,13 @@ public class DBIndexedTableTest extends AbstractGenericTest { iter = table.indexIteratorBefore(colIx, recs[recIx].getField(colIx)); for (int i = 0; i < 3; i++) { if (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[--recIx], rec); } } assertEquals(0, recIx); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -870,7 +870,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { private void deleteIteratedRecords(int recordCnt, int testColIx, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize); } @@ -938,7 +938,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { private void deleteIteratedIndexFields(int recordCnt, int testColIx, long keyIncrement, int varDataSize) throws Exception { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, recordCnt, varDataSize); } @@ -956,7 +956,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { int fieldCnt = 0; Field lastField = null; ArrayList fieldList = new ArrayList<>(); - for (Record rec : recs) { + for (DBRecord rec : recs) { Field f = rec.getField(testColIx); if (lastField == null || !lastField.equals(f)) { lastField = f; @@ -1009,7 +1009,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { int fieldCnt = 0; Field lastField = null; ArrayList fieldList = new ArrayList<>(); - for (Record rec : recs) { + for (DBRecord rec : recs) { Field f = rec.getField(testColIx); if (lastField == null || !lastField.equals(f)) { lastField = f; @@ -1037,7 +1037,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { } } - private int findStart(Record[] recs, int startIx, int colIx) { + private int findStart(DBRecord[] recs, int startIx, int colIx) { Field f = recs[startIx].getField(colIx); --startIx; while (startIx >= 0 && f.equals(recs[startIx].getField(colIx))) { @@ -1049,7 +1049,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { return ++startIx; } - private int findEnd(Record[] recs, int startIx, int colIx) { + private int findEnd(DBRecord[] recs, int startIx, int colIx) { Field f = recs[startIx].getField(colIx); ++startIx; while (startIx < recs.length && f.equals(recs[startIx].getField(colIx))) { @@ -1061,7 +1061,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { return --startIx; } - private class RecColumnComparator implements Comparator { + private class RecColumnComparator implements Comparator { final int columnIx; @@ -1073,7 +1073,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ @Override - public int compare(Record rec1, Record rec2) { + public int compare(DBRecord rec1, DBRecord rec2) { int r = rec1.getField(columnIx).compareTo(rec2.getField(columnIx)); if (r == 0) { if (rec1.getKey() == rec2.getKey()) { @@ -1156,7 +1156,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { @Test public void testRecordIteratorExtents() throws IOException { - Record[] recs = null; + DBRecord[] recs = null; recs = createOrderedRecordRange(DBTestUtils.SINGLE_SHORT, 30, 2, 1); Table table = dbh.getTable(table1Name); assertEquals(recs.length, table.getRecordCount()); @@ -1174,17 +1174,17 @@ public class DBIndexedTableTest extends AbstractGenericTest { Field maxField = new ShortField(Short.MAX_VALUE); RecordIterator iter = table.indexIterator(colIx, minField, maxField, false); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(recIx, -1); } - private Record[] createOrderedRecordRange(int schemaType, int recordCnt, long keyIncrement, + private DBRecord[] createOrderedRecordRange(int schemaType, int recordCnt, long keyIncrement, int varDataSize) throws IOException { long txId = dbh.startTransaction(); Table table = DBTestUtils.createLongKeyTable(dbh, table1Name, schemaType, true, false); - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int key = 0; key < recordCnt; key++) { try { recs[key] = DBTestUtils.createMidRangeRecord(table, key, varDataSize, true); @@ -1220,7 +1220,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { @Test public void testConsistencyAndIndexRebuild() throws IOException { - Record[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, ITER_REC_CNT, 10); + DBRecord[] recs = createRandomTableRecords(DBTestUtils.ALL_TYPES, ITER_REC_CNT, 10); long txId = dbh.startTransaction(); try { @@ -1240,7 +1240,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { int recIx = 0; RecordIterator iter = table.indexIterator(colIx); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(ITER_REC_CNT, recIx); @@ -1254,7 +1254,7 @@ public class DBIndexedTableTest extends AbstractGenericTest { int recIx = 0; RecordIterator iter = table.indexIterator(colIx); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(ITER_REC_CNT, recIx); diff --git a/Ghidra/Framework/DB/src/test/java/db/DBLongKeyChainedBufferUseTest.java b/Ghidra/Framework/DB/src/test/java/db/DBLongKeyChainedBufferUseTest.java index 1de9a8c055..478f25a817 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBLongKeyChainedBufferUseTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBLongKeyChainedBufferUseTest.java @@ -77,7 +77,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { // Add even keys for (int k = 0; k < 256; k += 2) { - Record rec = schema.createRecord(k); + DBRecord rec = schema.createRecord(k); rec.setString(0, getBigString("a", k)); rec.setString(1, getSmallString("b", k)); rec.setLongValue(2, 0x2222222222222222L); @@ -89,7 +89,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { // Add odd keys for (int k = 1; k < 256; k += 2) { - Record rec = schema.createRecord(k); + DBRecord rec = schema.createRecord(k); rec.setString(0, getBigString("a", k)); rec.setString(1, getSmallString("b", k)); rec.setLongValue(2, 0x2222222222222222L); @@ -116,7 +116,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { // Add even keys for (int k = 0; k < 256; k += 2) { - Record rec = schema.createRecord(k); + DBRecord rec = schema.createRecord(k); rec.setString(0, getSmallString("a", k)); rec.setString(1, getSmallString("b", k)); rec.setLongValue(2, 0x2222222222222222L); @@ -128,7 +128,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { // Add odd keys for (int k = 1; k < 256; k += 2) { - Record rec = schema.createRecord(k); + DBRecord rec = schema.createRecord(k); rec.setString(0, getSmallString("a", k)); rec.setString(1, getSmallString("b", k)); rec.setLongValue(2, 0x2222222222222222L); @@ -143,7 +143,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { return table; } - private void assertPrimitiveColumns(Record rec) { + private void assertPrimitiveColumns(DBRecord rec) { Assert.assertEquals(0x2222222222222222L, rec.getLongValue(2)); Assert.assertEquals((byte) 0x33, rec.getByteValue(3)); Assert.assertEquals((short) 0x4444, rec.getShortValue(4)); @@ -156,7 +156,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { Table table = fillTableBigRecs(256); for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); Assert.assertEquals(getBigString("a", k), rec.getString(0)); Assert.assertEquals(getSmallString("b", k), rec.getString(1)); assertPrimitiveColumns(rec); @@ -170,7 +170,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { Table table = fillTableSmallRecs(256); for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); Assert.assertEquals(rec.getString(0), getSmallString("a", k)); Assert.assertEquals(rec.getString(1), getSmallString("b", k)); assertPrimitiveColumns(rec); @@ -187,14 +187,14 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { // Update even keys for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); rec.setString(0, getSmallString("a", k)); table.putRecord(rec); } // Update odd keys for (int k = 1; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); rec.setString(0, getSmallString("a", k)); table.putRecord(rec); } @@ -202,7 +202,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { dbh.endTransaction(txId, true); for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); Assert.assertEquals(rec.getString(0), getSmallString("a", k)); Assert.assertEquals(rec.getString(1), getSmallString("b", k)); assertPrimitiveColumns(rec); @@ -219,14 +219,14 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { // Update even keys for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); rec.setString(1, getBigString("b", k, 3)); table.putRecord(rec); } // Update odd keys for (int k = 1; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); rec.setString(1, getBigString("b", k, 3)); table.putRecord(rec); } @@ -234,7 +234,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { dbh.endTransaction(txId, true); for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); Assert.assertEquals(rec.getString(0), getBigString("a", k)); Assert.assertEquals(rec.getString(1), getBigString("b", k, 3)); assertPrimitiveColumns(rec); @@ -253,14 +253,14 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { // Update even keys for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); rec.setString(1, getBigString("b", k, 4)); table.putRecord(rec); } // Update odd keys for (int k = 1; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); rec.setString(1, getBigString("b", k, 4)); table.putRecord(rec); } @@ -268,7 +268,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { dbh.endTransaction(txId, true); for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); Assert.assertEquals(rec.getString(0), getBigString("a", k)); Assert.assertEquals(rec.getString(1), getBigString("b", k, 4)); assertPrimitiveColumns(rec); @@ -285,14 +285,14 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { // Update even keys for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); rec.setString(1, getBigString("b", k)); table.putRecord(rec); } // Update odd keys for (int k = 1; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); rec.setString(1, getBigString("b", k)); table.putRecord(rec); } @@ -300,7 +300,7 @@ public class DBLongKeyChainedBufferUseTest extends AbstractGenericTest { dbh.endTransaction(txId, true); for (int k = 0; k < 256; k += 2) { - Record rec = table.getRecord(k); + DBRecord rec = table.getRecord(k); Assert.assertEquals(rec.getString(0), getSmallString("a", k)); Assert.assertEquals(rec.getString(1), getBigString("b", k)); assertPrimitiveColumns(rec); diff --git a/Ghidra/Framework/DB/src/test/java/db/DBLongKeyTableTest.java b/Ghidra/Framework/DB/src/test/java/db/DBLongKeyTableTest.java index dc211c4c72..1d50fe9a1e 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBLongKeyTableTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBLongKeyTableTest.java @@ -83,7 +83,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { long txId = dbh.startTransaction(); Table table = DBTestUtils.createLongKeyTable(dbh, table1Name, DBTestUtils.ALL_TYPES, false, false); - Record rec = null; + DBRecord rec = null; try { rec = DBTestUtils.createLongKeyRecord(table, true, varDataSize, true); } @@ -262,14 +262,14 @@ public class DBLongKeyTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createRandomLongKeyTableRecords(Table table, int recordCnt, int varDataSize) + private DBRecord[] createRandomLongKeyTableRecords(Table table, int recordCnt, int varDataSize) throws IOException { long txId = dbh.startTransaction(); if (table == null) { table = DBTestUtils.createLongKeyTable(dbh, table1Name, DBTestUtils.ALL_TYPES, false, false); } - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = DBTestUtils.createLongKeyRecord(table, true, varDataSize, true); @@ -288,13 +288,13 @@ public class DBLongKeyTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createOrderedLongKeyTableRecords(int recordCnt, long keyIncrement, + private DBRecord[] createOrderedLongKeyTableRecords(int recordCnt, long keyIncrement, int varDataSize) throws IOException { long txId = dbh.startTransaction(); Table table = DBTestUtils.createLongKeyTable(dbh, table1Name, DBTestUtils.ALL_TYPES, false, false); long key = 0; - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = DBTestUtils.createRecord(table, key, varDataSize, true); @@ -318,7 +318,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { */ private void iterateLongKeyRecords(boolean testStoredDB, int recordCnt, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomLongKeyTableRecords(null, recordCnt, varDataSize); } @@ -547,7 +547,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { */ private void iterateLongKeys(boolean testStoredDB, int recordCnt, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomLongKeyTableRecords(null, recordCnt, varDataSize); } @@ -723,7 +723,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testForwardDeleteIterator() throws IOException { - Record[] recs = createOrderedLongKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); + DBRecord[] recs = createOrderedLongKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); assertEquals(SMALL_ITER_REC_CNT, table.getRecordCount()); @@ -743,7 +743,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testReverseDeleteIterator() throws IOException { - Record[] recs = createOrderedLongKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); + DBRecord[] recs = createOrderedLongKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); assertEquals(SMALL_ITER_REC_CNT, table.getRecordCount()); @@ -762,22 +762,22 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testGetLongKeyRecordAfter() throws IOException { - Record[] recs = createRandomLongKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // After test for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAfter(recs[i].getKey()); + DBRecord rec = table.getRecordAfter(recs[i].getKey()); assertEquals(rec.getKey(), recs[i + 1].getKey()); } // End test - Record rec = table.getRecordAfter(recs[15999].getKey()); + DBRecord rec = table.getRecordAfter(recs[15999].getKey()); assertNull(rec); } - private int findHoleAfterLongKey(Record[] recs, int startIx) { + private int findHoleAfterLongKey(DBRecord[] recs, int startIx) { for (int i = startIx; i < recs.length - 1; i++) { if ((recs[i].getKey() + 1) < recs[i + 1].getKey()) { return i; @@ -786,7 +786,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { return -1; } - private int findHoleBeforeLongKey(Record[] recs, int startIx) { + private int findHoleBeforeLongKey(DBRecord[] recs, int startIx) { for (int i = startIx; i < recs.length; i++) { if ((recs[i - 1].getKey() + 1) < recs[i].getKey()) { return i; @@ -797,13 +797,13 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testGetLongKeyRecordAtOrAfter() throws IOException { - Record[] recs = createRandomLongKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // At and After tests for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAtOrAfter(recs[i].getKey()); + DBRecord rec = table.getRecordAtOrAfter(recs[i].getKey()); assertEquals(rec.getKey(), recs[i].getKey()); int ix = findHoleAfterLongKey(recs, i + 500); if (ix < 0) { @@ -818,7 +818,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { if (lastKey == Long.MAX_VALUE) { Assert.fail("Bad test data"); } - Record rec = table.getRecordAtOrAfter(lastKey); + DBRecord rec = table.getRecordAtOrAfter(lastKey); assertEquals(rec.getKey(), lastKey); rec = table.getRecordAtOrAfter(lastKey + 1); assertNull(rec); @@ -826,13 +826,13 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testGetLongKeyRecordAtOrBefore() throws IOException { - Record[] recs = createRandomLongKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // At and Before tests for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAtOrBefore(recs[i].getKey()); + DBRecord rec = table.getRecordAtOrBefore(recs[i].getKey()); assertEquals(rec.getKey(), recs[i].getKey()); int ix = findHoleBeforeLongKey(recs, i + 500); if (ix < 0) { @@ -847,7 +847,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { if (firstKey == Long.MIN_VALUE) { Assert.fail("Bad test data"); } - Record rec = table.getRecordAtOrBefore(firstKey); + DBRecord rec = table.getRecordAtOrBefore(firstKey); assertEquals(rec.getKey(), firstKey); rec = table.getRecordAtOrBefore(firstKey - 1); assertNull(rec); @@ -856,7 +856,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testDeleteLongKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomLongKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -870,7 +870,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 1; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); if ((recIx % 1000) == 0) { ++recIx; @@ -882,7 +882,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testForwardDeleteLongKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomLongKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -898,7 +898,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testReverseDeleteLongKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomLongKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -914,7 +914,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { public void testDeleteAllLongKeyRecords() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomLongKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, cnt, 1); Arrays.sort(recs); long txId = dbh.startTransaction(); @@ -934,7 +934,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -942,7 +942,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { private void deleteLongKeyRangeRecords(int count, int startIx, int endIx) throws IOException { - Record[] recs = createRandomLongKeyTableRecords(null, count, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, count, 1); Arrays.sort(recs); long txId = dbh.startTransaction(); @@ -953,7 +953,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = startIx != 0 ? 0 : (endIx + 1); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); if (recIx == startIx) { recIx = endIx + 1; @@ -982,7 +982,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testUpdateLongKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomLongKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -996,7 +996,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1005,7 +1005,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { @Test public void testUpdateBigLongKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomLongKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -1019,7 +1019,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1034,7 +1034,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { iter = table.iterator(); recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1047,7 +1047,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { assertTrue(!dbh.canUndo()); assertTrue(!dbh.canRedo()); - Record[] recs = createRandomLongKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -1058,7 +1058,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { // Update records long txId = dbh.startTransaction(); for (int i = 0; i < cnt; i += 100) { - Record rec = table.getSchema().createRecord(recs[i].getKey()); + DBRecord rec = table.getSchema().createRecord(recs[i].getKey()); DBTestUtils.fillRecord(rec, (BUFFER_SIZE / 8) * BUFFER_SIZE); table.putRecord(rec); } @@ -1074,7 +1074,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1096,7 +1096,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { iter = table.iterator(); recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -1109,7 +1109,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { assertTrue(!dbh.canUndo()); assertTrue(!dbh.canRedo()); - Record[] recs = createRandomLongKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomLongKeyTableRecords(null, cnt, 1); assertTrue(dbh.canUndo()); assertTrue(!dbh.canRedo()); @@ -1144,13 +1144,13 @@ public class DBLongKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); // Add records - Record[] newRecs = new Record[recs.length + 100]; + DBRecord[] newRecs = new DBRecord[recs.length + 100]; System.arraycopy(recs, 0, newRecs, 0, recs.length); txId = dbh.startTransaction(); for (int i = 0; i < 100; i++) { @@ -1174,7 +1174,7 @@ public class DBLongKeyTableTest extends AbstractGenericTest { iter = table.iterator(); recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recs.length, recIx); diff --git a/Ghidra/Framework/DB/src/test/java/db/DBTest.java b/Ghidra/Framework/DB/src/test/java/db/DBTest.java index 0e95e724e1..b2ae5e181c 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBTest.java @@ -464,7 +464,7 @@ public class DBTest extends AbstractGenericTest { } Schema s = tables[1].getSchema(); - Record rec = s.createRecord(1); + DBRecord rec = s.createRecord(1); txId = dbh.startTransaction(); try { diff --git a/Ghidra/Framework/DB/src/test/java/db/DBTestUtils.java b/Ghidra/Framework/DB/src/test/java/db/DBTestUtils.java index 65049ec7a1..5eb3ac557f 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBTestUtils.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBTestUtils.java @@ -271,7 +271,7 @@ public class DBTestUtils { * @param doInsert insert record into table if true * @return Record new record */ - static Record createLongKeyRecord(Table table, boolean randomKey, int varDataSize, + static DBRecord createLongKeyRecord(Table table, boolean randomKey, int varDataSize, boolean doInsert) throws IOException, DuplicateKeyException { long key; if (randomKey) { @@ -281,7 +281,7 @@ public class DBTestUtils { key = table.getMaxKey() + 1; } try { - Record rec = createRecord(table, key, varDataSize, doInsert); + DBRecord rec = createRecord(table, key, varDataSize, doInsert); if (!randomKey) { Assert.assertEquals(rec.getKey(), table.getMaxKey()); } @@ -304,7 +304,7 @@ public class DBTestUtils { * @throws IOException * @throws DuplicateKeyException */ - static Record createFixedKeyRecord(Table table, int varDataSize, boolean doInsert) + static DBRecord createFixedKeyRecord(Table table, int varDataSize, boolean doInsert) throws IOException, DuplicateKeyException { int keyLength = 10; byte[] bytes = new byte[keyLength]; @@ -313,7 +313,7 @@ public class DBTestUtils { key.setBinaryData(bytes); try { - Record rec = createRecord(table, key, varDataSize, doInsert); + DBRecord rec = createRecord(table, key, varDataSize, doInsert); Assert.assertEquals(key, rec.getKeyField()); return rec; } @@ -332,7 +332,7 @@ public class DBTestUtils { * @throws IOException * @throws DuplicateKeyException */ - static Record createBinaryKeyRecord(Table table, int maxKeyLength, int varDataSize, + static DBRecord createBinaryKeyRecord(Table table, int maxKeyLength, int varDataSize, boolean doInsert) throws IOException, DuplicateKeyException { int keyLength = (maxKeyLength < 0) ? -maxKeyLength : DBTestUtils.getRandomKeyLength(maxKeyLength); @@ -342,7 +342,7 @@ public class DBTestUtils { key.setBinaryData(bytes); try { - Record rec = createRecord(table, key, varDataSize, doInsert); + DBRecord rec = createRecord(table, key, varDataSize, doInsert); Assert.assertEquals(key, rec.getKeyField()); return rec; } @@ -361,18 +361,18 @@ public class DBTestUtils { * @throws IOException * @throws DuplicateKeyException record with assigned key already exists in table. */ - static Record createRecord(Table table, long key, int varDataSize, boolean doInsert) + static DBRecord createRecord(Table table, long key, int varDataSize, boolean doInsert) throws IOException, DuplicateKeyException { // Check for duplicate key if (doInsert) { - Record oldRec = table.getRecord(key); + DBRecord oldRec = table.getRecord(key); if (oldRec != null) { throw new DuplicateKeyException(); } } // Create record and fill with data - Record rec = table.getSchema().createRecord(key); + DBRecord rec = table.getSchema().createRecord(key); fillRecord(rec, varDataSize); // Insert record if requested @@ -395,18 +395,18 @@ public class DBTestUtils { * @throws IOException * @throws DuplicateKeyException record with assigned key already exists in table. */ - static Record createRecord(Table table, Field key, int varDataSize, boolean doInsert) + static DBRecord createRecord(Table table, Field key, int varDataSize, boolean doInsert) throws IOException, DuplicateKeyException { // Check for duplicate key if (doInsert) { - Record oldRec = table.getRecord(key); + DBRecord oldRec = table.getRecord(key); if (oldRec != null) { throw new DuplicateKeyException(); } } // Create record and fill with data - Record rec = table.getSchema().createRecord(key); + DBRecord rec = table.getSchema().createRecord(key); fillRecord(rec, varDataSize); // Insert record if requested @@ -455,18 +455,18 @@ public class DBTestUtils { * @throws IOException * @throws DuplicateKeyException record with assigned key already exists in table. */ - static Record createMidRangeRecord(Table table, long key, int varDataSize, boolean doInsert) + static DBRecord createMidRangeRecord(Table table, long key, int varDataSize, boolean doInsert) throws IOException, DuplicateKeyException { // Check for duplicate key if (doInsert) { - Record oldRec = table.getRecord(key); + DBRecord oldRec = table.getRecord(key); if (oldRec != null) { throw new DuplicateKeyException(); } } // Create record and fill with data - Record rec = table.getSchema().createRecord(key); + DBRecord rec = table.getSchema().createRecord(key); fillMidRangeRecord(rec, varDataSize); // Insert record if requested @@ -490,18 +490,18 @@ public class DBTestUtils { * @throws IOException * @throws DuplicateKeyException record with assigned key already exists in table. */ - static Record createMidRangeRecord(Table table, Field key, int varDataSize, boolean doInsert) + static DBRecord createMidRangeRecord(Table table, Field key, int varDataSize, boolean doInsert) throws IOException, DuplicateKeyException { // Check for duplicate key if (doInsert) { - Record oldRec = table.getRecord(key); + DBRecord oldRec = table.getRecord(key); if (oldRec != null) { throw new DuplicateKeyException(); } } // Create record and fill with data - Record rec = table.getSchema().createRecord(key); + DBRecord rec = table.getSchema().createRecord(key); fillMidRangeRecord(rec, varDataSize); // Insert record if requested @@ -521,7 +521,7 @@ public class DBTestUtils { * NOTE: The StringField does not strictly follow the varDataSize paramter. * A value less than 0 results in a null assignment to those fields. */ - static void fillRecord(Record rec, int varDataSize) { + static void fillRecord(DBRecord rec, int varDataSize) { Field[] fields = rec.getFields(); for (int i = 0; i < fields.length; i++) { @@ -586,7 +586,7 @@ public class DBTestUtils { * @param varDataSize number of bytes to fill into all variable length fields. * A value less than 0 results in a null assignment to those fields. */ - static void fillMidRangeRecord(Record rec, int varDataSize) { + static void fillMidRangeRecord(DBRecord rec, int varDataSize) { Field[] fields = rec.getFields(); for (int i = 0; i < fields.length; i++) { diff --git a/Ghidra/Framework/DB/src/test/java/db/DBVarKeyTableTest.java b/Ghidra/Framework/DB/src/test/java/db/DBVarKeyTableTest.java index 3eab9f758c..21cc67ae96 100644 --- a/Ghidra/Framework/DB/src/test/java/db/DBVarKeyTableTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/DBVarKeyTableTest.java @@ -86,7 +86,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { long txId = dbh.startTransaction(); Table table = DBTestUtils.createBinaryKeyTable(dbh, table1Name, DBTestUtils.ALL_TYPES, false); - Record rec = null; + DBRecord rec = null; try { rec = DBTestUtils.createBinaryKeyRecord(table, -MAX_VAR_KEY_LENGTH, varDataSize, true); } @@ -271,13 +271,13 @@ public class DBVarKeyTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createRandomVarKeyTableRecords(Table table, int recordCnt, int varDataSize) + private DBRecord[] createRandomVarKeyTableRecords(Table table, int recordCnt, int varDataSize) throws IOException { long txId = dbh.startTransaction(); if (table == null) { table = DBTestUtils.createBinaryKeyTable(dbh, table1Name, DBTestUtils.ALL_TYPES, false); } - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { recs[i] = @@ -297,7 +297,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { * @param varDataSize size of variable length data fields. * @return Record[] records which were inserted. */ - private Record[] createOrderedVarKeyTableRecords(int recordCnt, long keyIncrement, + private DBRecord[] createOrderedVarKeyTableRecords(int recordCnt, long keyIncrement, int varDataSize) throws IOException { long txId = dbh.startTransaction(); Table table = @@ -305,7 +305,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { long key = 0; Field keyField = new LongField(); - Record[] recs = new Record[recordCnt]; + DBRecord[] recs = new DBRecord[recordCnt]; for (int i = 0; i < recordCnt; i++) { try { keyField.setLongValue(key); @@ -331,7 +331,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { */ private void iterateVarKeyRecords(boolean testStoredDB, int recordCnt, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomVarKeyTableRecords(null, recordCnt, varDataSize); } @@ -349,7 +349,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { int recIx = 0; RecordIterator iter = table.iterator(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -358,7 +358,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { recIx = recordCnt / 2; iter = table.iterator(recs[recIx].getKeyField()); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recordCnt, recIx); @@ -367,7 +367,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { recIx = recordCnt - 1; iter = table.iterator(DBTestUtils.getMaxValue(MAX_VAR_KEY_LENGTH)); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -376,7 +376,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { recIx = recordCnt / 2; iter = table.iterator(recs[recIx].getKeyField()); while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(-1, recIx); @@ -388,7 +388,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { recs[minIx].getKeyField()); recIx = minIx; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(recIx, maxIx + 1); @@ -398,7 +398,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { recs[maxIx].getKeyField()); recIx = maxIx; while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(recs[recIx--], rec); } assertEquals(recIx, minIx - 1); @@ -515,7 +515,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { */ private void iterateVarKeys(boolean testStoredDB, int recordCnt, long keyIncrement, int varDataSize) throws IOException { - Record[] recs = null; + DBRecord[] recs = null; if (keyIncrement == 0) { recs = createRandomVarKeyTableRecords(null, recordCnt, varDataSize); } @@ -692,7 +692,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testForwardDeleteIterator() throws IOException { - Record[] recs = createOrderedVarKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); + DBRecord[] recs = createOrderedVarKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); assertEquals(SMALL_ITER_REC_CNT, table.getRecordCount()); @@ -711,7 +711,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testReverseDeleteIterator() throws IOException { - Record[] recs = createOrderedVarKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); + DBRecord[] recs = createOrderedVarKeyTableRecords(SMALL_ITER_REC_CNT, 2, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); assertEquals(SMALL_ITER_REC_CNT, table.getRecordCount()); @@ -729,22 +729,22 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testGetVarKeyRecordAfter() throws IOException { - Record[] recs = createRandomVarKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // After test for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAfter(recs[i].getKeyField()); + DBRecord rec = table.getRecordAfter(recs[i].getKeyField()); assertEquals(rec.getKeyField(), recs[i + 1].getKeyField()); } // End test - Record rec = table.getRecordAfter(recs[15999].getKeyField()); + DBRecord rec = table.getRecordAfter(recs[15999].getKeyField()); assertNull(rec); } - private int findHoleAfterVarKey(Record[] recs, int startIx) { + private int findHoleAfterVarKey(DBRecord[] recs, int startIx) { for (int i = startIx; i < recs.length - 1; i++) { if (DBTestUtils.increment((BinaryField) recs[i].getKeyField(), MAX_VAR_KEY_LENGTH).compareTo(recs[i + 1].getKeyField()) < 0) { @@ -754,7 +754,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { return -1; } - private int findHoleBeforeVarKey(Record[] recs, int startIx) { + private int findHoleBeforeVarKey(DBRecord[] recs, int startIx) { for (int i = startIx; i < recs.length; i++) { if (DBTestUtils.increment((BinaryField) recs[i - 1].getKeyField(), MAX_VAR_KEY_LENGTH).compareTo(recs[i].getKeyField()) < 0) { @@ -766,13 +766,13 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testGetVarKeyRecordAtOrAfter() throws IOException { - Record[] recs = createRandomVarKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // At and After tests for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAtOrAfter(recs[i].getKeyField()); + DBRecord rec = table.getRecordAtOrAfter(recs[i].getKeyField()); assertEquals(rec.getKeyField(), recs[i].getKeyField()); int ix = findHoleAfterVarKey(recs, i + 500); if (ix < 0) { @@ -785,7 +785,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { // End tests Field lastKey = recs[15999].getKeyField(); - Record rec = table.getRecordAtOrAfter(lastKey); + DBRecord rec = table.getRecordAtOrAfter(lastKey); assertEquals(rec.getKeyField(), lastKey); rec = table.getRecordAtOrAfter( DBTestUtils.increment((BinaryField) lastKey, MAX_VAR_KEY_LENGTH)); @@ -794,13 +794,13 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testGetVarKeyRecordAtOrBefore() throws IOException { - Record[] recs = createRandomVarKeyTableRecords(null, 16000, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, 16000, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); // At and Before tests for (int i = 1000; i < 16000; i += 1000) { - Record rec = table.getRecordAtOrBefore(recs[i].getKeyField()); + DBRecord rec = table.getRecordAtOrBefore(recs[i].getKeyField()); assertEquals(rec.getKeyField(), recs[i].getKeyField()); int ix = findHoleBeforeVarKey(recs, i + 500); if (ix < 0) { @@ -813,7 +813,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { // End tests Field firstKey = recs[0].getKeyField(); - Record rec = table.getRecordAtOrBefore(firstKey); + DBRecord rec = table.getRecordAtOrBefore(firstKey); assertEquals(rec.getKeyField(), firstKey); rec = table.getRecordAtOrBefore( DBTestUtils.decrement((BinaryField) firstKey, MAX_VAR_KEY_LENGTH)); @@ -823,7 +823,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testDeleteVarKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomVarKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -837,7 +837,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 1; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); if ((recIx % 1000) == 0) { ++recIx; @@ -849,7 +849,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testForwardDeleteVarKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomVarKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -865,7 +865,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testReverseDeleteVarKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomVarKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -881,7 +881,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { public void testDeleteAllVarKeyRecords() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomVarKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -901,7 +901,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -909,7 +909,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { private void deleteVarKeyRangeRecords(int count, int startIx, int endIx) throws IOException { - Record[] recs = createRandomVarKeyTableRecords(null, count, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, count, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -920,7 +920,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = startIx != 0 ? 0 : (endIx + 1); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); if (recIx == startIx) { recIx = endIx + 1; @@ -943,7 +943,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testUpdateVarKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomVarKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, cnt, 1); //Record[] recs = createOrderedVarKeyTableRecords(cnt, 1, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -958,7 +958,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -967,7 +967,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { @Test public void testUpdateBigVarKeyRecord() throws IOException { int cnt = SMALL_ITER_REC_CNT; - Record[] recs = createRandomVarKeyTableRecords(null, cnt, 1); + DBRecord[] recs = createRandomVarKeyTableRecords(null, cnt, 1); Arrays.sort(recs); Table table = dbh.getTable(table1Name); @@ -981,7 +981,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { RecordIterator iter = table.iterator(); int recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); @@ -996,7 +996,7 @@ public class DBVarKeyTableTest extends AbstractGenericTest { iter = table.iterator(); recIx = 0; while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(recs[recIx++], rec); } assertEquals(cnt, recIx); diff --git a/Ghidra/Framework/DB/src/test/java/db/TableConcurrencyTest.java b/Ghidra/Framework/DB/src/test/java/db/TableConcurrencyTest.java index 2164931e38..813864f8d8 100644 --- a/Ghidra/Framework/DB/src/test/java/db/TableConcurrencyTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/TableConcurrencyTest.java @@ -53,7 +53,7 @@ public class TableConcurrencyTest extends AbstractGenericTest { schema2 = table2.getSchema(); for (byte i = 0; i < 100; i++) { - Record rec = schema1.createRecord(i); + DBRecord rec = schema1.createRecord(i); rec.setLongValue(0, i); table1.putRecord(rec); @@ -226,7 +226,7 @@ public class TableConcurrencyTest extends AbstractGenericTest { table1.deleteRecord(10);// iterator already primed assertTrue(iter.hasNext()); - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(10, rec.getKey()); assertTrue(iter.hasNext()); @@ -271,7 +271,7 @@ public class TableConcurrencyTest extends AbstractGenericTest { table1.deleteRecord(10);// iterator already primed assertTrue(iter.hasPrevious()); - Record rec = iter.previous(); + DBRecord rec = iter.previous(); assertEquals(10, rec.getKey()); assertTrue(iter.hasPrevious()); @@ -458,7 +458,7 @@ public class TableConcurrencyTest extends AbstractGenericTest { table2.deleteRecord(getField((byte) 10));// iterator already primed assertTrue(iter.hasNext()); - Record rec = iter.next(); + DBRecord rec = iter.next(); assertEquals(getField((byte) 10), rec.getKeyField()); assertTrue(iter.hasNext()); diff --git a/Ghidra/Framework/DB/src/test/java/db/TableTest.java b/Ghidra/Framework/DB/src/test/java/db/TableTest.java index 8c26921b80..02fa5ca9f6 100644 --- a/Ghidra/Framework/DB/src/test/java/db/TableTest.java +++ b/Ghidra/Framework/DB/src/test/java/db/TableTest.java @@ -227,10 +227,10 @@ public class TableTest extends AbstractGenericTest { // // } // } - private Record generateRandomStringRecord(Schema schema, List keyList) { + private DBRecord generateRandomStringRecord(Schema schema, List keyList) { long key = (long) (Math.random() * 1000000000F); keyList.add(key); - Record record = schema.createRecord(key); + DBRecord record = schema.createRecord(key); record.setString(0, getRandomSizeString(200));// this size string causes 10 records per buffer return record; } @@ -270,7 +270,7 @@ public class TableTest extends AbstractGenericTest { int n = bufferCount * RECORD_KEY_SPACING; for (int i = 0; i < n; i++) { - Record rec = schema.createRecord(i * RECORD_KEY_SPACING); + DBRecord rec = schema.createRecord(i * RECORD_KEY_SPACING); if (fixedSize) { rec.setLongValue(0, i); rec.setIntValue(1, i); diff --git a/Ghidra/Framework/FileSystem/src/test/java/db/RecoveryDBTest.java b/Ghidra/Framework/FileSystem/src/test/java/db/RecoveryDBTest.java index b797454d22..fb447ae6a2 100644 --- a/Ghidra/Framework/FileSystem/src/test/java/db/RecoveryDBTest.java +++ b/Ghidra/Framework/FileSystem/src/test/java/db/RecoveryDBTest.java @@ -124,7 +124,7 @@ public class RecoveryDBTest extends AbstractGenericTest { private void tableFill(Table table, int recCnt, String baseName) throws Exception { for (int i = 0; i < recCnt; i++) { - Record rec = SCHEMA.createRecord(i); + DBRecord rec = SCHEMA.createRecord(i); rec.setString(0, baseName + i); table.putRecord(rec); } @@ -152,12 +152,12 @@ public class RecoveryDBTest extends AbstractGenericTest { assertEquals(RECORD_COUNT / 2, table1.getRecordCount()); for (int i = 0; i < RECORD_COUNT; i += 2) { - Record rec = table1.getRecord(i); + DBRecord rec = table1.getRecord(i); assertNull(rec); } for (int i = 1; i < RECORD_COUNT; i += 2) { - Record rec = table1.getRecord(i); + DBRecord rec = table1.getRecord(i); assertNotNull(rec); assertEquals("initTable1_" + i, rec.getString(0)); } @@ -171,7 +171,7 @@ public class RecoveryDBTest extends AbstractGenericTest { } for (int i = 1; i < RECORD_COUNT; i += 2) { - Record rec = table2.getRecord(i); + DBRecord rec = table2.getRecord(i); assertNotNull(rec); assertEquals("initTable2_" + i, rec.getString(0)); } @@ -207,12 +207,12 @@ public class RecoveryDBTest extends AbstractGenericTest { assertEquals(RECORD_COUNT / 2, table1.getRecordCount()); for (int i = 0; i < RECORD_COUNT; i += 2) { - Record rec = table1.getRecord(i); + DBRecord rec = table1.getRecord(i); assertNull(rec); } for (int i = 1; i < RECORD_COUNT; i += 2) { - Record rec = table1.getRecord(i); + DBRecord rec = table1.getRecord(i); assertNotNull(rec); assertEquals("initTable1_" + i, rec.getString(0)); } @@ -259,12 +259,12 @@ public class RecoveryDBTest extends AbstractGenericTest { assertEquals(RECORD_COUNT / 2, table1.getRecordCount()); for (int i = 0; i < RECORD_COUNT; i += 2) { - Record rec = table1.getRecord(i); + DBRecord rec = table1.getRecord(i); assertNull(rec); } for (int i = 1; i < RECORD_COUNT; i += 2) { - Record rec = table1.getRecord(i); + DBRecord rec = table1.getRecord(i); assertNotNull(rec); assertEquals("initTable1_" + i, rec.getString(0)); } @@ -278,7 +278,7 @@ public class RecoveryDBTest extends AbstractGenericTest { } for (int i = 1; i < RECORD_COUNT; i += 2) { - Record rec = table2.getRecord(i); + DBRecord rec = table2.getRecord(i); assertNotNull(rec); assertEquals("initTable2_" + i, rec.getString(0)); } @@ -315,12 +315,12 @@ public class RecoveryDBTest extends AbstractGenericTest { assertEquals(RECORD_COUNT / 2, table1.getRecordCount()); for (int i = 0; i < RECORD_COUNT; i += 2) { - Record rec = table1.getRecord(i); + DBRecord rec = table1.getRecord(i); assertNull(rec); } for (int i = 1; i < RECORD_COUNT; i += 2) { - Record rec = table1.getRecord(i); + DBRecord rec = table1.getRecord(i); assertNotNull(rec); assertEquals("initTable1_" + i, rec.getString(0)); } @@ -334,7 +334,7 @@ public class RecoveryDBTest extends AbstractGenericTest { } for (int i = 1; i < RECORD_COUNT; i += 2) { - Record rec = table2.getRecord(i); + DBRecord rec = table2.getRecord(i); assertNotNull(rec); assertEquals("initTable2_" + i, rec.getString(0)); } diff --git a/Ghidra/Framework/FileSystem/src/test/java/ghidra/framework/store/db/PackedDatabaseTest.java b/Ghidra/Framework/FileSystem/src/test/java/ghidra/framework/store/db/PackedDatabaseTest.java index 7592b0a9e7..2e789d4519 100644 --- a/Ghidra/Framework/FileSystem/src/test/java/ghidra/framework/store/db/PackedDatabaseTest.java +++ b/Ghidra/Framework/FileSystem/src/test/java/ghidra/framework/store/db/PackedDatabaseTest.java @@ -84,7 +84,7 @@ public class PackedDatabaseTest extends AbstractGenericTest { dbh = new PackedDBHandle("MyContent"); long txId = dbh.startTransaction(); Table table = dbh.createTable("MyTable", TEST_SCHEMA); - Record rec = TEST_SCHEMA.createRecord(1); + DBRecord rec = TEST_SCHEMA.createRecord(1); rec.setString(0, "String1"); table.putRecord(rec); dbh.endTransaction(txId, true); @@ -115,7 +115,7 @@ public class PackedDatabaseTest extends AbstractGenericTest { assertNotNull(table); assertEquals(1, table.getRecordCount()); - Record rec = table.getRecord(1); + DBRecord rec = table.getRecord(1); assertNotNull(rec); assertEquals("String1", rec.getString(0)); diff --git a/Ghidra/Framework/Project/src/main/java/ghidra/framework/data/MetadataManager.java b/Ghidra/Framework/Project/src/main/java/ghidra/framework/data/MetadataManager.java index f02ece87f5..cdc6283ced 100644 --- a/Ghidra/Framework/Project/src/main/java/ghidra/framework/data/MetadataManager.java +++ b/Ghidra/Framework/Project/src/main/java/ghidra/framework/data/MetadataManager.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -35,7 +34,7 @@ class MetadataManager { if (table != null) { RecordIterator iterator = table.iterator(); while(iterator.hasNext()) { - Record record = iterator.next(); + DBRecord record = iterator.next(); String key = record.getString(0); String value = record.getString(1); metadata.put(key, value); @@ -58,7 +57,7 @@ class MetadataManager { while(keyIterator.hasNext()) { String key = keyIterator.next(); String value = metadata.get(key); - Record record = SCHEMA.createRecord(id++); + DBRecord record = SCHEMA.createRecord(id++); record.setString(0, key); record.setString(1, value); table.putRecord(record); diff --git a/Ghidra/Framework/Project/src/main/java/ghidra/framework/data/OptionsDB.java b/Ghidra/Framework/Project/src/main/java/ghidra/framework/data/OptionsDB.java index 7c029c01b0..8156f756cf 100644 --- a/Ghidra/Framework/Project/src/main/java/ghidra/framework/data/OptionsDB.java +++ b/Ghidra/Framework/Project/src/main/java/ghidra/framework/data/OptionsDB.java @@ -97,7 +97,7 @@ class OptionsDB extends AbstractOptions { return false; } RecordIterator iterator = propertyTable.iterator(new StringField(newSubListPath)); - Record rec = iterator.next(); + DBRecord rec = iterator.next(); if (rec != null) { String keyName = ((StringField) rec.getKeyField()).getString(); if (keyName.startsWith(newSubListPath)) { @@ -106,7 +106,7 @@ class OptionsDB extends AbstractOptions { } // move records - ArrayList list = new ArrayList<>(); + ArrayList list = new ArrayList<>(); rec = propertyTable.getRecord(new StringField(oldPath)); if (rec != null) { propertyTable.deleteRecord(new StringField(oldPath)); @@ -127,7 +127,7 @@ class OptionsDB extends AbstractOptions { break; } } - for (Record updatedRec : list) { + for (DBRecord updatedRec : list) { propertyTable.putRecord(updatedRec); } @@ -141,7 +141,7 @@ class OptionsDB extends AbstractOptions { // remove records RecordIterator iterator = propertyTable.iterator(new StringField(path)); while (iterator.hasNext()) { - Record rec = iterator.next(); + DBRecord rec = iterator.next(); String keyName = ((StringField) rec.getKeyField()).getString(); if (keyName.equals(path)) { iterator.delete(); @@ -186,7 +186,7 @@ class OptionsDB extends AbstractOptions { if (propertyTable != null) { RecordIterator recIt = propertyTable.iterator(); while (recIt.hasNext()) { - Record rec = recIt.next(); + DBRecord rec = recIt.next(); names.add(rec.getKeyField().getString()); } } @@ -208,7 +208,7 @@ class OptionsDB extends AbstractOptions { if (propertyTable != null) { RecordIterator recIt = propertyTable.iterator(); while (recIt.hasNext()) { - Record rec = recIt.next(); + DBRecord rec = recIt.next(); String key = rec.getKeyField().getString(); if (optionName.equals(key)) { return true; @@ -222,7 +222,7 @@ class OptionsDB extends AbstractOptions { return false; } - private Record getPropertyRecord(String propertyName) { + private DBRecord getPropertyRecord(String propertyName) { if (propertyTable == null) { return null; } @@ -238,7 +238,7 @@ class OptionsDB extends AbstractOptions { return null; } - private void putRecord(Record rec) { + private void putRecord(DBRecord rec) { try { if (propertyTable == null) { propertyTable = @@ -265,7 +265,7 @@ class OptionsDB extends AbstractOptions { @Override public Object getCurrentValue() { if (!isCached) { - Record rec = getPropertyRecord(getName()); + DBRecord rec = getPropertyRecord(getName()); if (rec == null) { value = getDefaultValue(); } @@ -295,7 +295,7 @@ class OptionsDB extends AbstractOptions { removePropertyFromDB(getName()); } else { - Record rec = PROPERTY_SCHEMA.createRecord(new StringField(getName())); + DBRecord rec = PROPERTY_SCHEMA.createRecord(new StringField(getName())); OptionType optionType = getOptionType(); rec.setByteValue(TYPE_COL, (byte) (optionType.ordinal())); rec.setString(VALUE_COL, optionType.convertObjectToString(newValue)); @@ -321,7 +321,7 @@ class OptionsDB extends AbstractOptions { Object defaultValue) { if (type == OptionType.NO_TYPE) { - Record record = getPropertyRecord(optionName); + DBRecord record = getPropertyRecord(optionName); if (record != null) { type = OptionType.values()[record.getByteValue(TYPE_COL)]; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DBObjectCache.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DBObjectCache.java index 5bb75c0c1c..e2e766c868 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DBObjectCache.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DBObjectCache.java @@ -22,7 +22,7 @@ import java.lang.ref.ReferenceQueue; import java.lang.ref.WeakReference; import java.util.*; -import db.Record; +import db.DBRecord; import ghidra.program.model.address.KeyRange; /** @@ -81,13 +81,13 @@ public class DBObjectCache { * Retrieves the database object with the given record and associated key from the cache. * This form should be used in conjunction with record iterators to avoid unnecessary * record query during a possible object refresh. To benefit from the record the cached - * object must implement the {@link DatabaseObject#refresh(Record)} method which by default + * object must implement the {@link DatabaseObject#refresh(DBRecord)} method which by default * ignores the record and simply calls {@link DatabaseObject#refresh()}. * @param objectRecord the valid record corresponding to the object to be retrieved and possibly * used to refresh the associated object if found in cache * @return the cached object or null if the object with that key is not currently cached. */ - public synchronized T get(Record objectRecord) { + public synchronized T get(DBRecord objectRecord) { long key = objectRecord.getKey(); KeyedSoftReference ref = map.get(key); if (ref != null) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DataTypeArchiveDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DataTypeArchiveDB.java index ea02a2a1f5..5cb68fb9c3 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DataTypeArchiveDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DataTypeArchiveDB.java @@ -384,7 +384,7 @@ public class DataTypeArchiveDB extends DomainObjectAdapterDB private void createDatabase() throws IOException { table = dbh.createTable(TABLE_NAME, SCHEMA); - Record record = SCHEMA.createRecord(new StringField(ARCHIVE_DB_VERSION)); + DBRecord record = SCHEMA.createRecord(new StringField(ARCHIVE_DB_VERSION)); record.setString(0, Integer.toString(DB_VERSION)); table.putRecord(record); } @@ -430,13 +430,13 @@ public class DataTypeArchiveDB extends DomainObjectAdapterDB private void upgradeDatabase() throws IOException { table = dbh.getTable(TABLE_NAME); - Record record = SCHEMA.createRecord(new StringField(ARCHIVE_DB_VERSION)); + DBRecord record = SCHEMA.createRecord(new StringField(ARCHIVE_DB_VERSION)); record.setString(0, Integer.toString(DB_VERSION)); table.putRecord(record); } private int getStoredVersion() throws IOException { - Record record = table.getRecord(new StringField(ARCHIVE_DB_VERSION)); + DBRecord record = table.getRecord(new StringField(ARCHIVE_DB_VERSION)); // DB Version // if record does not exist return 1; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DataTypeArchiveDBChangeSet.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DataTypeArchiveDBChangeSet.java index bdb12f94c7..70a2ef9adb 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DataTypeArchiveDBChangeSet.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DataTypeArchiveDBChangeSet.java @@ -291,7 +291,7 @@ class DataTypeArchiveDBChangeSet implements DataTypeArchiveChangeSet, DomainObje } RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); ids.add(rec.getLongValue(0)); } } @@ -321,7 +321,7 @@ class DataTypeArchiveDBChangeSet implements DataTypeArchiveChangeSet, DomainObje private void writeIdRecords(DBHandle dbh, String tableName, Set ids) throws IOException { if (ids.size() > 0) { Table table = dbh.createTable(tableName, STORED_ID_SCHEMA); - Record rec = STORED_ID_SCHEMA.createRecord(0); + DBRecord rec = STORED_ID_SCHEMA.createRecord(0); int key = 1; for (long id : ids) { rec.setKey(key++); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DatabaseObject.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DatabaseObject.java index 915ade6424..44b9fd4100 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DatabaseObject.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/DatabaseObject.java @@ -17,7 +17,7 @@ package ghidra.program.database; import java.util.ConcurrentModificationException; -import db.Record; +import db.DBRecord; import ghidra.util.Lock; /** @@ -140,7 +140,7 @@ abstract public class DatabaseObject { * @param record optional record which may be used to refresh invalid object * @return true if the object is valid. */ - public boolean checkIsValid(Record record) { + public boolean checkIsValid(DBRecord record) { if (deleted) { return false; } @@ -199,7 +199,7 @@ abstract public class DatabaseObject { * object was deleted. Objects that extend this class must implement a refresh method. * If an object can never refresh itself, then it should always return false. */ - protected boolean refresh(Record record) { + protected boolean refresh(DBRecord record) { return refresh(); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/OverlaySpaceAdapterDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/OverlaySpaceAdapterDB.java index d73d3239d0..d0a7aced1b 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/OverlaySpaceAdapterDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/OverlaySpaceAdapterDB.java @@ -54,7 +54,7 @@ class OverlaySpaceAdapterDB { if (table != null) { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(OV_SPACE_NAME_COL); String templateSpaceName = rec.getString(OV_SPACE_BASE_COL); long minOffset = rec.getLongValue(OV_MIN_OFFSET_COL); @@ -86,7 +86,7 @@ class OverlaySpaceAdapterDB { if (table == null) { table = db.createTable(TABLE_NAME, SCHEMA); } - Record rec = SCHEMA.createRecord(table.getKey()); + DBRecord rec = SCHEMA.createRecord(table.getKey()); rec.setString(0, ovSpace.getName()); rec.setString(1, ovSpace.getOverlayedSpace().getName()); rec.setLongValue(OV_MIN_OFFSET_COL, ovSpace.getMinOffset()); @@ -105,7 +105,7 @@ class OverlaySpaceAdapterDB { if (table != null) { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(0); if (name.equals(spaceName)) { it.delete(); @@ -127,7 +127,7 @@ class OverlaySpaceAdapterDB { if (table != null) { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); OverlayAddressSpace space = map.remove(rec.getKey()); if (space != null) { //maxId = Math.max(maxId, space.getUnique()); @@ -173,7 +173,7 @@ class OverlaySpaceAdapterDB { if (table != null) { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(0); if (oldName.equals(spaceName)) { it.delete(); @@ -202,7 +202,7 @@ class OverlaySpaceAdapterDB { if (table != null) { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String oldUnderlyingSpaceName = rec.getString(OV_SPACE_BASE_COL); AddressSpace space = addrFactory.getAddressSpace(oldUnderlyingSpaceName); if (space != null && space.isNonLoadedMemorySpace()) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDB.java index 5b7d3cd4cf..331393df72 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDB.java @@ -1155,7 +1155,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM if (name.equals(newName)) { return; } - Record record = table.getRecord(new StringField(PROGRAM_NAME)); + DBRecord record = table.getRecord(new StringField(PROGRAM_NAME)); record.setString(0, newName); table.putRecord(record); getTreeManager().setProgramName(name, newName); @@ -1170,7 +1170,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM } private void refreshName() throws IOException { - Record record = table.getRecord(new StringField(PROGRAM_NAME)); + DBRecord record = table.getRecord(new StringField(PROGRAM_NAME)); name = record.getString(0); } @@ -1265,7 +1265,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM } private long getStoredBaseImageOffset() throws IOException { - Record rec = table.getRecord(new StringField(IMAGE_OFFSET)); + DBRecord rec = table.getRecord(new StringField(IMAGE_OFFSET)); if (rec != null) { return (new BigInteger(rec.getString(0), 16)).longValue(); } @@ -1325,7 +1325,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM if (commit) { try { - Record record = SCHEMA.createRecord(new StringField(IMAGE_OFFSET)); + DBRecord record = SCHEMA.createRecord(new StringField(IMAGE_OFFSET)); record.setString(0, Long.toHexString(base.getOffset())); table.putRecord(record); @@ -1384,7 +1384,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM private void createDatabase() throws IOException { table = dbh.createTable(TABLE_NAME, SCHEMA); - Record record = SCHEMA.createRecord(new StringField(PROGRAM_NAME)); + DBRecord record = SCHEMA.createRecord(new StringField(PROGRAM_NAME)); record.setString(0, name); table.putRecord(record); @@ -1432,7 +1432,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM if (table == null) { throw new IOException("Unsupported File Content"); } - Record record = table.getRecord(new StringField(PROGRAM_NAME)); + DBRecord record = table.getRecord(new StringField(PROGRAM_NAME)); name = record.getString(0); record = table.getRecord(new StringField(LANGUAGE_ID)); @@ -1501,7 +1501,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM table = dbh.getTable(TABLE_NAME); Field key = new StringField(PROGRAM_DB_VERSION); String versionStr = Integer.toString(DB_VERSION); - Record record = table.getRecord(key); + DBRecord record = table.getRecord(key); if (record != null && versionStr.equals(record.getString(0))) { return; // already has correct version } @@ -1534,7 +1534,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM } public int getStoredVersion() throws IOException { - Record record = table.getRecord(new StringField(PROGRAM_DB_VERSION)); + DBRecord record = table.getRecord(new StringField(PROGRAM_DB_VERSION)); if (record != null) { String s = record.getString(0); try { @@ -1549,7 +1549,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM private void checkOldProperties(int openMode, TaskMonitor monitor) throws IOException, VersionException { - Record record = table.getRecord(new StringField(EXECUTE_PATH)); + DBRecord record = table.getRecord(new StringField(EXECUTE_PATH)); if (record != null) { if (openMode == READ_ONLY) { return; // not important, get on path or format will return "unknown" @@ -2098,7 +2098,7 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM translator.fixupInstructions(this, translator.getOldLanguage(), monitor); } - Record record = SCHEMA.createRecord(new StringField(LANGUAGE_ID)); + DBRecord record = SCHEMA.createRecord(new StringField(LANGUAGE_ID)); record.setString(0, languageID.getIdAsString()); table.putRecord(record); record = SCHEMA.createRecord(new StringField(COMPILER_SPEC_ID)); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDBChangeSet.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDBChangeSet.java index 1c72d22338..5eccc4809b 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDBChangeSet.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDBChangeSet.java @@ -542,7 +542,7 @@ class ProgramDBChangeSet implements ProgramChangeSet, DomainObjectDBChangeSet { } RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); ids.add(rec.getLongValue(0)); } } @@ -557,7 +557,7 @@ class ProgramDBChangeSet implements ProgramChangeSet, DomainObjectDBChangeSet { } RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); Address addr1 = addrMap.decodeAddress(rec.getLongValue(0)); Address addr2 = addrMap.decodeAddress(rec.getLongValue(1)); // Memory addresses or external addresses are the only ones that should be in here. @@ -611,7 +611,7 @@ class ProgramDBChangeSet implements ProgramChangeSet, DomainObjectDBChangeSet { private void writeIdRecords(DBHandle dbh, String tableName, Set ids) throws IOException { if (ids.size() > 0) { Table table = dbh.createTable(tableName, STORED_ID_SCHEMA); - Record rec = STORED_ID_SCHEMA.createRecord(0); + DBRecord rec = STORED_ID_SCHEMA.createRecord(0); int key = 1; for (long id : ids) { rec.setKey(key++); @@ -625,7 +625,7 @@ class ProgramDBChangeSet implements ProgramChangeSet, DomainObjectDBChangeSet { throws IOException { if (!set.isEmpty()) { Table table = dbh.createTable(tableName, STORED_ADDRESS_RANGE_SCHEMA); - Record rec = STORED_ADDRESS_RANGE_SCHEMA.createRecord(0); + DBRecord rec = STORED_ADDRESS_RANGE_SCHEMA.createRecord(0); int key = 1; for (KeyRange range : addrMap.getKeyRanges(set, false, false)) { rec.setKey(key++); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramUserDataDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramUserDataDB.java index 4beee3fcbe..b7d7554cc3 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramUserDataDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramUserDataDB.java @@ -324,7 +324,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData registryTable = dbh.createTable(REGISTRY_TABLE_NAME, REGISTRY_SCHEMA, new int[] { PROPERTY_OWNER_COL }); - Record record = SCHEMA.createRecord(new StringField(LANGUAGE_ID)); + DBRecord record = SCHEMA.createRecord(new StringField(LANGUAGE_ID)); record.setString(VALUE_COL, languageID.getIdAsString()); table.putRecord(record); @@ -347,7 +347,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData throw new IOException("Unsupported User Data File Content"); } - Record record = table.getRecord(new StringField(LANGUAGE_ID)); + DBRecord record = table.getRecord(new StringField(LANGUAGE_ID)); languageID = new LanguageID(record.getString(VALUE_COL)); record = table.getRecord(new StringField(LANGUAGE_VERSION)); @@ -377,7 +377,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData private void upgradeDatabase() throws IOException { table = dbh.getTable(TABLE_NAME); - Record record = SCHEMA.createRecord(new StringField(STORED_DB_VERSION)); + DBRecord record = SCHEMA.createRecord(new StringField(STORED_DB_VERSION)); record.setString(VALUE_COL, Integer.toString(DB_VERSION)); table.putRecord(record); } @@ -438,7 +438,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData clearCache(true); - Record record = SCHEMA.createRecord(new StringField(LANGUAGE_ID)); + DBRecord record = SCHEMA.createRecord(new StringField(LANGUAGE_ID)); record.setString(VALUE_COL, languageID.getIdAsString()); table.putRecord(record); @@ -472,7 +472,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData try { for (Field key : registryTable.findRecords(new StringField(owner), PROPERTY_OWNER_COL)) { - Record rec = registryTable.getRecord(key); + DBRecord rec = registryTable.getRecord(key); if (propertyName.equals(rec.getString(PROPERTY_NAME_COL))) { int type = rec.getIntValue(PROPERTY_TYPE_COL); if (propertyType != type) { @@ -495,7 +495,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData } long key = registryTable.getKey(); - Record rec = REGISTRY_SCHEMA.createRecord(key); + DBRecord rec = REGISTRY_SCHEMA.createRecord(key); rec.setString(PROPERTY_OWNER_COL, owner); rec.setString(PROPERTY_NAME_COL, propertyName); rec.setIntValue(PROPERTY_TYPE_COL, propertyType); @@ -526,7 +526,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData return null; } - private PropertyMap getPropertyMap(Record rec) throws IOException { + private PropertyMap getPropertyMap(DBRecord rec) throws IOException { try { PropertyMap map; int type = rec.getIntValue(PROPERTY_TYPE_COL); @@ -579,7 +579,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData try { for (Field key : registryTable.findRecords(new StringField(owner), PROPERTY_OWNER_COL)) { - Record rec = registryTable.getRecord(key); + DBRecord rec = registryTable.getRecord(key); list.add(getPropertyMap(rec)); } } @@ -596,7 +596,7 @@ class ProgramUserDataDB extends DomainObjectAdapterDB implements ProgramUserData propertyMapOwners = new HashSet(); RecordIterator recIter = registryTable.iterator(); while (recIter.hasNext()) { - Record rec = recIter.next(); + DBRecord rec = recIter.next(); propertyMapOwners.add(rec.getString(PROPERTY_OWNER_COL)); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDB.java index 642212f522..7214396bce 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDB.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.bookmark; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; import ghidra.program.model.address.Address; @@ -28,9 +28,9 @@ import ghidra.program.model.listing.BookmarkType; public class BookmarkDB extends DatabaseObject implements Bookmark { private BookmarkDBManager mgr; - private Record record; + private DBRecord record; - BookmarkDB(BookmarkDBManager mgr, DBObjectCache cache, Record record) { + BookmarkDB(BookmarkDBManager mgr, DBObjectCache cache, DBRecord record) { super(cache, record.getKey()); this.mgr = mgr; this.record = record; @@ -46,7 +46,7 @@ public class BookmarkDB extends DatabaseObject implements Bookmark { * Update associated record * @param rec */ - void setRecord(Record rec) { + void setRecord(DBRecord rec) { if (rec.getKey() != key) { throw new IllegalArgumentException("Key mismatch"); } @@ -121,7 +121,7 @@ public class BookmarkDB extends DatabaseObject implements Bookmark { } @Override - protected boolean refresh(Record rec) { + protected boolean refresh(DBRecord rec) { if (rec == null) { rec = mgr.getRecord(key); } @@ -136,7 +136,7 @@ public class BookmarkDB extends DatabaseObject implements Bookmark { * Returns record associated with this bookmark or * null if bookmark has been deleted. */ - Record getRecord() { + DBRecord getRecord() { return checkIsValid() ? record : null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapter.java index 4002d0ca72..5f4af040a4 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -117,7 +116,7 @@ abstract class BookmarkDBAdapter { if (monitor.isCancelled()) { throw new IOException("Upgrade Cancelled"); } - Record rec = it.next(); + DBRecord rec = it.next(); int typeId = getTypeId(rec); tmpAdapter.addType(typeId); Address addr = oldAddrMap.decodeAddress(rec.getLongValue(ADDRESS_COL)); @@ -138,7 +137,7 @@ abstract class BookmarkDBAdapter { if (monitor.isCancelled()) { throw new IOException("Upgrade Cancelled"); } - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec); monitor.setProgress(++cnt); } @@ -151,7 +150,7 @@ abstract class BookmarkDBAdapter { } } - static int getTypeId(Record rec) { + static int getTypeId(DBRecord rec) { long key = rec.getKey(); return (int) (key >> 48); } @@ -181,7 +180,7 @@ abstract class BookmarkDBAdapter { * @return * @throws IOException */ - Record createBookmark(int typeId, String category, long index, String comment) + DBRecord createBookmark(int typeId, String category, long index, String comment) throws IOException { throw new UnsupportedOperationException("Bookmarks are read-only and may not be created"); } @@ -191,7 +190,7 @@ abstract class BookmarkDBAdapter { * @param rec modified bookmark record * @throws IOException */ - void updateRecord(Record rec) throws IOException { + void updateRecord(DBRecord rec) throws IOException { throw new UnsupportedOperationException("Bookmarks are read-only and may not be modified"); } @@ -209,7 +208,7 @@ abstract class BookmarkDBAdapter { * @param id bookmark ID * @return bookmark record or null if not found. */ - abstract Record getRecord(long id) throws IOException; + abstract DBRecord getRecord(long id) throws IOException; /** * Get all bookmark records associated with a specific type and address. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV0.java index 966abb962f..d9b10bb81a 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -55,7 +54,7 @@ class BookmarkDBAdapterV0 extends BookmarkDBAdapter { catch (VersionException e) { throw new AssertException(); } - Record[] oldTypes = oldMgr.getTypeRecords(); + DBRecord[] oldTypes = oldMgr.getTypeRecords(); if (oldTypes.length == 0) { return; } @@ -88,7 +87,7 @@ class BookmarkDBAdapterV0 extends BookmarkDBAdapter { } @Override - Record getRecord(long id) throws IOException { + DBRecord getRecord(long id) throws IOException { return conversionAdapter.getRecord(id); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV1.java index a7ee330b33..31bb32b84b 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV1.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -75,7 +74,7 @@ class BookmarkDBAdapterV1 extends BookmarkDBAdapter { AddressSet set = new AddressSet(); RecordIterator recordIter = getRecordsByType(typeId); while (recordIter.hasNext()) { - Record rec = recordIter.next(); + DBRecord rec = recordIter.next(); Address addr = addrMap.decodeAddress(rec.getLongValue(V1_ADDRESS_COL)); set.addRange(addr, addr); } @@ -88,7 +87,7 @@ class BookmarkDBAdapterV1 extends BookmarkDBAdapter { Field fv = new LongField(typeId); RecordIterator recordIter = table.indexIterator(V1_TYPE_ID_COL, fv, fv, true); while (recordIter.hasNext()) { - Record rec = recordIter.next(); + DBRecord rec = recordIter.next(); String cat = demangleTypeCategory(rec.getString(V1_TYPE_CATEGORY_COL)); set.add(cat); } @@ -99,13 +98,13 @@ class BookmarkDBAdapterV1 extends BookmarkDBAdapter { } @Override - Record getRecord(long id) throws IOException { + DBRecord getRecord(long id) throws IOException { return convertV1Record(table.getRecord(id)); } - private static Record convertV1Record(Record record) { + private static DBRecord convertV1Record(DBRecord record) { long key = record.getLongValue(V1_TYPE_ID_COL) << 48 | (record.getKey() & 0xffffffffL); - Record rec = BookmarkDBAdapter.SCHEMA.createRecord(key); + DBRecord rec = BookmarkDBAdapter.SCHEMA.createRecord(key); rec.setLongValue(BookmarkDBAdapter.ADDRESS_COL, record.getLongValue(V1_ADDRESS_COL)); rec.setString(BookmarkDBAdapter.CATEGORY_COL, demangleTypeCategory(record.getString(V1_TYPE_CATEGORY_COL))); @@ -177,10 +176,10 @@ class BookmarkDBAdapterV1 extends BookmarkDBAdapter { //================================================================================================== private class BatchRecordIterator implements RecordIterator { - private ListIterator iter; + private ListIterator iter; BatchRecordIterator(int typeId, long start, long end) throws IOException { - ArrayList list = new ArrayList(); + ArrayList list = new ArrayList(); Field sf = new LongField(start); Field ef = new LongField(end); RecordIterator recIter = table.indexIterator(V1_ADDRESS_COL, sf, ef, true); @@ -201,12 +200,12 @@ class BookmarkDBAdapterV1 extends BookmarkDBAdapter { } @Override - public Record next() throws IOException { + public DBRecord next() throws IOException { return iter.next(); } @Override - public Record previous() throws IOException { + public DBRecord previous() throws IOException { return iter.previous(); } @@ -223,7 +222,7 @@ class BookmarkDBAdapterV1 extends BookmarkDBAdapter { } @Override - protected Record convertRecord(Record record) { + protected DBRecord convertRecord(DBRecord record) { return convertV1Record(record); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV3.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV3.java index 42ab0fdc91..b2de91bb4e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV3.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBAdapterV3.java @@ -107,7 +107,7 @@ public class BookmarkDBAdapterV3 extends BookmarkDBAdapter { } @Override - Record getRecord(long id) throws IOException { + DBRecord getRecord(long id) throws IOException { Table table = getTable(id); if (table == null) { return null; @@ -160,7 +160,7 @@ public class BookmarkDBAdapterV3 extends BookmarkDBAdapter { // TODO: This is very inefficient but is just as fast as using the index iterator // Employing a separate category table would be faster while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String cat = rec.getString(V3_CATEGORY_COL); if (cat != null && cat.length() != 0) { set.add(cat); @@ -175,7 +175,7 @@ public class BookmarkDBAdapterV3 extends BookmarkDBAdapter { AddressSet set = new AddressSet(); RecordIterator recordIter = getRecordsByType(typeID); while (recordIter.hasNext()) { - Record rec = recordIter.next(); + DBRecord rec = recordIter.next(); Address addr = addressMap.decodeAddress(rec.getLongValue(V3_ADDRESS_COL)); set.addRange(addr, addr); } @@ -200,7 +200,7 @@ public class BookmarkDBAdapterV3 extends BookmarkDBAdapter { } @Override - Record createBookmark(int typeID, String category, long index, String comment) + DBRecord createBookmark(int typeID, String category, long index, String comment) throws IOException { if (!hasTable(typeID)) { return null; @@ -210,7 +210,7 @@ public class BookmarkDBAdapterV3 extends BookmarkDBAdapter { long nextId = table.getKey() + 1; long id = ((long) typeID << TYPE_ID_OFFSET) | nextId; - Record rec = V3_SCHEMA.createRecord(id); + DBRecord rec = V3_SCHEMA.createRecord(id); rec.setLongValue(V3_ADDRESS_COL, index); rec.setString(V3_CATEGORY_COL, category); rec.setString(V3_COMMENT_COL, comment); @@ -225,7 +225,7 @@ public class BookmarkDBAdapterV3 extends BookmarkDBAdapter { } @Override - void updateRecord(Record rec) throws IOException { + void updateRecord(DBRecord rec) throws IOException { Table table = getTable(rec.getKey()); table.putRecord(rec); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBManager.java index 57d06f9cc8..f5529f1e20 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDBManager.java @@ -96,8 +96,8 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager TaskMonitor.DUMMY); } - Record[] typeRecords = bookmarkTypeAdapter.getRecords(); - for (Record rec : typeRecords) { + DBRecord[] typeRecords = bookmarkTypeAdapter.getRecords(); + for (DBRecord rec : typeRecords) { int typeId = (int) rec.getKey(); BookmarkTypeDB type = new BookmarkTypeDB(typeId, rec.getString(BookmarkTypeDBAdapter.TYPE_NAME_COL)); @@ -157,7 +157,7 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager void bookmarkChanged(BookmarkDB bm) { lock.acquire(); try { - Record rec = bm.getRecord(); + DBRecord rec = bm.getRecord(); if (rec != null) { bookmarkAdapter.updateRecord(rec); Address addr = bm.getAddress(); @@ -179,11 +179,11 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager private void upgradeOldBookmarks(ProgramDB programDB) { OldBookmarkManager oldMgr = new OldBookmarkManager(programDB); - Record[] oldTypes = oldMgr.getTypeRecords(); + DBRecord[] oldTypes = oldMgr.getTypeRecords(); if (oldTypes.length == 0) { return; } - for (Record oldType : oldTypes) { + for (DBRecord oldType : oldTypes) { String type = oldType.getString(BookmarkTypeDBAdapter.TYPE_NAME_COL); AddressIterator iter = oldMgr.getBookmarkAddresses(type); while (iter.hasNext()) { @@ -296,7 +296,7 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager bm.setComment(comment); } else { - Record rec = bookmarkAdapter.createBookmark(typeId, category, + DBRecord rec = bookmarkAdapter.createBookmark(typeId, category, addrMap.getKey(addr, true), comment); bm = new BookmarkDB(this, cache, rec); @@ -315,7 +315,7 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager return null; } - private BookmarkDB getBookmark(Record bookmarkRecord) { + private BookmarkDB getBookmark(DBRecord bookmarkRecord) { BookmarkDB bm = cache.get(bookmarkRecord); if (bm == null) { bm = new BookmarkDB(this, cache, bookmarkRecord); @@ -333,7 +333,7 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager RecordIterator iter = bookmarkAdapter.getRecordsByTypeAtAddress(typeId, addrMap.getKey(addr, false)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); String cat = rec.getString(BookmarkDBAdapter.CATEGORY_COL); if (category.equals(cat)) { return getBookmark(rec); @@ -430,7 +430,7 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager RecordIterator iter = bookmarkAdapter.getRecordsByTypeAndCategory(bmt.getTypeId(), category); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); BookmarkDB bm = getBookmark(rec); removeBookmark(bm); monitor.checkCanceled(); @@ -458,8 +458,8 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager * @param id bookmark ID * @return bookmark record */ - Record getRecord(long id) { - Record rec = null; + DBRecord getRecord(long id) { + DBRecord rec = null; try { rec = bookmarkAdapter.getRecord(id); } @@ -498,7 +498,7 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager RecordIterator iter = bookmarkAdapter.getRecordsByTypeAtAddress(typeId, addrMap.getKey(addr, false)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); list.add(getBookmark(rec)); } } @@ -626,7 +626,7 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager try { BookmarkDB bm = cache.get(id); if (bm == null) { - Record record = bookmarkAdapter.getRecord(id); + DBRecord record = bookmarkAdapter.getRecord(id); if (record == null) { return null; } @@ -847,7 +847,7 @@ public class BookmarkDBManager implements BookmarkManager, ErrorHandler, Manager lock.acquire(); try { while (nextBookmark == null && (forward ? it.hasNext() : it.hasPrevious())) { - Record record = forward ? it.next() : it.previous(); + DBRecord record = forward ? it.next() : it.previous(); nextBookmark = getBookmark(record); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapter.java index b15dc914ae..38af17aee7 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapter.java @@ -85,13 +85,13 @@ abstract class BookmarkTypeDBAdapter { * @return array of records * @throws IOException */ - abstract Record[] getRecords() throws IOException; + abstract DBRecord[] getRecords() throws IOException; public int[] getTypeIds() throws IOException { - Record[] typeRecords = getRecords(); + DBRecord[] typeRecords = getRecords(); int[] ids = new int[typeRecords.length]; for (int i = 0; i < typeRecords.length; i++) { - Record rec = typeRecords[i]; + DBRecord rec = typeRecords[i]; ids[i] = (int) rec.getKey(); } return ids; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapterNoTable.java index 2472d4f7f7..9f3488c230 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapterNoTable.java @@ -18,14 +18,14 @@ package ghidra.program.database.bookmark; import java.io.IOException; import db.DBHandle; -import db.Record; +import db.DBRecord; /** * */ public class BookmarkTypeDBAdapterNoTable extends BookmarkTypeDBAdapter { - private Record[] records = new Record[0]; + private DBRecord[] records = new DBRecord[0]; /** * @param dbHandle the database handle @@ -44,7 +44,7 @@ public class BookmarkTypeDBAdapterNoTable extends BookmarkTypeDBAdapter { } @Override - Record[] getRecords() throws IOException { + DBRecord[] getRecords() throws IOException { return records; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapterV0.java index cf8418dcb5..14efef87d1 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkTypeDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -44,13 +43,13 @@ public class BookmarkTypeDBAdapterV0 extends BookmarkTypeDBAdapter { } @Override - Record[] getRecords() throws IOException { - ArrayList list = new ArrayList(); + DBRecord[] getRecords() throws IOException { + ArrayList list = new ArrayList(); RecordIterator iter = table.iterator(); while (iter.hasNext()) { list.add(iter.next()); } - Record[] recs = new Record[list.size()]; + DBRecord[] recs = new DBRecord[list.size()]; list.toArray(recs); return recs; } @@ -58,7 +57,7 @@ public class BookmarkTypeDBAdapterV0 extends BookmarkTypeDBAdapter { @Override void addType(int typeId, String type) throws IOException { - Record rec = SCHEMA.createRecord(typeId); + DBRecord rec = SCHEMA.createRecord(typeId); rec.setString(TYPE_NAME_COL, type); table.putRecord(rec); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/OldBookmarkManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/OldBookmarkManager.java index c71948b2da..56b2314ef6 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/OldBookmarkManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/OldBookmarkManager.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,7 +25,7 @@ import ghidra.util.exception.DuplicateNameException; import java.util.*; -import db.Record; +import db.DBRecord; /** * Interface to manage bookmarks on a program. @@ -41,7 +40,7 @@ class OldBookmarkManager { private Program program; private PropertyMapManager propertyMgr; - private HashMap bookmarkTypes = new HashMap(); // maps type to record + private HashMap bookmarkTypes = new HashMap(); // maps type to record // private ArrayList bookmarks = new ArrayList(); // private LongIntHashedList bookmarkAddrIndex = new LongIntHashedList(); @@ -56,7 +55,7 @@ class OldBookmarkManager { // Create type records String[] types = getTypes(); for (int i = 0; i < types.length; i++) { - Record rec = BookmarkTypeDBAdapter.SCHEMA.createRecord(i); + DBRecord rec = BookmarkTypeDBAdapter.SCHEMA.createRecord(i); rec.setString(BookmarkTypeDBAdapter.TYPE_NAME_COL, types[i]); bookmarkTypes.put(types[i], rec); } @@ -189,9 +188,9 @@ class OldBookmarkManager { /** * Returns array of bookmark type records */ - public Record[] getTypeRecords() { - Collection c = bookmarkTypes.values(); - Record[] recs = new Record[c.size()]; + public DBRecord[] getTypeRecords() { + Collection c = bookmarkTypes.values(); + DBRecord[] recs = new DBRecord[c.size()]; c.toArray(recs); return recs; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CodeManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CodeManager.java index 0cf7d32189..f4b2208b9e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CodeManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CodeManager.java @@ -260,12 +260,12 @@ public class CodeManager implements ErrorHandler, ManagerDB { Instruction inst = null; RecordIterator recIt = instAdapter.getRecords(firstInstrStart, true); if (recIt.hasNext()) { - Record rec = recIt.next(); + DBRecord rec = recIt.next(); inst = getInstructionDB(rec); recIt.previous(); } if (recIt.hasPrevious()) { - Record rec = recIt.previous(); + DBRecord rec = recIt.previous(); Instruction prevInst = getInstructionDB(rec); if (prevInst.getMaxAddress().compareTo(firstInstrStart) >= 0) { return prevInst; @@ -275,12 +275,12 @@ public class CodeManager implements ErrorHandler, ManagerDB { Data data = null; recIt = dataAdapter.getRecords(firstInstrStart, true); if (recIt.hasNext()) { - Record rec = recIt.next(); + DBRecord rec = recIt.next(); data = getDataDB(rec); recIt.previous(); } if (recIt.hasPrevious()) { - Record rec = recIt.previous(); + DBRecord rec = recIt.previous(); Data prevData = getDataDB(rec); if (prevData.getMaxAddress().compareTo(firstInstrStart) >= 0) { return prevData; @@ -930,8 +930,8 @@ public class CodeManager implements ErrorHandler, ManagerDB { } private CodeUnit getDefinedBefore(Address address) throws IOException { - Record dataRec = dataAdapter.getRecordBefore(address); - Record instRec = instAdapter.getRecordBefore(address); + DBRecord dataRec = dataAdapter.getRecordBefore(address); + DBRecord instRec = instAdapter.getRecordBefore(address); if (dataRec == null && instRec == null) { return null; @@ -1010,8 +1010,8 @@ public class CodeManager implements ErrorHandler, ManagerDB { return cu; } try { - Record dataRec = dataAdapter.getRecordBefore(address); - Record instRec = instAdapter.getRecordBefore(address); + DBRecord dataRec = dataAdapter.getRecordBefore(address); + DBRecord instRec = instAdapter.getRecordBefore(address); CodeUnit cuFirst = null, cuSecond = null; @@ -1320,7 +1320,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { try { CodeUnit cu = cache.get(addr); if (cu == null) { - Record rec = dataAdapter.getRecord(addr); + DBRecord rec = dataAdapter.getRecord(addr); return getDataDB(rec); } else if (cu instanceof Data) { @@ -1350,7 +1350,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { public Instruction getInstructionBefore(Address addr) { lock.acquire(); try { - Record rec = instAdapter.getRecordBefore(addr); + DBRecord rec = instAdapter.getRecordBefore(addr); return getInstructionDB(rec); } catch (IOException e) { @@ -1374,7 +1374,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { public Instruction getInstructionAfter(Address addr) { lock.acquire(); try { - Record rec = instAdapter.getRecordAfter(addr); + DBRecord rec = instAdapter.getRecordAfter(addr); return getInstructionDB(rec); } catch (IOException e) { @@ -1548,7 +1548,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { public Data getDefinedDataAfter(Address addr) { lock.acquire(); try { - Record rec = dataAdapter.getRecordAfter(addr); + DBRecord rec = dataAdapter.getRecordAfter(addr); return getDataDB(rec); } catch (IOException e) { @@ -1573,7 +1573,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { public Data getDefinedDataBefore(Address addr) { lock.acquire(); try { - Record rec = dataAdapter.getRecordBefore(addr); + DBRecord rec = dataAdapter.getRecordBefore(addr); return getDataDB(rec); } catch (IOException e) { @@ -1682,7 +1682,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { while (true) { if (nextInstAddr == null && instIter.hasNext()) { - Record nextInstRec = instIter.next(); + DBRecord nextInstRec = instIter.next(); nextInstAddr = addrMap.decodeAddress(nextInstRec.getKey()); nextInstEndAddr = nextInstAddr; int protoID = nextInstRec.getIntValue(InstDBAdapter.PROTO_ID_COL); @@ -1700,7 +1700,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { } if (nextDataAddr == null && dataIter.hasNext()) { - Record nextDataRec = dataIter.next(); + DBRecord nextDataRec = dataIter.next(); nextDataAddr = addrMap.decodeAddress(nextDataRec.getKey()); nextDataEndAddr = nextDataAddr; DataDB data = getDataDB(nextDataRec); @@ -1919,7 +1919,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { RecordIterator recIt = instAdapter.getRecords(startAddr, true); if (recIt.hasNext()) { - Record rec = recIt.next(); + DBRecord rec = recIt.next(); Instruction inst = getInstructionDB(rec); if (inst.getMinAddress().compareTo(endAddr) <= 0) { throw new CodeUnitInsertionException("Conflicting instruction exists at address " + @@ -1928,7 +1928,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { recIt.previous(); } if (recIt.hasPrevious()) { - Record rec = recIt.previous(); + DBRecord rec = recIt.previous(); Instruction inst = getInstructionDB(rec); if (inst.getMaxAddress().compareTo(startAddr) >= 0) { throw new CodeUnitInsertionException("Conflicting instruction exists at address " + @@ -1938,7 +1938,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { recIt = dataAdapter.getRecords(startAddr, true); if (recIt.hasNext()) { - Record rec = recIt.next(); + DBRecord rec = recIt.next(); Data data = getDataDB(rec); if (data.getMinAddress().compareTo(endAddr) <= 0) { throw new CodeUnitInsertionException("Conflicting data exists at address " + @@ -1947,7 +1947,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { recIt.previous(); } if (recIt.hasPrevious()) { - Record rec = recIt.previous(); + DBRecord rec = recIt.previous(); Data data = getDataDB(rec); if (data.getMaxAddress().compareTo(startAddr) >= 0) { throw new CodeUnitInsertionException("Conflicting data exists at address " + @@ -2033,7 +2033,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { return getUndefinedDataDB(addr, addrMap.getKey(addr, false)); } - Record record = dataAdapter.createData(addr, dataManager.getResolvedID(dataType)); + DBRecord record = dataAdapter.createData(addr, dataManager.getResolvedID(dataType)); DataType baseDt = dataType; if (baseDt instanceof TypeDef) { @@ -2635,7 +2635,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { protected boolean isUndefined(Address address, long addr) { if (program.getMemory().contains(address)) { try { - Record rec = dataAdapter.getRecord(addr); + DBRecord rec = dataAdapter.getRecord(addr); if (rec == null) { rec = instAdapter.getRecord(addr); } @@ -2668,7 +2668,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { RecordIterator it = dataAdapter.getRecords(); while (it.hasNext()) { monitor.checkCanceled(); - Record rec = it.next(); + DBRecord rec = it.next(); long id = rec.getLongValue(DataDBAdapter.DATA_TYPE_ID_COL); for (long dataTypeID : dataTypeIDs) { if (id == dataTypeID) { @@ -2726,7 +2726,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { * the cache, create a new DB object and add it. * @param rec record for the instruction */ - InstructionDB getInstructionDB(Record rec) { + InstructionDB getInstructionDB(DBRecord rec) { lock.acquire(); try { if (rec != null) { @@ -2754,7 +2754,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { * create a new DB object and add it. * @param rec data record */ - DataDB getDataDB(Record rec) { + DataDB getDataDB(DBRecord rec) { lock.acquire(); try { if (rec != null) { @@ -2792,8 +2792,8 @@ public class CodeManager implements ErrorHandler, ManagerDB { } Address getDefinedAddressAfter(Address address) { - Record dataRec = null; - Record instRec = null; + DBRecord dataRec = null; + DBRecord instRec = null; try { dataRec = dataAdapter.getRecordAfter(address); instRec = instAdapter.getRecordAfter(address); @@ -2876,7 +2876,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { RecordIterator iter = dataAdapter.getRecords(start, end, true); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Data data = getDataDB(rec); addDataReferences(data, new ArrayList
()); } @@ -3091,11 +3091,11 @@ public class CodeManager implements ErrorHandler, ManagerDB { } private InstructionDB getInstructionDB(long addr) throws IOException { - Record rec = instAdapter.getRecord(addr); + DBRecord rec = instAdapter.getRecord(addr); return getInstructionDB(rec); } - protected Record getInstructionRecord(long addr) { + protected DBRecord getInstructionRecord(long addr) { try { return instAdapter.getRecord(addr); } @@ -3115,7 +3115,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { return null; } - DataType getDataType(Record dataRecord) { + DataType getDataType(DBRecord dataRecord) { if (dataRecord != null) { long datatypeID = dataRecord.getLongValue(DataDBAdapter.DATA_TYPE_ID_COL); DataType dt = dataManager.getDataType(datatypeID); @@ -3323,7 +3323,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { public String getComment(int commentType, Address address) { try { long addr = addrMap.getKey(address, false); - Record commentRec = getCommentAdapter().getRecord(addr); + DBRecord commentRec = getCommentAdapter().getRecord(addr); if (commentRec != null) { return commentRec.getString(commentType); } @@ -3353,7 +3353,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { lock.acquire(); try { long addr = addrMap.getKey(address, true); - Record commentRec = getCommentAdapter().getRecord(addr); + DBRecord commentRec = getCommentAdapter().getRecord(addr); if (commentRec == null) { if (comment == null) { return; @@ -3444,20 +3444,20 @@ public class CodeManager implements ErrorHandler, ManagerDB { try { // records are sorted by date ascending - List allRecords = getHistoryRecords(addr, commentType); + List allRecords = getHistoryRecords(addr, commentType); List results = new ArrayList<>(); String comment = getComment(addr, commentType); while (!allRecords.isEmpty()) { - Record rec = allRecords.get(allRecords.size() - 1); + DBRecord rec = allRecords.get(allRecords.size() - 1); long date = rec.getLongValue(CommentHistoryAdapter.HISTORY_DATE_COL); - List records = subListByDate(allRecords, date); + List records = subListByDate(allRecords, date); List diffs = new ArrayList<>(records.size()); String user = null; - for (Record r : records) { + for (DBRecord r : records) { user = r.getString(CommentHistoryAdapter.HISTORY_USER_COL); int pos1 = r.getIntValue(CommentHistoryAdapter.HISTORY_POS1_COL); int pos2 = r.getIntValue(CommentHistoryAdapter.HISTORY_POS2_COL); @@ -3484,11 +3484,11 @@ public class CodeManager implements ErrorHandler, ManagerDB { } // note: you must have the lock when calling this method - private List getHistoryRecords(Address addr, int commentType) throws IOException { + private List getHistoryRecords(Address addr, int commentType) throws IOException { RecordIterator it = historyAdapter.getRecordsByAddress(addr); - List list = new ArrayList<>(); + List list = new ArrayList<>(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); if (rec.getByteValue(CommentHistoryAdapter.HISTORY_TYPE_COL) == commentType) { list.add(rec); } @@ -3497,10 +3497,10 @@ public class CodeManager implements ErrorHandler, ManagerDB { } // note: records are sorted by date; assume that the date we seek is at the end - private List subListByDate(List records, long date) { + private List subListByDate(List records, long date) { for (int i = records.size() - 1; i >= 0; i--) { - Record rec = records.get(i); + DBRecord rec = records.get(i); if (date != rec.getLongValue(CommentHistoryAdapter.HISTORY_DATE_COL)) { return records.subList(i + 1, records.size()); } @@ -3511,7 +3511,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { } private String getComment(Address addr, int commentType) throws IOException { - Record record = commentAdapter.getRecord(addrMap.getKey(addr, false)); + DBRecord record = commentAdapter.getRecord(addrMap.getKey(addr, false)); if (record != null) { return record.getString(commentType); } @@ -3523,7 +3523,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { try { RecordIterator it = dataAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); long id = rec.getLongValue(DataDBAdapter.DATA_TYPE_ID_COL); if (id == oldDataTypeID) { rec.setLongValue(DataDBAdapter.DATA_TYPE_ID_COL, newDataTypeID); @@ -3551,7 +3551,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { private void addCommentHistoryRecords(Address start, Address end) throws IOException { RecordIterator iter = commentAdapter.getRecords(start, end, true); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); addCommentHistoryRecord(rec, CodeUnit.PRE_COMMENT); addCommentHistoryRecord(rec, CodeUnit.POST_COMMENT); addCommentHistoryRecord(rec, CodeUnit.EOL_COMMENT); @@ -3560,7 +3560,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { } } - private void addCommentHistoryRecord(Record commentRec, int commentType) { + private void addCommentHistoryRecord(DBRecord commentRec, int commentType) { String comment = commentRec.getString(commentType); if (comment != null) { createCommentHistoryRecord(addrMap.decodeAddress(commentRec.getKey()), commentType, @@ -3608,7 +3608,7 @@ public class CodeManager implements ErrorHandler, ManagerDB { int count = 0; RecordIterator recIter = instAdapter.getRecords(); while (recIter.hasNext()) { - Record rec = recIter.next(); + DBRecord rec = recIter.next(); Address addr = addrMap.decodeAddress(rec.getKey()); if (minAddr == null) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CodeUnitDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CodeUnitDB.java index dfad2c2cb9..8999a62d11 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CodeUnitDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CodeUnitDB.java @@ -21,7 +21,7 @@ import java.util.*; import org.apache.commons.lang3.StringUtils; -import db.Record; +import db.DBRecord; import ghidra.program.database.*; import ghidra.program.model.address.Address; import ghidra.program.model.address.AddressOutOfBoundsException; @@ -53,7 +53,7 @@ abstract class CodeUnitDB extends DatabaseObject implements CodeUnit, ProcessorC protected ReferenceManager refMgr; protected ProgramDB program; - private Record commentRec; + private DBRecord commentRec; private boolean checkedComments; protected byte[] bytes; private ProgramContext programContext; @@ -89,7 +89,7 @@ abstract class CodeUnitDB extends DatabaseObject implements CodeUnit, ProcessorC } @Override - protected boolean refresh(Record record) { + protected boolean refresh(DBRecord record) { address = codeMgr.getAddressMap().decodeAddress(addr); endAddr = null; commentRec = null; @@ -121,7 +121,7 @@ abstract class CodeUnitDB extends DatabaseObject implements CodeUnit, ProcessorC * does NOT indicate existence and a record query may be required. * @return true if removal of code unit has been confirmed */ - abstract protected boolean hasBeenDeleted(Record record); + abstract protected boolean hasBeenDeleted(DBRecord record); @Override public void addMnemonicReference(Address refAddr, RefType refType, SourceType sourceType) { @@ -794,7 +794,7 @@ abstract class CodeUnitDB extends DatabaseObject implements CodeUnit, ProcessorC @Override public abstract String toString(); - Record getCommentRecord() { + DBRecord getCommentRecord() { return commentRec; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapter.java index 92e9cfa4d0..b751222dd8 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapter.java @@ -102,7 +102,7 @@ abstract class CommentHistoryAdapter { RecordIterator iter = oldAdapter.getAllRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getLongValue(HISTORY_ADDRESS_COL)); rec.setLongValue(HISTORY_ADDRESS_COL, addrMap.getKey(addr, true)); tmpAdapter.updateRecord(rec); @@ -115,7 +115,7 @@ abstract class CommentHistoryAdapter { iter = tmpAdapter.getAllRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); newAdapter.updateRecord(rec); monitor.setProgress(++count); } @@ -150,7 +150,7 @@ abstract class CommentHistoryAdapter { * @param rec the record to update * @throws IOException if there was a problem accessing the database */ - abstract void updateRecord(Record rec) throws IOException; + abstract void updateRecord(DBRecord rec) throws IOException; /** * Delete the records in the given range. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapterNoTable.java index ee2c77afdb..ff4a48a331 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapterNoTable.java @@ -17,7 +17,7 @@ package ghidra.program.database.code; import java.io.IOException; -import db.Record; +import db.DBRecord; import db.RecordIterator; import ghidra.program.database.util.EmptyRecordIterator; import ghidra.program.model.address.Address; @@ -45,7 +45,7 @@ class CommentHistoryAdapterNoTable extends CommentHistoryAdapter { } @Override - void updateRecord(Record rec) throws IOException { + void updateRecord(DBRecord rec) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapterV0.java index 3f4f2d9c1d..f446f6ee81 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentHistoryAdapterV0.java @@ -63,7 +63,7 @@ class CommentHistoryAdapterV0 extends CommentHistoryAdapter { void createRecord(long addr, byte commentType, int pos1, int pos2, String data, long date) throws IOException { - Record rec = table.getSchema().createRecord(table.getKey()); + DBRecord rec = table.getSchema().createRecord(table.getKey()); rec.setLongValue(HISTORY_ADDRESS_COL, addr); rec.setByteValue(HISTORY_TYPE_COL, commentType); rec.setIntValue(HISTORY_POS1_COL, pos1); @@ -87,7 +87,7 @@ class CommentHistoryAdapterV0 extends CommentHistoryAdapter { } @Override - void updateRecord(Record rec) throws IOException { + void updateRecord(DBRecord rec) throws IOException { table.putRecord(rec); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapter.java index bb66b1e171..52ec0066a9 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapter.java @@ -127,7 +127,7 @@ abstract class CommentsDBAdapter { RecordIterator iter = oldAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getKey()); rec.setKey(addrMap.getKey(addr, true)); tmpAdapter.updateRecord(rec); @@ -140,7 +140,7 @@ abstract class CommentsDBAdapter { iter = tmpAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); newAdapter.updateRecord(rec); monitor.setProgress(++count); } @@ -161,7 +161,7 @@ abstract class CommentsDBAdapter { * @param addr key for the record * @throws IOException if there was a problem accessing the database */ - abstract Record getRecord(long addr) throws IOException; + abstract DBRecord getRecord(long addr) throws IOException; /** * Create a comment record for the given comment type/ @@ -171,7 +171,7 @@ abstract class CommentsDBAdapter { * @return new comment record * @throws IOException if there was a problem accessing the database */ - abstract Record createRecord(long addr, int commentCol, String comment) throws IOException; + abstract DBRecord createRecord(long addr, int commentCol, String comment) throws IOException; /** * Delete the record at the given address @@ -194,7 +194,7 @@ abstract class CommentsDBAdapter { * Update the record with the comments from the given record. * @throws IOException if there was a problem accessing the database */ - abstract void updateRecord(Record commentRec) throws IOException; + abstract void updateRecord(DBRecord commentRec) throws IOException; /** * @see ghidra.program.database.code.MoveRangeAdapter#getRecords(long, long, boolean) @@ -224,7 +224,7 @@ abstract class CommentsDBAdapter { * @param record the record to put. * @throws IOException if a database io error occurs */ - abstract void putRecord(Record record) throws IOException; + abstract void putRecord(DBRecord record) throws IOException; /** * Returns a record iterator starting with the record at addr diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapterV0.java index 38492b7fc1..b2961aa84d 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapterV0.java @@ -79,7 +79,7 @@ class CommentsDBAdapterV0 extends CommentsDBAdapter { * @see ghidra.program.database.code.CommentsDBAdapter#getRecord(long) */ @Override - public Record getRecord(long addr) throws IOException { + public DBRecord getRecord(long addr) throws IOException { return adaptRecord(commentTable.getRecord(addr)); } @@ -87,7 +87,7 @@ class CommentsDBAdapterV0 extends CommentsDBAdapter { * @see ghidra.program.database.code.CommentsDBAdapter#createRecord(long, int, java.lang.String) */ @Override - public Record createRecord(long addr, int commentCol, String comment) throws IOException { + public DBRecord createRecord(long addr, int commentCol, String comment) throws IOException { return null; } @@ -108,10 +108,10 @@ class CommentsDBAdapterV0 extends CommentsDBAdapter { } /** - * @see ghidra.program.database.code.CommentsDBAdapter#updateRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.code.CommentsDBAdapter#updateRecord(ghidra.framework.store.db.DBRecord) */ @Override - public void updateRecord(Record commentRec) throws IOException { + public void updateRecord(DBRecord commentRec) throws IOException { } /** @@ -172,10 +172,10 @@ class CommentsDBAdapterV0 extends CommentsDBAdapter { } /** - * @see ghidra.program.database.code.CommentsDBAdapter#putRecord(db.Record) + * @see ghidra.program.database.code.CommentsDBAdapter#putRecord(db.DBRecord) */ @Override - public void putRecord(Record record) throws IOException { + public void putRecord(DBRecord record) throws IOException { } /** @@ -200,10 +200,10 @@ class CommentsDBAdapterV0 extends CommentsDBAdapter { * @param recV0 the record matching the version 0 schema. * @return a current comment record. */ - private Record adaptRecord(Record recV0) { + private DBRecord adaptRecord(DBRecord recV0) { if (recV0 == null) return null; - Record record = COMMENTS_SCHEMA.createRecord(recV0.getKey()); + DBRecord record = COMMENTS_SCHEMA.createRecord(recV0.getKey()); String comment = recV0.getString(EOL_COMMENT_COLUMN); if (comment != null) { @@ -259,16 +259,16 @@ class CommentsDBAdapterV0 extends CommentsDBAdapter { /** * @see ghidra.framework.store.db.RecordIterator#next() */ - public Record next() throws IOException { - Record rec = it.next(); + public DBRecord next() throws IOException { + DBRecord rec = it.next(); return adaptRecord(rec); } /** * @see ghidra.framework.store.db.RecordIterator#previous() */ - public Record previous() throws IOException { - Record rec = it.previous(); + public DBRecord previous() throws IOException { + DBRecord rec = it.previous(); return adaptRecord(rec); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapterV1.java index 448d2b80a7..e4a8d5f45e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/CommentsDBAdapterV1.java @@ -86,13 +86,13 @@ class CommentsDBAdapterV1 extends CommentsDBAdapter { } @Override - Record getRecord(long addr) throws IOException { + DBRecord getRecord(long addr) throws IOException { return commentTable.getRecord(addr); } @Override - Record createRecord(long addr, int commentCol, String comment) throws IOException { - Record record = COMMENTS_SCHEMA.createRecord(addr); + DBRecord createRecord(long addr, int commentCol, String comment) throws IOException { + DBRecord record = COMMENTS_SCHEMA.createRecord(addr); record.setString(commentCol, comment); commentTable.putRecord(record); return record; @@ -109,7 +109,7 @@ class CommentsDBAdapterV1 extends CommentsDBAdapter { } @Override - void updateRecord(Record commentRec) throws IOException { + void updateRecord(DBRecord commentRec) throws IOException { commentTable.putRecord(commentRec); } @@ -148,7 +148,7 @@ class CommentsDBAdapterV1 extends CommentsDBAdapter { } @Override - void putRecord(Record record) throws IOException { + void putRecord(DBRecord record) throws IOException { commentTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataComponent.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataComponent.java index 2f0600f897..0a2f33c204 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataComponent.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataComponent.java @@ -18,7 +18,7 @@ */ package ghidra.program.database.code; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.model.address.Address; import ghidra.program.model.data.*; @@ -87,7 +87,7 @@ class DataComponent extends DataDB { } @Override - protected boolean hasBeenDeleted(Record rec) { + protected boolean hasBeenDeleted(DBRecord rec) { // Records do not apply to data components which // are derived from parent data type if (parent.hasBeenDeleted(null)) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDB.java index 155536cf99..e5a32d2ce2 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDB.java @@ -18,7 +18,7 @@ package ghidra.program.database.code; import java.util.ArrayList; import java.util.List; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.docking.settings.SettingsDefinition; import ghidra.program.database.DBObjectCache; @@ -87,7 +87,7 @@ class DataDB extends CodeUnitDB implements Data { } @Override - protected boolean refresh(Record record) { + protected boolean refresh(DBRecord record) { if (componentCache != null) { componentCache.invalidate(); } @@ -96,7 +96,7 @@ class DataDB extends CodeUnitDB implements Data { } @Override - protected boolean hasBeenDeleted(Record rec) { + protected boolean hasBeenDeleted(DBRecord rec) { if (dataType == DataType.DEFAULT) { return rec != null || !codeMgr.isUndefined(address, addr); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDBAdapter.java index e8bea491aa..4230202da8 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDBAdapter.java @@ -90,7 +90,7 @@ abstract class DataDBAdapter { RecordIterator iter = oldAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getKey()); rec.setKey(addrMap.getKey(addr, true)); tmpAdapter.putRecord(rec); @@ -103,7 +103,7 @@ abstract class DataDBAdapter { iter = tmpAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); newAdapter.putRecord(rec); monitor.setProgress(++count); } @@ -118,31 +118,31 @@ abstract class DataDBAdapter { * Get the record at or after the given start address. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecordAtOrAfter(Address start) throws IOException; + abstract DBRecord getRecordAtOrAfter(Address start) throws IOException; /** * Get the Record afer the given start address. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecordAfter(Address start) throws IOException; + abstract DBRecord getRecordAfter(Address start) throws IOException; /** * Get the record at the given start address. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecord(Address start) throws IOException; + abstract DBRecord getRecord(Address start) throws IOException; /** * Get the record at the give key; * @param key the key of the record to retrieve. */ - abstract Record getRecord(long key) throws IOException; + abstract DBRecord getRecord(long key) throws IOException; /** * Get the record before the given address address. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecordBefore(Address addr) throws IOException; + abstract DBRecord getRecordBefore(Address addr) throws IOException; /** * Get a record iterator starting at the given address address. @@ -169,7 +169,7 @@ abstract class DataDBAdapter { * @param dataTypeID ID of data type * @throws IOException if there was a problem accessing the database */ - abstract Record createData(Address addr, long dataTypeID) throws IOException; + abstract DBRecord createData(Address addr, long dataTypeID) throws IOException; /** * Get the number of records in the data table. @@ -183,7 +183,7 @@ abstract class DataDBAdapter { * @throws IOException if there was a problem accessing the database * @return */ - abstract Record getRecordAtOrBefore(Address addr) throws IOException; + abstract DBRecord getRecordAtOrBefore(Address addr) throws IOException; /** * Get a iterator over the keys in the data table. @@ -216,7 +216,7 @@ abstract class DataDBAdapter { * @param record the record to add or update. * @throws IOException if a database io error occurs. */ - abstract void putRecord(Record record) throws IOException; + abstract void putRecord(DBRecord record) throws IOException; /** * Returns an iterator over the keys that fall within the address set provided. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDBAdapterV0.java index a3dafdd6ba..b2d66894df 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -62,7 +61,7 @@ class DataDBAdapterV0 extends DataDBAdapter { * @see ghidra.program.database.code.DataDBAdapter#getRecordAtOrAfter(ghidra.program.model.address.Address) */ @Override - Record getRecordAtOrAfter(Address addr) throws IOException { + DBRecord getRecordAtOrAfter(Address addr) throws IOException { AddressKeyRecordIterator it = new AddressKeyRecordIterator(dataTable, addrMap, addr, true); return it.next(); } @@ -71,7 +70,7 @@ class DataDBAdapterV0 extends DataDBAdapter { * @see ghidra.program.database.code.DataDBAdapter#getRecordAtOrBefore(long) */ @Override - Record getRecordAtOrBefore(Address addr) throws IOException { + DBRecord getRecordAtOrBefore(Address addr) throws IOException { AddressKeyRecordIterator it = new AddressKeyRecordIterator(dataTable, addrMap, addr, false); return it.previous(); } @@ -80,7 +79,7 @@ class DataDBAdapterV0 extends DataDBAdapter { * @see ghidra.program.database.code.DataDBAdapter#getRecordAfter(long) */ @Override - Record getRecordAfter(Address addr) throws IOException { + DBRecord getRecordAfter(Address addr) throws IOException { AddressKeyRecordIterator it = new AddressKeyRecordIterator(dataTable, addrMap, addr, false); return it.next(); } @@ -89,7 +88,7 @@ class DataDBAdapterV0 extends DataDBAdapter { * @see ghidra.program.database.code.DataDBAdapter#getRecord(long) */ @Override - Record getRecord(Address addr) throws IOException { + DBRecord getRecord(Address addr) throws IOException { return dataTable.getRecord(addrMap.getKey(addr, false)); } @@ -97,7 +96,7 @@ class DataDBAdapterV0 extends DataDBAdapter { * @see ghidra.program.database.code.DataDBAdapter#getRecord(long) */ @Override - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { return dataTable.getRecord(key); } @@ -105,7 +104,7 @@ class DataDBAdapterV0 extends DataDBAdapter { * @see ghidra.program.database.code.DataDBAdapter#getRecordBefore(long) */ @Override - Record getRecordBefore(Address addr) throws IOException { + DBRecord getRecordBefore(Address addr) throws IOException { AddressKeyRecordIterator it = new AddressKeyRecordIterator(dataTable, addrMap, addr, true); return it.previous(); } @@ -151,9 +150,9 @@ class DataDBAdapterV0 extends DataDBAdapter { * @see ghidra.program.database.code.DataDBAdapter#createData(long, long) */ @Override - Record createData(Address newAddr, long dataTypeID) throws IOException { + DBRecord createData(Address newAddr, long dataTypeID) throws IOException { long key = addrMap.getKey(newAddr, true); - Record record = DATA_SCHEMA.createRecord(key); + DBRecord record = DATA_SCHEMA.createRecord(key); record.setLongValue(DATA_TYPE_ID_COL, dataTypeID); dataTable.putRecord(record); return record; @@ -198,10 +197,10 @@ class DataDBAdapterV0 extends DataDBAdapter { } /** - * @see ghidra.program.database.code.MoveRangeAdapter#putRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.code.MoveRangeAdapter#putRecord(ghidra.framework.store.db.DBRecord) */ @Override - void putRecord(Record record) throws IOException { + void putRecord(DBRecord record) throws IOException { dataTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataRecordIterator.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataRecordIterator.java index b87f61b7a0..d6a9461ad4 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataRecordIterator.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/DataRecordIterator.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,7 +20,7 @@ import ghidra.program.model.listing.DataIterator; import java.io.IOException; -import db.Record; +import db.DBRecord; import db.RecordIterator; /** @@ -78,7 +77,7 @@ public class DataRecordIterator implements DataIterator { private void findNext() { try { while (nextData == null && (forward ? it.hasNext() : it.hasPrevious())) { - Record record = forward ? it.next() : it.previous(); + DBRecord record = forward ? it.next() : it.previous(); nextData = codeMgr.getDataDB(record); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapter.java index fa7c2f0eaf..9b43d29700 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapter.java @@ -95,7 +95,7 @@ abstract class InstDBAdapter { RecordIterator iter = oldAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getKey()); rec.setKey(addrMap.getKey(addr, true)); tmpAdapter.putRecord(rec); @@ -108,7 +108,7 @@ abstract class InstDBAdapter { iter = tmpAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); newAdapter.putRecord(rec); monitor.setProgress(++count); } @@ -148,7 +148,7 @@ abstract class InstDBAdapter { * @return the next record or null. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecordAtOrAfter(Address addr) throws IOException; + abstract DBRecord getRecordAtOrAfter(Address addr) throws IOException; /** * Returns the next record after the given address key @@ -156,21 +156,21 @@ abstract class InstDBAdapter { * @return the next record or null. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecordAfter(Address addr) throws IOException; + abstract DBRecord getRecordAfter(Address addr) throws IOException; /** * Returns the record at the given key or null if none exists. * @param addr the key. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecord(long addr) throws IOException; + abstract DBRecord getRecord(long addr) throws IOException; /** * Returns the record at the given address or null if none exists. * @param addr the address to use as the key * @throws IOException if there was a problem accessing the database */ - abstract Record getRecord(Address addr) throws IOException; + abstract DBRecord getRecord(Address addr) throws IOException; /** * Returns the record just before the given address key. @@ -178,7 +178,7 @@ abstract class InstDBAdapter { * @return the previous record or null. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecordBefore(Address addr) throws IOException; + abstract DBRecord getRecordBefore(Address addr) throws IOException; /** * Returns a record iterator over all records in the given range. @@ -207,7 +207,7 @@ abstract class InstDBAdapter { * @return the previous record or null. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecordAtOrBefore(Address addr) throws IOException; + abstract DBRecord getRecordAtOrBefore(Address addr) throws IOException; /** * Returns an AddressKeyIterator over the given range. @@ -233,7 +233,7 @@ abstract class InstDBAdapter { * @param record the record to add or update. * @throws IOException if there was a problem accessing the database */ - abstract void putRecord(Record record) throws IOException; + abstract void putRecord(DBRecord record) throws IOException; /** * Returns a record iterator starting at the given address. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapterV0.java index 5afed5d133..4dfc15b36d 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -78,7 +77,7 @@ class InstDBAdapterV0 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecordAtOrAfter(long) */ @Override - Record getRecordAtOrAfter(Address start) throws IOException { + DBRecord getRecordAtOrAfter(Address start) throws IOException { RecordIterator it = new AddressKeyRecordIterator(instTable, addrMap, start, true); return adaptRecord(it.next()); } @@ -87,7 +86,7 @@ class InstDBAdapterV0 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecordAtOrBefore(long) */ @Override - Record getRecordAtOrBefore(Address addr) throws IOException { + DBRecord getRecordAtOrBefore(Address addr) throws IOException { RecordIterator it = new AddressKeyRecordIterator(instTable, addrMap, addr, false); return adaptRecord(it.previous()); } @@ -96,7 +95,7 @@ class InstDBAdapterV0 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecord(long) */ @Override - Record getRecord(Address addr) throws IOException { + DBRecord getRecord(Address addr) throws IOException { return getRecord(addrMap.getKey(addr, false)); } @@ -104,7 +103,7 @@ class InstDBAdapterV0 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecord(long) */ @Override - Record getRecord(long addr) throws IOException { + DBRecord getRecord(long addr) throws IOException { return adaptRecord(instTable.getRecord(addr)); } @@ -112,7 +111,7 @@ class InstDBAdapterV0 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecordAfter(long) */ @Override - Record getRecordAfter(Address addr) throws IOException { + DBRecord getRecordAfter(Address addr) throws IOException { RecordIterator it = new AddressKeyRecordIterator(instTable, addrMap, addr, false); return adaptRecord(it.next()); } @@ -121,7 +120,7 @@ class InstDBAdapterV0 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecordBefore(long) */ @Override - Record getRecordBefore(Address addr) throws IOException { + DBRecord getRecordBefore(Address addr) throws IOException { RecordIterator it = new AddressKeyRecordIterator(instTable, addrMap, addr, true); return adaptRecord(it.previous()); } @@ -183,10 +182,10 @@ class InstDBAdapterV0 extends InstDBAdapter { } /** - * @see ghidra.program.database.code.MoveRangeAdapter#putRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.code.MoveRangeAdapter#putRecord(ghidra.framework.store.db.DBRecord) */ @Override - void putRecord(Record record) throws IOException { + void putRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @@ -207,10 +206,10 @@ class InstDBAdapterV0 extends InstDBAdapter { forward ? set.getMinAddress() : set.getMaxAddress(), forward)); } - private Record adaptRecord(Record rec) { + private DBRecord adaptRecord(DBRecord rec) { if (rec == null) return null; - Record newRec = INSTRUCTION_SCHEMA.createRecord(rec.getKey()); + DBRecord newRec = INSTRUCTION_SCHEMA.createRecord(rec.getKey()); newRec.setIntValue(0, rec.getIntValue(0)); newRec.setByteValue(1, (byte) 0); return newRec; @@ -247,16 +246,16 @@ class InstDBAdapterV0 extends InstDBAdapter { /** * @see ghidra.framework.store.db.RecordIterator#next() */ - public Record next() throws IOException { - Record rec = it.next(); + public DBRecord next() throws IOException { + DBRecord rec = it.next(); return adaptRecord(rec); } /** * @see ghidra.framework.store.db.RecordIterator#previous() */ - public Record previous() throws IOException { - Record rec = it.previous(); + public DBRecord previous() throws IOException { + DBRecord rec = it.previous(); return adaptRecord(rec); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapterV1.java index ba50acc553..bc76b75afc 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstDBAdapterV1.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -68,7 +67,7 @@ class InstDBAdapterV1 extends InstDBAdapter { */ @Override void createInstruction(long addr, int protoID, byte flags) throws IOException { - Record record = INSTRUCTION_SCHEMA.createRecord(addr); + DBRecord record = INSTRUCTION_SCHEMA.createRecord(addr); record.setIntValue(PROTO_ID_COL, protoID); record.setByteValue(FLAGS_COL, flags); instTable.putRecord(record); @@ -86,7 +85,7 @@ class InstDBAdapterV1 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecordAtOrAfter(long) */ @Override - Record getRecordAtOrAfter(Address addr) throws IOException { + DBRecord getRecordAtOrAfter(Address addr) throws IOException { AddressKeyRecordIterator it = new AddressKeyRecordIterator(instTable, addrMap, addr, true); return it.next(); } @@ -95,7 +94,7 @@ class InstDBAdapterV1 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecord(long) */ @Override - Record getRecord(long addr) throws IOException { + DBRecord getRecord(long addr) throws IOException { return instTable.getRecord(addr); } @@ -103,7 +102,7 @@ class InstDBAdapterV1 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecord(ghidra.program.model.address.Address) */ @Override - Record getRecord(Address addr) throws IOException { + DBRecord getRecord(Address addr) throws IOException { return instTable.getRecord(addrMap.getKey(addr, false)); } @@ -111,7 +110,7 @@ class InstDBAdapterV1 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecordAfter(long) */ @Override - Record getRecordAfter(Address addr) throws IOException { + DBRecord getRecordAfter(Address addr) throws IOException { AddressKeyRecordIterator it = new AddressKeyRecordIterator(instTable, addrMap, addr, false); return it.next(); } @@ -120,7 +119,7 @@ class InstDBAdapterV1 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecordBefore(long) */ @Override - Record getRecordBefore(Address addr) throws IOException { + DBRecord getRecordBefore(Address addr) throws IOException { AddressKeyRecordIterator it = new AddressKeyRecordIterator(instTable, addrMap, addr, true); return it.previous(); } @@ -157,7 +156,7 @@ class InstDBAdapterV1 extends InstDBAdapter { * @see ghidra.program.database.code.InstDBAdapter#getRecordAtOrBefore(long) */ @Override - Record getRecordAtOrBefore(Address addr) throws IOException { + DBRecord getRecordAtOrBefore(Address addr) throws IOException { AddressKeyRecordIterator it = new AddressKeyRecordIterator(instTable, addrMap, addr, false); return it.previous(); } @@ -201,10 +200,10 @@ class InstDBAdapterV1 extends InstDBAdapter { } /** - * @see ghidra.program.database.code.MoveRangeAdapter#putRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.code.MoveRangeAdapter#putRecord(ghidra.framework.store.db.DBRecord) */ @Override - void putRecord(Record record) throws IOException { + void putRecord(DBRecord record) throws IOException { instTable.putRecord(record); } @@ -221,7 +220,7 @@ class InstDBAdapterV1 extends InstDBAdapter { */ @Override void updateFlags(long addr, byte flags) throws IOException { - Record rec = instTable.getRecord(addr); + DBRecord rec = instTable.getRecord(addr); rec.setByteValue(FLAGS_COL, flags); instTable.putRecord(rec); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstructionDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstructionDB.java index 4e22e5b031..d0ee344463 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstructionDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstructionDB.java @@ -18,7 +18,7 @@ package ghidra.program.database.code; import java.util.ArrayList; import java.util.List; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.model.address.*; import ghidra.program.model.lang.*; @@ -71,7 +71,7 @@ public class InstructionDB extends CodeUnitDB implements Instruction, Instructio } @Override - protected boolean refresh(Record record) { + protected boolean refresh(DBRecord record) { parserContext = null; return super.refresh(record); } @@ -83,7 +83,7 @@ public class InstructionDB extends CodeUnitDB implements Instruction, Instructio } @Override - protected boolean hasBeenDeleted(Record rec) { + protected boolean hasBeenDeleted(DBRecord rec) { if (rec == null) { rec = codeMgr.getInstructionRecord(addr); if (rec == null) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstructionRecordIterator.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstructionRecordIterator.java index aec459fb52..a9b8ee809c 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstructionRecordIterator.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/InstructionRecordIterator.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,7 +21,7 @@ import ghidra.program.model.listing.InstructionIterator; import java.io.IOException; import java.util.Iterator; -import db.Record; +import db.DBRecord; import db.RecordIterator; /** @@ -74,7 +73,7 @@ public class InstructionRecordIterator implements InstructionIterator { private void findNext() { try { while (nextInstruction == null && (forward ? it.hasNext() : it.hasPrevious())) { - Record record = forward ? it.next() : it.previous(); + DBRecord record = forward ? it.next() : it.previous(); nextInstruction = codeMgr.getInstructionDB(record); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapter.java index 474f04e70c..7297cca7cc 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,7 +17,7 @@ package ghidra.program.database.code; import java.io.IOException; -import db.Record; +import db.DBRecord; import db.RecordIterator; /** @@ -31,7 +30,7 @@ interface ProtoDBAdapter { * @param protoId * @return */ - Record getRecord(int protoId) throws IOException; + DBRecord getRecord(int protoId) throws IOException; /** * Returns a record iterator over all records. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapterV0.java index 55de966cbd..04172f633f 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -90,15 +89,15 @@ class ProtoDBAdapterV0 implements ProtoDBAdapter { /** * @see ghidra.program.database.code.ProtoDBAdapter#getRecord(int) */ - public Record getRecord(int protoId) throws IOException { + public DBRecord getRecord(int protoId) throws IOException { return convertRecord(table.getRecord(protoId)); } - private Record convertRecord(Record oldRec) { + private DBRecord convertRecord(DBRecord oldRec) { long key = oldRec.getKey(); if (key < 0) key = -key; - Record newRec = PrototypeManager.PROTO_SCHEMA.createRecord(key); + DBRecord newRec = PrototypeManager.PROTO_SCHEMA.createRecord(key); newRec.setBinaryData(0, oldRec.getBinaryData(0)); newRec.setLongValue(1, oldRec.getLongValue(1)); newRec.setBooleanValue(2, false); @@ -131,16 +130,16 @@ class ProtoDBAdapterV0 implements ProtoDBAdapter { return it.hasPrevious(); } - public Record next() throws IOException { + public DBRecord next() throws IOException { return convertRecord(it.next()); } - public Record previous() throws IOException { - Record rec = it.previous(); + public DBRecord previous() throws IOException { + DBRecord rec = it.previous(); long key = rec.getKey(); if (key < 0) key = -key; - Record newRec = PrototypeManager.PROTO_SCHEMA.createRecord(key); + DBRecord newRec = PrototypeManager.PROTO_SCHEMA.createRecord(key); newRec.setBinaryData(0, rec.getBinaryData(0)); newRec.setLongValue(1, rec.getLongValue(1)); newRec.setBooleanValue(2, false); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapterV1.java index aff9ad514c..3e2cb10c4c 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/ProtoDBAdapterV1.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -66,7 +65,7 @@ class ProtoDBAdapterV1 implements ProtoDBAdapter { public void createRecord(int protoID, long addr, byte[] b, boolean inDelaySlot) throws IOException { - Record record = PrototypeManager.PROTO_SCHEMA.createRecord(protoID); + DBRecord record = PrototypeManager.PROTO_SCHEMA.createRecord(protoID); record.setBinaryData(PrototypeManager.BYTES_COL, b); record.setLongValue(PrototypeManager.ADDR_COL, addr); record.setBooleanValue(2, inDelaySlot); @@ -83,7 +82,7 @@ class ProtoDBAdapterV1 implements ProtoDBAdapter { /** * @see ghidra.program.database.code.ProtoDBAdapter#getRecord(int) */ - public Record getRecord(int protoId) throws IOException { + public DBRecord getRecord(int protoId) throws IOException { return table.getRecord(protoId); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/PrototypeManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/PrototypeManager.java index bfd2581534..3e520b95e9 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/PrototypeManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/code/PrototypeManager.java @@ -133,7 +133,7 @@ class PrototypeManager { if (monitor.isCancelled()) { throw new IOException("Upgrade Cancelled"); } - Record rec = it.next(); + DBRecord rec = it.next(); String oldValue = rec.getString(0); rec.setString(0, convertString(oldValue)); tempTable.putRecord(rec); @@ -147,7 +147,7 @@ class PrototypeManager { if (monitor.isCancelled()) { throw new IOException("Upgrade Cancelled"); } - Record rec = it.next(); + DBRecord rec = it.next(); contextTable.putRecord(rec); } } @@ -192,7 +192,7 @@ class PrototypeManager { if (monitor.isCancelled()) { throw new IOException("Upgrade Cancelled"); } - Record rec = it.next(); + DBRecord rec = it.next(); tempAdapter.createRecord((int) rec.getKey(), rec.getLongValue(ADDR_COL), rec.getBinaryData(BYTES_COL), rec.getBooleanValue(DELAY_COL)); } @@ -207,7 +207,7 @@ class PrototypeManager { if (monitor.isCancelled()) { throw new IOException("Upgrade Cancelled"); } - Record rec = it.next(); + DBRecord rec = it.next(); protoAdapter.createRecord((int) rec.getKey(), rec.getLongValue(ADDR_COL), rec.getBinaryData(BYTES_COL), rec.getBooleanValue(DELAY_COL)); @@ -279,7 +279,7 @@ class PrototypeManager { String valueStr = registerValue != null ? registerValue.getUnsignedValueIgnoreMask().toString() : "0"; - Record record = REGISTER_SCHEMA.createRecord(protoID); + DBRecord record = REGISTER_SCHEMA.createRecord(protoID); record.setString(0, valueStr); contextTable.putRecord(record); } @@ -310,7 +310,7 @@ class PrototypeManager { RecordIterator iter = protoAdapter.getRecords(); while (iter.hasNext()) { - Record record = iter.next(); + DBRecord record = iter.next(); int protoID = (int) record.getKey(); @@ -344,7 +344,7 @@ class PrototypeManager { int getOriginalPrototypeLength(int protoId) { try { - Record record = protoAdapter.getRecord(protoId); + DBRecord record = protoAdapter.getRecord(protoId); if (record != null) { byte[] bytes = record.getBinaryData(BYTES_COL); return bytes.length; @@ -359,7 +359,7 @@ class PrototypeManager { RegisterValue getOriginalPrototypeContext(InstructionPrototype prototype, Register baseContextReg) throws NoValueException { try { - Record record = contextTable.getRecord(protoHt.get(prototype)); + DBRecord record = contextTable.getRecord(protoHt.get(prototype)); if (record != null) { String s = record.getString(0); BigInteger value = s != null ? new BigInteger(s) : BigInteger.ZERO; @@ -372,7 +372,7 @@ class PrototypeManager { return null; } - private InstructionPrototype createPrototype(long protoID, Record record) { + private InstructionPrototype createPrototype(long protoID, DBRecord record) { Address address = addrMap.decodeAddress(record.getLongValue(ADDR_COL)); byte[] bytes = record.getBinaryData(BYTES_COL); MemBuffer memBuffer = new ByteMemBufferImpl(address, bytes, language.isBigEndian()); @@ -465,7 +465,7 @@ class PrototypeManager { return null; } try { - Record record = contextTable.getRecord(protoID); + DBRecord record = contextTable.getRecord(protoID); if (record != null) { String s = record.getString(0); BigInteger value = s != null ? new BigInteger(s) : BigInteger.ZERO; @@ -484,7 +484,7 @@ class PrototypeManager { return null; } try { - Record record = contextTable.getRecord(protoID); + DBRecord record = contextTable.getRecord(protoID); if (record != null) { String s = record.getString(0); BigInteger value = new BigInteger(s); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDB.java index 1d9e811feb..735e684a72 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDB.java @@ -17,7 +17,7 @@ package ghidra.program.database.data; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.docking.settings.SettingsDefinition; import ghidra.program.database.DBObjectCache; @@ -45,7 +45,7 @@ class ArrayDB extends DataTypeDB implements Array { * @param record */ public ArrayDB(DataTypeManagerDB dataMgr, DBObjectCache cache, - ArrayDBAdapter adapter, Record record) { + ArrayDBAdapter adapter, DBRecord record) { super(dataMgr, cache, record); this.adapter = adapter; } @@ -74,7 +74,7 @@ class ArrayDB extends DataTypeDB implements Array { @Override protected boolean refresh() { try { - Record rec = adapter.getRecord(key); + DBRecord rec = adapter.getRecord(key); if (rec != null) { record = rec; return super.refresh(); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapter.java index 500eee0df7..5f82d3212f 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapter.java @@ -67,14 +67,14 @@ abstract class ArrayDBAdapter { tmpAdapter = new ArrayDBAdapterV1(tmpHandle, true); RecordIterator it = oldAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateRecord(rec); } oldAdapter.deleteTable(handle); ArrayDBAdapterV1 newAdapter = new ArrayDBAdapterV1(handle, true); it = tmpAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec); } return newAdapter; @@ -85,16 +85,16 @@ abstract class ArrayDBAdapter { } } - abstract Record createRecord(long dataTypeID, int numberOfElements, int length, long catID) + abstract DBRecord createRecord(long dataTypeID, int numberOfElements, int length, long catID) throws IOException; - abstract Record getRecord(long arrayID) throws IOException; + abstract DBRecord getRecord(long arrayID) throws IOException; abstract RecordIterator getRecords() throws IOException; abstract boolean removeRecord(long dataID) throws IOException; - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; abstract void deleteTable(DBHandle handle) throws IOException; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapterV0.java index 47243e614d..1068127168 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapterV0.java @@ -56,13 +56,13 @@ class ArrayDBAdapterV0 extends ArrayDBAdapter { } @Override - public Record createRecord(long dataTypeID, int numberOfElements, int length, long catID) + public DBRecord createRecord(long dataTypeID, int numberOfElements, int length, long catID) throws IOException { return null; } @Override - public Record getRecord(long arrayID) throws IOException { + public DBRecord getRecord(long arrayID) throws IOException { return translateRecord(table.getRecord(arrayID)); } @@ -77,14 +77,14 @@ class ArrayDBAdapterV0 extends ArrayDBAdapter { } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { } - private Record translateRecord(Record oldRec) { + private DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = ArrayDBAdapter.SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = ArrayDBAdapter.SCHEMA.createRecord(oldRec.getKey()); rec.setLongValue(ArrayDBAdapter.ARRAY_DT_ID_COL, oldRec.getLongValue(V0_ARRAY_DT_ID_COL)); rec.setIntValue(ArrayDBAdapter.ARRAY_DIM_COL, oldRec.getIntValue(V0_ARRAY_DIM_COL)); rec.setIntValue(ArrayDBAdapter.ARRAY_LENGTH_COL, oldRec.getIntValue(V0_ARRAY_LENGTH_COL)); @@ -115,14 +115,14 @@ class ArrayDBAdapterV0 extends ArrayDBAdapter { } @Override - public Record next() throws IOException { - Record rec = it.next(); + public DBRecord next() throws IOException { + DBRecord rec = it.next(); return translateRecord(rec); } @Override - public Record previous() throws IOException { - Record rec = it.previous(); + public DBRecord previous() throws IOException { + DBRecord rec = it.previous(); return translateRecord(rec); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapterV1.java index 3212f66737..92e734bd58 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ArrayDBAdapterV1.java @@ -64,7 +64,7 @@ class ArrayDBAdapterV1 extends ArrayDBAdapter { } @Override - public Record createRecord(long dataTypeID, int numberOfElements, int length, long catID) + public DBRecord createRecord(long dataTypeID, int numberOfElements, int length, long catID) throws IOException { long tableKey = table.getKey(); @@ -73,7 +73,7 @@ class ArrayDBAdapterV1 extends ArrayDBAdapter { // } long key = DataTypeManagerDB.createKey(DataTypeManagerDB.ARRAY, tableKey); - Record record = V1_SCHEMA.createRecord(key); + DBRecord record = V1_SCHEMA.createRecord(key); record.setLongValue(V1_ARRAY_DT_ID_COL, dataTypeID); record.setIntValue(V1_ARRAY_DIM_COL, numberOfElements); record.setIntValue(V1_ARRAY_LENGTH_COL, length); @@ -83,7 +83,7 @@ class ArrayDBAdapterV1 extends ArrayDBAdapter { } @Override - public Record getRecord(long arrayID) throws IOException { + public DBRecord getRecord(long arrayID) throws IOException { return table.getRecord(arrayID); } @@ -98,7 +98,7 @@ class ArrayDBAdapterV1 extends ArrayDBAdapter { } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/BuiltinDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/BuiltinDBAdapter.java index acfe8d8741..809a6f4097 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/BuiltinDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/BuiltinDBAdapter.java @@ -53,7 +53,7 @@ public abstract class BuiltinDBAdapter { * @return new record * @throws IOException if there was a problem accessing the database */ - abstract Record createRecord(String name, String className, long categoryID) throws IOException; + abstract DBRecord createRecord(String name, String className, long categoryID) throws IOException; /** * Gets the Built-in data type record with the indicated ID. @@ -61,7 +61,7 @@ public abstract class BuiltinDBAdapter { * @return the record for the Built-in data type. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecord(long dataTypeID) throws IOException; + abstract DBRecord getRecord(long dataTypeID) throws IOException; /** * Returns an array containing the data type IDs for the given category ID @@ -77,7 +77,7 @@ public abstract class BuiltinDBAdapter { * @param record the new record * @throws IOException if there was a problem accessing the database */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Remove the record with the given dataID. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/BuiltinDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/BuiltinDBAdapterV0.java index a2010df9de..7f6333879a 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/BuiltinDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/BuiltinDBAdapterV0.java @@ -64,7 +64,7 @@ class BuiltinDBAdapterV0 extends BuiltinDBAdapter { } @Override - public Record getRecord(long dataTypeID) throws IOException { + public DBRecord getRecord(long dataTypeID) throws IOException { return table.getRecord(dataTypeID); } @@ -74,7 +74,7 @@ class BuiltinDBAdapterV0 extends BuiltinDBAdapter { } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } @@ -84,7 +84,7 @@ class BuiltinDBAdapterV0 extends BuiltinDBAdapter { } @Override - public Record createRecord(String name, String className, long categoryID) throws IOException { + public DBRecord createRecord(String name, String className, long categoryID) throws IOException { long tableKey = table.getKey(); if (tableKey <= 100) { @@ -92,7 +92,7 @@ class BuiltinDBAdapterV0 extends BuiltinDBAdapter { } long key = DataTypeManagerDB.createKey(DataTypeManagerDB.BUILT_IN, tableKey); - Record record = V0_SCHEMA.createRecord(key); + DBRecord record = V0_SCHEMA.createRecord(key); record.setString(V0_BUILT_IN_NAME_COL, name); record.setString(V0_BUILT_IN_CLASSNAME_COL, className); record.setLongValue(V0_BUILT_IN_CAT_COL, categoryID); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDB.java index f6a9cec400..b9394d8b60 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDB.java @@ -20,7 +20,7 @@ import java.util.*; import java.util.concurrent.ConcurrentHashMap; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; import ghidra.program.model.data.*; @@ -112,7 +112,7 @@ class CategoryDB extends DatabaseObject implements Category { } @Override - protected boolean refresh(Record rec) { + protected boolean refresh(DBRecord rec) { subcategoryMap.clear(); dataTypeMap.clear(); conflictMap.clear(); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDBAdapter.java index f57771ffe4..eef84c63b8 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDBAdapter.java @@ -39,7 +39,7 @@ abstract class CategoryDBAdapter { * @return the record for the given ID or null if no record with that id exists. * @throws IOException if IO error occurs */ - abstract Record getRecord(long categoryID) throws IOException; + abstract DBRecord getRecord(long categoryID) throws IOException; /** * Updates the record in the database @@ -67,7 +67,7 @@ abstract class CategoryDBAdapter { * @return a new record for the new category. * @throws IOException if IO error occurs */ - abstract Record createCategory(String name, long parentID) throws IOException; + abstract DBRecord createCategory(String name, long parentID) throws IOException; /** * Removes the category with the given ID. @@ -82,9 +82,9 @@ abstract class CategoryDBAdapter { * @return root category record * @throws IOException if IO error occurs */ - abstract Record getRootRecord() throws IOException; + abstract DBRecord getRootRecord() throws IOException; - abstract void putRecord(Record record) throws IOException; + abstract void putRecord(DBRecord record) throws IOException; abstract int getRecordCount(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDBAdapterV0.java index e94ea31390..cb10e688ef 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CategoryDBAdapterV0.java @@ -56,7 +56,7 @@ class CategoryDBAdapterV0 extends CategoryDBAdapter { } @Override - public Record getRecord(long categoryID) throws IOException { + public DBRecord getRecord(long categoryID) throws IOException { return table.getRecord(categoryID); } @@ -67,24 +67,24 @@ class CategoryDBAdapterV0 extends CategoryDBAdapter { @Override void updateRecord(long categoryID, long parentID, String name) throws IOException { - Record rec = table.getSchema().createRecord(categoryID); + DBRecord rec = table.getSchema().createRecord(categoryID); rec.setString(V0_CATEGORY_NAME_COL, name); rec.setLongValue(V0_CATEGORY_PARENT_COL, parentID); table.putRecord(rec); } @Override - void putRecord(Record record) throws IOException { + void putRecord(DBRecord record) throws IOException { table.putRecord(record); } @Override - public Record createCategory(String name, long parentID) throws IOException { + public DBRecord createCategory(String name, long parentID) throws IOException { long key = table.getKey(); if (key == 0) { key = 1; } - Record rec = table.getSchema().createRecord(key); + DBRecord rec = table.getSchema().createRecord(key); rec.setString(V0_CATEGORY_NAME_COL, name); rec.setLongValue(V0_CATEGORY_PARENT_COL, parentID); table.putRecord(rec); @@ -98,7 +98,7 @@ class CategoryDBAdapterV0 extends CategoryDBAdapter { } @Override - public Record getRootRecord() throws IOException { + public DBRecord getRootRecord() throws IOException { Field[] keys = table.findRecords(new LongField(-1), V0_CATEGORY_PARENT_COL); if (keys.length != 1) { throw new IOException("Found " + keys.length + " entries for root category"); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ComponentDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ComponentDBAdapter.java index 4296c02173..021e0c8114 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ComponentDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ComponentDBAdapter.java @@ -65,7 +65,7 @@ abstract class ComponentDBAdapter { * @return the component data type record. * @throws IOException if there is a problem accessing the database. */ - abstract Record createRecord(long dataTypeID, long parentID, int length, int ordinal, + abstract DBRecord createRecord(long dataTypeID, long parentID, int length, int ordinal, int offset, String name, String comment) throws IOException; /** @@ -74,7 +74,7 @@ abstract class ComponentDBAdapter { * @return the component record * @throws IOException if there is a problem accessing the database. */ - abstract Record getRecord(long componentID) throws IOException; + abstract DBRecord getRecord(long componentID) throws IOException; /** * Removes the component data type record with the specified ID. @@ -89,7 +89,7 @@ abstract class ComponentDBAdapter { * @param record the new record * @throws IOException if there is a problem accessing the database. */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Gets an array with all of the IDs of the defined components within the composite data type indicated. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ComponentDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ComponentDBAdapterV0.java index 46cb232c02..69f8f3a1aa 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ComponentDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ComponentDBAdapterV0.java @@ -74,7 +74,7 @@ class ComponentDBAdapterV0 extends ComponentDBAdapter { } @Override - public Record createRecord(long dataTypeID, long parentID, int length, int ordinal, int offset, + public DBRecord createRecord(long dataTypeID, long parentID, int length, int ordinal, int offset, String name, String comment) throws IOException { long tableKey = componentTable.getKey(); @@ -82,7 +82,7 @@ class ComponentDBAdapterV0 extends ComponentDBAdapter { // tableKey = DataManager.VOID_DATATYPE_ID +1; // } long key = DataTypeManagerDB.createKey(DataTypeManagerDB.COMPONENT, tableKey); - Record record = ComponentDBAdapter.COMPONENT_SCHEMA.createRecord(key); + DBRecord record = ComponentDBAdapter.COMPONENT_SCHEMA.createRecord(key); record.setLongValue(ComponentDBAdapter.COMPONENT_PARENT_ID_COL, parentID); record.setLongValue(ComponentDBAdapter.COMPONENT_OFFSET_COL, offset); record.setLongValue(ComponentDBAdapter.COMPONENT_DT_ID_COL, dataTypeID); @@ -95,12 +95,12 @@ class ComponentDBAdapterV0 extends ComponentDBAdapter { } @Override - public Record getRecord(long componentID) throws IOException { + public DBRecord getRecord(long componentID) throws IOException { return componentTable.getRecord(componentID); } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { componentTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDB.java index 4bef0a2106..10303f9fdf 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDB.java @@ -17,7 +17,7 @@ package ghidra.program.database.data; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.program.database.DBObjectCache; import ghidra.program.model.data.*; @@ -55,7 +55,7 @@ abstract class CompositeDB extends DataTypeDB implements Composite { */ CompositeDB(DataTypeManagerDB dataMgr, DBObjectCache cache, CompositeDBAdapter compositeAdapter, ComponentDBAdapter componentAdapter, - Record record) { + DBRecord record) { super(dataMgr, cache, record); this.compositeAdapter = compositeAdapter; this.componentAdapter = componentAdapter; @@ -154,7 +154,7 @@ abstract class CompositeDB extends DataTypeDB implements Composite { @Override protected boolean refresh() { try { - Record rec = compositeAdapter.getRecord(key); + DBRecord rec = compositeAdapter.getRecord(key); if (rec != null) { record = rec; initialize(); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapter.java index 25c7163dfe..06642b19eb 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapter.java @@ -136,7 +136,7 @@ abstract class CompositeDBAdapter { RecordIterator it = oldAdapter.getRecords(); while (it.hasNext()) { monitor.checkCanceled(); - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateRecord(rec, false); } oldAdapter.deleteTable(handle); @@ -144,7 +144,7 @@ abstract class CompositeDBAdapter { it = tmpAdapter.getRecords(); while (it.hasNext()) { monitor.checkCanceled(); - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec, false); } return newAdapter; @@ -172,7 +172,7 @@ abstract class CompositeDBAdapter { * @return the database record for this data type. * @throws IOException if the database can't be accessed. */ - abstract Record createRecord(String name, String comments, boolean isUnion, long categoryID, + abstract DBRecord createRecord(String name, String comments, boolean isUnion, long categoryID, int length, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime, int internalAlignment, int externalAlignment) throws IOException; @@ -182,7 +182,7 @@ abstract class CompositeDBAdapter { * @return the record for the composite (structure or union) data type. * @throws IOException if the database can't be accessed. */ - abstract Record getRecord(long dataTypeID) throws IOException; + abstract DBRecord getRecord(long dataTypeID) throws IOException; /** * Gets an iterator over all composite (structure and union) data type records. @@ -198,7 +198,7 @@ abstract class CompositeDBAdapter { * current time before putting the record in the database. * @throws IOException if the database can't be accessed. */ - abstract void updateRecord(Record record, boolean setLastChangeTime) throws IOException; + abstract void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException; /** * Removes the composite data type record with the specified ID. @@ -240,7 +240,7 @@ abstract class CompositeDBAdapter { * @return composite record found or null * @throws IOException if IO error occurs */ - abstract Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) + abstract DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV0.java index 2b49b1e4f4..42f5c382b2 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV0.java @@ -68,7 +68,7 @@ class CompositeDBAdapterV0 extends CompositeDBAdapter implements RecordTranslato } @Override - public Record createRecord(String name, String comments, boolean isUnion, long categoryID, + public DBRecord createRecord(String name, String comments, boolean isUnion, long categoryID, int length, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime, int internalAlignment, int externalAlignment) throws IOException { throw new UnsupportedOperationException("Not allowed to update prior version #" + VERSION + @@ -76,7 +76,7 @@ class CompositeDBAdapterV0 extends CompositeDBAdapter implements RecordTranslato } @Override - public Record getRecord(long dataTypeID) throws IOException { + public DBRecord getRecord(long dataTypeID) throws IOException { return translateRecord(compositeTable.getRecord(dataTypeID)); } @@ -86,7 +86,7 @@ class CompositeDBAdapterV0 extends CompositeDBAdapter implements RecordTranslato } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { throw new UnsupportedOperationException(); } @@ -112,11 +112,11 @@ class CompositeDBAdapterV0 extends CompositeDBAdapter implements RecordTranslato } @Override - public Record translateRecord(Record oldRec) { + public DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = CompositeDBAdapter.COMPOSITE_SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = CompositeDBAdapter.COMPOSITE_SCHEMA.createRecord(oldRec.getKey()); rec.setString(COMPOSITE_NAME_COL, oldRec.getString(V0_COMPOSITE_NAME_COL)); rec.setString(COMPOSITE_COMMENT_COL, oldRec.getString(V0_COMPOSITE_COMMENT_COL)); rec.setBooleanValue(COMPOSITE_IS_UNION_COL, @@ -135,7 +135,7 @@ class CompositeDBAdapterV0 extends CompositeDBAdapter implements RecordTranslato } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV1.java index d1b9ab548c..bc75c3ccec 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV1.java @@ -71,7 +71,7 @@ class CompositeDBAdapterV1 extends CompositeDBAdapter implements RecordTranslato } @Override - public Record createRecord(String name, String comments, boolean isUnion, long categoryID, + public DBRecord createRecord(String name, String comments, boolean isUnion, long categoryID, int length, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime, int internalAlignment, int externalAlignment) throws IOException { throw new UnsupportedOperationException("Not allowed to update prior version #" + VERSION + @@ -79,7 +79,7 @@ class CompositeDBAdapterV1 extends CompositeDBAdapter implements RecordTranslato } @Override - public Record getRecord(long dataTypeID) throws IOException { + public DBRecord getRecord(long dataTypeID) throws IOException { return translateRecord(compositeTable.getRecord(dataTypeID)); } @@ -89,7 +89,7 @@ class CompositeDBAdapterV1 extends CompositeDBAdapter implements RecordTranslato } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { throw new UnsupportedOperationException(); } @@ -119,11 +119,11 @@ class CompositeDBAdapterV1 extends CompositeDBAdapter implements RecordTranslato * @see db.RecordTranslator#translateRecord(db.Record) */ @Override - public Record translateRecord(Record oldRec) { + public DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = CompositeDBAdapter.COMPOSITE_SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = CompositeDBAdapter.COMPOSITE_SCHEMA.createRecord(oldRec.getKey()); rec.setString(COMPOSITE_NAME_COL, oldRec.getString(V1_COMPOSITE_NAME_COL)); rec.setString(COMPOSITE_COMMENT_COL, oldRec.getString(V1_COMPOSITE_COMMENT_COL)); rec.setBooleanValue(COMPOSITE_IS_UNION_COL, @@ -146,12 +146,12 @@ class CompositeDBAdapterV1 extends CompositeDBAdapter implements RecordTranslato } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { Field[] keys = compositeTable.findRecords(new LongField(datatypeID.getValue()), V1_COMPOSITE_UNIVERSAL_DT_ID_COL); for (int i = 0; i < keys.length; i++) { - Record record = compositeTable.getRecord(keys[i]); + DBRecord record = compositeTable.getRecord(keys[i]); if (record.getLongValue(V1_COMPOSITE_SOURCE_ARCHIVE_ID_COL) == sourceID.getValue()) { return translateRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV2V3.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV2V3.java index af757d2b3c..5a2b99a956 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV2V3.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDBAdapterV2V3.java @@ -123,7 +123,7 @@ class CompositeDBAdapterV2V3 extends CompositeDBAdapter { } @Override - public Record createRecord(String name, String comments, boolean isUnion, long categoryID, + public DBRecord createRecord(String name, String comments, boolean isUnion, long categoryID, int length, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime, int internalAlignment, int externalAlignment) throws IOException { if (readOnly) { @@ -137,7 +137,7 @@ class CompositeDBAdapterV2V3 extends CompositeDBAdapter { // tableKey = DataManager.VOID_DATATYPE_ID +1; // } long key = DataTypeManagerDB.createKey(DataTypeManagerDB.COMPOSITE, tableKey); - Record record = CompositeDBAdapter.COMPOSITE_SCHEMA.createRecord(key); + DBRecord record = CompositeDBAdapter.COMPOSITE_SCHEMA.createRecord(key); record.setString(V2_COMPOSITE_NAME_COL, name); record.setString(V2_COMPOSITE_COMMENT_COL, comments); @@ -156,7 +156,7 @@ class CompositeDBAdapterV2V3 extends CompositeDBAdapter { } @Override - public Record getRecord(long dataTypeID) throws IOException { + public DBRecord getRecord(long dataTypeID) throws IOException { return compositeTable.getRecord(dataTypeID); } @@ -166,7 +166,7 @@ class CompositeDBAdapterV2V3 extends CompositeDBAdapter { } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { if (readOnly) { throw new ReadOnlyException(); } @@ -203,12 +203,12 @@ class CompositeDBAdapterV2V3 extends CompositeDBAdapter { } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { Field[] keys = compositeTable.findRecords(new LongField(datatypeID.getValue()), V2_COMPOSITE_UNIVERSAL_DT_ID_COL); for (int i = 0; i < keys.length; i++) { - Record record = compositeTable.getRecord(keys[i]); + DBRecord record = compositeTable.getRecord(keys[i]); if (record.getLongValue(V2_COMPOSITE_SOURCE_ARCHIVE_ID_COL) == sourceID.getValue()) { return record; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeComponentDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeComponentDB.java index ca8e1027e8..fd6036582f 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeComponentDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeComponentDB.java @@ -20,7 +20,7 @@ package ghidra.program.database.data; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.program.model.data.*; import ghidra.util.SystemUtilities; @@ -35,7 +35,7 @@ class DataTypeComponentDB implements InternalDataTypeComponent { private final DataTypeManagerDB dataMgr; private final ComponentDBAdapter adapter; - private final Record record; // null record -> undefined component + private final DBRecord record; // null record -> undefined component private final Composite parent; private DataType cachedDataType; // required for bit-fields during packing process @@ -78,7 +78,7 @@ class DataTypeComponentDB implements InternalDataTypeComponent { * @param record */ DataTypeComponentDB(DataTypeManagerDB dataMgr, ComponentDBAdapter adapter, Composite parent, - Record record) { + DBRecord record) { this.dataMgr = dataMgr; this.adapter = adapter; this.record = record; @@ -438,7 +438,7 @@ class DataTypeComponentDB implements InternalDataTypeComponent { } } - Record getRecord() { + DBRecord getRecord() { return record; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeDB.java index e892c67bd1..f585736d45 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeDB.java @@ -22,7 +22,7 @@ import java.util.List; import javax.swing.event.ChangeEvent; import javax.swing.event.ChangeListener; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.docking.settings.SettingsDefinition; import ghidra.program.database.DBObjectCache; @@ -40,7 +40,7 @@ import ghidra.util.exception.NotYetImplementedException; */ abstract class DataTypeDB extends DatabaseObject implements DataType, ChangeListener { - protected Record record; + protected DBRecord record; protected final DataTypeManagerDB dataMgr; private volatile Settings defaultSettings; private final static SettingsDefinition[] EMPTY_DEFINITIONS = new SettingsDefinition[0]; @@ -51,7 +51,7 @@ abstract class DataTypeDB extends DatabaseObject implements DataType, ChangeList private volatile Category category; protected DataTypeDB(DataTypeManagerDB dataMgr, DBObjectCache cache, - Record record) { + DBRecord record) { super(cache, record.getKey()); this.dataMgr = dataMgr; this.record = record; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeManagerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeManagerDB.java index 29ed68bf6b..8cbe939628 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeManagerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeManagerDB.java @@ -701,7 +701,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { } CategoryDB cat = catCache.get(id); if (cat == null) { - Record rec = categoryAdapter.getRecord(id); + DBRecord rec = categoryAdapter.getRecord(id); if (rec != null) { long parentID = rec.getLongValue(CategoryDBAdapter.CATEGORY_PARENT_COL); CategoryDB parent = getCategoryDB(parentID); @@ -717,7 +717,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { if (c != null) { return c; } - Record rec = categoryAdapter.createCategory(categoryName, parent.getKey()); + DBRecord rec = categoryAdapter.createCategory(categoryName, parent.getKey()); String name = rec.getString(CategoryDBAdapter.CATEGORY_NAME_COL); CategoryDB cat = new CategoryDB(this, catCache, rec.getKey(), parent, name); parent.categoryAdded(cat);// must be before the event notification below @@ -1180,7 +1180,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return getSourceArchive(sourceArchive.getSourceArchiveID()); } try { - Record record = sourceArchiveAdapter.createRecord(sourceArchive); + DBRecord record = sourceArchiveAdapter.createRecord(sourceArchive); SourceArchive newSourceArchive = getSourceArchiveDB(record); invalidateSourceArchiveCache(); sourceArchiveAdded(newSourceArchive.getSourceArchiveID()); @@ -2029,7 +2029,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return (int) (dataID >> DATA_TYPE_KIND_SHIFT); } - private DataType getDataType(long dataTypeID, Record record) { + private DataType getDataType(long dataTypeID, DBRecord record) { int tableId = getTableID(dataTypeID); switch (tableId) { case BUILT_IN: @@ -2053,7 +2053,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { } } - private DataType getBuiltInDataType(long dataTypeID, Record record) { + private DataType getBuiltInDataType(long dataTypeID, DBRecord record) { lock.acquire(); try { Long key = dataTypeID; @@ -2118,7 +2118,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return null; } - private Enum getEnumDataType(long dataTypeID, Record record) { + private Enum getEnumDataType(long dataTypeID, DBRecord record) { lock.acquire(); try { EnumDB enu = (EnumDB) dtCache.get(dataTypeID); @@ -2141,7 +2141,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return null; } - private Composite getCompositeDataType(long dataTypeID, Record record) { + private Composite getCompositeDataType(long dataTypeID, DBRecord record) { lock.acquire(); try { CompositeDB comp = (CompositeDB) dtCache.get(dataTypeID); @@ -2171,7 +2171,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return null; } - private TypeDef getTypedefDataType(long dataTypeID, Record record) { + private TypeDef getTypedefDataType(long dataTypeID, DBRecord record) { lock.acquire(); try { TypedefDB typeDB = (TypedefDB) dtCache.get(dataTypeID); @@ -2194,7 +2194,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return null; } - private Array getArrayDataType(long dataTypeID, Record record) { + private Array getArrayDataType(long dataTypeID, DBRecord record) { lock.acquire(); try { ArrayDB arrayDB = (ArrayDB) dtCache.get(dataTypeID); @@ -2218,7 +2218,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return null; } - private Pointer getPointerDataType(long dataTypeID, Record record) { + private Pointer getPointerDataType(long dataTypeID, DBRecord record) { lock.acquire(); try { PointerDB ptrDB = (PointerDB) dtCache.get(dataTypeID); @@ -2242,7 +2242,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return null; } - private FunctionDefinition getFunctionDefDataType(long dataTypeID, Record record) { + private FunctionDefinition getFunctionDefDataType(long dataTypeID, DBRecord record) { lock.acquire(); try { FunctionDefinitionDB funDef = (FunctionDefinitionDB) dtCache.get(dataTypeID); @@ -2356,7 +2356,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { if (struct.isNotYetDefined() || struct.isInternallyAligned()) { len = 0; } - Record record = compositeAdapter.createRecord(name, struct.getDescription(), false, + DBRecord record = compositeAdapter.createRecord(name, struct.getDescription(), false, category.getID(), len, sourceArchiveIdValue, universalIdValue, struct.getLastChangeTime(), getInternalAlignment(struct), getExternalAlignment(struct)); @@ -2421,7 +2421,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { throw new IllegalArgumentException("Data type must have a valid name"); } DataType dataType = resolve(typedef.getDataType(), getDependencyConflictHandler()); - Record record = typedefAdapter.createRecord(getID(dataType), name, cat.getID(), + DBRecord record = typedefAdapter.createRecord(getID(dataType), name, cat.getID(), sourceArchiveIdValue, universalIdValue, typedef.getLastChangeTime()); TypedefDB typedefDB = new TypedefDB(this, dtCache, typedefAdapter, record); dataType.addParent(typedefDB); @@ -2437,7 +2437,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { } try { creatingDataType++; - Record record = compositeAdapter.createRecord(name, null, true, category.getID(), 0, + DBRecord record = compositeAdapter.createRecord(name, null, true, category.getID(), 0, sourceArchiveIdValue, universalIdValue, union.getLastChangeTime(), getInternalAlignment(union), getExternalAlignment(union)); UnionDB unionDB = @@ -2467,7 +2467,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { if (name == null || name.length() == 0) { throw new IllegalArgumentException("Data type must have a valid name"); } - Record record = enumAdapter.createRecord(name, enumm.getDescription(), cat.getID(), + DBRecord record = enumAdapter.createRecord(name, enumm.getDescription(), cat.getID(), (byte) enumm.getLength(), sourceArchiveIdValue, universalIdValue, enumm.getLastChangeTime()); long enumID = record.getKey(); @@ -2487,7 +2487,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { } long dataTypeID = getResolvedID(dt); - Record record = pointerAdapter.createRecord(dataTypeID, cat.getID(), length); + DBRecord record = pointerAdapter.createRecord(dataTypeID, cat.getID(), length); PointerDB ptrDB = new PointerDB(this, dtCache, pointerAdapter, record); if (dt != null) { dt.addParent(ptrDB); @@ -2518,7 +2518,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { elementLength = -1; } - Record record = + DBRecord record = arrayAdapter.createRecord(dataTypeID, numElements, elementLength, cat.getID()); addParentChildRecord(record.getKey(), dataTypeID); ArrayDB arrayDB = new ArrayDB(this, dtCache, arrayAdapter, record); @@ -2617,8 +2617,8 @@ abstract public class DataTypeManagerDB implements DataTypeManager { Map archiveMap = new HashMap<>(); archiveMap.put(BUILT_IN_ARCHIVE_UNIVERSAL_ID, BuiltInSourceArchive.INSTANCE); try { - List records = sourceArchiveAdapter.getRecords(); - for (Record record : records) { + List records = sourceArchiveAdapter.getRecords(); + for (DBRecord record : records) { SourceArchive sourceArchive = getSourceArchiveDB(record); archiveMap.put(sourceArchive.getSourceArchiveID(), sourceArchive); } @@ -2630,7 +2630,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { sourceArchiveMap = archiveMap; } - private SourceArchiveDB getSourceArchiveDB(Record record) { + private SourceArchiveDB getSourceArchiveDB(DBRecord record) { SourceArchiveDB archive = sourceArchiveDBCache.get(record.getKey()); if (archive == null) { archive = new SourceArchiveDB(this, sourceArchiveDBCache, sourceArchiveAdapter, record); @@ -2674,14 +2674,14 @@ abstract public class DataTypeManagerDB implements DataTypeManager { private DataType createMissingBuiltIn(MissingBuiltInDataType dt, Category category) throws IOException { - Record record = builtinAdapter.createRecord(dt.getMissingBuiltInName(), + DBRecord record = builtinAdapter.createRecord(dt.getMissingBuiltInName(), dt.getMissingBuiltInClassPath(), category.getID()); return getBuiltInDataType(record.getKey(), record); } private DataType createBuiltIn(BuiltInDataType dt, Category category) throws IOException { - Record record = + DBRecord record = builtinAdapter.createRecord(dt.getName(), dt.getClass().getName(), category.getID()); return getBuiltInDataType(record.getKey(), record); } @@ -2693,7 +2693,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { } try { creatingDataType++; - Record record = functionDefAdapter.createRecord(name, funDef.getComment(), cat.getID(), + DBRecord record = functionDefAdapter.createRecord(name, funDef.getComment(), cat.getID(), DEFAULT_DATATYPE_ID, funDef.hasVarArgs(), funDef.getGenericCallingConvention(), sourceArchiveIdValue, universalIdValue, funDef.getLastChangeTime()); FunctionDefinitionDB funDefDb = @@ -2749,7 +2749,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { private void getNextStruct() { try { while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); DataType dt = getDataType(rec.getKey(), rec); if (dt instanceof Structure) { nextStruct = (StructureDB) dt; @@ -2797,7 +2797,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { private void getNextComposite() { try { if (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); nextComposite = (CompositeDB) getDataType(rec.getKey(), rec); } } @@ -2856,13 +2856,13 @@ abstract public class DataTypeManagerDB implements DataTypeManager { try { for (Field arrayId : arrayAdapter.getRecordIdsInCategory(oldCatId)) { long id = arrayId.getLongValue(); - Record rec = arrayAdapter.getRecord(id); + DBRecord rec = arrayAdapter.getRecord(id); ArrayDB array = (ArrayDB) getDataType(id, rec); array.updatePath(dt); } for (Field ptrId : pointerAdapter.getRecordIdsInCategory(oldCatId)) { long id = ptrId.getLongValue(); - Record rec = pointerAdapter.getRecord(id); + DBRecord rec = pointerAdapter.getRecord(id); PointerDB ptr = (PointerDB) getDataType(id, rec); ptr.updatePath(dt); } @@ -3234,7 +3234,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { instanceSettingsAdapter.getRecords(range.minKey, range.maxKey); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); tmpTable.putRecord(rec); iter.delete(); } @@ -3243,7 +3243,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { RecordIterator iter = tmpTable.iterator(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); // update address column and re-introduce into table Address addr = addrMap.decodeAddress( rec.getLongValue(InstanceSettingsDBAdapter.INST_ADDR_COL)); @@ -3291,7 +3291,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { Field[] keys = instanceSettingsAdapter.getInstanceKeys(addrMap.getKey(dataAddr, false)); ArrayList list = new ArrayList<>(); for (Field key : keys) { - Record rec = instanceSettingsAdapter.getInstanceRecord(key.getLongValue()); + DBRecord rec = instanceSettingsAdapter.getInstanceRecord(key.getLongValue()); list.add(rec.getString(InstanceSettingsDBAdapter.INST_NAME_COL)); } String[] names = new String[list.size()]; @@ -3342,13 +3342,13 @@ abstract public class DataTypeManagerDB implements DataTypeManager { wasChanged = true; // create new record - Record rec = instanceSettingsAdapter.createInstanceRecord( + DBRecord rec = instanceSettingsAdapter.createInstanceRecord( addrMap.getKey(dataAddr, true), name, strValue, longValue, byteValue); settings = new InstanceSettingsDB(rec); settingsCache.put(dataAddr, name, settings); } else { - Record rec = settings.getRecord(); + DBRecord rec = settings.getRecord(); String recStrValue = rec.getString(SettingsDBAdapter.SETTINGS_STRING_VALUE_COL); byte[] recByteValue = rec.getBinaryData(SettingsDBAdapter.SETTINGS_BYTE_VALUE_COL); long recLongValue = rec.getLongValue(SettingsDBAdapter.SETTINGS_LONG_VALUE_COL); @@ -3383,7 +3383,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { return settings; } long addr = addrMap.getKey(dataAddr, false); - Record rec = getInstanceRecord(addr, name); + DBRecord rec = getInstanceRecord(addr, name); if (rec != null) { settings = new InstanceSettingsDB(rec); settingsCache.put(dataAddr, name, settings); @@ -3396,11 +3396,11 @@ abstract public class DataTypeManagerDB implements DataTypeManager { } } - private Record getInstanceRecord(long addr, String name) { + private DBRecord getInstanceRecord(long addr, String name) { try { Field[] keys = instanceSettingsAdapter.getInstanceKeys(addr); for (Field key : keys) { - Record rec = instanceSettingsAdapter.getInstanceRecord(key.getLongValue()); + DBRecord rec = instanceSettingsAdapter.getInstanceRecord(key.getLongValue()); if (rec.getString(InstanceSettingsDBAdapter.INST_NAME_COL).equals(name)) { return rec; } @@ -3718,7 +3718,7 @@ abstract public class DataTypeManagerDB implements DataTypeManager { private DataType findDataTypeForIDs(UniversalID sourceID, UniversalID datatypeID) { lock.acquire(); - Record record = null; + DBRecord record = null; try { record = typedefAdapter.getRecordWithIDs(sourceID, datatypeID); if (record == null) { @@ -3756,8 +3756,8 @@ abstract public class DataTypeManagerDB implements DataTypeManager { if (openMode == DBConstants.CREATE || openMode == DBConstants.READ_ONLY) { return false; } - List records = sourceArchiveAdapter.getRecords(); - for (Record record : records) { + List records = sourceArchiveAdapter.getRecords(); + for (DBRecord record : records) { if (SourceArchiveUpgradeMap.isReplacedSourceArchive(record.getKey())) { return true; } @@ -4208,9 +4208,9 @@ abstract public class DataTypeManagerDB implements DataTypeManager { */ class InstanceSettingsDB { - private Record record; + private DBRecord record; - InstanceSettingsDB(Record record) { + InstanceSettingsDB(DBRecord record) { this.record = record; } @@ -4230,7 +4230,7 @@ class InstanceSettingsDB { return record.getLongValue(InstanceSettingsDBAdapter.INST_LONG_VALUE_COL); } - Record getRecord() { + DBRecord getRecord() { return record; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDB.java index 29c9c6550b..7e9bfc7fae 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDB.java @@ -20,7 +20,7 @@ import java.math.BigInteger; import java.util.*; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.docking.settings.SettingsDefinition; import ghidra.program.database.DBObjectCache; @@ -47,7 +47,7 @@ class EnumDB extends DataTypeDB implements Enum { private List bitGroups; EnumDB(DataTypeManagerDB dataMgr, DBObjectCache cache, EnumDBAdapter adapter, - EnumValueDBAdapter valueAdapter, Record record) { + EnumValueDBAdapter valueAdapter, DBRecord record) { super(dataMgr, cache, record); this.adapter = adapter; this.valueAdapter = valueAdapter; @@ -88,7 +88,7 @@ class EnumDB extends DataTypeDB implements Enum { Field[] ids = valueAdapter.getValueIdsInEnum(key); for (Field id : ids) { - Record rec = valueAdapter.getRecord(id.getLongValue()); + DBRecord rec = valueAdapter.getRecord(id.getLongValue()); String valueName = rec.getString(EnumValueDBAdapter.ENUMVAL_NAME_COL); long value = rec.getLongValue(EnumValueDBAdapter.ENUMVAL_VALUE_COL); addToCache(valueName, value); @@ -256,7 +256,7 @@ class EnumDB extends DataTypeDB implements Enum { Field[] ids = valueAdapter.getValueIdsInEnum(key); for (Field id : ids) { - Record rec = valueAdapter.getRecord(id.getLongValue()); + DBRecord rec = valueAdapter.getRecord(id.getLongValue()); if (valueName.equals(rec.getString(EnumValueDBAdapter.ENUMVAL_NAME_COL))) { valueAdapter.removeRecord(id.getLongValue()); break; @@ -554,7 +554,7 @@ class EnumDB extends DataTypeDB implements Enum { nameMap = null; valueMap = null; bitGroups = null; - Record rec = adapter.getRecord(key); + DBRecord rec = adapter.getRecord(key); if (rec != null) { record = rec; return super.refresh(); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapter.java index b01d062d6c..ed43292eea 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapter.java @@ -108,14 +108,14 @@ abstract class EnumDBAdapter { tmpAdapter = new EnumDBAdapterV1(tmpHandle, true); RecordIterator it = oldAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateRecord(rec, false); } oldAdapter.deleteTable(handle); EnumDBAdapterV1 newAdapter = new EnumDBAdapterV1(handle, true); it = tmpAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec, false); } return newAdapter; @@ -138,7 +138,7 @@ abstract class EnumDBAdapter { * @return the database record for this data type. * @throws IOException if the database can't be accessed. */ - abstract Record createRecord(String name, String comments, long categoryID, byte size, + abstract DBRecord createRecord(String name, String comments, long categoryID, byte size, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException; /** @@ -147,7 +147,7 @@ abstract class EnumDBAdapter { * @return the record for the enumeration data type. * @throws IOException if the database can't be accessed. */ - abstract Record getRecord(long enumID) throws IOException; + abstract DBRecord getRecord(long enumID) throws IOException; /** * Gets an iterator over all enumeration data type records. @@ -163,7 +163,7 @@ abstract class EnumDBAdapter { * current time before putting the record in the database. * @throws IOException if the database can't be accessed. */ - abstract void updateRecord(Record record, boolean setLastChangeTime) throws IOException; + abstract void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException; /** * Remove the record for the given enumeration ID, and remove all of its @@ -204,7 +204,7 @@ abstract class EnumDBAdapter { * @return enum record found or null * @throws IOException if IO error occurs */ - abstract Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) + abstract DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterNoTable.java index 3a69800511..5982930d78 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterNoTable.java @@ -34,14 +34,14 @@ class EnumDBAdapterNoTable extends EnumDBAdapter { } @Override - public Record createRecord(String name, String comments, long categoryID, byte size, + public DBRecord createRecord(String name, String comments, long categoryID, byte size, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException { throw new UnsupportedOperationException( "Not allowed to update version prior to existence of Enumeration Data Types table."); } @Override - public Record getRecord(long enumID) throws IOException { + public DBRecord getRecord(long enumID) throws IOException { return null; } @@ -51,7 +51,7 @@ class EnumDBAdapterNoTable extends EnumDBAdapter { } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { throw new UnsupportedOperationException(); } @@ -75,7 +75,7 @@ class EnumDBAdapterNoTable extends EnumDBAdapter { } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterV0.java index af396ba490..733b9a9708 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterV0.java @@ -67,14 +67,14 @@ class EnumDBAdapterV0 extends EnumDBAdapter implements RecordTranslator { } @Override - public Record createRecord(String name, String comments, long categoryID, byte size, + public DBRecord createRecord(String name, String comments, long categoryID, byte size, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException { throw new UnsupportedOperationException("Not allowed to update prior version #" + VERSION + " of " + ENUM_TABLE_NAME + " table."); } @Override - public Record getRecord(long enumID) throws IOException { + public DBRecord getRecord(long enumID) throws IOException { return translateRecord(enumTable.getRecord(enumID)); } @@ -84,7 +84,7 @@ class EnumDBAdapterV0 extends EnumDBAdapter implements RecordTranslator { } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { throw new UnsupportedOperationException(); } @@ -110,11 +110,11 @@ class EnumDBAdapterV0 extends EnumDBAdapter implements RecordTranslator { } @Override - public Record translateRecord(Record oldRec) { + public DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = EnumDBAdapter.ENUM_SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = EnumDBAdapter.ENUM_SCHEMA.createRecord(oldRec.getKey()); rec.setString(ENUM_NAME_COL, oldRec.getString(V0_ENUM_NAME_COL)); rec.setString(ENUM_COMMENT_COL, oldRec.getString(V0_ENUM_COMMENT_COL)); rec.setLongValue(ENUM_CAT_COL, oldRec.getLongValue(V0_ENUM_CAT_COL)); @@ -127,7 +127,7 @@ class EnumDBAdapterV0 extends EnumDBAdapter implements RecordTranslator { } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterV1.java index 898af88a58..aa37beae15 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDBAdapterV1.java @@ -78,11 +78,11 @@ class EnumDBAdapterV1 extends EnumDBAdapter { } @Override - public Record createRecord(String name, String comments, long categoryID, byte size, + public DBRecord createRecord(String name, String comments, long categoryID, byte size, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException { long tableKey = enumTable.getKey(); long key = DataTypeManagerDB.createKey(DataTypeManagerDB.ENUM, tableKey); - Record record = V1_ENUM_SCHEMA.createRecord(key); + DBRecord record = V1_ENUM_SCHEMA.createRecord(key); record.setString(V1_ENUM_NAME_COL, name); record.setString(V1_ENUM_COMMENT_COL, comments); record.setLongValue(V1_ENUM_CAT_COL, categoryID); @@ -96,7 +96,7 @@ class EnumDBAdapterV1 extends EnumDBAdapter { } @Override - public Record getRecord(long enumID) throws IOException { + public DBRecord getRecord(long enumID) throws IOException { return enumTable.getRecord(enumID); } @@ -106,7 +106,7 @@ class EnumDBAdapterV1 extends EnumDBAdapter { } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { if (setLastChangeTime) { record.setLongValue(EnumDBAdapter.ENUM_LAST_CHANGE_TIME_COL, (new Date()).getTime()); } @@ -135,12 +135,12 @@ class EnumDBAdapterV1 extends EnumDBAdapter { } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { Field[] keys = enumTable.findRecords(new LongField(datatypeID.getValue()), V1_ENUM_UNIVERSAL_DT_ID_COL); for (int i = 0; i < keys.length; i++) { - Record record = enumTable.getRecord(keys[i]); + DBRecord record = enumTable.getRecord(keys[i]); if (record.getLongValue(V1_ENUM_SOURCE_ARCHIVE_ID_COL) == sourceID.getValue()) { return record; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapter.java index 092e62bcf8..e9557df4af 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapter.java @@ -98,7 +98,7 @@ abstract class EnumValueDBAdapter { * @return value record or null * @throws IOException if IO error occurs */ - abstract Record getRecord(long valueID) throws IOException; + abstract DBRecord getRecord(long valueID) throws IOException; /** * Remove the record for the given enum Value ID. @@ -112,7 +112,7 @@ abstract class EnumValueDBAdapter { * @param record the new record * @throws IOException if the database can't be accessed. */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Get enum value record IDs which correspond to specified enum datatype ID diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapterNoTable.java index e4cb5851b4..51e676ed79 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapterNoTable.java @@ -39,12 +39,12 @@ class EnumValueDBAdapterNoTable extends EnumValueDBAdapter { } @Override - public Record getRecord(long valueID) throws IOException { + public DBRecord getRecord(long valueID) throws IOException { return null; } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapterV0.java index a55f899e7c..90b4243971 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumValueDBAdapterV0.java @@ -72,7 +72,7 @@ class EnumValueDBAdapterV0 extends EnumValueDBAdapter { @Override public void createRecord(long enumID, String name, long value) throws IOException { - Record record = V0_ENUM_VALUE_SCHEMA.createRecord(valueTable.getKey()); + DBRecord record = V0_ENUM_VALUE_SCHEMA.createRecord(valueTable.getKey()); record.setLongValue(V0_ENUMVAL_ID_COL, enumID); record.setString(V0_ENUMVAL_NAME_COL, name); record.setLongValue(V0_ENUMVAL_VALUE_COL, value); @@ -80,7 +80,7 @@ class EnumValueDBAdapterV0 extends EnumValueDBAdapter { } @Override - public Record getRecord(long valueID) throws IOException { + public DBRecord getRecord(long valueID) throws IOException { return valueTable.getRecord(valueID); } @@ -90,7 +90,7 @@ class EnumValueDBAdapterV0 extends EnumValueDBAdapter { } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { valueTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDB.java index c8f772d5aa..f9cdd08e93 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.*; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.program.database.DBObjectCache; import ghidra.program.model.data.*; @@ -38,7 +38,7 @@ class FunctionDefinitionDB extends DataTypeDB implements FunctionDefinition { FunctionDefinitionDB(DataTypeManagerDB dataMgr, DBObjectCache cache, FunctionDefinitionDBAdapter adapter, FunctionParameterAdapter paramAdapter, - Record record) { + DBRecord record) { super(dataMgr, cache, record); this.funDefAdapter = adapter; this.paramAdapter = paramAdapter; @@ -60,7 +60,7 @@ class FunctionDefinitionDB extends DataTypeDB implements FunctionDefinition { try { Field[] ids = paramAdapter.getParameterIdsInFunctionDef(key); for (Field id : ids) { - Record rec = paramAdapter.getRecord(id.getLongValue()); + DBRecord rec = paramAdapter.getRecord(id.getLongValue()); parameters.add(new ParameterDefinitionDB(dataMgr, paramAdapter, this, rec)); } Collections.sort(parameters); @@ -73,7 +73,7 @@ class FunctionDefinitionDB extends DataTypeDB implements FunctionDefinition { @Override protected boolean refresh() { try { - Record rec = funDefAdapter.getRecord(key); + DBRecord rec = funDefAdapter.getRecord(key); if (rec != null) { record = rec; loadParameters(); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapter.java index ad96a58264..1c36630415 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapter.java @@ -124,7 +124,7 @@ abstract class FunctionDefinitionDBAdapter { tmpAdapter = new FunctionDefinitionDBAdapterV1(tmpHandle, true); RecordIterator it = oldAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateRecord(rec, false); } oldAdapter.deleteTable(handle); @@ -132,7 +132,7 @@ abstract class FunctionDefinitionDBAdapter { new FunctionDefinitionDBAdapterV1(handle, true); it = tmpAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec, false); } return newAdapter; @@ -157,7 +157,7 @@ abstract class FunctionDefinitionDBAdapter { * @return the database record for this data type. * @throws IOException if the database can't be accessed. */ - abstract Record createRecord(String name, String comments, long categoryID, long returnDtID, + abstract DBRecord createRecord(String name, String comments, long categoryID, long returnDtID, boolean hasVarArgs, GenericCallingConvention genericCallingConvention, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException; @@ -167,7 +167,7 @@ abstract class FunctionDefinitionDBAdapter { * @return the record for the function definition data type. * @throws IOException if the database can't be accessed. */ - abstract Record getRecord(long functionDefID) throws IOException; + abstract DBRecord getRecord(long functionDefID) throws IOException; /** * Gets an iterator over all function signature definition data type records. @@ -191,7 +191,7 @@ abstract class FunctionDefinitionDBAdapter { * current time before putting the record in the database. * @throws IOException if the database can't be accessed. */ - abstract void updateRecord(Record record, boolean setLastChangeTime) throws IOException; + abstract void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException; /** * Deletes the function definition data type table from the database with the specified database handle. @@ -224,7 +224,7 @@ abstract class FunctionDefinitionDBAdapter { * @return function definition record found or null * @throws IOException if IO error occurs */ - abstract Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) + abstract DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterNoTable.java index b0ff7cdd8f..cd149d79c1 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterNoTable.java @@ -37,7 +37,7 @@ class FunctionDefinitionDBAdapterNoTable extends FunctionDefinitionDBAdapter { } @Override - public Record createRecord(String name, String comments, long categoryID, long returnDtID, + public DBRecord createRecord(String name, String comments, long categoryID, long returnDtID, boolean hasVarArgs, GenericCallingConvention genericCallingConvention, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException { throw new UnsupportedOperationException( @@ -45,7 +45,7 @@ class FunctionDefinitionDBAdapterNoTable extends FunctionDefinitionDBAdapter { } @Override - public Record getRecord(long functionDefID) throws IOException { + public DBRecord getRecord(long functionDefID) throws IOException { return null; } @@ -55,7 +55,7 @@ class FunctionDefinitionDBAdapterNoTable extends FunctionDefinitionDBAdapter { } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { throw new UnsupportedOperationException(); } @@ -80,7 +80,7 @@ class FunctionDefinitionDBAdapterNoTable extends FunctionDefinitionDBAdapter { } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterV0.java index ad90da5798..5697a0069b 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterV0.java @@ -69,7 +69,7 @@ class FunctionDefinitionDBAdapterV0 extends FunctionDefinitionDBAdapter } @Override - public Record createRecord(String name, String comments, long categoryID, long returnDtID, + public DBRecord createRecord(String name, String comments, long categoryID, long returnDtID, boolean hasVarArgs, GenericCallingConvention genericCallingConvention, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException { throw new UnsupportedOperationException("Not allowed to update prior version #" + VERSION + @@ -77,7 +77,7 @@ class FunctionDefinitionDBAdapterV0 extends FunctionDefinitionDBAdapter } @Override - public Record getRecord(long functionDefID) throws IOException { + public DBRecord getRecord(long functionDefID) throws IOException { return translateRecord(table.getRecord(functionDefID)); } @@ -87,7 +87,7 @@ class FunctionDefinitionDBAdapterV0 extends FunctionDefinitionDBAdapter } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { throw new UnsupportedOperationException(); } @@ -112,11 +112,11 @@ class FunctionDefinitionDBAdapterV0 extends FunctionDefinitionDBAdapter } @Override - public Record translateRecord(Record oldRec) { + public DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = FunctionDefinitionDBAdapter.FUN_DEF_SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = FunctionDefinitionDBAdapter.FUN_DEF_SCHEMA.createRecord(oldRec.getKey()); rec.setString(FUNCTION_DEF_NAME_COL, oldRec.getString(V0_FUNCTION_DEF_NAME_COL)); rec.setString(FUNCTION_DEF_COMMENT_COL, oldRec.getString(V0_FUNCTION_DEF_COMMENT_COL)); rec.setLongValue(FUNCTION_DEF_CAT_ID_COL, oldRec.getLongValue(V0_FUNCTION_DEF_CAT_ID_COL)); @@ -131,7 +131,7 @@ class FunctionDefinitionDBAdapterV0 extends FunctionDefinitionDBAdapter } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterV1.java index 5a62ffcd4c..b3fa3de5ba 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionDefinitionDBAdapterV1.java @@ -79,7 +79,7 @@ class FunctionDefinitionDBAdapterV1 extends FunctionDefinitionDBAdapter { } @Override - public Record createRecord(String name, String comments, long categoryID, long returnDtID, + public DBRecord createRecord(String name, String comments, long categoryID, long returnDtID, boolean hasVarArgs, GenericCallingConvention genericCallingConvention, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException { byte flags = (byte) 0; @@ -102,7 +102,7 @@ class FunctionDefinitionDBAdapterV1 extends FunctionDefinitionDBAdapter { // tableKey = DataManager.VOID_DATATYPE_ID +1; // } long key = DataTypeManagerDB.createKey(DataTypeManagerDB.FUNCTION_DEF, tableKey); - Record record = V1_FUN_DEF_SCHEMA.createRecord(key); + DBRecord record = V1_FUN_DEF_SCHEMA.createRecord(key); record.setString(V1_FUNCTION_DEF_NAME_COL, name); record.setString(V1_FUNCTION_DEF_COMMENT_COL, comments); @@ -118,12 +118,12 @@ class FunctionDefinitionDBAdapterV1 extends FunctionDefinitionDBAdapter { } @Override - public Record getRecord(long functionDefID) throws IOException { + public DBRecord getRecord(long functionDefID) throws IOException { return table.getRecord(functionDefID); } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { if (setLastChangeTime) { record.setLongValue(FunctionDefinitionDBAdapter.FUNCTION_DEF_LAST_CHANGE_TIME_COL, (new Date()).getTime()); @@ -157,12 +157,12 @@ class FunctionDefinitionDBAdapterV1 extends FunctionDefinitionDBAdapter { } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { Field[] keys = table.findRecords(new LongField(datatypeID.getValue()), V1_FUNCTION_DEF_UNIVERSAL_DT_ID_COL); for (int i = 0; i < keys.length; i++) { - Record record = table.getRecord(keys[i]); + DBRecord record = table.getRecord(keys[i]); if (record.getLongValue(V1_FUNCTION_DEF_SOURCE_ARCHIVE_ID_COL) == sourceID.getValue()) { return record; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapter.java index 8b0a94074b..ef141fc156 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapter.java @@ -106,14 +106,14 @@ abstract class FunctionParameterAdapter { tmpAdapter = new FunctionParameterAdapterV1(tmpHandle, true); RecordIterator it = oldAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateRecord(rec); } oldAdapter.deleteTable(handle); FunctionParameterAdapterV1 newAdapter = new FunctionParameterAdapterV1(handle, true); it = tmpAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec); } return newAdapter; @@ -149,7 +149,7 @@ abstract class FunctionParameterAdapter { * @return new record * @throws IOException if IO error occurs */ - abstract Record createRecord(long dataTypeID, long parentID, int ordinal, String name, + abstract DBRecord createRecord(long dataTypeID, long parentID, int ordinal, String name, String comment, int dtLength) throws IOException; /** @@ -158,14 +158,14 @@ abstract class FunctionParameterAdapter { * @return parameter definition record or null * @throws IOException if IO error occurs */ - abstract Record getRecord(long parameterID) throws IOException; + abstract DBRecord getRecord(long parameterID) throws IOException; /** * Updates the function definition parameter data type table with the provided record. * @param record the new record * @throws IOException if the database can't be accessed. */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Removes the function definition parameter data type record with the specified ID. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterNoTable.java index 9a3dc73792..7a713fb8f9 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterNoTable.java @@ -38,13 +38,13 @@ class FunctionParameterAdapterNoTable extends FunctionParameterAdapter { } @Override - public Record createRecord(long dataTypeID, long parentID, int ordinal, String name, + public DBRecord createRecord(long dataTypeID, long parentID, int ordinal, String name, String comment, int dtLength) throws IOException { return null; } @Override - public Record getRecord(long parameterID) throws IOException { + public DBRecord getRecord(long parameterID) throws IOException { return null; } @@ -54,7 +54,7 @@ class FunctionParameterAdapterNoTable extends FunctionParameterAdapter { } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterV0.java index 450da6f5d2..b23f18271c 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterV0.java @@ -64,7 +64,7 @@ class FunctionParameterAdapterV0 extends FunctionParameterAdapter implements Rec } @Override - public Record createRecord(long dataTypeID, long parentID, int ordinal, String name, + public DBRecord createRecord(long dataTypeID, long parentID, int ordinal, String name, String comment, int dtLength) throws IOException { long tableKey = parameterTable.getKey(); @@ -72,7 +72,7 @@ class FunctionParameterAdapterV0 extends FunctionParameterAdapter implements Rec // tableKey = DataManager.VOID_DATATYPE_ID +1; // } long key = DataTypeManagerDB.createKey(DataTypeManagerDB.PARAMETER, tableKey); - Record record = V0_PARAMETER_SCHEMA.createRecord(key); + DBRecord record = V0_PARAMETER_SCHEMA.createRecord(key); record.setLongValue(V0_PARAMETER_PARENT_ID_COL, parentID); record.setLongValue(V0_PARAMETER_DT_ID_COL, dataTypeID); record.setString(V0_PARAMETER_NAME_COL, name); @@ -83,7 +83,7 @@ class FunctionParameterAdapterV0 extends FunctionParameterAdapter implements Rec } @Override - public Record getRecord(long parameterID) throws IOException { + public DBRecord getRecord(long parameterID) throws IOException { return translateRecord(parameterTable.getRecord(parameterID)); } @@ -93,7 +93,7 @@ class FunctionParameterAdapterV0 extends FunctionParameterAdapter implements Rec } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @@ -116,11 +116,11 @@ class FunctionParameterAdapterV0 extends FunctionParameterAdapter implements Rec * @see db.RecordTranslator#translateRecord(db.Record) */ @Override - public Record translateRecord(Record oldRec) { + public DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = FunctionParameterAdapter.PARAMETER_SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = FunctionParameterAdapter.PARAMETER_SCHEMA.createRecord(oldRec.getKey()); rec.setLongValue(FunctionParameterAdapter.PARAMETER_PARENT_ID_COL, oldRec.getLongValue(V0_PARAMETER_PARENT_ID_COL)); rec.setLongValue(FunctionParameterAdapter.PARAMETER_DT_ID_COL, diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterV1.java index cc94200881..f67a7ea810 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/FunctionParameterAdapterV1.java @@ -74,7 +74,7 @@ class FunctionParameterAdapterV1 extends FunctionParameterAdapter { } @Override - public Record createRecord(long dataTypeID, long parentID, int ordinal, String name, + public DBRecord createRecord(long dataTypeID, long parentID, int ordinal, String name, String comment, int dtLength) throws IOException { long tableKey = table.getKey(); @@ -82,7 +82,7 @@ class FunctionParameterAdapterV1 extends FunctionParameterAdapter { // tableKey = DataManager.VOID_DATATYPE_ID +1; // } long key = DataTypeManagerDB.createKey(DataTypeManagerDB.PARAMETER, tableKey); - Record record = V1_PARAMETER_SCHEMA.createRecord(key); + DBRecord record = V1_PARAMETER_SCHEMA.createRecord(key); record.setLongValue(V1_PARAMETER_PARENT_ID_COL, parentID); record.setLongValue(V1_PARAMETER_DT_ID_COL, dataTypeID); record.setString(V1_PARAMETER_NAME_COL, name); @@ -94,7 +94,7 @@ class FunctionParameterAdapterV1 extends FunctionParameterAdapter { } @Override - public Record getRecord(long parameterID) throws IOException { + public DBRecord getRecord(long parameterID) throws IOException { return table.getRecord(parameterID); } @@ -104,7 +104,7 @@ class FunctionParameterAdapterV1 extends FunctionParameterAdapter { } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/InstanceSettingsDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/InstanceSettingsDBAdapter.java index faef8a3d75..c704a916e7 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/InstanceSettingsDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/InstanceSettingsDBAdapter.java @@ -93,7 +93,7 @@ abstract class InstanceSettingsDBAdapter { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getLongValue(INST_ADDR_COL)); rec.setLongValue(INST_ADDR_COL, addrMap.getKey(addr, true)); tmpAdapter.updateInstanceRecord(rec); @@ -107,7 +107,7 @@ abstract class InstanceSettingsDBAdapter { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); newAdapter.updateInstanceRecord(rec); monitor.setProgress(++cnt); } @@ -133,7 +133,7 @@ abstract class InstanceSettingsDBAdapter { * @return * @throws IOException if there was a problem accessing the database */ - abstract Record createInstanceRecord(long addr, String name, String strValue, long longValue, + abstract DBRecord createInstanceRecord(long addr, String name, String strValue, long longValue, byte[] byteValue) throws IOException; /** @@ -155,13 +155,13 @@ abstract class InstanceSettingsDBAdapter { * @param settingsID key for the record * @throws IOException if there was a problem accessing the database */ - abstract Record getInstanceRecord(long settingsID) throws IOException; + abstract DBRecord getInstanceRecord(long settingsID) throws IOException; /** * Update the instance settings record in the table. * @throws IOException if there was a problem accessing the database */ - abstract void updateInstanceRecord(Record record) throws IOException; + abstract void updateInstanceRecord(DBRecord record) throws IOException; /** * Get an iterator over those records that fall in the given range for diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/InstanceSettingsDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/InstanceSettingsDBAdapterV0.java index 2b33e38150..6596d60ed1 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/InstanceSettingsDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/InstanceSettingsDBAdapterV0.java @@ -65,10 +65,10 @@ class InstanceSettingsDBAdapterV0 extends InstanceSettingsDBAdapter { } @Override - public Record createInstanceRecord(long addr, String name, String strValue, long longValue, + public DBRecord createInstanceRecord(long addr, String name, String strValue, long longValue, byte[] byteValue) throws IOException { - Record record = V0_INSTANCE_SCHEMA.createRecord(instanceTable.getKey()); + DBRecord record = V0_INSTANCE_SCHEMA.createRecord(instanceTable.getKey()); record.setLongValue(V0_INST_ADDR_COL, addr); record.setString(V0_INST_NAME_COL, name); record.setString(V0_INST_STRING_VALUE_COL, strValue); @@ -89,12 +89,12 @@ class InstanceSettingsDBAdapterV0 extends InstanceSettingsDBAdapter { } @Override - public Record getInstanceRecord(long settingsID) throws IOException { + public DBRecord getInstanceRecord(long settingsID) throws IOException { return instanceTable.getRecord(settingsID); } @Override - public void updateInstanceRecord(Record record) throws IOException { + public void updateInstanceRecord(DBRecord record) throws IOException { instanceTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ParameterDefinitionDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ParameterDefinitionDB.java index 267f92d9fa..81194843c7 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ParameterDefinitionDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ParameterDefinitionDB.java @@ -20,7 +20,7 @@ package ghidra.program.database.data; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.model.data.*; import ghidra.program.model.listing.Parameter; import ghidra.program.model.listing.Variable; @@ -32,19 +32,19 @@ import ghidra.program.model.symbol.SymbolUtilities; final class ParameterDefinitionDB implements ParameterDefinition { private DataTypeManagerDB dataMgr; - private Record record; + private DBRecord record; private FunctionDefinitionDB parent; private FunctionParameterAdapter adapter; ParameterDefinitionDB(DataTypeManagerDB dataMgr, FunctionParameterAdapter adapter, - FunctionDefinitionDB parent, Record record) { + FunctionDefinitionDB parent, DBRecord record) { this.dataMgr = dataMgr; this.parent = parent; this.adapter = adapter; this.record = record; } - Record getRecord() { + DBRecord getRecord() { return record; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ParentChildDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ParentChildDBAdapterV0.java index d2caa9d7ef..1c52bc1609 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ParentChildDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ParentChildDBAdapterV0.java @@ -53,7 +53,7 @@ class ParentChildDBAdapterV0 extends ParentChildAdapter { @Override public void createRecord(long parentID, long childID) throws IOException { long key = table.getKey(); - Record record = V0_SCHEMA.createRecord(key); + DBRecord record = V0_SCHEMA.createRecord(key); record.setLongValue(PARENT_COL, parentID); record.setLongValue(CHILD_COL, childID); table.putRecord(record); @@ -64,7 +64,7 @@ class ParentChildDBAdapterV0 extends ParentChildAdapter { Field[] ids = table.findRecords(new LongField(childID), CHILD_COL); for (Field id : ids) { - Record rec = table.getRecord(id); + DBRecord rec = table.getRecord(id); if (rec.getLongValue(PARENT_COL) == parentID) { table.deleteRecord(id); return; @@ -77,7 +77,7 @@ class ParentChildDBAdapterV0 extends ParentChildAdapter { Field[] ids = table.findRecords(new LongField(childID), CHILD_COL); long[] parentIds = new long[ids.length]; for (int i = 0; i < ids.length; i++) { - Record rec = table.getRecord(ids[i]); + DBRecord rec = table.getRecord(ids[i]); parentIds[i] = rec.getLongValue(PARENT_COL); } return parentIds; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDB.java index 2c034e9bdd..d4c9726ccc 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDB.java @@ -17,7 +17,7 @@ package ghidra.program.database.data; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.docking.settings.SettingsDefinition; import ghidra.program.database.DBObjectCache; @@ -55,7 +55,7 @@ class PointerDB extends DataTypeDB implements Pointer { * @param record */ public PointerDB(DataTypeManagerDB dataMgr, DBObjectCache cache, - PointerDBAdapter adapter, Record record) { + PointerDBAdapter adapter, DBRecord record) { super(dataMgr, cache, record); this.adapter = adapter; } @@ -108,7 +108,7 @@ class PointerDB extends DataTypeDB implements Pointer { @Override protected boolean refresh() { try { - Record rec = adapter.getRecord(key); + DBRecord rec = adapter.getRecord(key); if (rec != null) { record = rec; return super.refresh(); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapter.java index 804e89d7f9..255256c520 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapter.java @@ -77,14 +77,14 @@ abstract class PointerDBAdapter { tmpAdapter = new PointerDBAdapterV2(tmpHandle, true); RecordIterator it = oldAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateRecord(rec); } oldAdapter.deleteTable(handle); PointerDBAdapter newAdapter = new PointerDBAdapterV2(handle, true); it = tmpAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec); } return newAdapter; @@ -107,7 +107,7 @@ abstract class PointerDBAdapter { * @param length pointer size in bytes * @throws IOException if there was a problem accessing the database */ - abstract Record createRecord(long dataTypeID, long categoryID, int length) throws IOException; + abstract DBRecord createRecord(long dataTypeID, long categoryID, int length) throws IOException; /** * Get the record with the given pointerID. @@ -115,7 +115,7 @@ abstract class PointerDBAdapter { * @return requested pointer record or null if not found * @throws IOException if there was a problem accessing the database */ - abstract Record getRecord(long pointerID) throws IOException; + abstract DBRecord getRecord(long pointerID) throws IOException; abstract RecordIterator getRecords() throws IOException; @@ -132,7 +132,7 @@ abstract class PointerDBAdapter { * @param record pointer record to be updated * @throws IOException if there was a problem accessing the database */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Gets all the pointer data types that are contained in the category that @@ -143,7 +143,7 @@ abstract class PointerDBAdapter { */ abstract Field[] getRecordIdsInCategory(long categoryID) throws IOException; - Record translateRecord(Record rec) { + DBRecord translateRecord(DBRecord rec) { return rec; } @@ -170,14 +170,14 @@ abstract class PointerDBAdapter { } @Override - public Record next() throws IOException { - Record rec = it.next(); + public DBRecord next() throws IOException { + DBRecord rec = it.next(); return translateRecord(rec); } @Override - public Record previous() throws IOException { - Record rec = it.previous(); + public DBRecord previous() throws IOException { + DBRecord rec = it.previous(); return translateRecord(rec); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV0.java index 1db1964e7c..24f7f0c00f 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV0.java @@ -49,12 +49,12 @@ class PointerDBAdapterV0 extends PointerDBAdapter { } @Override - Record createRecord(long dataTypeID, long categoryID, int length) throws IOException { + DBRecord createRecord(long dataTypeID, long categoryID, int length) throws IOException { throw new UnsupportedOperationException("Cannot update Version 0"); } @Override - Record getRecord(long pointerID) throws IOException { + DBRecord getRecord(long pointerID) throws IOException { return translateRecord(table.getRecord(pointerID)); } @@ -69,7 +69,7 @@ class PointerDBAdapterV0 extends PointerDBAdapter { } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException("Cannot update Version 0"); } @@ -79,11 +79,11 @@ class PointerDBAdapterV0 extends PointerDBAdapter { } @Override - Record translateRecord(Record oldRec) { + DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = PointerDBAdapter.SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = PointerDBAdapter.SCHEMA.createRecord(oldRec.getKey()); rec.setLongValue(PTR_DT_ID_COL, oldRec.getLongValue(OLD_PTR_DTD_COL)); rec.setLongValue(PTR_CATEGORY_COL, 0); return rec; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV1.java index 6d390999e8..d6537c86b1 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV1.java @@ -49,11 +49,11 @@ class PointerDBAdapterV1 extends PointerDBAdapter { } @Override - Record translateRecord(Record oldRec) { + DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = PointerDBAdapter.SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = PointerDBAdapter.SCHEMA.createRecord(oldRec.getKey()); rec.setLongValue(PTR_DT_ID_COL, oldRec.getLongValue(OLD_PTR_DT_ID_COL)); rec.setLongValue(PTR_CATEGORY_COL, oldRec.getLongValue(OLD_PTR_CATEGORY_COL)); rec.setByteValue(PTR_LENGTH_COL, (byte) -1); @@ -61,12 +61,12 @@ class PointerDBAdapterV1 extends PointerDBAdapter { } @Override - Record createRecord(long dataTypeID, long categoryID, int length) throws IOException { + DBRecord createRecord(long dataTypeID, long categoryID, int length) throws IOException { throw new UnsupportedOperationException(); } @Override - Record getRecord(long pointerID) throws IOException { + DBRecord getRecord(long pointerID) throws IOException { return translateRecord(table.getRecord(pointerID)); } @@ -81,7 +81,7 @@ class PointerDBAdapterV1 extends PointerDBAdapter { } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV2.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV2.java index 923bbc7c7f..ded3e665d4 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV2.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/PointerDBAdapterV2.java @@ -46,11 +46,11 @@ class PointerDBAdapterV2 extends PointerDBAdapter { } @Override - Record createRecord(long dataTypeID, long categoryID, int length) throws IOException { + DBRecord createRecord(long dataTypeID, long categoryID, int length) throws IOException { long tableKey = table.getKey(); long key = DataTypeManagerDB.createKey(DataTypeManagerDB.POINTER, tableKey); - Record record = SCHEMA.createRecord(key); + DBRecord record = SCHEMA.createRecord(key); record.setLongValue(PTR_DT_ID_COL, dataTypeID); record.setLongValue(PTR_CATEGORY_COL, categoryID); record.setByteValue(PTR_LENGTH_COL, (byte) length); @@ -59,7 +59,7 @@ class PointerDBAdapterV2 extends PointerDBAdapter { } @Override - Record getRecord(long pointerID) throws IOException { + DBRecord getRecord(long pointerID) throws IOException { return table.getRecord(pointerID); } @@ -74,7 +74,7 @@ class PointerDBAdapterV2 extends PointerDBAdapter { } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDB.java index 8a969c6ba8..1e6912b039 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDB.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.data; -import db.Record; +import db.DBRecord; /** * DatabaseObject for a Default settings record. @@ -23,14 +23,14 @@ import db.Record; * */ class SettingsDB { - private Record record; + private DBRecord record; /** * Constructor * @param cache * @param record */ - SettingsDB(Record record) { + SettingsDB(DBRecord record) { this.record = record; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBAdapter.java index 1b48095341..52bc02cca7 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBAdapter.java @@ -60,7 +60,7 @@ abstract class SettingsDBAdapter { * @return new record * @throws IOException if there was a problem accessing the database */ - abstract Record createSettingsRecord(long dataTypeID, String name, String strValue, + abstract DBRecord createSettingsRecord(long dataTypeID, String name, String strValue, long longValue, byte[] byteValue) throws IOException; /** @@ -86,13 +86,13 @@ abstract class SettingsDBAdapter { * @return record corresponding to settingsID or null * @throws IOException if there was a problem accessing the database */ - abstract Record getSettingsRecord(long settingsID) throws IOException; + abstract DBRecord getSettingsRecord(long settingsID) throws IOException; /** * Update the default settings record in the table. * @param record the new record * @throws IOException if there was a problem accessing the database */ - abstract void updateSettingsRecord(Record record) throws IOException; + abstract void updateSettingsRecord(DBRecord record) throws IOException; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBAdapterV0.java index 635bb9f608..8ac528c3fc 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBAdapterV0.java @@ -58,10 +58,10 @@ class SettingsDBAdapterV0 extends SettingsDBAdapter { } @Override - public Record createSettingsRecord(long dataTypeID, String name, String strValue, + public DBRecord createSettingsRecord(long dataTypeID, String name, String strValue, long longValue, byte[] byteValue) throws IOException { - Record record = V0_SETTINGS_SCHEMA.createRecord(settingsTable.getKey()); + DBRecord record = V0_SETTINGS_SCHEMA.createRecord(settingsTable.getKey()); record.setLongValue(V0_SETTINGS_DT_ID_COL, dataTypeID); record.setString(V0_SETTINGS_NAME_COL, name); record.setString(V0_SETTINGS_STRING_VALUE_COL, strValue); @@ -82,12 +82,12 @@ class SettingsDBAdapterV0 extends SettingsDBAdapter { } @Override - public Record getSettingsRecord(long settingsID) throws IOException { + public DBRecord getSettingsRecord(long settingsID) throws IOException { return settingsTable.getRecord(settingsID); } @Override - public void updateSettingsRecord(Record record) throws IOException { + public void updateSettingsRecord(DBRecord record) throws IOException { settingsTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBManager.java index d4f8bdb18f..951d095629 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SettingsDBManager.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.*; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.program.model.data.DataType; import ghidra.program.model.data.DataTypeComponent; @@ -179,7 +179,7 @@ class SettingsDBManager implements Settings { try { Field[] keys = adapter.getSettingsKeys(dataTypeID); for (int i = 0; i < keys.length; i++) { - Record rec = adapter.getSettingsRecord(keys[i].getLongValue()); + DBRecord rec = adapter.getSettingsRecord(keys[i].getLongValue()); String settingsName = rec.getString(SettingsDBAdapter.SETTINGS_NAME_COL); if (settingsName.equals(name)) { adapter.removeSettingsRecord(keys[i].getLongValue()); @@ -213,7 +213,7 @@ class SettingsDBManager implements Settings { try { Field[] keys = adapter.getSettingsKeys(dataTypeID); for (int i = 0; i < keys.length; i++) { - Record rec = adapter.getSettingsRecord(keys[i].getLongValue()); + DBRecord rec = adapter.getSettingsRecord(keys[i].getLongValue()); String name = rec.getString(SettingsDBAdapter.SETTINGS_NAME_COL); if (!list.contains(name)) { list.add(name); @@ -275,11 +275,11 @@ class SettingsDBManager implements Settings { return oldLongValue != newLongValue; } - private Record getRecord(String name) { + private DBRecord getRecord(String name) { try { Field[] keys = adapter.getSettingsKeys(dataTypeID); for (int i = 0; i < keys.length; i++) { - Record rec = adapter.getSettingsRecord(keys[i].getLongValue()); + DBRecord rec = adapter.getSettingsRecord(keys[i].getLongValue()); if (rec.getString(SettingsDBAdapter.SETTINGS_NAME_COL).equals(name)) { return rec; } @@ -294,7 +294,7 @@ class SettingsDBManager implements Settings { private SettingsDB getSettingsDB(String name) { - Record record = getRecord(name); + DBRecord record = getRecord(name); if (record != null) { return new SettingsDB(record); } @@ -305,7 +305,7 @@ class SettingsDBManager implements Settings { byte[] byteValue) throws IOException { boolean wasChanged = false; - Record record = getRecord(name); + DBRecord record = getRecord(name); if (record == null) { wasChanged = true; record = adapter.createSettingsRecord(dataTypeID, name, strValue, longValue, byteValue); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapter.java index 8170773d2e..debb9cae8c 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapter.java @@ -104,16 +104,16 @@ abstract class SourceArchiveAdapter { SourceArchiveAdapter tmpAdapter = null; try { tmpAdapter = new SourceArchiveAdapterV0(tmpHandle, true); - Iterator it = oldAdapter.getRecords().iterator(); + Iterator it = oldAdapter.getRecords().iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateRecord(rec); } oldAdapter.deleteTable(handle); SourceArchiveAdapter newAdapter = new SourceArchiveAdapterV0(handle, true); it = tmpAdapter.getRecords().iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec); } @@ -131,25 +131,25 @@ abstract class SourceArchiveAdapter { * Creates a new source archive record using the information from the given source archive. * @param sourceArchive the source archive from which to get the archive information. */ - abstract Record createRecord(SourceArchive sourceArchive) throws IOException; + abstract DBRecord createRecord(SourceArchive sourceArchive) throws IOException; /** * Returns a list containing all records in the archive table * @return */ - abstract List getRecords() throws IOException; + abstract List getRecords() throws IOException; /** * Returns the record for the given key (sourceArchiveID) */ - abstract Record getRecord(long key) throws IOException; + abstract DBRecord getRecord(long key) throws IOException; /** * Updates the data type archive ID table with the provided record. * @param record the new record * @throws IOException if the database can't be accessed. */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Remove the record for the given data type archive ID. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapterNoTable.java index d3b47fbcc3..5acb2119c4 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapterNoTable.java @@ -25,14 +25,14 @@ import java.util.ArrayList; import java.util.List; import db.DBHandle; -import db.Record; +import db.DBRecord; /** * Adapter needed for a read-only version of data type manager that is not going * to be upgraded, and there is no Data Type Archive ID table in the data type manager. */ class SourceArchiveAdapterNoTable extends SourceArchiveAdapter { - private static Record LOCAL_RECORD; + private static DBRecord LOCAL_RECORD; static { LOCAL_RECORD = SCHEMA.createRecord(DataTypeManager.LOCAL_ARCHIVE_KEY); @@ -53,7 +53,7 @@ class SourceArchiveAdapterNoTable extends SourceArchiveAdapter { } @Override - Record createRecord(SourceArchive sourceArchive) throws IOException { + DBRecord createRecord(SourceArchive sourceArchive) throws IOException { throw new UnsupportedOperationException( "Not allowed to update version prior to existence of the Data Type Archive ID table."); } @@ -63,7 +63,7 @@ class SourceArchiveAdapterNoTable extends SourceArchiveAdapter { } @Override - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { if (key == DataTypeManager.LOCAL_ARCHIVE_KEY) { return LOCAL_RECORD; } @@ -71,8 +71,8 @@ class SourceArchiveAdapterNoTable extends SourceArchiveAdapter { } @Override - List getRecords() { - List records = new ArrayList(); + List getRecords() { + List records = new ArrayList(); records.add(LOCAL_RECORD); return records; } @@ -83,7 +83,7 @@ class SourceArchiveAdapterNoTable extends SourceArchiveAdapter { } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException("updateRecord not supported"); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapterV0.java index b128c7e16a..f1dd2e7951 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveAdapterV0.java @@ -79,14 +79,14 @@ class SourceArchiveAdapterV0 extends SourceArchiveAdapter { * @throws IOException */ private void createRecordForLocalManager() throws IOException { - Record record = V0_SCHEMA.createRecord(DataTypeManager.LOCAL_ARCHIVE_KEY); + DBRecord record = V0_SCHEMA.createRecord(DataTypeManager.LOCAL_ARCHIVE_KEY); record.setLongValue(V0_ARCHIVE_ID_LAST_SYNC_TIME_COL, (new Date()).getTime()); table.putRecord(record); } @Override - public Record createRecord(SourceArchive archive) throws IOException { - Record record = V0_SCHEMA.createRecord(archive.getSourceArchiveID().getValue()); + public DBRecord createRecord(SourceArchive archive) throws IOException { + DBRecord record = V0_SCHEMA.createRecord(archive.getSourceArchiveID().getValue()); record.setString(V0_ARCHIVE_ID_DOMAIN_FILE_ID_COL, archive.getDomainFileID()); record.setString(V0_ARCHIVE_ID_NAME_COL, archive.getName()); record.setByteValue(V0_ARCHIVE_ID_TYPE_COL, (byte) archive.getArchiveType().ordinal()); @@ -103,13 +103,13 @@ class SourceArchiveAdapterV0 extends SourceArchiveAdapter { } @Override - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { return table.getRecord(key); } @Override - public List getRecords() throws IOException { - List records = new ArrayList<>(); + public List getRecords() throws IOException { + List records = new ArrayList<>(); RecordIterator iterator = table.iterator(); while (iterator.hasNext()) { records.add(iterator.next()); @@ -118,7 +118,7 @@ class SourceArchiveAdapterV0 extends SourceArchiveAdapter { } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveDB.java index fd51f1f5af..cbc1c60130 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/SourceArchiveDB.java @@ -17,7 +17,7 @@ package ghidra.program.database.data; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; import ghidra.program.model.data.*; @@ -26,13 +26,13 @@ import ghidra.util.UniversalID; public class SourceArchiveDB extends DatabaseObject implements SourceArchive { private UniversalID sourceID; - private Record record; + private DBRecord record; private final SourceArchiveAdapter adapter; private final DataTypeManagerDB dtMgr; private Lock lock; public SourceArchiveDB(DataTypeManagerDB dtMgr, DBObjectCache cache, - SourceArchiveAdapter adapter, Record record) { + SourceArchiveAdapter adapter, DBRecord record) { super(cache, record.getKey()); this.dtMgr = dtMgr; this.adapter = adapter; @@ -97,7 +97,7 @@ public class SourceArchiveDB extends DatabaseObject implements SourceArchive { @Override protected boolean refresh() { try { - Record rec = adapter.getRecord(key); + DBRecord rec = adapter.getRecord(key); if (rec != null) { record = rec; return true; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/StructureDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/StructureDB.java index 9c87e4427a..8361f1ddcc 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/StructureDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/StructureDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.*; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.program.database.DBObjectCache; import ghidra.program.model.data.*; @@ -56,7 +56,7 @@ class StructureDB extends CompositeDB implements Structure { */ public StructureDB(DataTypeManagerDB dataMgr, DBObjectCache cache, CompositeDBAdapter compositeAdapter, ComponentDBAdapter componentAdapter, - Record record) { + DBRecord record) { super(dataMgr, cache, compositeAdapter, componentAdapter, record); } @@ -68,7 +68,7 @@ class StructureDB extends CompositeDB implements Structure { try { Field[] ids = componentAdapter.getComponentIdsInComposite(key); for (Field id : ids) { - Record rec = componentAdapter.getRecord(id.getLongValue()); + DBRecord rec = componentAdapter.getRecord(id.getLongValue()); DataTypeComponentDB component = new DataTypeComponentDB(dataMgr, componentAdapter, this, rec); if (component.isFlexibleArrayComponent()) { @@ -129,7 +129,7 @@ class StructureDB extends CompositeDB implements Structure { } else { int componentLength = getPreferredComponentLength(dataType, length); - Record rec = componentAdapter.createRecord(dataMgr.getResolvedID(dataType), key, + DBRecord rec = componentAdapter.createRecord(dataMgr.getResolvedID(dataType), key, componentLength, numComponents, structLength, name, comment); dtc = new DataTypeComponentDB(dataMgr, componentAdapter, this, rec); dataType.addParent(this); @@ -193,7 +193,7 @@ class StructureDB extends CompositeDB implements Structure { flexibleArrayComponent = null; } - Record rec = componentAdapter.createRecord(dataMgr.getResolvedID(dataType), key, 0, + DBRecord rec = componentAdapter.createRecord(dataMgr.getResolvedID(dataType), key, 0, -1, -1, name, comment); dtc = new DataTypeComponentDB(dataMgr, componentAdapter, this, rec); dataType.addParent(this); @@ -300,7 +300,7 @@ class StructureDB extends CompositeDB implements Structure { length = getPreferredComponentLength(dataType, length); int offset = getComponent(ordinal).getOffset(); - Record rec = componentAdapter.createRecord(dataMgr.getResolvedID(dataType), key, length, + DBRecord rec = componentAdapter.createRecord(dataMgr.getResolvedID(dataType), key, length, ordinal, offset, name, comment); DataTypeComponentDB dtc = new DataTypeComponentDB(dataMgr, componentAdapter, this, rec); dataType.addParent(this); @@ -474,7 +474,7 @@ class StructureDB extends CompositeDB implements Structure { BitFieldDataType bitfieldDt = new BitFieldDBDataType(baseDataType, bitSize, storageBitOffset); - Record rec = componentAdapter.createRecord(dataMgr.getResolvedID(bitfieldDt), key, + DBRecord rec = componentAdapter.createRecord(dataMgr.getResolvedID(bitfieldDt), key, bitfieldDt.getStorageSize(), ordinal, revisedOffset, componentName, comment); DataTypeComponentDB dtc = new DataTypeComponentDB(dataMgr, componentAdapter, this, rec); bitfieldDt.addParent(this); // has no affect @@ -1016,7 +1016,7 @@ class StructureDB extends CompositeDB implements Structure { length = getPreferredComponentLength(dataType, length); - Record rec = componentAdapter.createRecord(dataMgr.getResolvedID(dataType), key, length, + DBRecord rec = componentAdapter.createRecord(dataMgr.getResolvedID(dataType), key, length, ordinal, offset, name, comment); dataType.addParent(this); DataTypeComponentDB dtc = new DataTypeComponentDB(dataMgr, componentAdapter, this, rec); @@ -1301,7 +1301,7 @@ class StructureDB extends CompositeDB implements Structure { length = Math.min(length, maxOffset - dtc.getOffset()); } - Record rec = componentAdapter.createRecord(dataMgr.getResolvedID(dt), key, length, + DBRecord rec = componentAdapter.createRecord(dataMgr.getResolvedID(dt), key, length, dtc.getOrdinal(), dtc.getOffset(), dtc.getFieldName(), dtc.getComment()); dt.addParent(this); DataTypeComponentDB newDtc = @@ -1671,7 +1671,7 @@ class StructureDB extends CompositeDB implements Structure { } } } - Record rec = componentAdapter.createRecord(dataMgr.getResolvedID(resolvedDataType), key, + DBRecord rec = componentAdapter.createRecord(dataMgr.getResolvedID(resolvedDataType), key, length, ordinal, newOffset, name, comment); resolvedDataType.addParent(this); DataTypeComponentDB newDtc = diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDB.java index cae7c2ea46..054ebb7bc9 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDB.java @@ -17,7 +17,7 @@ package ghidra.program.database.data; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.docking.settings.SettingsDefinition; import ghidra.program.database.DBObjectCache; @@ -40,7 +40,7 @@ class TypedefDB extends DataTypeDB implements TypeDef { * @param key */ public TypedefDB(DataTypeManagerDB dataMgr, DBObjectCache cache, - TypedefDBAdapter adapter, Record record) { + TypedefDBAdapter adapter, DBRecord record) { super(dataMgr, cache, record); this.adapter = adapter; } @@ -236,7 +236,7 @@ class TypedefDB extends DataTypeDB implements TypeDef { @Override protected boolean refresh() { try { - Record rec = adapter.getRecord(key); + DBRecord rec = adapter.getRecord(key); if (rec != null) { record = rec; // super.getDefaultSettings(); // not sure why it was doing this - no one else does. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapter.java index 35e07e9a9a..3f3f28fba6 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapter.java @@ -98,14 +98,14 @@ abstract class TypedefDBAdapter { tmpAdapter = new TypedefDBAdapterV1(tmpHandle, true); RecordIterator it = oldAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateRecord(rec, false); } oldAdapter.deleteTable(handle); TypedefDBAdapter newAdapter = new TypedefDBAdapterV1(handle, true); it = tmpAdapter.getRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateRecord(rec, false); } return newAdapter; @@ -127,7 +127,7 @@ abstract class TypedefDBAdapter { * @return the database record for this data type. * @throws IOException if the database can't be accessed. */ - abstract Record createRecord(long dataTypeID, String name, long categoryID, + abstract DBRecord createRecord(long dataTypeID, String name, long categoryID, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException; /** @@ -136,7 +136,7 @@ abstract class TypedefDBAdapter { * @return the record for the type definition data type. * @throws IOException if the database can't be accessed. */ - abstract Record getRecord(long typedefID) throws IOException; + abstract DBRecord getRecord(long typedefID) throws IOException; /** * Gets an iterator over all type definition data type records. @@ -160,7 +160,7 @@ abstract class TypedefDBAdapter { * current time before putting the record in the database. * @throws IOException if the database can't be accessed. */ - abstract void updateRecord(Record record, boolean setLastChangeTime) throws IOException; + abstract void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException; /** * Deletes the type definition data type table from the database with the specified database handle. @@ -193,7 +193,7 @@ abstract class TypedefDBAdapter { * @return typedef record found or null * @throws IOException if IO error occurs */ - abstract Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) + abstract DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapterV0.java index d848ec7186..2c1dbffb0e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapterV0.java @@ -68,14 +68,14 @@ class TypedefDBAdapterV0 extends TypedefDBAdapter implements RecordTranslator { } @Override - public Record createRecord(long dataTypeID, String name, long categoryID, long sourceArchiveID, + public DBRecord createRecord(long dataTypeID, String name, long categoryID, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException { throw new UnsupportedOperationException("Not allowed to update prior version #" + VERSION + " of " + TYPEDEF_TABLE_NAME + " table."); } @Override - public Record getRecord(long typedefID) throws IOException { + public DBRecord getRecord(long typedefID) throws IOException { return translateRecord(table.getRecord(typedefID)); } @@ -85,7 +85,7 @@ class TypedefDBAdapterV0 extends TypedefDBAdapter implements RecordTranslator { } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { throw new UnsupportedOperationException(); } @@ -105,11 +105,11 @@ class TypedefDBAdapterV0 extends TypedefDBAdapter implements RecordTranslator { } @Override - public Record translateRecord(Record oldRec) { + public DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = TypedefDBAdapter.SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = TypedefDBAdapter.SCHEMA.createRecord(oldRec.getKey()); rec.setLongValue(TYPEDEF_DT_ID_COL, oldRec.getLongValue(V0_TYPEDEF_DT_ID_COL)); rec.setString(TYPEDEF_NAME_COL, oldRec.getString(V0_TYPEDEF_NAME_COL)); rec.setLongValue(TYPEDEF_CAT_COL, oldRec.getLongValue(V0_TYPEDEF_CAT_COL)); @@ -121,7 +121,7 @@ class TypedefDBAdapterV0 extends TypedefDBAdapter implements RecordTranslator { } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapterV1.java index eac7c7c2e3..eda97c81c4 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/TypedefDBAdapterV1.java @@ -78,7 +78,7 @@ class TypedefDBAdapterV1 extends TypedefDBAdapter { } @Override - public Record createRecord(long dataTypeID, String name, long categoryID, long sourceArchiveID, + public DBRecord createRecord(long dataTypeID, String name, long categoryID, long sourceArchiveID, long sourceDataTypeID, long lastChangeTime) throws IOException { long tableKey = table.getKey(); @@ -87,7 +87,7 @@ class TypedefDBAdapterV1 extends TypedefDBAdapter { // } long key = DataTypeManagerDB.createKey(DataTypeManagerDB.TYPEDEF, tableKey); - Record record = V1_SCHEMA.createRecord(key); + DBRecord record = V1_SCHEMA.createRecord(key); record.setLongValue(V1_TYPEDEF_DT_ID_COL, dataTypeID); record.setString(V1_TYPEDEF_NAME_COL, name); record.setLongValue(V1_TYPEDEF_CAT_COL, categoryID); @@ -100,7 +100,7 @@ class TypedefDBAdapterV1 extends TypedefDBAdapter { } @Override - public Record getRecord(long typedefID) throws IOException { + public DBRecord getRecord(long typedefID) throws IOException { return table.getRecord(typedefID); } @@ -110,7 +110,7 @@ class TypedefDBAdapterV1 extends TypedefDBAdapter { } @Override - public void updateRecord(Record record, boolean setLastChangeTime) throws IOException { + public void updateRecord(DBRecord record, boolean setLastChangeTime) throws IOException { if (setLastChangeTime) { record.setLongValue(TypedefDBAdapter.TYPEDEF_LAST_CHANGE_TIME_COL, (new Date()).getTime()); @@ -134,12 +134,12 @@ class TypedefDBAdapterV1 extends TypedefDBAdapter { } @Override - Record getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { + DBRecord getRecordWithIDs(UniversalID sourceID, UniversalID datatypeID) throws IOException { Field[] keys = table.findRecords(new LongField(datatypeID.getValue()), V1_TYPEDEF_UNIVERSAL_DT_ID_COL); for (int i = 0; i < keys.length; i++) { - Record record = table.getRecord(keys[i]); + DBRecord record = table.getRecord(keys[i]); if (record.getLongValue(V1_TYPEDEF_SOURCE_ARCHIVE_ID_COL) == sourceID.getValue()) { return record; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/UnionDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/UnionDB.java index ef18ce0e59..3a069e2aa0 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/UnionDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/UnionDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.*; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.docking.settings.Settings; import ghidra.program.database.DBObjectCache; import ghidra.program.model.data.*; @@ -46,7 +46,7 @@ class UnionDB extends CompositeDB implements Union { */ public UnionDB(DataTypeManagerDB dataMgr, DBObjectCache cache, CompositeDBAdapter compositeAdapter, ComponentDBAdapter componentAdapter, - Record record) { + DBRecord record) { super(dataMgr, cache, compositeAdapter, componentAdapter, record); } @@ -58,7 +58,7 @@ class UnionDB extends CompositeDB implements Union { try { Field[] ids = componentAdapter.getComponentIdsInComposite(key); for (Field id : ids) { - Record rec = componentAdapter.getRecord(id.getLongValue()); + DBRecord rec = componentAdapter.getRecord(id.getLongValue()); components.add(new DataTypeComponentDB(dataMgr, componentAdapter, this, rec)); } } @@ -146,7 +146,7 @@ class UnionDB extends CompositeDB implements Union { private DataTypeComponentDB createComponent(long dtID, int length, int ordinal, int offset, String name, String comment) { - Record rec; + DBRecord rec; try { rec = componentAdapter.createRecord(dtID, key, length, ordinal, offset, name, comment); return new DataTypeComponentDB(dataMgr, componentAdapter, this, rec); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/external/ExternalManagerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/external/ExternalManagerDB.java index 408755bc17..f3f38b0e65 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/external/ExternalManagerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/external/ExternalManagerDB.java @@ -126,7 +126,7 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager { RecordIterator iter = oldNameAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); String name = rec.getString(OldExtNameAdapter.EXT_NAME_COL); try { @@ -153,7 +153,7 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager { iter = oldExtRefAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Address fromAddr = oldAddrMap.decodeAddress(rec.getLongValue(OldExtRefAdapter.FROM_ADDR_COL)); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapter.java index c048377a52..0c7bcc1e45 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -71,10 +70,10 @@ abstract class CallingConventionDBAdapter { return new CallingConventionDBAdapterV0(handle, true); } - abstract Record createCallingConventionRecord(String name) throws IOException; + abstract DBRecord createCallingConventionRecord(String name) throws IOException; - abstract Record getCallingConventionRecord(byte callingConventionID) throws IOException; + abstract DBRecord getCallingConventionRecord(byte callingConventionID) throws IOException; - abstract Record getCallingConventionRecord(String name) throws IOException; + abstract DBRecord getCallingConventionRecord(String name) throws IOException; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapterNoTable.java index 43cfc9e8cc..ac7033ef0e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapterNoTable.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,7 +17,7 @@ package ghidra.program.database.function; import java.io.IOException; -import db.Record; +import db.DBRecord; /** * Adapter needed for a read-only version of Program that is not going @@ -37,7 +36,7 @@ class CallingConventionDBAdapterNoTable extends CallingConventionDBAdapter { * @see ghidra.program.database.function.CallingConventionDBAdapter#createCallingConventionRecord(java.lang.String) */ @Override - public Record createCallingConventionRecord(String name) throws IOException { + public DBRecord createCallingConventionRecord(String name) throws IOException { return null; } @@ -45,7 +44,7 @@ class CallingConventionDBAdapterNoTable extends CallingConventionDBAdapter { * @see ghidra.program.database.function.CallingConventionDBAdapter#getCallingConventionRecord(byte) */ @Override - public Record getCallingConventionRecord(byte callingConventionID) throws IOException { + public DBRecord getCallingConventionRecord(byte callingConventionID) throws IOException { return null; } @@ -53,7 +52,7 @@ class CallingConventionDBAdapterNoTable extends CallingConventionDBAdapter { * @see ghidra.program.database.function.CallingConventionDBAdapter#getCallingConventionRecord(java.lang.String) */ @Override - public Record getCallingConventionRecord(String name) throws IOException { + public DBRecord getCallingConventionRecord(String name) throws IOException { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapterV0.java index 17095df4a1..8e9f9e2942 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/CallingConventionDBAdapterV0.java @@ -61,9 +61,9 @@ class CallingConventionDBAdapterV0 extends CallingConventionDBAdapter { } @Override - public Record createCallingConventionRecord(String name) throws IOException { + public DBRecord createCallingConventionRecord(String name) throws IOException { byte key = getFirstAvailableKey(); - Record record = V0_CALLING_CONVENTION_SCHEMA.createRecord(new ByteField(key)); + DBRecord record = V0_CALLING_CONVENTION_SCHEMA.createRecord(new ByteField(key)); record.setString(V0_CALLING_CONVENTION_NAME_COL, name); callingConventionTable.putRecord(record); return record; @@ -77,7 +77,7 @@ class CallingConventionDBAdapterV0 extends CallingConventionDBAdapter { private byte getFirstAvailableKey() throws IOException { byte key = 2; for (; key < 256; key++) { - Record record = getCallingConventionRecord(key); + DBRecord record = getCallingConventionRecord(key); if (record == null) { return key; } @@ -89,15 +89,15 @@ class CallingConventionDBAdapterV0 extends CallingConventionDBAdapter { } @Override - public Record getCallingConventionRecord(byte callingConventionID) throws IOException { + public DBRecord getCallingConventionRecord(byte callingConventionID) throws IOException { return callingConventionTable.getRecord(new ByteField(callingConventionID)); } @Override - public Record getCallingConventionRecord(String name) throws IOException { + public DBRecord getCallingConventionRecord(String name) throws IOException { RecordIterator iterator = callingConventionTable.iterator(); while (iterator.hasNext()) { - Record record = iterator.next(); + DBRecord record = iterator.next(); String callingConventionName = record.getString(V0_CALLING_CONVENTION_NAME_COL); if (callingConventionName.equals(name)) { return record; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapter.java index 303a11e087..3b090a1751 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapter.java @@ -134,7 +134,7 @@ abstract class FunctionAdapter { RecordIterator it = oldAdapter.iterateFunctionRecords(); while (it.hasNext()) { monitor.checkCanceled(); - Record rec = it.next(); + DBRecord rec = it.next(); tmpAdapter.updateFunctionRecord(rec); monitor.setProgress(++count); } @@ -143,7 +143,7 @@ abstract class FunctionAdapter { it = tmpAdapter.iterateFunctionRecords(); while (it.hasNext()) { monitor.checkCanceled(); - Record rec = it.next(); + DBRecord rec = it.next(); newAdapter.updateFunctionRecord(rec); monitor.setProgress(++count); } @@ -180,17 +180,17 @@ abstract class FunctionAdapter { * @param functionKey * @return Record */ - abstract Record getFunctionRecord(long functionKey) throws IOException; + abstract DBRecord getFunctionRecord(long functionKey) throws IOException; /** * Update/Insert the specified function record. * @param functionRecord */ - abstract void updateFunctionRecord(Record functionRecord) throws IOException; + abstract void updateFunctionRecord(DBRecord functionRecord) throws IOException; - abstract Record createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException; + abstract DBRecord createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException; - abstract Record translateRecord(Record record); + abstract DBRecord translateRecord(DBRecord record); class TranslatedRecordIterator implements RecordIterator { private RecordIterator it; @@ -210,12 +210,12 @@ abstract class FunctionAdapter { } @Override - public Record next() throws IOException { + public DBRecord next() throws IOException { return translateRecord(it.next()); } @Override - public Record previous() throws IOException { + public DBRecord previous() throws IOException { return translateRecord(it.previous()); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV0.java index 3b786fe986..64d8e2137e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -103,16 +102,16 @@ class FunctionAdapterV0 extends FunctionAdapter { * @see ghidra.program.database.function.FunctionAdapter#getFunctionRecord(long) */ @Override - Record getFunctionRecord(long functionKey) throws IOException { - Record oldRecord = table.getRecord(functionKey); + DBRecord getFunctionRecord(long functionKey) throws IOException { + DBRecord oldRecord = table.getRecord(functionKey); return translateRecord(oldRecord); } /** - * @see ghidra.program.database.function.FunctionAdapter#updateFunctionRecord(db.Record) + * @see ghidra.program.database.function.FunctionAdapter#updateFunctionRecord(db.DBRecord) */ @Override - void updateFunctionRecord(Record functionRecord) throws IOException { + void updateFunctionRecord(DBRecord functionRecord) throws IOException { // table.putRecord(functionRecord); throw new UnsupportedOperationException(); } @@ -121,7 +120,7 @@ class FunctionAdapterV0 extends FunctionAdapter { * @see ghidra.program.database.function.FunctionAdapter#createFunctionRecord(ghidra.program.model.symbol.Scope, long) */ @Override - Record createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException { + DBRecord createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException { // Record rec = FUNCTION_SCHEMA.createRecord(symbolID); // rec.setLongValue(RETURN_DATA_TYPE_ID_COL, returnDataTypeId); // rec.setIntValue(STACK_PURGE_COL, Function.UNKNOWN_STACK_DEPTH_CHANGE); @@ -139,15 +138,15 @@ class FunctionAdapterV0 extends FunctionAdapter { } /** - * @see ghidra.program.database.function.FunctionAdapter#translateRecord(db.Record) + * @see ghidra.program.database.function.FunctionAdapter#translateRecord(db.DBRecord) */ @Override - Record translateRecord(Record record) { + DBRecord translateRecord(DBRecord record) { if (record == null) { return null; } long entryPointKey = record.getKey(); - Record newRecord = FunctionAdapter.FUNCTION_SCHEMA.createRecord(entryPointKey); + DBRecord newRecord = FunctionAdapter.FUNCTION_SCHEMA.createRecord(entryPointKey); newRecord.setLongValue(FunctionAdapter.RETURN_DATA_TYPE_ID_COL, record.getLongValue(V0_RETURN_DATA_TYPE_ID_COL)); newRecord.setIntValue(FunctionAdapter.STACK_PURGE_COL, diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV1.java index 284a40fc86..d75856e404 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV1.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -113,16 +112,16 @@ class FunctionAdapterV1 extends FunctionAdapter { * @see ghidra.program.database.function.FunctionAdapter#getFunctionRecord(long) */ @Override - Record getFunctionRecord(long functionKey) throws IOException { - Record oldRecord = table.getRecord(functionKey); + DBRecord getFunctionRecord(long functionKey) throws IOException { + DBRecord oldRecord = table.getRecord(functionKey); return translateRecord(oldRecord); } /** - * @see ghidra.program.database.function.FunctionAdapter#updateFunctionRecord(db.Record) + * @see ghidra.program.database.function.FunctionAdapter#updateFunctionRecord(db.DBRecord) */ @Override - void updateFunctionRecord(Record functionRecord) throws IOException { + void updateFunctionRecord(DBRecord functionRecord) throws IOException { throw new UnsupportedOperationException(); } @@ -130,7 +129,7 @@ class FunctionAdapterV1 extends FunctionAdapter { * @see ghidra.program.database.function.FunctionAdapter#createFunctionRecord(ghidra.program.model.symbol.Scope, long) */ @Override - Record createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException { + DBRecord createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException { // Record rec = FUNCTION_SCHEMA.createRecord(symbolID); // rec.setLongValue(RETURN_DATA_TYPE_ID_COL, returnDataTypeId); // rec.setIntValue(STACK_PURGE_COL, Function.UNKNOWN_STACK_DEPTH_CHANGE); @@ -148,15 +147,15 @@ class FunctionAdapterV1 extends FunctionAdapter { } /** - * @see ghidra.program.database.function.FunctionAdapter#translateRecord(db.Record) + * @see ghidra.program.database.function.FunctionAdapter#translateRecord(db.DBRecord) */ @Override - Record translateRecord(Record record) { + DBRecord translateRecord(DBRecord record) { if (record == null) { return null; } long entryPointKey = record.getKey(); - Record newRecord = FunctionAdapter.FUNCTION_SCHEMA.createRecord(entryPointKey); + DBRecord newRecord = FunctionAdapter.FUNCTION_SCHEMA.createRecord(entryPointKey); newRecord.setLongValue(FunctionAdapter.RETURN_DATA_TYPE_ID_COL, record.getLongValue(V1_RETURN_DATA_TYPE_ID_COL)); newRecord.setIntValue(FunctionAdapter.STACK_PURGE_COL, diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV2.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV2.java index 1c8c9cda64..d140014d30 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV2.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV2.java @@ -95,16 +95,16 @@ class FunctionAdapterV2 extends FunctionAdapter { * @see ghidra.program.database.function.FunctionAdapter#getFunctionRecord(long) */ @Override - Record getFunctionRecord(long functionKey) throws IOException { - Record oldRecord = table.getRecord(functionKey); + DBRecord getFunctionRecord(long functionKey) throws IOException { + DBRecord oldRecord = table.getRecord(functionKey); return translateRecord(oldRecord); } /** - * @see ghidra.program.database.function.FunctionAdapter#updateFunctionRecord(db.Record) + * @see ghidra.program.database.function.FunctionAdapter#updateFunctionRecord(db.DBRecord) */ @Override - void updateFunctionRecord(Record functionRecord) throws IOException { + void updateFunctionRecord(DBRecord functionRecord) throws IOException { throw new UnsupportedOperationException(); } @@ -112,7 +112,7 @@ class FunctionAdapterV2 extends FunctionAdapter { * @see ghidra.program.database.function.FunctionAdapter#createFunctionRecord(ghidra.program.model.symbol.Scope, long) */ @Override - Record createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException { + DBRecord createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException { // Record rec = FUNCTION_SCHEMA.createRecord(symbolID); // rec.setLongValue(RETURN_DATA_TYPE_ID_COL, returnDataTypeId); // rec.setIntValue(STACK_PURGE_COL, Function.UNKNOWN_STACK_DEPTH_CHANGE); @@ -130,15 +130,15 @@ class FunctionAdapterV2 extends FunctionAdapter { } /** - * @see ghidra.program.database.function.FunctionAdapter#translateRecord(db.Record) + * @see ghidra.program.database.function.FunctionAdapter#translateRecord(db.DBRecord) */ @Override - Record translateRecord(Record record) { + DBRecord translateRecord(DBRecord record) { if (record == null) { return null; } long entryPointKey = record.getKey(); - Record newRecord = FunctionAdapter.FUNCTION_SCHEMA.createRecord(entryPointKey); + DBRecord newRecord = FunctionAdapter.FUNCTION_SCHEMA.createRecord(entryPointKey); newRecord.setLongValue(FunctionAdapter.RETURN_DATA_TYPE_ID_COL, record.getLongValue(V2_RETURN_DATA_TYPE_ID_COL)); newRecord.setIntValue(FunctionAdapter.STACK_PURGE_COL, diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV3.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV3.java index eca75bb2ae..0d64b65a70 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV3.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionAdapterV3.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -96,15 +95,15 @@ class FunctionAdapterV3 extends FunctionAdapter { * @see ghidra.program.database.function.FunctionAdapter#getFunctionRecord(long) */ @Override - Record getFunctionRecord(long functionKey) throws IOException { + DBRecord getFunctionRecord(long functionKey) throws IOException { return table.getRecord(functionKey); } /** - * @see ghidra.program.database.function.FunctionAdapter#updateFunctionRecord(db.Record) + * @see ghidra.program.database.function.FunctionAdapter#updateFunctionRecord(db.DBRecord) */ @Override - void updateFunctionRecord(Record functionRecord) throws IOException { + void updateFunctionRecord(DBRecord functionRecord) throws IOException { table.putRecord(functionRecord); } @@ -112,8 +111,8 @@ class FunctionAdapterV3 extends FunctionAdapter { * @see ghidra.program.database.function.FunctionAdapter#createFunctionRecord(ghidra.program.model.symbol.Scope, long) */ @Override - Record createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException { - Record rec = FUNCTION_SCHEMA.createRecord(symbolID); + DBRecord createFunctionRecord(long symbolID, long returnDataTypeId) throws IOException { + DBRecord rec = FUNCTION_SCHEMA.createRecord(symbolID); rec.setByteValue(FUNCTION_FLAGS_COL, getSignatureSourceFlagBits(SourceType.DEFAULT)); rec.setLongValue(RETURN_DATA_TYPE_ID_COL, returnDataTypeId); rec.setByteValue(CALLING_CONVENTION_ID_COL, @@ -132,10 +131,10 @@ class FunctionAdapterV3 extends FunctionAdapter { } /** - * @see ghidra.program.database.function.FunctionAdapter#translateRecord(db.Record) + * @see ghidra.program.database.function.FunctionAdapter#translateRecord(db.DBRecord) */ @Override - Record translateRecord(Record record) { + DBRecord translateRecord(DBRecord record) { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionDB.java index 7d1131530e..461abdd72e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionDB.java @@ -18,7 +18,7 @@ package ghidra.program.database.function; import java.io.IOException; import java.util.*; -import db.Record; +import db.DBRecord; import ghidra.program.database.*; import ghidra.program.database.data.DataTypeManagerDB; import ghidra.program.database.external.ExternalManagerDB; @@ -48,7 +48,7 @@ public class FunctionDB extends DatabaseObject implements Function { private ProgramDB program; private Address entryPoint; private Symbol functionSymbol; - private Record rec; + private DBRecord rec; private FunctionStackFrame frame; @@ -86,7 +86,7 @@ public class FunctionDB extends DatabaseObject implements Function { private boolean updateRefreshRequired = false; FunctionDB(FunctionManagerDB manager, DBObjectCache cache, AddressMap addrMap, - Record rec) { + DBRecord rec) { super(cache, rec.getKey()); this.manager = manager; program = manager.getProgram(); @@ -1755,7 +1755,7 @@ public class FunctionDB extends DatabaseObject implements Function { } @Override - protected boolean refresh(Record refreshRec) { + protected boolean refresh(DBRecord refreshRec) { if (updateInProgressCount != 0) { // update may have caused variable/data-type changes which may trigger a // refresh of this function - must defer until update completed diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java index 96a6cf0018..5388c282ae 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java @@ -155,7 +155,7 @@ public class FunctionManagerDB implements FunctionManager { return name; } try { - Record record = callingConventionAdapter.getCallingConventionRecord(id); + DBRecord record = callingConventionAdapter.getCallingConventionRecord(id); if (record == null) { return null; } @@ -198,7 +198,7 @@ public class FunctionManagerDB implements FunctionManager { if (callingConvention == null) { throw new InvalidInputException("Invalid calling convention name: " + name); } - Record record = callingConventionAdapter.getCallingConventionRecord(name); + DBRecord record = callingConventionAdapter.getCallingConventionRecord(name); if (record == null) { record = callingConventionAdapter.createCallingConventionRecord(name); } @@ -293,7 +293,7 @@ public class FunctionManagerDB implements FunctionManager { long returnDataTypeId = program.getDataTypeManager().getResolvedID(DataType.DEFAULT); try { - Record rec = adapter.createFunctionRecord(symbol.getID(), returnDataTypeId); + DBRecord rec = adapter.createFunctionRecord(symbol.getID(), returnDataTypeId); FunctionDB funcDB = new FunctionDB(this, cache, addrMap, rec); @@ -403,7 +403,7 @@ public class FunctionManagerDB implements FunctionManager { symbol, oldName, symbol.getName()); } - Record rec = adapter.createFunctionRecord(symbol.getID(), returnDataTypeId); + DBRecord rec = adapter.createFunctionRecord(symbol.getID(), returnDataTypeId); FunctionDB funcDB = new FunctionDB(this, cache, addrMap, rec); namespaceMgr.setBody(funcDB, body); @@ -533,7 +533,7 @@ public class FunctionManagerDB implements FunctionManager { // TODO: How should thunks which refer to deleted function be handled? // What about case where use is "re-creating" referenced function? // Delete thunks for now... - Record rec = thunks.next(); + DBRecord rec = thunks.next(); Symbol s = symbolMgr.getSymbol(rec.getKey()); if (s != null) { s.delete(); @@ -587,7 +587,7 @@ public class FunctionManagerDB implements FunctionManager { FunctionDB func = cache.get(key); if (func == null) { try { - Record rec = adapter.getFunctionRecord(key); + DBRecord rec = adapter.getFunctionRecord(key); if (rec != null) { func = new FunctionDB(this, cache, addrMap, rec); } @@ -1325,7 +1325,7 @@ public class FunctionManagerDB implements FunctionManager { try { RecordIterator it = adapter.iterateFunctionRecords(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); if (thunkAdapter.getThunkRecord(rec.getKey()) != null) { continue; // skip thunks @@ -1380,7 +1380,7 @@ public class FunctionManagerDB implements FunctionManager { return thunkedFunction != null ? thunkedFunction.getID() : -1; } try { - Record rec = thunkAdapter.getThunkRecord(functionId); + DBRecord rec = thunkAdapter.getThunkRecord(functionId); return rec != null ? rec.getLongValue(ThunkFunctionAdapter.LINKED_FUNCTION_ID_COL) : -1; } @@ -1405,7 +1405,7 @@ public class FunctionManagerDB implements FunctionManager { try { RecordIterator records = thunkAdapter.iterateThunkRecords(referencedFunctionId); while (records.hasNext()) { - Record rec = records.next(); + DBRecord rec = records.next(); if (list == null) { list = new ArrayList<>(1); } @@ -1422,7 +1422,7 @@ public class FunctionManagerDB implements FunctionManager { } FunctionDB getThunkedFunction(FunctionDB function) { - Record rec = null; + DBRecord rec = null; try { rec = thunkAdapter.getThunkRecord(function.getKey()); if (rec != null) { @@ -1453,7 +1453,7 @@ public class FunctionManagerDB implements FunctionManager { while (recIter.hasNext()) { monitor.checkCanceled(); - Record rec = recIter.next(); + DBRecord rec = recIter.next(); // NOTE: addrMap has already been switched-over to new language and its address spaces String serialization = rec.getString(FunctionAdapter.RETURN_STORAGE_COL); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagAdapter.java index f96c74297a..f560c81cf5 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagAdapter.java @@ -97,7 +97,7 @@ abstract class FunctionTagAdapter { * @return Record, or null if not found * @throws IOException */ - abstract Record getRecord(String tag) throws IOException; + abstract DBRecord getRecord(String tag) throws IOException; /** * Returns the tag record with the given id. @@ -106,24 +106,24 @@ abstract class FunctionTagAdapter { * @return Record, or null if not found * @throws IOException */ - abstract Record getRecord(long id) throws IOException; + abstract DBRecord getRecord(long id) throws IOException; /** - * Creates a {@link Record} with the given tag name. + * Creates a {@link DBRecord} with the given tag name. * * @param tag the tag name to create * @param comment tag comment * @return * @throws IOException */ - abstract Record createTagRecord(String tag, String comment) throws IOException; + abstract DBRecord createTagRecord(String tag, String comment) throws IOException; /** * Updates the database record for a tag. * @param record tag record * @throws IOException */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Removes the tag with the given name from the database. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagAdapterV0.java index 8622a74278..00706ae92c 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagAdapterV0.java @@ -64,7 +64,7 @@ class FunctionTagAdapterV0 extends FunctionTagAdapter implements DBListener { } @Override - Record getRecord(String tag) throws IOException { + DBRecord getRecord(String tag) throws IOException { if (table == null) { return null; } @@ -72,7 +72,7 @@ class FunctionTagAdapterV0 extends FunctionTagAdapter implements DBListener { // using an indexed column. RecordIterator iter = table.iterator(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); if (rec.getString(V0_TAG_NAME_COL).equals(tag)) { return rec; } @@ -81,11 +81,11 @@ class FunctionTagAdapterV0 extends FunctionTagAdapter implements DBListener { } @Override - Record createTagRecord(String tag, String comment) throws IOException { + DBRecord createTagRecord(String tag, String comment) throws IOException { // See if there is already a record for this tag name. If so, // just return that one. - Record rec = getRecord(tag); + DBRecord rec = getRecord(tag); if (rec == null) { rec = V0_SCHEMA.createRecord(getTable().getKey()); @@ -121,7 +121,7 @@ class FunctionTagAdapterV0 extends FunctionTagAdapter implements DBListener { } @Override - Record getRecord(long id) throws IOException { + DBRecord getRecord(long id) throws IOException { if (table == null) { return null; } @@ -129,7 +129,7 @@ class FunctionTagAdapterV0 extends FunctionTagAdapter implements DBListener { } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { getTable().putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagDB.java index 241566da4a..f46e0857de 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagDB.java @@ -18,7 +18,7 @@ package ghidra.program.database.function; import java.io.IOException; import java.util.Objects; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; import ghidra.program.model.listing.FunctionTag; @@ -29,10 +29,10 @@ import ghidra.program.model.listing.FunctionTag; public class FunctionTagDB extends DatabaseObject implements FunctionTag { private FunctionTagManagerDB mgr; - private Record record; + private DBRecord record; public FunctionTagDB(FunctionTagManagerDB mgr, DBObjectCache cache, - Record record) { + DBRecord record) { super(cache, record.getKey()); this.mgr = mgr; this.record = record; @@ -120,7 +120,7 @@ public class FunctionTagDB extends DatabaseObject implements FunctionTag { * Get tag record * @return record */ - Record getRecord() { + DBRecord getRecord() { return record; } @@ -133,7 +133,7 @@ public class FunctionTagDB extends DatabaseObject implements FunctionTag { } @Override - protected boolean refresh(Record rec) { + protected boolean refresh(DBRecord rec) { // As per the description of this function, if the record passed-in // is null, use whatever is in the database. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagManagerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagManagerDB.java index 6dc63ecbcc..eaebfd28f5 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagManagerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagManagerDB.java @@ -84,7 +84,7 @@ public class FunctionTagManagerDB implements FunctionTagManager, ErrorHandler { lock.acquire(); try { - Record rec = functionTagAdapter.getRecord(name); + DBRecord rec = functionTagAdapter.getRecord(name); if (rec != null) { return getFunctionTagFromCache(rec); } @@ -110,7 +110,7 @@ public class FunctionTagManagerDB implements FunctionTagManager, ErrorHandler { return tag; } - Record rec = functionTagAdapter.getRecord(id); + DBRecord rec = functionTagAdapter.getRecord(id); if (rec != null) { return new FunctionTagDB(this, cache, rec); } @@ -160,7 +160,7 @@ public class FunctionTagManagerDB implements FunctionTagManager, ErrorHandler { return tag; } - Record record = functionTagAdapter.createTagRecord(name, comment); + DBRecord record = functionTagAdapter.createTagRecord(name, comment); tag = getFunctionTagFromCache(record); fireTagCreatedNotification(ChangeManager.DOCR_FUNCTION_TAG_CREATED, tag); @@ -268,7 +268,7 @@ public class FunctionTagManagerDB implements FunctionTagManager, ErrorHandler { List tags = new ArrayList<>(); RecordIterator records = functionTagAdapter.getRecords(); while (records.hasNext()) { - Record record = records.next(); + DBRecord record = records.next(); tags.add(getFunctionTagFromCache(record)); } @@ -283,7 +283,7 @@ public class FunctionTagManagerDB implements FunctionTagManager, ErrorHandler { return Collections.emptyList(); } - public Record getTagRecord(long id) throws IOException { + public DBRecord getTagRecord(long id) throws IOException { return functionTagAdapter.getRecord(id); } @@ -331,7 +331,7 @@ public class FunctionTagManagerDB implements FunctionTagManager, ErrorHandler { * @param tagRecord the tag record to retrieve * @return tag new cached tag object */ - private FunctionTag getFunctionTagFromCache(Record tagRecord) { + private FunctionTag getFunctionTagFromCache(DBRecord tagRecord) { FunctionTagDB tag = cache.get(tagRecord); if (tag == null) { tag = new FunctionTagDB(this, cache, tagRecord); @@ -382,8 +382,8 @@ public class FunctionTagManagerDB implements FunctionTagManager, ErrorHandler { functionTagMappingAdapter.getRecordsByFunctionID(functionId); while (functionRecords.hasNext()) { - Record mappingRecord = functionRecords.next(); - Record tagRecord = functionTagAdapter.getRecord( + DBRecord mappingRecord = functionRecords.next(); + DBRecord tagRecord = functionTagAdapter.getRecord( mappingRecord.getLongValue(FunctionTagMappingAdapter.TAG_ID_COL)); tags.add(getFunctionTagFromCache(tagRecord)); } @@ -418,7 +418,7 @@ public class FunctionTagManagerDB implements FunctionTagManager, ErrorHandler { Map map = LazyMap.lazyMap(new HashMap<>(), () -> new Counter()); RecordIterator records = functionTagMappingAdapter.getRecords(); while (records.hasNext()) { - Record mappingRecord = records.next(); + DBRecord mappingRecord = records.next(); long tagId = mappingRecord.getLongValue(FunctionTagMappingAdapter.TAG_ID_COL); FunctionTag tag = getFunctionTag(tagId); map.get(tag).count++; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapter.java index 151014c195..1baa6e7990 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapter.java @@ -86,7 +86,7 @@ abstract class FunctionTagMappingAdapter { * @return null if not found * @throws IOException if database error occurs */ - abstract Record getRecord(long functionID, long tagID) throws IOException; + abstract DBRecord getRecord(long functionID, long tagID) throws IOException; /** * Creates a new record with the given function and tag ID's. @@ -96,7 +96,7 @@ abstract class FunctionTagMappingAdapter { * @return newly-created database record * @throws IOException if database error occurs */ - abstract Record createFunctionTagRecord(long functionID, long tagID) + abstract DBRecord createFunctionTagRecord(long functionID, long tagID) throws IOException; /** diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapterNoTable.java index 71dd0a0fe3..ffc7e982d4 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapterNoTable.java @@ -35,12 +35,12 @@ class FunctionTagMappingAdapterNoTable extends FunctionTagMappingAdapter { ******************************************************************************/ @Override - Record getRecord(long functionID, long tagID) throws IOException { + DBRecord getRecord(long functionID, long tagID) throws IOException { return null; } @Override - Record createFunctionTagRecord(long functionID, long tagID) + DBRecord createFunctionTagRecord(long functionID, long tagID) throws IOException { throw new UnsupportedOperationException("create record not supported"); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapterV0.java index 9bb36f4dda..9baaf22188 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionTagMappingAdapterV0.java @@ -71,7 +71,7 @@ class FunctionTagMappingAdapterV0 extends FunctionTagMappingAdapter implements D ******************************************************************************/ @Override - Record getRecord(long functionID, long tagID) throws IOException { + DBRecord getRecord(long functionID, long tagID) throws IOException { if (table == null) { return null; @@ -82,7 +82,7 @@ class FunctionTagMappingAdapterV0 extends FunctionTagMappingAdapter implements D RecordIterator iter = table.indexIterator(V0_FUNCTION_ID_COL, value, value, true); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); if ((rec.getLongValue(V0_FUNCTION_ID_COL) == functionID) && (rec.getLongValue(V0_TAG_ID_COL) == tagID)) { return rec; @@ -93,10 +93,10 @@ class FunctionTagMappingAdapterV0 extends FunctionTagMappingAdapter implements D } @Override - Record createFunctionTagRecord(long functionID, long tagID) throws IOException { + DBRecord createFunctionTagRecord(long functionID, long tagID) throws IOException { Table t = getTable(); - Record rec = SCHEMA.createRecord(t.getKey()); + DBRecord rec = SCHEMA.createRecord(t.getKey()); rec.setLongValue(V0_FUNCTION_ID_COL, functionID); rec.setLongValue(V0_TAG_ID_COL, tagID); t.putRecord(rec); @@ -107,7 +107,7 @@ class FunctionTagMappingAdapterV0 extends FunctionTagMappingAdapter implements D @Override boolean removeFunctionTagRecord(long functionID, long tagID) throws IOException { - Record record = getRecord(functionID, tagID); + DBRecord record = getRecord(functionID, tagID); if (record != null) { return table.deleteRecord(record.getKey()); } @@ -127,7 +127,7 @@ class FunctionTagMappingAdapterV0 extends FunctionTagMappingAdapter implements D // so it won't be indexed. RecordIterator iter = table.iterator(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); Long tID = rec.getLongValue(V0_TAG_ID_COL); if (tID == tagID) { iter.delete(); @@ -160,7 +160,7 @@ class FunctionTagMappingAdapterV0 extends FunctionTagMappingAdapter implements D } RecordIterator iter = table.iterator(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); if ((rec.getLongValue(V0_TAG_ID_COL) == tagID)) { return true; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/ThunkFunctionAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/ThunkFunctionAdapter.java index c25198afe4..d9a08b8c25 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/ThunkFunctionAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/ThunkFunctionAdapter.java @@ -75,13 +75,13 @@ abstract class ThunkFunctionAdapter { abstract RecordIterator iterateThunkRecords(long linkedFunctionKey) throws IOException; - abstract Record getThunkRecord(long functionKey) throws IOException; + abstract DBRecord getThunkRecord(long functionKey) throws IOException; abstract void removeThunkRecord(long functionKey) throws IOException; - abstract void updateThunkRecord(Record rec) throws IOException; + abstract void updateThunkRecord(DBRecord rec) throws IOException; - abstract Record createThunkRecord(long thunkFunctionId, long referencedFunctionId) + abstract DBRecord createThunkRecord(long thunkFunctionId, long referencedFunctionId) throws IOException; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/ThunkFunctionAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/ThunkFunctionAdapterV0.java index 3808458723..7dc16aaca3 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/ThunkFunctionAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/ThunkFunctionAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -74,7 +73,7 @@ public class ThunkFunctionAdapterV0 extends ThunkFunctionAdapter { } @Override - Record getThunkRecord(long functionKey) throws IOException { + DBRecord getThunkRecord(long functionKey) throws IOException { return table.getRecord(functionKey); } @@ -84,13 +83,13 @@ public class ThunkFunctionAdapterV0 extends ThunkFunctionAdapter { } @Override - void updateThunkRecord(Record rec) throws IOException { + void updateThunkRecord(DBRecord rec) throws IOException { table.putRecord(rec); } @Override - Record createThunkRecord(long thunkFunctionId, long referencedFunctionId) throws IOException { - Record rec = THUNK_FUNCTION_SCHEMA.createRecord(thunkFunctionId); + DBRecord createThunkRecord(long thunkFunctionId, long referencedFunctionId) throws IOException { + DBRecord rec = THUNK_FUNCTION_SCHEMA.createRecord(thunkFunctionId); rec.setField(LINKED_FUNCTION_ID_COL, new LongField(referencedFunctionId)); table.putRecord(rec); return rec; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressKeyRecordIterator.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressKeyRecordIterator.java index ed749be9c3..ba8100b658 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressKeyRecordIterator.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressKeyRecordIterator.java @@ -220,7 +220,7 @@ public class AddressKeyRecordIterator implements RecordIterator { /** * @see db.RecordIterator#next() */ - public Record next() throws IOException { + public DBRecord next() throws IOException { if (hasNext()) { return it.next(); } @@ -230,7 +230,7 @@ public class AddressKeyRecordIterator implements RecordIterator { /** * @see db.RecordIterator#previous() */ - public Record previous() throws IOException { + public DBRecord previous() throws IOException { if (hasPrevious()) { return it.previous(); } @@ -247,7 +247,7 @@ public class AddressKeyRecordIterator implements RecordIterator { return false; } - public Iterator iterator() { + public Iterator iterator() { // TODO Auto-generated method stub return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressMapDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressMapDBAdapterV0.java index 479b1ed7f8..c7d189732e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressMapDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressMapDBAdapterV0.java @@ -60,7 +60,7 @@ class AddressMapDBAdapterV0 extends AddressMapDBAdapter { RecordIterator it = table.iterator(); int deletedID = 1; while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(SPACE_NAME_COL); int segment = rec.getIntValue(SEGMENT_COL); AddressSpace space = factory.getAddressSpace(spaceName); @@ -98,7 +98,7 @@ class AddressMapDBAdapterV0 extends AddressMapDBAdapter { ArrayList list = new ArrayList(); RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(SPACE_NAME_COL); boolean deleted = (factory.getAddressSpace(spaceName) == null); list.add(new AddressMapEntry((int) rec.getKey(), spaceName, diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressMapDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressMapDBAdapterV1.java index 4a6402eba5..ba498e76a5 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressMapDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressMapDBAdapterV1.java @@ -65,7 +65,7 @@ class AddressMapDBAdapterV1 extends AddressMapDBAdapter { addresses = new Address[table.getRecordCount()]; RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(SPACE_NAME_COL); int segment = rec.getIntValue(SEGMENT_COL); boolean deleted = rec.getBooleanValue(DELETED_COL); @@ -106,7 +106,7 @@ class AddressMapDBAdapterV1 extends AddressMapDBAdapter { ArrayList list = new ArrayList(); RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(SPACE_NAME_COL); list.add(new AddressMapEntry((int) rec.getKey(), spaceName, rec.getIntValue(SEGMENT_COL), rec.getBooleanValue(DELETED_COL))); @@ -126,7 +126,7 @@ class AddressMapDBAdapterV1 extends AddressMapDBAdapter { if (entry.index != table.getRecordCount()) { throw new IllegalArgumentException("Bad map entry"); } - Record rec = SCHEMA.createRecord(entry.index); + DBRecord rec = SCHEMA.createRecord(entry.index); rec.setString(SPACE_NAME_COL, entry.name); rec.setIntValue(SEGMENT_COL, entry.segment); rec.setBooleanValue(DELETED_COL, entry.deleted); @@ -141,7 +141,7 @@ class AddressMapDBAdapterV1 extends AddressMapDBAdapter { @Override Address[] addBaseAddress(Address addr, long normalizedOffset) { - Record rec = SCHEMA.createRecord(addresses.length); + DBRecord rec = SCHEMA.createRecord(addresses.length); AddressSpace space = addr.getAddressSpace(); rec.setString(SPACE_NAME_COL, space.getName()); int segment = (int) (normalizedOffset >> AddressMapDB.ADDR_OFFSET_SIZE); @@ -181,7 +181,7 @@ class AddressMapDBAdapterV1 extends AddressMapDBAdapter { void renameOverlaySpace(String oldName, String newName) throws IOException { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(SPACE_NAME_COL); boolean deleted = rec.getBooleanValue(DELETED_COL); if (!deleted && spaceName.equals(oldName)) { @@ -195,7 +195,7 @@ class AddressMapDBAdapterV1 extends AddressMapDBAdapter { void deleteOverlaySpace(String name) throws IOException { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); String spaceName = rec.getString(SPACE_NAME_COL); if (spaceName.equals(name)) { rec.setBooleanValue(DELETED_COL, true); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressRecordDeleter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressRecordDeleter.java index ad94e417c1..ace9c925ad 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressRecordDeleter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/map/AddressRecordDeleter.java @@ -79,7 +79,7 @@ public class AddressRecordDeleter { while (iter.hasNext()) { Field next = iter.next(); if (filter != null) { - Record record = table.getRecord(next); + DBRecord record = table.getRecord(next); if (!filter.matches(record)) { continue; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/BitMappedSubMemoryBlock.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/BitMappedSubMemoryBlock.java index 51600d349e..dfa7eea60a 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/BitMappedSubMemoryBlock.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/BitMappedSubMemoryBlock.java @@ -17,7 +17,7 @@ package ghidra.program.database.mem; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.database.map.AddressMapDB; import ghidra.program.model.address.*; import ghidra.program.model.mem.MemoryAccessException; @@ -31,7 +31,7 @@ class BitMappedSubMemoryBlock extends SubMemoryBlock { private final Address mappedAddress; private boolean ioPending; - BitMappedSubMemoryBlock(MemoryMapDBAdapter adapter, Record record) { + BitMappedSubMemoryBlock(MemoryMapDBAdapter adapter, DBRecord record) { super(adapter, record); this.memMap = adapter.getMemoryMap(); AddressMapDB addressMap = memMap.getAddressMap(); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/BufferSubMemoryBlock.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/BufferSubMemoryBlock.java index 2b65260cd8..fde2b809a2 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/BufferSubMemoryBlock.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/BufferSubMemoryBlock.java @@ -18,7 +18,7 @@ package ghidra.program.database.mem; import java.io.IOException; import db.DBBuffer; -import db.Record; +import db.DBRecord; import ghidra.program.model.mem.Memory; /** @@ -28,7 +28,7 @@ import ghidra.program.model.mem.Memory; class BufferSubMemoryBlock extends SubMemoryBlock { final DBBuffer buf; - BufferSubMemoryBlock(MemoryMapDBAdapter adapter, Record record) throws IOException { + BufferSubMemoryBlock(MemoryMapDBAdapter adapter, DBRecord record) throws IOException { super(adapter, record); int bufferID = record.getIntValue(MemoryMapDBAdapter.SUB_INT_DATA1_COL); buf = adapter.getBuffer(bufferID); @@ -105,7 +105,7 @@ class BufferSubMemoryBlock extends SubMemoryBlock { DBBuffer split = buf.split(offset); - Record newSubRecord = adapter.createSubBlockRecord(0, 0, newLength, + DBRecord newSubRecord = adapter.createSubBlockRecord(0, 0, newLength, MemoryMapDBAdapter.SUB_TYPE_BUFFER, split.getId(), 0); return new BufferSubMemoryBlock(adapter, newSubRecord); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/ByteMappedSubMemoryBlock.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/ByteMappedSubMemoryBlock.java index b46c4302cc..2541ae8715 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/ByteMappedSubMemoryBlock.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/ByteMappedSubMemoryBlock.java @@ -17,7 +17,7 @@ package ghidra.program.database.mem; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.database.map.AddressMapDB; import ghidra.program.model.address.*; import ghidra.program.model.mem.MemoryAccessException; @@ -34,7 +34,7 @@ class ByteMappedSubMemoryBlock extends SubMemoryBlock { private boolean ioPending; - ByteMappedSubMemoryBlock(MemoryMapDBAdapter adapter, Record record) { + ByteMappedSubMemoryBlock(MemoryMapDBAdapter adapter, DBRecord record) { super(adapter, record); this.memMap = adapter.getMemoryMap(); AddressMapDB addressMap = memMap.getAddressMap(); @@ -191,7 +191,7 @@ class ByteMappedSubMemoryBlock extends SubMemoryBlock { AddressMapDB addressMap = adapter.getMemoryMap().getAddressMap(); long encodedAddr = addressMap.getKey(newAddr, true); - Record newSubRecord = adapter.createSubBlockRecord(0, 0, newLength, + DBRecord newSubRecord = adapter.createSubBlockRecord(0, 0, newLength, MemoryMapDBAdapter.SUB_TYPE_BYTE_MAPPED, 0, encodedAddr); return new ByteMappedSubMemoryBlock(adapter, newSubRecord); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytes.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytes.java index f1e2ac6fe9..e8c8643edd 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytes.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytes.java @@ -39,7 +39,7 @@ public class FileBytes { private DBBuffer[] layeredBuffers; private boolean invalid = false; - public FileBytes(FileBytesAdapter adapter, Record record) throws IOException { + public FileBytes(FileBytesAdapter adapter, DBRecord record) throws IOException { this.adapter = adapter; this.id = record.getKey(); this.filename = record.getString(FileBytesAdapter.FILENAME_COL); @@ -48,7 +48,7 @@ public class FileBytes { refresh(record); } - synchronized boolean refresh(Record record) throws IOException { + synchronized boolean refresh(DBRecord record) throws IOException { String f = record.getString(FileBytesAdapter.FILENAME_COL); long offset = record.getLongValue(FileBytesAdapter.OFFSET_COL); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytesAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytesAdapterV0.java index d9482941bd..c5a2905ba9 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytesAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytesAdapterV0.java @@ -64,7 +64,7 @@ class FileBytesAdapterV0 extends FileBytesAdapter { // load existing file bytes RecordIterator iterator = table.iterator(); while (iterator.hasNext()) { - Record record = iterator.next(); + DBRecord record = iterator.next(); fileBytesList.add(new FileBytes(this, record)); } @@ -77,7 +77,7 @@ class FileBytesAdapterV0 extends FileBytesAdapter { DBBuffer[] layeredBuffers = createLayeredBuffers(buffers); int[] bufIds = getIds(buffers); int[] layeredBufIds = getIds(layeredBuffers); - Record record = SCHEMA.createRecord(table.getKey()); + DBRecord record = SCHEMA.createRecord(table.getKey()); record.setString(V0_FILENAME_COL, filename); record.setLongValue(V0_OFFSET_COL, offset); record.setLongValue(V0_SIZE_COL, size); @@ -105,7 +105,7 @@ class FileBytesAdapterV0 extends FileBytesAdapter { RecordIterator iterator = table.iterator(); while (iterator.hasNext()) { - Record record = iterator.next(); + DBRecord record = iterator.next(); FileBytes fileBytes = map.remove(record.getKey()); if (fileBytes != null) { if (!fileBytes.refresh(record)) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytesSubMemoryBlock.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytesSubMemoryBlock.java index a3c8192d1f..58c7e875d8 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytesSubMemoryBlock.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/FileBytesSubMemoryBlock.java @@ -17,7 +17,7 @@ package ghidra.program.database.mem; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.model.mem.MemoryAccessException; /** @@ -27,7 +27,7 @@ class FileBytesSubMemoryBlock extends SubMemoryBlock { private final FileBytes fileBytes; private final long fileBytesOffset; - FileBytesSubMemoryBlock(MemoryMapDBAdapter adapter, Record record) throws IOException { + FileBytesSubMemoryBlock(MemoryMapDBAdapter adapter, DBRecord record) throws IOException { super(adapter, record); long fileBytesID = record.getLongValue(MemoryMapDBAdapter.SUB_INT_DATA1_COL); fileBytesOffset = record.getLongValue(MemoryMapDBAdapter.SUB_LONG_DATA2_COL); @@ -104,7 +104,7 @@ class FileBytesSubMemoryBlock extends SubMemoryBlock { adapter.updateSubBlockRecord(record); int fileBytesID = record.getIntValue(MemoryMapDBAdapter.SUB_INT_DATA1_COL); - Record newSubRecord = adapter.createSubBlockRecord(0, 0, newLength, + DBRecord newSubRecord = adapter.createSubBlockRecord(0, 0, newLength, MemoryMapDBAdapter.SUB_TYPE_FILE_BYTES, fileBytesID, fileBytesOffset + offset); return new FileBytesSubMemoryBlock(adapter, newSubRecord); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryBlockDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryBlockDB.java index 72fe562a79..ec760560cc 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryBlockDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryBlockDB.java @@ -20,7 +20,7 @@ import java.io.InputStream; import java.util.*; import db.DBBuffer; -import db.Record; +import db.DBRecord; import ghidra.framework.store.LockException; import ghidra.program.database.map.AddressMap; import ghidra.program.database.map.AddressMapDB; @@ -31,7 +31,7 @@ import ghidra.util.exception.AssertException; public class MemoryBlockDB implements MemoryBlock { private MemoryMapDBAdapter adapter; - protected Record record; + protected DBRecord record; private Address startAddress; private long length; private List subBlocks; @@ -42,7 +42,7 @@ public class MemoryBlockDB implements MemoryBlock { private List mappedBlocks; // list of mapped blocks which map onto this block - MemoryBlockDB(MemoryMapDBAdapter adapter, Record record, List subBlocks) { + MemoryBlockDB(MemoryMapDBAdapter adapter, DBRecord record, List subBlocks) { this.adapter = adapter; this.record = record; this.memMap = adapter.getMemoryMap(); @@ -58,7 +58,7 @@ public class MemoryBlockDB implements MemoryBlock { return id; } - void refresh(Record lRecord, List list) { + void refresh(DBRecord lRecord, List list) { if (id != lRecord.getKey()) { throw new AssertException("Incorrect block record"); } @@ -642,7 +642,7 @@ public class MemoryBlockDB implements MemoryBlock { private void createBufferSubBlock(byte initialValue, long blockOffset, int size) throws IOException { DBBuffer buffer = adapter.createBuffer(size, initialValue); - Record subBlockRecord = adapter.createSubBlockRecord(id, blockOffset, size, + DBRecord subBlockRecord = adapter.createSubBlockRecord(id, blockOffset, size, MemoryMapDBAdapter.SUB_TYPE_BUFFER, buffer.getId(), 0); BufferSubMemoryBlock sub = new BufferSubMemoryBlock(adapter, subBlockRecord); @@ -684,7 +684,7 @@ public class MemoryBlockDB implements MemoryBlock { subBlock.delete(); } subBlocks.clear(); - Record subRecord = adapter.createSubBlockRecord(id, 0, length, + DBRecord subRecord = adapter.createSubBlockRecord(id, 0, length, MemoryMapDBAdapter.SUB_TYPE_UNITIALIZED, 0, 0); subBlocks.add(new UninitializedSubMemoryBlock(adapter, subRecord)); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapter.java index 3cc6ae4ded..6a3fbf8e52 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapter.java @@ -240,7 +240,7 @@ abstract class MemoryMapDBAdapter { * @param record the record to update. * @throws IOException if a database IO error occurs. */ - abstract void updateBlockRecord(Record record) throws IOException; + abstract void updateBlockRecord(DBRecord record) throws IOException; /** * Creates a new DBuffer object with the given length and initial value. @@ -269,7 +269,7 @@ abstract class MemoryMapDBAdapter { * @param record the record to update. * @throws IOException if a database IO error occurs. */ - protected abstract void updateSubBlockRecord(Record record) throws IOException; + protected abstract void updateSubBlockRecord(DBRecord record) throws IOException; /** * Creates a record for a new created sub block @@ -283,7 +283,7 @@ abstract class MemoryMapDBAdapter { * @return the newly created record. * @throws IOException if a database error occurs */ - abstract Record createSubBlockRecord(long memBlockId, long startingOffset, long length, + abstract DBRecord createSubBlockRecord(long memBlockId, long startingOffset, long length, byte subType, int data1, long data2) throws IOException; /** diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV0.java index 30decfc948..6f6e48c5b3 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV0.java @@ -97,7 +97,7 @@ class MemoryMapDBAdapterV0 extends MemoryMapDBAdapter { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); int permissions = 0; if (rec.getBooleanValue(V0_IS_READ_COL)) { permissions |= MemoryBlock.READ; @@ -117,8 +117,8 @@ class MemoryMapDBAdapterV0 extends MemoryMapDBAdapter { segment = rec.getIntValue(V0_SEGMENT_COL); } - Record blockRecord = BLOCK_SCHEMA.createRecord(key); - Record subBlockRecord = SUB_BLOCK_SCHEMA.createRecord(key); + DBRecord blockRecord = BLOCK_SCHEMA.createRecord(key); + DBRecord subBlockRecord = SUB_BLOCK_SCHEMA.createRecord(key); blockRecord.setString(NAME_COL, rec.getString(V0_NAME_COL)); blockRecord.setString(COMMENTS_COL, rec.getString(V0_COMMENTS_COL)); @@ -143,7 +143,7 @@ class MemoryMapDBAdapterV0 extends MemoryMapDBAdapter { Collections.sort(blocks); } - private SubMemoryBlock getSubBlock(MemoryMapDB memMap, long bufID, Record record, int type, + private SubMemoryBlock getSubBlock(MemoryMapDB memMap, long bufID, DBRecord record, int type, long overlayAddr) throws IOException { switch (type) { case MemoryMapDBAdapterV2.BIT_MAPPED: @@ -212,7 +212,7 @@ class MemoryMapDBAdapterV0 extends MemoryMapDBAdapter { } @Override - void updateBlockRecord(Record record) throws IOException { + void updateBlockRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @@ -248,12 +248,12 @@ class MemoryMapDBAdapterV0 extends MemoryMapDBAdapter { } @Override - protected void updateSubBlockRecord(Record record) throws IOException { + protected void updateSubBlockRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @Override - Record createSubBlockRecord(long memBlockId, long startingOffset, long length, byte subType, + DBRecord createSubBlockRecord(long memBlockId, long startingOffset, long length, byte subType, int data1, long data2) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV2.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV2.java index 7a27671123..45d54985bf 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV2.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV2.java @@ -84,7 +84,7 @@ class MemoryMapDBAdapterV2 extends MemoryMapDBAdapter { RecordIterator it = table.iterator(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); int permissions = rec.getByteValue(V2_PERMISSIONS_COL); long startAddr = rec.getLongValue(V2_START_ADDR_COL); @@ -92,8 +92,8 @@ class MemoryMapDBAdapterV2 extends MemoryMapDBAdapter { int bufID = rec.getIntValue(V2_CHAIN_BUF_COL); int segment = rec.getIntValue(V2_SEGMENT_COL); - Record blockRecord = BLOCK_SCHEMA.createRecord(key); - Record subBlockRecord = SUB_BLOCK_SCHEMA.createRecord(key); + DBRecord blockRecord = BLOCK_SCHEMA.createRecord(key); + DBRecord subBlockRecord = SUB_BLOCK_SCHEMA.createRecord(key); blockRecord.setString(NAME_COL, rec.getString(V2_NAME_COL)); blockRecord.setString(COMMENTS_COL, rec.getString(V2_COMMENTS_COL)); @@ -119,7 +119,7 @@ class MemoryMapDBAdapterV2 extends MemoryMapDBAdapter { } - private SubMemoryBlock getSubBlock(int bufID, Record record, int type, long overlayAddr) + private SubMemoryBlock getSubBlock(int bufID, DBRecord record, int type, long overlayAddr) throws IOException { switch (type) { case MemoryMapDBAdapterV2.BIT_MAPPED: @@ -178,7 +178,7 @@ class MemoryMapDBAdapterV2 extends MemoryMapDBAdapter { } @Override - void updateBlockRecord(Record record) throws IOException { + void updateBlockRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @@ -211,12 +211,12 @@ class MemoryMapDBAdapterV2 extends MemoryMapDBAdapter { } @Override - protected void updateSubBlockRecord(Record record) throws IOException { + protected void updateSubBlockRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @Override - Record createSubBlockRecord(long memBlockId, long startingOffset, long length, byte subType, + DBRecord createSubBlockRecord(long memBlockId, long startingOffset, long length, byte subType, int data1, long data2) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV3.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV3.java index 1d6817f761..3655865b5a 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV3.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/MemoryMapDBAdapterV3.java @@ -122,7 +122,7 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { List newBlocks = new ArrayList<>(); RecordIterator it = memBlockTable.iterator(); while (it.hasNext()) { - Record record = it.next(); + DBRecord record = it.next(); long key = record.getKey(); MemoryBlockDB block = blockMap.remove(key); if (block != null) { @@ -154,7 +154,7 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { List subBlocks = new ArrayList<>(); try { - Record blockRecord = createMemoryBlockRecord(name, startAddr, length, permissions); + DBRecord blockRecord = createMemoryBlockRecord(name, startAddr, length, permissions); long key = blockRecord.getKey(); int numFullBlocks = (int) (length / maxSubBlockSize); int lastSubBlockSize = (int) (length % maxSubBlockSize); @@ -209,10 +209,10 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { updateAddressMapForAllAddresses(startAddr, buf.length()); List subBlocks = new ArrayList<>(); - Record blockRecord = createMemoryBlockRecord(name, startAddr, buf.length(), permissions); + DBRecord blockRecord = createMemoryBlockRecord(name, startAddr, buf.length(), permissions); long key = blockRecord.getKey(); - Record subRecord = + DBRecord subRecord = createSubBlockRecord(key, 0, buf.length(), V3_SUB_TYPE_BUFFER, buf.getId(), 0); subBlockTable.putRecord(subRecord); subBlocks.add(new BufferSubMemoryBlock(this, subRecord)); @@ -229,10 +229,10 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { updateAddressMapForAllAddresses(startAddress, length); List subBlocks = new ArrayList<>(); - Record blockRecord = createMemoryBlockRecord(name, startAddress, length, permissions); + DBRecord blockRecord = createMemoryBlockRecord(name, startAddress, length, permissions); long key = blockRecord.getKey(); - Record subRecord = createSubBlockRecord(key, 0, length, V3_SUB_TYPE_UNITIALIZED, 0, 0); + DBRecord subRecord = createSubBlockRecord(key, 0, length, V3_SUB_TYPE_UNITIALIZED, 0, 0); subBlocks.add(new UninitializedSubMemoryBlock(this, subRecord)); memBlockTable.putRecord(blockRecord); @@ -245,7 +245,7 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { @Override protected MemoryBlockDB createBlock(String name, Address startAddress, long length, int permissions, List splitBlocks) throws IOException { - Record blockRecord = createMemoryBlockRecord(name, startAddress, length, permissions); + DBRecord blockRecord = createMemoryBlockRecord(name, startAddress, length, permissions); long key = blockRecord.getKey(); long startingOffset = 0; @@ -284,10 +284,10 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { updateAddressMapForAllAddresses(startAddress, length); List subBlocks = new ArrayList<>(); - Record blockRecord = createMemoryBlockRecord(name, startAddress, length, permissions); + DBRecord blockRecord = createMemoryBlockRecord(name, startAddress, length, permissions); long key = blockRecord.getKey(); - Record subRecord = createSubBlockRecord(key, 0, length, V3_SUB_TYPE_FILE_BYTES, + DBRecord subRecord = createSubBlockRecord(key, 0, length, V3_SUB_TYPE_FILE_BYTES, (int) fileBytes.getId(), offset); subBlocks.add(createSubBlock(subRecord)); @@ -305,11 +305,11 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { updateAddressMapForAllAddresses(startAddress, length); List subBlocks = new ArrayList<>(); - Record blockRecord = createMemoryBlockRecord(name, startAddress, length, permissions); + DBRecord blockRecord = createMemoryBlockRecord(name, startAddress, length, permissions); long key = blockRecord.getKey(); long encoded = addrMap.getKey(mappedAddress, true); - Record subRecord = createSubBlockRecord(key, 0, length, type, mappingScheme, encoded); + DBRecord subRecord = createSubBlockRecord(key, 0, length, type, mappingScheme, encoded); subBlocks.add(createSubBlock(subRecord)); memBlockTable.putRecord(blockRecord); @@ -330,12 +330,12 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { } @Override - void updateBlockRecord(Record record) throws IOException { + void updateBlockRecord(DBRecord record) throws IOException { memBlockTable.putRecord(record); } @Override - protected void updateSubBlockRecord(Record record) throws IOException { + protected void updateSubBlockRecord(DBRecord record) throws IOException { subBlockTable.putRecord(record); } @@ -353,10 +353,10 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { } @Override - Record createSubBlockRecord(long parentKey, long startingOffset, long length, byte type, + DBRecord createSubBlockRecord(long parentKey, long startingOffset, long length, byte type, int data1, long data2) throws IOException { - Record record = V3_SUB_BLOCK_SCHEMA.createRecord(subBlockTable.getKey()); + DBRecord record = V3_SUB_BLOCK_SCHEMA.createRecord(subBlockTable.getKey()); record.setLongValue(V3_SUB_PARENT_ID_COL, parentKey); record.setByteValue(V3_SUB_TYPE_COL, type); record.setLongValue(V3_SUB_LENGTH_COL, length); @@ -368,9 +368,9 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { return record; } - private Record createMemoryBlockRecord(String name, Address startAddr, long length, + private DBRecord createMemoryBlockRecord(String name, Address startAddr, long length, int permissions) { - Record record = V3_BLOCK_SCHEMA.createRecord(memBlockTable.getKey()); + DBRecord record = V3_BLOCK_SCHEMA.createRecord(memBlockTable.getKey()); record.setString(V3_NAME_COL, name); record.setLongValue(V3_START_ADDR_COL, addrMap.getKey(startAddr, true)); record.setLongValue(V3_LENGTH_COL, length); @@ -383,7 +383,7 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { List subBlocks = new ArrayList<>(subBlockTable.getRecordCount()); RecordIterator it = subBlockTable.iterator(); while (it.hasNext()) { - Record record = it.next(); + DBRecord record = it.next(); subBlocks.add(createSubBlock(record)); } return subBlocks.stream().collect(Collectors.groupingBy(SubMemoryBlock::getParentBlockID)); @@ -402,7 +402,7 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { addrMap.getKeyRanges(set, true); } - private SubMemoryBlock createSubBlock(Record record) throws IOException { + private SubMemoryBlock createSubBlock(DBRecord record) throws IOException { byte byteValue = record.getByteValue(V3_SUB_TYPE_COL); switch (byteValue) { @@ -424,7 +424,7 @@ public class MemoryMapDBAdapterV3 extends MemoryMapDBAdapter { private SubMemoryBlock createBufferSubBlock(long parentKey, long offset, long length, InputStream is) throws IOException { DBBuffer buffer = createBuffer(length, is); - Record record = + DBRecord record = createSubBlockRecord(parentKey, offset, length, V3_SUB_TYPE_BUFFER, buffer.getId(), 0); return new BufferSubMemoryBlock(this, record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/SubMemoryBlock.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/SubMemoryBlock.java index eb655c95a3..570f24ffc6 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/SubMemoryBlock.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/SubMemoryBlock.java @@ -17,7 +17,7 @@ package ghidra.program.database.mem; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.model.mem.*; /** @@ -27,11 +27,11 @@ import ghidra.program.model.mem.*; abstract class SubMemoryBlock implements Comparable { protected final MemoryMapDBAdapter adapter; - protected final Record record; + protected final DBRecord record; protected long subBlockLength; protected long subBlockOffset; - protected SubMemoryBlock(MemoryMapDBAdapter adapter, Record record) { + protected SubMemoryBlock(MemoryMapDBAdapter adapter, DBRecord record) { this.adapter = adapter; this.record = record; this.subBlockOffset = record.getLongValue(MemoryMapDBAdapter.SUB_START_OFFSET_COL); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/UninitializedSubMemoryBlock.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/UninitializedSubMemoryBlock.java index e30c47c253..7bdedf13e0 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/UninitializedSubMemoryBlock.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/mem/UninitializedSubMemoryBlock.java @@ -17,7 +17,7 @@ package ghidra.program.database.mem; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.model.mem.MemoryAccessException; /** @@ -25,7 +25,7 @@ import ghidra.program.model.mem.MemoryAccessException; */ class UninitializedSubMemoryBlock extends SubMemoryBlock { - UninitializedSubMemoryBlock(MemoryMapDBAdapter adapter, Record record) { + UninitializedSubMemoryBlock(MemoryMapDBAdapter adapter, DBRecord record) { super(adapter, record); } @@ -78,7 +78,7 @@ class UninitializedSubMemoryBlock extends SubMemoryBlock { record.setLongValue(MemoryMapDBAdapter.SUB_LENGTH_COL, subBlockLength); adapter.updateSubBlockRecord(record); - Record newSubRecord = adapter.createSubBlockRecord(-1, 0, newLength, + DBRecord newSubRecord = adapter.createSubBlockRecord(-1, 0, newLength, MemoryMapDBAdapter.SUB_TYPE_UNITIALIZED, 0, 0); return new UninitializedSubMemoryBlock(adapter, newSubRecord); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/FragmentDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/FragmentDB.java index 98e964ce2d..8160ee27e3 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/FragmentDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/FragmentDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.Iterator; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; import ghidra.program.model.address.*; @@ -35,7 +35,7 @@ import ghidra.util.exception.NotFoundException; */ class FragmentDB extends DatabaseObject implements ProgramFragment { - private Record record; + private DBRecord record; private ModuleManager moduleMgr; private GroupDBAdapter adapter; private AddressSetView addrSet; @@ -48,7 +48,7 @@ class FragmentDB extends DatabaseObject implements ProgramFragment { * @param record * @param addrSet */ - FragmentDB(ModuleManager moduleMgr, DBObjectCache cache, Record record, + FragmentDB(ModuleManager moduleMgr, DBObjectCache cache, DBRecord record, AddressSet addrSet) { super(cache, record.getKey()); this.moduleMgr = moduleMgr; @@ -61,7 +61,7 @@ class FragmentDB extends DatabaseObject implements ProgramFragment { @Override protected boolean refresh() { try { - Record rec = adapter.getFragmentRecord(key); + DBRecord rec = adapter.getFragmentRecord(key); if (rec != null) { record = rec; addrSet = moduleMgr.getFragmentAddressSet(key); @@ -177,7 +177,7 @@ class FragmentDB extends DatabaseObject implements ProgramFragment { lock.acquire(); try { checkIsValid(); - Record r = adapter.getFragmentRecord(name); + DBRecord r = adapter.getFragmentRecord(name); if (r != null) { if (key != r.getKey()) { throw new DuplicateNameException(name + " already exists"); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/GroupDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/GroupDBAdapter.java index 2eaceb2d0c..24295bd8e5 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/GroupDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/GroupDBAdapter.java @@ -18,7 +18,7 @@ package ghidra.program.database.module; import java.io.IOException; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.util.exception.DuplicateNameException; /** @@ -34,7 +34,7 @@ interface GroupDBAdapter { * @return record for the root module; should never be null * @throws IOException if there was a problem accessing the database */ - Record createRootModule(String name) throws IOException; + DBRecord createRootModule(String name) throws IOException; /** * Create a new module. @@ -45,7 +45,7 @@ interface GroupDBAdapter { * @throws DuplicateNameException if a module or fragment already exists * having the given name */ - Record createModule(long parentModuleID, String name) + DBRecord createModule(long parentModuleID, String name) throws IOException, DuplicateNameException; /** @@ -54,7 +54,7 @@ interface GroupDBAdapter { * @return record for the module; null if the record was not found * @throws IOException if there was a problem accessing the database */ - Record getModuleRecord(long moduleID) throws IOException; + DBRecord getModuleRecord(long moduleID) throws IOException; /** * Get the module record with the given name. @@ -62,13 +62,13 @@ interface GroupDBAdapter { * @return module record; null if no module exists with the given name * @throws IOException if there was a problem accessing the database */ - Record getModuleRecord(String name) throws IOException; + DBRecord getModuleRecord(String name) throws IOException; /** * Update the module table with the given record. * @throws IOException if there was a problem accessing the database */ - void updateModuleRecord(Record record) throws IOException; + void updateModuleRecord(DBRecord record) throws IOException; /** * Create a new fragment @@ -79,7 +79,7 @@ interface GroupDBAdapter { * @throws DuplicateNameException if a module or fragment already exists * having the given name */ - Record createFragment(long parentModuleID, String name) + DBRecord createFragment(long parentModuleID, String name) throws IOException, DuplicateNameException; /** @@ -88,7 +88,7 @@ interface GroupDBAdapter { * @return * @throws IOException if there was a problem accessing the database */ - Record getFragmentRecord(long fragID) throws IOException; + DBRecord getFragmentRecord(long fragID) throws IOException; /** * Get the fragment record with the given name. @@ -97,13 +97,13 @@ interface GroupDBAdapter { * name * @throws IOException if there was a problem accessing the database */ - Record getFragmentRecord(String name) throws IOException; + DBRecord getFragmentRecord(String name) throws IOException; /** * Update the fragment table with the given record. * @throws IOException if there was a problem accessing the database */ - void updateFragmentRecord(Record record) throws IOException; + void updateFragmentRecord(DBRecord record) throws IOException; /** * Get the record in the Parent/Child table. @@ -112,7 +112,7 @@ interface GroupDBAdapter { * @return record; null if the record was not found * @throws IOException if there was a problem accessing the database */ - Record getParentChildRecord(long parentID, long childID) throws IOException; + DBRecord getParentChildRecord(long parentID, long childID) throws IOException; /** * Get the keys in the Parent/Child table that are indexed on the given @@ -129,7 +129,7 @@ interface GroupDBAdapter { * @return record or null if the record does not exist * @throws IOException if there was a problem accessing the database */ - Record getParentChildRecord(long key) throws IOException; + DBRecord getParentChildRecord(long key) throws IOException; /** * Create a new Parent/Child record. @@ -138,7 +138,7 @@ interface GroupDBAdapter { * @return record or nul if the record does not exist * @throws IOException if there was a problem accessing the database */ - Record addParentChildRecord(long parentID, long childID) throws IOException; + DBRecord addParentChildRecord(long parentID, long childID) throws IOException; /** * Remove the record with the given key in the Parent/Child table. @@ -151,7 +151,7 @@ interface GroupDBAdapter { * Update the Parent/Child table with the given record. * @throws IOException if there was a problem accessing the database */ - void updateParentChildRecord(Record record) throws IOException; + void updateParentChildRecord(DBRecord record) throws IOException; /** * Remove the fragment record. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/GroupDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/GroupDBAdapterV0.java index 4c478060d4..35589eb532 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/GroupDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/GroupDBAdapterV0.java @@ -44,18 +44,18 @@ class GroupDBAdapterV0 implements GroupDBAdapter { } @Override - public Record createModule(long parentModuleID, String name) + public DBRecord createModule(long parentModuleID, String name) throws IOException, DuplicateNameException { if (getModuleRecord(name) != null || getFragmentRecord(name) != null) { throw new DuplicateNameException(name + " already exists"); } - Record record = TreeManager.MODULE_SCHEMA.createRecord(moduleTable.getKey()); + DBRecord record = TreeManager.MODULE_SCHEMA.createRecord(moduleTable.getKey()); record.setString(TreeManager.MODULE_NAME_COL, name); moduleTable.putRecord(record); // insert record for parent/child table - Record pcRec = TreeManager.PARENT_CHILD_SCHEMA.createRecord(parentChildTable.getKey()); + DBRecord pcRec = TreeManager.PARENT_CHILD_SCHEMA.createRecord(parentChildTable.getKey()); pcRec.setLongValue(TreeManager.PARENT_ID_COL, parentModuleID); pcRec.setLongValue(TreeManager.CHILD_ID_COL, record.getKey()); parentChildTable.putRecord(pcRec); @@ -64,7 +64,7 @@ class GroupDBAdapterV0 implements GroupDBAdapter { } @Override - public Record createFragment(long parentModuleID, String name) + public DBRecord createFragment(long parentModuleID, String name) throws IOException, DuplicateNameException { if (getFragmentRecord(name) != null || getModuleRecord(name) != null) { @@ -74,11 +74,11 @@ class GroupDBAdapterV0 implements GroupDBAdapter { if (key == 0) { key = 1; } - Record record = TreeManager.FRAGMENT_SCHEMA.createRecord(key); + DBRecord record = TreeManager.FRAGMENT_SCHEMA.createRecord(key); record.setString(TreeManager.FRAGMENT_NAME_COL, name); fragmentTable.putRecord(record); - Record pcRec = TreeManager.PARENT_CHILD_SCHEMA.createRecord(parentChildTable.getKey()); + DBRecord pcRec = TreeManager.PARENT_CHILD_SCHEMA.createRecord(parentChildTable.getKey()); pcRec.setLongValue(TreeManager.PARENT_ID_COL, parentModuleID); // negative value to indicate fragment pcRec.setLongValue(TreeManager.CHILD_ID_COL, -key); @@ -89,12 +89,12 @@ class GroupDBAdapterV0 implements GroupDBAdapter { } @Override - public Record getFragmentRecord(long key) throws IOException { + public DBRecord getFragmentRecord(long key) throws IOException { return fragmentTable.getRecord(key); } @Override - public Record getModuleRecord(long key) throws IOException { + public DBRecord getModuleRecord(long key) throws IOException { return moduleTable.getRecord(key); } @@ -103,11 +103,11 @@ class GroupDBAdapterV0 implements GroupDBAdapter { * @param childID negative value if child is a fragment */ @Override - public Record getParentChildRecord(long parentID, long childID) throws IOException { + public DBRecord getParentChildRecord(long parentID, long childID) throws IOException { Field[] keys = parentChildTable.findRecords(new LongField(parentID), TreeManager.PARENT_ID_COL); for (int i = 0; i < keys.length; i++) { - Record pcRec = parentChildTable.getRecord(keys[i]); + DBRecord pcRec = parentChildTable.getRecord(keys[i]); if (pcRec.getLongValue(TreeManager.CHILD_ID_COL) == childID) { return pcRec; } @@ -116,9 +116,9 @@ class GroupDBAdapterV0 implements GroupDBAdapter { } @Override - public Record addParentChildRecord(long moduleID, long childID) throws IOException { + public DBRecord addParentChildRecord(long moduleID, long childID) throws IOException { - Record pcRec = TreeManager.PARENT_CHILD_SCHEMA.createRecord(parentChildTable.getKey()); + DBRecord pcRec = TreeManager.PARENT_CHILD_SCHEMA.createRecord(parentChildTable.getKey()); pcRec.setLongValue(TreeManager.PARENT_ID_COL, moduleID); pcRec.setLongValue(TreeManager.CHILD_ID_COL, childID); parentChildTable.putRecord(pcRec); @@ -136,7 +136,7 @@ class GroupDBAdapterV0 implements GroupDBAdapter { } @Override - public Record getFragmentRecord(String name) throws IOException { + public DBRecord getFragmentRecord(String name) throws IOException { Field[] keys = fragmentTable.findRecords(new StringField(name), TreeManager.FRAGMENT_NAME_COL); if (keys.length == 0) { @@ -149,7 +149,7 @@ class GroupDBAdapterV0 implements GroupDBAdapter { } @Override - public Record getModuleRecord(String name) throws IOException { + public DBRecord getModuleRecord(String name) throws IOException { Field[] keys = moduleTable.findRecords(new StringField(name), TreeManager.MODULE_NAME_COL); if (keys.length == 0) { return null; @@ -161,28 +161,28 @@ class GroupDBAdapterV0 implements GroupDBAdapter { } @Override - public Record getParentChildRecord(long key) throws IOException { + public DBRecord getParentChildRecord(long key) throws IOException { return parentChildTable.getRecord(key); } @Override - public void updateModuleRecord(Record record) throws IOException { + public void updateModuleRecord(DBRecord record) throws IOException { moduleTable.putRecord(record); } @Override - public void updateFragmentRecord(Record record) throws IOException { + public void updateFragmentRecord(DBRecord record) throws IOException { fragmentTable.putRecord(record); } @Override - public void updateParentChildRecord(Record record) throws IOException { + public void updateParentChildRecord(DBRecord record) throws IOException { parentChildTable.putRecord(record); } @Override - public Record createRootModule(String name) throws IOException { - Record record = TreeManager.MODULE_SCHEMA.createRecord(0); + public DBRecord createRootModule(String name) throws IOException { + DBRecord record = TreeManager.MODULE_SCHEMA.createRecord(0); record.setString(TreeManager.MODULE_NAME_COL, name); moduleTable.putRecord(record); return record; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/ModuleDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/ModuleDB.java index ce73ae2dc7..f911d1f4e4 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/ModuleDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/ModuleDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.*; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; import ghidra.program.model.address.*; @@ -35,7 +35,7 @@ import ghidra.util.exception.*; */ class ModuleDB extends DatabaseObject implements ProgramModule { - private Record record; + private DBRecord record; private ModuleManager moduleMgr; private GroupDBAdapter adapter; private int childCount; // cache the count so we don't have to access @@ -49,7 +49,7 @@ class ModuleDB extends DatabaseObject implements ProgramModule { * @param cache ModuleDB cache * @param record database record for this module */ - ModuleDB(ModuleManager moduleMgr, DBObjectCache cache, Record record) { + ModuleDB(ModuleManager moduleMgr, DBObjectCache cache, DBRecord record) { super(cache, record.getKey()); this.moduleMgr = moduleMgr; this.record = record; @@ -61,7 +61,7 @@ class ModuleDB extends DatabaseObject implements ProgramModule { @Override protected boolean refresh() { try { - Record rec = adapter.getModuleRecord(key); + DBRecord rec = adapter.getModuleRecord(key); if (rec != null) { record = rec; childCount = 0; @@ -89,13 +89,13 @@ class ModuleDB extends DatabaseObject implements ProgramModule { FragmentDB frag = (FragmentDB) fragment; long fragID = frag.getKey(); // add a row to the parent/child table - Record parentChildRecord = adapter.getParentChildRecord(key, -fragID); + DBRecord parentChildRecord = adapter.getParentChildRecord(key, -fragID); if (parentChildRecord != null) { throw new DuplicateGroupException( frag.getName() + " already exists a child of " + getName()); } - Record pcRec = adapter.addParentChildRecord(key, -fragID); + DBRecord pcRec = adapter.addParentChildRecord(key, -fragID); updateChildCount(); updateOrderField(pcRec); moduleMgr.fragmentAdded(key, frag); @@ -118,7 +118,7 @@ class ModuleDB extends DatabaseObject implements ProgramModule { ModuleDB moduleDB = (ModuleDB) module; long moduleID = moduleDB.getKey(); - Record parentChildRecord = adapter.getParentChildRecord(key, moduleID); + DBRecord parentChildRecord = adapter.getParentChildRecord(key, moduleID); if (parentChildRecord != null) { throw new DuplicateGroupException( module.getName() + " already exists a child of " + getName()); @@ -128,7 +128,7 @@ class ModuleDB extends DatabaseObject implements ProgramModule { getName() + " is already a descendant of " + module.getName()); } - Record pcRec = adapter.addParentChildRecord(key, moduleID); + DBRecord pcRec = adapter.addParentChildRecord(key, moduleID); updateChildCount(); updateOrderField(pcRec); moduleMgr.moduleAdded(key, module); @@ -171,9 +171,9 @@ class ModuleDB extends DatabaseObject implements ProgramModule { lock.acquire(); try { checkDeleted(); - Record parentChildRecord = adapter.createFragment(key, fragmentName); + DBRecord parentChildRecord = adapter.createFragment(key, fragmentName); FragmentDB frag = moduleMgr.getFragmentDB(parentChildRecord); - Record pcRec = adapter.getParentChildRecord(key, -frag.getKey()); + DBRecord pcRec = adapter.getParentChildRecord(key, -frag.getKey()); updateChildCount(); updateOrderField(pcRec); moduleMgr.fragmentAdded(key, frag); @@ -194,9 +194,9 @@ class ModuleDB extends DatabaseObject implements ProgramModule { lock.acquire(); try { checkDeleted(); - Record moduleRecord = adapter.createModule(key, moduleName); + DBRecord moduleRecord = adapter.createModule(key, moduleName); ModuleDB moduleDB = moduleMgr.getModuleDB(moduleRecord); - Record pcRec = adapter.getParentChildRecord(key, moduleDB.key); + DBRecord pcRec = adapter.getParentChildRecord(key, moduleDB.key); updateChildCount(); updateOrderField(pcRec); moduleMgr.moduleAdded(key, moduleDB); @@ -216,10 +216,10 @@ class ModuleDB extends DatabaseObject implements ProgramModule { lock.acquire(); try { checkIsValid(); - List list = getParentChildRecords(); + List list = getParentChildRecords(); Group[] kids = new Group[list.size()]; for (int i = 0; i < list.size(); i++) { - Record rec = list.get(i); + DBRecord rec = list.get(i); long childID = rec.getLongValue(TreeManager.CHILD_ID_COL); if (childID < 0) { kids[i] = moduleMgr.getFragmentDB(-childID); @@ -269,8 +269,8 @@ class ModuleDB extends DatabaseObject implements ProgramModule { lock.acquire(); try { checkIsValid(); - Record fragmentRecord = adapter.getFragmentRecord(name); - Record pcRec = null; + DBRecord fragmentRecord = adapter.getFragmentRecord(name); + DBRecord pcRec = null; if (fragmentRecord != null) { long fragID = fragmentRecord.getKey(); pcRec = adapter.getParentChildRecord(key, -fragID); @@ -397,12 +397,12 @@ class ModuleDB extends DatabaseObject implements ProgramModule { boolean foundName = false; Group group = null; - List list = getParentChildRecords(); + List list = getParentChildRecords(); for (int i = 0; i < list.size(); i++) { - Record rec = list.get(i); + DBRecord rec = list.get(i); long childID = rec.getLongValue(TreeManager.CHILD_ID_COL); String childName = null; - Record childRec = null; + DBRecord childRec = null; if (childID < 0) { childRec = adapter.getFragmentRecord(-childID); childName = childRec.getString(TreeManager.FRAGMENT_NAME_COL); @@ -425,7 +425,7 @@ class ModuleDB extends DatabaseObject implements ProgramModule { if (!foundName) { throw new NotFoundException(name + " is not a child of " + getName()); } - Record pcRec = list.remove(currentIndex); + DBRecord pcRec = list.remove(currentIndex); list.add(index, pcRec); updateChildOrder(list); @@ -445,13 +445,13 @@ class ModuleDB extends DatabaseObject implements ProgramModule { lock.acquire(); try { checkDeleted(); - Record rec = adapter.getFragmentRecord(name); + DBRecord rec = adapter.getFragmentRecord(name); boolean deleteChild = false; if (rec != null) { // make sure that I am a parent of this child long childID = rec.getKey(); - Record pcRec = adapter.getParentChildRecord(key, -childID); + DBRecord pcRec = adapter.getParentChildRecord(key, -childID); if (pcRec == null) { // check for module record return removeModuleRecord(name); @@ -479,13 +479,13 @@ class ModuleDB extends DatabaseObject implements ProgramModule { private boolean removeModuleRecord(String name) throws IOException, NotEmptyException { - Record rec = adapter.getModuleRecord(name); + DBRecord rec = adapter.getModuleRecord(name); if (rec == null) { return false; } boolean deleteChild = false; long childID = rec.getKey(); - Record pcRec = adapter.getParentChildRecord(key, childID); + DBRecord pcRec = adapter.getParentChildRecord(key, childID); if (pcRec == null) { return false; } @@ -527,9 +527,9 @@ class ModuleDB extends DatabaseObject implements ProgramModule { } ModuleDB oldModuleDB = (ModuleDB) oldParent; - Record oldPcRec = adapter.getParentChildRecord(oldModuleDB.key, childID); + DBRecord oldPcRec = adapter.getParentChildRecord(oldModuleDB.key, childID); adapter.removeParentChildRecord(oldPcRec.getKey()); - Record newPcRec = adapter.addParentChildRecord(key, childID); + DBRecord newPcRec = adapter.addParentChildRecord(key, childID); ++childCount; updateOrderField(newPcRec); oldModuleDB.resetChildOrder(); @@ -628,7 +628,7 @@ class ModuleDB extends DatabaseObject implements ProgramModule { moduleMgr.getProgram().setName(name); return; } - Record r = adapter.getModuleRecord(name); + DBRecord r = adapter.getModuleRecord(name); if (r != null) { if (key != r.getKey()) { throw new DuplicateNameException(name + " already exists"); @@ -653,13 +653,13 @@ class ModuleDB extends DatabaseObject implements ProgramModule { //////////////////////////////////////////////////////////// - Record getRecord() { + DBRecord getRecord() { return record; } private boolean contains(long childID) { try { - Record rec = adapter.getParentChildRecord(key, childID); + DBRecord rec = adapter.getParentChildRecord(key, childID); return rec != null; } catch (IOException e) { @@ -668,21 +668,21 @@ class ModuleDB extends DatabaseObject implements ProgramModule { return false; } - private boolean removeChild(long childID, Record pcRec, boolean isFragment, boolean deleteChild) + private boolean removeChild(long childID, DBRecord pcRec, boolean isFragment, boolean deleteChild) throws IOException { adapter.removeParentChildRecord(pcRec.getKey()); String name = null; boolean success = true; if (isFragment) { - Record fragRec = adapter.getFragmentRecord(childID); + DBRecord fragRec = adapter.getFragmentRecord(childID); name = fragRec.getString(TreeManager.FRAGMENT_NAME_COL); if (deleteChild) { success = adapter.removeFragmentRecord(childID); } } else { - Record mrec = adapter.getModuleRecord(childID); + DBRecord mrec = adapter.getModuleRecord(childID); name = mrec.getString(TreeManager.MODULE_NAME_COL); if (deleteChild) { success = adapter.removeModuleRecord(childID); @@ -699,12 +699,12 @@ class ModuleDB extends DatabaseObject implements ProgramModule { /** * Get sorted list based on child order column. */ - private List getParentChildRecords() throws IOException { + private List getParentChildRecords() throws IOException { Field[] keys = adapter.getParentChildKeys(key, TreeManager.PARENT_ID_COL); - List list = new ArrayList(); - Comparator c = new ParentChildRecordComparator(); + List list = new ArrayList(); + Comparator c = new ParentChildRecordComparator(); for (int i = 0; i < keys.length; i++) { - Record rec = adapter.getParentChildRecord(keys[i].getLongValue()); + DBRecord rec = adapter.getParentChildRecord(keys[i].getLongValue()); int index = Collections.binarySearch(list, rec, c); if (index < 0) { index = -index - 1; @@ -717,21 +717,21 @@ class ModuleDB extends DatabaseObject implements ProgramModule { /** * Use the given list to get the child order and update each record. */ - private void updateChildOrder(List list) throws IOException { + private void updateChildOrder(List list) throws IOException { for (int i = 0; i < list.size(); i++) { - Record pcRec = list.get(i); + DBRecord pcRec = list.get(i); pcRec.setIntValue(TreeManager.ORDER_COL, i); adapter.updateParentChildRecord(pcRec); } } private void resetChildOrder() throws IOException { - List list = getParentChildRecords(); + List list = getParentChildRecords(); updateChildOrder(list); updateChildCount(); } - private void updateOrderField(Record pcRec) throws IOException { + private void updateOrderField(DBRecord pcRec) throws IOException { int orderValue = getNumChildren() - 1; if (orderValue < 0) { orderValue = 0; @@ -742,9 +742,9 @@ class ModuleDB extends DatabaseObject implements ProgramModule { private Address findFirstAddress(ModuleDB module) { try { - List list = module.getParentChildRecords(); + List list = module.getParentChildRecords(); for (int i = 0; i < list.size(); i++) { - Record rec = list.get(i); + DBRecord rec = list.get(i); long childID = rec.getLongValue(TreeManager.CHILD_ID_COL); if (childID < 0) { FragmentDB frag = moduleMgr.getFragmentDB(-childID); @@ -769,9 +769,9 @@ class ModuleDB extends DatabaseObject implements ProgramModule { private Address findLastAddress(ModuleDB module) { try { - List list = module.getParentChildRecords(); + List list = module.getParentChildRecords(); for (int i = list.size() - 1; i >= 0; i--) { - Record rec = list.get(i); + DBRecord rec = list.get(i); long childID = rec.getLongValue(TreeManager.CHILD_ID_COL); if (childID < 0) { FragmentDB frag = moduleMgr.getFragmentDB(-childID); @@ -799,9 +799,9 @@ class ModuleDB extends DatabaseObject implements ProgramModule { Address minAddr = addr; try { - List list = module.getParentChildRecords(); + List list = module.getParentChildRecords(); for (int i = 0; i < list.size(); i++) { - Record rec = list.get(i); + DBRecord rec = list.get(i); long childID = rec.getLongValue(TreeManager.CHILD_ID_COL); Address childMinAddr = null; if (childID < 0) { @@ -833,9 +833,9 @@ class ModuleDB extends DatabaseObject implements ProgramModule { Address maxAddr = addr; try { - List list = module.getParentChildRecords(); + List list = module.getParentChildRecords(); for (int i = 0; i < list.size(); i++) { - Record rec = list.get(i); + DBRecord rec = list.get(i); long childID = rec.getLongValue(TreeManager.CHILD_ID_COL); Address childMaxAddr = null; if (childID < 0) { @@ -875,10 +875,10 @@ class ModuleDB extends DatabaseObject implements ProgramModule { } } - private class ParentChildRecordComparator implements Comparator { + private class ParentChildRecordComparator implements Comparator { @Override - public int compare(Record r1, Record r2) { + public int compare(DBRecord r1, DBRecord r2) { int index1 = r1.getIntValue(TreeManager.ORDER_COL); int index2 = r2.getIntValue(TreeManager.ORDER_COL); if (index1 < index2) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/ModuleManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/ModuleManager.java index cb21367ac2..6f719a9236 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/ModuleManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/ModuleManager.java @@ -50,7 +50,7 @@ class ModuleManager { private HashSet nameSet; private AddressRangeMapDB fragMap; private ErrorHandler errHandler; - private Record record; + private DBRecord record; private Object versionTag; // gets updated everytime this module manager's cache is invalidated, // or a new memory block is added @@ -58,7 +58,7 @@ class ModuleManager { static long ROOT_MODULE_ID = 0; - ModuleManager(TreeManager treeMgr, Record rec, ProgramDB program, boolean createTables) + ModuleManager(TreeManager treeMgr, DBRecord rec, ProgramDB program, boolean createTables) throws IOException { this.treeMgr = treeMgr; @@ -180,7 +180,7 @@ class ModuleManager { * */ private void createRootModule() throws IOException { - Record rootRecord = adapter.createRootModule(program.getName()); + DBRecord rootRecord = adapter.createRootModule(program.getName()); ModuleDB root = new ModuleDB(this, moduleCache, rootRecord); nameSet.add(root.getName()); } @@ -197,7 +197,7 @@ class ModuleManager { lock.acquire(); try { ModuleDB root = getModuleDB(ROOT_MODULE_ID); - Record rec = root.getRecord(); + DBRecord rec = root.getRecord(); rec.setString(TreeManager.MODULE_NAME_COL, newName); adapter.updateModuleRecord(rec); treeMgr.updateTreeRecord(record); @@ -217,12 +217,12 @@ class ModuleManager { } ProgramModule getModule(String name) throws IOException { - Record moduleRecord = adapter.getModuleRecord(name); + DBRecord moduleRecord = adapter.getModuleRecord(name); return getModuleDB(moduleRecord); } ProgramFragment getFragment(String name) throws IOException { - Record fragmentRecord = adapter.getFragmentRecord(name); + DBRecord fragmentRecord = adapter.getFragmentRecord(name); return getFragmentDB(fragmentRecord); } @@ -466,7 +466,7 @@ class ModuleManager { return false; } for (Field key : keys) { - Record parentChildRecord = adapter.getParentChildRecord(key.getLongValue()); + DBRecord parentChildRecord = adapter.getParentChildRecord(key.getLongValue()); long childID = parentChildRecord.getLongValue(TreeManager.CHILD_ID_COL); if (childID == id) { @@ -479,7 +479,7 @@ class ModuleManager { return false; } - FragmentDB getFragmentDB(Record fragmentRecord) { + FragmentDB getFragmentDB(DBRecord fragmentRecord) { lock.acquire(); try { if (fragmentRecord == null) { @@ -504,7 +504,7 @@ class ModuleManager { if (frag != null) { return frag; } - Record fragmentRecord = adapter.getFragmentRecord(fragID); + DBRecord fragmentRecord = adapter.getFragmentRecord(fragID); return createFragmentDB(fragmentRecord); } @@ -513,7 +513,7 @@ class ModuleManager { } } - ModuleDB getModuleDB(Record moduleRecord) { + ModuleDB getModuleDB(DBRecord moduleRecord) { lock.acquire(); try { if (moduleRecord == null) { @@ -538,7 +538,7 @@ class ModuleManager { if (moduleDB != null) { return moduleDB; } - Record moduleRecord = adapter.getModuleRecord(moduleID); + DBRecord moduleRecord = adapter.getModuleRecord(moduleID); return createModuleDB(moduleRecord); } @@ -648,8 +648,8 @@ class ModuleManager { Field[] keys = adapter.getParentChildKeys(childID, TreeManager.CHILD_ID_COL); String[] names = new String[keys.length]; for (int i = 0; i < keys.length; i++) { - Record parentChildRecord = adapter.getParentChildRecord(keys[i].getLongValue()); - Record mrec = adapter.getModuleRecord( + DBRecord parentChildRecord = adapter.getParentChildRecord(keys[i].getLongValue()); + DBRecord mrec = adapter.getModuleRecord( parentChildRecord.getLongValue(TreeManager.PARENT_ID_COL)); names[i] = mrec.getString(TreeManager.MODULE_NAME_COL); } @@ -671,8 +671,8 @@ class ModuleManager { Field[] keys = adapter.getParentChildKeys(childID, TreeManager.CHILD_ID_COL); ProgramModule[] modules = new ProgramModule[keys.length]; for (int i = 0; i < keys.length; i++) { - Record parentChildRecord = adapter.getParentChildRecord(keys[i].getLongValue()); - Record mrec = adapter.getModuleRecord( + DBRecord parentChildRecord = adapter.getParentChildRecord(keys[i].getLongValue()); + DBRecord mrec = adapter.getModuleRecord( parentChildRecord.getLongValue(TreeManager.PARENT_ID_COL)); modules[i] = getModuleDB(mrec); } @@ -721,7 +721,7 @@ class ModuleManager { return TreeManager.getParentChildTableName(treeID); } - private ModuleDB createModuleDB(Record moduleRecord) { + private ModuleDB createModuleDB(DBRecord moduleRecord) { if (moduleRecord != null) { ModuleDB moduleDB; moduleDB = new ModuleDB(this, moduleCache, moduleRecord); @@ -731,7 +731,7 @@ class ModuleManager { return null; } - private FragmentDB createFragmentDB(Record fragmentRecord) { + private FragmentDB createFragmentDB(DBRecord fragmentRecord) { if (fragmentRecord != null) { FragmentDB f = new FragmentDB(this, fragCache, fragmentRecord, getFragmentAddressSet(fragmentRecord.getKey())); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeDBAdapter.java index 5ac0e2b65b..8524bf7a42 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeDBAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,7 +17,7 @@ package ghidra.program.database.module; import java.io.IOException; -import db.Record; +import db.DBRecord; import db.RecordIterator; /** @@ -36,7 +35,7 @@ interface TreeDBAdapter { * @return record for the tree * @throws IOException if there was a problem accessing the database */ - Record createRecord(String name) throws IOException; + DBRecord createRecord(String name) throws IOException; /** * Delete the record for the tree and all associated tables. @@ -50,13 +49,13 @@ interface TreeDBAdapter { * Get the record for the given tree ID. * @throws IOException if there was a problem accessing the database */ - Record getRecord(long treeID) throws IOException; + DBRecord getRecord(long treeID) throws IOException; /** * Get the record for the tree with the given name. * @throws IOException if there was a problem accessing the database */ - Record getRecord(String name) throws IOException; + DBRecord getRecord(String name) throws IOException; /** * Get an iterator over all tree records. @@ -68,5 +67,5 @@ interface TreeDBAdapter { * Update the tree table with the given record. * @throws IOException if there was a problem accessing the database */ - void updateRecord(Record record) throws IOException; + void updateRecord(DBRecord record) throws IOException; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeDBAdapterV0.java index 4533f0e41a..67e79bcf0f 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeDBAdapterV0.java @@ -50,8 +50,8 @@ class TreeDBAdapterV0 implements TreeDBAdapter { } @Override - public Record createRecord(String name) throws IOException { - Record record = TreeManager.TREE_SCHEMA.createRecord(treeTable.getKey()); + public DBRecord createRecord(String name) throws IOException { + DBRecord record = TreeManager.TREE_SCHEMA.createRecord(treeTable.getKey()); record.setString(TreeManager.TREE_NAME_COL, name); record.setLongValue(TreeManager.MODIFICATION_NUM_COL, 0); treeTable.putRecord(record); @@ -71,12 +71,12 @@ class TreeDBAdapterV0 implements TreeDBAdapter { } @Override - public Record getRecord(long treeID) throws IOException { + public DBRecord getRecord(long treeID) throws IOException { return treeTable.getRecord(treeID); } @Override - public Record getRecord(String name) throws IOException { + public DBRecord getRecord(String name) throws IOException { Field[] keys = treeTable.findRecords(new StringField(name), TreeManager.TREE_NAME_COL); if (keys.length == 0) { return null; @@ -93,7 +93,7 @@ class TreeDBAdapterV0 implements TreeDBAdapter { } @Override - public void updateRecord(Record record) throws IOException { + public void updateRecord(DBRecord record) throws IOException { treeTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeManager.java index 97159a8b8b..4dc0269edf 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/module/TreeManager.java @@ -180,7 +180,7 @@ public class TreeManager implements ManagerDB { private void addressUpgrade(TaskMonitor monitor) throws CancelledException, IOException { RecordIterator iter = adapter.getRecords(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); long key = rec.getKey(); String treeName = rec.getString(TREE_NAME_COL); ModuleManager.addressUpgrade(this, key, treeName, addrMap, monitor); @@ -216,7 +216,7 @@ public class TreeManager implements ManagerDB { throw new DuplicateNameException( "Root module named " + treeName + " already exists"); } - Record record = adapter.createRecord(treeName); + DBRecord record = adapter.createRecord(treeName); ModuleManager m = new ModuleManager(this, record, program, true); treeMap.put(treeName, m); addMemoryBlocks(m); @@ -267,7 +267,7 @@ public class TreeManager implements ManagerDB { try { RecordIterator iter = adapter.getRecords(); while (iter.hasNext()) { - Record record = iter.next(); + DBRecord record = iter.next(); String name = record.getString(TREE_NAME_COL); return getRootModule(name); } @@ -289,7 +289,7 @@ public class TreeManager implements ManagerDB { int index = 0; while (iter.hasNext()) { - Record record = iter.next(); + DBRecord record = iter.next(); names[index] = record.getString(TREE_NAME_COL); ++index; } @@ -340,7 +340,7 @@ public class TreeManager implements ManagerDB { lock.acquire(); try { if (treeMap.containsKey(treeName)) { - Record rec = adapter.getRecord(treeName); + DBRecord rec = adapter.getRecord(treeName); adapter.deleteRecord(rec.getKey()); ModuleManager mm = treeMap.remove(treeName); mm.dispose(); @@ -530,7 +530,7 @@ public class TreeManager implements ManagerDB { String getTreeName(long treeID) { try { - Record record = adapter.getRecord(treeID); + DBRecord record = adapter.getRecord(treeID); if (record != null) { return record.getString(TREE_NAME_COL); } @@ -590,7 +590,7 @@ public class TreeManager implements ManagerDB { RecordIterator iter = adapter.getRecords(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); long key = rec.getKey(); String treeName = rec.getString(TREE_NAME_COL); long modNumber = rec.getLongValue(MODIFICATION_NUM_COL); @@ -646,7 +646,7 @@ public class TreeManager implements ManagerDB { } } - void updateTreeRecord(Record record) { + void updateTreeRecord(DBRecord record) { updateTreeRecord(record, true); } @@ -656,7 +656,7 @@ public class TreeManager implements ManagerDB { * @param updateModificationNumber true means to update the * modification number */ - void updateTreeRecord(Record record, boolean updateModificationNumber) { + void updateTreeRecord(DBRecord record, boolean updateModificationNumber) { try { if (updateModificationNumber) { record.setLongValue(MODIFICATION_NUM_COL, @@ -669,7 +669,7 @@ public class TreeManager implements ManagerDB { } } - Record getTreeRecord(long treeID) { + DBRecord getTreeRecord(long treeID) { try { return adapter.getRecord(treeID); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapter.java index 07793802ad..900f70b5d7 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -72,7 +71,7 @@ abstract class OldFunctionDBAdapter { * @param functionKey * @return Record */ - abstract Record getFunctionRecord(long functionKey) throws IOException; + abstract DBRecord getFunctionRecord(long functionKey) throws IOException; /** * Iterate over all function records. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapterV0.java index 917733f5aa..9737493968 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -71,20 +70,20 @@ class OldFunctionDBAdapterV0 extends OldFunctionDBAdapter { * @see ghidra.program.database.function.FunctionDBAdapter#getFunctionRecord(long) */ @Override - public Record getFunctionRecord(long functionKey) throws IOException { - Record oldRecord = table.getRecord(functionKey); + public DBRecord getFunctionRecord(long functionKey) throws IOException { + DBRecord oldRecord = table.getRecord(functionKey); return translateRecord(oldRecord); } /** - * @see ghidra.program.database.function.FunctionDBAdapter#translateRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.function.FunctionDBAdapter#translateRecord(ghidra.framework.store.db.DBRecord) */ - public Record translateRecord(Record oldRecord) { + public DBRecord translateRecord(DBRecord oldRecord) { if (oldRecord == null) { return null; } long entryPointKey = oldRecord.getKey(); - Record newRecord = OldFunctionDBAdapter.FUNCTIONS_SCHEMA.createRecord(entryPointKey); + DBRecord newRecord = OldFunctionDBAdapter.FUNCTIONS_SCHEMA.createRecord(entryPointKey); newRecord.setLongValue(OldFunctionDBAdapter.RETURN_DATA_TYPE_ID_COL, oldRecord.getLongValue(V0_RETURN_DATA_TYPE_ID_COL)); newRecord.setIntValue(OldFunctionDBAdapter.STACK_DEPTH_COL, @@ -126,17 +125,17 @@ class OldFunctionDBAdapterV0 extends OldFunctionDBAdapter { return it.hasPrevious(); } - public Record next() throws IOException { - Record rec = it.next(); + public DBRecord next() throws IOException { + DBRecord rec = it.next(); return translate(rec); } - public Record previous() throws IOException { - Record rec = it.previous(); + public DBRecord previous() throws IOException { + DBRecord rec = it.previous(); return translate(rec); } - private Record translate(Record oldRecord) { + private DBRecord translate(DBRecord oldRecord) { return translateRecord(oldRecord); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapterV1.java index 2d8d26fca4..ec59159d57 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDBAdapterV1.java @@ -64,7 +64,7 @@ class OldFunctionDBAdapterV1 extends OldFunctionDBAdapter { * @see ghidra.program.database.function.FunctionDBAdapter#getFunctionRecord(long) */ @Override - public Record getFunctionRecord(long functionKey) throws IOException { + public DBRecord getFunctionRecord(long functionKey) throws IOException { return table.getRecord(functionKey); } @@ -77,9 +77,9 @@ class OldFunctionDBAdapterV1 extends OldFunctionDBAdapter { } /** - * @see ghidra.program.database.function.FunctionDBAdapter#translateRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.function.FunctionDBAdapter#translateRecord(ghidra.framework.store.db.DBRecord) */ - public Record translateRecord(Record oldRecord) { + public DBRecord translateRecord(DBRecord oldRecord) { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDataDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDataDB.java index ae8ebd2234..69a0094789 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDataDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionDataDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.*; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.program.database.ProgramDB; import ghidra.program.database.map.AddressMap; import ghidra.program.model.address.Address; @@ -43,14 +43,14 @@ class OldFunctionDataDB { private OldFunctionDBAdapter functionAdapter; private OldRegisterVariableDBAdapter registerAdapter; - private Record functionRecord; + private DBRecord functionRecord; private Address entryPoint; private AddressSetView body; private OldStackFrameDB frame; private List regParams; - OldFunctionDataDB(OldFunctionManager functionManager, AddressMap addrMap, Record functionRecord, + OldFunctionDataDB(OldFunctionManager functionManager, AddressMap addrMap, DBRecord functionRecord, AddressSetView body) { this.functionManager = functionManager; @@ -202,7 +202,7 @@ class OldFunctionDataDB { try { Field[] keys = registerAdapter.getRegisterVariableKeys(functionRecord.getKey()); for (int i = 0; i < keys.length; i++) { - Record varRec = registerAdapter.getRegisterVariableRecord(keys[i].getLongValue()); + DBRecord varRec = registerAdapter.getRegisterVariableRecord(keys[i].getLongValue()); regParams.add(getRegisterParameter(varRec, i)); } // TODO Does register variable list need to be sorted? @@ -212,7 +212,7 @@ class OldFunctionDataDB { } } - private Parameter getRegisterParameter(Record record, int ordinal) { + private Parameter getRegisterParameter(DBRecord record, int ordinal) { String name = record.getString(OldRegisterVariableDBAdapter.REG_VAR_NAME_COL); long dataTypeId = record.getLongValue(OldRegisterVariableDBAdapter.REG_VAR_DATA_TYPE_ID_COL); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionManager.java index 0fd38814c3..b0a7c24de1 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldFunctionManager.java @@ -261,7 +261,7 @@ public class OldFunctionManager implements ErrorHandler { return functionMap.getBody(functionKey); } - synchronized OldFunctionDataDB getFunction(Record rec) { + synchronized OldFunctionDataDB getFunction(DBRecord rec) { return new OldFunctionDataDB(this, addrMap, rec, null); } @@ -314,7 +314,7 @@ public class OldFunctionManager implements ErrorHandler { } synchronized (OldFunctionManager.this) { try { - Record rec = recordIter.next(); + DBRecord rec = recordIter.next(); if (rec != null) { func = getFunction(rec); hasNext = true; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldRegisterVariableDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldRegisterVariableDBAdapter.java index 090330f5d7..1c12519f29 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldRegisterVariableDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldRegisterVariableDBAdapter.java @@ -53,7 +53,7 @@ abstract class OldRegisterVariableDBAdapter { * @param key * @return Record */ - abstract Record getRegisterVariableRecord(long key) throws IOException; + abstract DBRecord getRegisterVariableRecord(long key) throws IOException; /** * Get all register variable keys which correspond to a function. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldRegisterVariableDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldRegisterVariableDBAdapterV0.java index c340ac848e..4d7c9cfb5c 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldRegisterVariableDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldRegisterVariableDBAdapterV0.java @@ -51,7 +51,7 @@ class OldRegisterVariableDBAdapterV0 extends OldRegisterVariableDBAdapter { } @Override - public Record getRegisterVariableRecord(long key) throws IOException { + public DBRecord getRegisterVariableRecord(long key) throws IOException { return table.getRecord(key); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackFrameDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackFrameDB.java index b40c6991f4..ed7c7c35a9 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackFrameDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackFrameDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.*; import db.Field; -import db.Record; +import db.DBRecord; import ghidra.program.model.address.AddressOutOfBoundsException; import ghidra.program.model.data.DataType; import ghidra.program.model.listing.*; @@ -90,7 +90,7 @@ class OldStackFrameDB implements StackFrame { variables = new ArrayList(); Field[] keys = adapter.getStackVariableKeys(function.getKey()); for (int i = 0; i < keys.length; i++) { - Record varRec = adapter.getStackVariableRecord(keys[i].getLongValue()); + DBRecord varRec = adapter.getStackVariableRecord(keys[i].getLongValue()); variables.add(getStackVariable(varRec)); } Collections.sort(variables, StackVariableComparator.get()); @@ -100,7 +100,7 @@ class OldStackFrameDB implements StackFrame { } } - private Variable getStackVariable(Record record) { + private Variable getStackVariable(DBRecord record) { int offset = record.getIntValue(OldStackVariableDBAdapter.STACK_VAR_OFFSET_COL); long dataTypeId = record.getLongValue(OldStackVariableDBAdapter.STACK_VAR_DATA_TYPE_ID_COL); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapter.java index 7b382f33d6..d000e4e151 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapter.java @@ -66,7 +66,7 @@ abstract class OldStackVariableDBAdapter { * @return Record record or null * @throws IOException if IO error occurs */ - abstract Record getStackVariableRecord(long key) throws IOException; + abstract DBRecord getStackVariableRecord(long key) throws IOException; /** * Get all stack variable keys which correspond to a function. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapterV0.java index e44a918a80..228baad5ed 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapterV0.java @@ -58,7 +58,7 @@ class OldStackVariableDBAdapterV0 extends OldStackVariableDBAdapter { } @Override - public Record getStackVariableRecord(long key) throws IOException { + public DBRecord getStackVariableRecord(long key) throws IOException { return translateRecord(table.getRecord(key)); } @@ -67,11 +67,11 @@ class OldStackVariableDBAdapterV0 extends OldStackVariableDBAdapter { return table.findRecords(new LongField(functionKey), V0_STACK_VAR_FUNCTION_KEY_COL); } - private Record translateRecord(Record oldRec) { + private DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = OldStackVariableDBAdapter.STACK_VARS_SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = OldStackVariableDBAdapter.STACK_VARS_SCHEMA.createRecord(oldRec.getKey()); rec.setLongValue(OldStackVariableDBAdapter.STACK_VAR_FUNCTION_KEY_COL, oldRec.getLongValue(V0_STACK_VAR_FUNCTION_KEY_COL)); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapterV1.java index 5d8e0dd74e..536275b064 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/oldfunction/OldStackVariableDBAdapterV1.java @@ -64,7 +64,7 @@ class OldStackVariableDBAdapterV1 extends OldStackVariableDBAdapter { } @Override - public Record getStackVariableRecord(long key) throws IOException { + public DBRecord getStackVariableRecord(long key) throws IOException { return table.getRecord(key); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/DBPropertyMapManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/DBPropertyMapManager.java index 0157a3ba7d..22c1b01491 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/DBPropertyMapManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/DBPropertyMapManager.java @@ -144,7 +144,7 @@ public class DBPropertyMapManager implements PropertyMapManager, ManagerDB { VersionException ve = null; RecordIterator iter = propertiesDBAdapter.getRecords(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); String name = rec.getKeyField().getString(); byte propertyType = rec.getByteValue(PROPERTY_TYPE_COL); PropertyMap pm = null; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/GenericSaveable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/GenericSaveable.java index 008064e349..e725eb2a03 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/GenericSaveable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/GenericSaveable.java @@ -29,7 +29,7 @@ import ghidra.util.Saveable; */ public class GenericSaveable implements Saveable { - final Record record; + final DBRecord record; final Schema schema; final Class[] fieldClasses = new Class[0]; @@ -39,7 +39,7 @@ public class GenericSaveable implements Saveable { * @param record the saveable's record. * @param schema the saveable's database table's schema. */ - GenericSaveable(Record record, Schema schema) { + GenericSaveable(DBRecord record, Schema schema) { this.record = record; this.schema = schema; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/IntPropertyMapDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/IntPropertyMapDB.java index cc54bf74b7..f93814e2a4 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/IntPropertyMapDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/IntPropertyMapDB.java @@ -70,13 +70,13 @@ public class IntPropertyMapDB extends PropertyMapDB implements IntPropertyMap { else { oldValue = (Integer) cache.get(key); if (oldValue == null) { - Record rec = propertyTable.getRecord(key); + DBRecord rec = propertyTable.getRecord(key); if (rec != null) { oldValue = new Integer(rec.getIntValue(PROPERTY_VALUE_COL)); } } } - Record rec = schema.createRecord(key); + DBRecord rec = schema.createRecord(key); rec.setIntValue(PROPERTY_VALUE_COL, value); propertyTable.putRecord(rec); @@ -112,7 +112,7 @@ public class IntPropertyMapDB extends PropertyMapDB implements IntPropertyMap { return ((Integer) obj).intValue(); } - Record rec = propertyTable.getRecord(key); + DBRecord rec = propertyTable.getRecord(key); if (rec == null) { throw NO_VALUE_EXCEPTION; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/LongPropertyMapDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/LongPropertyMapDB.java index bddf4a8566..99a3931afe 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/LongPropertyMapDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/LongPropertyMapDB.java @@ -68,13 +68,13 @@ public class LongPropertyMapDB extends PropertyMapDB implements LongPropertyMap else { oldValue = (Long) cache.get(key); if (oldValue == null) { - Record rec = propertyTable.getRecord(key); + DBRecord rec = propertyTable.getRecord(key); if (rec != null) { oldValue = new Long(rec.getLongValue(PROPERTY_VALUE_COL)); } } } - Record rec = schema.createRecord(key); + DBRecord rec = schema.createRecord(key); rec.setLongValue(PROPERTY_VALUE_COL, value); propertyTable.putRecord(rec); cache.put(key, new Long(value)); @@ -109,7 +109,7 @@ public class LongPropertyMapDB extends PropertyMapDB implements LongPropertyMap return ((Long) obj).longValue(); } - Record rec = propertyTable.getRecord(key); + DBRecord rec = propertyTable.getRecord(key); if (rec == null) { throw NO_VALUE_EXCEPTION; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/ObjectPropertyMapDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/ObjectPropertyMapDB.java index f3d6476491..6daa43a4ca 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/ObjectPropertyMapDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/ObjectPropertyMapDB.java @@ -191,7 +191,7 @@ public class ObjectPropertyMapDB extends PropertyMapDB implements ObjectProperty if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); ObjectStorageAdapterDB oldObjStorage = new ObjectStorageAdapterDB(rec); ObjectStorageAdapterDB newObjStorage = new ObjectStorageAdapterDB(); if (!tokenInstance.upgrade(oldObjStorage, schema.getVersion(), newObjStorage)) { @@ -204,7 +204,7 @@ public class ObjectPropertyMapDB extends PropertyMapDB implements ObjectProperty tempTable = tmpDb.createTable(getTableName(), newSchema); } Address addr = oldAddressMap.decodeAddress(rec.getKey()); - Record newRecord = newSchema.createRecord(addrMap.getKey(addr, true)); + DBRecord newRecord = newSchema.createRecord(addrMap.getKey(addr, true)); newObjStorage.save(newRecord); if (tempTable != null) { tempTable.putRecord(newRecord); @@ -231,7 +231,7 @@ public class ObjectPropertyMapDB extends PropertyMapDB implements ObjectProperty if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); propertyTable.putRecord(rec); monitor.setProgress(++count); } @@ -258,7 +258,7 @@ public class ObjectPropertyMapDB extends PropertyMapDB implements ObjectProperty String tableName = getTableName(); Schema s; - Record rec; + DBRecord rec; if (saveableObjectClass != GenericSaveable.class) { ObjectStorageAdapterDB objStorage = new ObjectStorageAdapterDB(); value.save(objStorage); @@ -270,7 +270,7 @@ public class ObjectPropertyMapDB extends PropertyMapDB implements ObjectProperty } else { // GenericSaveable GenericSaveable genericSaveable = ((GenericSaveable) value); - Record originalRec = genericSaveable.record; + DBRecord originalRec = genericSaveable.record; s = genericSaveable.schema; checkSchema(s); createPropertyTable(tableName, s); @@ -339,7 +339,7 @@ public class ObjectPropertyMapDB extends PropertyMapDB implements ObjectProperty return obj; } - Record rec = propertyTable.getRecord(key); + DBRecord rec = propertyTable.getRecord(key); if (rec == null) { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/PropertiesDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/PropertiesDBAdapterV0.java index c22d192ff9..0bb438e8bb 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/PropertiesDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/PropertiesDBAdapterV0.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -45,7 +44,7 @@ class PropertiesDBAdapterV0 implements PropertiesDBAdapter { * @see ghidra.program.database.properties.PropertiesDBAdapter#createRecord(java.lang.String, byte, java.lang.String) */ public void putRecord(String propertyName, byte type, String objClassName) throws IOException { - Record rec = + DBRecord rec = DBPropertyMapManager.PROPERTIES_SCHEMA.createRecord(new StringField(propertyName)); rec.setByteValue(DBPropertyMapManager.PROPERTY_TYPE_COL, type); if (type == DBPropertyMapManager.OBJECT_PROPERTY_TYPE) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/PropertyMapDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/PropertyMapDB.java index b12735f93a..aaf6bff622 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/PropertyMapDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/PropertyMapDB.java @@ -124,7 +124,7 @@ public abstract class PropertyMapDB implements PropertyMap { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); if (tempTable == null) { // Create table on first entry upgrade tempTable = tmpDb.createTable(getTableName(), schema); @@ -151,7 +151,7 @@ public abstract class PropertyMapDB implements PropertyMap { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); propertyTable.putRecord(rec); monitor.setProgress(++count); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/StringPropertyMapDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/StringPropertyMapDB.java index 5975fa017e..e4169dd6a0 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/StringPropertyMapDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/StringPropertyMapDB.java @@ -70,13 +70,13 @@ public class StringPropertyMapDB extends PropertyMapDB implements StringProperty else { oldValue = (String) cache.get(key); if (oldValue == null) { - Record rec = propertyTable.getRecord(key); + DBRecord rec = propertyTable.getRecord(key); if (rec != null) { oldValue = rec.getString(PROPERTY_VALUE_COL); } } } - Record rec = schema.createRecord(key); + DBRecord rec = schema.createRecord(key); rec.setString(PROPERTY_VALUE_COL, value); propertyTable.putRecord(rec); cache.put(key, value); @@ -113,7 +113,7 @@ public class StringPropertyMapDB extends PropertyMapDB implements StringProperty return str; } - Record rec = propertyTable.getRecord(key); + DBRecord rec = propertyTable.getRecord(key); if (rec == null) { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/VoidPropertyMapDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/VoidPropertyMapDB.java index 52e17289ff..56efea11d6 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/VoidPropertyMapDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/properties/VoidPropertyMapDB.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,7 +26,7 @@ import ghidra.util.task.TaskMonitor; import java.io.IOException; import db.DBHandle; -import db.Record; +import db.DBRecord; import db.util.ErrorHandler; /** @@ -71,7 +70,7 @@ public class VoidPropertyMapDB extends PropertyMapDB implements VoidPropertyMap if (propertyTable == null) { createTable(null); } - Record rec = schema.createRecord(key); + DBRecord rec = schema.createRecord(key); propertyTable.putRecord(rec); cache.put(key, VOID_OBJECT); changeMgr.setPropertyChanged(name, addr, oldValue, new Boolean(true)); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/BigRefListV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/BigRefListV0.java index 0853a06646..e4b5b67c75 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/BigRefListV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/BigRefListV0.java @@ -55,7 +55,7 @@ class BigRefListV0 extends RefList { private byte refLevel = -1; private Table table; - private Record record; + private DBRecord record; /** * Construct new empty reference list @@ -84,7 +84,7 @@ class BigRefListV0 extends RefList { * @param cache RefList object cache * @param isFrom true for from-adapter use, false for to-adapter use */ - BigRefListV0(Record rec, RecordAdapter adapter, AddressMap addrMap, ProgramDB program, + BigRefListV0(DBRecord rec, RecordAdapter adapter, AddressMap addrMap, ProgramDB program, DBObjectCache cache, boolean isFrom) throws IOException { super(rec.getKey(), addrMap.decodeAddress(rec.getKey()), adapter, addrMap, program, cache, isFrom); @@ -182,7 +182,7 @@ class BigRefListV0 extends RefList { if (id < 0) { id = 0; } - Record refRec = BIG_REFS_SCHEMA.createRecord(id); + DBRecord refRec = BIG_REFS_SCHEMA.createRecord(id); refRec.setLongValue(ADDRESS_COL, addrMap.getKey(isFrom ? toAddr : fromAddr, true)); RefListFlagsV0 flags = new RefListFlagsV0(isPrimary, isOffset, symbolID >= 0, isShifted, source); @@ -194,7 +194,7 @@ class BigRefListV0 extends RefList { table.putRecord(refRec); } - private ReferenceDB getRef(Record rec) { + private ReferenceDB getRef(DBRecord rec) { long symbolID = -1; long addr = rec.getLongValue(ADDRESS_COL); @@ -272,7 +272,7 @@ class BigRefListV0 extends RefList { } RecordIterator iterator = table.iterator(); while (iterator.hasNext()) { - Record rec = iterator.next(); + DBRecord rec = iterator.next(); if (rec.getByteValue(OPINDEX_COL) != opIndex) { continue; } @@ -288,7 +288,7 @@ class BigRefListV0 extends RefList { synchronized ReferenceDB getRef(Address refAddress, int opIndex) throws IOException { LongField addrField = new LongField(addrMap.getKey(refAddress, false)); for (Field id : table.findRecords(addrField, ADDRESS_COL)) { - Record rec = table.getRecord(id); + DBRecord rec = table.getRecord(id); if (rec.getByteValue(OPINDEX_COL) == (byte) opIndex) { return getRef(rec); } @@ -325,7 +325,7 @@ class BigRefListV0 extends RefList { synchronized boolean removeRef(Address deleteAddr, int opIndex) throws IOException { LongField addrField = new LongField(addrMap.getKey(deleteAddr, false)); for (Field id : table.findRecords(addrField, ADDRESS_COL)) { - Record rec = table.getRecord(id); + DBRecord rec = table.getRecord(id); if (rec.getByteValue(OPINDEX_COL) == (byte) opIndex) { table.deleteRecord(id); if (table.getRecordCount() == 0) { @@ -369,7 +369,7 @@ class BigRefListV0 extends RefList { Address changeAddr = isFrom ? ref.getToAddress() : ref.getFromAddress(); LongField addrField = new LongField(addrMap.getKey(changeAddr, false)); for (Field id : table.findRecords(addrField, ADDRESS_COL)) { - Record rec = table.getRecord(id); + DBRecord rec = table.getRecord(id); if (rec.getByteValue(OPINDEX_COL) == (byte) opIndex) { RefListFlagsV0 flags = new RefListFlagsV0(rec.getByteValue(FLAGS_COL)); if (flags.isPrimary() == isPrimary) { @@ -391,7 +391,7 @@ class BigRefListV0 extends RefList { Address changeAddr = isFrom ? ref.getToAddress() : ref.getFromAddress(); LongField addrField = new LongField(addrMap.getKey(changeAddr, false)); for (Field id : table.findRecords(addrField, ADDRESS_COL)) { - Record rec = table.getRecord(id); + DBRecord rec = table.getRecord(id); if (rec.getByteValue(OPINDEX_COL) == (byte) opIndex) { RefListFlagsV0 flags = new RefListFlagsV0(rec.getByteValue(FLAGS_COL)); if (flags.hasSymbolID() == hasSymbolID && @@ -417,7 +417,7 @@ class BigRefListV0 extends RefList { } LongField addrField = new LongField(addrMap.getKey(changeAddr, false)); for (Field id : table.findRecords(addrField, ADDRESS_COL)) { - Record rec = table.getRecord(id); + DBRecord rec = table.getRecord(id); if (rec.getByteValue(OPINDEX_COL) == (byte) opIndex) { if (refType.getValue() == rec.getByteValue(TYPE_COL)) { return; // change not required diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/FromAdapterSharedTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/FromAdapterSharedTable.java index 69b2045969..fb55f7db87 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/FromAdapterSharedTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/FromAdapterSharedTable.java @@ -86,7 +86,7 @@ class FromAdapterSharedTable extends FromAdapter { RecordIterator iter = table.indexIterator(OLD_FROM_ADDR_COL, fromField, fromField, true); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); boolean isUser = rec.getBooleanValue(OLD_USER_DEFINED_COL); SourceType source = isUser ? SourceType.USER_DEFINED : SourceType.DEFAULT; @@ -111,7 +111,7 @@ class FromAdapterSharedTable extends FromAdapter { } @Override - public Record createRecord(long key, int numRefs, byte refLevel, byte[] refData) + public DBRecord createRecord(long key, int numRefs, byte refLevel, byte[] refData) throws IOException { throw new UnsupportedOperationException(); } @@ -122,12 +122,12 @@ class FromAdapterSharedTable extends FromAdapter { } @Override - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { return table.getRecord(key); } @Override - public void putRecord(Record record) throws IOException { + public void putRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/FromAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/FromAdapterV0.java index 13fcd14aab..f1597d3dbc 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/FromAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/FromAdapterV0.java @@ -58,7 +58,7 @@ class FromAdapterV0 extends FromAdapter { @Override public RefList getRefList(ProgramDB program, DBObjectCache cache, Address from, long fromAddr) throws IOException { - Record rec = table.getRecord(fromAddr); + DBRecord rec = table.getRecord(fromAddr); if (rec != null) { return new RefListV0(rec, this, addrMap, program, cache, true); } @@ -71,9 +71,9 @@ class FromAdapterV0 extends FromAdapter { } @Override - public Record createRecord(long key, int numRefs, byte refLevel, byte[] refData) + public DBRecord createRecord(long key, int numRefs, byte refLevel, byte[] refData) throws IOException { - Record rec = FROM_REFS_SCHEMA.createRecord(key); + DBRecord rec = FROM_REFS_SCHEMA.createRecord(key); rec.setIntValue(REF_COUNT_COL, numRefs); rec.setBinaryData(REF_DATA_COL, refData); table.putRecord(rec); @@ -81,12 +81,12 @@ class FromAdapterV0 extends FromAdapter { } @Override - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { return table.getRecord(key); } @Override - public void putRecord(Record record) throws IOException { + public void putRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/RecordAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/RecordAdapter.java index cb347f42eb..b809663647 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/RecordAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/RecordAdapter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,20 +17,20 @@ package ghidra.program.database.references; import java.io.IOException; -import db.Record; +import db.DBRecord; interface RecordAdapter { - public Record createRecord(long key, int numRefs, byte refLevel, byte[] refData) + public DBRecord createRecord(long key, int numRefs, byte refLevel, byte[] refData) throws IOException; - public Record getRecord(long key) throws IOException; + public DBRecord getRecord(long key) throws IOException; /** * @param key * @param refData */ - public void putRecord(Record record) throws IOException; + public void putRecord(DBRecord record) throws IOException; /** * @param key diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/RefListV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/RefListV0.java index e03faf2388..6da0e5b90a 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/RefListV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/RefListV0.java @@ -24,7 +24,7 @@ package ghidra.program.database.references; import java.io.IOException; import java.util.Iterator; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.ProgramDB; import ghidra.program.database.map.AddressMap; @@ -47,7 +47,7 @@ class RefListV0 extends RefList { private int numRefs; private byte refLevel = -1; private byte[] refData; - private Record record; + private DBRecord record; /** * Construct new temporary empty reference list @@ -101,7 +101,7 @@ class RefListV0 extends RefList { * @param cache RefList object cache * @param isFrom true for from-adapter use, false for to-adapter use */ - RefListV0(Record rec, RecordAdapter adapter, AddressMap addrMap, ProgramDB program, + RefListV0(DBRecord rec, RecordAdapter adapter, AddressMap addrMap, ProgramDB program, DBObjectCache cache, boolean isFrom) { super(rec.getKey(), addrMap.decodeAddress(rec.getKey()), adapter, addrMap, program, cache, isFrom); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ReferenceDBManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ReferenceDBManager.java index 4d351e83ee..867e454da0 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ReferenceDBManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ReferenceDBManager.java @@ -253,7 +253,7 @@ public class ReferenceDBManager implements ReferenceManager, ManagerDB, ErrorHan RecordIterator iter = oldStackRefAdapter.getRecords(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Address fromAddr = oldAddrMap.decodeAddress(rec.getLongValue(OldStackRefDBAdpater.FROM_ADDR_COL)); @@ -1469,7 +1469,7 @@ public class ReferenceDBManager implements ReferenceManager, ManagerDB, ErrorHan public byte getReferenceLevel(Address toAddr) { try { - Record rec = toAdapter.getRecord(addrMap.getKey(toAddr, false)); + DBRecord rec = toAdapter.getRecord(addrMap.getKey(toAddr, false)); if (rec != null) { return rec.getByteValue(ToAdapter.REF_LEVEL_COL); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterSharedTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterSharedTable.java index 606e3f83df..31215b2457 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterSharedTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterSharedTable.java @@ -85,7 +85,7 @@ class ToAdapterSharedTable extends ToAdapter { RecordIterator iter = table.indexIterator(OLD_TO_ADDR_COL, toField, toField, true); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); boolean isUser = rec.getBooleanValue(OLD_USER_DEFINED_COL); SourceType source = isUser ? SourceType.USER_DEFINED : SourceType.DEFAULT; @@ -110,18 +110,18 @@ class ToAdapterSharedTable extends ToAdapter { } @Override - public Record createRecord(long key, int numRefs, byte refType, byte[] refData) + public DBRecord createRecord(long key, int numRefs, byte refType, byte[] refData) throws IOException { throw new UnsupportedOperationException(); } @Override - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { return table.getRecord(key); } @Override - public void putRecord(Record record) throws IOException { + public void putRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterV0.java index b440178cfe..21a5ad6cba 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterV0.java @@ -66,7 +66,7 @@ class ToAdapterV0 extends ToAdapter { @Override public RefList getRefList(ProgramDB program, DBObjectCache cache, Address to, long toAddr) throws IOException { - Record rec = translateRecord(table.getRecord(toAddr)); + DBRecord rec = translateRecord(table.getRecord(toAddr)); if (rec != null) { return new RefListV0(rec, this, addrMap, program, cache, false); } @@ -79,18 +79,18 @@ class ToAdapterV0 extends ToAdapter { } @Override - public Record createRecord(long key, int numRefs, byte refLevel, byte[] refData) + public DBRecord createRecord(long key, int numRefs, byte refLevel, byte[] refData) throws IOException { throw new UnsupportedOperationException(); } @Override - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { return translateRecord(table.getRecord(key)); } @Override - public void putRecord(Record record) throws IOException { + public void putRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @@ -127,18 +127,18 @@ class ToAdapterV0 extends ToAdapter { return table.getRecordCount(); } - private Record translateRecord(Record oldRec) { + private DBRecord translateRecord(DBRecord oldRec) { if (oldRec == null) { return null; } - Record rec = TO_REFS_SCHEMA.createRecord(oldRec.getKey()); + DBRecord rec = TO_REFS_SCHEMA.createRecord(oldRec.getKey()); rec.setIntValue(REF_COUNT_COL, oldRec.getIntValue(REF_COUNT_COL)); rec.setBinaryData(REF_DATA_COL, oldRec.getBinaryData(REF_DATA_COL)); rec.setByteValue(REF_LEVEL_COL, getRefLevel(rec)); return rec; } - private byte getRefLevel(Record newRec) { + private byte getRefLevel(DBRecord newRec) { try { RefList refList = new RefListV0(newRec, this, addrMap, null, null, false); Reference[] refs = refList.getAllRefs(); @@ -179,14 +179,14 @@ class ToAdapterV0 extends ToAdapter { } @Override - public Record next() throws IOException { - Record rec = it.next(); + public DBRecord next() throws IOException { + DBRecord rec = it.next(); return translateRecord(rec); } @Override - public Record previous() throws IOException { - Record rec = it.previous(); + public DBRecord previous() throws IOException { + DBRecord rec = it.previous(); return translateRecord(rec); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterV1.java index 80055514a5..1c46e6093e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ToAdapterV1.java @@ -73,7 +73,7 @@ class ToAdapterV1 extends ToAdapter { @Override public RefList getRefList(ProgramDB program, DBObjectCache cache, Address to, long toAddr) throws IOException { - Record rec = table.getRecord(toAddr); + DBRecord rec = table.getRecord(toAddr); if (rec != null) { if (rec.getBinaryData(REF_DATA_COL) == null) { return new BigRefListV0(rec, this, addrMap, program, cache, false); @@ -90,9 +90,9 @@ class ToAdapterV1 extends ToAdapter { } @Override - public Record createRecord(long key, int numRefs, byte refLevel, byte[] refData) + public DBRecord createRecord(long key, int numRefs, byte refLevel, byte[] refData) throws IOException { - Record rec = TO_REFS_SCHEMA.createRecord(key); + DBRecord rec = TO_REFS_SCHEMA.createRecord(key); rec.setIntValue(REF_COUNT_COL, numRefs); rec.setBinaryData(REF_DATA_COL, refData); rec.setByteValue(REF_LEVEL_COL, refLevel); @@ -101,12 +101,12 @@ class ToAdapterV1 extends ToAdapter { } @Override - public Record getRecord(long key) throws IOException { + public DBRecord getRecord(long key) throws IOException { return table.getRecord(key); } @Override - public void putRecord(Record record) throws IOException { + public void putRecord(DBRecord record) throws IOException { table.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapter.java index a3c8c2940b..9fb1388aa8 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapter.java @@ -100,7 +100,7 @@ abstract class RelocationDBAdapter { RelocationDBAdapter tmpAdapter = new RelocationDBAdapterV4(tmpHandle, addrMap, true); RecordIterator iter = oldAdapter.iterator(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getKey()); BinaryCodedField values = new BinaryCodedField((BinaryField) rec.getFieldValue(VALU_COL)); @@ -113,7 +113,7 @@ abstract class RelocationDBAdapter { iter = tmpAdapter.iterator(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); BinaryCodedField values = new BinaryCodedField((BinaryField) rec.getFieldValue(VALU_COL)); newAdapter.add(rec.getKey(), rec.getIntValue(TYPE_COL), values.getLongArray(), @@ -135,7 +135,7 @@ abstract class RelocationDBAdapter { abstract void remove(long addrKey) throws IOException; - abstract Record get(long addrKey) throws IOException; + abstract DBRecord get(long addrKey) throws IOException; abstract RecordIterator iterator() throws IOException; @@ -147,7 +147,7 @@ abstract class RelocationDBAdapter { abstract int getRecordCount(); - abstract Record adaptRecord(Record rec); + abstract DBRecord adaptRecord(DBRecord rec); //================================================================================================== // Inner Classes @@ -176,14 +176,14 @@ abstract class RelocationDBAdapter { } @Override - public Record next() throws IOException { - Record rec = it.next(); + public DBRecord next() throws IOException { + DBRecord rec = it.next(); return adaptRecord(rec); } @Override - public Record previous() throws IOException { - Record rec = it.previous(); + public DBRecord previous() throws IOException { + DBRecord rec = it.previous(); return adaptRecord(rec); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterNoTable.java index 83acd10757..983124da1e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterNoTable.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,7 +23,7 @@ import java.io.IOException; import java.lang.UnsupportedOperationException; -import db.Record; +import db.DBRecord; import db.RecordIterator; /** @@ -39,7 +38,7 @@ class RelocationDBAdapterNoTable extends RelocationDBAdapter { } @Override - Record get(long addrKey) { + DBRecord get(long addrKey) { return null; } @@ -74,7 +73,7 @@ class RelocationDBAdapterNoTable extends RelocationDBAdapter { } @Override - Record adaptRecord(Record rec) { + DBRecord adaptRecord(DBRecord rec) { throw new UnsupportedOperationException(); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV1.java index 7966cca073..eb8b1a34fa 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV1.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -50,7 +49,7 @@ class RelocationDBAdapterV1 extends RelocationDBAdapter { } @Override - Record get(long addrKey) throws IOException { + DBRecord get(long addrKey) throws IOException { return relocTable.getRecord(addrKey); } @@ -89,8 +88,8 @@ class RelocationDBAdapterV1 extends RelocationDBAdapter { } @Override - Record adaptRecord(Record rec) { - Record newRec = SCHEMA.createRecord(rec.getKey()); + DBRecord adaptRecord(DBRecord rec) { + DBRecord newRec = SCHEMA.createRecord(rec.getKey()); newRec.setIntValue(TYPE_COL, rec.getIntValue(TYPE_COL)); newRec.setBinaryData(BYTES_COL, null); return newRec; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV2.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV2.java index 99ddb20d96..74654a5792 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV2.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV2.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -50,7 +49,7 @@ class RelocationDBAdapterV2 extends RelocationDBAdapter { } @Override - Record get(long addrKey) throws IOException { + DBRecord get(long addrKey) throws IOException { return relocTable.getRecord(addrKey); } @@ -89,8 +88,8 @@ class RelocationDBAdapterV2 extends RelocationDBAdapter { } @Override - Record adaptRecord(Record rec) { - Record newRec = SCHEMA.createRecord(rec.getKey()); + DBRecord adaptRecord(DBRecord rec) { + DBRecord newRec = SCHEMA.createRecord(rec.getKey()); newRec.setIntValue(TYPE_COL, rec.getIntValue(TYPE_COL)); long[] values = new long[] { rec.getLongValue(VALU_COL) }; newRec.setField(VALU_COL, new BinaryCodedField(values)); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV3.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV3.java index 5ae140b8d5..8d15f53ea6 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV3.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV3.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -61,7 +60,7 @@ class RelocationDBAdapterV3 extends RelocationDBAdapter { } @Override - Record get(long addrKey) throws IOException { + DBRecord get(long addrKey) throws IOException { return relocTable.getRecord(addrKey); } @@ -96,8 +95,8 @@ class RelocationDBAdapterV3 extends RelocationDBAdapter { } @Override - Record adaptRecord(Record rec) { - Record newRec = SCHEMA.createRecord(rec.getKey()); + DBRecord adaptRecord(DBRecord rec) { + DBRecord newRec = SCHEMA.createRecord(rec.getKey()); newRec.setIntValue(TYPE_COL, rec.getIntValue(TYPE_COL)); long[] values = new long[] { rec.getLongValue(VALU_COL) }; newRec.setField(VALU_COL, new BinaryCodedField(values)); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV4.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV4.java index 810c856567..d73e3b354a 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV4.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationDBAdapterV4.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -57,7 +56,7 @@ public class RelocationDBAdapterV4 extends RelocationDBAdapter { @Override void add(long addrKey, int type, long[] values, byte[] bytes, String symbolName) throws IOException { - Record r = SCHEMA.createRecord(addrKey); + DBRecord r = SCHEMA.createRecord(addrKey); r.setIntValue(TYPE_COL, type); r.setField(VALU_COL, new BinaryCodedField(values)); r.setBinaryData(BYTES_COL, bytes); @@ -66,7 +65,7 @@ public class RelocationDBAdapterV4 extends RelocationDBAdapter { } @Override - Record get(long addrKey) throws IOException { + DBRecord get(long addrKey) throws IOException { return relocTable.getRecord(addrKey); } @@ -101,7 +100,7 @@ public class RelocationDBAdapterV4 extends RelocationDBAdapter { } @Override - Record adaptRecord(Record rec) { + DBRecord adaptRecord(DBRecord rec) { // my guess is that we don't need to do this until there is a version newer than us throw new UnsupportedOperationException("Don't know how to adapt to the new version"); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationManager.java index 752795612a..43f5b36b19 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/reloc/RelocationManager.java @@ -109,7 +109,7 @@ public class RelocationManager implements RelocationTable, ManagerDB { @Override public Relocation getRelocation(Address addr) { try { - Record rec = adapter.get(addrMap.getKey(addr, false)); + DBRecord rec = adapter.get(addrMap.getKey(addr, false)); if (rec != null) { return getRelocation(rec); } @@ -120,7 +120,7 @@ public class RelocationManager implements RelocationTable, ManagerDB { return null; } - private Relocation getRelocation(Record rec) { + private Relocation getRelocation(DBRecord rec) { BinaryCodedField valuesField = new BinaryCodedField((BinaryField) rec.getFieldValue(RelocationDBAdapter.VALU_COL)); return new Relocation(addrMap.decodeAddress(rec.getKey()), @@ -147,7 +147,7 @@ public class RelocationManager implements RelocationTable, ManagerDB { try { ri = adapter.iterator(addr); if (ri.hasNext()) { - Record r = ri.next(); + DBRecord r = ri.next(); Relocation relocation = getRelocation(r); if (!relocation.getAddress().equals(addr)) { return relocation; @@ -202,7 +202,7 @@ public class RelocationManager implements RelocationTable, ManagerDB { if (ri == null) return null; try { - Record r = ri.next(); + DBRecord r = ri.next(); return getRelocation(r); } catch (IOException e) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/AddressSetFilteredSymbolIterator.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/AddressSetFilteredSymbolIterator.java index eeace90734..f927a33cde 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/AddressSetFilteredSymbolIterator.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/AddressSetFilteredSymbolIterator.java @@ -18,7 +18,7 @@ package ghidra.program.database.symbol; import java.io.IOException; import java.util.Iterator; -import db.Record; +import db.DBRecord; import db.RecordIterator; import ghidra.program.database.util.Query; import ghidra.program.database.util.QueryRecordIterator; @@ -82,7 +82,7 @@ class AddressSetFilteredSymbolIterator implements SymbolIterator { private void findNext() throws IOException { if (recIter != null && recIter.hasNext()) { - Record rec = recIter.next(); + DBRecord rec = recIter.next(); currentSymbol = symbolMgr.getSymbol(rec); } else { @@ -92,7 +92,7 @@ class AddressSetFilteredSymbolIterator implements SymbolIterator { adapter.getSymbols(range.getMinAddress(), range.getMaxAddress(), forward); recIter = new QueryRecordIterator(it, query, forward); if (recIter.hasNext()) { - Record rec = recIter.next(); + DBRecord rec = recIter.next(); currentSymbol = symbolMgr.getSymbol(rec); break; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/ClassSymbol.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/ClassSymbol.java index 970ef62f8b..16df4ca907 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/ClassSymbol.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/ClassSymbol.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.symbol; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.model.address.Address; import ghidra.program.model.symbol.*; @@ -37,7 +37,7 @@ public class ClassSymbol extends SymbolDB { * @param record the record associated with the symbol. */ public ClassSymbol(SymbolManager symbolMgr, DBObjectCache cache, Address address, - Record record) { + DBRecord record) { super(symbolMgr, cache, address, record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/CodeSymbol.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/CodeSymbol.java index 8c4d1a26ef..7e546f831e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/CodeSymbol.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/CodeSymbol.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.symbol; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.external.ExternalManagerDB; import ghidra.program.model.address.Address; @@ -46,7 +46,7 @@ public class CodeSymbol extends SymbolDB { * @param record the record for this symbol */ public CodeSymbol(SymbolManager mgr, DBObjectCache cache, Address addr, - Record record) { + DBRecord record) { super(mgr, cache, addr, record); } @@ -70,7 +70,7 @@ public class CodeSymbol extends SymbolDB { } @Override - protected boolean refresh(Record rec) { + protected boolean refresh(DBRecord rec) { if (!isDynamic()) { return super.refresh(rec); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDB.java index 4b697254ed..50154b5f9b 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDB.java @@ -17,7 +17,7 @@ package ghidra.program.database.symbol; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; import ghidra.program.model.address.Address; @@ -39,7 +39,7 @@ import ghidra.util.exception.*; */ public class EquateDB extends DatabaseObject implements Equate { - private Record record; + private DBRecord record; private EquateManager equateMgr; /** @@ -48,7 +48,7 @@ public class EquateDB extends DatabaseObject implements Equate { * @param cache EquateDB cache * @param record the record for this equate. */ - public EquateDB(EquateManager equateMgr, DBObjectCache cache, Record record) { + public EquateDB(EquateManager equateMgr, DBObjectCache cache, DBRecord record) { super(cache, record.getKey()); this.equateMgr = equateMgr; this.record = record; @@ -56,7 +56,7 @@ public class EquateDB extends DatabaseObject implements Equate { @Override protected boolean refresh() { - Record rec = equateMgr.getEquateRecord(key); + DBRecord rec = equateMgr.getEquateRecord(key); if (rec == null) { return false; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDBAdapter.java index b5e8b92bf3..d547700f93 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDBAdapter.java @@ -63,7 +63,7 @@ abstract class EquateDBAdapter { * @param key the key to look up the record. * @throws IOException if there is no equate with the given */ - abstract Record getRecord(long key) throws IOException; + abstract DBRecord getRecord(long key) throws IOException; /** * Remove the record with the given key. @@ -77,7 +77,7 @@ abstract class EquateDBAdapter { * @param record the record to update. * @throws IOException if there was a problem accessing the database */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Create a new record for the equate. @@ -86,7 +86,7 @@ abstract class EquateDBAdapter { * @return new record * @throws IOException if there was a problem accessing the database */ - abstract Record createEquate(String name, long value) throws IOException; + abstract DBRecord createEquate(String name, long value) throws IOException; /** * Get an iterator over all the equate records. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDBAdapterV0.java index 652311c814..4717360cc2 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateDBAdapterV0.java @@ -52,10 +52,10 @@ class EquateDBAdapterV0 extends EquateDBAdapter { } /** - * @see ghidra.program.database.symbol.EquateDBAdapter#updateRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.symbol.EquateDBAdapter#updateRecord(ghidra.framework.store.db.DBRecord) */ @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { equateTable.putRecord(record); } @@ -93,8 +93,8 @@ class EquateDBAdapterV0 extends EquateDBAdapter { * @see ghidra.program.database.symbol.EquateDBAdapter#createEquate(java.lang.String, long) */ @Override - Record createEquate(String name, long value) throws IOException { - Record rec = equateTable.getSchema().createRecord(equateTable.getKey()); + DBRecord createEquate(String name, long value) throws IOException { + DBRecord rec = equateTable.getSchema().createRecord(equateTable.getKey()); rec.setString(NAME_COL, name); rec.setLongValue(VALUE_COL, value); equateTable.putRecord(rec); @@ -105,7 +105,7 @@ class EquateDBAdapterV0 extends EquateDBAdapter { * @see ghidra.program.database.symbol.EquateDBAdapter#getRecord(long) */ @Override - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { return equateTable.getRecord(key); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateManager.java index 9d3e47300f..4442b38850 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateManager.java @@ -118,7 +118,7 @@ public class EquateManager implements EquateTable, ErrorHandler, ManagerDB { throw new DuplicateNameException(name + " already exists for an equate."); } validateName(name); - Record record = equateAdapter.createEquate(name, value); + DBRecord record = equateAdapter.createEquate(name, value); EquateDB equate = new EquateDB(this, equateCache, record); program.setChanged(ChangeManager.DOCR_EQUATE_ADDED, new EquateInfo(name, value, null, 0, 0), null); @@ -297,7 +297,7 @@ public class EquateManager implements EquateTable, ErrorHandler, ManagerDB { try { RecordIterator iter = equateAdapter.getRecords(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); EquateDB equateDB = getEquateDB(rec.getKey()); if (equateDB.getValue() == value) { list.add(equateDB); @@ -428,7 +428,7 @@ public class EquateManager implements EquateTable, ErrorHandler, ManagerDB { removeRef(equateDB, ref); } } - Record record = + DBRecord record = refAdapter.createReference(addr, (short) opIndex, dynamicHash, equateID); new EquateRefDB(this, refCache, record); @@ -497,7 +497,7 @@ public class EquateManager implements EquateTable, ErrorHandler, ManagerDB { program.setChanged(ChangeManager.DOCR_EQUATE_RENAMED, oldName, newName); } - Record getEquateRecord(long equateID) { + DBRecord getEquateRecord(long equateID) { try { return equateAdapter.getRecord(equateID); } @@ -507,7 +507,7 @@ public class EquateManager implements EquateTable, ErrorHandler, ManagerDB { return null; } - Record getEquateRefRecord(long refID) { + DBRecord getEquateRefRecord(long refID) { try { return refAdapter.getRecord(refID); } @@ -537,7 +537,7 @@ public class EquateManager implements EquateTable, ErrorHandler, ManagerDB { try { EquateDB equateDB = equateCache.get(equateID); if (equateDB == null) { - Record record = equateAdapter.getRecord(equateID); + DBRecord record = equateAdapter.getRecord(equateID); if (record != null) { equateDB = new EquateDB(this, equateCache, record); } @@ -554,7 +554,7 @@ public class EquateManager implements EquateTable, ErrorHandler, ManagerDB { try { EquateRefDB ref = refCache.get(key); if (ref == null) { - Record record = refAdapter.getRecord(key); + DBRecord record = refAdapter.getRecord(key); ref = new EquateRefDB(this, refCache, record); } return ref; @@ -688,7 +688,7 @@ public class EquateManager implements EquateTable, ErrorHandler, ManagerDB { public Equate next() { if (iter != null) { try { - Record record = iter.next(); + DBRecord record = iter.next(); if (record != null) { return getEquateDB(record.getKey()); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDB.java index 71af6cd329..00a6513cb3 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDB.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.symbol; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.DatabaseObject; import ghidra.program.database.map.AddressMap; @@ -29,7 +29,7 @@ import ghidra.program.model.symbol.EquateReference; */ class EquateRefDB extends DatabaseObject implements EquateReference { - private Record record; + private DBRecord record; private EquateManager equateMgr; private AddressMap addrMap; @@ -39,7 +39,7 @@ class EquateRefDB extends DatabaseObject implements EquateReference { * @param cache * @param record */ - EquateRefDB(EquateManager equateMgr, DBObjectCache cache, Record record) { + EquateRefDB(EquateManager equateMgr, DBObjectCache cache, DBRecord record) { super(cache, record.getKey()); addrMap = equateMgr.getAddressMap(); this.equateMgr = equateMgr; @@ -48,7 +48,7 @@ class EquateRefDB extends DatabaseObject implements EquateReference { @Override protected boolean refresh() { - Record rec = equateMgr.getEquateRefRecord(key); + DBRecord rec = equateMgr.getEquateRefRecord(key); if (rec == null) { return false; } @@ -76,7 +76,7 @@ class EquateRefDB extends DatabaseObject implements EquateReference { return record.getLongValue(EquateRefDBAdapter.HASH_COL); } - Record getRecord() { + DBRecord getRecord() { return record; } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapter.java index 8811371b53..d822a857e0 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapter.java @@ -98,7 +98,7 @@ abstract class EquateRefDBAdapter { EquateRefDBAdapter tmpAdapter = new EquateRefDBAdapterV1(tmpHandle, addrMap, true); RecordIterator iter = oldAdapter.getRecords(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getLongValue(ADDR_COL)); rec.setLongValue(ADDR_COL, addrMap.getKey(addr, true)); rec.setLongValue(HASH_COL, 0); @@ -110,7 +110,7 @@ abstract class EquateRefDBAdapter { iter = tmpAdapter.getRecords(); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); newAdapter.updateRecord(rec); } return newAdapter; @@ -129,7 +129,7 @@ abstract class EquateRefDBAdapter { * @return new record * @throws IOException if there was a problem accessing the database */ - abstract Record createReference(long addr, short opIndex, long dynamicHash, long equateNameID) + abstract DBRecord createReference(long addr, short opIndex, long dynamicHash, long equateNameID) throws IOException; /** @@ -137,7 +137,7 @@ abstract class EquateRefDBAdapter { * @param the key of the record to retrieve. * @throws IOException if there was a problem accessing the database */ - abstract Record getRecord(long key) throws IOException; + abstract DBRecord getRecord(long key) throws IOException; /** * Get an iterator over all the equate reference records. @@ -162,7 +162,7 @@ abstract class EquateRefDBAdapter { * @param record the record to update. * @throws IOException if there was a problem accessing the database */ - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; /** * Get the records that have the given equateID. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapterV0.java index 02fe7644ef..efb15f9306 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapterV0.java @@ -59,7 +59,7 @@ class EquateRefDBAdapterV0 extends EquateRefDBAdapter { * @see ghidra.program.database.symbol.EquateRefDBAdapter#getRecord(long) */ @Override - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { return convertV0Record(refTable.getRecord(key)); } @@ -67,7 +67,7 @@ class EquateRefDBAdapterV0 extends EquateRefDBAdapter { * @see ghidra.program.database.symbol.EquateRefDBAdapter#createReference(long, short, long, long) */ @Override - Record createReference(long addr, short opIndex, long dynamicHash, long equateID) { + DBRecord createReference(long addr, short opIndex, long dynamicHash, long equateID) { throw new UnsupportedOperationException(); } @@ -80,10 +80,10 @@ class EquateRefDBAdapterV0 extends EquateRefDBAdapter { } /** - * @see ghidra.program.database.symbol.EquateRefDBAdapter#updateRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.symbol.EquateRefDBAdapter#updateRecord(ghidra.framework.store.db.DBRecord) */ @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @@ -160,11 +160,11 @@ class EquateRefDBAdapterV0 extends EquateRefDBAdapter { return refTable.getRecordCount(); } - private static Record convertV0Record(Record record) { + private static DBRecord convertV0Record(DBRecord record) { if (record == null) { return null; } - Record newRec = REFS_SCHEMA.createRecord(record.getKey()); + DBRecord newRec = REFS_SCHEMA.createRecord(record.getKey()); newRec.setLongValue(EQUATE_ID_COL, record.getLongValue(V0_EQUATE_ID_COL)); newRec.setLongValue(ADDR_COL, record.getLongValue(V0_ADDR_COL)); newRec.setShortValue(OP_INDEX_COL, record.getShortValue(V0_OP_INDEX_COL)); @@ -179,7 +179,7 @@ class EquateRefDBAdapterV0 extends EquateRefDBAdapter { } @Override - protected Record convertRecord(Record record) { + protected DBRecord convertRecord(DBRecord record) { return convertV0Record(record); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapterV1.java index aef81c502e..d74225d08f 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/EquateRefDBAdapterV1.java @@ -67,7 +67,7 @@ class EquateRefDBAdapterV1 extends EquateRefDBAdapter { * @see ghidra.program.database.symbol.EquateRefDBAdapter#getRecord(long) */ @Override - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { return refTable.getRecord(key); } @@ -75,9 +75,9 @@ class EquateRefDBAdapterV1 extends EquateRefDBAdapter { * @see ghidra.program.database.symbol.EquateRefDBAdapter#createReference(long, short, long, long) */ @Override - Record createReference(long addr, short opIndex, long dynamicHash, long equateID) + DBRecord createReference(long addr, short opIndex, long dynamicHash, long equateID) throws IOException { - Record rec = refTable.getSchema().createRecord(refTable.getKey()); + DBRecord rec = refTable.getSchema().createRecord(refTable.getKey()); rec.setLongValue(ADDR_COL, addr); rec.setShortValue(OP_INDEX_COL, opIndex); rec.setLongValue(HASH_COL, dynamicHash); @@ -95,10 +95,10 @@ class EquateRefDBAdapterV1 extends EquateRefDBAdapter { } /** - * @see ghidra.program.database.symbol.EquateRefDBAdapter#updateRecord(ghidra.framework.store.db.Record) + * @see ghidra.program.database.symbol.EquateRefDBAdapter#updateRecord(ghidra.framework.store.db.DBRecord) */ @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { refTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/FunctionSymbol.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/FunctionSymbol.java index fd1c617240..08a9fe0424 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/FunctionSymbol.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/FunctionSymbol.java @@ -18,7 +18,7 @@ package ghidra.program.database.symbol; import java.util.ArrayList; import java.util.List; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.ProgramDB; import ghidra.program.database.external.ExternalManagerDB; @@ -56,7 +56,7 @@ public class FunctionSymbol extends SymbolDB { * @param record the record for this symbol. */ public FunctionSymbol(SymbolManager symbolMgr, DBObjectCache cache, Address address, - Record record) { + DBRecord record) { super(symbolMgr, cache, address, record); this.functionMgr = symbolMgr.getFunctionManager(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/GlobalRegisterSymbol.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/GlobalRegisterSymbol.java index af0044804b..f7075799ca 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/GlobalRegisterSymbol.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/GlobalRegisterSymbol.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.symbol; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.model.address.Address; import ghidra.program.model.lang.Register; @@ -37,7 +37,7 @@ public class GlobalRegisterSymbol extends SymbolDB { * @param record the record for this symbol. */ public GlobalRegisterSymbol(SymbolManager mgr, DBObjectCache cache, Address addr, - Record record) { + DBRecord record) { super(mgr, cache, addr, record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/GlobalVariableSymbolDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/GlobalVariableSymbolDB.java index d641e86939..9303aaf344 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/GlobalVariableSymbolDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/GlobalVariableSymbolDB.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.symbol; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.model.address.Address; import ghidra.program.model.listing.Function; @@ -32,7 +32,7 @@ public class GlobalVariableSymbolDB extends VariableSymbolDB { * @param record the record for the symbol */ public GlobalVariableSymbolDB(SymbolManager symbolMgr, DBObjectCache cache, - VariableStorageManagerDB variableMgr, Address address, Record record) { + VariableStorageManagerDB variableMgr, Address address, DBRecord record) { super(symbolMgr, cache, SymbolType.GLOBAL_VAR, variableMgr, address, record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/LabelHistoryAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/LabelHistoryAdapterV0.java index 21a6a3cb61..1b712c9da8 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/LabelHistoryAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/LabelHistoryAdapterV0.java @@ -83,7 +83,7 @@ class LabelHistoryAdapterV0 extends LabelHistoryAdapter { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getLongValue(HISTORY_ADDR_COL)); rec.setLongValue(HISTORY_ADDR_COL, addrMap.getKey(addr, true)); tmpAdapter.table.putRecord(rec); @@ -98,7 +98,7 @@ class LabelHistoryAdapterV0 extends LabelHistoryAdapter { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); newAdapter.table.putRecord(rec); monitor.setProgress(++count); } @@ -115,7 +115,7 @@ class LabelHistoryAdapterV0 extends LabelHistoryAdapter { @Override public void createRecord(long addr, byte actionID, String labelStr) throws IOException { - Record rec = table.getSchema().createRecord(table.getKey()); + DBRecord rec = table.getSchema().createRecord(table.getKey()); rec.setLongValue(HISTORY_ADDR_COL, addr); rec.setByteValue(HISTORY_ACTION_COL, actionID); @@ -158,7 +158,7 @@ class LabelHistoryAdapterV0 extends LabelHistoryAdapter { void moveAddress(long oldAddr, long newAddr) throws IOException { Field[] keys = table.findRecords(new LongField(oldAddr), HISTORY_ADDR_COL); for (Field key : keys) { - Record rec = table.getRecord(key); + DBRecord rec = table.getRecord(key); rec.setLongValue(HISTORY_ADDR_COL, newAddr); table.putRecord(rec); } @@ -183,7 +183,7 @@ class LabelHistoryAdapterV0 extends LabelHistoryAdapter { final Set
set, TaskMonitor monitor) throws CancelledException, IOException { RecordFilter filter = new RecordFilter() { @Override - public boolean matches(Record record) { + public boolean matches(DBRecord record) { Address addr = addrMap.decodeAddress(record.getLongValue(HISTORY_ADDR_COL)); return set == null || !set.contains(addr); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/LibrarySymbol.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/LibrarySymbol.java index be48274022..3e76380be1 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/LibrarySymbol.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/LibrarySymbol.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.symbol; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.model.address.Address; import ghidra.program.model.listing.CircularDependencyException; @@ -47,7 +47,7 @@ public class LibrarySymbol extends SymbolDB { * @param record the record for this symbol */ public LibrarySymbol(SymbolManager symbolMgr, DBObjectCache cache, Address address, - Record record) { + DBRecord record) { super(symbolMgr, cache, address, record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/NamespaceSymbol.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/NamespaceSymbol.java index 8943fd1bf5..383776380d 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/NamespaceSymbol.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/NamespaceSymbol.java @@ -15,7 +15,7 @@ */ package ghidra.program.database.symbol; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.model.address.Address; import ghidra.program.model.symbol.*; @@ -36,7 +36,7 @@ public class NamespaceSymbol extends SymbolDB { * @param addr the address for this symbol. * @param record the record for this symbol. */ - NamespaceSymbol(SymbolManager mgr, DBObjectCache cache, Address addr, Record record) { + NamespaceSymbol(SymbolManager mgr, DBObjectCache cache, Address addr, DBRecord record) { super(mgr, cache, addr, record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/OldVariableStorageDBAdapterV0V1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/OldVariableStorageDBAdapterV0V1.java index 319bc5934d..5f54d17ca0 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/OldVariableStorageDBAdapterV0V1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/OldVariableStorageDBAdapterV0V1.java @@ -57,14 +57,14 @@ class OldVariableStorageDBAdapterV0V1 { } } - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { return variableStorageTable.getRecord(key); } - Record[] getRecordsForNamespace(long namespaceID) throws IOException { + DBRecord[] getRecordsForNamespace(long namespaceID) throws IOException { Field[] keys = variableStorageTable.findRecords(new LongField(namespaceID), NAMESPACE_ID_COL); - Record[] records = new Record[keys.length]; + DBRecord[] records = new DBRecord[keys.length]; for (int i = 0; i < keys.length; i++) { records[i] = variableStorageTable.getRecord(keys[i]); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/OldVariableStorageManagerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/OldVariableStorageManagerDB.java index fe266f5cbf..d8512487c6 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/OldVariableStorageManagerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/OldVariableStorageManagerDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.Hashtable; import db.DBHandle; -import db.Record; +import db.DBRecord; import ghidra.program.database.map.AddressMap; import ghidra.program.model.address.Address; import ghidra.program.model.address.AddressSpace; @@ -71,8 +71,8 @@ public class OldVariableStorageManagerDB { variableAddrLookupCache.clear(); storageAddrLookupCache.clear(); lastNamespaceCacheID = namespaceID; - Record[] records = adapter.getRecordsForNamespace(namespaceID); - for (Record rec : records) { + DBRecord[] records = adapter.getRecordsForNamespace(namespaceID); + for (DBRecord rec : records) { OldVariableStorage varStore = new OldVariableStorage(rec); variableAddrLookupCache.put(varStore.variableAddr, varStore); storageAddrLookupCache.put(varStore.storageAddr, varStore); @@ -89,7 +89,7 @@ public class OldVariableStorageManagerDB { return varStore; } } - Record rec = adapter.getRecord(variableAddr.getOffset()); + DBRecord rec = adapter.getRecord(variableAddr.getOffset()); if (rec == null) { return null; } @@ -106,7 +106,7 @@ public class OldVariableStorageManagerDB { private final Address variableAddr; private final Address storageAddr; - private OldVariableStorage(Record record) { + private OldVariableStorage(DBRecord record) { this.variableAddr = AddressSpace.VARIABLE_SPACE.getAddress(record.getKey()); this.storageAddr = addrMap.decodeAddress( record.getLongValue(OldVariableStorageDBAdapterV0V1.STORAGE_ADDR_COL)); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDB.java index c6b7955b6b..3d4cedef45 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDB.java @@ -19,7 +19,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.List; -import db.Record; +import db.DBRecord; import ghidra.program.database.*; import ghidra.program.database.external.ExternalLocationDB; import ghidra.program.database.external.ExternalManagerDB; @@ -43,7 +43,7 @@ import ghidra.util.task.UnknownProgressWrappingTaskMonitor; */ public abstract class SymbolDB extends DatabaseObject implements Symbol { - private Record record; + private DBRecord record; private boolean isDeleting = false; protected Address address; protected SymbolManager symbolMgr; @@ -67,7 +67,7 @@ public abstract class SymbolDB extends DatabaseObject implements Symbol { } SymbolDB(SymbolManager symbolMgr, DBObjectCache cache, Address address, - Record record) { + DBRecord record) { super(cache, record.getKey()); this.symbolMgr = symbolMgr; this.address = address; @@ -93,7 +93,7 @@ public abstract class SymbolDB extends DatabaseObject implements Symbol { } @Override - protected boolean refresh(Record rec) { + protected boolean refresh(DBRecord rec) { if (record != null) { if (rec == null) { rec = symbolMgr.getSymbolRecord(key); @@ -631,7 +631,7 @@ public abstract class SymbolDB extends DatabaseObject implements Symbol { } } - private void updateSymbolSource(Record symbolRecord, SourceType source) { + private void updateSymbolSource(DBRecord symbolRecord, SourceType source) { byte flags = record.getByteValue(SymbolDatabaseAdapter.SYMBOL_FLAGS_COL); flags &= ~SymbolDatabaseAdapter.SYMBOL_SOURCE_BITS; flags |= (byte) source.ordinal(); @@ -914,7 +914,7 @@ public abstract class SymbolDB extends DatabaseObject implements Symbol { * Change the record and key associated with this symbol * @param record the record */ - void setRecord(Record record) { + void setRecord(DBRecord record) { this.record = record; keyChanged(record.getKey()); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapter.java index 3ea9921999..ab244d409b 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapter.java @@ -131,7 +131,7 @@ abstract class SymbolDatabaseAdapter { * @throws IllegalArgumentException if you try to set the source to DEFAULT for a symbol type * that doesn't allow it. */ - abstract Record createSymbol(String name, Address address, long parentSymbolID, + abstract DBRecord createSymbol(String name, Address address, long parentSymbolID, SymbolType symbolType, long data1, int data2, String data3, SourceType source) throws IOException; @@ -141,7 +141,7 @@ abstract class SymbolDatabaseAdapter { * @return record with the given symbolID * @throws IOException if there was a problem accessing the database */ - abstract Record getSymbolRecord(long symbolID) throws IOException; + abstract DBRecord getSymbolRecord(long symbolID) throws IOException; /** * Remove the record for the given symbol ID @@ -192,7 +192,7 @@ abstract class SymbolDatabaseAdapter { * @param record * @throws IOException if there was a problem accessing the database */ - abstract void updateSymbolRecord(Record record) throws IOException; + abstract void updateSymbolRecord(DBRecord record) throws IOException; /** * Get all of the symbols. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV0.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV0.java index 65a9fe9211..41bf7db29a 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV0.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV0.java @@ -89,7 +89,7 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { RecordIterator iter = symbolTable.iterator(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); if (rec.getBooleanValue(V0_SYMBOL_LOCAL_COL)) { SymbolManager.saveLocalSymbol(handle, rec.getKey(), rec.getLongValue(V0_SYMBOL_ADDR_COL), rec.getString(V0_SYMBOL_NAME_COL), @@ -100,7 +100,7 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { return symbolTable.getKey(); } - private Record convertRecord(Record record) { + private DBRecord convertRecord(DBRecord record) { if (record == null) { return null; } @@ -108,7 +108,7 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { record.getBooleanValue(V0_SYMBOL_LOCAL_COL)) { throw new AssertException("Unexpected Symbol"); } - Record rec = SymbolDatabaseAdapter.SYMBOL_SCHEMA.createRecord(record.getKey()); + DBRecord rec = SymbolDatabaseAdapter.SYMBOL_SCHEMA.createRecord(record.getKey()); rec.setString(SymbolDatabaseAdapter.SYMBOL_NAME_COL, record.getString(V0_SYMBOL_NAME_COL)); rec.setLongValue(SymbolDatabaseAdapter.SYMBOL_ADDR_COL, record.getLongValue(V0_SYMBOL_ADDR_COL)); @@ -123,7 +123,7 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { } @Override - Record createSymbol(String name, Address address, long namespaceID, SymbolType symbolType, + DBRecord createSymbol(String name, Address address, long namespaceID, SymbolType symbolType, long data1, int data2, String data3, SourceType source) { throw new UnsupportedOperationException(); } @@ -144,7 +144,7 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { } @Override - Record getSymbolRecord(long symbolID) throws IOException { + DBRecord getSymbolRecord(long symbolID) throws IOException { return convertRecord(symbolTable.getRecord(symbolID)); } @@ -167,7 +167,7 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { } @Override - void updateSymbolRecord(Record record) throws IOException { + void updateSymbolRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @@ -228,7 +228,7 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { private class V0ConvertedRecordIterator implements RecordIterator { private RecordIterator symIter; - private Record rec; + private DBRecord rec; /** * Construct a symbol filtered record iterator @@ -259,9 +259,9 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { } @Override - public Record next() throws IOException { + public DBRecord next() throws IOException { if (hasNext()) { - Record r = rec; + DBRecord r = rec; rec = null; return convertRecord(r); } @@ -269,7 +269,7 @@ class SymbolDatabaseAdapterV0 extends SymbolDatabaseAdapter { } @Override - public Record previous() throws IOException { + public DBRecord previous() throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV1.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV1.java index 0b864ed040..c862d24fda 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV1.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV1.java @@ -73,7 +73,7 @@ class SymbolDatabaseAdapterV1 extends SymbolDatabaseAdapter { } @Override - Record createSymbol(String name, Address address, long namespaceID, SymbolType symbolType, + DBRecord createSymbol(String name, Address address, long namespaceID, SymbolType symbolType, long data1, int data2, String data3, SourceType source) { throw new UnsupportedOperationException(); } @@ -102,7 +102,7 @@ class SymbolDatabaseAdapterV1 extends SymbolDatabaseAdapter { } @Override - Record getSymbolRecord(long symbolID) throws IOException { + DBRecord getSymbolRecord(long symbolID) throws IOException { return convertV1Record(symbolTable.getRecord(symbolID)); } @@ -111,11 +111,11 @@ class SymbolDatabaseAdapterV1 extends SymbolDatabaseAdapter { * @param recV1 the record matching the version 1 schema. * @return a current symbol record. */ - private Record convertV1Record(Record record) { + private DBRecord convertV1Record(DBRecord record) { if (record == null) { return null; } - Record rec = SymbolDatabaseAdapter.SYMBOL_SCHEMA.createRecord(record.getKey()); + DBRecord rec = SymbolDatabaseAdapter.SYMBOL_SCHEMA.createRecord(record.getKey()); String symbolName = record.getString(V1_SYMBOL_NAME_COL); rec.setString(SymbolDatabaseAdapter.SYMBOL_NAME_COL, symbolName); long symbolAddrKey = record.getLongValue(V1_SYMBOL_ADDR_COL); @@ -161,7 +161,7 @@ class SymbolDatabaseAdapterV1 extends SymbolDatabaseAdapter { } @Override - void updateSymbolRecord(Record record) throws IOException { + void updateSymbolRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } @@ -224,7 +224,7 @@ class SymbolDatabaseAdapterV1 extends SymbolDatabaseAdapter { } @Override - protected Record convertRecord(Record record) { + protected DBRecord convertRecord(DBRecord record) { return convertV1Record(record); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV2.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV2.java index 6ae8c48913..f25b675b76 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV2.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDatabaseAdapterV2.java @@ -84,12 +84,12 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { SymbolDatabaseAdapterV2 tmpAdapter = new SymbolDatabaseAdapterV2(tmpHandle, addrMap, true); RecordIterator iter = oldAdapter.getSymbols(); - Record zeroRecord = null; + DBRecord zeroRecord = null; while (iter.hasNext()) { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getLongValue(SYMBOL_ADDR_COL)); rec.setLongValue(SYMBOL_ADDR_COL, addrMap.getKey(addr, true)); if (rec.getKey() == 0) { @@ -123,7 +123,7 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = iter.next(); + DBRecord rec = iter.next(); // Make sure user symbols do not start with reserved prefix String name = rec.getString(SYMBOL_NAME_COL); @@ -153,7 +153,7 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { * @param zeroRecord * @throws IOException */ - private void createSymbol(long nextKey, Record zeroRecord) throws IOException { + private void createSymbol(long nextKey, DBRecord zeroRecord) throws IOException { zeroRecord.setKey(nextKey); symbolTable.putRecord(zeroRecord); } @@ -167,7 +167,7 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { try { RecordIterator iter = tmpAdapter.getSymbolsByName(newName); while (iter.hasNext()) { - Record otherRec = iter.next(); + DBRecord otherRec = iter.next(); if (namespaceId == otherRec.getLongValue(SYMBOL_PARENT_COL)) { throw new DuplicateNameException(); } @@ -181,7 +181,7 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { } @Override - Record createSymbol(String name, Address address, long namespaceID, SymbolType symbolType, + DBRecord createSymbol(String name, Address address, long namespaceID, SymbolType symbolType, long data1, int data2, String data3, SourceType source) throws IOException { long nextID = symbolTable.getKey(); @@ -193,11 +193,11 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { (byte) source.ordinal()); } - private Record createSymbol(long id, String name, Address address, long namespaceID, + private DBRecord createSymbol(long id, String name, Address address, long namespaceID, SymbolType symbolType, long data1, int data2, String data3, byte flags) throws IOException { - Record rec = symbolTable.getSchema().createRecord(id); + DBRecord rec = symbolTable.getSchema().createRecord(id); rec.setString(SYMBOL_NAME_COL, name); rec.setLongValue(SYMBOL_ADDR_COL, addrMap.getKey(address, true)); rec.setLongValue(SYMBOL_PARENT_COL, namespaceID); @@ -234,7 +234,7 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { } @Override - Record getSymbolRecord(long symbolID) throws IOException { + DBRecord getSymbolRecord(long symbolID) throws IOException { return symbolTable.getRecord(symbolID); } @@ -256,7 +256,7 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { } @Override - void updateSymbolRecord(Record record) throws IOException { + void updateSymbolRecord(DBRecord record) throws IOException { symbolTable.putRecord(record); } @@ -281,7 +281,7 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { long newKey = addrMap.getKey(newAddr, true); Field[] keys = symbolTable.findRecords(oldKey, SYMBOL_ADDR_COL); for (Field key : keys) { - Record rec = symbolTable.getRecord(key); + DBRecord rec = symbolTable.getRecord(key); rec.setLongValue(SYMBOL_ADDR_COL, newKey); symbolTable.putRecord(rec); } @@ -310,7 +310,7 @@ class SymbolDatabaseAdapterV2 extends SymbolDatabaseAdapter { private Set
set = new HashSet
(); @Override - public boolean matches(Record record) { + public boolean matches(DBRecord record) { // only move symbols whose anchor flag is not on Address addr = addrMap.decodeAddress(record.getLongValue(SYMBOL_ADDR_COL)); byte flags = record.getByteValue(SymbolDatabaseAdapter.SYMBOL_FLAGS_COL); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolManager.java index 66dd6472e9..6dc5934ba9 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolManager.java @@ -202,7 +202,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { monitor.initialize(1); RecordIterator recIter = adapter.getSymbolsByNamespace(libSym.getID()); while (recIter.hasNext()) { - Record rec = recIter.next(); + DBRecord rec = recIter.next(); Address oldAddr = addrMap.decodeAddress(rec.getLongValue(SymbolDatabaseAdapter.SYMBOL_ADDR_COL)); if (!(oldAddr instanceof OldGenericNamespaceAddress)) { @@ -229,7 +229,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { AddressSpace.EXTERNAL_SPACE.getMaxAddress(), true); while (symbolRecordIterator.hasNext()) { monitor.checkCanceled(); - Record rec = symbolRecordIterator.next(); + DBRecord rec = symbolRecordIterator.next(); rec.setByteValue(SymbolDatabaseAdapter.SYMBOL_TYPE_COL, SymbolType.LABEL.getID()); adapter.updateSymbolRecord(rec); } @@ -256,7 +256,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { while (symbolRecordIterator.hasNext()) { monitor.checkCanceled(); monitor.setProgress(++cnt); - Record rec = symbolRecordIterator.next(); + DBRecord rec = symbolRecordIterator.next(); long addr = rec.getLongValue(SymbolDatabaseAdapter.SYMBOL_ADDR_COL); Address oldAddress = addrMap.decodeAddress(addr); if (!(oldAddress instanceof OldGenericNamespaceAddress)) { @@ -315,7 +315,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { long curDataTypeId = -1; while (recIter.hasNext()) { monitor.checkCanceled(); - Record rec = recIter.next(); + DBRecord rec = recIter.next(); Address addr = addrMap.decodeAddress(rec.getLongValue(SymbolDatabaseAdapter.SYMBOL_ADDR_COL)); if (!addr.isVariableAddress()) { @@ -385,7 +385,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { RecordIterator iter = table.iterator(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getKey()); refManager.addExternalEntryPointRef(addr); monitor.setProgress(++cnt); @@ -416,7 +416,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { RecordIterator iter = table.iterator(); while (iter.hasNext()) { monitor.checkCanceled(); - Record rec = iter.next(); + DBRecord rec = iter.next(); Address addr = oldAddrMap.decodeAddress(rec.getLongValue(OLD_SYMBOL_ADDR_COL)); Namespace namespace = namespaceMgr.getNamespaceContaining(addr); if (namespace.getID() != Namespace.GLOBAL_NAMESPACE_ID) { @@ -457,7 +457,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { if (table == null) { table = tmpHandle.createTable(OLD_LOCAL_SYMBOLS_TABLE, OLD_LOCAL_SYMBOLS_SCHEMA); } - Record rec = OLD_LOCAL_SYMBOLS_SCHEMA.createRecord(symbolID); + DBRecord rec = OLD_LOCAL_SYMBOLS_SCHEMA.createRecord(symbolID); rec.setLongValue(OLD_SYMBOL_ADDR_COL, oldAddr); rec.setString(OLD_SYMBOL_NAME_COL, name); rec.setBooleanValue(OLD_SYMBOL_IS_PRIMARY_COL, isPrimary); @@ -509,7 +509,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { Address address = symbol.getAddress(); symbolRemoved(symbol, address, symbol.getName(), oldKey, Namespace.GLOBAL_NAMESPACE_ID, null); - Record record = adapter.createSymbol(newName, address, newParentID, SymbolType.LABEL, 0, + DBRecord record = adapter.createSymbol(newName, address, newParentID, SymbolType.LABEL, 0, 1, null, source); symbol.setRecord(record);// symbol object was morphed symbolAdded(symbol); @@ -549,7 +549,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { } checkDuplicateSymbolName(addr, name, namespace, type); - Record rec = SymbolDatabaseAdapter.SYMBOL_SCHEMA.createRecord(symbolID); + DBRecord rec = SymbolDatabaseAdapter.SYMBOL_SCHEMA.createRecord(symbolID); rec.setString(SymbolDatabaseAdapter.SYMBOL_NAME_COL, name); rec.setLongValue(SymbolDatabaseAdapter.SYMBOL_ADDR_COL, addrMap.getKey(addr, true)); rec.setLongValue(SymbolDatabaseAdapter.SYMBOL_PARENT_COL, namespace.getID()); @@ -560,7 +560,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { adapter.updateSymbolRecord(rec); } - private SymbolDB makeSymbol(Address addr, Record record, SymbolType type) { + private SymbolDB makeSymbol(Address addr, DBRecord record, SymbolType type) { if (addr == null) { addr = addrMap.decodeAddress(record.getLongValue(SymbolDatabaseAdapter.SYMBOL_ADDR_COL)); @@ -748,7 +748,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { return s; } try { - Record record = adapter.getSymbolRecord(symbolID); + DBRecord record = adapter.getSymbolRecord(symbolID); if (record != null) { return createCachedSymbol(record); } @@ -1284,7 +1284,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { try { RecordIterator iter = historyAdapter.getRecordsByAddress(addrMap.getKey(addr, false)); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); list.add(new LabelHistory( addrMap.decodeAddress(rec.getLongValue(LabelHistoryAdapter.HISTORY_ADDR_COL)), rec.getString(LabelHistoryAdapter.HISTORY_USER_COL), @@ -1390,7 +1390,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { ArrayList symbols = new ArrayList<>(); RecordIterator iter = adapter.getSymbolsByNamespace(namespaceID); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); symbols.add(getSymbol(rec)); } Iterator it = symbols.iterator(); @@ -1448,7 +1448,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { return adapter; } - Record getSymbolRecord(long symbolID) { + DBRecord getSymbolRecord(long symbolID) { try { return adapter.getSymbolRecord(symbolID); } @@ -1517,7 +1517,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { } } - private SymbolDB createCachedSymbol(Record record) { + private SymbolDB createCachedSymbol(DBRecord record) { long addr = record.getLongValue(SymbolDatabaseAdapter.SYMBOL_ADDR_COL); byte typeID = record.getByteValue(SymbolDatabaseAdapter.SYMBOL_TYPE_COL); SymbolType type = SymbolType.getSymbolType(typeID); @@ -1525,7 +1525,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { return s; } - SymbolDB getSymbol(Record record) { + SymbolDB getSymbol(DBRecord record) { lock.acquire(); try { SymbolDB s = cache.get(record); @@ -1683,7 +1683,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { lock.acquire(); boolean hasNext = forward ? it.hasNext() : it.hasPrevious(); if (hasNext) { - Record rec = forward ? it.next() : it.previous(); + DBRecord rec = forward ? it.next() : it.previous(); nextSymbol = getSymbol(rec); } return hasNext; @@ -1888,7 +1888,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { @Override public LabelHistory next() { try { - Record rec = iter.next(); + DBRecord rec = iter.next(); if (rec != null) { return new LabelHistory( addrMap.decodeAddress( @@ -2059,7 +2059,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { try { RecordIterator it = adapter.getSymbols(); while (it.hasNext()) { - Record rec = it.next(); + DBRecord rec = it.next(); byte typeID = rec.getByteValue(SymbolDatabaseAdapter.SYMBOL_TYPE_COL); // Change datatype ID contained with symbol data1 for all @@ -2489,7 +2489,7 @@ public class SymbolManager implements SymbolTable, ManagerDB { long data1, int data2, String data3, SourceType source) { try { - Record record = adapter.createSymbol(name, addr, namespace.getID(), type, data1, data2, + DBRecord record = adapter.createSymbol(name, addr, namespace.getID(), type, data1, data2, data3, source); SymbolDB newSymbol = makeSymbol(addr, record, type); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapter.java index a78a334f68..273eaa1943 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapter.java @@ -75,9 +75,9 @@ abstract class VariableStorageDBAdapter { throw new AssertException("Variable storage table is from newer version"); } - abstract void updateRecord(Record record) throws IOException; + abstract void updateRecord(DBRecord record) throws IOException; - abstract Record getRecord(long key) throws IOException; + abstract DBRecord getRecord(long key) throws IOException; /** * Locate the record key which corresponds to the specified hash value. diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapterNoTable.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapterNoTable.java index 98b63d6ede..3440fdbd6f 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapterNoTable.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapterNoTable.java @@ -17,7 +17,7 @@ package ghidra.program.database.symbol; import java.io.IOException; -import db.Record; +import db.DBRecord; import db.RecordIterator; import ghidra.program.database.util.EmptyRecordIterator; @@ -42,12 +42,12 @@ public class VariableStorageDBAdapterNoTable extends VariableStorageDBAdapter { } @Override - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { return null; } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { throw new UnsupportedOperationException(); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapterV2.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapterV2.java index ff7c4c670f..0314bdac08 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapterV2.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageDBAdapterV2.java @@ -70,12 +70,12 @@ public class VariableStorageDBAdapterV2 extends VariableStorageDBAdapter { } @Override - Record getRecord(long key) throws IOException { + DBRecord getRecord(long key) throws IOException { return variableStorageTable.getRecord(key); } @Override - void updateRecord(Record record) throws IOException { + void updateRecord(DBRecord record) throws IOException { variableStorageTable.putRecord(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageManagerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageManagerDB.java index 60362e6889..e0a07e9d76 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageManagerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableStorageManagerDB.java @@ -94,7 +94,7 @@ public class VariableStorageManagerDB { if (varStore != null) { return varStore; } - Record rec = adapter.getRecord(variableAddr.getOffset()); + DBRecord rec = adapter.getRecord(variableAddr.getOffset()); if (rec == null) { return null; } @@ -107,7 +107,7 @@ public class VariableStorageManagerDB { if (!variableAddr.isVariableAddress()) { throw new IllegalArgumentException(); } - Record rec = adapter.getRecord(variableAddr.getOffset()); + DBRecord rec = adapter.getRecord(variableAddr.getOffset()); if (rec == null) { return null; } @@ -152,7 +152,7 @@ public class VariableStorageManagerDB { // create new storage record key = adapter.getNextStorageID(); - Record rec = VariableStorageDBAdapter.VARIABLE_STORAGE_SCHEMA.createRecord(key); + DBRecord rec = VariableStorageDBAdapter.VARIABLE_STORAGE_SCHEMA.createRecord(key); rec.setLongValue(VariableStorageDBAdapter.HASH_COL, storage.getLongHash()); rec.setString(VariableStorageDBAdapter.STORAGE_COL, storage.getSerializationString()); adapter.updateRecord(rec); @@ -209,9 +209,9 @@ public class VariableStorageManagerDB { private class MyVariableStorage extends DatabaseObject { private VariableStorage storage; - private Record record; + private DBRecord record; - private MyVariableStorage(DBObjectCache cache, Record record) { + private MyVariableStorage(DBObjectCache cache, DBRecord record) { super(cache, record.getKey()); this.record = record; try { @@ -244,7 +244,7 @@ public class VariableStorageManagerDB { try { storage = VariableStorage.BAD_STORAGE; if (record != null) { - Record rec = adapter.getRecord(key); + DBRecord rec = adapter.getRecord(key); if (rec == null) { return false; } @@ -289,7 +289,7 @@ public class VariableStorageManagerDB { while (recIter.hasNext()) { monitor.checkCanceled(); - Record rec = recIter.next(); + DBRecord rec = recIter.next(); // NOTE: addrMap has already been switched-over to new language and its address spaces String serialization = rec.getString(VariableStorageDBAdapter.STORAGE_COL); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableSymbolDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableSymbolDB.java index 2bea32aa44..e9850bc765 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableSymbolDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/VariableSymbolDB.java @@ -17,7 +17,7 @@ package ghidra.program.database.symbol; import java.io.IOException; -import db.Record; +import db.DBRecord; import ghidra.program.database.DBObjectCache; import ghidra.program.database.function.FunctionDB; import ghidra.program.model.address.Address; @@ -55,7 +55,7 @@ public class VariableSymbolDB extends SymbolDB { * @param record the record for the symbol */ public VariableSymbolDB(SymbolManager symbolMgr, DBObjectCache cache, SymbolType type, - VariableStorageManagerDB variableMgr, Address address, Record record) { + VariableStorageManagerDB variableMgr, Address address, DBRecord record) { super(symbolMgr, cache, address, record); this.type = type; this.variableMgr = variableMgr; @@ -110,7 +110,7 @@ public class VariableSymbolDB extends SymbolDB { } @Override - protected boolean refresh(Record rec) { + protected boolean refresh(DBRecord rec) { boolean isValid = super.refresh(rec); variableStorage = null; return isValid; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AddressRangeMapDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AddressRangeMapDB.java index e85d707799..1ce138aebd 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AddressRangeMapDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AddressRangeMapDB.java @@ -172,7 +172,7 @@ public class AddressRangeMapDB implements DBListener { } try { long index = addrMap.getKey(addr, false); - Record rec = rangeMapTable.getRecordAtOrBefore(index); + DBRecord rec = rangeMapTable.getRecordAtOrBefore(index); if (rec != null) { Address startAddr = addrMap.decodeAddress(rec.getKey()); Address endAddr = addrMap.decodeAddress(rec.getLongValue(TO_COL)); @@ -300,7 +300,7 @@ public class AddressRangeMapDB implements DBListener { // fix up the start of the range, unless the range starts at a key-range MIN if (!addrMap.isKeyRangeMin(start)) { - Record rec = rangeMapTable.getRecordBefore(start); + DBRecord rec = rangeMapTable.getRecordBefore(start); if (rec != null) { long to = rec.getLongValue(TO_COL); if (addrMap.hasSameKeyBase(start, to)) { @@ -331,7 +331,7 @@ public class AddressRangeMapDB implements DBListener { // fix up the end of the range, unless the end goes to key-range MAX if (!addrMap.isKeyRangeMax(end)) { - Record rec = rangeMapTable.getRecord(end + 1); + DBRecord rec = rangeMapTable.getRecord(end + 1); if (rec != null && rec.fieldEquals(VALUE_COL, value)) { end = rec.getLongValue(TO_COL); rangeMapTable.deleteRecord(rec.getKey()); @@ -341,7 +341,7 @@ public class AddressRangeMapDB implements DBListener { // fix records which overlap paint range RecordIterator iter = rangeMapTable.iterator(start, end, start); while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); iter.delete(); long to = rec.getLongValue(TO_COL); if (to > end) { @@ -357,7 +357,7 @@ public class AddressRangeMapDB implements DBListener { // insert new range entry if value was specified if (value != null) { - Record rec = rangeMapSchema.createRecord(start); + DBRecord rec = rangeMapSchema.createRecord(start); rec.setLongValue(TO_COL, end); rec.setField(VALUE_COL, value); rangeMapTable.putRecord(rec); @@ -413,7 +413,7 @@ public class AddressRangeMapDB implements DBListener { try { RecordIterator iterator = rangeMapTable.iterator(); while (iterator.hasNext()) { - Record rec = iterator.next(); + DBRecord rec = iterator.next(); Address startAddr = addrMap.decodeAddress(rec.getKey()); Address endAddr = addrMap.decodeAddress(rec.getLongValue(TO_COL)); set.addRange(startAddr, endAddr); @@ -444,7 +444,7 @@ public class AddressRangeMapDB implements DBListener { RecordIterator iterator = rangeMapTable.indexIterator(VALUE_COL, value, value, true); while (iterator.hasNext()) { - Record rec = iterator.next(); + DBRecord rec = iterator.next(); Address startAddr = addrMap.decodeAddress(rec.getKey()); Address endAddr = addrMap.decodeAddress(rec.getLongValue(TO_COL)); set.addRange(startAddr, endAddr); @@ -522,7 +522,7 @@ public class AddressRangeMapDB implements DBListener { AddressKeyRecordIterator addressKeyRecordIterator = new AddressKeyRecordIterator(rangeMapTable, addrMap, min, addr, addr, true); if (addressKeyRecordIterator.hasPrevious()) { - Record rec = addressKeyRecordIterator.previous(); + DBRecord rec = addressKeyRecordIterator.previous(); Address fromAddr = addrMap.decodeAddress(rec.getKey()); Address toAddr = addrMap.decodeAddress(rec.getLongValue(TO_COL)); if (toAddr.compareTo(addr) >= 0) { @@ -534,7 +534,7 @@ public class AddressRangeMapDB implements DBListener { addressKeyRecordIterator = new AddressKeyRecordIterator(rangeMapTable, addrMap, addr, max, addr, true); if (addressKeyRecordIterator.hasNext()) { - Record rec = addressKeyRecordIterator.next(); + DBRecord rec = addressKeyRecordIterator.next(); Address fromAddr = addrMap.decodeAddress(rec.getKey()); Address toAddr = addrMap.decodeAddress(rec.getLongValue(TO_COL)); if (fromAddr.compareTo(addr) == 0) { @@ -562,7 +562,7 @@ public class AddressRangeMapDB implements DBListener { private class RangeIterator implements AddressRangeIterator { private RecordIterator recIter; - private Record nextRec; + private DBRecord nextRec; private boolean checkStart; private long startIndex; @@ -603,7 +603,7 @@ public class AddressRangeMapDB implements DBListener { try { startIndex = addrMap.getKey(startAddr, false); if (startIndex != AddressMap.INVALID_ADDRESS_KEY) { - Record rec = rangeMapTable.getRecordBefore(startIndex); + DBRecord rec = rangeMapTable.getRecordBefore(startIndex); if (rec != null) { long to = rec.getLongValue(TO_COL); if (addrMap.hasSameKeyBase(startIndex, to) && to >= startIndex) { @@ -641,7 +641,7 @@ public class AddressRangeMapDB implements DBListener { try { startIndex = addrMap.getKey(startAddr, false); if (startIndex != AddressMap.INVALID_ADDRESS_KEY) { - Record rec = rangeMapTable.getRecordBefore(startIndex); + DBRecord rec = rangeMapTable.getRecordBefore(startIndex); if (rec != null) { long to = rec.getLongValue(TO_COL); if (addrMap.hasSameKeyBase(startIndex, to) && to >= startIndex) { @@ -714,7 +714,7 @@ public class AddressRangeMapDB implements DBListener { AddressRange range = null; if (recIter != null) { try { - Record rec; + DBRecord rec; if (nextRec != null) { rec = nextRec; nextRec = null; @@ -788,7 +788,7 @@ public class AddressRangeMapDB implements DBListener { private class ValueRangeIterator implements AddressRangeIterator { RecordIterator recIter; - Record nextRec; + DBRecord nextRec; private int expectedModCount; @@ -859,7 +859,7 @@ public class AddressRangeMapDB implements DBListener { AddressRange range = null; if (recIter != null) { try { - Record rec; + DBRecord rec; if (nextRec != null) { rec = nextRec; nextRec = null; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AndQuery.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AndQuery.java index da252a69f2..9d6d95786d 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AndQuery.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AndQuery.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,7 +18,7 @@ */ package ghidra.program.database.util; -import db.Record; +import db.DBRecord; /** * Combines two queries such that this query is the logical "AND" of the two queries. If the @@ -40,9 +39,9 @@ public class AndQuery implements Query { } /** - * @see ghidra.program.database.util.Query#matches(db.Record) + * @see ghidra.program.database.util.Query#matches(db.DBRecord) */ - public boolean matches(Record record) { + public boolean matches(DBRecord record) { return q1.matches(record) && q2.matches(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/DatabaseTableUtils.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/DatabaseTableUtils.java index 66ffc8e825..6a2e9aa0b7 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/DatabaseTableUtils.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/DatabaseTableUtils.java @@ -61,7 +61,7 @@ public class DatabaseTableUtils { throw new CancelledException(); } Field key = startFromTop ? it.next() : it.previous(); - Record rec = table.getRecord(key); + DBRecord rec = table.getRecord(key); if (filter == null || filter.matches(rec)) { Address addr = addrMap.decodeAddress(rec.getLongValue(addrCol)); addr = toAddr.add(addr.subtract(fromAddr)); @@ -139,7 +139,7 @@ public class DatabaseTableUtils { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = it.next(); + DBRecord rec = it.next(); Address addr = addrMap.decodeAddress(rec.getKey()); long offset = addr.subtract(fromAddr); addr = toAddr.add(offset); @@ -154,7 +154,7 @@ public class DatabaseTableUtils { if (monitor.isCancelled()) { throw new CancelledException(); } - Record rec = it.next(); + DBRecord rec = it.next(); table.putRecord(rec); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/EmptyRecordIterator.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/EmptyRecordIterator.java index eb751214e0..d5f4d02d6b 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/EmptyRecordIterator.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/EmptyRecordIterator.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,7 +20,7 @@ package ghidra.program.database.util; import java.io.IOException; -import db.Record; +import db.DBRecord; import db.RecordIterator; /** @@ -46,14 +45,14 @@ public class EmptyRecordIterator implements RecordIterator { /** * @see db.RecordIterator#next() */ - public Record next() throws IOException { + public DBRecord next() throws IOException { return null; } /** * @see db.RecordIterator#previous() */ - public Record previous() throws IOException { + public DBRecord previous() throws IOException { return null; } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/FieldMatchQuery.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/FieldMatchQuery.java index 8f0358987e..3354255afe 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/FieldMatchQuery.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/FieldMatchQuery.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +16,7 @@ package ghidra.program.database.util; import db.Field; -import db.Record; +import db.DBRecord; /** * Query implementation used to test a field in a record to match a given value. @@ -37,9 +36,9 @@ public class FieldMatchQuery implements Query { } /** - * @see ghidra.program.database.util.Query#matches(db.Record) + * @see ghidra.program.database.util.Query#matches(db.DBRecord) */ - public boolean matches(Record record) { + public boolean matches(DBRecord record) { return record.fieldEquals(column, value); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/FieldRangeQuery.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/FieldRangeQuery.java index e00c1ebb9b..961c15b070 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/FieldRangeQuery.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/FieldRangeQuery.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,7 +19,7 @@ package ghidra.program.database.util; import db.Field; -import db.Record; +import db.DBRecord; /** * Query implementation used to test a field in a record to fall within a range of values. @@ -44,9 +43,9 @@ public class FieldRangeQuery implements Query { } /** - * @see ghidra.program.database.util.Query#matches(db.Record) + * @see ghidra.program.database.util.Query#matches(db.DBRecord) */ - public boolean matches(Record record) { + public boolean matches(DBRecord record) { return (record.compareFieldTo(column, min) > 0) && (record.compareFieldTo(column, max) < 0); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/NotQuery.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/NotQuery.java index 8b46515245..eea151fd5c 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/NotQuery.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/NotQuery.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,7 +18,7 @@ */ package ghidra.program.database.util; -import db.Record; +import db.DBRecord; /** * Negates the given query such that this query is the logical "NOT" of the given query. @@ -36,9 +35,9 @@ public class NotQuery implements Query { } /** - * @see ghidra.program.database.util.Query#matches(db.Record) + * @see ghidra.program.database.util.Query#matches(db.DBRecord) */ - public boolean matches(Record record) { + public boolean matches(DBRecord record) { return !q1.matches(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/OrQuery.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/OrQuery.java index 0d3d9b455a..69ac6040da 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/OrQuery.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/OrQuery.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,7 +18,7 @@ */ package ghidra.program.database.util; -import db.Record; +import db.DBRecord; /** * Combines two queries such that this query is the logical "OR" of the two queries. If the @@ -40,9 +39,9 @@ public class OrQuery implements Query { } /** - * @see ghidra.program.database.util.Query#matches(db.Record) + * @see ghidra.program.database.util.Query#matches(db.DBRecord) */ - public boolean matches(Record record) { + public boolean matches(DBRecord record) { return q1.matches(record) || q2.matches(record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/Query.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/Query.java index b1c9e46370..9d05b4e21e 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/Query.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/Query.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,7 +18,7 @@ */ package ghidra.program.database.util; -import db.Record; +import db.DBRecord; /** * Query interface used to test a record for some condition. @@ -29,5 +28,5 @@ public interface Query { * Returns true if the given record matches the querys condition. * @param record the record to test for compliance. */ - boolean matches(Record record); + boolean matches(DBRecord record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/QueryRecordIterator.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/QueryRecordIterator.java index a8a5e7145e..b08eb7119d 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/QueryRecordIterator.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/QueryRecordIterator.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,7 +23,7 @@ import ghidra.util.exception.ClosedException; import java.io.IOException; -import db.Record; +import db.DBRecord; import db.RecordIterator; /** @@ -34,7 +33,7 @@ public class QueryRecordIterator implements RecordIterator { private RecordIterator iter; private Query query; - private Record record; + private DBRecord record; private boolean forward; /** @@ -77,9 +76,9 @@ public class QueryRecordIterator implements RecordIterator { /** * @see db.RecordIterator#next() */ - public Record next() throws IOException { + public DBRecord next() throws IOException { if (hasNext()) { - Record rec = record; + DBRecord rec = record; record = null; return rec; } @@ -99,9 +98,9 @@ public class QueryRecordIterator implements RecordIterator { /** * @see db.RecordIterator#previous() */ - public Record previous() throws IOException { + public DBRecord previous() throws IOException { if (hasPrevious()) { - Record rec = record; + DBRecord rec = record; record = null; return rec; } @@ -118,7 +117,7 @@ public class QueryRecordIterator implements RecordIterator { private void findNext() { try { while (iter.hasNext()) { - Record rec = iter.next(); + DBRecord rec = iter.next(); if (query.matches(rec)) { record = rec; return; @@ -136,7 +135,7 @@ public class QueryRecordIterator implements RecordIterator { private void findPrevious() { try { while (iter.hasPrevious()) { - Record rec = iter.previous(); + DBRecord rec = iter.previous(); if (query.matches(rec)) { record = rec; return; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/RecordFilter.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/RecordFilter.java index 78882258ed..bfe5c631c3 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/RecordFilter.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/RecordFilter.java @@ -1,6 +1,5 @@ /* ### * IP: GHIDRA - * REVIEWED: YES * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,8 +15,8 @@ */ package ghidra.program.database.util; -import db.Record; +import db.DBRecord; public interface RecordFilter { - public boolean matches(Record record); + public boolean matches(DBRecord record); } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/SharedRangeMapDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/SharedRangeMapDB.java index a5430eca28..fffdabb573 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/SharedRangeMapDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/SharedRangeMapDB.java @@ -133,9 +133,9 @@ public class SharedRangeMapDB { // Get next range Field mapKey = mapKeys[i]; - Record mapRec = mapTable.getRecord(mapKey); + DBRecord mapRec = mapTable.getRecord(mapKey); long rangeKey = mapRec.getLongValue(MAP_RANGE_KEY_COL); - Record rangeRec = rangeTable.getRecord(rangeKey); + DBRecord rangeRec = rangeTable.getRecord(rangeKey); // Consoldate range if it overlaps long min = rangeKey; @@ -160,7 +160,7 @@ public class SharedRangeMapDB { } // Handle existing range which overlaps start index. - Record rangeRec = rangeTable.getRecordBefore(start); + DBRecord rangeRec = rangeTable.getRecordBefore(start); if (rangeRec != null) { //long startRange = rangeRec.getKey(); long endRange = rangeRec.getLongValue(RANGE_TO_COL); @@ -221,7 +221,7 @@ public class SharedRangeMapDB { * @param value */ private void insertMapEntry(long rangeKey, long value) throws IOException { - Record rec = MAP_SCHEMA.createRecord(mapTable.getMaxKey() + 1); + DBRecord rec = MAP_SCHEMA.createRecord(mapTable.getMaxKey() + 1); rec.setLongValue(MAP_RANGE_KEY_COL, rangeKey); rec.setLongValue(MAP_VALUE_COL, value); mapTable.putRecord(rec); @@ -233,7 +233,7 @@ public class SharedRangeMapDB { * @param end */ private void insertRangeEntry(long start, long end) throws IOException { - Record rec = RANGES_SCHEMA.createRecord(start); + DBRecord rec = RANGES_SCHEMA.createRecord(start); rec.setLongValue(RANGE_TO_COL, end); rangeTable.putRecord(rec); } @@ -247,10 +247,10 @@ public class SharedRangeMapDB { * @return Record * @throws IOException */ - private Record splitRange(Record rangeRecord, long newEnd) throws IOException { + private DBRecord splitRange(DBRecord rangeRecord, long newEnd) throws IOException { // Split range record - Record newRange = RANGES_SCHEMA.createRecord(newEnd + 1); + DBRecord newRange = RANGES_SCHEMA.createRecord(newEnd + 1); newRange.setField(RANGE_TO_COL, rangeRecord.getFieldValue(RANGE_TO_COL)); rangeRecord.setLongValue(RANGE_TO_COL, newEnd); rangeTable.putRecord(rangeRecord); @@ -259,7 +259,7 @@ public class SharedRangeMapDB { // Split related map records Field[] mapKeys = mapTable.findRecords(rangeRecord.getKeyField(), MAP_RANGE_KEY_COL); for (int i = 0; i < mapKeys.length; i++) { - Record mapRec = mapTable.getRecord(mapKeys[i]); + DBRecord mapRec = mapTable.getRecord(mapKeys[i]); mapRec.setKey(mapTable.getMaxKey() + 1); mapRec.setField(MAP_RANGE_KEY_COL, newRange.getKeyField()); mapTable.putRecord(mapRec); @@ -278,7 +278,7 @@ public class SharedRangeMapDB { Field[] values = new Field[mapKeys.length]; for (int i = 0; i < mapKeys.length; i++) { - Record rec = mapTable.getRecord(mapKeys[i]); + DBRecord rec = mapTable.getRecord(mapKeys[i]); values[i] = rec.getFieldValue(MAP_VALUE_COL); } Arrays.sort(values); @@ -304,7 +304,7 @@ public class SharedRangeMapDB { } // Consolidate previous range if possible - Record rangeRec = rangeTable.getRecordBefore(rangeKey); + DBRecord rangeRec = rangeTable.getRecordBefore(rangeKey); if (rangeRec != null && rangeRec.getLongValue(RANGE_TO_COL) == (rangeKey - 1)) { Field[] keys = mapTable.findRecords(rangeRec.getKeyField(), MAP_RANGE_KEY_COL); // Can consolidate if range occupied by the same set of values @@ -358,12 +358,12 @@ public class SharedRangeMapDB { // Remove Map entry Field mapKey = mapKeys[i]; - Record mapRec = mapTable.getRecord(mapKey); + DBRecord mapRec = mapTable.getRecord(mapKey); mapTable.deleteRecord(mapKey); // Consolidate Range long rangeKey = mapRec.getLongValue(MAP_RANGE_KEY_COL); - Record rangeRec = rangeTable.getRecord(rangeKey); + DBRecord rangeRec = rangeTable.getRecord(rangeKey); consolidateRange(rangeKey, rangeRec.getLongValue(RANGE_TO_COL)); } } @@ -421,7 +421,7 @@ public class SharedRangeMapDB { try { // Adjust start index to pickup first range which contains start - Record rec = rangeTable.getRecordAtOrBefore(start); + DBRecord rec = rangeTable.getRecordAtOrBefore(start); if (rec != null && rec.getLongValue(RANGE_TO_COL) >= start) { start = rec.getKey(); } @@ -451,7 +451,7 @@ public class SharedRangeMapDB { synchronized (dbHandle) { try { while (nextValue == null) { - Record rec = mapRecIter.next(); + DBRecord rec = mapRecIter.next(); if (rec == null) break; nextValue = rec.getFieldValue(MAP_VALUE_COL); @@ -524,7 +524,7 @@ public class SharedRangeMapDB { public IndexRange next() { synchronized (dbHandle) { try { - Record rec = recordIter.next(); + DBRecord rec = recordIter.next(); if (rec != null) { long rangeKey = rec.getLongValue(MAP_RANGE_KEY_COL); rec = rangeTable.getRecord(rangeKey); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/StringMatchQuery.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/StringMatchQuery.java index 0c9c91a108..4cbf2feedc 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/StringMatchQuery.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/StringMatchQuery.java @@ -21,7 +21,7 @@ package ghidra.program.database.util; import java.util.regex.Matcher; import java.util.regex.Pattern; -import db.Record; +import db.DBRecord; import ghidra.util.UserSearchUtils; /** @@ -45,7 +45,7 @@ public class StringMatchQuery implements Query { } @Override - public boolean matches(Record record) { + public boolean matches(DBRecord record) { String value = record.getString(col); Matcher matcher = pattern.matcher(value); diff --git a/Ghidra/Test/IntegrationTest/src/test.slow/java/ghidra/server/RepositoryFileSystemTest.java b/Ghidra/Test/IntegrationTest/src/test.slow/java/ghidra/server/RepositoryFileSystemTest.java index d4d2d5f7e2..07f639b4e4 100644 --- a/Ghidra/Test/IntegrationTest/src/test.slow/java/ghidra/server/RepositoryFileSystemTest.java +++ b/Ghidra/Test/IntegrationTest/src/test.slow/java/ghidra/server/RepositoryFileSystemTest.java @@ -116,7 +116,7 @@ public class RepositoryFileSystemTest extends AbstractGhidraHeadedIntegrationTes // Add record long txId = dbh.startTransaction(); - Record rec = schema.createRecord(i); + DBRecord rec = schema.createRecord(i); rec.setIntValue(0, i); testTable.putRecord(rec); Msg.debug(this, "Added record to test table, key=" + i); @@ -216,7 +216,7 @@ public class RepositoryFileSystemTest extends AbstractGhidraHeadedIntegrationTes try { Table testTable = dbh.getTable("test"); assertEquals(1, testTable.getRecordCount()); - Record rec = testTable.getRecord(2); + DBRecord rec = testTable.getRecord(2); assertNotNull(rec); assertEquals(2, rec.getIntValue(0)); }