pulled updates from main repository (had to remove patches to double hash)

CHANGELOG.md

@@ -1,3 +1,11 @@
+# v2.6.1
+ - [#168](https://github.com/xmrig/xmrig-proxy/issues/168) Added support for [mining algorithm negotiation](https://github.com/xmrig/xmrig-proxy/blob/dev/doc/STRATUM_EXT.md#1-mining-algorithm-negotiation).
+ - Added IPBC coin support, base algorithm `cn-lite` variant `ipbc`.
+ - [#581](https://github.com/xmrig/xmrig/issues/581) Added support for upcoming Stellite (XTL) fork, base algorithm `cn` variant `xtl`, variant can set now, no need do it after fork.
+ - Added support for **rig-id** stratum protocol extensions, compatible with xmr-stak.
+ - Changed behavior for option `variant=-1` for `cryptonight`, now variant is `1` by default, if you mine old coins need change `variant` to `0`.
+ - A lot of small fixes and better unification with proxy code.
+
 # v2.6.0-beta3
 - [#563](https://github.com/xmrig/xmrig/issues/563) **Added [advanced threads mode](https://github.com/xmrig/xmrig/issues/563), now possible configure each thread individually.**
 - [#255](https://github.com/xmrig/xmrig/issues/563) Low power mode extended to **triple**, **quard** and **penta** modes.
@@ -24,6 +32,11 @@
  - Added `--api-no-ipv6` and similar config option to disable IPv6 support for HTTP API.
  - Added `--api-no-restricted` to enable full access to api, this option has no effect if `--api-access-token` not specified.
 
+# v2.5.3
+- Fixed critical bug, in some cases miner was can't recovery connection and switch to failover pool, version 2.5.2 affected. If you use v2.6.0-beta3 this issue doesn't concern you.
+- [#499](https://github.com/xmrig/xmrig/issues/499) IPv6 support disabled for internal HTTP API.
+- Added workaround for nicehash.com if you use `cryptonightv7.<region>.nicehash.com` option `variant=1` will be set automatically.
+
 # v2.5.2
 - [#448](https://github.com/xmrig/xmrig/issues/478) Fixed broken reconnect.
 

CMakeLists.txt

@@ -4,6 +4,7 @@ project(xmrig)
 option(WITH_LIBCPUID "Use Libcpuid" ON)
 option(WITH_AEON     "CryptoNight-Lite support" ON)
 option(WITH_SUMO     "CryptoNight-Heavy support" ON)
+option(WITH_IPBC     "CryptoNight-IPBC support" ON)
 option(WITH_HTTPD    "HTTP REST API" ON)
 option(BUILD_STATIC  "Build static binary" OFF)
 
@@ -17,11 +18,24 @@ set(HEADERS
     src/common/config/CommonConfig.h
     src/common/config/ConfigLoader.h
     src/common/config/ConfigWatcher.h
+    src/common/Console.h
+    src/common/crypto/Algorithm.h
+    src/common/crypto/keccak.h
+    src/common/log/ConsoleLog.h
+    src/common/log/FileLog.h
+    src/common/log/Log.h
+    src/common/net/Client.h
+    src/common/net/Id.h
+    src/common/net/Job.h
+    src/common/net/Pool.h
+    src/common/net/Storage.h
+    src/common/net/strategies/FailoverStrategy.h
+    src/common/net/strategies/SinglePoolStrategy.h
+    src/common/net/SubmitResult.h
     src/common/Platform.h
     src/common/utils/c_str.h
     src/common/utils/mm_malloc.h
     src/common/xmrig.h
-    src/Console.h
     src/core/Config.cpp
     src/core/ConfigLoader_platform.h
     src/core/Controller.h
@@ -38,21 +52,10 @@ set(HEADERS
     src/interfaces/IThread.h
     src/interfaces/IWatcherListener.h
     src/interfaces/IWorker.h
-    src/log/ConsoleLog.h
-    src/log/FileLog.h
-    src/log/Log.h
     src/Mem.h
-    src/net/Client.h
-    src/net/Id.h
-    src/net/Job.h
     src/net/JobResult.h
     src/net/Network.h
-    src/net/Pool.h
-    src/net/Storage.h
     src/net/strategies/DonateStrategy.h
-    src/net/strategies/FailoverStrategy.h
-    src/net/strategies/SinglePoolStrategy.h
-    src/net/SubmitResult.h
     src/Summary.h
     src/version.h
     src/workers/CpuThread.h
@@ -67,7 +70,6 @@ set(HEADERS_CRYPTO
     src/crypto/c_blake256.h
     src/crypto/c_groestl.h
     src/crypto/c_jh.h
-    src/crypto/c_keccak.h
     src/crypto/c_skein.h
     src/crypto/CryptoNight.h
     src/crypto/CryptoNight_constants.h
@@ -91,22 +93,24 @@ set(SOURCES
     src/common/config/CommonConfig.cpp
     src/common/config/ConfigLoader.cpp
     src/common/config/ConfigWatcher.cpp
+    src/common/Console.cpp
+    src/common/crypto/Algorithm.cpp
+    src/common/crypto/keccak.cpp
+    src/common/log/ConsoleLog.cpp
+    src/common/log/FileLog.cpp
+    src/common/log/Log.cpp
+    src/common/net/Client.cpp
+    src/common/net/Job.cpp
+    src/common/net/Pool.cpp
+    src/common/net/strategies/FailoverStrategy.cpp
+    src/common/net/strategies/SinglePoolStrategy.cpp
+    src/common/net/SubmitResult.cpp
     src/common/Platform.cpp
-    src/Console.cpp
     src/core/Config.cpp
     src/core/Controller.cpp
-    src/log/ConsoleLog.cpp
-    src/log/FileLog.cpp
-    src/log/Log.cpp
     src/Mem.cpp
-    src/net/Client.cpp
-    src/net/Job.cpp
     src/net/Network.cpp
-    src/net/Pool.cpp
     src/net/strategies/DonateStrategy.cpp
-    src/net/strategies/FailoverStrategy.cpp
-    src/net/strategies/SinglePoolStrategy.cpp
-    src/net/SubmitResult.cpp
     src/Summary.cpp
     src/workers/CpuThread.cpp
     src/workers/Handle.cpp
@@ -118,7 +122,6 @@ set(SOURCES
    )
 
 set(SOURCES_CRYPTO
-    src/crypto/c_keccak.c
     src/crypto/c_groestl.c
     src/crypto/c_blake256.c
     src/crypto/c_jh.c
@@ -194,7 +197,7 @@ endif()
 CHECK_INCLUDE_FILE (syslog.h HAVE_SYSLOG_H)
 if (HAVE_SYSLOG_H)
     add_definitions(/DHAVE_SYSLOG_H)
-    set(SOURCES_SYSLOG src/log/SysLog.h src/log/SysLog.cpp)
+    set(SOURCES_SYSLOG src/common/log/SysLog.h src/common/log/SysLog.cpp)
 endif()
 
 if (NOT WITH_AEON)
@@ -205,6 +208,10 @@ if (NOT WITH_SUMO)
     add_definitions(/DXMRIG_NO_SUMO)
 endif()
 
+if (NOT WITH_IPBC)
+    add_definitions(/DXMRIG_NO_IPBC)
+endif()
+
 if (WITH_HTTPD)
     find_package(MHD)
 

README.md

@@ -1,7 +1,5 @@
 # XMRig
 
-:warning: **You must update miners to version 2.5 before April 6 due [Monero PoW change](https://getmonero.org/2018/02/11/PoW-change-and-key-reuse.html).**
-
 [![Github All Releases](https://img.shields.io/github/downloads/xmrig/xmrig/total.svg)](https://github.com/xmrig/xmrig/releases)
 [![GitHub release](https://img.shields.io/github/release/xmrig/xmrig/all.svg)](https://github.com/xmrig/xmrig/releases)
 [![GitHub Release Date](https://img.shields.io/github/release-date-pre/xmrig/xmrig.svg)](https://github.com/xmrig/xmrig/releases)
@@ -124,10 +122,10 @@ Please note performance is highly dependent on system load. The numbers above ar
 ## Release checksums
 ### SHA-256
 ```
-6b32fefb356b27caa2180be17755d09639f0654096a1a0c61e8f10f4f2ac1626 xmrig-2.6.0-beta3-xenial-amd64.tar.gz/xmrig-2.6.0-beta3/xmrig
+ca60d04204aa3195e8cd72887c7deced1a7c664e538256f138b5698d381ceb00 xmrig-2.6.2-xenial-amd64.tar.gz/xmrig-2.6.2/xmrig
-c8b40f4d7aac9d0cc7c3d02cadeac91b0bdb034aae2fb6b415d503272eabb987 xmrig-2.6.0-beta3-gcc-win32.zip/xmrig.exe
+49dc64eeecdbfffb452ad3cd7a0118d8640208b0b898b2901464d0be6183c169 xmrig-2.6.2-gcc-win32.zip/xmrig.exe
-32cf7958f97a23296186e38a4addb9cf234adcbd9c7914b15e4209a87fe272e7 xmrig-2.6.0-beta3-gcc-win64.zip/xmrig.exe
+56141544ac6d03565909b3043fab104bf40cadb32d53a12d821e1328bc50f087 xmrig-2.6.2-gcc-win64.zip/xmrig.exe
-4f176ee4c4be52701edc0d573cf9647c4aacbb4ff14975b80b98e6fe63068542 xmrig-2.6.0-beta3-msvc-win64.zip/xmrig.exe
+24661a8807f4b991c79e587e846aaea589720ed84d79afb41d14709a6fb908ce xmrig-2.6.2-msvc-win64.zip/xmrig.exe
 ```
 
 ## Contacts

doc/ALGORITHMS.md

@@ -0,0 +1,44 @@
+# Algorithms
+
+XMRig uses a different way to specify algorithms, compared to other miners.
+
+Algorithm selection splitted to 2 parts:
+
+ * Global base algorithm per miner or proxy instance, `algo` option. Possible values: `cryptonight`, `cryptonight-lite`, `cryptonight-heavy`.
+ * Algorithm variant specified separately for each pool, `variant` option.
+
+Possible variants for `cryptonight`:
+
+ * `0` Original cryptonight.
+ * `1` cryptonight variant 1, also known as cryptonight v7 or monero7.
+ * `"xtl"` Stellite coin variant.
+
+Possible variants for `cryptonight-lite`:
+
+ * `0` Original cryptonight-lite.
+ * `1` cryptonight-lite variant 1, also known as cryptonight-lite v7 or aeon7.
+ * `"ipbc"` IPBC coin variant.
+
+For `cryptonight-heavy` currently no variants.
+
+
+### Cheatsheet
+
+You mine **Sumokoin** or **Haven Protocol**?
+Your algorithm is `cryptonight-heavy` no variant option need.
+
+You mine **Aeon**, **TurtleCoin** or **IPBC**?
+Your base algorithm is `cryptonight-lite`:
+
+Variants:
+ * Aeon: `-1` autodetect. `0` right now, `1` after fork.
+ * TurtleCoin: `1`.
+ * IPBC: `"ipbc"`.
+
+In all other cases base algorithm is `cryptonight`.
+
+### Mining algorithm negotiation
+If your pool support [mining algorithm negotiation](https://github.com/xmrig/xmrig-proxy/issues/168) miner will choice proper variant automaticaly and if you choice wrong base algorithm you will see error message.
+
+Pools with mining algorithm negotiation support.
+ * [www.hashvault.pro](https://www.hashvault.pro/)

res/app.rc

@@ -4,8 +4,8 @@
 IDI_ICON1    ICON    DISCARDABLE    "app.ico"
 
 VS_VERSION_INFO VERSIONINFO
-  FILEVERSION APP_VER_MAJOR,APP_VER_MINOR,APP_VER_BUILD,APP_VER_REV
+  FILEVERSION APP_VER_MAJOR,APP_VER_MINOR,APP_VER_PATCH,0
-  PRODUCTVERSION APP_VER_MAJOR,APP_VER_MINOR,APP_VER_BUILD,APP_VER_REV
+  PRODUCTVERSION APP_VER_MAJOR,APP_VER_MINOR,APP_VER_PATCH,0
   FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
   FILEFLAGS VS_FF_DEBUG

src/App.cpp

@@ -28,15 +28,13 @@
 
 #include "api/Api.h"
 #include "App.h"
+#include "common/Console.h"
+#include "common/log/Log.h"
 #include "common/Platform.h"
-#include "Console.h"
 #include "core/Config.h"
 #include "core/Controller.h"
 #include "Cpu.h"
 #include "crypto/CryptoNight.h"
-#include "log/ConsoleLog.h"
-#include "log/FileLog.h"
-#include "log/Log.h"
 #include "Mem.h"
 #include "net/Network.h"
 #include "Summary.h"

src/App_unix.cpp

@@ -29,9 +29,9 @@
 
 
 #include "App.h"
+#include "common/log/Log.h"
 #include "core/Config.h"
 #include "core/Controller.h"
-#include "log/Log.h"
 
 
 void App::background()

src/Mem_unix.cpp

@@ -27,10 +27,10 @@
 #include <sys/mman.h>
 
 
+#include "common/log/Log.h"
 #include "common/utils/mm_malloc.h"
 #include "common/xmrig.h"
 #include "crypto/CryptoNight.h"
-#include "log/Log.h"
 #include "Mem.h"
 
 

src/Mem_win.cpp

@@ -29,11 +29,11 @@
 #include <tchar.h>
 
 
+#include "common/log/Log.h"
 #include "common/utils/mm_malloc.h"
 #include "common/xmrig.h"
 #include "crypto/CryptoNight.h"
 #include "crypto/CryptoNight_constants.h"
-#include "log/Log.h"
 #include "Mem.h"
 
 

src/Summary.cpp

@@ -27,12 +27,12 @@
 #include <uv.h>
 
 
+#include "common/log/Log.h"
+#include "common/net/Pool.h"
 #include "core/Config.h"
 #include "core/Controller.h"
 #include "Cpu.h"
-#include "log/Log.h"
 #include "Mem.h"
-#include "net/Pool.h"
 #include "Summary.h"
 #include "version.h"
 
@@ -104,7 +104,7 @@ static void print_threads(xmrig::Config *config)
 
         Log::i()->text(config->isColors() ? "\x1B[01;32m * \x1B[01;37mTHREADS:      \x1B[01;36m%d\x1B[01;37m, %s, av=%d, %sdonate=%d%%%s" : " * THREADS:      %d, %s, av=%d, %sdonate=%d%%%s",
                        config->threadsCount(),
-                       config->algoName(),
+                       config->algorithm().name(),
                        config->algoVariant(),
                        config->isColors() && config->donateLevel() == 0 ? "\x1B[01;31m" : "",
                        config->donateLevel(),
@@ -113,7 +113,7 @@ static void print_threads(xmrig::Config *config)
     else {
         Log::i()->text(config->isColors() ? "\x1B[01;32m * \x1B[01;37mTHREADS:      \x1B[01;36m%d\x1B[01;37m, %s, %sdonate=%d%%" : " * THREADS:      %d, %s, %sdonate=%d%%",
                        config->threadsCount(),
-                       config->algoName(),
+                       config->algorithm().name(),
                        config->isColors() && config->donateLevel() == 0 ? "\x1B[01;31m" : "",
                        config->donateLevel());
     }
@@ -132,8 +132,8 @@ static void print_pools(xmrig::Config *config)
     }
 
 #   ifdef APP_DEBUG
-    for (size_t i = 0; i < pools.size(); ++i) {
+    for (const Pool &pool : pools) {
-        Log::i()->text("%s:%d, user: %s, pass: %s, ka: %d, nicehash: %d", pools[i].host(), pools[i].port(), pools[i].user(), pools[i].password(), pools[i].keepAlive(), pools[i].isNicehash());
+        pool.print();
     }
 #   endif
 }

src/api/ApiRouter.cpp

@@ -35,13 +35,14 @@
 #include "api/ApiRouter.h"
 #include "common/api/HttpReply.h"
 #include "common/api/HttpRequest.h"
+#include "common/crypto/keccak.h"
+#include "common/net/Job.h"
 #include "common/Platform.h"
 #include "core/Config.h"
 #include "core/Controller.h"
 #include "Cpu.h"
 #include "interfaces/IThread.h"
 #include "Mem.h"
-#include "net/Job.h"
 #include "rapidjson/document.h"
 #include "rapidjson/prettywriter.h"
 #include "rapidjson/stringbuffer.h"
@@ -50,12 +51,6 @@
 #include "workers/Workers.h"
 
 
-extern "C"
-{
-#include "crypto/c_keccak.h"
-}
-
-
 static inline double normalize(double d)
 {
     if (!isnormal(d)) {
@@ -171,7 +166,7 @@ void ApiRouter::genId()
             memcpy(input, interfaces[i].phys_addr, addrSize);
             memcpy(input + addrSize, APP_KIND, strlen(APP_KIND));
 
-            keccak(input, static_cast<int>(inSize), hash, sizeof(hash));
+            xmrig::keccak(input, inSize, hash);
             Job::toHex(hash, 8, m_id);
 
             delete [] input;
@@ -249,7 +244,7 @@ void ApiRouter::getMiner(rapidjson::Document &doc) const
     doc.AddMember("kind",         APP_KIND, allocator);
     doc.AddMember("ua",           rapidjson::StringRef(Platform::userAgent()), allocator);
     doc.AddMember("cpu",          cpu, allocator);
-    doc.AddMember("algo",         rapidjson::StringRef(m_controller->config()->algoName()), allocator);
+    doc.AddMember("algo",         rapidjson::StringRef(m_controller->config()->algorithm().name()), allocator);
     doc.AddMember("hugepages",    Workers::hugePages() > 0, allocator);
     doc.AddMember("donate_level", m_controller->config()->donateLevel(), allocator);
 }

src/api/NetworkState.cpp

@@ -4,8 +4,8 @@
  * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
  * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
  * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright 2016-2017 XMRig       <support@xmrig.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- *
+ * Copyright 2016-2018 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -29,7 +29,7 @@
 
 
 #include "api/NetworkState.h"
-#include "net/SubmitResult.h"
+#include "common/net/SubmitResult.h"
 
 
 NetworkState::NetworkState() :

src/common/Console.cpp

@@ -4,8 +4,8 @@
  * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
  * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
  * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright 2016-2017 XMRig       <support@xmrig.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- *
+ * Copyright 2016-2018 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@
  */
 
 
-#include "Console.h"
+#include "common/Console.h"
 #include "interfaces/IConsoleListener.h"
 
 

src/common/Console.h

@@ -4,8 +4,8 @@
  * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
  * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
  * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright 2016-2017 XMRig       <support@xmrig.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- *
+ * Copyright 2016-2018 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by

src/common/Platform_unix.cpp

@@ -4,8 +4,8 @@
  * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
  * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
  * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright 2016-2017 XMRig       <support@xmrig.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- *
+ * Copyright 2016-2018 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by

src/common/api/Httpd.cpp

@@ -30,7 +30,7 @@
 #include "common/api/Httpd.h"
 #include "common/api/HttpReply.h"
 #include "common/api/HttpRequest.h"
-#include "log/Log.h"
+#include "common/log/Log.h"
 
 
 Httpd::Httpd(int port, const char *accessToken, bool IPv6, bool restricted) :
@@ -81,7 +81,12 @@ bool Httpd::start()
         return false;
     }
 
+#   if MHD_VERSION >= 0x00093900
     uv_timer_start(&m_timer, Httpd::onTimer, kIdleInterval, kIdleInterval);
+#   else
+    uv_timer_start(&m_timer, Httpd::onTimer, kActiveInterval, kActiveInterval);
+#   endif
+
     return true;
 }
 
@@ -107,6 +112,7 @@ void Httpd::run()
 {
     MHD_run(m_daemon);
 
+#   if MHD_VERSION >= 0x00093900
     const MHD_DaemonInfo *info = MHD_get_daemon_info(m_daemon, MHD_DAEMON_INFO_CURRENT_CONNECTIONS);
     if (m_idle && info->num_connections) {
         uv_timer_set_repeat(&m_timer, kActiveInterval);
@@ -116,6 +122,7 @@ void Httpd::run()
         uv_timer_set_repeat(&m_timer, kIdleInterval);
         m_idle = true;
     }
+#   endif
 }
 
 

src/common/config/CommonConfig.cpp

@@ -30,16 +30,14 @@
 
 
 #include "common/config/CommonConfig.h"
+#include "common/log/Log.h"
 #include "donate.h"
-#include "log/Log.h"
-#include "net/Pool.h"
 #include "rapidjson/document.h"
 #include "rapidjson/filewritestream.h"
 #include "rapidjson/prettywriter.h"
 
 
 xmrig::CommonConfig::CommonConfig() :
-    m_algorithm(CRYPTONIGHT),
     m_adjusted(false),
     m_apiIPv6(false),
     m_apiRestricted(true),
@@ -57,7 +55,8 @@ xmrig::CommonConfig::CommonConfig() :
     m_donateLevel(kDefaultDonateLevel),
     m_printTime(60),
     m_retries(5),
-    m_retryPause(5)
+    m_retryPause(5),
+    m_state(NoneState)
 {
     m_pools.push_back(Pool());
 
@@ -73,28 +72,40 @@ xmrig::CommonConfig::~CommonConfig()
 }
 
 
-bool xmrig::CommonConfig::adjust()
+bool xmrig::CommonConfig::finalize()
 {
-    if (m_adjusted) {
+    if (m_state == ReadyState) {
+        return true;
+    }
+
+    if (m_state == ErrorState) {
         return false;
     }
 
-    m_adjusted = true;
+    if (!m_algorithm.isValid()) {
-
+        m_algorithm.setAlgo(CRYPTONIGHT);
-    for (Pool &pool : m_pools) {
-        pool.adjust(algorithm());
     }
 
+    for (Pool &pool : m_pools) {
+        pool.adjust(m_algorithm.algo());
+
+        if (pool.isValid() && pool.algorithm().isValid()) {
+            m_activePools.push_back(std::move(pool));
+        }
+    }
+
+    m_pools.clear();
+
+    if (m_activePools.empty()) {
+        m_state = ErrorState;
+        return false;
+    }
+
+    m_state = ReadyState;
     return true;
 }
 
 
-bool xmrig::CommonConfig::isValid() const
-{
-    return m_pools[0].isValid() && m_algorithm != INVALID_ALGO;
-}
-
-
 bool xmrig::CommonConfig::parseBoolean(int key, bool enable)
 {
     switch (key) {
@@ -142,7 +153,7 @@ bool xmrig::CommonConfig::parseString(int key, const char *arg)
 {
     switch (key) {
     case AlgorithmKey: /* --algo */
-        setAlgo(arg);
+        m_algorithm.parseAlgorithm(arg);
         break;
 
     case UserpassKey: /* --userpass */
@@ -178,6 +189,14 @@ bool xmrig::CommonConfig::parseString(int key, const char *arg)
         m_pools.back().setPassword(arg);
         break;
 
+    case RigIdKey: /* --rig-id */
+        m_pools.back().setRigId(arg);
+        break;
+
+    case VariantKey: /* --variant */
+        m_pools.back().algorithm().parseVariant(arg);
+        break;
+
     case LogFileKey: /* --log-file */
         m_logFile = arg;
         break;
@@ -196,7 +215,6 @@ bool xmrig::CommonConfig::parseString(int key, const char *arg)
 
     case RetriesKey:     /* --retries */
     case RetryPauseKey:  /* --retry-pause */
-    case VariantKey:     /* --variant */
     case ApiPort:        /* --api-port */
     case PrintTimeKey:   /* --cpu-priority */
         return parseUint64(key, strtol(arg, nullptr, 10));
@@ -205,7 +223,7 @@ bool xmrig::CommonConfig::parseString(int key, const char *arg)
     case SyslogKey:     /* --syslog */
     case KeepAliveKey:  /* --keepalive */
     case NicehashKey:   /* --nicehash */
-    case ApiIPv6Key:       /* --api-ipv6 */
+    case ApiIPv6Key:    /* --api-ipv6 */
         return parseBoolean(key, true);
 
     case ColorKey:         /* --no-color */
@@ -296,7 +314,7 @@ bool xmrig::CommonConfig::parseInt(int key, int arg)
         break;
 
     case VariantKey: /* --variant */
-        m_pools.back().setVariant(arg);
+        m_pools.back().algorithm().parseVariant(arg);
         break;
 
     case DonateLevelKey: /* --donate-level */
@@ -323,9 +341,3 @@ bool xmrig::CommonConfig::parseInt(int key, int arg)
 
     return true;
 }
-
-
-void xmrig::CommonConfig::setAlgo(const char *algo)
-{
-    m_algorithm = Pool::algorithm(algo);
-}

src/common/config/CommonConfig.h

@@ -28,10 +28,10 @@
 #include <vector>
 
 
+#include "common/net/Pool.h"
 #include "common/utils/c_str.h"
 #include "common/xmrig.h"
 #include "interfaces/IConfig.h"
-#include "net/Pool.h"
 
 
 namespace xmrig {
@@ -43,18 +43,17 @@ public:
     CommonConfig();
     ~CommonConfig();
 
-    inline Algo algorithm() const                  { return m_algorithm; }
     inline bool isApiIPv6() const                  { return m_apiIPv6; }
     inline bool isApiRestricted() const            { return m_apiRestricted; }
     inline bool isBackground() const               { return m_background; }
     inline bool isColors() const                   { return m_colors; }
     inline bool isSyslog() const                   { return m_syslog; }
-    inline const char *algoName() const            { return Pool::algoName(m_algorithm); }
+    inline const Algorithm &algorithm() const      { return m_algorithm; }
     inline const char *apiToken() const            { return m_apiToken.data(); }
     inline const char *apiWorkerId() const         { return m_apiWorkerId.data(); }
     inline const char *logFile() const             { return m_logFile.data(); }
     inline const char *userAgent() const           { return m_userAgent.data(); }
-    inline const std::vector<Pool> &pools() const  { return m_pools; }
+    inline const std::vector<Pool> &pools() const  { return m_activePools; }
     inline int apiPort() const                     { return m_apiPort; }
     inline int donateLevel() const                 { return m_donateLevel; }
     inline int printTime() const                   { return m_printTime; }
@@ -66,15 +65,20 @@ public:
     inline const char *fileName() const override   { return m_fileName.data(); }
 
 protected:
-    bool adjust() override;
+    enum State {
-    bool isValid() const override;
+        NoneState,
+        ReadyState,
+        ErrorState
+    };
+
+    bool finalize() override;
     bool parseBoolean(int key, bool enable) override;
     bool parseString(int key, const char *arg) override;
     bool parseUint64(int key, uint64_t arg) override;
     bool save() override;
     void setFileName(const char *fileName) override;
 
-    Algo m_algorithm;
+    Algorithm m_algorithm;
     bool m_adjusted;
     bool m_apiIPv6;
     bool m_apiRestricted;
@@ -87,6 +91,8 @@ protected:
     int m_printTime;
     int m_retries;
     int m_retryPause;
+    State m_state;
+    std::vector<Pool> m_activePools;
     std::vector<Pool> m_pools;
     xmrig::c_str m_apiToken;
     xmrig::c_str m_apiWorkerId;
@@ -96,7 +102,6 @@ protected:
 
 private:
     bool parseInt(int key, int arg);
-    void setAlgo(const char *algo);
 };
 
 

src/common/config/ConfigLoader.cpp

@@ -34,12 +34,12 @@
 
 #include "common/config/ConfigLoader.h"
 #include "common/config/ConfigWatcher.h"
+#include "common/net/Pool.h"
 #include "common/Platform.h"
 #include "core/ConfigCreator.h"
 #include "core/ConfigLoader_platform.h"
 #include "interfaces/IConfig.h"
 #include "interfaces/IWatcherListener.h"
-#include "net/Pool.h"
 #include "rapidjson/document.h"
 #include "rapidjson/error/en.h"
 #include "rapidjson/filereadstream.h"
@@ -108,9 +108,8 @@ bool xmrig::ConfigLoader::loadFromJSON(xmrig::IConfig *config, const rapidjson::
     }
 
     config->parseJSON(doc);
-    config->adjust();
 
-    return config->isValid();
+    return config->finalize();
 }
 
 
@@ -163,11 +162,14 @@ xmrig::IConfig *xmrig::ConfigLoader::load(int argc, char **argv, IConfigCreator
         return nullptr;
     }
 
-    if (!config->isValid()) {
+    if (!config->finalize()) {
+        delete config;
+
+        config = m_creator->create();
         loadFromFile(config, Platform::defaultConfigName());
     }
 
-    if (!config->isValid()) {
+    if (!config->finalize()) {
         fprintf(stderr, "No valid configuration found. Exiting.\n");
         delete config;
         return nullptr;
@@ -177,7 +179,6 @@ xmrig::IConfig *xmrig::ConfigLoader::load(int argc, char **argv, IConfigCreator
         m_watcher = new xmrig::ConfigWatcher(config->fileName(), creator, listener);
     }
 
-    config->adjust();
     return config;
 }
 

src/common/config/ConfigWatcher.cpp

@@ -27,9 +27,9 @@
 
 #include "common/config/ConfigLoader.h"
 #include "common/config/ConfigWatcher.h"
+#include "common/log/Log.h"
 #include "core/ConfigCreator.h"
 #include "interfaces/IWatcherListener.h"
-#include "log/Log.h"
 
 
 xmrig::ConfigWatcher::ConfigWatcher(const char *path, IConfigCreator *creator, IWatcherListener *listener) :
@@ -83,7 +83,7 @@ void xmrig::ConfigWatcher::reload()
     IConfig *config = m_creator->create();
     ConfigLoader::loadFromFile(config, m_path.data());
 
-    if (!config->isValid()) {
+    if (!config->finalize()) {
         LOG_ERR("reloading failed");
 
         delete config;

src/common/crypto/Algorithm.cpp

@@ -0,0 +1,219 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2016-2018 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+
+#include "common/crypto/Algorithm.h"
+
+
+#ifdef _MSC_VER
+#   define strncasecmp _strnicmp
+#   define strcasecmp  _stricmp
+#endif
+
+
+#ifndef ARRAY_SIZE
+#   define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+#endif
+
+
+struct AlgoData
+{
+    const char *name;
+    const char *shortName;
+    xmrig::Algo algo;
+    xmrig::Variant variant;
+};
+
+
+static AlgoData const algorithms[] = {
+    { "cryptonight",           "cn",           xmrig::CRYPTONIGHT,       xmrig::VARIANT_AUTO },
+    { "cryptonight/0",         "cn/0",         xmrig::CRYPTONIGHT,       xmrig::VARIANT_0    },
+    { "cryptonight/1",         "cn/1",         xmrig::CRYPTONIGHT,       xmrig::VARIANT_1    },
+    { "cryptonight/xtl",       "cn/xtl",       xmrig::CRYPTONIGHT,       xmrig::VARIANT_XTL  },
+
+#   ifndef XMRIG_NO_AEON
+    { "cryptonight-lite",      "cn-lite",      xmrig::CRYPTONIGHT_LITE,  xmrig::VARIANT_AUTO },
+    { "cryptonight-lite/0",    "cn-lite/0",    xmrig::CRYPTONIGHT_LITE,  xmrig::VARIANT_0    },
+    { "cryptonight-lite/1",    "cn-lite/1",    xmrig::CRYPTONIGHT_LITE,  xmrig::VARIANT_1    },
+    { "cryptonight-lite/ipbc", "cn-lite/ipbc", xmrig::CRYPTONIGHT_LITE,  xmrig::VARIANT_IPBC },
+#   endif
+
+#   ifndef XMRIG_NO_SUMO
+    { "cryptonight-heavy",     "cn-heavy",     xmrig::CRYPTONIGHT_HEAVY, xmrig::VARIANT_0    },
+#   endif
+};
+
+
+#ifdef XMRIG_PROXY_PROJECT
+static AlgoData const xmrStakAlgorithms[] = {
+    { "cryptonight-monerov7",    nullptr, xmrig::CRYPTONIGHT,      xmrig::VARIANT_1    },
+    { "cryptonight_v7",          nullptr, xmrig::CRYPTONIGHT,      xmrig::VARIANT_1    },
+    { "cryptonight_v7_stellite", nullptr, xmrig::CRYPTONIGHT,      xmrig::VARIANT_XTL  },
+    { "cryptonight_lite",        nullptr, xmrig::CRYPTONIGHT_LITE, xmrig::VARIANT_0    },
+    { "cryptonight-aeonv7",      nullptr, xmrig::CRYPTONIGHT_LITE, xmrig::VARIANT_1    },
+    { "cryptonight_lite_v7",     nullptr, xmrig::CRYPTONIGHT_LITE, xmrig::VARIANT_1    },
+    { "cryptonight_lite_v7_xor", nullptr, xmrig::CRYPTONIGHT_LITE, xmrig::VARIANT_IPBC },
+};
+#endif
+
+
+static const char *variants[] = {
+    "0",
+    "1",
+    "ipbc",
+    "xtl"
+};
+
+
+bool xmrig::Algorithm::isValid() const
+{
+    if (m_algo == INVALID_ALGO) {
+        return false;
+    }
+
+    for (size_t i = 0; i < ARRAY_SIZE(algorithms); i++) {
+        if (algorithms[i].algo == m_algo && algorithms[i].variant == m_variant) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+const char *xmrig::Algorithm::variantName() const
+{
+    if (m_variant == VARIANT_AUTO) {
+        return "auto";
+    }
+
+    return variants[m_variant];
+}
+
+
+void xmrig::Algorithm::parseAlgorithm(const char *algo)
+{
+    m_algo    = INVALID_ALGO;
+    m_variant = VARIANT_AUTO;
+
+    assert(algo != nullptr);
+    if (algo == nullptr) {
+        return;
+    }
+
+    for (size_t i = 0; i < ARRAY_SIZE(algorithms); i++) {
+        if ((strcasecmp(algo, algorithms[i].name) == 0) || (strcasecmp(algo, algorithms[i].shortName) == 0)) {
+            m_algo    = algorithms[i].algo;
+            m_variant = algorithms[i].variant;
+            break;
+        }
+    }
+
+    if (m_algo == INVALID_ALGO) {
+        assert(false);
+    }
+}
+
+
+void xmrig::Algorithm::parseVariant(const char *variant)
+{
+    if (m_algo == CRYPTONIGHT_HEAVY) {
+        m_variant = VARIANT_0;
+        return;
+    }
+
+    m_variant = VARIANT_AUTO;
+
+    for (size_t i = 0; i < ARRAY_SIZE(variants); i++) {
+        if (strcasecmp(variant, variants[i]) == 0) {
+            m_variant = static_cast<Variant>(i);
+            break;
+        }
+    }
+}
+
+
+void xmrig::Algorithm::parseVariant(int variant)
+{
+    if (variant >= VARIANT_AUTO && variant <= VARIANT_XTL) {
+       m_variant = static_cast<Variant>(variant);
+    }
+    else {
+        assert(false);
+    }
+}
+
+
+void xmrig::Algorithm::setAlgo(Algo algo)
+{
+    m_algo = algo;
+
+    if (m_algo == CRYPTONIGHT_HEAVY) {
+        m_variant = VARIANT_0;
+    }
+}
+
+
+#ifdef XMRIG_PROXY_PROJECT
+void xmrig::Algorithm::parseXmrStakAlgorithm(const char *algo)
+{
+    m_algo    = INVALID_ALGO;
+    m_variant = VARIANT_AUTO;
+
+    assert(algo != nullptr);
+    if (algo == nullptr) {
+        return;
+    }
+
+    for (size_t i = 0; i < ARRAY_SIZE(xmrStakAlgorithms); i++) {
+        if (strcasecmp(algo, xmrStakAlgorithms[i].name) == 0) {
+            m_algo    = xmrStakAlgorithms[i].algo;
+            m_variant = xmrStakAlgorithms[i].variant;
+            break;
+        }
+    }
+
+    if (m_algo == INVALID_ALGO) {
+        assert(false);
+    }
+}
+#endif
+
+
+const char *xmrig::Algorithm::name(bool shortName) const
+{
+    for (size_t i = 0; i < ARRAY_SIZE(algorithms); i++) {
+        if (algorithms[i].algo == m_algo && algorithms[i].variant == m_variant) {
+            return shortName ? algorithms[i].shortName : algorithms[i].name;
+        }
+    }
+
+    return "invalid";
+}

src/common/crypto/Algorithm.h

@@ -0,0 +1,91 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2016-2018 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ALGORITHM_H__
+#define __ALGORITHM_H__
+
+
+#include <vector>
+
+
+#include "common/xmrig.h"
+
+
+namespace xmrig {
+
+
+class Algorithm
+{
+public:
+    inline Algorithm() :
+        m_algo(INVALID_ALGO),
+        m_variant(VARIANT_AUTO)
+    {}
+
+    inline Algorithm(Algo algo, Variant variant) :
+        m_variant(variant)
+    {
+        setAlgo(algo);
+    }
+
+    inline Algorithm(const char *algo)
+    {
+        parseAlgorithm(algo);
+    }
+
+    bool isEqual(const Algorithm &other) const { return m_algo == other.m_algo && m_variant == other.m_variant; }
+    inline Algo algo() const                   { return m_algo; }
+    inline const char *name() const            { return name(false); }
+    inline const char *shortName() const       { return name(true); }
+    inline Variant variant() const             { return m_variant; }
+    inline void setVariant(Variant variant)    { m_variant = variant; }
+
+    inline bool operator!=(const Algorithm &other) const  { return !isEqual(other); }
+    inline bool operator==(const Algorithm &other) const  { return isEqual(other); }
+
+    bool isValid() const;
+    const char *variantName() const;
+    void parseAlgorithm(const char *algo);
+    void parseVariant(const char *variant);
+    void parseVariant(int variant);
+    void setAlgo(Algo algo);
+
+#   ifdef XMRIG_PROXY_PROJECT
+    void parseXmrStakAlgorithm(const char *algo);
+#   endif
+
+private:
+    const char *name(bool shortName) const;
+
+    Algo m_algo;
+    Variant m_variant;
+};
+
+
+typedef std::vector<xmrig::Algorithm> Algorithms;
+
+
+} /* namespace xmrig */
+
+#endif /* __ALGORITHM_H__ */

src/common/crypto/keccak.cpp

@@ -1,10 +1,35 @@
-// keccak.c
+/* XMRig
-// 19-Nov-11  Markku-Juhani O. Saarinen <mjos@iki.fi>
+ * Copyright 2010      Jeff Garzik               <jgarzik@pobox.com>
-// A baseline Keccak (3rd round) implementation.
+ * Copyright 2011      Markku-Juhani O. Saarinen <mjos@iki.fi>
+ * Copyright 2012-2014 pooler                    <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones               <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466                  <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee                 <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak                  <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2016-2018 XMRig                     <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
 
 #include <stdint.h>
 #include <memory.h>
 
+
+#include "common/crypto/keccak.h"
+
+
 #define HASH_DATA_AREA 136
 #define KECCAK_ROUNDS 24
 
@@ -26,7 +51,7 @@ const uint64_t keccakf_rndc[24] =
 
 // update the state with given number of rounds
 
-void keccakf(uint64_t st[25], int rounds)
+void xmrig::keccakf(uint64_t st[25], int rounds)
 {
     int i, j, round;
     uint64_t t, bc[5];
@@ -139,7 +164,8 @@ void keccakf(uint64_t st[25], int rounds)
 // compute a keccak hash (md) of given byte length from "in"
 typedef uint64_t state_t[25];
 
-void keccak(const uint8_t *in, int inlen, uint8_t *md, int mdlen)
+
+void xmrig::keccak(const uint8_t *in, int inlen, uint8_t *md, int mdlen)
 {
     state_t st;
     uint8_t temp[144];
@@ -151,9 +177,11 @@ void keccak(const uint8_t *in, int inlen, uint8_t *md, int mdlen)
     memset(st, 0, sizeof(st));
 
     for ( ; inlen >= rsiz; inlen -= rsiz, in += rsiz) {
-        for (i = 0; i < rsizw; i++)
+        for (i = 0; i < rsizw; i++) {
             st[i] ^= ((uint64_t *) in)[i];
-        keccakf(st, KECCAK_ROUNDS);
+        }
+
+        xmrig::keccakf(st, KECCAK_ROUNDS);
     }
 
     // last block and padding
@@ -162,15 +190,11 @@ void keccak(const uint8_t *in, int inlen, uint8_t *md, int mdlen)
     memset(temp + inlen, 0, rsiz - inlen);
     temp[rsiz - 1] |= 0x80;
 
-    for (i = 0; i < rsizw; i++)
+    for (i = 0; i < rsizw; i++) {
         st[i] ^= ((uint64_t *) temp)[i];
+    }
 
     keccakf(st, KECCAK_ROUNDS);
 
     memcpy(md, st, mdlen);
 }
-
-void keccak1600(const uint8_t *in, int inlen, uint8_t *md)
-{
-    keccak(in, inlen, md, sizeof(state_t));
-}

src/common/crypto/keccak.h

@@ -0,0 +1,49 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik               <jgarzik@pobox.com>
+ * Copyright 2011      Markku-Juhani O. Saarinen <mjos@iki.fi>
+ * Copyright 2012-2014 pooler                    <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones               <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466                  <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee                 <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak                  <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2016-2018 XMRig                     <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef KECCAK_H_
+#define KECCAK_H_
+
+#include <stdint.h>
+#include <string.h>
+
+
+namespace xmrig {
+
+// compute a keccak hash (md) of given byte length from "in"
+void keccak(const uint8_t *in, int inlen, uint8_t *md, int mdlen);
+
+
+inline void keccak(const uint8_t *in, size_t inlen, uint8_t *md)
+{
+    keccak(in, static_cast<int>(inlen), md, 200);
+}
+
+// update the state
+void keccakf(uint64_t st[25], int norounds);
+
+} /* namespace xmrig */
+
+#endif /* KECCAK_H_ */

src/common/log/ConsoleLog.cpp

@@ -34,10 +34,10 @@
 #endif
 
 
+#include "common/log/ConsoleLog.h"
+#include "common/log/Log.h"
 #include "core/Config.h"
 #include "core/Controller.h"
-#include "log/ConsoleLog.h"
-#include "log/Log.h"
 
 
 ConsoleLog::ConsoleLog(xmrig::Controller *controller) :

src/common/log/FileLog.cpp

@@ -29,7 +29,7 @@
 #include <time.h>
 
 
-#include "log/FileLog.h"
+#include "common/log/FileLog.h"
 
 
 FileLog::FileLog(const char *fileName)

src/common/log/Log.cpp

@@ -29,8 +29,8 @@
 #include <time.h>
 
 
+#include "common/log/Log.h"
 #include "interfaces/ILogBackend.h"
-#include "log/Log.h"
 
 
 Log *Log::m_self = nullptr;
@@ -50,6 +50,8 @@ void Log::message(Log::Level level, const char* fmt, ...)
         va_end(copy);
     }
 
+    va_end(args);
+
     uv_mutex_unlock(&m_mutex);
 }
 

src/common/log/Log.h

@@ -80,6 +80,18 @@ private:
 };
 
 
+#define RED_BOLD(x)     "\x1B[1;31m" x "\x1B[0m"
+#define RED(x)          "\x1B[0;31m" x "\x1B[0m"
+#define GREEN_BOLD(x)   "\x1B[1;32m" x "\x1B[0m"
+#define GREEN(x)        "\x1B[0;32m" x "\x1B[0m"
+#define MAGENTA_BOLD(x) "\x1B[1;35m" x "\x1B[0m"
+#define MAGENTA(x)      "\x1B[0;35m" x "\x1B[0m"
+#define CYAN_BOLD(x)    "\x1B[1;36m" x "\x1B[0m"
+#define CYAN(x)         "\x1B[0;36m" x "\x1B[0m"
+#define WHITE_BOLD(x)   "\x1B[1;37m" x "\x1B[0m"
+#define WHITE(x)        "\x1B[0;37m" x "\x1B[0m"
+
+
 #define LOG_ERR(x, ...)    Log::i()->message(Log::ERR,     x, ##__VA_ARGS__)
 #define LOG_WARN(x, ...)   Log::i()->message(Log::WARNING, x, ##__VA_ARGS__)
 #define LOG_NOTICE(x, ...) Log::i()->message(Log::NOTICE,  x, ##__VA_ARGS__)

src/common/log/SysLog.cpp

@@ -25,7 +25,7 @@
 #include <syslog.h>
 
 
-#include "log/SysLog.h"
+#include "common/log/SysLog.h"
 #include "version.h"
 
 

src/common/net/Client.cpp

@@ -29,22 +29,16 @@
 #include <utility>
 
 
+#include "common/log/Log.h"
+#include "common/net/Client.h"
 #include "interfaces/IClientListener.h"
-#include "log/Log.h"
+#include "net/JobResult.h"
-#include "net/Client.h"
 #include "rapidjson/document.h"
 #include "rapidjson/error/en.h"
 #include "rapidjson/stringbuffer.h"
 #include "rapidjson/writer.h"
 
 
-#ifdef XMRIG_PROXY_PROJECT
-#   include "proxy/JobResult.h"
-#else
-#   include "net/JobResult.h"
-#endif
-
-
 #ifdef _MSC_VER
 #   define strncasecmp(x,y,z) _strnicmp(x,y,z)
 #endif
@@ -60,7 +54,9 @@ Client::Client(int id, const char *agent, IClientListener *listener) :
     m_quiet(false),
     m_agent(agent),
     m_listener(listener),
+    m_extensions(0),
     m_id(id),
+    m_retries(5),
     m_retryPause(5000),
     m_failures(0),
     m_recvBufPos(0),
@@ -166,12 +162,14 @@ bool Client::disconnect()
 
 int64_t Client::submit(const JobResult &result)
 {
+    using namespace rapidjson;
+
 #   ifdef XMRIG_PROXY_PROJECT
     const char *nonce = result.nonce;
     const char *data  = result.result;
 #   else
-    char nonce[9];
+    char *nonce = m_sendBuf;
-    char data[65];
+    char *data  = m_sendBuf + 16;
 
     Job::toHex(reinterpret_cast<const unsigned char*>(&result.nonce), 4, nonce);
     nonce[8] = '\0';
@@ -180,8 +178,24 @@ int64_t Client::submit(const JobResult &result)
     data[64] = '\0';
 #   endif
 
-    const size_t size = snprintf(m_sendBuf, sizeof(m_sendBuf), "{\"id\":%" PRIu64 ",\"jsonrpc\":\"2.0\",\"method\":\"submit\",\"params\":{\"id\":\"%s\",\"job_id\":\"%s\",\"nonce\":\"%s\",\"result\":\"%s\"}}\n",
+    Document doc(kObjectType);
-                                 m_sequence, m_rpcId.data(), result.jobId.data(), nonce, data);
+    auto &allocator = doc.GetAllocator();
+
+    doc.AddMember("id",      m_sequence, allocator);
+    doc.AddMember("jsonrpc", "2.0", allocator);
+    doc.AddMember("method",  "submit", allocator);
+
+    Value params(kObjectType);
+    params.AddMember("id",     StringRef(m_rpcId.data()), allocator);
+    params.AddMember("job_id", StringRef(result.jobId.data()), allocator);
+    params.AddMember("nonce",  StringRef(nonce), allocator);
+    params.AddMember("result", StringRef(data), allocator);
+
+    if (m_extensions & AlgoExt) {
+        params.AddMember("algo", StringRef(result.algorithm.shortName()), allocator);
+    }
+
+    doc.AddMember("params", params, allocator);
 
 #   ifdef XMRIG_PROXY_PROJECT
     m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff(), result.id);
@@ -189,7 +203,7 @@ int64_t Client::submit(const JobResult &result)
     m_results[m_sequence] = SubmitResult(m_sequence, result.diff, result.actualDiff());
 #   endif
 
-    return send(size);
+    return send(doc);
 }
 
 
@@ -238,12 +252,7 @@ bool Client::parseJob(const rapidjson::Value &params, int *code)
         return false;
     }
 
-#   ifdef XMRIG_PROXY_PROJECT
+    Job job(m_id, m_nicehash, m_pool.algorithm(), m_rpcId);
-    Job job(m_id, m_pool.variant());
-    job.setClientId(m_rpcId);
-#   else
-    Job job(m_id, m_nicehash, m_pool.algo(), m_pool.variant());
-#   endif
 
     if (!job.setId(params["job_id"].GetString())) {
         *code = 3;
@@ -260,12 +269,26 @@ bool Client::parseJob(const rapidjson::Value &params, int *code)
         return false;
     }
 
-    if (params.HasMember("coin")) {
+    if (params.HasMember("algo")) {
-        job.setCoin(params["coin"].GetString());
+        job.algorithm().parseAlgorithm(params["algo"].GetString());
     }
 
     if (params.HasMember("variant")) {
-        job.setVariant(params["variant"].GetInt());
+        const rapidjson::Value &variant = params["variant"];
+
+        if (variant.IsInt()) {
+            job.algorithm().parseVariant(variant.GetInt());
+        }
+        else if (variant.IsString()){
+            job.algorithm().parseVariant(variant.GetString());
+        }
+    }
+
+    if (!verifyAlgorithm(job.algorithm())) {
+        *code = 6;
+
+        close();
+        return false;
     }
 
     if (m_job != job) {
@@ -278,7 +301,7 @@ bool Client::parseJob(const rapidjson::Value &params, int *code)
         return false;
     }
 
-    if (!m_quiet) {
+    if (!isQuiet()) {
         LOG_WARN("[%s] duplicate job received, reconnect", m_pool.url());
     }
 
@@ -294,9 +317,7 @@ bool Client::parseLogin(const rapidjson::Value &result, int *code)
         return false;
     }
 
-#   ifndef XMRIG_PROXY_PROJECT
     m_nicehash = m_pool.isNicehash();
-#   endif
 
     if (result.HasMember("extensions")) {
         parseExtensions(result["extensions"]);
@@ -309,6 +330,27 @@ bool Client::parseLogin(const rapidjson::Value &result, int *code)
 }
 
 
+bool Client::verifyAlgorithm(const xmrig::Algorithm &algorithm) const
+{
+    if (m_pool.isCompatible(algorithm)) {
+        return true;
+    }
+
+    if (isQuiet()) {
+        return false;
+    }
+
+    if (algorithm.isValid()) {
+        LOG_ERR("Incompatible algorithm \"%s\" detected, reconnect", algorithm.name());
+    }
+    else {
+        LOG_ERR("Unknown/unsupported algorithm detected, reconnect");
+    }
+
+    return false;
+}
+
+
 int Client::resolve(const char *host)
 {
     setState(HostLookupState);
@@ -322,7 +364,7 @@ int Client::resolve(const char *host)
 
     const int r = uv_getaddrinfo(uv_default_loop(), &m_resolver, Client::onResolved, host, nullptr, &m_hints);
     if (r) {
-        if (!m_quiet) {
+        if (!isQuiet()) {
             LOG_ERR("[%s:%u] getaddrinfo error: \"%s\"", host, m_pool.port(), uv_strerror(r));
         }
         return 1;
@@ -332,6 +374,27 @@ int Client::resolve(const char *host)
 }
 
 
+int64_t Client::send(const rapidjson::Document &doc)
+{
+    using namespace rapidjson;
+
+    StringBuffer buffer(0, 512);
+    Writer<StringBuffer> writer(buffer);
+    doc.Accept(writer);
+
+    const size_t size = buffer.GetSize();
+    if (size > (sizeof(m_buf) - 2)) {
+        return -1;
+    }
+
+    memcpy(m_sendBuf, buffer.GetString(), size);
+    m_sendBuf[size]     = '\n';
+    m_sendBuf[size + 1] = '\0';
+
+    return send(size + 1);
+}
+
+
 int64_t Client::send(size_t size)
 {
     LOG_DEBUG("[%s] send (%d bytes): \"%s\"", m_pool.url(), size, m_sendBuf);
@@ -396,38 +459,35 @@ void Client::connect(sockaddr *addr)
 
 void Client::login()
 {
+    using namespace rapidjson;
     m_results.clear();
 
-    rapidjson::Document doc;
+    Document doc(kObjectType);
-    doc.SetObject();
-
     auto &allocator = doc.GetAllocator();
 
     doc.AddMember("id",      1,       allocator);
     doc.AddMember("jsonrpc", "2.0",   allocator);
     doc.AddMember("method",  "login", allocator);
 
-    rapidjson::Value params(rapidjson::kObjectType);
+    Value params(kObjectType);
-    params.AddMember("login", rapidjson::StringRef(m_pool.user()),     allocator);
+    params.AddMember("login", StringRef(m_pool.user()),     allocator);
-    params.AddMember("pass",  rapidjson::StringRef(m_pool.password()), allocator);
+    params.AddMember("pass",  StringRef(m_pool.password()), allocator);
-    params.AddMember("agent", rapidjson::StringRef(m_agent),           allocator);
+    params.AddMember("agent", StringRef(m_agent),           allocator);
 
-    doc.AddMember("params", params, allocator);
+    if (m_pool.rigId()) {
-
+        params.AddMember("rigid", StringRef(m_pool.rigId()), allocator);
-    rapidjson::StringBuffer buffer(0, 512);
-    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
-    doc.Accept(writer);
-
-    const size_t size = buffer.GetSize();
-    if (size > (sizeof(m_buf) - 2)) {
-        return;
     }
 
-    memcpy(m_sendBuf, buffer.GetString(), size);
+    Value algo(kArrayType);
-    m_sendBuf[size]     = '\n';
-    m_sendBuf[size + 1] = '\0';
 
-    send(size + 1);
+    for (const auto &a : m_pool.algorithms()) {
+        algo.PushBack(StringRef(a.shortName()), allocator);
+    }
+
+    params.AddMember("algo", algo, allocator);
+    doc.AddMember("params", params, allocator);
+
+    send(doc);
 }
 
 
@@ -452,7 +512,7 @@ void Client::parse(char *line, size_t len)
     LOG_DEBUG("[%s] received (%d bytes): \"%s\"", m_pool.url(), len, line);
 
     if (len < 32 || line[0] != '{') {
-        if (!m_quiet) {
+        if (!isQuiet()) {
             LOG_ERR("[%s] JSON decode failed", m_pool.url());
         }
 
@@ -461,7 +521,7 @@ void Client::parse(char *line, size_t len)
 
     rapidjson::Document doc;
     if (doc.ParseInsitu(line).HasParseError()) {
-        if (!m_quiet) {
+        if (!isQuiet()) {
             LOG_ERR("[%s] JSON decode failed: \"%s\"", m_pool.url(), rapidjson::GetParseError_En(doc.GetParseError()));
         }
 
@@ -484,6 +544,8 @@ void Client::parse(char *line, size_t len)
 
 void Client::parseExtensions(const rapidjson::Value &value)
 {
+    m_extensions = 0;
+
     if (!value.IsArray()) {
         return;
     }
@@ -493,8 +555,15 @@ void Client::parseExtensions(const rapidjson::Value &value)
             continue;
         }
 
+        if (strcmp(ext.GetString(), "algo") == 0) {
+            m_extensions |= AlgoExt;
+            continue;
+        }
+
         if (strcmp(ext.GetString(), "nicehash") == 0) {
+            m_extensions |= NicehashExt;
             m_nicehash = true;
+            continue;
         }
     }
 }
@@ -503,7 +572,7 @@ void Client::parseExtensions(const rapidjson::Value &value)
 void Client::parseNotification(const char *method, const rapidjson::Value &params, const rapidjson::Value &error)
 {
     if (error.IsObject()) {
-        if (!m_quiet) {
+        if (!isQuiet()) {
             LOG_ERR("[%s] error: \"%s\", code: %d", m_pool.url(), error["message"].GetString(), error["code"].GetInt());
         }
         return;
@@ -537,7 +606,7 @@ void Client::parseResponse(int64_t id, const rapidjson::Value &result, const rap
             m_listener->onResultAccepted(this, it->second, message);
             m_results.erase(it);
         }
-        else if (!m_quiet) {
+        else if (!isQuiet()) {
             LOG_ERR("[%s] error: \"%s\", code: %d", m_pool.url(), message, error["code"].GetInt());
         }
 
@@ -555,7 +624,7 @@ void Client::parseResponse(int64_t id, const rapidjson::Value &result, const rap
     if (id == 1) {
         int code = -1;
         if (!parseLogin(result, &code)) {
-            if (!m_quiet) {
+            if (!isQuiet()) {
                 LOG_ERR("[%s] login error code: %d", m_pool.url(), code);
             }
 
@@ -660,7 +729,7 @@ void Client::onConnect(uv_connect_t *req, int status)
     }
 
     if (status < 0) {
-        if (!client->m_quiet) {
+        if (!client->isQuiet()) {
             LOG_ERR("[%s] connect error: \"%s\"", client->m_pool.url(), uv_strerror(status));
         }
 
@@ -688,7 +757,7 @@ void Client::onRead(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)
     }
 
     if (nread < 0) {
-        if (nread != UV_EOF && !client->m_quiet) {
+        if (nread != UV_EOF && !client->isQuiet()) {
             LOG_ERR("[%s] read error: \"%s\"", client->m_pool.url(), uv_strerror((int) nread));
         }
 
@@ -748,7 +817,7 @@ void Client::onResolved(uv_getaddrinfo_t *req, int status, struct addrinfo *res)
     }
 
     if (status < 0) {
-        if (!client->m_quiet) {
+        if (!client->isQuiet()) {
             LOG_ERR("[%s] DNS error: \"%s\"", client->m_pool.url(), uv_strerror(status));
         }
 
@@ -772,7 +841,7 @@ void Client::onResolved(uv_getaddrinfo_t *req, int status, struct addrinfo *res)
     }
 
     if (ipv4.empty() && ipv6.empty()) {
-        if (!client->m_quiet) {
+        if (!client->isQuiet()) {
             LOG_ERR("[%s] DNS error: \"No IPv4 (A) or IPv6 (AAAA) records found\"", client->m_pool.url());
         }
 

src/common/net/Client.h

@@ -30,11 +30,11 @@
 #include <vector>
 
 
-#include "net/Id.h"
+#include "common/net/Id.h"
-#include "net/Job.h"
+#include "common/net/Job.h"
-#include "net/Storage.h"
+#include "common/net/Pool.h"
-#include "net/SubmitResult.h"
+#include "common/net/Storage.h"
-#include "net/Pool.h"
+#include "common/net/SubmitResult.h"
 #include "rapidjson/fwd.h"
 
 
@@ -74,14 +74,22 @@ public:
     inline SocketState state() const         { return m_state; }
     inline uint16_t port() const             { return m_pool.port(); }
     inline void setQuiet(bool quiet)         { m_quiet = quiet; }
+    inline void setRetries(int retries)      { m_retries = retries; }
     inline void setRetryPause(int ms)        { m_retryPause = ms; }
 
 private:
+    enum Extensions {
+        NicehashExt  = 1,
+        AlgoExt      = 2
+    };
+
     bool close();
     bool isCriticalError(const char *message);
     bool parseJob(const rapidjson::Value &params, int *code);
     bool parseLogin(const rapidjson::Value &result, int *code);
+    bool verifyAlgorithm(const xmrig::Algorithm &algorithm) const;
     int resolve(const char *host);
+    int64_t send(const rapidjson::Document &doc);
     int64_t send(size_t size);
     void connect(const std::vector<addrinfo*> &ipv4, const std::vector<addrinfo*> &ipv6);
     void connect(sockaddr *addr);
@@ -96,6 +104,8 @@ private:
     void setState(SocketState state);
     void startTimeout();
 
+    inline bool isQuiet() const { return m_quiet || m_failures >= m_retries; }
+
     static void onAllocBuffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf);
     static void onClose(uv_handle_t *handle);
     static void onConnect(uv_connect_t *req, int status);
@@ -113,7 +123,9 @@ private:
     char m_sendBuf[768];
     const char *m_agent;
     IClientListener *m_listener;
+    int m_extensions;
     int m_id;
+    int m_retries;
     int m_retryPause;
     int64_t m_failures;
     Job m_job;

src/common/net/Job.cpp

@@ -27,7 +27,7 @@
 #include <string.h>
 
 
-#include "net/Job.h"
+#include "common/net/Job.h"
 
 
 static inline unsigned char hf_hex2bin(char c, bool &err)
@@ -59,31 +59,27 @@ static inline char hf_bin2hex(unsigned char c)
 
 Job::Job() :
     m_nicehash(false),
-    m_coin(),
-    m_algo(xmrig::CRYPTONIGHT),
     m_poolId(-2),
     m_threadId(-1),
     m_size(0),
     m_diff(0),
     m_target(0),
-    m_blob(),
-    m_variant(xmrig::VARIANT_AUTO)
-{
-}
-
-
-Job::Job(int poolId, bool nicehash, int algo, int variant) :
-    m_nicehash(nicehash),
-    m_coin(),
-    m_algo(algo),
-    m_poolId(poolId),
-    m_threadId(-1),
-    m_size(0),
-    m_diff(0),
-    m_target(0),
     m_blob()
 {
-    setVariant(variant);
+}
+
+
+Job::Job(int poolId, bool nicehash, xmrig::Algorithm algorithm, const xmrig::Id &clientId) :
+    m_nicehash(nicehash),
+    m_poolId(poolId),
+    m_threadId(-1),
+    m_size(0),
+    m_diff(0),
+    m_target(0),
+    m_blob(),
+    m_algorithm(algorithm),
+    m_clientId(clientId)
+{
 }
 
 
@@ -116,6 +112,11 @@ bool Job::setBlob(const char *blob)
         m_nicehash = true;
     }
 
+#   ifdef XMRIG_PROXY_PROJECT
+    memset(m_rawBlob, 0, sizeof(m_rawBlob));
+    memcpy(m_rawBlob, blob, m_size * 2);
+#   endif
+
     return true;
 }
 
@@ -152,37 +153,35 @@ bool Job::setTarget(const char *target)
         return false;
     }
 
+#   ifdef XMRIG_PROXY_PROJECT
+    memset(m_rawTarget, 0, sizeof(m_rawTarget));
+    memcpy(m_rawTarget, target, len);
+#   endif
+
     m_diff = toDiff(m_target);
     return true;
 }
 
 
-void Job::setCoin(const char *coin)
+xmrig::Variant Job::variant() const
 {
-    if (!coin || strlen(coin) > 4) {
+    if (m_algorithm.algo() == xmrig::CRYPTONIGHT_HEAVY) {
-        memset(m_coin, 0, sizeof(m_coin));
+        return xmrig::VARIANT_0;
-        return;
     }
 
-    strncpy(m_coin, coin, sizeof(m_coin));
+    if (m_algorithm.variant() == xmrig::VARIANT_XTL && m_blob[0] < 4) {
-    m_algo = strcmp(m_coin, "AEON") == 0 ? xmrig::CRYPTONIGHT_LITE : xmrig::CRYPTONIGHT;
+        return xmrig::VARIANT_1;
-}
-
-
-void Job::setVariant(int variant)
-{
-    switch (variant) {
-    case xmrig::VARIANT_AUTO:
-    case xmrig::VARIANT_NONE:
-    case xmrig::VARIANT_V1:
-        m_variant = static_cast<xmrig::Variant>(variant);
-        break;
-
-    default:
-        assert(false);
-        m_variant = xmrig::VARIANT_AUTO;
-        break;
     }
+
+    if (m_algorithm.variant() == xmrig::VARIANT_AUTO) {
+        if (m_algorithm.algo() == xmrig::CRYPTONIGHT) {
+            return xmrig::VARIANT_1;
+        }
+
+        return (m_blob[0] > 6 ? xmrig::VARIANT_1 : xmrig::VARIANT_0);
+    }
+
+    return m_algorithm.variant();
 }
 
 

src/common/net/Job.h

@@ -30,39 +30,45 @@
 #include <stdint.h>
 
 
-#include "common/xmrig.h"
+#include "common/crypto/Algorithm.h"
-#include "net/Id.h"
+#include "common/net/Id.h"
 
 
 class Job
 {
 public:
     Job();
-    Job(int poolId, bool nicehash, int algo, int variant);
+    Job(int poolId, bool nicehash, xmrig::Algorithm algorithm, const xmrig::Id &clientId);
     ~Job();
 
     bool setBlob(const char *blob);
     bool setTarget(const char *target);
-    void setCoin(const char *coin);
+    xmrig::Variant variant() const;
-    void setVariant(int variant);
 
-    inline bool isNicehash() const         { return m_nicehash; }
+    inline bool isNicehash() const                    { return m_nicehash; }
-    inline bool isValid() const            { return m_size > 0 && m_diff > 0; }
+    inline bool isValid() const                       { return m_size > 0 && m_diff > 0; }
-    inline bool setId(const char *id)      { return m_id.setId(id); }
+    inline bool setId(const char *id)                 { return m_id.setId(id); }
-    inline const char *coin() const        { return m_coin; }
+    inline const uint32_t *nonce() const              { return reinterpret_cast<const uint32_t*>(m_blob + 39); }
-    inline const uint32_t *nonce() const   { return reinterpret_cast<const uint32_t*>(m_blob + 39); }
+    inline const uint8_t *blob() const                { return m_blob; }
-    inline const uint8_t *blob() const     { return m_blob; }
+    inline const xmrig::Algorithm &algorithm() const  { return m_algorithm; }
-    inline const xmrig::Id &id() const     { return m_id; }
+    inline const xmrig::Id &clientId() const          { return m_clientId; }
-    inline int poolId() const              { return m_poolId; }
+    inline const xmrig::Id &id() const                { return m_id; }
-    inline int threadId() const            { return m_threadId; }
+    inline int poolId() const                         { return m_poolId; }
-    inline size_t size() const             { return m_size; }
+    inline int threadId() const                       { return m_threadId; }
-    inline uint32_t *nonce()               { return reinterpret_cast<uint32_t*>(m_blob + 39); }
+    inline size_t size() const                        { return m_size; }
-    inline uint32_t diff() const           { return (uint32_t) m_diff; }
+    inline uint32_t *nonce()                          { return reinterpret_cast<uint32_t*>(m_blob + 39); }
-    inline uint64_t target() const         { return m_target; }
+    inline uint32_t diff() const                      { return static_cast<uint32_t>(m_diff); }
-    inline void setNicehash(bool nicehash) { m_nicehash = nicehash; }
+    inline uint64_t target() const                    { return m_target; }
-    inline void setPoolId(int poolId)      { m_poolId = poolId; }
+    inline void reset()                               { m_size = 0; m_diff = 0; }
-    inline void setThreadId(int threadId)  { m_threadId = threadId; }
+    inline void setClientId(const xmrig::Id &id)      { m_clientId = id; }
-    inline xmrig::Variant variant() const  { return (m_variant == xmrig::VARIANT_AUTO ? (m_blob[0] > 6 ? xmrig::VARIANT_V1 : xmrig::VARIANT_NONE) : m_variant); }
+    inline void setPoolId(int poolId)                 { m_poolId = poolId; }
+    inline void setThreadId(int threadId)             { m_threadId = threadId; }
+    inline xmrig::Algorithm &algorithm()              { return m_algorithm; }
+
+#   ifdef XMRIG_PROXY_PROJECT
+    inline char *rawBlob()                 { return m_rawBlob; }
+    inline const char *rawTarget() const   { return m_rawTarget; }
+#   endif
 
     static bool fromHex(const char* in, unsigned int len, unsigned char* out);
     static inline uint32_t *nonce(uint8_t *blob)   { return reinterpret_cast<uint32_t*>(blob + 39); }
@@ -78,16 +84,20 @@ public:
 
 private:
     bool m_nicehash;
-    char m_coin[5];
-    int m_algo;
     int m_poolId;
     int m_threadId;
     size_t m_size;
     uint64_t m_diff;
     uint64_t m_target;
     uint8_t m_blob[96]; // Max blob size is 84 (75 fixed + 9 variable), aligned to 96. https://github.com/xmrig/xmrig/issues/1 Thanks fireice-uk.
+    xmrig::Algorithm m_algorithm;
+    xmrig::Id m_clientId;
     xmrig::Id m_id;
-    xmrig::Variant m_variant;
+
+#   ifdef XMRIG_PROXY_PROJECT
+    char m_rawBlob[176];
+    char m_rawTarget[24];
+#   endif
 };
 
 #endif /* __JOB_H__ */

src/common/net/Pool.cpp

@@ -28,7 +28,13 @@
 #include <stdio.h>
 
 
-#include "net/Pool.h"
+#include "common/net/Pool.h"
+#include "rapidjson/document.h"
+
+
+#ifdef APP_DEBUG
+#   include "common/log/Log.h"
+#endif
 
 
 #ifdef _MSC_VER
@@ -37,42 +43,10 @@
 #endif
 
 
-static const char *algoNames[] = {
-    "cryptonight",
-#   ifndef XMRIG_NO_AEON
-    "cryptonight-lite",
-#   else
-    nullptr,
-#   endif
-#   ifndef XMRIG_NO_SUMO
-    "cryptonight-heavy"
-#   else
-    nullptr
-#   endif
-};
-
-
-static const char *algoNamesShort[] = {
-    "cn",
-#   ifndef XMRIG_NO_AEON
-    "cn-lite",
-#   else
-    nullptr,
-#   endif
-#   ifndef XMRIG_NO_SUMO
-    "cn-heavy"
-#   else
-    nullptr
-#   endif
-};
-
-
 Pool::Pool() :
     m_nicehash(false),
     m_keepAlive(0),
-    m_port(kDefaultPort),
+    m_port(kDefaultPort)
-    m_algo(xmrig::CRYPTONIGHT),
-    m_variant(xmrig::VARIANT_AUTO)
 {
 }
 
@@ -91,23 +65,19 @@ Pool::Pool() :
 Pool::Pool(const char *url) :
     m_nicehash(false),
     m_keepAlive(0),
-    m_port(kDefaultPort),
+    m_port(kDefaultPort)
-    m_algo(xmrig::CRYPTONIGHT),
-    m_variant(xmrig::VARIANT_AUTO)
 {
     parse(url);
 }
 
 
-Pool::Pool(const char *host, uint16_t port, const char *user, const char *password, int keepAlive, bool nicehash, xmrig::Variant variant) :
+Pool::Pool(const char *host, uint16_t port, const char *user, const char *password, int keepAlive, bool nicehash) :
     m_nicehash(nicehash),
     m_keepAlive(keepAlive),
     m_port(port),
-    m_algo(xmrig::CRYPTONIGHT),
     m_host(host),
     m_password(password),
-    m_user(user),
+    m_user(user)
-        m_variant(variant)
 {
     const size_t size = m_host.size() + 8;
     assert(size > 8);
@@ -119,34 +89,29 @@ Pool::Pool(const char *host, uint16_t port, const char *user, const char *passwo
 }
 
 
-const char *Pool::algoName(xmrig::Algo algorithm)
+bool Pool::isCompatible(const xmrig::Algorithm &algorithm) const
 {
-    return algoNames[algorithm];
+    for (const auto &a : m_algorithms) {
-}
+        if (algorithm == a) {
-
+            return true;
-
-xmrig::Algo Pool::algorithm(const char *algo)
-{
-#   ifndef XMRIG_NO_AEON
-    if (strcasecmp(algo, "cryptonight-light") == 0) {
-        fprintf(stderr, "Algorithm \"cryptonight-light\" is deprecated, use \"cryptonight-lite\" instead\n");
-
-        return xmrig::CRYPTONIGHT_LITE;
-    }
-#   endif
-
-    const size_t size = sizeof(algoNames) / sizeof(algoNames[0]);
-
-    assert(size == (sizeof(algoNamesShort) / sizeof(algoNamesShort[0])));
-
-    for (size_t i = 0; i < size; i++) {
-        if ((algoNames[i] && strcasecmp(algo, algoNames[i]) == 0) || (algoNamesShort[i] && strcasecmp(algo, algoNamesShort[i]) == 0)) {
-            return static_cast<xmrig::Algo>(i);
         }
     }
 
-    fprintf(stderr, "Unknown algorithm \"%s\" specified.\n", algo);
+    return false;
-    return xmrig::INVALID_ALGO;
+}
+
+
+bool Pool::isEqual(const Pool &other) const
+{
+    return (m_nicehash     == other.m_nicehash
+            && m_keepAlive == other.m_keepAlive
+            && m_port      == other.m_port
+            && m_algorithm == other.m_algorithm
+            && m_host      == other.m_host
+            && m_password  == other.m_password
+            && m_rigId     == other.m_rigId
+            && m_url       == other.m_url
+            && m_user      == other.m_user);
 }
 
 
@@ -208,53 +173,104 @@ bool Pool::setUserpass(const char *userpass)
 }
 
 
-void Pool::adjust(xmrig::Algo algo)
+rapidjson::Value Pool::toJSON(rapidjson::Document &doc) const
+{
+    using namespace rapidjson;
+
+    auto &allocator = doc.GetAllocator();
+
+    Value obj(kObjectType);
+
+    obj.AddMember("url",    StringRef(url()), allocator);
+    obj.AddMember("user",   StringRef(user()), allocator);
+    obj.AddMember("pass",   StringRef(password()), allocator);
+    obj.AddMember("rig-id", rigId() ? Value(StringRef(rigId())).Move() : Value(kNullType).Move(), allocator);
+
+#   ifndef XMRIG_PROXY_PROJECT
+    obj.AddMember("nicehash", isNicehash(), allocator);
+#   endif
+
+    if (m_keepAlive == 0 || m_keepAlive == kKeepAliveTimeout) {
+        obj.AddMember("keepalive", m_keepAlive > 0, allocator);
+    }
+    else {
+        obj.AddMember("keepalive", m_keepAlive, allocator);
+    }
+
+    switch (m_algorithm.variant()) {
+    case xmrig::VARIANT_AUTO:
+    case xmrig::VARIANT_0:
+    case xmrig::VARIANT_1:
+        obj.AddMember("variant", m_algorithm.variant(), allocator);
+        break;
+
+    default:
+        obj.AddMember("variant", StringRef(m_algorithm.variantName()), allocator);
+        break;
+    }
+
+    return obj;
+}
+
+
+void Pool::adjust(xmrig::Algo algorithm)
 {
     if (!isValid()) {
         return;
     }
 
-    m_algo = algo;
+    if (!m_algorithm.isValid()) {
+        m_algorithm.setAlgo(algorithm);
+
+        if (m_algorithm.variant() == xmrig::VARIANT_AUTO) {
+            if (algorithm == xmrig::CRYPTONIGHT)  {
+                m_algorithm.setVariant(xmrig::VARIANT_1);
+            }
+        }
+    }
 
     if (strstr(m_host.data(), ".nicehash.com")) {
         m_keepAlive = false;
         m_nicehash  = true;
+
+        if (strstr(m_host.data(), "cryptonightv7.")) {
+            m_algorithm.setVariant(xmrig::VARIANT_1);
+        }
     }
 
     if (strstr(m_host.data(), ".minergate.com")) {
         m_keepAlive = false;
+        m_algorithm.setVariant(xmrig::VARIANT_1);
     }
+
+    m_algorithms.push_back(m_algorithm);
+
+#   ifndef XMRIG_PROXY_PROJECT
+    if (m_algorithm.algo() != xmrig::CRYPTONIGHT_HEAVY) {
+        addVariant(xmrig::VARIANT_1);
+        addVariant(xmrig::VARIANT_0);
+        addVariant(xmrig::VARIANT_XTL);
+        addVariant(xmrig::VARIANT_IPBC);
+        addVariant(xmrig::VARIANT_AUTO);
+    }
+#   endif
 }
 
 
-void Pool::setVariant(int variant)
+#ifdef APP_DEBUG
+void Pool::print() const
 {
-   switch (variant) {
+    LOG_NOTICE("url:       %s", m_url.data());
-   case xmrig::VARIANT_AUTO:
+    LOG_DEBUG ("host:      %s", m_host.data());
-   case xmrig::VARIANT_NONE:
+    LOG_DEBUG ("port:      %d", static_cast<int>(m_port));
-   case xmrig::VARIANT_V1:
+    LOG_DEBUG ("user:      %s", m_user.data());
-       m_variant = static_cast<xmrig::Variant>(variant);
+    LOG_DEBUG ("pass:      %s", m_password.data());
-       break;
+    LOG_DEBUG ("rig-id     %s", m_rigId.data());
-
+    LOG_DEBUG ("algo:      %s", m_algorithm.name());
-   default:
+    LOG_DEBUG ("nicehash:  %d", static_cast<int>(m_nicehash));
-       assert(false);
+    LOG_DEBUG ("keepAlive: %d", m_keepAlive);
-       break;
-   }
-}
-
-
-bool Pool::isEqual(const Pool &other) const
-{
-    return (m_nicehash     == other.m_nicehash
-            && m_keepAlive == other.m_keepAlive
-            && m_port      == other.m_port
-            && m_algo      == other.m_algo
-            && m_host      == other.m_host
-            && m_password  == other.m_password
-            && m_url       == other.m_url
-            && m_user      == other.m_user
-            && m_variant   == other.m_variant);
 }
+#endif
 
 
 bool Pool::parseIPv6(const char *addr)
@@ -278,3 +294,14 @@ bool Pool::parseIPv6(const char *addr)
 
     return true;
 }
+
+
+void Pool::addVariant(xmrig::Variant variant)
+{
+    const xmrig::Algorithm algorithm(m_algorithm.algo(), variant);
+    if (!algorithm.isValid() || m_algorithm == algorithm) {
+        return;
+    }
+
+    m_algorithms.push_back(algorithm);
+}

src/common/net/Pool.h

@@ -25,11 +25,12 @@
 #define __POOL_H__
 
 
-#include <stdint.h>
+#include <vector>
 
 
+#include "common/crypto/Algorithm.h"
 #include "common/utils/c_str.h"
-#include "common/xmrig.h"
+#include "rapidjson/fwd.h"
 
 
 class Pool
@@ -47,50 +48,58 @@ public:
         const char *user       = nullptr,
         const char *password   = nullptr,
         int keepAlive          = 0,
-        bool nicehash          = false,
+        bool nicehash          = false
-        xmrig::Variant variant = xmrig::VARIANT_AUTO
        );
 
-    static const char *algoName(xmrig::Algo algorithm);
+    inline bool isNicehash() const                     { return m_nicehash; }
-    static xmrig::Algo algorithm(const char *algo);
+    inline bool isValid() const                        { return !m_host.isNull() && m_port > 0; }
-
+    inline const char *host() const                    { return m_host.data(); }
-    inline bool isNicehash() const                { return m_nicehash; }
+    inline const char *password() const                { return !m_password.isNull() ? m_password.data() : kDefaultPassword; }
-    inline bool isValid() const                   { return !m_host.isNull() && m_port > 0; }
+    inline const char *rigId() const                   { return m_rigId.data(); }
-    inline const char *host() const               { return m_host.data(); }
+    inline const char *url() const                     { return m_url.data(); }
-    inline const char *password() const           { return !m_password.isNull() ? m_password.data() : kDefaultPassword; }
+    inline const char *user() const                    { return !m_user.isNull() ? m_user.data() : kDefaultUser; }
-    inline const char *url() const                { return m_url.data(); }
+    inline const xmrig::Algorithm &algorithm() const   { return m_algorithm; }
-    inline const char *user() const               { return !m_user.isNull() ? m_user.data() : kDefaultUser; }
+    inline const xmrig::Algorithms &algorithms() const { return m_algorithms; }
-    inline int keepAlive() const                  { return m_keepAlive; }
+    inline int keepAlive() const                       { return m_keepAlive; }
-    inline uint16_t port() const                  { return m_port; }
+    inline uint16_t port() const                       { return m_port; }
-    inline void setKeepAlive(int keepAlive)       { m_keepAlive = keepAlive >= 0 ? keepAlive : 0; }
+    inline void setKeepAlive(int keepAlive)            { m_keepAlive = keepAlive >= 0 ? keepAlive : 0; }
-    inline void setNicehash(bool nicehash)        { m_nicehash = nicehash; }
+    inline void setNicehash(bool nicehash)             { m_nicehash = nicehash; }
-    inline void setPassword(const char *password) { m_password = password; }
+    inline void setPassword(const char *password)      { m_password = password; }
-    inline void setUser(const char *user)         { m_user = user; }
+    inline void setRigId(const char *rigId)            { m_rigId = rigId; }
-    inline xmrig::Algo algo() const               { return m_algo; }
+    inline void setUser(const char *user)              { m_user = user; }
-    inline xmrig::Variant variant() const         { return m_variant; }
+    inline xmrig::Algorithm &algorithm()               { return m_algorithm; }
 
     inline bool operator!=(const Pool &other) const  { return !isEqual(other); }
     inline bool operator==(const Pool &other) const  { return isEqual(other); }
 
+    bool isCompatible(const xmrig::Algorithm &algorithm) const;
+    bool isEqual(const Pool &other) const;
     bool parse(const char *url);
     bool setUserpass(const char *userpass);
-    void adjust(xmrig::Algo algo);
+    rapidjson::Value toJSON(rapidjson::Document &doc) const;
-    void setVariant(int variant);
+    void adjust(xmrig::Algo algorithm);
 
-    bool isEqual(const Pool &other) const;
+#   ifdef APP_DEBUG
+    void print() const;
+#   endif
 
 private:
     bool parseIPv6(const char *addr);
+    void addVariant(xmrig::Variant variant);
 
     bool m_nicehash;
     int m_keepAlive;
     uint16_t m_port;
-    xmrig::Algo m_algo;
+    xmrig::Algorithm m_algorithm;
+    xmrig::Algorithms m_algorithms;
     xmrig::c_str m_host;
     xmrig::c_str m_password;
+    xmrig::c_str m_rigId;
     xmrig::c_str m_url;
     xmrig::c_str m_user;
-    xmrig::Variant m_variant;
 };
 
+
+typedef std::vector<Pool> Pools;
+
 #endif /* __POOL_H__ */

src/common/net/Storage.h

@@ -28,8 +28,6 @@
 #include <assert.h>
 #include <map>
 
-#include "log/Log.h"
-
 
 namespace xmrig {
 

src/common/net/SubmitResult.cpp

@@ -4,8 +4,8 @@
  * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
  * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
  * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright 2016-2017 XMRig       <support@xmrig.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- *
+ * Copyright 2016-2018 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -25,10 +25,11 @@
 #include <uv.h>
 
 
-#include "net/SubmitResult.h"
+#include "common/net/SubmitResult.h"
 
 
-SubmitResult::SubmitResult(int64_t seq, uint32_t diff, uint64_t actualDiff) :
+SubmitResult::SubmitResult(int64_t seq, uint32_t diff, uint64_t actualDiff, int64_t reqId) :
+    reqId(reqId),
     seq(seq),
     diff(diff),
     actualDiff(actualDiff),

src/common/net/SubmitResult.h

@@ -4,8 +4,8 @@
  * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
  * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
  * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright 2016-2017 XMRig       <support@xmrig.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- *
+ * Copyright 2016-2018 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -31,11 +31,12 @@
 class SubmitResult
 {
 public:
-    inline SubmitResult() : seq(0), diff(0), actualDiff(0), elapsed(0), start(0) {}
+    inline SubmitResult() : reqId(0), seq(0), diff(0), actualDiff(0), elapsed(0), start(0) {}
-    SubmitResult(int64_t seq, uint32_t diff, uint64_t actualDiff);
+    SubmitResult(int64_t seq, uint32_t diff, uint64_t actualDiff, int64_t reqId = 0);
 
     void done();
 
+    int64_t reqId;
     int64_t seq;
     uint32_t diff;
     uint64_t actualDiff;

src/common/net/strategies/FailoverStrategy.cpp

@@ -22,10 +22,10 @@
  */
 
 
+#include "common/net/Client.h"
+#include "common/net/strategies/FailoverStrategy.h"
 #include "common/Platform.h"
 #include "interfaces/IStrategyListener.h"
-#include "net/Client.h"
-#include "net/strategies/FailoverStrategy.h"
 
 
 FailoverStrategy::FailoverStrategy(const std::vector<Pool> &urls, int retryPause, int retries, IStrategyListener *listener, bool quiet) :
@@ -157,6 +157,7 @@ void FailoverStrategy::add(const Pool &pool)
 {
     Client *client = new Client((int) m_pools.size(), Platform::userAgent(), this);
     client->setPool(pool);
+    client->setRetries(m_retries);
     client->setRetryPause(m_retryPause * 1000);
     client->setQuiet(m_quiet);
 

src/common/net/strategies/FailoverStrategy.h

@@ -28,9 +28,9 @@
 #include <vector>
 
 
+#include "common/net/Pool.h"
 #include "interfaces/IClientListener.h"
 #include "interfaces/IStrategy.h"
-#include "net/Pool.h"
 
 
 class Client;

src/common/net/strategies/SinglePoolStrategy.cpp

@@ -22,18 +22,19 @@
  */
 
 
+#include "common/net/Client.h"
+#include "common/net/strategies/SinglePoolStrategy.h"
 #include "common/Platform.h"
 #include "interfaces/IStrategyListener.h"
-#include "net/Client.h"
-#include "net/strategies/SinglePoolStrategy.h"
 
 
-SinglePoolStrategy::SinglePoolStrategy(const Pool &pool, int retryPause, IStrategyListener *listener, bool quiet) :
+SinglePoolStrategy::SinglePoolStrategy(const Pool &pool, int retryPause, int retries, IStrategyListener *listener, bool quiet) :
     m_active(false),
     m_listener(listener)
 {
     m_client = new Client(0, Platform::userAgent(), this);
     m_client->setPool(pool);
+    m_client->setRetries(retries);
     m_client->setRetryPause(retryPause * 1000);
     m_client->setQuiet(quiet);
 }

src/common/net/strategies/SinglePoolStrategy.h

@@ -37,7 +37,7 @@ class Url;
 class SinglePoolStrategy : public IStrategy, public IClientListener
 {
 public:
-    SinglePoolStrategy(const Pool &pool, int retryPause, IStrategyListener *listener, bool quiet = false);
+    SinglePoolStrategy(const Pool &pool, int retryPause, int retries, IStrategyListener *listener, bool quiet = false);
     ~SinglePoolStrategy();
 
 public:

src/common/utils/c_str.h

@@ -68,7 +68,7 @@ public:
 
     inline bool isEqual(const char *str) const
     {
-        return (m_data != nullptr && str != nullptr && strcmp(m_data, str)) || (m_data == nullptr && m_data == nullptr);
+        return (m_data != nullptr && str != nullptr && strcmp(m_data, str) == 0) || (m_data == nullptr && m_data == nullptr);
     }
 
 

src/common/xmrig.h

@@ -33,7 +33,7 @@ enum Algo {
     INVALID_ALGO = -1,
     CRYPTONIGHT,       /* CryptoNight (Monero) */
     CRYPTONIGHT_LITE,  /* CryptoNight-Lite (AEON) */
-    CRYPTONIGHT_HEAVY, /* CryptoNight-Heavy (SUMO) */
+    CRYPTONIGHT_HEAVY  /* CryptoNight-Heavy (SUMO) */
 };
 
 
@@ -59,8 +59,10 @@ enum AlgoVariant {
 
 enum Variant {
     VARIANT_AUTO = -1, // Autodetect
-    VARIANT_NONE = 0,  // Original CryptoNight
+    VARIANT_0    = 0,  // Original CryptoNight or CryptoNight-Heavy
-    VARIANT_V1   = 1   // Monero v7 PoW
+    VARIANT_1    = 1,  // CryptoNight variant 1 also known as Monero7 and CryptoNightV7
+    VARIANT_IPBC = 2,  // CryptoNight Lite variant 1 with XOR (IPBC only)
+    VARIANT_XTL  = 3   // CryptoNight variant 1 (Stellite only)
 };
 
 

src/config.json

@@ -1,34 +1,38 @@
 {
-    "algo": "cryptonight",  // cryptonight (default) or cryptonight-lite
+    "algo": "cryptonight",
-    "av": 0,                // algorithm variation, 0 auto select
-    "background": false,    // true to run the miner in the background
-    "colors": true,         // false to disable colored output    
-    "cpu-affinity": null,   // set process affinity to CPU core(s), mask "0x3" for cores 0 and 1
-    "cpu-priority": null,   // set process priority (0 idle, 2 normal to 5 highest)
-    "donate-level": 5,      // donate level, mininum 1%
-    "log-file": null,       // log all output to a file, example: "c:/some/path/xmrig.log"
-    "max-cpu-usage": 75,    // maximum CPU usage for automatic mode, usually limiting factor is CPU cache not this option.  
-    "print-time": 60,       // print hashrate report every N seconds
-    "retries": 5,           // number of times to retry before switch to backup server
-    "retry-pause": 5,       // time to pause between retries
-    "safe": false,          // true to safe adjust threads and av settings for current CPU
-    "syslog": false,        // use system log for output messages
-    "threads": null,        // number of miner threads
-    "pools": [
-        {
-            "url": "failover.xmrig.com:443", // URL of mining server
-            "user": "YOUR_WALLET",           // username for mining server
-            "pass": "x",                     // password for mining server
-            "keepalive": true,               // send keepalived for prevent timeout (need pool support)
-            "nicehash": false,               // enable nicehash/xmrig-proxy support
-            "variant": -1                    // algorithm PoW variant
-        }
-    ],
     "api": {
-        "port": 0,                             // port for the miner API https://github.com/xmrig/xmrig/wiki/API
+        "port": 0,
-        "access-token": null,                  // access token for API
+        "access-token": null,
-        "worker-id": null,                     // custom worker-id for API
+        "worker-id": null,
         "ipv6": false,
         "restricted": true
-    }
+    },
+    "av": 0,
+    "background": false,
+    "colors": true,
+    "cpu-affinity": null,
+    "cpu-priority": null,
+    "donate-level": 5,
+    "huge-pages": true,
+    "hw-aes": null,
+    "log-file": null,
+    "max-cpu-usage": 75,
+    "pools": [
+        {
+            "url": "proxy.fee.xmrig.com:9999",
+            "user": "YOUR_WALLET",
+            "pass": "x",
+            "rig-id": null,
+            "nicehash": false,
+            "keepalive": false,
+            "variant": 1
+        }
+    ],
+    "print-time": 60,
+    "retries": 5,
+    "retry-pause": 5,
+    "safe": false,
+    "threads": null,
+    "user-agent": null,
+    "watch": false
 }

src/core/Config.cpp

@@ -31,7 +31,6 @@
 #include "core/ConfigCreator.h"
 #include "Cpu.h"
 #include "crypto/CryptoNight_constants.h"
-#include "net/Pool.h"
 #include "rapidjson/document.h"
 #include "rapidjson/filewritestream.h"
 #include "rapidjson/prettywriter.h"
@@ -72,7 +71,7 @@ void xmrig::Config::getJSON(rapidjson::Document &doc) const
 
     auto &allocator = doc.GetAllocator();
 
-    doc.AddMember("algo", StringRef(algoName()), allocator);
+    doc.AddMember("algo", StringRef(algorithm().name()), allocator);
 
     Value api(kObjectType);
     api.AddMember("port",         apiPort(), allocator);
@@ -103,24 +102,8 @@ void xmrig::Config::getJSON(rapidjson::Document &doc) const
 
     Value pools(kArrayType);
 
-    for (const Pool &pool : m_pools) {
+    for (const Pool &pool : m_activePools) {
-        Value obj(kObjectType);
+        pools.PushBack(pool.toJSON(doc), allocator);
-
-        obj.AddMember("url",     StringRef(pool.url()), allocator);
-        obj.AddMember("user",    StringRef(pool.user()), allocator);
-        obj.AddMember("pass",    StringRef(pool.password()), allocator);
-
-        if (pool.keepAlive() == 0 || pool.keepAlive() == Pool::kKeepAliveTimeout) {
-            obj.AddMember("keepalive", pool.keepAlive() > 0, allocator);
-        }
-        else {
-            obj.AddMember("keepalive", pool.keepAlive(), allocator);
-        }
-
-        obj.AddMember("nicehash", pool.isNicehash(), allocator);
-        obj.AddMember("variant",  pool.variant(), allocator);
-
-        pools.PushBack(obj, allocator);
     }
 
     doc.AddMember("pools",         pools, allocator);
@@ -158,9 +141,13 @@ xmrig::Config *xmrig::Config::load(int argc, char **argv, IWatcherListener *list
 }
 
 
-bool xmrig::Config::adjust()
+bool xmrig::Config::finalize()
 {
-    if (!CommonConfig::adjust()) {
+    if (m_state != NoneState) {
+        return CommonConfig::finalize();
+    }
+
+    if (!CommonConfig::finalize()) {
         return false;
     }
 
@@ -169,16 +156,16 @@ bool xmrig::Config::adjust()
         const bool softAES = (m_aesMode == AES_AUTO ? (Cpu::hasAES() ? AES_HW : AES_SOFT) : m_aesMode) == AES_SOFT;
 
         for (size_t i = 0; i < m_threads.cpu.size(); ++i) {
-            m_threads.list.push_back(CpuThread::createFromData(i, m_algorithm, m_threads.cpu[i], m_priority, softAES));
+            m_threads.list.push_back(CpuThread::createFromData(i, m_algorithm.algo(), m_threads.cpu[i], m_priority, softAES));
         }
 
         return true;
     }
 
-    m_algoVariant  = getAlgoVariant();
+    const AlgoVariant av = getAlgoVariant();
     m_threads.mode = m_threads.count ? Simple : Automatic;
 
-    const size_t size = CpuThread::multiway(m_algoVariant) * cn_select_memory(m_algorithm) / 1024;
+    const size_t size = CpuThread::multiway(av) * cn_select_memory(m_algorithm.algo()) / 1024;
 
     if (!m_threads.count) {
         m_threads.count = Cpu::optimalThreadsCount(size, m_maxCpuUsage);
@@ -191,7 +178,7 @@ bool xmrig::Config::adjust()
     }
 
     for (size_t i = 0; i < m_threads.count; ++i) {
-        m_threads.list.push_back(CpuThread::createFromAV(i, m_algorithm, m_algoVariant, m_threads.mask, m_priority));
+        m_threads.list.push_back(CpuThread::createFromAV(i, m_algorithm.algo(), av, m_threads.mask, m_priority));
     }
 
     return true;
@@ -351,7 +338,7 @@ bool xmrig::Config::parseInt(int key, int arg)
 xmrig::AlgoVariant xmrig::Config::getAlgoVariant() const
 {
 #   ifndef XMRIG_NO_AEON
-    if (m_algorithm == xmrig::CRYPTONIGHT_LITE) {
+    if (m_algorithm.algo() == xmrig::CRYPTONIGHT_LITE) {
         return getAlgoVariantLite();
     }
 #   endif

src/core/Config.h

@@ -88,7 +88,7 @@ public:
     static Config *load(int argc, char **argv, IWatcherListener *listener);
 
 protected:
-    bool adjust() override;
+    bool finalize() override;
     bool parseBoolean(int key, bool enable) override;
     bool parseString(int key, const char *arg) override;
     bool parseUint64(int key, uint64_t arg) override;

src/core/ConfigLoader_platform.h

@@ -58,6 +58,7 @@ Options:\n\
   -O, --userpass=U:P       username:password pair for mining server\n\
   -u, --user=USERNAME      username for mining server\n\
   -p, --pass=PASSWORD      password for mining server\n\
+      --rig-id=ID          rig identifier for pool-side statistics (needs pool support)\n\
   -t, --threads=N          number of miner threads\n\
   -v, --av=N               algorithm variation, 0 auto select\n\
   -k, --keepalive          send keepalived for prevent timeout (need pool support)\n\
@@ -128,6 +129,7 @@ static struct option const options[] = {
     { "user",              1, nullptr, xmrig::IConfig::UserKey           },
     { "user-agent",        1, nullptr, xmrig::IConfig::UserAgentKey      },
     { "userpass",          1, nullptr, xmrig::IConfig::UserpassKey       },
+    { "rig-id",            1, nullptr, xmrig::IConfig::RigIdKey          },
     { "version",           0, nullptr, xmrig::IConfig::VersionKey        },
     { 0, 0, 0, 0 }
 };
@@ -165,6 +167,7 @@ static struct option const pool_options[] = {
     { "nicehash",      0, nullptr, xmrig::IConfig::NicehashKey   },
     { "keepalive",     2, nullptr, xmrig::IConfig::KeepAliveKey  },
     { "variant",       1, nullptr, xmrig::IConfig::VariantKey    },
+    { "rig-id",        1, nullptr, xmrig::IConfig::RigIdKey      },
     { 0, 0, 0, 0 }
 };
 

src/core/Controller.cpp

@@ -26,19 +26,19 @@
 
 
 #include "common/config/ConfigLoader.h"
+#include "common/log/ConsoleLog.h"
+#include "common/log/FileLog.h"
+#include "common/log/Log.h"
 #include "common/Platform.h"
 #include "core/Config.h"
 #include "core/Controller.h"
 #include "Cpu.h"
 #include "interfaces/IControllerListener.h"
-#include "log/ConsoleLog.h"
-#include "log/FileLog.h"
-#include "log/Log.h"
 #include "net/Network.h"
 
 
 #ifdef HAVE_SYSLOG_H
-#   include "log/SysLog.h"
+#   include "common/log/SysLog.h"
 #endif
 
 

src/crypto/CryptoNight_constants.h

@@ -53,6 +53,7 @@ template<> inline constexpr size_t cn_select_memory<CRYPTONIGHT>()       { retur
 template<> inline constexpr size_t cn_select_memory<CRYPTONIGHT_LITE>()  { return CRYPTONIGHT_LITE_MEMORY; }
 template<> inline constexpr size_t cn_select_memory<CRYPTONIGHT_HEAVY>() { return CRYPTONIGHT_HEAVY_MEMORY; }
 
+
 inline size_t cn_select_memory(Algo algorithm)
 {
     switch(algorithm)
@@ -79,6 +80,7 @@ template<> inline constexpr uint32_t cn_select_mask<CRYPTONIGHT>()       { retur
 template<> inline constexpr uint32_t cn_select_mask<CRYPTONIGHT_LITE>()  { return CRYPTONIGHT_LITE_MASK; }
 template<> inline constexpr uint32_t cn_select_mask<CRYPTONIGHT_HEAVY>() { return CRYPTONIGHT_HEAVY_MASK; }
 
+
 inline uint32_t cn_select_mask(Algo algorithm)
 {
     switch(algorithm)
@@ -105,6 +107,7 @@ template<> inline constexpr uint32_t cn_select_iter<CRYPTONIGHT>()       { retur
 template<> inline constexpr uint32_t cn_select_iter<CRYPTONIGHT_LITE>()  { return CRYPTONIGHT_LITE_ITER; }
 template<> inline constexpr uint32_t cn_select_iter<CRYPTONIGHT_HEAVY>() { return CRYPTONIGHT_HEAVY_ITER; }
 
+
 inline uint32_t cn_select_iter(Algo algorithm)
 {
     switch(algorithm)

src/crypto/CryptoNight_test.h

@@ -84,6 +84,21 @@ const static uint8_t test_output_v1[160] = {
 };
 
 
+// Stellite (XTL)
+const static uint8_t test_output_xtl[160] = {
+    0x8F, 0xE5, 0xF0, 0x5F, 0x02, 0x2A, 0x61, 0x7D, 0xE5, 0x3F, 0x79, 0x36, 0x4B, 0x25, 0xCB, 0xC3,
+    0xC0, 0x8E, 0x0E, 0x1F, 0xE3, 0xBE, 0x48, 0x57, 0x07, 0x03, 0xFE, 0xE1, 0xEC, 0x0E, 0xB0, 0xB1,
+    0x21, 0x26, 0xFF, 0x98, 0xE6, 0x86, 0x08, 0x5B, 0xC9, 0x96, 0x44, 0xA3, 0xB8, 0x4E, 0x28, 0x90,
+    0x76, 0xED, 0xAD, 0xB9, 0xAA, 0xAC, 0x01, 0x94, 0x1D, 0xBE, 0x3E, 0xEA, 0xAD, 0xEE, 0xB2, 0xCF,
+    0xB0, 0x43, 0x4B, 0x88, 0xFC, 0xB2, 0xF3, 0x82, 0x9D, 0xD7, 0xDF, 0x51, 0x97, 0x2C, 0x5A, 0xE3,
+    0xC7, 0x16, 0x0B, 0xC8, 0x7C, 0xB7, 0x2F, 0x1C, 0x55, 0x33, 0xCA, 0xE1, 0xEE, 0x08, 0xA4, 0x86,
+    0x60, 0xED, 0x6E, 0x9D, 0x2D, 0x05, 0x0D, 0x7D, 0x02, 0x49, 0x23, 0x39, 0x7C, 0xC3, 0x6D, 0x3D,
+    0x05, 0x51, 0x28, 0xF1, 0x9B, 0x3C, 0xDF, 0xC4, 0xEA, 0x8A, 0xA6, 0x6A, 0x3C, 0x8B, 0xE2, 0xAF,
+    0x47, 0x00, 0xFC, 0x36, 0xED, 0x50, 0xBB, 0xD2, 0x2E, 0x63, 0x4B, 0x93, 0x11, 0x0C, 0xA7, 0xBA,
+    0x32, 0x6E, 0x47, 0x4D, 0xCE, 0xCC, 0x82, 0x54, 0x1D, 0x06, 0xF8, 0x06, 0x86, 0xBD, 0x22, 0x48
+};
+
+
 #ifndef XMRIG_NO_AEON
 const static uint8_t test_output_v0_lite[160] = {
     0x36, 0x95, 0xB4, 0xB5, 0x3B, 0xB0, 0x03, 0x58, 0xB0, 0xAD, 0x38, 0xDC, 0x16, 0x0F, 0xEB, 0x9E,
@@ -112,6 +127,21 @@ const static uint8_t test_output_v1_lite[160] = {
     0x8C, 0x2B, 0xA4, 0x1F, 0x60, 0x76, 0x39, 0xD7, 0xF6, 0x46, 0x77, 0x18, 0x20, 0xAD, 0xD4, 0xC9,
     0x87, 0xF7, 0x37, 0xDA, 0xFD, 0xBA, 0xBA, 0xD2, 0xF2, 0x68, 0xDC, 0x26, 0x8D, 0x1B, 0x08, 0xC6
 };
+
+
+// IPBC
+const static uint8_t test_output_ipbc_lite[160] = {
+    0xE4, 0x93, 0x8C, 0xAA, 0x59, 0x8D, 0x02, 0x8A, 0xB8, 0x6F, 0x25, 0xD2, 0xB1, 0x23, 0xD0, 0xD5,
+    0x33, 0xE3, 0x9F, 0x37, 0xAC, 0xE5, 0xF8, 0xEB, 0x7A, 0xE8, 0x40, 0xEB, 0x5D, 0xB1, 0x35, 0x5F,
+    0xB2, 0x47, 0x86, 0xF0, 0x7F, 0x6F, 0x4B, 0x55, 0x3E, 0xA1, 0xBB, 0xE8, 0xA1, 0x75, 0x00, 0x2D,
+    0x07, 0x9A, 0x21, 0x0E, 0xBD, 0x06, 0x6A, 0xB0, 0xFD, 0x96, 0x9E, 0xE6, 0xE4, 0x69, 0x67, 0xBB,
+    0x88, 0x45, 0x0B, 0x91, 0x0B, 0x7B, 0xCB, 0x21, 0x3C, 0x3C, 0x09, 0x30, 0x07, 0x71, 0x07, 0xD5,
+    0xB8, 0x2D, 0x83, 0x09, 0xAF, 0x7E, 0xB2, 0xA8, 0xAC, 0x25, 0xDC, 0x10, 0xF8, 0x63, 0x6A, 0xBC,
+    0x73, 0x01, 0x4E, 0xA8, 0x1C, 0xDA, 0x9A, 0x86, 0x17, 0xEC, 0xA8, 0xFB, 0xAA, 0x23, 0x23, 0x17,
+    0xE1, 0x32, 0x68, 0x9C, 0x4C, 0xF4, 0x08, 0xED, 0xB0, 0x15, 0xC3, 0xA9, 0x0F, 0xF0, 0xA2, 0x7E,
+    0xD9, 0xE4, 0x23, 0xA7, 0x9E, 0x91, 0xD8, 0x73, 0x94, 0xD6, 0x6C, 0x70, 0x9B, 0x8B, 0x72, 0x92,
+    0xA3, 0xA4, 0x0A, 0xE2, 0x3C, 0x0A, 0x34, 0x88, 0xA1, 0x6D, 0xFE, 0x02, 0x44, 0x60, 0x7B, 0x3D
+};
 #endif
 
 

src/crypto/CryptoNight_x86.h

@@ -35,6 +35,7 @@
 #endif
 
 
+#include "common/crypto/keccak.h"
 #include "crypto/CryptoNight.h"
 #include "crypto/CryptoNight_constants.h"
 #include "crypto/CryptoNight_monero.h"
@@ -43,7 +44,6 @@
 
 extern "C"
 {
-#include "crypto/c_keccak.h"
 #include "crypto/c_groestl.h"
 #include "crypto/c_blake256.h"
 #include "crypto/c_jh.h"
@@ -389,6 +389,7 @@ static inline void cn_implode_scratchpad(const __m128i *input, __m128i *output)
 }
 
 
+template<int SHIFT>
 static inline void cryptonight_monero_tweak(uint64_t* mem_out, __m128i tmp)
 {
     mem_out[0] = EXTRACT64(tmp);
@@ -398,12 +399,14 @@ static inline void cryptonight_monero_tweak(uint64_t* mem_out, __m128i tmp)
 
     uint8_t x = vh >> 24;
     static const uint16_t table = 0x7531;
-    vh ^= ((table >> ((((x >> 3) & 6) | (x & 1)) << 1)) & 0x3) << 28;
+    const uint8_t index = (((x >> SHIFT) & 6) | (x & 1)) << 1;
+    vh ^= ((table >> index) & 0x3) << 28;
 
     mem_out[1] = vh;
 }
 
 
+
 template<xmrig::Algo ALGO, bool SOFT_AES, int VARIANT>
 inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t size, uint8_t *__restrict__ output, cryptonight_ctx **__restrict__ ctx)
 {
@@ -416,7 +419,7 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
         return;
     }
 
-    keccak(input, (int) size, ctx[0]->state, 200);
+    xmrig::keccak(input, size, ctx[0]->state);
 
     VARIANT1_INIT(0)
 
@@ -429,22 +432,27 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
     uint64_t ah0 = h0[1] ^ h0[5];
     __m128i bx0 = _mm_set_epi64x(h0[3] ^ h0[7], h0[2] ^ h0[6]);
 
-    uint64_t idx0 = h0[0] ^ h0[4];
+    uint64_t idx0 = al0;
-    void* mp = ((uint8_t*) l0) + ((idx0) & MASK);
+    void* mp = ((uint8_t*) l0) + (idx0 & MASK);
 
     for (size_t i = 0; i < ITERATIONS; i++) {
         __m128i cx;
 
         if (SOFT_AES) {
             cx = soft_aesenc((uint32_t*) mp, _mm_set_epi64x(ah0, al0));
-        } else {  
+        }
+        else {  
             cx = _mm_load_si128((__m128i *) mp);
             cx = _mm_aesenc_si128(cx, _mm_set_epi64x(ah0, al0));
         }
 
-        _mm_store_si128((__m128i *) mp, _mm_xor_si128(bx0, cx));
+        if (VARIANT > 0) {
-        VARIANT1_1(mp);        
+            cryptonight_monero_tweak<VARIANT == xmrig::VARIANT_XTL ? 4 : 3>((uint64_t*) mp, _mm_xor_si128(bx0, cx));
-        mp = ((uint8_t*) l0) + ((idx0 = EXTRACT64(cx)) & MASK);        
+        } else {
+            _mm_store_si128((__m128i *) mp, _mm_xor_si128(bx0, cx));
+        }
+
+        mp = (void*) &l0[(idx0 = EXTRACT64(cx)) & MASK];
         bx0 = cx;
 
         uint64_t hi, lo, cl, ch;
@@ -455,30 +463,39 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
         al0 += hi;
         ah0 += lo;
 
-        VARIANT1_2(ah0, 0);
         ((uint64_t*) mp)[0] = al0;
-        ((uint64_t*) mp)[1] = ah0;
-        VARIANT1_2(ah0, 0);
 
-        ah0 ^= ch;
+        if (VARIANT > 0) {
+            if (VARIANT == xmrig::VARIANT_IPBC) {
+                ((uint64_t*) mp)[1] = ah0 ^ tweak1_2_0 ^ al0;
+            }
+            else {
+                ((uint64_t*) mp)[1] = ah0 ^ tweak1_2_0;
+            }
+        }
+        else {
+            ((uint64_t*) mp)[1] = ah0;
+        }
+
         al0 ^= cl;
-        mp = ((uint8_t*) l0) + ((al0) & MASK); 
+        ah0 ^= ch;
+        mp = (void*) &l0[al0 & MASK];
 
         if (ALGO == xmrig::CRYPTONIGHT_HEAVY) {
-            int64_t n  = ((int64_t*)mp)[0];
+            int64_t n  = ((int64_t*) mp)[0];
-            int32_t d  = ((int32_t*)mp)[2];
+            int32_t d  = ((int32_t*) mp)[2];
             int64_t q = n / (d | 0x5);
+
             ((int64_t*) mp)[0] = n ^ q;
         }
     }
 
     cn_implode_scratchpad<ALGO, MEM, SOFT_AES>((__m128i*) ctx[0]->memory, (__m128i*) ctx[0]->state);
 
-    keccakf(h0, 24);
+    xmrig::keccakf(h0, 24);
     extra_hashes[ctx[0]->state[0] & 3](ctx[0]->state, 200, output);
 }
 
-
 template<xmrig::Algo ALGO, bool SOFT_AES, int VARIANT>
 inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t size, uint8_t *__restrict__ output, cryptonight_ctx **__restrict__ ctx)
 {
@@ -491,8 +508,8 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
         return;
     }
 
-    keccak(input,        (int) size, ctx[0]->state, 200);
+    xmrig::keccak(input,        size, ctx[0]->state);
-    keccak(input + size, (int) size, ctx[1]->state, 200);
+    xmrig::keccak(input + size, size, ctx[1]->state);
 
     VARIANT1_INIT(0);
     VARIANT1_INIT(1);
@@ -516,91 +533,109 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
     uint64_t idx0 = al0;
     uint64_t idx1 = al1;
 
-    void* mp0 = ((uint8_t*) l0) + ((idx0) & MASK);
-    void* mp1 = ((uint8_t*) l1) + ((idx1) & MASK);
-
     for (size_t i = 0; i < ITERATIONS; i++) {
         __m128i cx0, cx1;
 
         if (SOFT_AES) {
-            cx0 = soft_aesenc((uint32_t*) mp0, _mm_set_epi64x(ah0, al0));
+            cx0 = soft_aesenc((uint32_t*)&l0[idx0 & MASK], _mm_set_epi64x(ah0, al0));
-            cx1 = soft_aesenc((uint32_t*) mp1, _mm_set_epi64x(ah1, al1));
+            cx1 = soft_aesenc((uint32_t*)&l1[idx1 & MASK], _mm_set_epi64x(ah1, al1));
-        } else {
+        }
-            cx0 = _mm_load_si128((__m128i *) mp0);
+        else {
-            cx1 = _mm_load_si128((__m128i *)mp1);
+            cx0 = _mm_load_si128((__m128i *) &l0[idx0 & MASK]);
+            cx1 = _mm_load_si128((__m128i *) &l1[idx1 & MASK]);
             cx0 = _mm_aesenc_si128(cx0, _mm_set_epi64x(ah0, al0));
             cx1 = _mm_aesenc_si128(cx1, _mm_set_epi64x(ah1, al1));
         }
 
         if (VARIANT > 0) {
-            cryptonight_monero_tweak((uint64_t*)mp0, _mm_xor_si128(bx0, cx0));
+            cryptonight_monero_tweak<VARIANT == xmrig::VARIANT_XTL ? 4 : 3>((uint64_t*)&l0[idx0 & MASK], _mm_xor_si128(bx0, cx0));
-            cryptonight_monero_tweak((uint64_t*)mp1, _mm_xor_si128(bx1, cx1));
+            cryptonight_monero_tweak<VARIANT == xmrig::VARIANT_XTL ? 4 : 3>((uint64_t*)&l1[idx1 & MASK], _mm_xor_si128(bx1, cx1));
         } else {
-            _mm_store_si128((__m128i *) mp0, _mm_xor_si128(bx0, cx0));
+            _mm_store_si128((__m128i *) &l0[idx0 & MASK], _mm_xor_si128(bx0, cx0));
-            _mm_store_si128((__m128i *) mp1, _mm_xor_si128(bx1, cx1));
+            _mm_store_si128((__m128i *) &l1[idx1 & MASK], _mm_xor_si128(bx1, cx1));
         }
 
-        mp0 = ((uint8_t*) l0) + ((idx0 = EXTRACT64(cx0)) & MASK);
+        idx0 = EXTRACT64(cx0);
-        mp1 = ((uint8_t*) l1) + ((idx1 = EXTRACT64(cx1)) & MASK);
+        idx1 = EXTRACT64(cx1);
 
         bx0 = cx0;
         bx1 = cx1;
 
         uint64_t hi, lo, cl, ch;
-        cl = ((uint64_t*) mp0)[0];
+        cl = ((uint64_t*) &l0[idx0 & MASK])[0];
-        ch = ((uint64_t*) mp0)[1];
+        ch = ((uint64_t*) &l0[idx0 & MASK])[1];
         lo = __umul128(idx0, cl, &hi);
 
         al0 += hi;
         ah0 += lo;
 
-        VARIANT1_2(ah0, 0);
+        ((uint64_t*)&l0[idx0 & MASK])[0] = al0;
-        ((uint64_t*) mp0)[0] = al0;
-        ((uint64_t*) mp0)[1] = ah0;
-        VARIANT1_2(ah0, 0);
 
-        ah0 ^= ch;
+        if (VARIANT > 0) {
-        al0 ^= cl;
+            if (VARIANT == xmrig::VARIANT_IPBC) {
-        mp0 = ((uint8_t*) l0) + ((al0) & MASK);
+                ((uint64_t*)&l0[idx0 & MASK])[1] = ah0 ^ tweak1_2_0 ^ al0;
-
+            }
-        if (ALGO == xmrig::CRYPTONIGHT_HEAVY) {
+            else {
-            int64_t n  = ((int64_t*)mp0)[0];
+                ((uint64_t*)&l0[idx0 & MASK])[1] = ah0 ^ tweak1_2_0;
-            int32_t d  = ((int32_t*)mp0)[2];
+            }
-            int64_t q = n / (d | 0x5);
+        }
-
+        else {
-            ((int64_t*) mp0)[0] = n ^ q;
+            ((uint64_t*)&l0[idx0 & MASK])[1] = ah0;
         }
 
-        cl = ((uint64_t*) mp1)[0];
+        al0 ^= cl;
-        ch = ((uint64_t*) mp1)[1];
+        ah0 ^= ch;
+        idx0 = al0;
+
+        if (ALGO == xmrig::CRYPTONIGHT_HEAVY) {
+            int64_t n  = ((int64_t*)&l0[idx0 & MASK])[0];
+            int32_t d  = ((int32_t*)&l0[idx0 & MASK])[2];
+            int64_t q = n / (d | 0x5);
+
+            ((int64_t*)&l0[idx0 & MASK])[0] = n ^ q;
+            idx0 = d ^ q;
+        }
+
+        cl = ((uint64_t*) &l1[idx1 & MASK])[0];
+        ch = ((uint64_t*) &l1[idx1 & MASK])[1];
         lo = __umul128(idx1, cl, &hi);
 
         al1 += hi;
         ah1 += lo;
 
-        VARIANT1_2(ah1, 1);
+        ((uint64_t*)&l1[idx1 & MASK])[0] = al1;
-        ((uint64_t*) mp1)[0] = al1;
+
-        ((uint64_t*) mp1)[1] = ah1;
+        if (VARIANT > 0) {
-        VARIANT1_2(ah1, 1);
+            if (VARIANT == xmrig::VARIANT_IPBC) {
+                ((uint64_t*)&l1[idx1 & MASK])[1] = ah1 ^ tweak1_2_1 ^ al1;
+            }
+            else {
+                ((uint64_t*)&l1[idx1 & MASK])[1] = ah1 ^ tweak1_2_1;
+            }
+        }
+        else {
+            ((uint64_t*)&l1[idx1 & MASK])[1] = ah1;
+        }
 
-        ah1 ^= ch;
         al1 ^= cl;
-        mp1 = ((uint8_t*) l1) + ((al1) & MASK);
+        ah1 ^= ch;
+        idx1 = al1;
 
         if (ALGO == xmrig::CRYPTONIGHT_HEAVY) {
-            int64_t n  = ((int64_t*)mp1)[0];
+            int64_t n  = ((int64_t*)&l1[idx1 & MASK])[0];
-            int32_t d  = ((int32_t*)mp1)[2];
+            int32_t d  = ((int32_t*)&l1[idx1 & MASK])[2];
             int64_t q = n / (d | 0x5);
 
-            ((int64_t*)mp1)[0] = n ^ q;
+            ((int64_t*)&l1[idx1 & MASK])[0] = n ^ q;
+            idx1 = d ^ q;
         }
     }
 
     cn_implode_scratchpad<ALGO, MEM, SOFT_AES>((__m128i*) l0, (__m128i*) h0);
     cn_implode_scratchpad<ALGO, MEM, SOFT_AES>((__m128i*) l1, (__m128i*) h1);
 
-    keccakf(h0, 24);
+    xmrig::keccakf(h0, 24);
-    keccakf(h1, 24);
+    xmrig::keccakf(h1, 24);
 
     extra_hashes[ctx[0]->state[0] & 3](ctx[0]->state, 200, output);
     extra_hashes[ctx[1]->state[0] & 3](ctx[1]->state, 200, output + 32);
@@ -622,7 +657,7 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
     b = _mm_xor_si128(b, c);                                           \
                                                                        \
     if (VARIANT > 0) {                                                 \
-        cryptonight_monero_tweak(reinterpret_cast<uint64_t*>(ptr), b); \
+        cryptonight_monero_tweak<VARIANT == xmrig::VARIANT_XTL ? 4 : 3>(reinterpret_cast<uint64_t*>(ptr), b); \
     } else {                                                           \
         _mm_store_si128(ptr, b);                                       \
     }
@@ -640,6 +675,10 @@ inline void cryptonight_double_hash(const uint8_t *__restrict__ input, size_t si
                                                         \
     if (VARIANT > 0) {                                  \
         _mm_store_si128(ptr, _mm_xor_si128(a, mc));     \
+                                                        \
+        if (VARIANT == xmrig::VARIANT_IPBC) {           \
+            ((uint64_t*)ptr)[1] ^= ((uint64_t*)ptr)[0]; \
+        }                                               \
     } else {                                            \
         _mm_store_si128(ptr, a);                        \
     }                                                   \
@@ -677,7 +716,7 @@ inline void cryptonight_triple_hash(const uint8_t *__restrict__ input, size_t si
     }
 
     for (size_t i = 0; i < 3; i++) {
-        keccak(input + size * i, static_cast<int>(size), ctx[i]->state, 200);
+        xmrig::keccak(input + size * i, size, ctx[i]->state);
         cn_explode_scratchpad<ALGO, MEM, SOFT_AES>(reinterpret_cast<__m128i*>(ctx[i]->state), reinterpret_cast<__m128i*>(ctx[i]->memory));
     }
 
@@ -748,7 +787,7 @@ inline void cryptonight_triple_hash(const uint8_t *__restrict__ input, size_t si
 
     for (size_t i = 0; i < 3; i++) {
         cn_implode_scratchpad<ALGO, MEM, SOFT_AES>(reinterpret_cast<__m128i*>(ctx[i]->memory), reinterpret_cast<__m128i*>(ctx[i]->state));
-        keccakf(reinterpret_cast<uint64_t*>(ctx[i]->state), 24);
+        xmrig::keccakf(reinterpret_cast<uint64_t*>(ctx[i]->state), 24);
         extra_hashes[ctx[i]->state[0] & 3](ctx[i]->state, 200, output + 32 * i);
     }
 }
@@ -767,7 +806,7 @@ inline void cryptonight_quad_hash(const uint8_t *__restrict__ input, size_t size
     }
 
     for (size_t i = 0; i < 4; i++) {
-        keccak(input + size * i, static_cast<int>(size), ctx[i]->state, 200);
+        xmrig::keccak(input + size * i, size, ctx[i]->state);
         cn_explode_scratchpad<ALGO, MEM, SOFT_AES>(reinterpret_cast<__m128i*>(ctx[i]->state), reinterpret_cast<__m128i*>(ctx[i]->memory));
     }
 
@@ -854,7 +893,7 @@ inline void cryptonight_quad_hash(const uint8_t *__restrict__ input, size_t size
 
     for (size_t i = 0; i < 4; i++) {
         cn_implode_scratchpad<ALGO, MEM, SOFT_AES>(reinterpret_cast<__m128i*>(ctx[i]->memory), reinterpret_cast<__m128i*>(ctx[i]->state));
-        keccakf(reinterpret_cast<uint64_t*>(ctx[i]->state), 24);
+        xmrig::keccakf(reinterpret_cast<uint64_t*>(ctx[i]->state), 24);
         extra_hashes[ctx[i]->state[0] & 3](ctx[i]->state, 200, output + 32 * i);
     }
 }
@@ -873,7 +912,7 @@ inline void cryptonight_penta_hash(const uint8_t *__restrict__ input, size_t siz
     }
 
     for (size_t i = 0; i < 5; i++) {
-        keccak(input + size * i, static_cast<int>(size), ctx[i]->state, 200);
+        xmrig::keccak(input + size * i, size, ctx[i]->state);
         cn_explode_scratchpad<ALGO, MEM, SOFT_AES>(reinterpret_cast<__m128i*>(ctx[i]->state), reinterpret_cast<__m128i*>(ctx[i]->memory));
     }
 
@@ -975,7 +1014,7 @@ inline void cryptonight_penta_hash(const uint8_t *__restrict__ input, size_t siz
 
     for (size_t i = 0; i < 5; i++) {
         cn_implode_scratchpad<ALGO, MEM, SOFT_AES>(reinterpret_cast<__m128i*>(ctx[i]->memory), reinterpret_cast<__m128i*>(ctx[i]->state));
-        keccakf(reinterpret_cast<uint64_t*>(ctx[i]->state), 24);
+        xmrig::keccakf(reinterpret_cast<uint64_t*>(ctx[i]->state), 24);
         extra_hashes[ctx[i]->state[0] & 3](ctx[i]->state, 200, output + 32 * i);
     }
 }

src/crypto/c_keccak.h

@@ -1,26 +0,0 @@
-// keccak.h
-// 19-Nov-11  Markku-Juhani O. Saarinen <mjos@iki.fi>
-
-#ifndef KECCAK_H
-#define KECCAK_H
-
-#include <stdint.h>
-#include <string.h>
-
-#ifndef KECCAK_ROUNDS
-#define KECCAK_ROUNDS 24
-#endif
-
-#ifndef ROTL64
-#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
-#endif
-
-// compute a keccak hash (md) of given byte length from "in"
-int keccak(const uint8_t *in, int inlen, uint8_t *md, int mdlen);
-
-// update the state
-void keccakf(uint64_t st[25], int norounds);
-
-void keccak1600(const uint8_t *in, int inlen, uint8_t *md);
-
-#endif

src/interfaces/IConfig.h

@@ -36,30 +36,31 @@ public:
     enum Keys {
         // common
         AlgorithmKey      = 'a',
-        ApiPort           = 4000,
         ApiAccessTokenKey = 4001,
-        ApiWorkerIdKey    = 4002,
         ApiIPv6Key        = 4003,
+        ApiPort           = 4000,
         ApiRestrictedKey  = 4004,
+        ApiWorkerIdKey    = 4002,
         BackgroundKey     = 'B',
+        ColorKey          = 1002,
         ConfigKey         = 'c',
         DonateLevelKey    = 1003,
         HelpKey           = 'h',
         KeepAliveKey      = 'k',
         LogFileKey        = 'l',
-        ColorKey          = 1002,
-        WatchKey          = 1105,
         PasswordKey       = 'p',
         RetriesKey        = 'r',
         RetryPauseKey     = 'R',
+        RigIdKey          = 1012,
         SyslogKey         = 'S',
         UrlKey            = 'o',
-        UserKey           = 'u',
         UserAgentKey      = 1008,
+        UserKey           = 'u',
         UserpassKey       = 'O',
+        VariantKey        = 1010,
         VerboseKey        = 1100,
         VersionKey        = 'V',
-        VariantKey        = 1010,
+        WatchKey          = 1105,
 
         // xmrig common
         CPUPriorityKey    = 1021,
@@ -90,8 +91,7 @@ public:
 
     virtual ~IConfig() {}
 
-    virtual bool adjust()                                  = 0;
+    virtual bool finalize()                                = 0;
-    virtual bool isValid() const                           = 0;
     virtual bool isWatch() const                           = 0;
     virtual bool parseBoolean(int key, bool enable)        = 0;
     virtual bool parseString(int key, const char *arg)     = 0;

src/net/JobResult.h

@@ -29,41 +29,24 @@
 #include <stdint.h>
 
 
-#include "Job.h"
+#include "common/net/Job.h"
 
 
 class JobResult
 {
 public:
     inline JobResult() : poolId(0), diff(0), nonce(0) {}
-    inline JobResult(int poolId, const xmrig::Id &jobId, uint32_t nonce, const uint8_t *result, uint32_t diff) :
+    inline JobResult(int poolId, const xmrig::Id &jobId, uint32_t nonce, const uint8_t *result, uint32_t diff, const xmrig::Algorithm &algorithm) :
         poolId(poolId),
         diff(diff),
         nonce(nonce),
+        algorithm(algorithm),
         jobId(jobId)
     {
         memcpy(this->result, result, sizeof(this->result));
     }
 
 
-    inline JobResult(const Job &job) : poolId(0), diff(0), nonce(0)
-    {
-        jobId  = job.id();
-        poolId = job.poolId();
-        diff   = job.diff();
-        nonce  = *job.nonce();
-    }
-
-
-    inline JobResult &operator=(const Job &job) {
-        jobId  = job.id();
-        poolId = job.poolId();
-        diff   = job.diff();
-
-        return *this;
-    }
-
-
     inline uint64_t actualDiff() const
     {
         return Job::toDiff(reinterpret_cast<const uint64_t*>(result)[3]);
@@ -74,6 +57,7 @@ public:
     uint32_t diff;
     uint32_t nonce;
     uint8_t result[32];
+    xmrig::Algorithm algorithm;
     xmrig::Id jobId;
 };
 

src/net/Network.cpp

@@ -31,16 +31,16 @@
 
 
 #include "api/Api.h"
-#include "log/Log.h"
+#include "common/log/Log.h"
-#include "net/Client.h"
+#include "common/net/Client.h"
+#include "common/net/strategies/FailoverStrategy.h"
+#include "common/net/strategies/SinglePoolStrategy.h"
+#include "common/net/SubmitResult.h"
+#include "core/Config.h"
+#include "core/Controller.h"
 #include "net/Network.h"
 #include "net/strategies/DonateStrategy.h"
-#include "net/strategies/FailoverStrategy.h"
-#include "net/strategies/SinglePoolStrategy.h"
-#include "net/SubmitResult.h"
 #include "workers/Workers.h"
-#include "core/Controller.h"
-#include "core/Config.h"
 
 
 Network::Network(xmrig::Controller *controller) :
@@ -57,11 +57,11 @@ Network::Network(xmrig::Controller *controller) :
         m_strategy = new FailoverStrategy(pools, controller->config()->retryPause(), controller->config()->retries(), this);
     }
     else {
-        m_strategy = new SinglePoolStrategy(pools.front(), controller->config()->retryPause(), this);
+        m_strategy = new SinglePoolStrategy(pools.front(), controller->config()->retryPause(), controller->config()->retries(), this);
     }
 
     if (controller->config()->donateLevel() > 0) {
-        m_donate = new DonateStrategy(controller->config()->donateLevel(), controller->config()->pools().front().user(), controller->config()->algorithm(), this);
+        m_donate = new DonateStrategy(controller->config()->donateLevel(), controller->config()->pools().front().user(), controller->config()->algorithm().algo(), this);
     }
 
     m_timer.data = this;
@@ -166,12 +166,9 @@ bool Network::isColors() const
 
 void Network::setJob(Client *client, const Job &job, bool donate)
 {
-    if (isColors()) {
+    LOG_INFO(isColors() ? MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%d") " algo " WHITE_BOLD("%s")
-        LOG_INFO("\x1B[01;35mnew job\x1B[0m from \x1B[01;37m%s:%d\x1B[0m diff \x1B[01;37m%d", client->host(), client->port(), job.diff());
+                        : "new job from %s:%d diff %d algo %s",
-    }
+             client->host(), client->port(), job.diff(), job.algorithm().shortName());
-    else {
-        LOG_INFO("new job from %s:%d diff %d", client->host(), client->port(), job.diff());
-    }
 
     m_state.diff = job.diff();
     Workers::setJob(job, donate);

src/net/strategies/DonateStrategy.cpp

@@ -22,19 +22,15 @@
  */
 
 
+#include "common/crypto/keccak.h"
+#include "common/net/Client.h"
+#include "common/net/Job.h"
+#include "common/net/strategies/FailoverStrategy.h"
+#include "common/net/strategies/SinglePoolStrategy.h"
 #include "common/Platform.h"
 #include "common/xmrig.h"
 #include "interfaces/IStrategyListener.h"
-#include "net/Client.h"
-#include "net/Job.h"
 #include "net/strategies/DonateStrategy.h"
-#include "net/strategies/FailoverStrategy.h"
-
-
-extern "C"
-{
-#include "crypto/c_keccak.h"
-}
 
 
 const static char *kDonatePool1   = "miner.fee.xmrig.com";
@@ -46,7 +42,7 @@ static inline float randomf(float min, float max) {
 }
 
 
-DonateStrategy::DonateStrategy(int level, const char *user, int algo, IStrategyListener *listener) :
+DonateStrategy::DonateStrategy(int level, const char *user, xmrig::Algo algo, IStrategyListener *listener) :
     m_active(false),
     m_donateTime(level * 60 * 1000),
     m_idleTime((100 - level) * 60 * 1000),
@@ -56,7 +52,7 @@ DonateStrategy::DonateStrategy(int level, const char *user, int algo, IStrategyL
     uint8_t hash[200];
     char userId[65] = { 0 };
 
-    keccak(reinterpret_cast<const uint8_t *>(user), static_cast<int>(strlen(user)), hash, sizeof(hash));
+    xmrig::keccak(reinterpret_cast<const uint8_t *>(user), strlen(user), hash);
     Job::toHex(hash, 32, userId);
 
     if (algo == xmrig::CRYPTONIGHT) {
@@ -66,14 +62,21 @@ DonateStrategy::DonateStrategy(int level, const char *user, int algo, IStrategyL
     }
     else if (algo == xmrig::CRYPTONIGHT_HEAVY) {
         m_pools.push_back(Pool(kDonatePool1, 8888, userId, nullptr, false, true));
-        m_pools.push_back(Pool(kDonatePool1, 8889, userId, nullptr, false, true));
     }
     else {
         m_pools.push_back(Pool(kDonatePool1, 5555, userId, nullptr, false, true));
-        m_pools.push_back(Pool(kDonatePool1, 7777, userId, nullptr, false, true));
     }
 
-    m_strategy = new FailoverStrategy(m_pools, 1, 1, this, true);
+    for (Pool &pool : m_pools) {
+        pool.algorithm().setAlgo(algo);
+    }
+
+    if (m_pools.size() > 1) {
+        m_strategy = new FailoverStrategy(m_pools, 1, 2, this, true);
+    }
+    else {
+        m_strategy = new SinglePoolStrategy(m_pools.front(), 1, 2, this, true);
+    }
 
     m_timer.data = this;
     uv_timer_init(uv_default_loop(), &m_timer);

src/net/strategies/DonateStrategy.h

@@ -29,10 +29,10 @@
 #include <vector>
 
 
+#include "common/net/Pool.h"
 #include "interfaces/IClientListener.h"
 #include "interfaces/IStrategy.h"
 #include "interfaces/IStrategyListener.h"
-#include "net/Pool.h"
 
 
 class Client;
@@ -43,7 +43,7 @@ class Url;
 class DonateStrategy : public IStrategy, public IStrategyListener
 {
 public:
-    DonateStrategy(int level, const char *user, int algo, IStrategyListener *listener);
+    DonateStrategy(int level, const char *user, xmrig::Algo algo, IStrategyListener *listener);
     ~DonateStrategy();
 
 public:

src/version.h

@@ -27,7 +27,7 @@
 #define APP_ID        "xmrig"
 #define APP_NAME      "XMRig"
 #define APP_DESC      "XMRig CPU miner"
-#define APP_VERSION   "2.6.0-beta3"
+#define APP_VERSION   "2.6.1"
 #define APP_DOMAIN    "xmrig.com"
 #define APP_SITE      "www.xmrig.com"
 #define APP_COPYRIGHT "Copyright (C) 2016-2018 xmrig.com"
@@ -35,8 +35,7 @@
 
 #define APP_VER_MAJOR  2
 #define APP_VER_MINOR  6
-#define APP_VER_BUILD  0
+#define APP_VER_PATCH  1
-#define APP_VER_REV    3
 
 #ifdef _MSC_VER
 #   if (_MSC_VER >= 1910)

src/workers/CpuThread.cpp

@@ -24,7 +24,7 @@
 #include <assert.h>
 
 
-#include "net/Pool.h"
+#include "common/net/Pool.h"
 #include "rapidjson/document.h"
 #include "workers/CpuThread.h"
 
@@ -62,69 +62,97 @@ bool xmrig::CpuThread::isSoftAES(AlgoVariant av)
 
 xmrig::CpuThread::cn_hash_fun xmrig::CpuThread::fn(Algo algorithm, AlgoVariant av, Variant variant)
 {
-    assert(variant == VARIANT_NONE || variant == VARIANT_V1);
+    assert(variant == VARIANT_0 || variant == VARIANT_1 || variant == VARIANT_IPBC || variant == VARIANT_XTL);
 
-    static const cn_hash_fun func_table[50] = {
+    static const cn_hash_fun func_table[90] = {
-        cryptonight_single_hash<CRYPTONIGHT, false, VARIANT_NONE>,
+        cryptonight_single_hash<CRYPTONIGHT, false, VARIANT_0>,
-        cryptonight_double_hash<CRYPTONIGHT, false, VARIANT_NONE>,
+        cryptonight_double_hash<CRYPTONIGHT, false, VARIANT_0>,
-        cryptonight_single_hash<CRYPTONIGHT, true,  VARIANT_NONE>,
+        cryptonight_single_hash<CRYPTONIGHT, true,  VARIANT_0>,
-        cryptonight_double_hash<CRYPTONIGHT, true,  VARIANT_NONE>,
+        cryptonight_double_hash<CRYPTONIGHT, true,  VARIANT_0>,
-        cryptonight_triple_hash<CRYPTONIGHT, false, VARIANT_NONE>,
+        cryptonight_triple_hash<CRYPTONIGHT, false, VARIANT_0>,
-        cryptonight_quad_hash<CRYPTONIGHT,   false, VARIANT_NONE>,
+        cryptonight_quad_hash<CRYPTONIGHT,   false, VARIANT_0>,
-        cryptonight_penta_hash<CRYPTONIGHT,  false, VARIANT_NONE>,
+        cryptonight_penta_hash<CRYPTONIGHT,  false, VARIANT_0>,
-        cryptonight_triple_hash<CRYPTONIGHT, true,  VARIANT_NONE>,
+        cryptonight_triple_hash<CRYPTONIGHT, true,  VARIANT_0>,
-        cryptonight_quad_hash<CRYPTONIGHT,   true,  VARIANT_NONE>,
+        cryptonight_quad_hash<CRYPTONIGHT,   true,  VARIANT_0>,
-        cryptonight_penta_hash<CRYPTONIGHT,  true,  VARIANT_NONE>,
+        cryptonight_penta_hash<CRYPTONIGHT,  true,  VARIANT_0>,
 
-        cryptonight_single_hash<CRYPTONIGHT, false, VARIANT_V1>,
+        cryptonight_single_hash<CRYPTONIGHT, false, VARIANT_1>,
-        cryptonight_double_hash<CRYPTONIGHT, false, VARIANT_V1>,
+        cryptonight_double_hash<CRYPTONIGHT, false, VARIANT_1>,
-        cryptonight_single_hash<CRYPTONIGHT, true,  VARIANT_V1>,
+        cryptonight_single_hash<CRYPTONIGHT, true,  VARIANT_1>,
-        cryptonight_double_hash<CRYPTONIGHT, true,  VARIANT_V1>,
+        cryptonight_double_hash<CRYPTONIGHT, true,  VARIANT_1>,
-        cryptonight_triple_hash<CRYPTONIGHT, false, VARIANT_V1>,
+        cryptonight_triple_hash<CRYPTONIGHT, false, VARIANT_1>,
-        cryptonight_quad_hash<CRYPTONIGHT,   false, VARIANT_V1>,
+        cryptonight_quad_hash<CRYPTONIGHT,   false, VARIANT_1>,
-        cryptonight_penta_hash<CRYPTONIGHT,  false, VARIANT_V1>,
+        cryptonight_penta_hash<CRYPTONIGHT,  false, VARIANT_1>,
-        cryptonight_triple_hash<CRYPTONIGHT, true,  VARIANT_V1>,
+        cryptonight_triple_hash<CRYPTONIGHT, true,  VARIANT_1>,
-        cryptonight_quad_hash<CRYPTONIGHT,   true,  VARIANT_V1>,
+        cryptonight_quad_hash<CRYPTONIGHT,   true,  VARIANT_1>,
-        cryptonight_penta_hash<CRYPTONIGHT,  true,  VARIANT_V1>,
+        cryptonight_penta_hash<CRYPTONIGHT,  true,  VARIANT_1>,
+
+        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+
+        cryptonight_single_hash<CRYPTONIGHT, false, VARIANT_XTL>,
+        cryptonight_double_hash<CRYPTONIGHT, false, VARIANT_XTL>,
+        cryptonight_single_hash<CRYPTONIGHT, true,  VARIANT_XTL>,
+        cryptonight_double_hash<CRYPTONIGHT, true,  VARIANT_XTL>,
+        cryptonight_triple_hash<CRYPTONIGHT, false, VARIANT_XTL>,
+        cryptonight_quad_hash<CRYPTONIGHT,   false, VARIANT_XTL>,
+        cryptonight_penta_hash<CRYPTONIGHT,  false, VARIANT_XTL>,
+        cryptonight_triple_hash<CRYPTONIGHT, true,  VARIANT_XTL>,
+        cryptonight_quad_hash<CRYPTONIGHT,   true,  VARIANT_XTL>,
+        cryptonight_penta_hash<CRYPTONIGHT,  true,  VARIANT_XTL>,
 
 #       ifndef XMRIG_NO_AEON
-        cryptonight_single_hash<CRYPTONIGHT_LITE, false, VARIANT_NONE>,
+        cryptonight_single_hash<CRYPTONIGHT_LITE, false, VARIANT_0>,
-        cryptonight_double_hash<CRYPTONIGHT_LITE, false, VARIANT_NONE>,
+        cryptonight_double_hash<CRYPTONIGHT_LITE, false, VARIANT_0>,
-        cryptonight_single_hash<CRYPTONIGHT_LITE, true,  VARIANT_NONE>,
+        cryptonight_single_hash<CRYPTONIGHT_LITE, true,  VARIANT_0>,
-        cryptonight_double_hash<CRYPTONIGHT_LITE, true,  VARIANT_NONE>,
+        cryptonight_double_hash<CRYPTONIGHT_LITE, true,  VARIANT_0>,
-        cryptonight_triple_hash<CRYPTONIGHT_LITE, false, VARIANT_NONE>,
+        cryptonight_triple_hash<CRYPTONIGHT_LITE, false, VARIANT_0>,
-        cryptonight_quad_hash<CRYPTONIGHT_LITE,   false, VARIANT_NONE>,
+        cryptonight_quad_hash<CRYPTONIGHT_LITE,   false, VARIANT_0>,
-        cryptonight_penta_hash<CRYPTONIGHT_LITE,  false, VARIANT_NONE>,
+        cryptonight_penta_hash<CRYPTONIGHT_LITE,  false, VARIANT_0>,
-        cryptonight_triple_hash<CRYPTONIGHT_LITE, true,  VARIANT_NONE>,
+        cryptonight_triple_hash<CRYPTONIGHT_LITE, true,  VARIANT_0>,
-        cryptonight_quad_hash<CRYPTONIGHT_LITE,   true,  VARIANT_NONE>,
+        cryptonight_quad_hash<CRYPTONIGHT_LITE,   true,  VARIANT_0>,
-        cryptonight_penta_hash<CRYPTONIGHT_LITE,  true,  VARIANT_NONE>,
+        cryptonight_penta_hash<CRYPTONIGHT_LITE,  true,  VARIANT_0>,
 
-        cryptonight_single_hash<CRYPTONIGHT_LITE, false, VARIANT_V1>,
+        cryptonight_single_hash<CRYPTONIGHT_LITE, false, VARIANT_1>,
-        cryptonight_double_hash<CRYPTONIGHT_LITE, false, VARIANT_V1>,
+        cryptonight_double_hash<CRYPTONIGHT_LITE, false, VARIANT_1>,
-        cryptonight_single_hash<CRYPTONIGHT_LITE, true,  VARIANT_V1>,
+        cryptonight_single_hash<CRYPTONIGHT_LITE, true,  VARIANT_1>,
-        cryptonight_double_hash<CRYPTONIGHT_LITE, true,  VARIANT_V1>,
+        cryptonight_double_hash<CRYPTONIGHT_LITE, true,  VARIANT_1>,
-        cryptonight_triple_hash<CRYPTONIGHT_LITE, false, VARIANT_V1>,
+        cryptonight_triple_hash<CRYPTONIGHT_LITE, false, VARIANT_1>,
-        cryptonight_quad_hash<CRYPTONIGHT_LITE,   false, VARIANT_V1>,
+        cryptonight_quad_hash<CRYPTONIGHT_LITE,   false, VARIANT_1>,
-        cryptonight_penta_hash<CRYPTONIGHT_LITE,  false, VARIANT_V1>,
+        cryptonight_penta_hash<CRYPTONIGHT_LITE,  false, VARIANT_1>,
-        cryptonight_triple_hash<CRYPTONIGHT_LITE, true,  VARIANT_V1>,
+        cryptonight_triple_hash<CRYPTONIGHT_LITE, true,  VARIANT_1>,
-        cryptonight_quad_hash<CRYPTONIGHT_LITE,   true,  VARIANT_V1>,
+        cryptonight_quad_hash<CRYPTONIGHT_LITE,   true,  VARIANT_1>,
-        cryptonight_penta_hash<CRYPTONIGHT_LITE,  true,  VARIANT_V1>,
+        cryptonight_penta_hash<CRYPTONIGHT_LITE,  true,  VARIANT_1>,
+
+        cryptonight_single_hash<CRYPTONIGHT_LITE, false, VARIANT_IPBC>,
+        cryptonight_double_hash<CRYPTONIGHT_LITE, false, VARIANT_IPBC>,
+        cryptonight_single_hash<CRYPTONIGHT_LITE, true,  VARIANT_IPBC>,
+        cryptonight_double_hash<CRYPTONIGHT_LITE, true,  VARIANT_IPBC>,
+        cryptonight_triple_hash<CRYPTONIGHT_LITE, false, VARIANT_IPBC>,
+        cryptonight_quad_hash<CRYPTONIGHT_LITE,   false, VARIANT_IPBC>,
+        cryptonight_penta_hash<CRYPTONIGHT_LITE,  false, VARIANT_IPBC>,
+        cryptonight_triple_hash<CRYPTONIGHT_LITE, true,  VARIANT_IPBC>,
+        cryptonight_quad_hash<CRYPTONIGHT_LITE,   true,  VARIANT_IPBC>,
+        cryptonight_penta_hash<CRYPTONIGHT_LITE,  true,  VARIANT_IPBC>,
+
+        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
 #       else
         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
 #       endif
 
 #       ifndef XMRIG_NO_SUMO
-        cryptonight_single_hash<CRYPTONIGHT_HEAVY, false, VARIANT_NONE>,
+        cryptonight_single_hash<CRYPTONIGHT_HEAVY, false, VARIANT_0>,
-        cryptonight_double_hash<CRYPTONIGHT_HEAVY, false, VARIANT_NONE>,
+        cryptonight_double_hash<CRYPTONIGHT_HEAVY, false, VARIANT_0>,
-        cryptonight_single_hash<CRYPTONIGHT_HEAVY, true,  VARIANT_NONE>,
+        cryptonight_single_hash<CRYPTONIGHT_HEAVY, true,  VARIANT_0>,
-        cryptonight_double_hash<CRYPTONIGHT_HEAVY, true,  VARIANT_NONE>,
+        cryptonight_double_hash<CRYPTONIGHT_HEAVY, true,  VARIANT_0>,
-        cryptonight_triple_hash<CRYPTONIGHT_HEAVY, false, VARIANT_NONE>,
+        cryptonight_triple_hash<CRYPTONIGHT_HEAVY, false, VARIANT_0>,
-        cryptonight_quad_hash<CRYPTONIGHT_HEAVY,   false, VARIANT_NONE>,
+        cryptonight_quad_hash<CRYPTONIGHT_HEAVY,   false, VARIANT_0>,
-        cryptonight_penta_hash<CRYPTONIGHT_HEAVY,  false, VARIANT_NONE>,
+        cryptonight_penta_hash<CRYPTONIGHT_HEAVY,  false, VARIANT_0>,
-        cryptonight_triple_hash<CRYPTONIGHT_HEAVY, true,  VARIANT_NONE>,
+        cryptonight_triple_hash<CRYPTONIGHT_HEAVY, true,  VARIANT_0>,
-        cryptonight_quad_hash<CRYPTONIGHT_HEAVY,   true,  VARIANT_NONE>,
+        cryptonight_quad_hash<CRYPTONIGHT_HEAVY,   true,  VARIANT_0>,
-        cryptonight_penta_hash<CRYPTONIGHT_HEAVY,  true,  VARIANT_NONE>,
+        cryptonight_penta_hash<CRYPTONIGHT_HEAVY,  true,  VARIANT_0>,
 #       else
         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
 #       endif
@@ -132,11 +160,22 @@ xmrig::CpuThread::cn_hash_fun xmrig::CpuThread::fn(Algo algorithm, AlgoVariant a
 
 #   ifndef XMRIG_NO_SUMO
     if (algorithm == CRYPTONIGHT_HEAVY) {
-        variant = VARIANT_NONE;
+        variant = VARIANT_0;
     }
 #   endif
 
-    return func_table[20 * algorithm + 10 * variant + av - 1];
+    const size_t index = 40 * algorithm + 10 * variant + av - 1;
+
+#   ifndef NDEBUG
+    cn_hash_fun func = func_table[index];
+
+    assert(index < sizeof(func_table) / sizeof(func_table[0]));
+    assert(func != nullptr);
+
+    return func;
+#   else
+    return func_table[index];
+#   endif
 }
 
 
@@ -252,7 +291,6 @@ rapidjson::Value xmrig::CpuThread::toAPI(rapidjson::Document &doc) const
     auto &allocator = doc.GetAllocator();
 
     obj.AddMember("type",          "cpu", allocator);
-    obj.AddMember("algo",           rapidjson::StringRef(Pool::algoName(algorithm())), allocator);
     obj.AddMember("av",             m_av, allocator);
     obj.AddMember("low_power_mode", multiway(), allocator);
     obj.AddMember("affine_to_cpu",  affinity(), allocator);

src/workers/Hashrate.cpp

@@ -29,9 +29,9 @@
 #include <stdio.h>
 
 
+#include "common/log/Log.h"
 #include "core/Config.h"
 #include "core/Controller.h"
-#include "log/Log.h"
 #include "workers/Hashrate.h"
 
 

src/workers/MultiWorker.cpp

@@ -50,23 +50,31 @@ MultiWorker<N>::~MultiWorker()
 template<size_t N>
 bool MultiWorker<N>::selfTest()
 {
-    if (m_thread->fn(xmrig::VARIANT_NONE) == nullptr) {
+    if (m_thread->fn(xmrig::VARIANT_0) == nullptr) {
         return false;
     }
 
-    m_thread->fn(xmrig::VARIANT_NONE)(test_input, 76, m_hash, m_ctx);
+    m_thread->fn(xmrig::VARIANT_0)(test_input, 76, m_hash, m_ctx);
 
     if (m_thread->algorithm() == xmrig::CRYPTONIGHT && memcmp(m_hash, test_output_v0, sizeof m_hash) == 0) {
-        m_thread->fn(xmrig::VARIANT_V1)(test_input, 76, m_hash, m_ctx);
+        m_thread->fn(xmrig::VARIANT_1)(test_input, 76, m_hash, m_ctx);
+        if (memcmp(m_hash, test_output_v1, sizeof m_hash) != 0) {
+            return false;
+        }
 
-        return memcmp(m_hash, test_output_v1, sizeof m_hash) == 0;
+        m_thread->fn(xmrig::VARIANT_XTL)(test_input, 76, m_hash, m_ctx);
+        return memcmp(m_hash, test_output_xtl, sizeof m_hash) == 0;
     }
 
 #   ifndef XMRIG_NO_AEON
     if (m_thread->algorithm() == xmrig::CRYPTONIGHT_LITE && memcmp(m_hash, test_output_v0_lite, sizeof m_hash) == 0) {
-        m_thread->fn(xmrig::VARIANT_V1)(test_input, 76, m_hash, m_ctx);
+        m_thread->fn(xmrig::VARIANT_1)(test_input, 76, m_hash, m_ctx);
+        if (memcmp(m_hash, test_output_v1_lite, sizeof m_hash) != 0) {
+            return false;
+        }
 
-        return memcmp(m_hash, test_output_v1_lite, sizeof m_hash) == 0;
+        m_thread->fn(xmrig::VARIANT_IPBC)(test_input, 76, m_hash, m_ctx);
+        return memcmp(m_hash, test_output_ipbc_lite, sizeof m_hash) == 0;
     }
 #   endif
 
@@ -104,7 +112,7 @@ void MultiWorker<N>::start()
 
             for (size_t i = 0; i < N; ++i) {
                 if (*reinterpret_cast<uint64_t*>(m_hash + (i * 32) + 24) < m_state.job.target()) {
-                    Workers::submit(JobResult(m_state.job.poolId(), m_state.job.id(), *nonce(i), m_hash + (i * 32), m_state.job.diff()));
+                    Workers::submit(JobResult(m_state.job.poolId(), m_state.job.id(), *nonce(i), m_hash + (i * 32), m_state.job.diff(), m_state.job.algorithm()));
                 }
 
                 *nonce(i) += 1;

src/workers/MultiWorker.h

@@ -26,8 +26,8 @@
 #define __MULTIWORKER_H__
 
 
+#include "common/net/Job.h"
 #include "Mem.h"
-#include "net/Job.h"
 #include "net/JobResult.h"
 #include "workers/Worker.h"
 

src/workers/Workers.cpp

@@ -26,12 +26,12 @@
 
 
 #include "api/Api.h"
+#include "common/log/Log.h"
 #include "core/Config.h"
 #include "core/Controller.h"
 #include "crypto/CryptoNight_constants.h"
 #include "interfaces/IJobResultListener.h"
 #include "interfaces/IThread.h"
-#include "log/Log.h"
 #include "Mem.h"
 #include "rapidjson/document.h"
 #include "workers/Handle.h"
@@ -132,8 +132,8 @@ void Workers::setJob(const Job &job, bool donate)
 void Workers::start(xmrig::Controller *controller)
 {
     const std::vector<xmrig::IThread *> &threads = controller->config()->threads();
-    m_status.algo    = controller->config()->algorithm();
+    m_status.algo    = controller->config()->algorithm().algo();
-    m_status.colors  = controller->config()->isHugePages();
+    m_status.colors  = controller->config()->isColors();
     m_status.threads = threads.size();
 
     for (const xmrig::IThread *thread : threads) {
@@ -301,9 +301,9 @@ void Workers::start(IWorker *worker)
         const size_t memory  = m_status.ways * xmrig::cn_select_memory(m_status.algo) / 1048576;
 
         if (m_status.colors) {
-            LOG_INFO("\x1B[01;32mREADY (CPU)\x1B[0m threads \x1B[01;36m%zu(%zu)\x1B[0m huge pages %s%zu/%zu %1.0f%%\x1B[0m memory \x1B[01;36m%zu.0 MB",
+            LOG_INFO(GREEN_BOLD("READY (CPU)") " threads " CYAN_BOLD("%zu(%zu)") " huge pages %s%zu/%zu %1.0f%%\x1B[0m memory " CYAN_BOLD("%zu.0 MB") "",
                      m_status.threads, m_status.ways,
-                     (m_status.hugePages == m_status.pages ? "\x1B[01;32m" : (m_status.hugePages == 0 ? "\x1B[01;31m" : "\x1B[01;33m")),
+                     (m_status.hugePages == m_status.pages ? "\x1B[1;32m" : (m_status.hugePages == 0 ? "\x1B[1;31m" : "\x1B[1;33m")),
                      m_status.hugePages, m_status.pages, percent, memory);
         }
         else {

src/workers/Workers.h

@@ -30,7 +30,7 @@
 #include <uv.h>
 #include <vector>
 
-#include "net/Job.h"
+#include "common/net/Job.h"
 #include "net/JobResult.h"
 #include "rapidjson/fwd.h"
 

test/CMakeLists.txt

@@ -1,9 +0,0 @@
-project("xmrig-test" C)
-cmake_minimum_required(VERSION 3.0)
-
-include(CTest)
-
-add_subdirectory(unity)
-add_subdirectory(cryptonight)
-add_subdirectory(cryptonight_lite)
-add_subdirectory(autoconf)

test/autoconf/CMakeLists.txt

@@ -1,16 +0,0 @@
-set(SOURCES
-    autoconf.c
-    ../../cpu.h
-    ../../cpu.c
-   )
-
-add_executable(autoconf_app ${SOURCES})
-target_link_libraries(autoconf_app unity)
-
-include_directories(../..)
-
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-strict-aliasing")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O2")
-add_definitions(-DBUILD_TEST)
-
-add_test(autoconf_test autoconf_app)

test/autoconf/autoconf.c

@@ -1,152 +0,0 @@
-#include <unity.h>
-
-#include "cpu.h"
-#include "options.h"
-
-struct cpu_info cpu_info = { 0 };
-
-
-static void set_cpu_info(int total_logical_cpus, int l2_cache, int l3_cache) {
-    cpu_info.total_cores        = total_logical_cpus;
-    cpu_info.total_logical_cpus = total_logical_cpus;
-    cpu_info.l2_cache           = l2_cache;
-    cpu_info.l3_cache           = l3_cache;
-}
-
-
-void test_autoconf_should_GetOptimalThreadsCounti7(void) {
-    set_cpu_info(8, 1024, 8192); // 4C/8T 8 MB (Generic i7 CPU)
-
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 100));
-    TEST_ASSERT_EQUAL_INT(2, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(8, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 100));
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(6, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 75));
-    TEST_ASSERT_EQUAL_INT(5, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 60));
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 50));
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 35));
-    TEST_ASSERT_EQUAL_INT(2, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 20));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 5));
-}
-
-
-void test_autoconf_should_GetOptimalThreadsCounti5(void) {
-    set_cpu_info(4, 1024, 6144); // 2C/4T 6 MB (Generic i5 CPU)
-
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 100));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 75));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 75));
-
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 100));
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 75));
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 75));
-}
-
-
-void test_autoconf_should_GetOptimalThreadsCounti3(void) {
-    set_cpu_info(4, 512, 3072); // 2C/4T 3 MB (Generic i3 CPU)
-
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 100));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 75));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 75));
-
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 100));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 75));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 75));
-}
-
-
-void test_autoconf_should_GetOptimalThreadsCountR7(void) {
-    set_cpu_info(16, 4096, 16384); // 8C/16T 16 MB (AMD Ryzen 7)
-
-    TEST_ASSERT_EQUAL_INT(8, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 100));
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(8, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 75));
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 75));
-
-    TEST_ASSERT_EQUAL_INT(16, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 100));
-    TEST_ASSERT_EQUAL_INT(8, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(12, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 75));
-    TEST_ASSERT_EQUAL_INT(8, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 75));
-}
-
-
-void test_autoconf_should_GetOptimalThreadsCountTwoE5620(void) {
-    set_cpu_info(16, 2048, 24576); // 8C/16T 24 MB (Two E5620)
-
-    TEST_ASSERT_EQUAL_INT(12, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 100));
-    TEST_ASSERT_EQUAL_INT(6, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(12, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 75));
-    TEST_ASSERT_EQUAL_INT(6, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 75));
-
-    TEST_ASSERT_EQUAL_INT(16, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 100));
-    TEST_ASSERT_EQUAL_INT(12, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(12, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 75));
-    TEST_ASSERT_EQUAL_INT(12, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 75));
-}
-
-
-void test_autoconf_should_GetOptimalThreadsCountVCPU(void) {
-    set_cpu_info(1, 1024, 15360); // 1C/1T 15 MB (Single core Virtual CPU)
-
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 100));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 75));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 75));
-
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 100));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 75));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 75));
-}
-
-
-void test_autoconf_should_GetOptimalThreadsCountNoL3(void) {
-    set_cpu_info(8, 8192, 0); // 4C/8T (Multi core Virtual CPU without L3 cache)
-
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT, false, 100));
-    TEST_ASSERT_EQUAL_INT(2, get_optimal_threads_count(ALGO_CRYPTONIGHT, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(8, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 100));
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, true, 100));
-
-    TEST_ASSERT_EQUAL_INT(6, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 75));
-    TEST_ASSERT_EQUAL_INT(5, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 60));
-    TEST_ASSERT_EQUAL_INT(4, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 50));
-    TEST_ASSERT_EQUAL_INT(3, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 35));
-    TEST_ASSERT_EQUAL_INT(2, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 20));
-    TEST_ASSERT_EQUAL_INT(1, get_optimal_threads_count(ALGO_CRYPTONIGHT_LITE, false, 5));
-}
-
-
-int main(void)
-{
-    UNITY_BEGIN();
-
-    RUN_TEST(test_autoconf_should_GetOptimalThreadsCounti7);
-    RUN_TEST(test_autoconf_should_GetOptimalThreadsCounti5);
-    RUN_TEST(test_autoconf_should_GetOptimalThreadsCounti3);
-    RUN_TEST(test_autoconf_should_GetOptimalThreadsCountR7);
-    RUN_TEST(test_autoconf_should_GetOptimalThreadsCountR7);
-    RUN_TEST(test_autoconf_should_GetOptimalThreadsCountTwoE5620);
-    RUN_TEST(test_autoconf_should_GetOptimalThreadsCountVCPU);
-    RUN_TEST(test_autoconf_should_GetOptimalThreadsCountNoL3);
-
-    return UNITY_END();
-}

test/cryptonight/CMakeLists.txt

@@ -1,28 +0,0 @@
-set(SOURCES
-    cryptonight.c
-    ../../options.h
-    ../../algo/cryptonight/cryptonight.h
-    ../../algo/cryptonight/cryptonight.c
-    ../../algo/cryptonight/cryptonight_av1_aesni.c
-    ../../algo/cryptonight/cryptonight_av2_aesni_double.c
-    ../../algo/cryptonight/cryptonight_av3_softaes.c
-    ../../algo/cryptonight/cryptonight_av4_softaes_double.c
-    ../../crypto/c_keccak.c
-    ../../crypto/c_blake256.c
-    ../../crypto/c_groestl.c
-    ../../crypto/c_jh.c
-    ../../crypto/c_skein.c
-    ../../crypto/soft_aes.c
-   )
-
-add_executable(cryptonight_app ${SOURCES})
-target_link_libraries(cryptonight_app unity)
-
-include_directories(../..)
-
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes -fno-strict-aliasing")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O2")
-add_definitions(-DBUILD_TEST)
-add_definitions(-DXMRIG_NO_AEON)
-
-add_test(cryptonight_test cryptonight_app)

test/cryptonight/cryptonight.c

@@ -1,136 +0,0 @@
-#include <unity.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <string.h>
-#include <mm_malloc.h>
-
-#include "options.h"
-#include "algo/cryptonight/cryptonight.h"
-
-bool opt_double_hash = false;
-
-const static char input1[152] = {
-    0x03, 0x05, 0xA0, 0xDB, 0xD6, 0xBF, 0x05, 0xCF, 0x16, 0xE5, 0x03, 0xF3, 0xA6, 0x6F, 0x78, 0x00,
-    0x7C, 0xBF, 0x34, 0x14, 0x43, 0x32, 0xEC, 0xBF, 0xC2, 0x2E, 0xD9, 0x5C, 0x87, 0x00, 0x38, 0x3B,
-    0x30, 0x9A, 0xCE, 0x19, 0x23, 0xA0, 0x96, 0x4B, 0x00, 0x00, 0x00, 0x08, 0xBA, 0x93, 0x9A, 0x62,
-    0x72, 0x4C, 0x0D, 0x75, 0x81, 0xFC, 0xE5, 0x76, 0x1E, 0x9D, 0x8A, 0x0E, 0x6A, 0x1C, 0x3F, 0x92,
-    0x4F, 0xDD, 0x84, 0x93, 0xD1, 0x11, 0x56, 0x49, 0xC0, 0x5E, 0xB6, 0x01,
-    0x01, 0x00, 0xFB, 0x8E, 0x8A, 0xC8, 0x05, 0x89, 0x93, 0x23, 0x37, 0x1B, 0xB7, 0x90, 0xDB, 0x19,
-    0x21, 0x8A, 0xFD, 0x8D, 0xB8, 0xE3, 0x75, 0x5D, 0x8B, 0x90, 0xF3, 0x9B, 0x3D, 0x55, 0x06, 0xA9,
-    0xAB, 0xCE, 0x4F, 0xA9, 0x12, 0x24, 0x45, 0x00, 0x00, 0x00, 0x00, 0xEE, 0x81, 0x46, 0xD4, 0x9F,
-    0xA9, 0x3E, 0xE7, 0x24, 0xDE, 0xB5, 0x7D, 0x12, 0xCB, 0xC6, 0xC6, 0xF3, 0xB9, 0x24, 0xD9, 0x46,
-    0x12, 0x7C, 0x7A, 0x97, 0x41, 0x8F, 0x93, 0x48, 0x82, 0x8F, 0x0F, 0x02,
-};
-
-const static char input2[] = "This is a test";
-const static char input3[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus pellentesque metus.";
-
-
-void cryptonight_av1_aesni(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx);
-void cryptonight_av2_aesni_double(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx);
-void cryptonight_av3_softaes(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx);
-void cryptonight_av4_softaes_double(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx);
-
-
-static char hash[64];
-#define RESULT1        "1a3ffbee909b420d91f7be6e5fb56db71b3110d886011e877ee5786afd080100"
-#define RESULT1_DOUBLE "1a3ffbee909b420d91f7be6e5fb56db71b3110d886011e877ee5786afd0801001b606a3f4a07d6489a1bcd07697bd16696b61c8ae982f61a90160f4e52828a7f"
-#define RESULT2        "a084f01d1437a09c6985401b60d43554ae105802c5f5d8a9b3253649c0be6605"
-#define RESULT3        "0bbe54bd26caa92a1d436eec71cbef02560062fa689fe14d7efcf42566b411cf"
-
-
-static char *bin2hex(const unsigned char *p, size_t len)
-{
-    char *s = malloc((len * 2) + 1);
-    if (!s) {
-        return NULL;
-    }
-
-    for (int i = 0; i < len; i++) {
-        sprintf(s + (i * 2), "%02x", (unsigned int) p[i]);
-    }
-
-    return s;
-}
-
-
-static void * create_ctx(int ratio) {
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) _mm_malloc(sizeof(struct cryptonight_ctx), 16);
-    ctx->memory = (uint8_t *) _mm_malloc(MEMORY * ratio, 16);
-
-    return ctx;
-}
-
-
-static void free_ctx(struct cryptonight_ctx *ctx) {
-    _mm_free(ctx->memory);
-    _mm_free(ctx);
-}
-
-
-void test_cryptonight_av1_should_CalcHash(void) {
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) create_ctx(1);
-
-    cryptonight_av1_aesni(input1, 76, &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT1, bin2hex(hash, 32));
-
-    cryptonight_av1_aesni(input2, strlen(input2), &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT2, bin2hex(hash, 32));
-
-    cryptonight_av1_aesni(input3, strlen(input3), &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT3, bin2hex(hash, 32));
-
-    free_ctx(ctx);
-}
-
-
-void test_cryptonight_av2_should_CalcHash(void)
-{
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) create_ctx(2);
-
-    cryptonight_av2_aesni_double(input1, 76, &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT1_DOUBLE, bin2hex(hash, 64));
-
-    free_ctx(ctx);
-}
-
-
-void test_cryptonight_av3_should_CalcHash(void)
-{
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) create_ctx(1);
-
-    cryptonight_av3_softaes(input1, 76, &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT1, bin2hex(hash, 32));
-
-    cryptonight_av3_softaes(input2, strlen(input2), &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT2, bin2hex(hash, 32));
-
-    cryptonight_av3_softaes(input3, strlen(input3), &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT3, bin2hex(hash, 32));
-
-    free_ctx(ctx);
-}
-
-
-void test_cryptonight_av4_should_CalcHash(void)
-{
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) create_ctx(2);
-
-    cryptonight_av4_softaes_double(input1, 76, &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT1_DOUBLE, bin2hex(hash, 64));
-
-    free_ctx(ctx);
-}
-
-
-int main(void)
-{
-    UNITY_BEGIN();
-
-    RUN_TEST(test_cryptonight_av1_should_CalcHash);
-    RUN_TEST(test_cryptonight_av2_should_CalcHash);
-    RUN_TEST(test_cryptonight_av3_should_CalcHash);
-    RUN_TEST(test_cryptonight_av4_should_CalcHash);
-
-    return UNITY_END();
-}

