Add disambiguation info to source strings

4 files changed, 46 insertions, 32 deletions

diff --git a/src/format/Kdbx4Reader.cpp b/src/format/Kdbx4Reader.cpp
index 38063acf1..8b9d4ab2b 100644
--- a/src/format/Kdbx4Reader.cpp
+++ b/src/format/Kdbx4Reader.cpp
@@ -298,6 +298,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
             & KeePass2::VARIANTMAP_CRITICAL_MASK;
     quint16 maxVersion = KeePass2::VARIANTMAP_VERSION & KeePass2::VARIANTMAP_CRITICAL_MASK;
     if (!ok || (version > maxVersion)) {
+        //: Translation: variant map = data structure for storing meta data
         raiseError(tr("Unsupported KeePass variant map version."));
         return {};
     }
@@ -310,6 +311,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
                != KeePass2::VariantMapFieldType::End)) {
         auto nameLen = Endian::readSizedInt<quint32>(device, KeePass2::BYTEORDER, &ok);
         if (!ok) {
+            //: Translation: variant map = data structure for storing meta data
             raiseError(tr("Invalid variant map entry name length"));
             return {};
         }
@@ -317,6 +319,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
         if (nameLen != 0) {
             nameBytes = device->read(nameLen);
             if (static_cast<quint32>(nameBytes.size()) != nameLen) {
+                //: Translation: variant map = data structure for storing meta data
                 raiseError(tr("Invalid variant map entry name data"));
                 return {};
             }
@@ -325,6 +328,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
 
         auto valueLen = Endian::readSizedInt<quint32>(device, KeePass2::BYTEORDER, &ok);
         if (!ok) {
+            //: Translation: variant map = data structure for storing meta data
             raiseError(tr("Invalid variant map entry value length"));
             return {};
         }
@@ -332,6 +336,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
         if (valueLen != 0) {
             valueBytes = device->read(valueLen);
             if (static_cast<quint32>(valueBytes.size()) != valueLen) {
+                //: Translation comment: variant map = data structure for storing meta data
                 raiseError(tr("Invalid variant map entry value data"));
                 return {};
             }
@@ -342,6 +347,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
             if (valueLen == 1) {
                 vm.insert(name, QVariant(valueBytes.at(0) != 0));
             } else {
+                //: Translation: variant map = data structure for storing meta data
                 raiseError(tr("Invalid variant map Bool entry value length"));
                 return {};
             }
@@ -351,6 +357,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
             if (valueLen == 4) {
                 vm.insert(name, QVariant(Endian::bytesToSizedInt<qint32>(valueBytes, KeePass2::BYTEORDER)));
             } else {
+                //: Translation: variant map = data structure for storing meta data
                 raiseError(tr("Invalid variant map Int32 entry value length"));
                 return {};
             }
@@ -360,6 +367,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
             if (valueLen == 4) {
                 vm.insert(name, QVariant(Endian::bytesToSizedInt<quint32>(valueBytes, KeePass2::BYTEORDER)));
             } else {
+                //: Translation: variant map = data structure for storing meta data
                 raiseError(tr("Invalid variant map UInt32 entry value length"));
                 return {};
             }
@@ -369,6 +377,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
             if (valueLen == 8) {
                 vm.insert(name, QVariant(Endian::bytesToSizedInt<qint64>(valueBytes, KeePass2::BYTEORDER)));
             } else {
+                //: Translation: variant map = data structure for storing meta data
                 raiseError(tr("Invalid variant map Int64 entry value length"));
                 return {};
             }
@@ -378,6 +387,7 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
             if (valueLen == 8) {
                 vm.insert(name, QVariant(Endian::bytesToSizedInt<quint64>(valueBytes, KeePass2::BYTEORDER)));
             } else {
+                //: Translation: variant map = data structure for storing meta data
                 raiseError(tr("Invalid variant map UInt64 entry value length"));
                 return {};
             }
@@ -392,12 +402,14 @@ QVariantMap Kdbx4Reader::readVariantMap(QIODevice* device)
             break;
 
         default:
+            //: Translation: variant map = data structure for storing meta data
             raiseError(tr("Invalid variant map entry type"));
             return {};
         }
     }
 
     if (fieldTypeArray.size() != 1) {
+        //: Translation: variant map = data structure for storing meta data
         raiseError(tr("Invalid variant map field type size"));
         return {};
     }
diff --git a/src/format/Kdbx4Writer.cpp b/src/format/Kdbx4Writer.cpp
index 7ce8bab1a..42cc3ecb5 100644
--- a/src/format/Kdbx4Writer.cpp
+++ b/src/format/Kdbx4Writer.cpp
@@ -41,7 +41,7 @@ bool Kdbx4Writer::writeDatabase(QIODevice* device, Database* db)
     }
     int ivSize = SymmetricCipher::algorithmIvSize(algo);
     if (ivSize < 0) {
-        raiseError(tr("Invalid symmetric cipher IV size."));
+        raiseError(tr("Invalid symmetric cipher IV size.", "IV = Initialization Vector for symmetric cipher"));
         return false;
     }
 
