Change MBED_STATIC_ASSERTs version for built-in

Author: pea-pod

TESTS/mbedmicro-mbed/static_assert/test_c.c

@@ -15,43 +15,43 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-#include "mbed_assert.h"
+#include <assert.h>
 #define THE_ANSWER 42
 
 // Tests for static asserts in different contexts
 // multiple asserts are used to guarantee no conflicts occur in generated labels
 
 // Test for static asserts in global context
-MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
-                   "An int must be larger than char");
-MBED_STATIC_ASSERT(2 + 2 == 4,
-                   "Hopefully the universe is mathematically consistent");
-MBED_STATIC_ASSERT(THE_ANSWER == 42,
-                   "Said Deep Thought, with infinite majesty and calm");
+static_assert(sizeof(int) >= sizeof(char),
+              "An int must be larger than char");
+static_assert(2 + 2 == 4,
+              "Hopefully the universe is mathematically consistent");
+static_assert(THE_ANSWER == 42,
+              "Said Deep Thought, with infinite majesty and calm");
 
 struct test {
     int dummy;
 
     // Test for static asserts in struct context
-    MBED_STRUCT_STATIC_ASSERT(sizeof(int) >= sizeof(char),
-                              "An int must be larger than char");
-    MBED_STRUCT_STATIC_ASSERT(2 + 2 == 4,
-                              "Hopefully the universe is mathematically consistent");
-    MBED_STRUCT_STATIC_ASSERT(THE_ANSWER == 42,
-                              "Said Deep Thought, with infinite majesty and calm");
+    static_assert(sizeof(int) >= sizeof(char),
+                  "An int must be larger than char");
+    static_assert(2 + 2 == 4,
+                  "Hopefully the universe is mathematically consistent");
+    static_assert(THE_ANSWER == 42,
+                  "Said Deep Thought, with infinite majesty and calm");
 };
 
-MBED_STATIC_ASSERT(sizeof(struct test) == sizeof(int),
-                   "Static assertions should not change the size of a struct");
+static_assert(sizeof(struct test) == sizeof(int),
+              "Static assertions should not change the size of a struct");
 
 void doit_c(void)
 {
     // Test for static asserts in function context
-    MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
-                       "An int must be larger than char");
-    MBED_STATIC_ASSERT(2 + 2 == 4,
-                       "Hopefully the universe is mathematically consistent");
-    MBED_STATIC_ASSERT(THE_ANSWER == 42,
-                       "Said Deep Thought, with infinite majesty and calm");
+    static_assert(sizeof(int) >= sizeof(char),
+                  "An int must be larger than char");
+    static_assert(2 + 2 == 4,
+                  "Hopefully the universe is mathematically consistent");
+    static_assert(THE_ANSWER == 42,
+                  "Said Deep Thought, with infinite majesty and calm");
 }
 

TESTS/mbedmicro-mbed/static_assert/test_cpp.cpp

@@ -22,43 +22,43 @@
 // multiple asserts are used to guarantee no conflicts occur in generated labels
 
 // Test for static asserts in global context
-MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
-                   "An int must be larger than char");
-MBED_STATIC_ASSERT(2 + 2 == 4,
-                   "Hopefully the universe is mathematically consistent");
-MBED_STATIC_ASSERT(THE_ANSWER == 42,
-                   "Said Deep Thought, with infinite majesty and calm");
+static_assert(sizeof(int) >= sizeof(char),
+              "An int must be larger than char");
+static_assert(2 + 2 == 4,
+              "Hopefully the universe is mathematically consistent");
+static_assert(THE_ANSWER == 42,
+              "Said Deep Thought, with infinite majesty and calm");
 
 struct test {
     int dummy;
 
     // Test for static asserts in struct context
-    MBED_STRUCT_STATIC_ASSERT(sizeof(int) >= sizeof(char),
-                              "An int must be larger than char");
-    MBED_STRUCT_STATIC_ASSERT(2 + 2 == 4,
-                              "Hopefully the universe is mathematically consistent");
-    MBED_STRUCT_STATIC_ASSERT(THE_ANSWER == 42,
-                              "Said Deep Thought, with infinite majesty and calm");
+    static_assert(sizeof(int) >= sizeof(char),
+                  "An int must be larger than char");
+    static_assert(2 + 2 == 4,
+                  "Hopefully the universe is mathematically consistent");
+    static_assert(THE_ANSWER == 42,
+                  "Said Deep Thought, with infinite majesty and calm");
 
-    MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
-                       "An int must be larger than char");
-    MBED_STATIC_ASSERT(2 + 2 == 4,
-                       "Hopefully the universe is mathematically consistent");
-    MBED_STATIC_ASSERT(THE_ANSWER == 42,
-                       "Said Deep Thought, with infinite majesty and calm");
+    static_assert(sizeof(int) >= sizeof(char),
+                  "An int must be larger than char");
+    static_assert(2 + 2 == 4,
+                  "Hopefully the universe is mathematically consistent");
+    static_assert(THE_ANSWER == 42,
+                  "Said Deep Thought, with infinite majesty and calm");
 };
 
