Format

calculator/tinyexpr.c

@@ -82,12 +82,12 @@ typedef struct state {
     int lookup_len;
 } state;
 
-#define TYPE_MASK(TYPE) ((TYPE)&0x0000001F)
+#define TYPE_MASK(TYPE) ((TYPE) & 0x0000001F)
 
-#define IS_PURE(TYPE) (((TYPE)&TE_FLAG_PURE) != 0)
-#define IS_FUNCTION(TYPE) (((TYPE)&TE_FUNCTION0) != 0)
-#define IS_CLOSURE(TYPE) (((TYPE)&TE_CLOSURE0) != 0)
-#define ARITY(TYPE) (((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE)&0x00000007) : 0)
+#define IS_PURE(TYPE) (((TYPE) & TE_FLAG_PURE) != 0)
+#define IS_FUNCTION(TYPE) (((TYPE) & TE_FUNCTION0) != 0)
+#define IS_CLOSURE(TYPE) (((TYPE) & TE_CLOSURE0) != 0)
+#define ARITY(TYPE) (((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE) & 0x00000007) : 0)
 #define NEW_EXPR(type, ...) new_expr((type), (const te_expr*[]){__VA_ARGS__})
 
 static te_expr* new_expr(const int type, const te_expr* parameters[]) {

esubghz_chat/crypto/aes.c

@@ -75,34 +75,34 @@ static uint32_t RCON[10]; // AES round constants
 /*
  *  AES forward and reverse encryption round processing macros
  */
-#define AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3)                                     \
-    {                                                                                  \
-        X0 = *RK++ ^ FT0[(Y0)&0xFF] ^ FT1[(Y1 >> 8) & 0xFF] ^ FT2[(Y2 >> 16) & 0xFF] ^ \
-             FT3[(Y3 >> 24) & 0xFF];                                                   \
-                                                                                       \
-        X1 = *RK++ ^ FT0[(Y1)&0xFF] ^ FT1[(Y2 >> 8) & 0xFF] ^ FT2[(Y3 >> 16) & 0xFF] ^ \
-             FT3[(Y0 >> 24) & 0xFF];                                                   \
-                                                                                       \
-        X2 = *RK++ ^ FT0[(Y2)&0xFF] ^ FT1[(Y3 >> 8) & 0xFF] ^ FT2[(Y0 >> 16) & 0xFF] ^ \
-             FT3[(Y1 >> 24) & 0xFF];                                                   \
-                                                                                       \
-        X3 = *RK++ ^ FT0[(Y3)&0xFF] ^ FT1[(Y0 >> 8) & 0xFF] ^ FT2[(Y1 >> 16) & 0xFF] ^ \
-             FT3[(Y2 >> 24) & 0xFF];                                                   \
+#define AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3)                                       \
+    {                                                                                    \
+        X0 = *RK++ ^ FT0[(Y0) & 0xFF] ^ FT1[(Y1 >> 8) & 0xFF] ^ FT2[(Y2 >> 16) & 0xFF] ^ \
+             FT3[(Y3 >> 24) & 0xFF];                                                     \
+                                                                                         \
+        X1 = *RK++ ^ FT0[(Y1) & 0xFF] ^ FT1[(Y2 >> 8) & 0xFF] ^ FT2[(Y3 >> 16) & 0xFF] ^ \
+             FT3[(Y0 >> 24) & 0xFF];                                                     \
+                                                                                         \
+        X2 = *RK++ ^ FT0[(Y2) & 0xFF] ^ FT1[(Y3 >> 8) & 0xFF] ^ FT2[(Y0 >> 16) & 0xFF] ^ \
+             FT3[(Y1 >> 24) & 0xFF];                                                     \
+                                                                                         \
+        X3 = *RK++ ^ FT0[(Y3) & 0xFF] ^ FT1[(Y0 >> 8) & 0xFF] ^ FT2[(Y1 >> 16) & 0xFF] ^ \
+             FT3[(Y2 >> 24) & 0xFF];                                                     \
     }
 
-#define AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3)                                     \
-    {                                                                                  \
-        X0 = *RK++ ^ RT0[(Y0)&0xFF] ^ RT1[(Y3 >> 8) & 0xFF] ^ RT2[(Y2 >> 16) & 0xFF] ^ \
-             RT3[(Y1 >> 24) & 0xFF];                                                   \
-                                                                                       \
-        X1 = *RK++ ^ RT0[(Y1)&0xFF] ^ RT1[(Y0 >> 8) & 0xFF] ^ RT2[(Y3 >> 16) & 0xFF] ^ \
-             RT3[(Y2 >> 24) & 0xFF];                                                   \
-                                                                                       \
-        X2 = *RK++ ^ RT0[(Y2)&0xFF] ^ RT1[(Y1 >> 8) & 0xFF] ^ RT2[(Y0 >> 16) & 0xFF] ^ \
-             RT3[(Y3 >> 24) & 0xFF];                                                   \
-                                                                                       \
-        X3 = *RK++ ^ RT0[(Y3)&0xFF] ^ RT1[(Y2 >> 8) & 0xFF] ^ RT2[(Y1 >> 16) & 0xFF] ^ \
-             RT3[(Y0 >> 24) & 0xFF];                                                   \
+#define AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3)                                       \
+    {                                                                                    \
+        X0 = *RK++ ^ RT0[(Y0) & 0xFF] ^ RT1[(Y3 >> 8) & 0xFF] ^ RT2[(Y2 >> 16) & 0xFF] ^ \
+             RT3[(Y1 >> 24) & 0xFF];                                                     \
+                                                                                         \
+        X1 = *RK++ ^ RT0[(Y1) & 0xFF] ^ RT1[(Y0 >> 8) & 0xFF] ^ RT2[(Y3 >> 16) & 0xFF] ^ \
+             RT3[(Y2 >> 24) & 0xFF];                                                     \
+                                                                                         \
+        X2 = *RK++ ^ RT0[(Y2) & 0xFF] ^ RT1[(Y1 >> 8) & 0xFF] ^ RT2[(Y0 >> 16) & 0xFF] ^ \
+             RT3[(Y3 >> 24) & 0xFF];                                                     \
+                                                                                         \
+        X3 = *RK++ ^ RT0[(Y3) & 0xFF] ^ RT1[(Y2 >> 8) & 0xFF] ^ RT2[(Y1 >> 16) & 0xFF] ^ \
+             RT3[(Y0 >> 24) & 0xFF];                                                     \
     }
 
 /*
@@ -392,16 +392,16 @@ int aes_cipher(aes_context* ctx, const uchar input[16], uchar output[16]) {
 
         AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3);
 
-        X0 = *RK++ ^ ((uint32_t)RSb[(Y0)&0xFF]) ^ ((uint32_t)RSb[(Y3 >> 8) & 0xFF] << 8) ^
+        X0 = *RK++ ^ ((uint32_t)RSb[(Y0) & 0xFF]) ^ ((uint32_t)RSb[(Y3 >> 8) & 0xFF] << 8) ^
              ((uint32_t)RSb[(Y2 >> 16) & 0xFF] << 16) ^ ((uint32_t)RSb[(Y1 >> 24) & 0xFF] << 24);
 
-        X1 = *RK++ ^ ((uint32_t)RSb[(Y1)&0xFF]) ^ ((uint32_t)RSb[(Y0 >> 8) & 0xFF] << 8) ^
+        X1 = *RK++ ^ ((uint32_t)RSb[(Y1) & 0xFF]) ^ ((uint32_t)RSb[(Y0 >> 8) & 0xFF] << 8) ^
              ((uint32_t)RSb[(Y3 >> 16) & 0xFF] << 16) ^ ((uint32_t)RSb[(Y2 >> 24) & 0xFF] << 24);
 
-        X2 = *RK++ ^ ((uint32_t)RSb[(Y2)&0xFF]) ^ ((uint32_t)RSb[(Y1 >> 8) & 0xFF] << 8) ^
+        X2 = *RK++ ^ ((uint32_t)RSb[(Y2) & 0xFF]) ^ ((uint32_t)RSb[(Y1 >> 8) & 0xFF] << 8) ^
              ((uint32_t)RSb[(Y0 >> 16) & 0xFF] << 16) ^ ((uint32_t)RSb[(Y3 >> 24) & 0xFF] << 24);
 
-        X3 = *RK++ ^ ((uint32_t)RSb[(Y3)&0xFF]) ^ ((uint32_t)RSb[(Y2 >> 8) & 0xFF] << 8) ^
+        X3 = *RK++ ^ ((uint32_t)RSb[(Y3) & 0xFF]) ^ ((uint32_t)RSb[(Y2 >> 8) & 0xFF] << 8) ^
              ((uint32_t)RSb[(Y1 >> 16) & 0xFF] << 16) ^ ((uint32_t)RSb[(Y0 >> 24) & 0xFF] << 24);
     } else /* ENCRYPT */
     {
@@ -414,16 +414,16 @@ int aes_cipher(aes_context* ctx, const uchar input[16], uchar output[16]) {
 
         AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3);
 
-        X0 = *RK++ ^ ((uint32_t)FSb[(Y0)&0xFF]) ^ ((uint32_t)FSb[(Y1 >> 8) & 0xFF] << 8) ^
+        X0 = *RK++ ^ ((uint32_t)FSb[(Y0) & 0xFF]) ^ ((uint32_t)FSb[(Y1 >> 8) & 0xFF] << 8) ^
              ((uint32_t)FSb[(Y2 >> 16) & 0xFF] << 16) ^ ((uint32_t)FSb[(Y3 >> 24) & 0xFF] << 24);
 
-        X1 = *RK++ ^ ((uint32_t)FSb[(Y1)&0xFF]) ^ ((uint32_t)FSb[(Y2 >> 8) & 0xFF] << 8) ^
+        X1 = *RK++ ^ ((uint32_t)FSb[(Y1) & 0xFF]) ^ ((uint32_t)FSb[(Y2 >> 8) & 0xFF] << 8) ^
              ((uint32_t)FSb[(Y3 >> 16) & 0xFF] << 16) ^ ((uint32_t)FSb[(Y0 >> 24) & 0xFF] << 24);
 
-        X2 = *RK++ ^ ((uint32_t)FSb[(Y2)&0xFF]) ^ ((uint32_t)FSb[(Y3 >> 8) & 0xFF] << 8) ^
+        X2 = *RK++ ^ ((uint32_t)FSb[(Y2) & 0xFF]) ^ ((uint32_t)FSb[(Y3 >> 8) & 0xFF] << 8) ^
              ((uint32_t)FSb[(Y0 >> 16) & 0xFF] << 16) ^ ((uint32_t)FSb[(Y1 >> 24) & 0xFF] << 24);
 
-        X3 = *RK++ ^ ((uint32_t)FSb[(Y3)&0xFF]) ^ ((uint32_t)FSb[(Y0 >> 8) & 0xFF] << 8) ^
+        X3 = *RK++ ^ ((uint32_t)FSb[(Y3) & 0xFF]) ^ ((uint32_t)FSb[(Y0 >> 8) & 0xFF] << 8) ^
              ((uint32_t)FSb[(Y1 >> 16) & 0xFF] << 16) ^ ((uint32_t)FSb[(Y2 >> 24) & 0xFF] << 24);
 
 #if AES_DECRYPTION // whether AES decryption is supported

flizzer_tracker/sound_engine/sound_engine_defs.h

@@ -20,9 +20,9 @@
 #define MAX_ADSR (0xff << 17)
 #define MAX_ADSR_VOLUME 0x80
 #define BASE_FREQ 22050
-#define envspd(eng, slope)                                                                     \
-    ((slope) != 0 ?                                                                            \
-         (((uint64_t)MAX_ADSR / ((slope) * (slope)*256 / 8)) * BASE_FREQ / eng->sample_rate) : \
+#define envspd(eng, slope)                                                                       \
+    ((slope) != 0 ?                                                                              \
+         (((uint64_t)MAX_ADSR / ((slope) * (slope) * 256 / 8)) * BASE_FREQ / eng->sample_rate) : \
          ((uint64_t)MAX_ADSR * BASE_FREQ / eng->sample_rate))
 
 typedef enum {

flizzer_tracker/tracker_engine/tracker_engine.c

@@ -405,9 +405,9 @@ void tracker_engine_advance_channel(TrackerEngine* tracker_engine, uint8_t chan)
 
             else {
                 te_channel->vibrato_position += ((uint32_t)te_channel->vibrato_speed << 21);
-                vib =
-                    (int32_t)(sound_engine_triangle(te_channel->vibrato_position >> 9) - WAVE_AMP / 2) *
-                    (int32_t)te_channel->vibrato_depth / (256 * 128);
+                vib = (int32_t)(sound_engine_triangle(te_channel->vibrato_position >> 9) -
+                                WAVE_AMP / 2) *
+                      (int32_t)te_channel->vibrato_depth / (256 * 128);
             }
         }
 
@@ -442,9 +442,9 @@ void tracker_engine_advance_channel(TrackerEngine* tracker_engine, uint8_t chan)
             tracker_engine->sound_engine->channel[chan].pw = tracker_engine->channel[chan].pw;
         }
 
-        int32_t chn_note =
-            (int16_t)(te_channel->fixed_note != 0xffff ? te_channel->fixed_note : te_channel->note) +
-            vib + ((int16_t)te_channel->arpeggio_note << 8);
+        int32_t chn_note = (int16_t)(te_channel->fixed_note != 0xffff ? te_channel->fixed_note :
+                                                                        te_channel->note) +
+                           vib + ((int16_t)te_channel->arpeggio_note << 8);
 
         if(chn_note < 0) {
             chn_note = 0;

mfkey32/mfkey32.c

@@ -38,10 +38,10 @@
 #define CONST_M2_1 (LF_POLY_ODD << 1)
 #define CONST_M1_2 (LF_POLY_ODD)
 #define CONST_M2_2 (LF_POLY_EVEN << 1 | 1)
-#define BIT(x, n) ((x) >> (n)&1)
+#define BIT(x, n) ((x) >> (n) & 1)
 #define BEBIT(x, n) BIT(x, (n) ^ 24)
 #define SWAPENDIAN(x) \
-    ((x) = ((x) >> 8 & 0xff00ff) | ((x)&0xff00ff) << 8, (x) = (x) >> 16 | (x) << 16)
+    ((x) = ((x) >> 8 & 0xff00ff) | ((x) & 0xff00ff) << 8, (x) = (x) >> 16 | (x) << 16)
 //#define SIZEOF(arr) sizeof(arr) / sizeof(*arr)
 
 static int eta_round_time = 56;

rootoflife/roots_of_life_game.c

@@ -27,7 +27,7 @@
 // Root Spawn
 #define ROOT_SIZE_X 7
 #define ROOT_SIZE_Y 7
-#define ROOT(Y, X) ((Y)*ROOT_SIZE_X + (X))
+#define ROOT(Y, X) ((Y) * ROOT_SIZE_X + (X))
 
 #define SPAWN_DIRECTIONS 2
 #define GROW_STEPS 4

tama_p1/tamalib/cpu.h

@@ -52,22 +52,22 @@
 #define SET_RAM_MEMORY(buffer, n, v)                                                         \
     {                                                                                        \
         buffer[RAM_TO_MEMORY(n)] = (buffer[RAM_TO_MEMORY(n)] & ~(0xF << (((n) % 2) << 2))) | \
-                                   ((v)&0xF) << (((n) % 2) << 2);                            \
+                                   ((v) & 0xF) << (((n) % 2) << 2);                          \
     }
 #define SET_DISP1_MEMORY(buffer, n, v)                                                           \
     {                                                                                            \
         buffer[DISP1_TO_MEMORY(n)] = (buffer[DISP1_TO_MEMORY(n)] & ~(0xF << (((n) % 2) << 2))) | \
-                                     ((v)&0xF) << (((n) % 2) << 2);                              \
+                                     ((v) & 0xF) << (((n) % 2) << 2);                            \
     }
 #define SET_DISP2_MEMORY(buffer, n, v)                                                           \
     {                                                                                            \
         buffer[DISP2_TO_MEMORY(n)] = (buffer[DISP2_TO_MEMORY(n)] & ~(0xF << (((n) % 2) << 2))) | \
-                                     ((v)&0xF) << (((n) % 2) << 2);                              \
+                                     ((v) & 0xF) << (((n) % 2) << 2);                            \
     }
 #define SET_IO_MEMORY(buffer, n, v)                                                        \
     {                                                                                      \
         buffer[IO_TO_MEMORY(n)] = (buffer[IO_TO_MEMORY(n)] & ~(0xF << (((n) % 2) << 2))) | \
-                                  ((v)&0xF) << (((n) % 2) << 2);                           \
+                                  ((v) & 0xF) << (((n) % 2) << 2);                         \
     }
 #define SET_MEMORY(buffer, n, v)                                   \
     {                                                              \

totp/services/idle_timeout/idle_timeout.c

@@ -3,7 +3,7 @@
 #include <furi/core/timer.h>
 
 #define IDLE_TIMER_CHECK_PERIODICITY_SEC (1)
-#define SEC_TO_TICKS(sec) ((sec)*1000)
+#define SEC_TO_TICKS(sec) ((sec) * 1000)
 
 struct IdleTimeoutContext {
     FuriTimer* timer;

totp/types/token_info.c

@@ -8,8 +8,8 @@
 #include "common.h"
 #include "../services/crypto/crypto_facade.h"
 
-#define ESTIMATE_BASE32_PLAIN_LENGTH(base32_length) ((base32_length)*0.625f)
-#define ESTIMATE_BASE64_PLAIN_LENGTH(base64_length) ((base64_length)*0.75f)
+#define ESTIMATE_BASE32_PLAIN_LENGTH(base32_length) ((base32_length) * 0.625f)
+#define ESTIMATE_BASE64_PLAIN_LENGTH(base64_length) ((base64_length) * 0.75f)
 
 TokenInfo* token_info_alloc() {
     TokenInfo* tokenInfo = malloc(sizeof(TokenInfo));

unitemp/sensors/BME680.c

@@ -155,10 +155,11 @@ static float BME680_compensate_humidity(I2CSensor* i2c_sensor, int32_t hum_adc)
     var1 =
         (float)((float)hum_adc) - (((float)bme680_instance->hum_cal.dig_H1 * 16.0f) +
                                    (((float)bme680_instance->hum_cal.dig_H3 / 2.0f) * temp_comp));
-    var2 = var1 *
-           ((float)(((float)bme680_instance->hum_cal.dig_H2 / 262144.0f) *
-                    (1.0f + (((float)bme680_instance->hum_cal.dig_H4 / 16384.0f) * temp_comp) +
-                     (((float)bme680_instance->hum_cal.dig_H5 / 1048576.0f) * temp_comp * temp_comp))));
+    var2 =
+        var1 * ((float)(((float)bme680_instance->hum_cal.dig_H2 / 262144.0f) *
+                        (1.0f + (((float)bme680_instance->hum_cal.dig_H4 / 16384.0f) * temp_comp) +
+                         (((float)bme680_instance->hum_cal.dig_H5 / 1048576.0f) * temp_comp *
+                          temp_comp))));
     var3 = (float)bme680_instance->hum_cal.dig_H6 / 16384.0f;
     var4 = (float)bme680_instance->hum_cal.dig_H7 / 2097152.0f;
     calc_hum = var2 + ((var3 + (var4 * temp_comp)) * var2 * var2);
@@ -256,9 +257,11 @@ static bool BME680_readCalValues(I2CSensor* i2c_sensor) {
 
     /* Humidity related coefficients */
     bme680_instance->hum_cal.dig_H1 =
-        (uint16_t)(((uint16_t)coeff_array[BME680_H1_MSB_REG] << BME680_HUM_REG_SHIFT_VAL) | (coeff_array[BME680_H1_LSB_REG] & BME680_BIT_H1_DATA_MSK));
+        (uint16_t)(((uint16_t)coeff_array[BME680_H1_MSB_REG] << BME680_HUM_REG_SHIFT_VAL) |
+                   (coeff_array[BME680_H1_LSB_REG] & BME680_BIT_H1_DATA_MSK));
     bme680_instance->hum_cal.dig_H2 =
-        (uint16_t)(((uint16_t)coeff_array[BME680_H2_MSB_REG] << BME680_HUM_REG_SHIFT_VAL) | ((coeff_array[BME680_H2_LSB_REG]) >> BME680_HUM_REG_SHIFT_VAL));
+        (uint16_t)(((uint16_t)coeff_array[BME680_H2_MSB_REG] << BME680_HUM_REG_SHIFT_VAL) |
+                   ((coeff_array[BME680_H2_LSB_REG]) >> BME680_HUM_REG_SHIFT_VAL));
     bme680_instance->hum_cal.dig_H3 = (int8_t)coeff_array[BME680_H3_REG];
     bme680_instance->hum_cal.dig_H4 = (int8_t)coeff_array[BME680_H4_REG];
     bme680_instance->hum_cal.dig_H5 = (int8_t)coeff_array[BME680_H5_REG];