test/cryptonight_lite/CMakeLists.txt

@@ -1,27 +0,0 @@
-set(SOURCES
-    cryptonight_lite.c
-    ../../options.h
-    ../../algo/cryptonight/cryptonight.h
-    ../../algo/cryptonight/cryptonight.c
-    ../../algo/cryptonight-lite/cryptonight_lite_av1_aesni.c
-    ../../algo/cryptonight-lite/cryptonight_lite_av2_aesni_double.c
-    ../../algo/cryptonight-lite/cryptonight_lite_av3_softaes.c
-    ../../algo/cryptonight-lite/cryptonight_lite_av4_softaes_double.c
-    ../../crypto/c_keccak.c
-    ../../crypto/c_blake256.c
-    ../../crypto/c_groestl.c
-    ../../crypto/c_jh.c
-    ../../crypto/c_skein.c
-    ../../crypto/soft_aes.c
-   )
-
-add_executable(cryptonight_lite_app ${SOURCES})
-target_link_libraries(cryptonight_lite_app unity)
-
-include_directories(../..)
-
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes -fno-strict-aliasing")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O2")
-add_definitions(-DBUILD_TEST)
-
-add_test(cryptonight_lite_test cryptonight_lite_app)

test/cryptonight_lite/cryptonight_lite.c