-MBED_STATIC_ASSERT(sizeof(struct test) == sizeof(int),
-                   "Static assertions should not change the size of a struct");
+static_assert(sizeof(struct test) == sizeof(int),
+              "Static assertions should not change the size of a struct");
 
 void doit_c(void)
 {
     // Test for static asserts in function context
-    MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
-                       "An int must be larger than char");
-    MBED_STATIC_ASSERT(2 + 2 == 4,
-                       "Hopefully the universe is mathematically consistent");
-    MBED_STATIC_ASSERT(THE_ANSWER == 42,
-                       "Said Deep Thought, with infinite majesty and calm");
+    static_assert(sizeof(int) >= sizeof(char),
+                  "An int must be larger than char");
+    static_assert(2 + 2 == 4,
+                  "Hopefully the universe is mathematically consistent");
+    static_assert(THE_ANSWER == 42,
+                  "Said Deep Thought, with infinite majesty and calm");
 }
 

components/storage/blockdevice/COMPONENT_SD/SDBlockDevice.cpp

@@ -264,8 +264,8 @@ SDBlockDevice::SDBlockDevice(PinName mosi, PinName miso, PinName sclk, PinName c
     _card_type = SDCARD_NONE;
 
     // Set default to 100kHz for initialisation and 1MHz for data transfer
-    MBED_STATIC_ASSERT(((MBED_CONF_SD_INIT_FREQUENCY >= 100000) && (MBED_CONF_SD_INIT_FREQUENCY <= 400000)),
-                       "Initialization frequency should be between 100KHz to 400KHz");
+    static_assert(((MBED_CONF_SD_INIT_FREQUENCY >= 100000) && (MBED_CONF_SD_INIT_FREQUENCY <= 400000)),
+                  "Initialization frequency should be between 100KHz to 400KHz");
     _init_sck = MBED_CONF_SD_INIT_FREQUENCY;
     _transfer_sck = hz;
 
@@ -285,8 +285,8 @@ SDBlockDevice::SDBlockDevice(const spi_pinmap_t &spi_pinmap, PinName cs, uint64_
     _card_type = SDCARD_NONE;
 
     // Set default to 100kHz for initialisation and 1MHz for data transfer
-    MBED_STATIC_ASSERT(((MBED_CONF_SD_INIT_FREQUENCY >= 100000) && (MBED_CONF_SD_INIT_FREQUENCY <= 400000)),
-                       "Initialization frequency should be between 100KHz to 400KHz");
+    static_assert(((MBED_CONF_SD_INIT_FREQUENCY >= 100000) && (MBED_CONF_SD_INIT_FREQUENCY <= 400000)),
+                  "Initialization frequency should be between 100KHz to 400KHz");
     _init_sck = MBED_CONF_SD_INIT_FREQUENCY;
     _transfer_sck = hz;
 
@@ -711,15 +711,15 @@ uint8_t SDBlockDevice::_cmd_spi(SDBlockDevice::cmdSupported cmd, uint32_t arg)
         // CMD0 is executed in SD mode, hence should have correct CRC
         // CMD8 CRC verification is always enabled
         switch (cmd) {
-            case CMD0_GO_IDLE_STATE:
-                cmdPacket[5] = 0x95;
-                break;
-            case CMD8_SEND_IF_COND:
-                cmdPacket[5] = 0x87;
-                break;
-            default:
-                cmdPacket[5] = 0xFF;    // Make sure bit 0-End bit is high
-                break;
+        case CMD0_GO_IDLE_STATE:
+            cmdPacket[5] = 0x95;
+            break;
+        case CMD8_SEND_IF_COND:
+            cmdPacket[5] = 0x87;
+            break;
+        default:
+            cmdPacket[5] = 0xFF;    // Make sure bit 0-End bit is high
+            break;
         }
     }
 
@@ -817,30 +817,30 @@ int SDBlockDevice::_cmd(SDBlockDevice::cmdSupported cmd, uint32_t arg, bool isAc
 
     // Get rest of the response part for other commands
     switch (cmd) {
-        case CMD8_SEND_IF_COND:             // Response R7
-            debug_if(_dbg, "V2-Version Card\n");
-            _card_type = SDCARD_V2; // fallthrough
-        // Note: No break here, need to read rest of the response
-        case CMD58_READ_OCR:                // Response R3
-            response  = (_spi.write(SPI_FILL_CHAR) << 24);
-            response |= (_spi.write(SPI_FILL_CHAR) << 16);
-            response |= (_spi.write(SPI_FILL_CHAR) << 8);
-            response |= _spi.write(SPI_FILL_CHAR);
-            debug_if(_dbg, "R3/R7: 0x%" PRIx32 "\n", response);
-            break;
+    case CMD8_SEND_IF_COND:             // Response R7
+        debug_if(_dbg, "V2-Version Card\n");
+        _card_type = SDCARD_V2; // fallthrough
+    // Note: No break here, need to read rest of the response
+    case CMD58_READ_OCR:                // Response R3
+        response  = (_spi.write(SPI_FILL_CHAR) << 24);
+        response |= (_spi.write(SPI_FILL_CHAR) << 16);
+        response |= (_spi.write(SPI_FILL_CHAR) << 8);
+        response |= _spi.write(SPI_FILL_CHAR);
+        debug_if(_dbg, "R3/R7: 0x%" PRIx32 "\n", response);
+        break;
 
-        case CMD12_STOP_TRANSMISSION:       // Response R1b
-        case CMD38_ERASE:
-            _wait_ready(SD_COMMAND_TIMEOUT);
-            break;
+    case CMD12_STOP_TRANSMISSION:       // Response R1b
+    case CMD38_ERASE:
+        _wait_ready(SD_COMMAND_TIMEOUT);
+        break;
 
-        case ACMD13_SD_STATUS:             // Response R2
-            response = _spi.write(SPI_FILL_CHAR);
-            debug_if(_dbg, "R2: 0x%" PRIx32 "\n", response);
-            break;
+    case ACMD13_SD_STATUS:             // Response R2
+        response = _spi.write(SPI_FILL_CHAR);
+        debug_if(_dbg, "R2: 0x%" PRIx32 "\n", response);
+        break;
 
-        default:                            // Response R1
-            break;
+    default:                            // Response R1
+        break;
     }
 
     // Pass the updated response to the command
@@ -1044,41 +1044,41 @@ bd_size_t SDBlockDevice::_sd_sectors()
     // csd_structure : csd[127:126]
     int csd_structure = ext_bits(csd, 127, 126);
     switch (csd_structure) {
-        case 0:
-            c_size = ext_bits(csd, 73, 62);              // c_size        : csd[73:62]
-            c_size_mult = ext_bits(csd, 49, 47);         // c_size_mult   : csd[49:47]
-            read_bl_len = ext_bits(csd, 83, 80);         // read_bl_len   : csd[83:80] - the *maximum* read block length
-            block_len = 1 << read_bl_len;                // BLOCK_LEN = 2^READ_BL_LEN
-            mult = 1 << (c_size_mult + 2);               // MULT = 2^C_SIZE_MULT+2 (C_SIZE_MULT < 8)
-            blocknr = (c_size + 1) * mult;               // BLOCKNR = (C_SIZE+1) * MULT
-            capacity = (bd_size_t) blocknr * block_len;  // memory capacity = BLOCKNR * BLOCK_LEN
-            blocks = capacity / _block_size;
-            debug_if(SD_DBG, "Standard Capacity: c_size: %" PRIu32 " \n", c_size);
-            debug_if(SD_DBG, "Sectors: 0x%" PRIx64 " : %" PRIu64 "\n", blocks, blocks);
-            debug_if(SD_DBG, "Capacity: 0x%" PRIx64 " : %" PRIu64 " MB\n", capacity, (capacity / (1024U * 1024U)));
-
-            // ERASE_BLK_EN = 1: Erase in multiple of 512 bytes supported
-            if (ext_bits(csd, 46, 46)) {
-                _erase_size = BLOCK_SIZE_HC;
-            } else {
-                // ERASE_BLK_EN = 1: Erase in multiple of SECTOR_SIZE supported
-                _erase_size = BLOCK_SIZE_HC * (ext_bits(csd, 45, 39) + 1);
-            }
-            break;
-
-        case 1:
-            hc_c_size = ext_bits(csd, 69, 48);            // device size : C_SIZE : [69:48]
-            blocks = (hc_c_size + 1) << 10;               // block count = C_SIZE+1) * 1K byte (512B is block size)
-            debug_if(SD_DBG, "SDHC/SDXC Card: hc_c_size: %" PRIu32 " \n", hc_c_size);
-            debug_if(SD_DBG, "Sectors: 0x%" PRIx64 "x : %" PRIu64 "\n", blocks, blocks);
-            debug_if(SD_DBG, "Capacity: %" PRIu64 " MB\n", (blocks / (2048U)));
-            // ERASE_BLK_EN is fixed to 1, which means host can erase one or multiple of 512 bytes.
+    case 0:
+        c_size = ext_bits(csd, 73, 62);              // c_size        : csd[73:62]
+        c_size_mult = ext_bits(csd, 49, 47);         // c_size_mult   : csd[49:47]
+        read_bl_len = ext_bits(csd, 83, 80);         // read_bl_len   : csd[83:80] - the *maximum* read block length
+        block_len = 1 << read_bl_len;                // BLOCK_LEN = 2^READ_BL_LEN
+        mult = 1 << (c_size_mult + 2);               // MULT = 2^C_SIZE_MULT+2 (C_SIZE_MULT < 8)
+        blocknr = (c_size + 1) * mult;               // BLOCKNR = (C_SIZE+1) * MULT
+        capacity = (bd_size_t) blocknr * block_len;  // memory capacity = BLOCKNR * BLOCK_LEN
+        blocks = capacity / _block_size;
+        debug_if(SD_DBG, "Standard Capacity: c_size: %" PRIu32 " \n", c_size);
+        debug_if(SD_DBG, "Sectors: 0x%" PRIx64 " : %" PRIu64 "\n", blocks, blocks);
+        debug_if(SD_DBG, "Capacity: 0x%" PRIx64 " : %" PRIu64 " MB\n", capacity, (capacity / (1024U * 1024U)));
+
+        // ERASE_BLK_EN = 1: Erase in multiple of 512 bytes supported
+        if (ext_bits(csd, 46, 46)) {
             _erase_size = BLOCK_SIZE_HC;
-            break;
+        } else {
+            // ERASE_BLK_EN = 1: Erase in multiple of SECTOR_SIZE supported
+            _erase_size = BLOCK_SIZE_HC * (ext_bits(csd, 45, 39) + 1);
+        }
+        break;
 
-        default:
-            debug_if(SD_DBG, "CSD struct unsupported\r\n");
-            return 0;
+    case 1:
+        hc_c_size = ext_bits(csd, 69, 48);            // device size : C_SIZE : [69:48]
+        blocks = (hc_c_size + 1) << 10;               // block count = C_SIZE+1) * 1K byte (512B is block size)
+        debug_if(SD_DBG, "SDHC/SDXC Card: hc_c_size: %" PRIu32 " \n", hc_c_size);
+        debug_if(SD_DBG, "Sectors: 0x%" PRIx64 "x : %" PRIu64 "\n", blocks, blocks);
+        debug_if(SD_DBG, "Capacity: %" PRIu64 " MB\n", (blocks / (2048U)));
+        // ERASE_BLK_EN is fixed to 1, which means host can erase one or multiple of 512 bytes.
+        _erase_size = BLOCK_SIZE_HC;
+        break;
+
+    default:
+        debug_if(SD_DBG, "CSD struct unsupported\r\n");
+        return 0;
     };
     return blocks;
 }

drivers/source/MbedCRC.cpp

@@ -23,8 +23,8 @@ namespace mbed {
 
 SingletonPtr<PlatformMutex> mbed_crc_mutex;
 
-MBED_STATIC_ASSERT(MBED_CRC_TABLE_SIZE == 0 || MBED_CRC_TABLE_SIZE == 16 || MBED_CRC_TABLE_SIZE == 256,
-                   "Configuration setting drivers.crc-table-size must be set to 0, 16 or 256");
+static_assert(MBED_CRC_TABLE_SIZE == 0 || MBED_CRC_TABLE_SIZE == 16 || MBED_CRC_TABLE_SIZE == 256,
+              "Configuration setting drivers.crc-table-size must be set to 0, 16 or 256");
 
 #if MBED_CRC_TABLE_SIZE > 0
 

events/source/equeue_mbed.cpp

@@ -105,10 +105,10 @@ static void equeue_tick_update()
 
 void equeue_tick_init()
 {
-    MBED_STATIC_ASSERT(sizeof(equeue_timer) >= sizeof(ALIAS_TIMER),
-                       "The equeue_timer buffer must fit the class Timer");
-    MBED_STATIC_ASSERT(sizeof(equeue_ticker) >= sizeof(ALIAS_TICKER),
-                       "The equeue_ticker buffer must fit the class Ticker");
+    static_assert(sizeof(equeue_timer) >= sizeof(ALIAS_TIMER),
+                  "The equeue_timer buffer must fit the class Timer");
+    static_assert(sizeof(equeue_ticker) >= sizeof(ALIAS_TICKER),
+                  "The equeue_ticker buffer must fit the class Ticker");
     ALIAS_TIMER *timer = new (equeue_timer) ALIAS_TIMER;
     ALIAS_TICKER *ticker = new (equeue_ticker) ALIAS_TICKER;
 
@@ -155,7 +155,7 @@ void equeue_mutex_unlock(equeue_mutex_t *m)
 
 #include "rtos/EventFlags.h"
 
-MBED_STATIC_ASSERT(sizeof(equeue_sema_t) == sizeof(rtos::EventFlags), "equeue_sema_t / rtos::EventFlags mismatch");
+static_assert(sizeof(equeue_sema_t) == sizeof(rtos::EventFlags), "equeue_sema_t / rtos::EventFlags mismatch");
 
 int equeue_sema_create(equeue_sema_t *s)
 {

features/FEATURE_BLE/ble/common/Duration.h

@@ -137,7 +137,7 @@ struct Duration {
     Duration(Duration<OtherRep, OtherTB, OtherRange, OtherF> other) :
         duration(clamp(other.value() * (OtherTB / TB)))
     {
-        MBED_STATIC_ASSERT(OtherTB >= TB && (OtherTB % TB) == 0, "Incompatible units");
+        static_assert(OtherTB >= TB && (OtherTB % TB) == 0, "Incompatible units");
     }
 
     /**

features/FEATURE_EXPERIMENTAL_API/TARGET_PSA/TARGET_MBED_PSA_SRV/services/crypto/COMPONENT_PSA_SRV_IPC/psa_crypto_spm.c

@@ -30,17 +30,17 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
+#include <assert.h>
 
 #include "psa_manifest/sid.h"
 #include "psa/client.h"
 #include "psa/crypto.h"
 #include "crypto_platform_spe.h"
-#include "mbed_assert.h"
 
 #define MINOR_VER 1
 #define CLIENT_PSA_KEY_ID_SIZE_IN_BYTES 4
 
-MBED_STATIC_ASSERT(sizeof(psa_key_id_t) == CLIENT_PSA_KEY_ID_SIZE_IN_BYTES, "Unexpected psa_key_id_t size");
+static_assert(sizeof(psa_key_id_t) == CLIENT_PSA_KEY_ID_SIZE_IN_BYTES, "Unexpected psa_key_id_t size");
 
 /****************************************************************/
 /* INTERNAL HELPER FUNCTIONS */