@@ -82,6 +82,7 @@ bool Kdbx4Writer::writeDatabase(QIODevice* device, Database* db)
         QVariantMap kdfParams = KeePass2::kdfToParameters(db->kdf());
         QByteArray kdfParamBytes;
         if (!serializeVariantMap(kdfParams, kdfParamBytes)) {
+            //: Translation comment: variant map = data structure for storing meta data
             raiseError(tr("Failed to serialize KDF parameters variant map"));
             return false;
         }
diff --git a/src/format/KdbxXmlReader.cpp b/src/format/KdbxXmlReader.cpp
index 774bb00c7..0b09e8a2f 100644
--- a/src/format/KdbxXmlReader.cpp
+++ b/src/format/KdbxXmlReader.cpp
@@ -1120,6 +1120,7 @@ QByteArray KdbxXmlReader::readCompressedBinary()
 
     QByteArray result;
     if (!Tools::readAllFromDevice(&compressor, result)) {
+        //: Translator meant is a binary data inside an entry
         raiseError(tr("Unable to decompress binary"));
     }
     return result;
diff --git a/src/format/KeePass1Reader.cpp b/src/format/KeePass1Reader.cpp
index 20f9ff232..390857075 100644
--- a/src/format/KeePass1Reader.cpp
+++ b/src/format/KeePass1Reader.cpp
@@ -126,37 +126,37 @@ Database* KeePass1Reader::readDatabase(QIODevice* device, const QString& passwor
 
     m_encryptionIV = m_device->read(16);
     if (m_encryptionIV.size() != 16) {
-        raiseError("Unable to read encryption IV");
+        raiseError(tr("Unable to read encryption IV", "IV = Initialization Vector for symmetric cipher"));
         return nullptr;
     }
 
     auto numGroups = Endian::readSizedInt<quint32>(m_device, KeePass1::BYTEORDER, &ok);
     if (!ok) {
-        raiseError("Invalid number of groups");
+        raiseError(tr("Invalid number of groups"));
         return nullptr;
     }
 
     auto numEntries = Endian::readSizedInt<quint32>(m_device, KeePass1::BYTEORDER, &ok);
     if (!ok) {
-        raiseError("Invalid number of entries");
+        raiseError(tr("Invalid number of entries"));
         return nullptr;
     }
 
     m_contentHashHeader = m_device->read(32);
     if (m_contentHashHeader.size() != 32) {
-        raiseError("Invalid content hash size");
+        raiseError(tr("Invalid content hash size"));
         return nullptr;
     }
 
     m_transformSeed = m_device->read(32);
     if (m_transformSeed.size() != 32) {
-        raiseError("Invalid transform seed size");
+        raiseError(tr("Invalid transform seed size"));
         return nullptr;
     }
 
     m_transformRounds = Endian::readSizedInt<quint32>(m_device, KeePass1::BYTEORDER, &ok);
     if (!ok) {
-        raiseError("Invalid number of transform rounds");
+        raiseError(tr("Invalid number of transform rounds"));
         return nullptr;
     }
     auto kdf = QSharedPointer<AesKdf>::create(true);
@@ -191,7 +191,7 @@ Database* KeePass1Reader::readDatabase(QIODevice* device, const QString& passwor
     }
 
     if (!constructGroupTree(groups)) {
-        raiseError("Unable to construct group tree");
+        raiseError(tr("Unable to construct group tree"));
         return nullptr;
     }
 
@@ -401,7 +401,7 @@ QByteArray KeePass1Reader::key(const QByteArray& password, const QByteArray& key
     bool result = key.transform(*m_db->kdf(), transformedKey);
 
     if (!result) {
-        raiseError("Key transformation failed");
+        raiseError(tr("Key transformation failed"));
         return QByteArray();
     }
 
@@ -445,19 +445,19 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
     do {
         quint16 fieldType = Endian::readSizedInt<quint16>(cipherStream, KeePass1::BYTEORDER, &ok);
         if (!ok) {
-            raiseError("Invalid group field type number");
+            raiseError(tr("Invalid group field type number"));
             return nullptr;
         }
 
         int fieldSize = static_cast<int>(Endian::readSizedInt<quint32>(cipherStream, KeePass1::BYTEORDER, &ok));
         if (!ok) {
-            raiseError("Invalid group field size");
+            raiseError(tr("Invalid group field size"));
             return nullptr;
         }
 
         QByteArray fieldData = cipherStream->read(fieldSize);
         if (fieldData.size() != fieldSize) {
-            raiseError("Read group field data doesn't match size");
+            raiseError(tr("Read group field data doesn't match size"));
             return nullptr;
         }
 
@@ -467,7 +467,7 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
             break;
         case 0x0001:
             if (fieldSize != 4) {
-                raiseError("Incorrect group id field size");
+                raiseError(tr("Incorrect group id field size"));
                 return nullptr;
             }
             groupId = Endian::bytesToSizedInt<quint32>(fieldData, KeePass1::BYTEORDER);
@@ -479,7 +479,7 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
         case 0x0003:
         {
             if (fieldSize != 5) {
-                raiseError("Incorrect group creation time field size");
+                raiseError(tr("Incorrect group creation time field size"));
                 return nullptr;
             }
             QDateTime dateTime = dateFromPackedStruct(fieldData);
@@ -491,7 +491,7 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
         case 0x0004:
         {
             if (fieldSize != 5) {
-                raiseError("Incorrect group modification time field size");
+                raiseError(tr("Incorrect group modification time field size"));
                 return nullptr;
             }
             QDateTime dateTime = dateFromPackedStruct(fieldData);
@@ -503,7 +503,7 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
         case 0x0005:
         {
             if (fieldSize != 5) {
-                raiseError("Incorrect group access time field size");
+                raiseError(tr("Incorrect group access time field size"));
             }
             QDateTime dateTime = dateFromPackedStruct(fieldData);
             if (dateTime.isValid()) {
@@ -514,7 +514,7 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
         case 0x0006:
         {
             if (fieldSize != 5) {
-                raiseError("Incorrect group expiry time field size");
+                raiseError(tr("Incorrect group expiry time field size"));
             }
             QDateTime dateTime = dateFromPackedStruct(fieldData);
             if (dateTime.isValid()) {
@@ -526,7 +526,7 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
         case 0x0007:
         {
             if (fieldSize != 4) {
-                raiseError("Incorrect group icon field size");
+                raiseError(tr("Incorrect group icon field size"));
                 return nullptr;
             }
             quint32 iconNumber = Endian::bytesToSizedInt<quint32>(fieldData, KeePass1::BYTEORDER);
@@ -536,7 +536,7 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
         case 0x0008:
         {
             if (fieldSize != 2) {
-                raiseError("Incorrect group level field size");
+                raiseError(tr("Incorrect group level field size"));
                 return nullptr;
             }
             groupLevel = Endian::bytesToSizedInt<quint16>(fieldData, KeePass1::BYTEORDER);
@@ -551,13 +551,13 @@ Group* KeePass1Reader::readGroup(QIODevice* cipherStream)
             break;
         default:
             // invalid field
-            raiseError("Invalid group field type");
+            raiseError(tr("Invalid group field type"));
             return nullptr;
         }
     } while (!reachedEnd);
 
     if (!groupIdSet || !groupLevelSet) {
-        raiseError("Missing group id or level");
+        raiseError(tr("Missing group id or level"));
         return nullptr;
     }
 
@@ -583,19 +583,19 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
     do {
         quint16 fieldType = Endian::readSizedInt<quint16>(cipherStream, KeePass1::BYTEORDER, &ok);
         if (!ok) {
-            raiseError("Missing entry field type number");
+            raiseError(tr("Missing entry field type number"));
             return nullptr;
         }
 
         int fieldSize = static_cast<int>(Endian::readSizedInt<quint32>(cipherStream, KeePass1::BYTEORDER, &ok));
         if (!ok) {
-            raiseError("Invalid entry field size");
+            raiseError(tr("Invalid entry field size"));
             return nullptr;
         }
 
         QByteArray fieldData = cipherStream->read(fieldSize);
         if (fieldData.size() != fieldSize) {
-            raiseError("Read entry field data doesn't match size");
+            raiseError(tr("Read entry field data doesn't match size"));
             return nullptr;
         }
 
@@ -605,7 +605,7 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
             break;
         case 0x0001:
             if (fieldSize != 16) {
-                raiseError("Invalid entry uuid field size");
+                raiseError(tr("Invalid entry uuid field size"));
                 return nullptr;
             }
             m_entryUuids.insert(fieldData, entry.data());
@@ -613,7 +613,7 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
         case 0x0002:
         {
             if (fieldSize != 4) {
-                raiseError("Invalid entry group id field size");
+                raiseError(tr("Invalid entry group id field size"));
                 return nullptr;
             }
             quint32 groupId = Endian::bytesToSizedInt<quint32>(fieldData, KeePass1::BYTEORDER);
@@ -623,7 +623,7 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
         case 0x0003:
         {
             if (fieldSize != 4) {
-                raiseError("Invalid entry icon field size");
+                raiseError(tr("Invalid entry icon field size"));
                 return nullptr;
             }
             quint32 iconNumber = Endian::bytesToSizedInt<quint32>(fieldData, KeePass1::BYTEORDER);
@@ -648,7 +648,7 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
         case 0x0009:
         {
             if (fieldSize != 5) {
-                raiseError("Invalid entry creation time field size");
+                raiseError(tr("Invalid entry creation time field size"));
                 return nullptr;
             }
             QDateTime dateTime = dateFromPackedStruct(fieldData);
@@ -660,7 +660,7 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
         case 0x000A:
         {
             if (fieldSize != 5) {
-                raiseError("Invalid entry modification time field size");
+                raiseError(tr("Invalid entry modification time field size"));
                 return nullptr;
             }
             QDateTime dateTime = dateFromPackedStruct(fieldData);
@@ -672,7 +672,7 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
         case 0x000B:
         {
             if (fieldSize != 5) {
-                raiseError("Invalid entry creation time field size");
+                raiseError(tr("Invalid entry creation time field size"));
                 return nullptr;
             }
             QDateTime dateTime = dateFromPackedStruct(fieldData);
@@ -684,7 +684,7 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
         case 0x000C:
         {
             if (fieldSize != 5) {
-                raiseError("Invalid entry expiry time field size");
+                raiseError(tr("Invalid entry expiry time field size"));
                 return nullptr;
             }
             QDateTime dateTime = dateFromPackedStruct(fieldData);
@@ -707,7 +707,7 @@ Entry* KeePass1Reader::readEntry(QIODevice* cipherStream)
             break;
         default:
             // invalid field
-            raiseError("Invalid entry field type");
+            raiseError(tr("Invalid entry field type"));
             return nullptr;
         }
     } while (!reachedEnd);