@@ -1,124 +0,0 @@
-#include <unity.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <string.h>
-#include <mm_malloc.h>
-
-#include "options.h"
-#include "algo/cryptonight/cryptonight.h"
-
-bool opt_double_hash = false;
-enum mining_algo opt_algo = ALGO_CRYPTONIGHT_LITE;
-
-const static char input1[152] = {
-    0x03, 0x05, 0xA0, 0xDB, 0xD6, 0xBF, 0x05, 0xCF, 0x16, 0xE5, 0x03, 0xF3, 0xA6, 0x6F, 0x78, 0x00,
-    0x7C, 0xBF, 0x34, 0x14, 0x43, 0x32, 0xEC, 0xBF, 0xC2, 0x2E, 0xD9, 0x5C, 0x87, 0x00, 0x38, 0x3B,
-    0x30, 0x9A, 0xCE, 0x19, 0x23, 0xA0, 0x96, 0x4B, 0x00, 0x00, 0x00, 0x08, 0xBA, 0x93, 0x9A, 0x62,
-    0x72, 0x4C, 0x0D, 0x75, 0x81, 0xFC, 0xE5, 0x76, 0x1E, 0x9D, 0x8A, 0x0E, 0x6A, 0x1C, 0x3F, 0x92,
-    0x4F, 0xDD, 0x84, 0x93, 0xD1, 0x11, 0x56, 0x49, 0xC0, 0x5E, 0xB6, 0x01,
-    0x01, 0x00, 0xFB, 0x8E, 0x8A, 0xC8, 0x05, 0x89, 0x93, 0x23, 0x37, 0x1B, 0xB7, 0x90, 0xDB, 0x19,
-    0x21, 0x8A, 0xFD, 0x8D, 0xB8, 0xE3, 0x75, 0x5D, 0x8B, 0x90, 0xF3, 0x9B, 0x3D, 0x55, 0x06, 0xA9,
-    0xAB, 0xCE, 0x4F, 0xA9, 0x12, 0x24, 0x45, 0x00, 0x00, 0x00, 0x00, 0xEE, 0x81, 0x46, 0xD4, 0x9F,
-    0xA9, 0x3E, 0xE7, 0x24, 0xDE, 0xB5, 0x7D, 0x12, 0xCB, 0xC6, 0xC6, 0xF3, 0xB9, 0x24, 0xD9, 0x46,
-    0x12, 0x7C, 0x7A, 0x97, 0x41, 0x8F, 0x93, 0x48, 0x82, 0x8F, 0x0F, 0x02,
-};
-
-
-void cryptonight_av1_aesni(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx)          {}
-void cryptonight_av2_aesni_double(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx)   {}
-void cryptonight_av3_softaes(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx)        {}
-void cryptonight_av4_softaes_double(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx) {}
-
-void cryptonight_lite_av1_aesni(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx);
-void cryptonight_lite_av2_aesni_double(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx);
-void cryptonight_lite_av3_softaes(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx);
-void cryptonight_lite_av4_softaes_double(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx);
-
-
-static char hash[64];
-#define RESULT1        "3695b4b53bb00358b0ad38dc160feb9e004eece09b83a72ef6ba9864d3510c88"
-#define RESULT1_DOUBLE "3695b4b53bb00358b0ad38dc160feb9e004eece09b83a72ef6ba9864d3510c8828a22bad3f93d1408fca472eb5ad1cbe75f21d053c8ce5b3af105a57713e21dd"
-
-
-static char *bin2hex(const unsigned char *p, size_t len)
-{
-    char *s = malloc((len * 2) + 1);
-    if (!s) {
-        return NULL;
-    }
-
-    for (int i = 0; i < len; i++) {
-        sprintf(s + (i * 2), "%02x", (unsigned int) p[i]);
-    }
-
-    return s;
-}
-
-
-static void * create_ctx(int ratio) {
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) _mm_malloc(sizeof(struct cryptonight_ctx), 16);
-    ctx->memory = (uint8_t *) _mm_malloc(MEMORY_LITE * ratio, 16);
-
-    return ctx;
-}
-
-
-static void free_ctx(struct cryptonight_ctx *ctx) {
-    _mm_free(ctx->memory);
-    _mm_free(ctx);
-}
-
-
-void test_cryptonight_lite_av1_should_CalcHash(void) {
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) create_ctx(1);
-
-    cryptonight_lite_av1_aesni(input1, 76, &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT1, bin2hex(hash, 32));
-
-    free_ctx(ctx);
-}
-
-
-void test_cryptonight_lite_av2_should_CalcHash(void)
-{
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) create_ctx(2);
-
-    cryptonight_lite_av2_aesni_double(input1, 76, &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT1_DOUBLE, bin2hex(hash, 64));
-
-    free_ctx(ctx);
-}
-
-
-void test_cryptonight_lite_av3_should_CalcHash(void) {
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) create_ctx(1);
-
-    cryptonight_lite_av3_softaes(input1, 76, &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT1, bin2hex(hash, 32));
-
-    free_ctx(ctx);
-}
-
-
-void test_cryptonight_lite_av4_should_CalcHash(void)
-{
-    struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) create_ctx(2);
-
-    cryptonight_lite_av4_softaes_double(input1, 76, &hash, ctx);
-    TEST_ASSERT_EQUAL_STRING(RESULT1_DOUBLE, bin2hex(hash, 64));
-
-    free_ctx(ctx);
-}
-
-
-int main(void)
-{
-    UNITY_BEGIN();
-
-    RUN_TEST(test_cryptonight_lite_av1_should_CalcHash);
-    RUN_TEST(test_cryptonight_lite_av2_should_CalcHash);
-    RUN_TEST(test_cryptonight_lite_av3_should_CalcHash);
-    RUN_TEST(test_cryptonight_lite_av4_should_CalcHash);
-
-    return UNITY_END();
-}

