diff --git a/lib/WjCryptLib_Aes.c b/lib/WjCryptLib_Aes.c
index 612c7ee..63c3bdc 100644
--- a/lib/WjCryptLib_Aes.c
+++ b/lib/WjCryptLib_Aes.c
@@ -667,20 +667,20 @@ static const uint32_t rcon[] =
 #define BYTE(x, n) (((x) >> (8 * (n))) & 255)
 
 #define STORE32H(x, y)                           \
-{                                                \
+do {                                             \
     (y)[0] = (unsigned char)(((x)>>24)&255);     \
     (y)[1] = (unsigned char)(((x)>>16)&255);     \
     (y)[2] = (unsigned char)(((x)>>8)&255);      \
     (y)[3] = (unsigned char)((x)&255);           \
-}
+} while (0)
 
 #define LOAD32H(x, y)                            \
-{                                                \
+do {                                             \
     x = ((uint32_t)((y)[0] & 255)<<24)           \
       | ((uint32_t)((y)[1] & 255)<<16)           \
       | ((uint32_t)((y)[2] & 255)<<8)            \
       | ((uint32_t)((y)[3] & 255));              \
-}
+} while (0)
 
 #define ROL(x, y)  ( (((uint32_t)(x)<<(uint32_t)((y)&31)) | (((uint32_t)(x)&0xFFFFFFFFUL)>>(uint32_t)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
 #define ROR(x, y)  ( ((((uint32_t)(x)&0xFFFFFFFFUL)>>(uint32_t)((y)&31)) | ((uint32_t)(x)<<(uint32_t)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
diff --git a/lib/WjCryptLib_AesCtr.c b/lib/WjCryptLib_AesCtr.c
index a5e67b6..0008d34 100644
--- a/lib/WjCryptLib_AesCtr.c
+++ b/lib/WjCryptLib_AesCtr.c
@@ -27,10 +27,10 @@
 #define MIN( x, y ) ( ((x)<(y))?(x):(y) )
 
 #define STORE64H( x, y )                                                       \
-   { (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255);     \
-     (y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255);     \
-     (y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255);     \
-     (y)[6] = (uint8_t)(((x)>>8)&255);  (y)[7] = (uint8_t)((x)&255); }
+    do { (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255); \
+         (y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255); \
+         (y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255); \
+         (y)[6] = (uint8_t)(((x)>>8)&255);  (y)[7] = (uint8_t)((x)&255); } while (0)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //  INTERNAL FUNCTIONS
diff --git a/lib/WjCryptLib_Rc4.c b/lib/WjCryptLib_Rc4.c
index 22828fa..e177e60 100644
--- a/lib/WjCryptLib_Rc4.c
+++ b/lib/WjCryptLib_Rc4.c
@@ -18,11 +18,11 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #define SwapBytes( Value1, Value2 )                 \
-{                                                   \
+do {                                                \
     uint8_t temp = Value1;                          \
     Value1 = Value2;                                \
     Value2 = temp;                                  \
-}
+} while (0)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //  PUBLIC FUNCTIONS
diff --git a/lib/WjCryptLib_Sha1.c b/lib/WjCryptLib_Sha1.c
index be190fe..ab550a3 100644
--- a/lib/WjCryptLib_Sha1.c
+++ b/lib/WjCryptLib_Sha1.c
@@ -48,10 +48,10 @@ typedef union
 
 // Endian neutral macro for loading 32 bit value from 4 byte array (in big endian form).
 #define LOAD32H(x, y)                           \
-     { x = ((uint32_t)((y)[0] & 255)<<24) |     \
-           ((uint32_t)((y)[1] & 255)<<16) |     \
-           ((uint32_t)((y)[2] & 255)<<8)  |     \
-           ((uint32_t)((y)[3] & 255)); }
+    do { x = ((uint32_t)((y)[0] & 255)<<24) |     \
+             ((uint32_t)((y)[1] & 255)<<16) |     \
+             ((uint32_t)((y)[2] & 255)<<8)  |     \
+             ((uint32_t)((y)[3] & 255)); } while (0)
 
 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 
@@ -65,11 +65,11 @@ typedef union
 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15] ^ block->l[(i+8)&15] ^ block->l[(i+2)&15] ^ block->l[i&15],1))
 
 // (R0+R1), R2, R3, R4 are the different operations used in SHA1
-#define R0(v,w,x,y,z,i)  z += ((w&(x^y))^y)     + blk0(i)+ 0x5A827999 + rol(v,5); w=rol(w,30);
-#define R1(v,w,x,y,z,i)  z += ((w&(x^y))^y)     + blk(i) + 0x5A827999 + rol(v,5); w=rol(w,30);
-#define R2(v,w,x,y,z,i)  z += (w^x^y)           + blk(i) + 0x6ED9EBA1 + rol(v,5); w=rol(w,30);
-#define R3(v,w,x,y,z,i)  z += (((w|x)&y)|(w&x)) + blk(i) + 0x8F1BBCDC + rol(v,5); w=rol(w,30);
-#define R4(v,w,x,y,z,i)  z += (w^x^y)           + blk(i) + 0xCA62C1D6 + rol(v,5); w=rol(w,30);
+#define R0(v,w,x,y,z,i)  do { z += ((w&(x^y))^y)     + blk0(i)+ 0x5A827999 + rol(v,5); w=rol(w,30); } while (0)
+#define R1(v,w,x,y,z,i)  do { z += ((w&(x^y))^y)     + blk(i) + 0x5A827999 + rol(v,5); w=rol(w,30); } while (0)
+#define R2(v,w,x,y,z,i)  do { z += (w^x^y)           + blk(i) + 0x6ED9EBA1 + rol(v,5); w=rol(w,30); } while (0)
+#define R3(v,w,x,y,z,i)  do { z += (((w|x)&y)|(w&x)) + blk(i) + 0x8F1BBCDC + rol(v,5); w=rol(w,30); } while (0)
+#define R4(v,w,x,y,z,i)  do { z += (w^x^y)           + blk(i) + 0xCA62C1D6 + rol(v,5); w=rol(w,30); } while (0)
 
 // Loads the 128 bits from ByteArray into WordArray, treating ByteArray as big endian data
 #ifdef USE_LITTLE_ENDIAN_SHORTCUT
