source/utils/CarlaUtils.hpp

   1 // SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
   2 // SPDX-License-Identifier: GPL-2.0-or-later
   3
   4 #ifndef CARLA_UTILS_HPP_INCLUDED
   5 #define CARLA_UTILS_HPP_INCLUDED
   6
   7 #include "CarlaDefines.h"
   8
   9 #include <cassert>
  10 #include <cstdarg>
  11 #include <cstdio>
  12 #include <cstdlib>
  13 #include <cstring>
  14
  15 #ifdef CARLA_PROPER_CPP11_SUPPORT
  16 # ifdef __GNUC__
  17 #  include <cxxabi.h>
  18 # endif
  19 # include <cstdint>
  20 #else
  21 # include <stdint.h>
  22 #endif
  23
  24 #ifdef CARLA_OS_WIN
  25 # ifndef NOMINMAX
  26 #  define NOMINMAX
  27 # endif
  28 # define WIN32_LEAN_AND_MEAN 1
  29 # include <shlwapi.h>
  30 # include <winsock2.h>
  31 # include <windows.h>
  32 #else
  33 # include <strings.h>
  34 # include <unistd.h>
  35 #endif
  36
  37 // --------------------------------------------------------------------------------------------------------------------
  38 // misc functions
  39
  40 /*
  41  * Return "true" or "false" according to yesNo.
  42  */
  43 static inline
  44 const char* bool2str(const bool yesNo) noexcept
  45 {
  46     return yesNo ? "true" : "false";
  47 }
  48
  49 /*
  50  * Set a string as empty/null.
  51  */
  52 static inline
  53 void nullStrBuf(char* const strBuf) noexcept
  54 {
  55     strBuf[0] = '\0';
  56 }
  57
  58 /*
  59  * Dummy function.
  60  */
  61 static inline
  62 void pass() noexcept {}
  63
  64 // --------------------------------------------------------------------------------------------------------------------
  65 // string print functions
  66
  67 /*
  68  * Internal noexcept-safe fopen function.
  69  */
  70 static inline
  71 FILE* __carla_fopen(const char* const filename, FILE* const fallback) noexcept
  72 {
  73 #ifdef CARLA_OS_LINUX
  74     if (std::getenv("CARLA_CAPTURE_CONSOLE_OUTPUT") == nullptr)
  75         return fallback;
  76
  77     FILE* ret = nullptr;
  78
  79     try {
  80         ret = std::fopen(filename, "a+");
  81     } CARLA_CATCH_UNWIND catch (...) {}
  82
  83     if (ret == nullptr)
  84         ret = fallback;
  85
  86     return ret;
  87 #else
  88     return fallback;
  89     // unused
  90     (void)filename;
  91 #endif
  92 }
  93
  94 /*
  95  * Print a string to stdout with newline (gray color).
  96  * Does nothing if DEBUG is not defined.
  97  */
  98 #ifndef DEBUG
  99 # define carla_debug(...)
 100 #else
 101 static inline
 102 void carla_debug(const char* const fmt, ...) noexcept
 103 {
 104     static FILE* const output = __carla_fopen("/tmp/carla.debug.log", stdout);
 105
 106     try {
 107         va_list args;
 108         va_start(args, fmt);
 109
 110         if (output == stdout)
 111         {
 112 #ifdef CARLA_OS_MAC
 113             std::fprintf(output, "\x1b[37;1m[carla] ");
 114 #else
 115             std::fprintf(output, "\x1b[30;1m[carla] ");
 116 #endif
 117             std::vfprintf(output, fmt, args);
 118             std::fprintf(output, "\x1b[0m\n");
 119         }
 120         else
 121         {
 122             std::fprintf(output, "[carla] ");
 123             std::vfprintf(output, fmt, args);
 124             std::fprintf(output, "\n");
 125         }
 126
 127         std::fflush(output);
 128         va_end(args);
 129     } CARLA_CATCH_UNWIND catch (...) {}
 130 }
 131 #endif
 132
 133 /*
 134  * Print a string to stdout with newline.
 135  */
 136 static inline
 137 void carla_stdout(const char* const fmt, ...) noexcept
 138 {
 139     static FILE* const output = __carla_fopen("/tmp/carla.stdout.log", stdout);
 140
 141     try {
 142         va_list args;
 143         va_start(args, fmt);
 144         std::fprintf(output, "[carla] ");
 145         std::vfprintf(output, fmt, args);
 146         std::fprintf(output, "\n");
 147 #ifndef DEBUG
 148         if (output != stdout)
 149 #endif
 150             std::fflush(output);
 151         va_end(args);
 152     } CARLA_CATCH_UNWIND catch (...) {}
 153 }
 154
 155 /*
 156  * Print a string to stderr with newline.
 157  */
 158 static inline
 159 void carla_stderr(const char* const fmt, ...) noexcept
 160 {
 161     static FILE* const output = __carla_fopen("/tmp/carla.stderr.log", stderr);
 162
 163     try {
 164         va_list args;
 165         va_start(args, fmt);
 166         std::fprintf(output, "[carla] ");
 167         std::vfprintf(output, fmt, args);
 168         std::fprintf(output, "\n");
 169 #ifndef DEBUG
 170         if (output != stderr)
 171 #endif
 172             std::fflush(output);
 173         va_end(args);
 174     } CARLA_CATCH_UNWIND catch (...) {}
 175 }
 176
 177 /*
 178  * Print a string to stderr with newline (red color).
 179  */
 180 static inline
 181 void carla_stderr2(const char* const fmt, ...) noexcept
 182 {
 183     static FILE* const output = __carla_fopen("/tmp/carla.stderr2.log", stderr);
 184
 185     try {
 186         va_list args;
 187         va_start(args, fmt);
 188
 189         if (output == stderr)
 190         {
 191             std::fprintf(output, "\x1b[31m[carla] ");
 192             std::vfprintf(output, fmt, args);
 193             std::fprintf(output, "\x1b[0m\n");
 194         }
 195         else
 196         {
 197             std::fprintf(output, "[carla] ");
 198             std::vfprintf(output, fmt, args);
 199             std::fprintf(output, "\n");
 200         }
 201
 202         std::fflush(output);
 203         va_end(args);
 204     } CARLA_CATCH_UNWIND catch (...) {}
 205 }
 206
 207 // --------------------------------------------------------------------------------------------------------------------
 208 // carla_safe_assert*
 209
 210 /*
 211  * Print a safe assertion error message.
 212  */
 213 static inline
 214 void carla_safe_assert(const char* const assertion, const char* const file, const int line) noexcept
 215 {
 216     carla_stderr2("Carla assertion failure: \"%s\" in file %s, line %i", assertion, file, line);
 217 }
 218
 219 /*
 220  * Print a safe assertion error message, with 1 extra signed integer value.
 221  */
 222 static inline
 223 void carla_safe_assert_int(const char* const assertion, const char* const file,
 224                            const int line, const int value) noexcept
 225 {
 226     carla_stderr2("Carla assertion failure: \"%s\" in file %s, line %i, value %i", assertion, file, line, value);
 227 }
 228
 229 /*
 230  * Print a safe assertion error message, with 1 extra unsigned integer value.
 231  */
 232 static inline
 233 void carla_safe_assert_uint(const char* const assertion, const char* const file,
 234                             const int line, const uint value) noexcept
 235 {
 236     carla_stderr2("Carla assertion failure: \"%s\" in file %s, line %i, value %u", assertion, file, line, value);
 237 }
 238
 239 /*
 240  * Print a safe assertion error message, with 2 extra signed integer values.
 241  */
 242 static inline
 243 void carla_safe_assert_int2(const char* const assertion, const char* const file,
 244                             const int line, const int v1, const int v2) noexcept
 245 {
 246     carla_stderr2("Carla assertion failure: \"%s\" in file %s, line %i, v1 %i, v2 %i", assertion, file, line, v1, v2);
 247 }
 248
 249 /*
 250  * Print a safe assertion error message, with 2 extra unsigned integer values.
 251  */
 252 static inline
 253 void carla_safe_assert_uint2(const char* const assertion, const char* const file,
 254                              const int line, const uint v1, const uint v2) noexcept
 255 {
 256     carla_stderr2("Carla assertion failure: \"%s\" in file %s, line %i, v1 %u, v2 %u", assertion, file, line, v1, v2);
 257 }
 258
 259 /*
 260  * Print a safe assertion error message, with a custom error message.
 261  */
 262 static inline
 263 void carla_custom_safe_assert(const char* const message,
 264                               const char* const assertion, const char* const file, const int line) noexcept
 265 {
 266     carla_stderr2("Carla assertion failure: %s, condition \"%s\" in file %s, line %i", message, assertion, file, line);
 267 }
 268
 269 // --------------------------------------------------------------------------------------------------------------------
 270 // carla_safe_exception*
 271
 272 /*
 273  * Print a safe exception error message.
 274  */
 275 static inline
 276 void carla_safe_exception(const char* const exception, const char* const file, const int line) noexcept
 277 {
 278     carla_stderr2("Carla exception caught: \"%s\" in file %s, line %i", exception, file, line);
 279 }
 280
 281 // --------------------------------------------------------------------------------------------------------------------
 282 // carla_setenv
 283
 284 /*
 285  * Set environment variable 'key' to 'value'.
 286  */
 287 static inline
 288 void carla_setenv(const char* const key, const char* const value) noexcept
 289 {
 290     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
 291     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);
 292
 293 #ifdef CARLA_OS_WIN
 294     try {
 295         ::SetEnvironmentVariableA(key, value);
 296     } CARLA_SAFE_EXCEPTION("carla_setenv");
 297 #else
 298     ::setenv(key, value, 1);
 299 #endif
 300 }
 301
 302 /*
 303  * Unset environment variable 'key'.
 304  */
 305 static inline
 306 void carla_unsetenv(const char* const key) noexcept
 307 {
 308     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
 309
 310 #ifdef CARLA_OS_WIN
 311     try {
 312         ::SetEnvironmentVariableA(key, nullptr);
 313     } CARLA_SAFE_EXCEPTION("carla_unsetenv");
 314 #else
 315     ::unsetenv(key);
 316 #endif
 317 }
 318
 319 // --------------------------------------------------------------------------------------------------------------------
 320 // carla_strdup
 321
 322 /*
 323  * Custom 'strdup' function.
 324  * Returned value is always valid, and must be freed with "delete[] var".
 325  * May throw.
 326  */
 327 static inline
 328 const char* carla_strdup(const char* const strBuf)
 329 {
 330     CARLA_SAFE_ASSERT(strBuf != nullptr);
 331
 332     const std::size_t bufferLen = (strBuf != nullptr) ? std::strlen(strBuf) : 0;
 333     char* const       buffer    = new char[bufferLen+1];
 334
 335     if (bufferLen > 0)
 336         std::memcpy(buffer, strBuf, bufferLen);
 337
 338     buffer[bufferLen] = '\0';
 339
 340     return buffer;
 341 }
 342
 343 /*
 344  * Custom 'strdup' function.
 345  * Calls "std::free(strBuf)".
 346  * Returned value is always valid, and must be freed with "delete[] var".
 347  * May throw.
 348  */
 349 static inline
 350 const char* carla_strdup_free(char* const strBuf)
 351 {
 352     const char* const buffer = carla_strdup(strBuf);
 353     std::free(strBuf);
 354     return buffer;
 355 }
 356
 357 /*
 358  * Custom 'strdup' function, safe version.
 359  * Returned value may be null. It must be freed with "delete[] var".
 360  */
 361 static inline
 362 const char* carla_strdup_safe(const char* const strBuf) noexcept
 363 {
 364     CARLA_SAFE_ASSERT_RETURN(strBuf != nullptr, nullptr);
 365
 366     const std::size_t bufferLen = std::strlen(strBuf);
 367     char* buffer;
 368
 369     try {
 370         buffer = new char[bufferLen+1];
 371     } CARLA_SAFE_EXCEPTION_RETURN("carla_strdup_safe", nullptr);
 372
 373     if (bufferLen > 0)
 374         std::memcpy(buffer, strBuf, bufferLen);
 375
 376     buffer[bufferLen] = '\0';
 377
 378     return buffer;
 379 }
 380
 381 // --------------------------------------------------------------------------------------------------------------------
 382 // carla_strcase*
 383
 384 #ifdef CARLA_OS_WIN
 385 # ifdef _MSC_VER
 386 #  pragma comment(lib, "shlwapi.lib")
 387 # endif
 388
 389 static inline
 390 int carla_strcasecmp(const char* const str1, const char* const str2) noexcept
 391 {
 392     return ::StrCmpIA(str1, str2);
 393 }
 394
 395 static inline
 396 const char* carla_strcasestr(const char* const haystack, const char* const needle) noexcept
 397 {
 398     return ::StrStrIA(haystack, needle);
 399 }
 400 #else
 401 static inline
 402 ssize_t carla_strcasecmp(const char* const str1, const char* const str2) noexcept
 403 {
 404     return ::strcasecmp(str1, str2);
 405 }
 406
 407 static inline
 408 const char* carla_strcasestr(const char* const haystack, const char* const needle) noexcept
 409 {
 410     return ::strcasestr(haystack, needle);
 411 }
 412 #endif
 413
 414 // --------------------------------------------------------------------------------------------------------------------
 415 // memory functions
 416
 417 /*
 418  * Add array values to another array.
 419  */
 420 template<typename T>
 421 static inline
 422 void carla_add(T dest[], const T src[], const std::size_t count) noexcept
 423 {
 424     CARLA_SAFE_ASSERT_RETURN(dest != nullptr,);
 425     CARLA_SAFE_ASSERT_RETURN(src != nullptr,);
 426     CARLA_SAFE_ASSERT_RETURN(dest != src,);
 427     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 428
 429     for (std::size_t i=0; i<count; ++i)
 430         dest[i] += src[i];
 431 }
 432
 433 /*
 434  * Add array values to another array, with a multiplication factor.
 435  */
 436 template<typename T>
 437 static inline
 438 void carla_addWithMultiply(T dest[], const T src[], const T& multiplier, const std::size_t count) noexcept
 439 {
 440     CARLA_SAFE_ASSERT_RETURN(dest != nullptr,);
 441     CARLA_SAFE_ASSERT_RETURN(src != nullptr,);
 442     CARLA_SAFE_ASSERT_RETURN(dest != src,);
 443     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 444
 445     for (std::size_t i=0; i<count; ++i)
 446         dest[i] += src[i] * multiplier;
 447 }
 448
 449 /*
 450  * Copy array values to another array.
 451  */
 452 template<typename T>
 453 static inline
 454 void carla_copy(T dest[], const T src[], const std::size_t count) noexcept
 455 {
 456     CARLA_SAFE_ASSERT_RETURN(dest != nullptr,);
 457     CARLA_SAFE_ASSERT_RETURN(src != nullptr,);
 458     CARLA_SAFE_ASSERT_RETURN(dest != src,);
 459     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 460
 461     std::memcpy(dest, src, count*sizeof(T));
 462 }
 463
 464 /*
 465  * Copy array values to another array, with a multiplication factor.
 466  */
 467 template<typename T>
 468 static inline
 469 void carla_copyWithMultiply(T dest[], const T src[], const T& multiplier, const std::size_t count) noexcept
 470 {
 471     CARLA_SAFE_ASSERT_RETURN(dest != nullptr,);
 472     CARLA_SAFE_ASSERT_RETURN(src != nullptr,);
 473     CARLA_SAFE_ASSERT_RETURN(dest != src,);
 474     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 475
 476     for (std::size_t i=0; i<count; ++i)
 477         dest[i] = src[i] * multiplier;
 478 }
 479
 480 /*
 481  * Fill an array with a fixed value.
 482  */
 483 template<typename T>
 484 static inline
 485 void carla_fill(T data[], const T& value, const std::size_t count) noexcept
 486 {
 487     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
 488     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 489
 490     if (value == 0)
 491     {
 492         std::memset(data, 0, count*sizeof(T));
 493     }
 494     else
 495     {
 496         for (std::size_t i=0; i<count; ++i)
 497             data[i] = value;
 498     }
 499 }
 500
 501 /*
 502  * Multiply an array with a fixed value.
 503  */
 504 template<typename T>
 505 static inline
 506 void carla_multiply(T data[], const T& multiplier, const std::size_t count) noexcept
 507 {
 508     CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
 509     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 510
 511     if (multiplier == 0)
 512     {
 513         std::memset(data, 0, count*sizeof(T));
 514     }
 515     else
 516     {
 517         for (std::size_t i=0; i<count; ++i)
 518             data[i] *= multiplier;
 519     }
 520 }
 521
 522 /*
 523  * Clear a byte array.
 524  */
 525 static inline
 526 void carla_zeroBytes(uint8_t bytes[], const std::size_t count) noexcept
 527 {
 528     CARLA_SAFE_ASSERT_RETURN(bytes != nullptr,);
 529     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 530
 531     std::memset(bytes, 0, count*sizeof(uint8_t));
 532 }
 533
 534 /*
 535  * Clear a char array.
 536  */
 537 static inline
 538 void carla_zeroChars(char chars[], const std::size_t count) noexcept
 539 {
 540     CARLA_SAFE_ASSERT_RETURN(chars != nullptr,);
 541     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 542
 543     std::memset(chars, 0, count*sizeof(char));
 544 }
 545
 546 /*
 547  * Clear a pointer array.
 548  */
 549 template<typename T>
 550 static inline
 551 void carla_zeroPointers(T* ptrs[], const std::size_t count) noexcept
 552 {
 553     CARLA_SAFE_ASSERT_RETURN(ptrs != nullptr,);
 554     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 555
 556     std::memset(ptrs, 0, count*sizeof(T*));
 557 }
 558
 559 /*
 560  * Clear a single struct.
 561  */
 562 template <typename T>
 563 static inline
 564 void carla_zeroStruct(T& s) noexcept
 565 {
 566     std::memset(&s, 0, sizeof(T));
 567 }
 568
 569 /*
 570  * Clear a struct array.
 571  */
 572 template <typename T>
 573 static inline
 574 void carla_zeroStructs(T structs[], const std::size_t count) noexcept
 575 {
 576     CARLA_SAFE_ASSERT_RETURN(structs != nullptr,);
 577     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 578
 579     std::memset(structs, 0, count*sizeof(T));
 580 }
 581
 582 /*
 583  * Copy a single struct.
 584  */
 585 template <typename T>
 586 static inline
 587 void carla_copyStruct(T& dest, const T& src) noexcept
 588 {
 589     std::memcpy(&dest, &src, sizeof(T));
 590 }
 591
 592 /*
 593  * Copy a struct array.
 594  */
 595 template <typename T>
 596 static inline
 597 void carla_copyStructs(T dest[], const T src[], const std::size_t count) noexcept
 598 {
 599     CARLA_SAFE_ASSERT_RETURN(dest != nullptr,);
 600     CARLA_SAFE_ASSERT_RETURN(src != nullptr,);
 601     CARLA_SAFE_ASSERT_RETURN(dest != src,);
 602     CARLA_SAFE_ASSERT_RETURN(count > 0,);
 603
 604     std::memcpy(dest, src, count*sizeof(T));
 605 }
 606
 607 // --------------------------------------------------------------------------------------------------------------------
 608
 609 #endif // CARLA_UTILS_HPP_INCLUDED