test/unity/CMakeLists.txt

@@ -1,2 +0,0 @@
-add_library(unity STATIC unity.c)
-target_include_directories(unity PUBLIC .)

test/unity/unity.h

@@ -1,293 +0,0 @@
-/* ==========================================
-    Unity Project - A Test Framework for C
-    Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-#ifndef UNITY_FRAMEWORK_H
-#define UNITY_FRAMEWORK_H
-#define UNITY
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include "unity_internals.h"
-
-void setUp(void);
-void tearDown(void);
-
-/*-------------------------------------------------------
- * Configuration Options
- *-------------------------------------------------------
- * All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above.
-
- * Integers/longs/pointers
- *     - Unity attempts to automatically discover your integer sizes
- *       - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h>
- *       - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h>
- *     - If you cannot use the automatic methods above, you can force Unity by using these options:
- *       - define UNITY_SUPPORT_64
- *       - set UNITY_INT_WIDTH
- *       - set UNITY_LONG_WIDTH
- *       - set UNITY_POINTER_WIDTH
-
- * Floats
- *     - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons
- *     - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT
- *     - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats
- *     - define UNITY_FLOAT_VERBOSE to print floating point values in errors (uses sprintf)
- *     - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons
- *     - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default)
- *     - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE
- *     - define UNITY_DOUBLE_TYPE to specify something other than double
- *     - define UNITY_DOUBLE_VERBOSE to print floating point values in errors (uses sprintf)
- *     - define UNITY_VERBOSE_NUMBER_MAX_LENGTH to change maximum length of printed numbers (used by sprintf)
-
- * Output
- *     - by default, Unity prints to standard out with putchar.  define UNITY_OUTPUT_CHAR(a) with a different function if desired
- *     - define UNITY_DIFFERENTIATE_FINAL_FAIL to print FAILED (vs. FAIL) at test end summary - for automated search for failure
-
- * Optimization
- *     - by default, line numbers are stored in unsigned shorts.  Define UNITY_LINE_TYPE with a different type if your files are huge
- *     - by default, test and failure counters are unsigned shorts.  Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests.
-
- * Test Cases
- *     - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script
-
- * Parameterized Tests
- *     - you'll want to create a define of TEST_CASE(...) which basically evaluates to nothing
-
- * Tests with Arguments
- *     - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity
-
- *-------------------------------------------------------
- * Basic Fail and Ignore
- *-------------------------------------------------------*/
-
-#define TEST_FAIL_MESSAGE(message)                                                                 UNITY_TEST_FAIL(__LINE__, (message))
-#define TEST_FAIL()                                                                                UNITY_TEST_FAIL(__LINE__, NULL)
-#define TEST_IGNORE_MESSAGE(message)                                                               UNITY_TEST_IGNORE(__LINE__, (message))
-#define TEST_IGNORE()                                                                              UNITY_TEST_IGNORE(__LINE__, NULL)
-#define TEST_ONLY()
-
-/* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails.
- * This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */
-#define TEST_PASS()                                                                                longjmp(Unity.AbortFrame, 1)
-
-/*-------------------------------------------------------
- * Test Asserts (simple)
- *-------------------------------------------------------*/
-
-/* Boolean */
-#define TEST_ASSERT(condition)                                                                     UNITY_TEST_ASSERT(       (condition), __LINE__, " Expression Evaluated To FALSE")
-#define TEST_ASSERT_TRUE(condition)                                                                UNITY_TEST_ASSERT(       (condition), __LINE__, " Expected TRUE Was FALSE")
-#define TEST_ASSERT_UNLESS(condition)                                                              UNITY_TEST_ASSERT(      !(condition), __LINE__, " Expression Evaluated To TRUE")
-#define TEST_ASSERT_FALSE(condition)                                                               UNITY_TEST_ASSERT(      !(condition), __LINE__, " Expected FALSE Was TRUE")
-#define TEST_ASSERT_NULL(pointer)                                                                  UNITY_TEST_ASSERT_NULL(    (pointer), __LINE__, " Expected NULL")
-#define TEST_ASSERT_NOT_NULL(pointer)                                                              UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL")
-
-/* Integers (of all sizes) */
-#define TEST_ASSERT_EQUAL_INT(expected, actual)                                                    UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_INT8(expected, actual)                                                   UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_INT16(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_INT32(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_INT64(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL(expected, actual)                                                        UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_NOT_EQUAL(expected, actual)                                                    UNITY_TEST_ASSERT(((expected) !=  (actual)), __LINE__, " Expected Not-Equal")
-#define TEST_ASSERT_EQUAL_UINT(expected, actual)                                                   UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT8(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT16(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT32(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT64(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX(expected, actual)                                                    UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX8(expected, actual)                                                   UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX16(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX32(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX64(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BITS(mask, expected, actual)                                                   UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BITS_HIGH(mask, actual)                                                        UNITY_TEST_ASSERT_BITS((mask), (_UU32)(-1), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BITS_LOW(mask, actual)                                                         UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BIT_HIGH(bit, actual)                                                          UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(-1), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BIT_LOW(bit, actual)                                                           UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(0), (actual), __LINE__, NULL)
-
-/* Integer Ranges (of all sizes) */
-#define TEST_ASSERT_INT_WITHIN(delta, expected, actual)                                            UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_INT8_WITHIN(delta, expected, actual)                                           UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_INT16_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_INT32_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_INT64_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_UINT_WITHIN(delta, expected, actual)                                           UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_UINT8_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_UINT16_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_UINT32_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_UINT64_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_HEX_WITHIN(delta, expected, actual)                                            UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual)                                           UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-
-/* Structs and Strings */
-#define TEST_ASSERT_EQUAL_PTR(expected, actual)                                                    UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_STRING(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len)                                        UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len)                                            UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, NULL)
-
-/* Arrays */
-#define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements)                                UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements)                               UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements)                               UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements)                                UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements)                               UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements)                                UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements)                        UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, NULL)
-
-/* Floating Point (If Enabled) */
-#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual)                                          UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_FLOAT(expected, actual)                                                  UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements)                              UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_INF(actual)                                                           UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_NEG_INF(actual)                                                       UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_NAN(actual)                                                           UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_DETERMINATE(actual)                                                   UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_NOT_INF(actual)                                                       UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual)                                                   UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_NOT_NAN(actual)                                                       UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual)                                               UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, NULL)
-
-/* Double (If Enabled) */
-#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual)                                         UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_DOUBLE(expected, actual)                                                 UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements)                             UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_INF(actual)                                                          UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual)                                                      UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_NAN(actual)                                                          UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual)                                                  UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_NOT_INF(actual)                                                      UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual)                                                  UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual)                                                      UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual)                                              UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL)
-
-/*-------------------------------------------------------
- * Test Asserts (with additional messages)
- *-------------------------------------------------------*/
-
-/* Boolean */
-#define TEST_ASSERT_MESSAGE(condition, message)                                                    UNITY_TEST_ASSERT(       (condition), __LINE__, (message))
-#define TEST_ASSERT_TRUE_MESSAGE(condition, message)                                               UNITY_TEST_ASSERT(       (condition), __LINE__, (message))
-#define TEST_ASSERT_UNLESS_MESSAGE(condition, message)                                             UNITY_TEST_ASSERT(      !(condition), __LINE__, (message))
-#define TEST_ASSERT_FALSE_MESSAGE(condition, message)                                              UNITY_TEST_ASSERT(      !(condition), __LINE__, (message))
-#define TEST_ASSERT_NULL_MESSAGE(pointer, message)                                                 UNITY_TEST_ASSERT_NULL(    (pointer), __LINE__, (message))
-#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message)                                             UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message))
-
-/* Integers (of all sizes) */
-#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message)                                  UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message)                                       UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT(((expected) !=  (actual)), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message)                                  UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message)                                  UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message)                                  UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message)                                       UNITY_TEST_ASSERT_BITS((mask), (_UU32)(-1), (actual), __LINE__, (message))
-#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message)                                        UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, (message))
-#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message)                                         UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(-1), (actual), __LINE__, (message))
-#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message)                                          UNITY_TEST_ASSERT_BITS(((_UU32)1 << (bit)), (_UU32)(0), (actual), __LINE__, (message))
-
-/* Integer Ranges (of all sizes) */
-#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message)                           UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message)                          UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_INT16_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_INT32_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_INT64_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_UINT_WITHIN_MESSAGE(delta, expected, actual, message)                          UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_UINT8_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_UINT16_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_UINT32_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_UINT64_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message)                           UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message)                          UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message))
-
-/* Structs and Strings */
-#define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message)                                   UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message)                       UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message)                           UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message))
-
-/* Arrays */
-#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message)               UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message)               UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message)              UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message)               UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message)       UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, (message))
-
-/* Floating Point (If Enabled) */
-#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message)                         UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message)                                 UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message)             UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message)                                          UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, (message))
-#define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message)                                      UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, (message))
-#define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message)                                          UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, (message))
-#define TEST_ASSERT_FLOAT_IS_DETERMINATE_MESSAGE(actual, message)                                  UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, (message))
-#define TEST_ASSERT_FLOAT_IS_NOT_INF_MESSAGE(actual, message)                                      UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, (message))
-#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF_MESSAGE(actual, message)                                  UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, (message))
-#define TEST_ASSERT_FLOAT_IS_NOT_NAN_MESSAGE(actual, message)                                      UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, (message))
-#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE_MESSAGE(actual, message)                              UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, (message))
-
-/* Double (If Enabled) */
-#define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message)                        UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message)                                UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message))
-#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message)            UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message))
-#define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message)                                         UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, (message))
-#define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message)                                     UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, (message))
-#define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message)                                         UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, (message))
-#define TEST_ASSERT_DOUBLE_IS_DETERMINATE_MESSAGE(actual, message)                                 UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, (message))
-#define TEST_ASSERT_DOUBLE_IS_NOT_INF_MESSAGE(actual, message)                                     UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, (message))
-#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF_MESSAGE(actual, message)                                 UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, (message))
-#define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message)                                     UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message))
-#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message)                             UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message))
-
-/* end of UNITY_FRAMEWORK_H */
-#ifdef __cplusplus
-}
-#endif
-#endif

