--- a/HexFile.cpp	Mon Jan 12 13:49:16 2026 +0000
+++ b/HexFile.cpp	Mon Jan 12 13:51:17 2026 +0000
@@ -53,16 +53,19 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 HexFile::HexFile()
-: _memSize(0),
+    : _memSize(0)
+    ,
 #ifdef FROG_MASTER
-  _baseAddress(0),
+    _baseAddress(0)
+    ,
 #endif
-  _buffer(0)
+    _buffer(0)
 {}
 
 HexFile::~HexFile()
 {
-    delete[] _buffer; _buffer = 0;
+    delete[] _buffer;
+    _buffer = 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -79,8 +82,8 @@
 
 bool HexFile::sqwiz(size_t newMemSize)
 {
-    if( newMemSize >= _memSize ) {
-        LOG_THROW( "Squiz failed" );
+    if (newMemSize >= _memSize) {
+        LOG_THROW("Squiz failed");
     }
     _memSize = newMemSize;
     return true;
@@ -93,65 +96,61 @@
 void HexFile::readLine()
 {
     QByteArray line = _file.readLine();
-    if( line[0] != ':' )
-        LOG_THROW( "Bad HEX format" );
+    if (line[0] != ':')
+        LOG_THROW("Bad HEX format");
 
     unsigned char checksum = 0;
     bool ok = true;
-    for(int i=1; ok && i<line.length(); i+=2) {
-        if( line[i]=='\r' || line[i]=='\n' )
+    for (int i = 1; ok && i < line.length(); i += 2) {
+        if (line[i] == '\r' || line[i] == '\n')
             break;
-        checksum += line.mid(i,2).toInt(&ok,16);
+        checksum += line.mid(i, 2).toInt(&ok, 16);
     }
-    if( ! ok )
-        LOG_THROW( "Bad HEX header" );
-    if( checksum != 0 )
-        LOG_THROW( "Bad HEX checksum" );
+    if (!ok)
+        LOG_THROW("Bad HEX header");
+    if (checksum != 0)
+        LOG_THROW("Bad HEX checksum");
 
-    int len  = line.mid(1,2).toInt(0, 16);
-    int addr = line.mid(3,2).toInt(0, 16) << 8
-             | line.mid(5,2).toInt(0, 16);
-    int type = line.mid(7,2).toInt(0, 16);
+    int len = line.mid(1, 2).toInt(0, 16);
+    int addr = line.mid(3, 2).toInt(0, 16) << 8 | line.mid(5, 2).toInt(0, 16);
+    int type = line.mid(7, 2).toInt(0, 16);
 
-    switch( type )
-    {
+    switch (type) {
     case 00: //---- Data record ----------------------------------------------
-        if( _baseAddress == 0x300000 )  // Skip configuration bits.
+        if (_baseAddress == 0x300000) // Skip configuration bits.
             return;
-        if( _baseAddress == 0xF00000 )  // Skip internal prom reset.
+        if (_baseAddress == 0xF00000) // Skip internal prom reset.
             return;
 
-        for(int i=0; i<len; i++, ++addr)
-        {
+        for (int i = 0; i < len; i++, ++addr) {
             size_t a = _baseAddress + addr;
-            if( a >= _memSize )
-                LOG_THROW( "BAD HEX address" );
+            if (a >= _memSize)
+                LOG_THROW("BAD HEX address");
 
-            if( _buffer[a] != 0xFF )
-                LOG_THROW( "Double write" );
+            if (_buffer[a] != 0xFF)
+                LOG_THROW("Double write");
 
-            _buffer[a] = line.mid(9+i*2,2).toInt(&ok,16);
-            if( !ok )
-                LOG_THROW( "Bad HEX byte" );
+            _buffer[a] = line.mid(9 + i * 2, 2).toInt(&ok, 16);
+            if (!ok)
+                LOG_THROW("Bad HEX byte");
             bytes++;
         }
         break;
 
-    case 01: //---- END OF FILE record ---------------------------------------
+    case 01:            //---- END OF FILE record ---------------------------------------
         _file.seek(-1); // Force to end of file.
         break;
 
     case 02: //---- Segment address record -----------------------------------
-        if( len != 2 || addr != 0 )
-            LOG_THROW( "Bad HEX Segment Address record" );
-        _baseAddress = line.mid(9,4).toInt(0,16) << 4;
+        if (len != 2 || addr != 0)
+            LOG_THROW("Bad HEX Segment Address record");
+        _baseAddress = line.mid(9, 4).toInt(0, 16) << 4;
         break;
 
     case 04: //---- Extended Linear Address Record ---------------------------
-        if( len != 2 || addr != 0 )
-            LOG_THROW( "Bad HEX Extended Linear Address Record" );
-        _baseAddress = line.mid( 9,2).toInt(0,16) << 20
-                     | line.mid(11,2).toInt(0,16) << 16;
+        if (len != 2 || addr != 0)
+            LOG_THROW("Bad HEX Extended Linear Address Record");
+        _baseAddress = line.mid(9, 2).toInt(0, 16) << 20 | line.mid(11, 2).toInt(0, 16) << 16;
         break;
 
     default:
@@ -161,17 +160,16 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void HexFile::load(const QString& fileName)
+void HexFile::load(const QString &fileName)
 {
     Q_ASSERT(_buffer);
 
     _file.setFileName(fileName);
-    if( ! _file.open(QIODevice::ReadOnly) )
+    if (!_file.open(QIODevice::ReadOnly))
         LOG_THROW("Can't open HEX file");
 
     bytes = 0;
-    while( ! _file.atEnd() )
-    {
+    while (!_file.atEnd()) {
         PROGRESS(_file.pos(), _file.size());
         readLine();
     }
@@ -179,13 +177,13 @@
 
     _file.close();
 
-    LOG_TRACE( int(bytes/1024.0f) << "KB loaded ("
-            << int(bytes * 100.0f / _memSize) << "% of firmware area).");
+    LOG_TRACE(int(bytes / 1024.0f)
+              << "KB loaded (" << int(bytes * 100.0f / _memSize) << "% of firmware area).");
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-const unsigned char* HexFile::data() const
+const unsigned char *HexFile::data() const
 {
     Q_ASSERT(_buffer);
     return _buffer;
@@ -199,27 +197,26 @@
 
     unsigned short low = 0;
     unsigned short high = 0;
-    for(size_t i=0; i < _memSize; ++i)
-    {
-        low  += _buffer[i];
+    for (size_t i = 0; i < _memSize; ++i) {
+        low += _buffer[i];
         high += low;
     }
-    return (((unsigned int)high) << 16) + low;
+    return (((unsigned int) high) << 16) + low;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef FROG_MASTER
-void HexFile::saveEncrypted(const QString&, byte [16])
+void HexFile::saveEncrypted(const QString &, byte[16])
 {
-    LOG_THROW( "No encryption" );
+    LOG_THROW("No encryption");
 }
 #else
-void HexFile::saveEncrypted(const QString& fileName, byte secretKey[16])
+void HexFile::saveEncrypted(const QString &fileName, byte secretKey[16])
 {
     _file.setFileName(fileName);
-    if( ! _file.open(QIODevice::WriteOnly|QIODevice::Truncate) )
-        LOG_THROW( "Can't save to encrypted file" );
+    if (!_file.open(QIODevice::WriteOnly | QIODevice::Truncate))
+        LOG_THROW("Can't save to encrypted file");
 
     QTextStream out(&_file);
     out.setIntegerBase(16);
@@ -227,18 +224,16 @@
 
     //---- Generates 128 bits of random initialization vector ----------------
     Rijndael::CFB<128>::IV iv = {0};
-    Rijndael::ECB<128> PRNG; PRNG.setupEncrypt(secretKey);
-    for(int i=0; i<sizeof iv; ++i)
+    Rijndael::ECB<128> PRNG;
+    PRNG.setupEncrypt(secretKey);
+    for (int i = 0; i < sizeof iv; ++i)
         iv[i] = PRNG.get_random() % 256;
 
-    size_t bytes = 0;   // encrypted fake address
-    for(int i0 = 0; i0 < sizeof iv; i0+=0x10)
-    {
-        out << qSetFieldWidth(1) << ":"
-            << qSetFieldWidth(6) << bytes
-            << qSetFieldWidth(2);
-        for(int i=0; i<0x10; i++)
-            out << iv[i0+i];
+    size_t bytes = 0; // encrypted fake address
+    for (int i0 = 0; i0 < sizeof iv; i0 += 0x10) {
+        out << qSetFieldWidth(1) << ":" << qSetFieldWidth(6) << bytes << qSetFieldWidth(2);
+        for (int i = 0; i < 0x10; i++)
+            out << iv[i0 + i];
         out << qSetFieldWidth(1) << "\n";
         bytes += 0x10;
     }
@@ -250,15 +245,12 @@
     PROGRESS(0, _memSize);
 
     byte encrypted[32];
-    for(size_t addr = 0; addr < _memSize; addr += 0x10)
-    {
+    for (size_t addr = 0; addr < _memSize; addr += 0x10) {
         PROGRESS(addr, _memSize);
 
         enc.encrypt(_buffer + addr, encrypted);
-        out << qSetFieldWidth(1) << ":"
-            << qSetFieldWidth(6) << bytes
-            << qSetFieldWidth(2);
-        for(int i=0; i<16; i++)
+        out << qSetFieldWidth(1) << ":" << qSetFieldWidth(6) << bytes << qSetFieldWidth(2);
+        for (int i = 0; i < 16; i++)
             out << encrypted[i];
         out << qSetFieldWidth(1) << "\n";
         bytes += 16;
@@ -266,18 +258,11 @@
 
     //---- Process data ------------------------------------------------------
     unsigned int sum = checksum(); // 33.29.BD.1D
-    out << qSetFieldWidth(1) << ":"
-        << qSetFieldWidth(6) << bytes
-        << qSetFieldWidth(2)
-        << ((sum    ) & 0xff)
-        << ((sum>> 8) & 0xff)
-        << ((sum>>16) & 0xff)
-        << ((sum>>24) & 0xff)
-        << qSetFieldWidth(1) << "\n"
-        ;
+    out << qSetFieldWidth(1) << ":" << qSetFieldWidth(6) << bytes << qSetFieldWidth(2)
+        << ((sum) & 0xff) << ((sum >> 8) & 0xff) << ((sum >> 16) & 0xff) << ((sum >> 24) & 0xff)
+        << qSetFieldWidth(1) << "\n";
 
-    qDebug().nospace() << int( bytes/1024.0f) << "KB saved into "
-                       << fileName.section('/', -1);
+    qDebug().nospace() << int(bytes / 1024.0f) << "KB saved into " << fileName.section('/', -1);
 
     PROGRESS_RESET();
 }
@@ -285,33 +270,32 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void HexFile::loadEncrypted(const QString& fileName, unsigned char secretKey[16])
+void HexFile::loadEncrypted(const QString &fileName, unsigned char secretKey[16])
 {
     Q_ASSERT(_buffer);
 
     _file.setFileName(fileName);
-    if( ! _file.open(QIODevice::ReadOnly) )
-        LOG_THROW( "Cannot open HEX file "  << fileName );
+    if (!_file.open(QIODevice::ReadOnly))
+        LOG_THROW("Cannot open HEX file " << fileName);
 
     //---- Read 128 bits of initialization vector ----------------------------
     Rijndael::CFB<128>::IV iv = {0};
 
     unsigned int bytes = 0;
     bool ok = true;
-    for(size_t i0 = 0; i0 < sizeof iv; i0+=0x10)
-    {
+    for (size_t i0 = 0; i0 < sizeof iv; i0 += 0x10) {
         QByteArray line = _file.readLine();
-        if( line[0] != ':' )
-            LOG_THROW( "Bad HEX line" );
+        if (line[0] != ':')
+            LOG_THROW("Bad HEX line");
 
-        unsigned int readAddr = line.mid(1,6).toInt(&ok, 16);
-        if( !ok || readAddr != bytes )
-            LOG_THROW( "Bad HEX address" );
+        unsigned int readAddr = line.mid(1, 6).toInt(&ok, 16);
+        if (!ok || readAddr != bytes)
+            LOG_THROW("Bad HEX address");
 
-        for(int i=0; i<0x10; i++)
-            iv[i0+i] = line.mid(2*i+7,2).toInt(&ok, 16);
-        if( !ok )
-            LOG_THROW( "Bad HEX file format" );
+        for (int i = 0; i < 0x10; i++)
+            iv[i0 + i] = line.mid(2 * i + 7, 2).toInt(&ok, 16);
+        if (!ok)
+            LOG_THROW("Bad HEX file format");
 
         bytes += 0x10;
     }
@@ -320,39 +304,37 @@
     Rijndael::CFB<128> dec(secretKey, iv);
 
     //---- Process data ------------------------------------------------------
-    PROGRESS(0, (int)_memSize);
+    PROGRESS(0, (int) _memSize);
 
     Rijndael::Block encrypted;
-    for(size_t addr = 0; addr < _memSize; addr += 0x10)
-    {
-        PROGRESS((int)addr, (int)_memSize);
+    for (size_t addr = 0; addr < _memSize; addr += 0x10) {
+        PROGRESS((int) addr, (int) _memSize);
 
         QByteArray line = _file.readLine();
-        if( line[0] != ':' )
-            LOG_THROW( "Bad HEX line" );
+        if (line[0] != ':')
+            LOG_THROW("Bad HEX line");
 
-        unsigned int readAddr = line.mid(1,6).toInt(&ok, 16);
-        if( !ok || readAddr != bytes )
-            LOG_THROW( "Bad HEX address" );
+        unsigned int readAddr = line.mid(1, 6).toInt(&ok, 16);
+        if (!ok || readAddr != bytes)
+            LOG_THROW("Bad HEX address");
 
-        for(int i=0; i<0x10; i++)
-            encrypted[i] = line.mid(2*i+7,2).toInt(&ok, 16);
-        if( !ok )
-            LOG_THROW( "Bad HEX file format" );
+        for (int i = 0; i < 0x10; i++)
+            encrypted[i] = line.mid(2 * i + 7, 2).toInt(&ok, 16);
+        if (!ok)
+            LOG_THROW("Bad HEX file format");
         bytes += 0x10;
 
-        dec.decrypt(encrypted, *(Rijndael::Block*)(_buffer+addr));
+        dec.decrypt(encrypted, *(Rijndael::Block *) (_buffer + addr));
     }
     QByteArray line = _file.readLine();
-    if( bytes != (unsigned int)line.mid(1,6).toInt(&ok, 16) || !ok )
-        LOG_THROW( "Bad HEX address" );
+    if (bytes != (unsigned int) line.mid(1, 6).toInt(&ok, 16) || !ok)
+        LOG_THROW("Bad HEX address");
 
-    unsigned int sum =  line.mid( 7,2).toInt(&ok, 16)
-                     + (line.mid( 9,2).toInt(&ok, 16) << 8 )
-                     + (line.mid(11,2).toInt(&ok, 16) << 16)
-                     + (line.mid(13,2).toInt(&ok, 16) << 24);
-    if( sum != checksum() )
-        LOG_THROW( "Bad HEX checksum" );
+    unsigned int sum = line.mid(7, 2).toInt(&ok, 16) + (line.mid(9, 2).toInt(&ok, 16) << 8)
+                       + (line.mid(11, 2).toInt(&ok, 16) << 16)
+                       + (line.mid(13, 2).toInt(&ok, 16) << 24);
+    if (sum != checksum())
+        LOG_THROW("Bad HEX checksum");
 
     PROGRESS_RESET();
 }