@@ -77,13 +77,13 @@ typedef union
         memcpy( WordArray, ByteArray, 64 )
 #else
     #define Load128BitsAsWords( WordArray, ByteArray )      \
-    {                                                       \
+    do {                                                    \
         uint32_t i;                                         \
         for( i=0; i<16; i++ )                               \
         {                                                   \
             LOAD32H( (WordArray)[i], (ByteArray)+(i*4) );   \
         }                                                   \
-    }
+    } while (0)
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/lib/WjCryptLib_Sha256.c b/lib/WjCryptLib_Sha256.c
index 559865e..498874b 100644
--- a/lib/WjCryptLib_Sha256.c
+++ b/lib/WjCryptLib_Sha256.c
@@ -23,21 +23,21 @@
 
 #define MIN(x, y) ( ((x)<(y))?(x):(y) )
 
-#define STORE32H(x, y)                                                                     \
-     { (y)[0] = (uint8_t)(((x)>>24)&255); (y)[1] = (uint8_t)(((x)>>16)&255);   \
-       (y)[2] = (uint8_t)(((x)>>8)&255); (y)[3] = (uint8_t)((x)&255); }
+#define STORE32H(x, y)                                                         \
+    do { (y)[0] = (uint8_t)(((x)>>24)&255); (y)[1] = (uint8_t)(((x)>>16)&255); \
+         (y)[2] = (uint8_t)(((x)>>8)&255); (y)[3] = (uint8_t)((x)&255); } while (0)
 
 #define LOAD32H(x, y)                            \
-     { x = ((uint32_t)((y)[0] & 255)<<24) | \
-           ((uint32_t)((y)[1] & 255)<<16) | \
-           ((uint32_t)((y)[2] & 255)<<8)  | \
-           ((uint32_t)((y)[3] & 255)); }
+    do { x = ((uint32_t)((y)[0] & 255)<<24) | \
+             ((uint32_t)((y)[1] & 255)<<16) | \
+             ((uint32_t)((y)[2] & 255)<<8)  | \
+             ((uint32_t)((y)[3] & 255)); } while (0)
 
-#define STORE64H(x, y)                                                                     \
-   { (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255);     \
-     (y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255);     \
-     (y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255);     \
-     (y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); }
+#define STORE64H(x, y)                                                         \
+    do { (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255); \
+         (y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255); \
+         (y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255); \
+         (y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); } while (0)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //  CONSTANTS
@@ -77,10 +77,12 @@ static const uint32_t K[64] = {
 #define Gamma1( x )       (S(x, 17) ^ S(x, 19) ^ R(x, 10))
 
 #define Sha256Round( a, b, c, d, e, f, g, h, i )       \
+    do {                                               \
      t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i];   \
      t1 = Sigma0(a) + Maj(a, b, c);                    \
      d += t0;                                          \
-     h  = t0 + t1;
+     h  = t0 + t1;                                     \
+    } while (0)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //  TransformFunction
diff --git a/lib/WjCryptLib_Sha512.c b/lib/WjCryptLib_Sha512.c
index a47365d..d09d87b 100644
--- a/lib/WjCryptLib_Sha512.c
+++ b/lib/WjCryptLib_Sha512.c
@@ -23,17 +23,17 @@
 
 #define MIN( x, y ) ( ((x)<(y))?(x):(y) )
 
-#define LOAD64H( x, y )                                                      \
-   { x = (((uint64_t)((y)[0] & 255))<<56)|(((uint64_t)((y)[1] & 255))<<48) | \
-         (((uint64_t)((y)[2] & 255))<<40)|(((uint64_t)((y)[3] & 255))<<32) | \
-         (((uint64_t)((y)[4] & 255))<<24)|(((uint64_t)((y)[5] & 255))<<16) | \
-         (((uint64_t)((y)[6] & 255))<<8)|(((uint64_t)((y)[7] & 255))); }
-
-#define STORE64H( x, y )                                                                     \
-   { (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255);     \
-     (y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255);     \
-     (y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255);     \
-     (y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); }
+#define LOAD64H( x, y )                                                          \
+    do { x = (((uint64_t)((y)[0] & 255))<<56)|(((uint64_t)((y)[1] & 255))<<48) | \
+             (((uint64_t)((y)[2] & 255))<<40)|(((uint64_t)((y)[3] & 255))<<32) | \
+             (((uint64_t)((y)[4] & 255))<<24)|(((uint64_t)((y)[5] & 255))<<16) | \
+             (((uint64_t)((y)[6] & 255))<<8)|(((uint64_t)((y)[7] & 255))); } while (0)
+
+#define STORE64H( x, y )                                                       \
+    do { (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255); \
+         (y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255); \
+         (y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255); \
+         (y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); } while (0)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //  CONSTANTS
@@ -80,10 +80,12 @@ static const uint64_t K[80] = {
 #define Gamma1( x )       (S(x, 19) ^ S(x, 61) ^ R(x, 6))
 
 #define Sha512Round( a, b, c, d, e, f, g, h, i )       \
+    do {                                               \
      t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i];   \
      t1 = Sigma0(a) + Maj(a, b, c);                    \
      d += t0;                                          \
-     h  = t0 + t1;
+     h  = t0 + t1;                                     \
+    } while (0)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //  TransformFunction