test/unity/unity_internals.h

@@ -1,749 +0,0 @@
-/* ==========================================
-    Unity Project - A Test Framework for C
-    Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-#ifndef UNITY_INTERNALS_H
-#define UNITY_INTERNALS_H
-
-#ifdef UNITY_INCLUDE_CONFIG_H
-#include "unity_config.h"
-#endif
-
-#include <setjmp.h>
-
-#ifndef UNITY_EXCLUDE_MATH_H
-#include <math.h>
-#endif
-
-/* Unity Attempts to Auto-Detect Integer Types
- * Attempt 1: UINT_MAX, ULONG_MAX in <limits.h>, or default to 32 bits
- * Attempt 2: UINTPTR_MAX in <stdint.h>, or default to same size as long
- * The user may override any of these derived constants:
- * UNITY_INT_WIDTH, UNITY_LONG_WIDTH, UNITY_POINTER_WIDTH */
-#ifndef UNITY_EXCLUDE_STDINT_H
-#include <stdint.h>
-#endif
-
-#ifndef UNITY_EXCLUDE_LIMITS_H
-#include <limits.h>
-#endif
-
-/*-------------------------------------------------------
- * Guess Widths If Not Specified
- *-------------------------------------------------------*/
-
-/* Determine the size of an int, if not already specified.
- * We cannot use sizeof(int), because it is not yet defined
- * at this stage in the translation of the C program.
- * Therefore, infer it from UINT_MAX if possible. */
-#ifndef UNITY_INT_WIDTH
-  #ifdef UINT_MAX
-    #if (UINT_MAX == 0xFFFF)
-      #define UNITY_INT_WIDTH (16)
-    #elif (UINT_MAX == 0xFFFFFFFF)
-      #define UNITY_INT_WIDTH (32)
-    #elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF)
-      #define UNITY_INT_WIDTH (64)
-    #endif
-  #else /* Set to default */
-    #define UNITY_INT_WIDTH (32)
-  #endif /* UINT_MAX */
-#endif
-
-/* Determine the size of a long, if not already specified. */
-#ifndef UNITY_LONG_WIDTH
-  #ifdef ULONG_MAX
-    #if (ULONG_MAX == 0xFFFF)
-      #define UNITY_LONG_WIDTH (16)
-    #elif (ULONG_MAX == 0xFFFFFFFF)
-      #define UNITY_LONG_WIDTH (32)
-    #elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF)
-      #define UNITY_LONG_WIDTH (64)
-    #endif
-  #else /* Set to default */
-    #define UNITY_LONG_WIDTH (32)
-  #endif /* ULONG_MAX */
-#endif
-
-/* Determine the size of a pointer, if not already specified. */
-#ifndef UNITY_POINTER_WIDTH
-  #ifdef UINTPTR_MAX
-    #if (UINTPTR_MAX <= 0xFFFF)
-      #define UNITY_POINTER_WIDTH (16)
-    #elif (UINTPTR_MAX <= 0xFFFFFFFF)
-      #define UNITY_POINTER_WIDTH (32)
-    #elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF)
-      #define UNITY_POINTER_WIDTH (64)
-    #endif
-  #else /* Set to default */
-    #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH
-  #endif /* UINTPTR_MAX */
-#endif
-
-/*-------------------------------------------------------
- * Int Support (Define types based on detected sizes)
- *-------------------------------------------------------*/
-
-#if (UNITY_INT_WIDTH == 32)
-    typedef unsigned char   _UU8;
-    typedef unsigned short  _UU16;
-    typedef unsigned int    _UU32;
-    typedef signed char     _US8;
-    typedef signed short    _US16;
-    typedef signed int      _US32;
-#elif (UNITY_INT_WIDTH == 16)
-    typedef unsigned char   _UU8;
-    typedef unsigned int    _UU16;
-    typedef unsigned long   _UU32;
-    typedef signed char     _US8;
-    typedef signed int      _US16;
-    typedef signed long     _US32;
-#else
-    #error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported)
-#endif
-
-/*-------------------------------------------------------
- * 64-bit Support
- *-------------------------------------------------------*/
-
-#ifndef UNITY_SUPPORT_64
-  #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64
-    #define UNITY_SUPPORT_64
-  #endif
-#endif
-
-#ifndef UNITY_SUPPORT_64
-    /* No 64-bit Support */
-    typedef _UU32 _U_UINT;
-    typedef _US32 _U_SINT;
-#else
-
-    /* 64-bit Support */
-  #if (UNITY_LONG_WIDTH == 32)
-    typedef unsigned long long _UU64;
-    typedef signed long long   _US64;
-  #elif (UNITY_LONG_WIDTH == 64)
-    typedef unsigned long      _UU64;
-    typedef signed long        _US64;
-  #else
-    #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported)
-  #endif
-    typedef _UU64 _U_UINT;
-    typedef _US64 _U_SINT;
-
-#endif
-
-/*-------------------------------------------------------
- * Pointer Support
- *-------------------------------------------------------*/
-
-#if (UNITY_POINTER_WIDTH == 32)
-    typedef _UU32 _UP;
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32
-#elif (UNITY_POINTER_WIDTH == 64)
-    typedef _UU64 _UP;
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64
-#elif (UNITY_POINTER_WIDTH == 16)
-    typedef _UU16 _UP;
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16
-#else
-    #error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported)
-#endif
-
-#ifndef UNITY_PTR_ATTRIBUTE
-#define UNITY_PTR_ATTRIBUTE
-#endif
-
-#ifndef UNITY_INTERNAL_PTR
-#define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void*
-/* #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const _UU8* */
-#endif
-
-/*-------------------------------------------------------
- * Float Support
- *-------------------------------------------------------*/
-
-#ifdef UNITY_EXCLUDE_FLOAT
-
-/* No Floating Point Support */
-#undef UNITY_INCLUDE_FLOAT
-#undef UNITY_FLOAT_PRECISION
-#undef UNITY_FLOAT_TYPE
-#undef UNITY_FLOAT_VERBOSE
-
-#else
-
-#ifndef UNITY_INCLUDE_FLOAT
-#define UNITY_INCLUDE_FLOAT
-#endif
-
-/* Floating Point Support */
-#ifndef UNITY_FLOAT_PRECISION
-#define UNITY_FLOAT_PRECISION (0.00001f)
-#endif
-#ifndef UNITY_FLOAT_TYPE
-#define UNITY_FLOAT_TYPE float
-#endif
-typedef UNITY_FLOAT_TYPE _UF;
-
-#ifndef isinf
-/* The value of Inf - Inf is NaN */
-#define isinf(n) (isnan((n) - (n)) && !isnan(n))
-#endif
-
-#ifndef isnan
-/* NaN is the only floating point value that does NOT equal itself.
- * Therefore if n != n, then it is NaN. */
-#define isnan(n) ((n != n) ? 1 : 0)
-#endif
-
-#ifndef isneg
-#define isneg(n) ((n < 0.0f) ? 1 : 0)
-#endif
-
-#ifndef ispos
-#define ispos(n) ((n > 0.0f) ? 1 : 0)
-#endif
-
-#endif
-
-/*-------------------------------------------------------
- * Double Float Support
- *-------------------------------------------------------*/
-
-/* unlike FLOAT, we DON'T include by default */
-#ifndef UNITY_EXCLUDE_DOUBLE
-  #ifndef UNITY_INCLUDE_DOUBLE
-  #define UNITY_EXCLUDE_DOUBLE
-  #endif
-#endif
-
-#ifdef UNITY_EXCLUDE_DOUBLE
-
-  /* No Floating Point Support */
-  #undef UNITY_DOUBLE_PRECISION
-  #undef UNITY_DOUBLE_TYPE
-  #undef UNITY_DOUBLE_VERBOSE
-
-  #ifdef UNITY_INCLUDE_DOUBLE
-    #undef UNITY_INCLUDE_DOUBLE
-  #endif
-
-  #ifdef UNITY_FLOAT_VERBOSE
-    typedef _UF _UD;
-    /* For parameter in UnityPrintFloat, double promotion required */
-  #endif
-
-#else
-
-  /* Double Floating Point Support */
-  #ifndef UNITY_DOUBLE_PRECISION
-  #define UNITY_DOUBLE_PRECISION (1e-12f)
-  #endif
-
-  #ifndef UNITY_DOUBLE_TYPE
-  #define UNITY_DOUBLE_TYPE double
-  #endif
-  typedef UNITY_DOUBLE_TYPE _UD;
-
-#endif
-
-#ifdef UNITY_DOUBLE_VERBOSE
-#ifndef UNITY_FLOAT_VERBOSE
-#define UNITY_FLOAT_VERBOSE
-#endif
-#endif
-
-/*-------------------------------------------------------
- * Output Method: stdout (DEFAULT)
- *-------------------------------------------------------*/
-#ifndef UNITY_OUTPUT_CHAR
-/* Default to using putchar, which is defined in stdio.h */
-#include <stdio.h>
-#define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
-#else
-  /* If defined as something else, make sure we declare it here so it's ready for use */
-  #ifndef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
-extern void UNITY_OUTPUT_CHAR(int);
-  #endif
-#endif
-
-#ifndef UNITY_OUTPUT_FLUSH
-/* Default to using fflush, which is defined in stdio.h */
-#include <stdio.h>
-#define UNITY_OUTPUT_FLUSH (void)fflush(stdout)
-#else
-  /* If defined as something else, make sure we declare it here so it's ready for use */
-  #ifndef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
-extern void UNITY_OUTPUT_FLUSH(void);
-  #endif
-#endif
-
-#ifndef UNITY_OUTPUT_FLUSH
-#define UNITY_FLUSH_CALL()
-#else
-#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH
-#endif
-
-#ifndef UNITY_PRINT_EOL
-#define UNITY_PRINT_EOL()    UNITY_OUTPUT_CHAR('\n')
-#endif
-
-#ifndef UNITY_OUTPUT_START
-#define UNITY_OUTPUT_START()
-#endif
-
-#ifndef UNITY_OUTPUT_COMPLETE
-#define UNITY_OUTPUT_COMPLETE()
-#endif
-
-/*-------------------------------------------------------
- * Footprint
- *-------------------------------------------------------*/
-
-#ifndef UNITY_LINE_TYPE
-#define UNITY_LINE_TYPE _U_UINT
-#endif
-
-#ifndef UNITY_COUNTER_TYPE
-#define UNITY_COUNTER_TYPE _U_UINT
-#endif
-
-/*-------------------------------------------------------
- * Language Features Available
- *-------------------------------------------------------*/
-#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA)
-#   ifdef __GNUC__ /* includes clang */
-#       if !(defined(__WIN32__) && defined(__clang__)) && !defined(__TMS470__)
-#           define UNITY_WEAK_ATTRIBUTE __attribute__((weak))
-#       endif
-#   endif
-#endif
-
-#ifdef UNITY_NO_WEAK
-#   undef UNITY_WEAK_ATTRIBUTE
-#   undef UNITY_WEAK_PRAGMA
-#endif
-
-
-/*-------------------------------------------------------
- * Internal Structs Needed
- *-------------------------------------------------------*/
-
-typedef void (*UnityTestFunction)(void);
-
-#define UNITY_DISPLAY_RANGE_INT  (0x10)
-#define UNITY_DISPLAY_RANGE_UINT (0x20)
-#define UNITY_DISPLAY_RANGE_HEX  (0x40)
-#define UNITY_DISPLAY_RANGE_AUTO (0x80)
-
-typedef enum
-{
-UNITY_DISPLAY_STYLE_INT = sizeof(int)+ UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-    UNITY_DISPLAY_STYLE_INT8     = 1 + UNITY_DISPLAY_RANGE_INT,
-    UNITY_DISPLAY_STYLE_INT16    = 2 + UNITY_DISPLAY_RANGE_INT,
-    UNITY_DISPLAY_STYLE_INT32    = 4 + UNITY_DISPLAY_RANGE_INT,
-#ifdef UNITY_SUPPORT_64
-    UNITY_DISPLAY_STYLE_INT64    = 8 + UNITY_DISPLAY_RANGE_INT,
-#endif
-
-UNITY_DISPLAY_STYLE_UINT = sizeof(unsigned) + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-    UNITY_DISPLAY_STYLE_UINT8    = 1 + UNITY_DISPLAY_RANGE_UINT,
-    UNITY_DISPLAY_STYLE_UINT16   = 2 + UNITY_DISPLAY_RANGE_UINT,
-    UNITY_DISPLAY_STYLE_UINT32   = 4 + UNITY_DISPLAY_RANGE_UINT,
-#ifdef UNITY_SUPPORT_64
-    UNITY_DISPLAY_STYLE_UINT64   = 8 + UNITY_DISPLAY_RANGE_UINT,
-#endif
-
-    UNITY_DISPLAY_STYLE_HEX8     = 1 + UNITY_DISPLAY_RANGE_HEX,
-    UNITY_DISPLAY_STYLE_HEX16    = 2 + UNITY_DISPLAY_RANGE_HEX,
-    UNITY_DISPLAY_STYLE_HEX32    = 4 + UNITY_DISPLAY_RANGE_HEX,
-#ifdef UNITY_SUPPORT_64
-    UNITY_DISPLAY_STYLE_HEX64    = 8 + UNITY_DISPLAY_RANGE_HEX,
-#endif
-
-    UNITY_DISPLAY_STYLE_UNKNOWN
-} UNITY_DISPLAY_STYLE_T;
-
-#ifndef UNITY_EXCLUDE_FLOAT
-typedef enum _UNITY_FLOAT_TRAIT_T
-{
-    UNITY_FLOAT_IS_NOT_INF       = 0,
-    UNITY_FLOAT_IS_INF,
-    UNITY_FLOAT_IS_NOT_NEG_INF,
-    UNITY_FLOAT_IS_NEG_INF,
-    UNITY_FLOAT_IS_NOT_NAN,
-    UNITY_FLOAT_IS_NAN,
-    UNITY_FLOAT_IS_NOT_DET,
-    UNITY_FLOAT_IS_DET,
-    UNITY_FLOAT_INVALID_TRAIT
-} UNITY_FLOAT_TRAIT_T;
-#endif
-
-struct _Unity
-{
-    const char* TestFile;
-    const char* CurrentTestName;
-#ifndef UNITY_EXCLUDE_DETAILS
-    const char* CurrentDetail1;
-    const char* CurrentDetail2;
-#endif
-    UNITY_LINE_TYPE CurrentTestLineNumber;
-    UNITY_COUNTER_TYPE NumberOfTests;
-    UNITY_COUNTER_TYPE TestFailures;
-    UNITY_COUNTER_TYPE TestIgnores;
-    UNITY_COUNTER_TYPE CurrentTestFailed;
-    UNITY_COUNTER_TYPE CurrentTestIgnored;
-    jmp_buf AbortFrame;
-};
-
-extern struct _Unity Unity;
-
-/*-------------------------------------------------------
- * Test Suite Management
- *-------------------------------------------------------*/
-
-void UnityBegin(const char* filename);
-int  UnityEnd(void);
-void UnityConcludeTest(void);
-void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum);
-
-/*-------------------------------------------------------
- * Details Support
- *-------------------------------------------------------*/
-
-#ifdef UNITY_EXCLUDE_DETAILS
-#define UNITY_CLR_DETAILS()
-#define UNITY_SET_DETAIL(d1)
-#define UNITY_SET_DETAILS(d1,d2)
-#else
-#define UNITY_CLR_DETAILS()      { Unity.CurrentDetail1 = 0;   Unity.CurrentDetail2 = 0;  }
-#define UNITY_SET_DETAIL(d1)     { Unity.CurrentDetail1 = d1;  Unity.CurrentDetail2 = 0;  }
-#define UNITY_SET_DETAILS(d1,d2) { Unity.CurrentDetail1 = d1;  Unity.CurrentDetail2 = d2; }
-
-#ifndef UNITY_DETAIL1_NAME
-#define UNITY_DETAIL1_NAME "Function"
-#endif
-
-#ifndef UNITY_DETAIL2_NAME
-#define UNITY_DETAIL2_NAME "Argument"
-#endif
-#endif
-
-/*-------------------------------------------------------
- * Test Output
- *-------------------------------------------------------*/
-
-void UnityPrint(const char* string);
-void UnityPrintMask(const _U_UINT mask, const _U_UINT number);
-void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style);
-void UnityPrintNumber(const _U_SINT number);
-void UnityPrintNumberUnsigned(const _U_UINT number);
-void UnityPrintNumberHex(const _U_UINT number, const char nibbles);
-
-#ifdef UNITY_FLOAT_VERBOSE
-void UnityPrintFloat(const _UD number);
-#endif
-
-/*-------------------------------------------------------
- * Test Assertion Functions
- *-------------------------------------------------------
- *  Use the macros below this section instead of calling
- *  these directly. The macros have a consistent naming
- *  convention and will pull in file and line information
- *  for you. */
-
-void UnityAssertEqualNumber(const _U_SINT expected,
-                            const _U_SINT actual,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber,
-                            const UNITY_DISPLAY_STYLE_T style);
-
-void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
-                              UNITY_INTERNAL_PTR actual,
-                              const _UU32 num_elements,
-                              const char* msg,
-                              const UNITY_LINE_TYPE lineNumber,
-                              const UNITY_DISPLAY_STYLE_T style);
-
-void UnityAssertBits(const _U_SINT mask,
-                     const _U_SINT expected,
-                     const _U_SINT actual,
-                     const char* msg,
-                     const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualString(const char* expected,
-                            const char* actual,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualStringLen(const char* expected,
-                            const char* actual,
-                            const _UU32 length,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualStringArray( const char** expected,
-                                  const char** actual,
-                                  const _UU32 num_elements,
-                                  const char* msg,
-                                  const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected,
-                             UNITY_INTERNAL_PTR actual,
-                             const _UU32 length,
-                             const _UU32 num_elements,
-                             const char* msg,
-                             const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertNumbersWithin(const _U_UINT delta,
-                              const _U_SINT expected,
-                              const _U_SINT actual,
-                              const char* msg,
-                              const UNITY_LINE_TYPE lineNumber,
-                              const UNITY_DISPLAY_STYLE_T style);
-
-void UnityFail(const char* message, const UNITY_LINE_TYPE line);
-
-void UnityIgnore(const char* message, const UNITY_LINE_TYPE line);
-
-#ifndef UNITY_EXCLUDE_FLOAT
-void UnityAssertFloatsWithin(const _UF delta,
-                             const _UF expected,
-                             const _UF actual,
-                             const char* msg,
-                             const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
-                                UNITY_PTR_ATTRIBUTE const _UF* actual,
-                                const _UU32 num_elements,
-                                const char* msg,
-                                const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertFloatSpecial(const _UF actual,
-                             const char* msg,
-                             const UNITY_LINE_TYPE lineNumber,
-                             const UNITY_FLOAT_TRAIT_T style);
-#endif
-
-#ifndef UNITY_EXCLUDE_DOUBLE
-void UnityAssertDoublesWithin(const _UD delta,
-                              const _UD expected,
-                              const _UD actual,
-                              const char* msg,
-                              const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
-                                 UNITY_PTR_ATTRIBUTE const _UD* actual,
-                                 const _UU32 num_elements,
-                                 const char* msg,
-                                 const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertDoubleSpecial(const _UD actual,
-                              const char* msg,
-                              const UNITY_LINE_TYPE lineNumber,
-                              const UNITY_FLOAT_TRAIT_T style);
-#endif
-
-/*-------------------------------------------------------
- * Error Strings We Might Need
- *-------------------------------------------------------*/
-
-extern const char UnityStrErrFloat[];
-extern const char UnityStrErrDouble[];
-extern const char UnityStrErr64[];
-
-/*-------------------------------------------------------
- * Test Running Macros
- *-------------------------------------------------------*/
-
-#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0)
-
-#define TEST_ABORT() {longjmp(Unity.AbortFrame, 1);}
-
-/* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */
-#ifndef RUN_TEST
-#ifdef __STDC_VERSION__
-#if __STDC_VERSION__ >= 199901L
-#define RUN_TEST(...) UnityDefaultTestRun(RUN_TEST_FIRST(__VA_ARGS__), RUN_TEST_SECOND(__VA_ARGS__))
-#define RUN_TEST_FIRST(...) RUN_TEST_FIRST_HELPER(__VA_ARGS__, throwaway)
-#define RUN_TEST_FIRST_HELPER(first, ...) (first), #first
-#define RUN_TEST_SECOND(...) RUN_TEST_SECOND_HELPER(__VA_ARGS__, __LINE__, throwaway)
-#define RUN_TEST_SECOND_HELPER(first, second, ...) (second)
-#endif
-#endif
-#endif
-
-/* If we can't do the tricky version, we'll just have to require them to always include the line number */
-#ifndef RUN_TEST
-#ifdef CMOCK
-#define RUN_TEST(func, num) UnityDefaultTestRun(func, #func, num)
-#else
-#define RUN_TEST(func) UnityDefaultTestRun(func, #func, __LINE__)
-#endif
-#endif
-
-#define TEST_LINE_NUM (Unity.CurrentTestLineNumber)
-#define TEST_IS_IGNORED (Unity.CurrentTestIgnored)
-#define UNITY_NEW_TEST(a) \
-    Unity.CurrentTestName = (a); \
-    Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)(__LINE__); \
-    Unity.NumberOfTests++;
-
-#ifndef UNITY_BEGIN
-#define UNITY_BEGIN() UnityBegin(__FILE__)
-#endif
-
-#ifndef UNITY_END
-#define UNITY_END() UnityEnd()
-#endif
-
-#define UNITY_UNUSED(x) (void)(sizeof(x))
-
-/*-----------------------------------------------
- * Command Line Argument Support
- *-----------------------------------------------*/
-
-#ifdef UNITY_USE_COMMAND_LINE_ARGS
-int UnityParseOptions(int argc, char** argv);
-int UnityTestMatches(void);
-#endif
-
-/*-------------------------------------------------------
- * Basic Fail and Ignore
- *-------------------------------------------------------*/
-
-#define UNITY_TEST_FAIL(line, message)   UnityFail(   (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)(line))
-
-/*-------------------------------------------------------
- * Test Asserts
- *-------------------------------------------------------*/
-
-#define UNITY_TEST_ASSERT(condition, line, message)                                              if (condition) {} else {UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message));}
-#define UNITY_TEST_ASSERT_NULL(pointer, line, message)                                           UNITY_TEST_ASSERT(((pointer) == NULL),  (UNITY_LINE_TYPE)(line), (message))
-#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message)                                       UNITY_TEST_ASSERT(((pointer) != NULL),  (UNITY_LINE_TYPE)(line), (message))
-
-#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message)                             UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message)                            UnityAssertEqualNumber((_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message)                           UnityAssertEqualNumber((_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message)                           UnityAssertEqualNumber((_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message)                            UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message)                           UnityAssertEqualNumber((_U_SINT)(_UU8 )(expected), (_U_SINT)(_UU8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
-#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message)                          UnityAssertEqualNumber((_U_SINT)(_UU16)(expected), (_U_SINT)(_UU16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
-#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message)                          UnityAssertEqualNumber((_U_SINT)(_UU32)(expected), (_U_SINT)(_UU32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
-#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message)                            UnityAssertEqualNumber((_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message)                           UnityAssertEqualNumber((_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message)                           UnityAssertEqualNumber((_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
-#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message)                            UnityAssertBits((_U_SINT)(mask), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line))
-
-#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message)                     UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin((_UU8 )(delta), (_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((_UU16)(delta), (_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_INT32_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((_UU32)(delta), (_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((_UU8 )(delta), (_U_SINT)(_U_UINT)(_UU8 )(expected), (_U_SINT)(_U_UINT)(_UU8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
-#define UNITY_TEST_ASSERT_UINT16_WITHIN(delta, expected, actual, line, message)                  UnityAssertNumbersWithin((_UU16)(delta), (_U_SINT)(_U_UINT)(_UU16)(expected), (_U_SINT)(_U_UINT)(_UU16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
-#define UNITY_TEST_ASSERT_UINT32_WITHIN(delta, expected, actual, line, message)                  UnityAssertNumbersWithin((_UU32)(delta), (_U_SINT)(_U_UINT)(_UU32)(expected), (_U_SINT)(_U_UINT)(_UU32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
-#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message)                    UnityAssertNumbersWithin((_UU8 )(delta), (_U_SINT)(_U_UINT)(_UU8 )(expected), (_U_SINT)(_U_UINT)(_UU8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((_UU16)(delta), (_U_SINT)(_U_UINT)(_UU16)(expected), (_U_SINT)(_U_UINT)(_UU16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((_UU32)(delta), (_U_SINT)(_U_UINT)(_UU32)(expected), (_U_SINT)(_U_UINT)(_UU32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
-
-#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message)                             UnityAssertEqualNumber((_U_SINT)(_UP)(expected), (_U_SINT)(_UP)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER)
-#define UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, line, message)                          UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len, line, message)                 UnityAssertEqualStringLen((const char*)(expected), (const char*)(actual), (_UU32)(len), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message)                     UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(len), 1, (message), (UNITY_LINE_TYPE)(line))
-
-#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
-#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
-#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
-#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
-#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message)      UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
-#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message)      UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
-#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message)        UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
-#define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message)         UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(_UP*)(expected), (UNITY_INTERNAL_PTR)(_UP*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER)
-#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message)      UnityAssertEqualStringArray((const char**)(expected), (const char**)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(len), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line))
-
-#ifdef UNITY_SUPPORT_64
-#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message)                           UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
-#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message)                          UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
-#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message)                           UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
-#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
-#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message)      UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
-#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
-#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
-#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message)                  UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
-#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message)                   UnityAssertNumbersWithin((delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
-#else
-#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message)                           UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message)                          UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message)                           UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message)       UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message)      UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message)       UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message)                  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64)
-#endif
-
-#ifdef UNITY_EXCLUDE_FLOAT
-#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message)                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message)                           UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message)       UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message)                                    UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message)                                UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message)                                    UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message)                            UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message)                                UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message)                            UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message)                                UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message)                        UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
-#else
-#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message)                   UnityAssertFloatsWithin((_UF)(delta), (_UF)(expected), (_UF)(actual), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message)                           UNITY_TEST_ASSERT_FLOAT_WITHIN((_UF)(expected) * (_UF)UNITY_FLOAT_PRECISION, (_UF)(expected), (_UF)(actual), (UNITY_LINE_TYPE)(line), (message))
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message)       UnityAssertEqualFloatArray((_UF*)(expected), (_UF*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)(line))
-#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message)                                    UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message)                                UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message)                                    UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN)
-#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message)                            UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message)                                UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message)                            UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message)                                UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message)                        UnityAssertFloatSpecial((_UF)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET)
-#endif
-
-#ifdef UNITY_EXCLUDE_DOUBLE
-#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message)                  UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message)                          UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message)      UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message)                                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message)                               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message)                                   UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message)                           UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message)                               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message)                           UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message)                               UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message)                       UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
-#else
-#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message)                  UnityAssertDoublesWithin((_UD)(delta), (_UD)(expected), (_UD)(actual), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message)                          UNITY_TEST_ASSERT_DOUBLE_WITHIN((_UD)(expected) * (_UD)UNITY_DOUBLE_PRECISION, (_UD)expected, (_UD)actual, (UNITY_LINE_TYPE)(line), message)
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message)      UnityAssertEqualDoubleArray((_UD*)(expected), (_UD*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message)                                   UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message)                               UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message)                                   UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message)                           UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message)                               UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message)                           UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message)                               UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message)                       UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET)
-#endif
-
-/* End of UNITY_INTERNALS_H */
-#endif