source/utils/CarlaUtils.hpp

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