Skip to content

Commit d4fe757

Browse files
SenRamakriSenRamakri
committed
Adding mbed prefixes to all macros and functions to avoid namespace conflicts
1 parent 147d9ca commit d4fe757

File tree

14 files changed

+158
-158
lines changed

14 files changed

+158
-158
lines changed

‎TESTS/mbed_platform/error_handling/main.cpp

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ void test_error_count_and_reset()
3636
TEST_ASSERT_EQUAL_INT(count, get_error_count());
3737

3838
//clear the errors and error count to 0
39-
clear_all_errors();
39+
mbed_clear_all_errors();
4040

4141
//Now the error count should be 0
4242
TEST_ASSERT_EQUAL_INT(0, get_error_count());
@@ -56,15 +56,15 @@ void test_error_capturing()
5656
MBED_WARNING(MBED_ERROR_OUT_OF_RESOURCES, "System type error", 0x1100 );
5757
mbed_error_status_t lastError = get_last_error();
5858
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_SYSTEM, MBED_GET_ERROR_TYPE(lastError));
59-
TEST_ASSERT_EQUAL_UINT(MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
59+
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
6060
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_OUT_OF_RESOURCES, MBED_GET_ERROR_CODE(lastError));
6161

62-
mbed_error_status_t error = MAKE_ERROR(MODULE_DRIVER_SERIAL, MBED_ERROR_CODE_OUT_OF_RESOURCES);
62+
mbed_error_status_t error = MBED_MAKE_ERROR(MBED_MODULE_DRIVER_SERIAL, MBED_ERROR_CODE_OUT_OF_RESOURCES);
6363
MBED_WARNING(error, "Error Serial", 0xAA );
6464
lastError = get_last_error();
6565
TEST_ASSERT_EQUAL_UINT(error, lastError);
6666

67-
error = MAKE_CUSTOM_ERROR(MODULE_APPLICATION, MBED_ERROR_CODE_UNKNOWN);
67+
error = MBED_MAKE_CUSTOM_ERROR(MBED_MODULE_APPLICATION, MBED_ERROR_CODE_UNKNOWN);
6868
MBED_WARNING(error, "Custom Error Unknown", 0x1234 );
6969
lastError = get_last_error();
7070
TEST_ASSERT_EQUAL_UINT(error, lastError);
@@ -73,34 +73,34 @@ void test_error_capturing()
7373
lastError = get_last_error();
7474
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_EPERM, lastError);
7575

76-
error = MAKE_CUSTOM_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_CREATE_FAILED);
76+
error = MBED_MAKE_CUSTOM_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_CREATE_FAILED);
7777
MBED_WARNING(error, "Custom Error Type", error_value);
7878
lastError = get_last_error();
7979
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_CUSTOM, MBED_GET_ERROR_TYPE(lastError));
80-
TEST_ASSERT_EQUAL_UINT(MODULE_PLATFORM, MBED_GET_ERROR_MODULE(lastError));
80+
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_PLATFORM, MBED_GET_ERROR_MODULE(lastError));
8181
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_CREATE_FAILED, MBED_GET_ERROR_CODE(lastError));
82-
mbed_error_status_t status = get_last_error_log_info( &error_ctx );
82+
mbed_error_status_t status = mbed_get_last_error_log_info( &error_ctx );
8383
TEST_ASSERT(status == MBED_SUCCESS);
8484
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
8585

8686
error_value = 0xAABBCC;
8787
MBED_WARNING(MBED_ERROR_EACCES, "Posix Error", error_value );
8888
lastError = get_last_error();
8989
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_POSIX, MBED_GET_ERROR_TYPE(lastError));
90-
TEST_ASSERT_EQUAL_UINT(MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
90+
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
9191
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_EACCES, MBED_GET_ERROR_CODE(lastError));
92-
status = get_last_error_log_info( &error_ctx );
92+
status = mbed_get_last_error_log_info( &error_ctx );
9393
TEST_ASSERT(status == MBED_SUCCESS);
9494
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
9595

9696
error_value = 0;
97-
error = MAKE_ERROR(MODULE_HAL, MBED_ERROR_CODE_UNKNOWN);
97+
error = MBED_MAKE_ERROR(MBED_MODULE_HAL, MBED_ERROR_CODE_UNKNOWN);
9898
MBED_WARNING(error, "HAL Entity error", error_value );
9999
lastError = get_last_error();
100100
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_SYSTEM, MBED_GET_ERROR_TYPE(lastError));
101-
TEST_ASSERT_EQUAL_UINT(MODULE_HAL, MBED_GET_ERROR_MODULE(lastError));
101+
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_HAL, MBED_GET_ERROR_MODULE(lastError));
102102
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_UNKNOWN, MBED_GET_ERROR_CODE(lastError));
103-
status = get_last_error_log_info( &error_ctx );
103+
status = mbed_get_last_error_log_info( &error_ctx );
104104
TEST_ASSERT(status == MBED_SUCCESS);
105105
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
106106

@@ -121,7 +121,7 @@ void test_error_context_capture()
121121
mbed_error_ctx error_ctx = {0};
122122

123123
MBED_WARNING(MBED_ERROR_INVALID_ARGUMENT, "System type error", error_value );
124-
mbed_error_status_t status = get_last_error_log_info( &error_ctx );
124+
mbed_error_status_t status = mbed_get_last_error_log_info( &error_ctx );
125125
TEST_ASSERT(status == MBED_SUCCESS);
126126
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
127127
TEST_ASSERT_EQUAL_UINT(osThreadGetId(), error_ctx.thread_id);
@@ -144,22 +144,22 @@ void test_error_logging()
144144
mbed_error_ctx error_ctx = {0};
145145

146146
//clear the current errors first
147-
clear_all_errors();
147+
mbed_clear_all_errors();
148148

149149
//log 3 errors and retrieve them to ensure they are correct
150150
MBED_WARNING(MBED_ERROR_INVALID_ARGUMENT, "Invalid argument", 1 );
151151
MBED_WARNING(MBED_ERROR_INVALID_SIZE, "Invalid size", 2 );
152152
MBED_WARNING(MBED_ERROR_INVALID_FORMAT, "Invalid format", 3 );
153153

154-
mbed_error_status_t status = get_error_log_info( 0, &error_ctx );
154+
mbed_error_status_t status = mbed_get_error_log_info( 0, &error_ctx );
155155
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_ARGUMENT, error_ctx.error_status);
156156
TEST_ASSERT_EQUAL_UINT(1, error_ctx.error_value);
157157

158-
status = get_error_log_info( 1, &error_ctx );
158+
status = mbed_get_error_log_info( 1, &error_ctx );
159159
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_SIZE, error_ctx.error_status);
160160
TEST_ASSERT_EQUAL_UINT(2, error_ctx.error_value);
161161

162-
status = get_error_log_info( 2, &error_ctx );
162+
status = mbed_get_error_log_info( 2, &error_ctx );
163163
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_FORMAT, error_ctx.error_status);
164164
TEST_ASSERT_EQUAL_UINT(3, error_ctx.error_value);
165165

@@ -175,24 +175,24 @@ void test_error_logging()
175175
MBED_WARNING(MBED_ERROR_UNSUPPORTED, "Not supported", 12 );
176176
MBED_WARNING(MBED_ERROR_ACCESS_DENIED, "Access denied", 13 );
177177

178-
status = get_error_log_info( 0, &error_ctx );
178+
status = mbed_get_error_log_info( 0, &error_ctx );
179179
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TIME_OUT, error_ctx.error_status);
180180
TEST_ASSERT_EQUAL_UINT(10, error_ctx.error_value);
181181

182-
status = get_error_log_info( 1, &error_ctx );
182+
status = mbed_get_error_log_info( 1, &error_ctx );
183183
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_ALREADY_IN_USE, error_ctx.error_status);
184184
TEST_ASSERT_EQUAL_UINT(11, error_ctx.error_value);
185185

186-
status = get_error_log_info( 2, &error_ctx );
186+
status = mbed_get_error_log_info( 2, &error_ctx );
187187
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_UNSUPPORTED, error_ctx.error_status);
188188
TEST_ASSERT_EQUAL_UINT(12, error_ctx.error_value);
189189

190-
status = get_error_log_info( 3, &error_ctx );
190+
status = mbed_get_error_log_info( 3, &error_ctx );
191191
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_ACCESS_DENIED, error_ctx.error_status);
192192
TEST_ASSERT_EQUAL_UINT(13, error_ctx.error_value);
193193

194194
//Try an index which is invalid, we should get ERROR_INVALID_ARGUMENT back
195-
status = get_error_log_info( 99, &error_ctx );
195+
status = mbed_get_error_log_info( 99, &error_ctx );
196196
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_ARGUMENT, status);
197197

198198
}
@@ -228,10 +228,10 @@ void test_error_logging_multithread()
228228
errThread[i]->join();
229229
}
230230

231-
i = get_error_log_count()-1;
231+
i = mbed_get_error_log_count()-1;
232232
//printf("\nError log count = %d\n", i+1);
233233
for(;i>=0;--i) {
234-
mbed_error_status_t status = get_error_log_info( i, &error_ctx );
234+
mbed_error_status_t status = mbed_get_error_log_info( i, &error_ctx );
235235
if(status != MBED_SUCCESS) {
236236
TEST_FAIL();
237237
}
@@ -252,7 +252,7 @@ void MyErrorHook(const mbed_error_ctx *error_ctx)
252252
*/
253253
void test_error_hook()
254254
{
255-
if( MBED_SUCCESS != set_error_hook(MyErrorHook)) {
255+
if( MBED_SUCCESS != mbed_set_error_hook(MyErrorHook)) {
256256
TEST_FAIL();
257257
}
258258

@@ -317,7 +317,7 @@ void test_save_error_log()
317317
TEST_FAIL();
318318
}
319319

320-
if(MBED_SUCCESS != save_error_log("/fs/errors.log")) {
320+
if(MBED_SUCCESS != mbed_save_error_log("/fs/errors.log")) {
321321
printf("Failed saving error log");
322322
TEST_FAIL();
323323
}

‎features/FEATURE_LWIP/lwip-interface/lwip-sys/arch/lwip_sys_arch.c

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -123,15 +123,15 @@ u32_t sys_now(void) {
123123
*---------------------------------------------------------------------------*/
124124
err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
125125
if (queue_sz > MB_SIZE)
126-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_INVALID_SIZE), "sys_mbox_new size error\n", queue_sz);
126+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INVALID_SIZE), "sys_mbox_new size error\n", queue_sz);
127127

128128
memset(mbox, 0, sizeof(*mbox));
129129

130130
mbox->attr.cb_mem = &mbox->data;
131131
mbox->attr.cb_size = sizeof(mbox->data);
132132
mbox->id = osEventFlagsNew(&mbox->attr);
133133
if (mbox->id == NULL)
134-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_mbox_new create error\n", mbox->id);
134+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_mbox_new create error\n", mbox->id);
135135

136136
osEventFlagsSet(mbox->id, SYS_MBOX_POST_EVENT);
137137

@@ -150,7 +150,7 @@ err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
150150
*---------------------------------------------------------------------------*/
151151
void sys_mbox_free(sys_mbox_t *mbox) {
152152
if (mbox->post_idx != mbox->fetch_idx)
153-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_FREE_FAILED), "sys_mbox_free error\n", mbox->post_idx);
153+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_FREE_FAILED), "sys_mbox_free error\n", mbox->post_idx);
154154
}
155155

156156
/*---------------------------------------------------------------------------*
@@ -309,7 +309,7 @@ err_t sys_sem_new(sys_sem_t *sem, u8_t count) {
309309
sem->attr.cb_size = sizeof(sem->data);
310310
sem->id = osSemaphoreNew(UINT16_MAX, count, &sem->attr);
311311
if (sem->id == NULL)
312-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_sem_new create error\n", sem->id);
312+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_sem_new create error\n", sem->id);
313313

314314
return ERR_OK;
315315
}
@@ -388,14 +388,14 @@ err_t sys_mutex_new(sys_mutex_t *mutex) {
388388
* @param mutex the mutex to lock */
389389
void sys_mutex_lock(sys_mutex_t *mutex) {
390390
if (osMutexAcquire(mutex->id, osWaitForever) != osOK)
391-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_mutex_lock error\n", mutex->id);
391+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_mutex_lock error\n", mutex->id);
392392
}
393393

394394
/** Unlock a mutex
395395
* @param mutex the mutex to unlock */
396396
void sys_mutex_unlock(sys_mutex_t *mutex) {
397397
if (osMutexRelease(mutex->id) != osOK)
398-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_UNLOCK_FAILED), "sys_mutex_unlock error\n", mutex->id);
398+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_UNLOCK_FAILED), "sys_mutex_unlock error\n", mutex->id);
399399
}
400400

401401
/** Delete a mutex
@@ -418,7 +418,7 @@ void sys_init(void) {
418418
lwip_sys_mutex_attr.cb_size = sizeof(lwip_sys_mutex_data);
419419
lwip_sys_mutex = osMutexNew(&lwip_sys_mutex_attr);
420420
if (lwip_sys_mutex == NULL)
421-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_INITIALIZATION_FAILED), "sys_init error\n", lwip_sys_mutex);
421+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INITIALIZATION_FAILED), "sys_init error\n", lwip_sys_mutex);
422422
}
423423

424424
/*---------------------------------------------------------------------------*
@@ -452,7 +452,7 @@ u32_t sys_jiffies(void) {
452452
*---------------------------------------------------------------------------*/
453453
sys_prot_t sys_arch_protect(void) {
454454
if (osMutexAcquire(lwip_sys_mutex, osWaitForever) != osOK)
455-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_protect error\n", lwip_sys_mutex);
455+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_protect error\n", lwip_sys_mutex);
456456
return (sys_prot_t) 1;
457457
}
458458

@@ -469,7 +469,7 @@ sys_prot_t sys_arch_protect(void) {
469469
*---------------------------------------------------------------------------*/
470470
void sys_arch_unprotect(sys_prot_t p) {
471471
if (osMutexRelease(lwip_sys_mutex) != osOK)
472-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_unprotect error\n", lwip_sys_mutex);
472+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_unprotect error\n", lwip_sys_mutex);
473473
}
474474

475475
u32_t sys_now(void) {
@@ -508,7 +508,7 @@ sys_thread_t sys_thread_new(const char *pcName,
508508
LWIP_DEBUGF(SYS_DEBUG, ("New Thread: %s\n", pcName));
509509

510510
if (thread_pool_index >= SYS_THREAD_POOL_N)
511-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new number error\n", thread_pool_index);
511+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new number error\n", thread_pool_index);
512512
sys_thread_t t = (sys_thread_t)&thread_pool[thread_pool_index];
513513
thread_pool_index++;
514514

@@ -520,11 +520,11 @@ sys_thread_t sys_thread_new(const char *pcName,
520520
t->attr.stack_size = stacksize;
521521
t->attr.stack_mem = malloc(stacksize);
522522
if (t->attr.stack_mem == NULL) {
523-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_OUT_OF_MEMORY), "Error allocating the stack memory", t);
523+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_OUT_OF_MEMORY), "Error allocating the stack memory", t);
524524
}
525525
t->id = osThreadNew((osThreadFunc_t)thread, arg, &t->attr);
526526
if (t->id == NULL)
527-
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new create error\n", t->id);
527+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new create error\n", t->id);
528528

529529
return t;
530530
}

‎features/filesystem/bd/ReadOnlyBlockDevice.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -57,13 +57,13 @@ int ReadOnlyBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
5757

5858
int ReadOnlyBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size)
5959
{
60-
MBED_ERROR(MAKE_ERROR(MODULE_BLOCK_DEVICE, MBED_ERROR_CODE_WRITE_PROTECTED), "ReadOnlyBlockDevice::program() not allowed", addr);
60+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_BLOCK_DEVICE, MBED_ERROR_CODE_WRITE_PROTECTED), "ReadOnlyBlockDevice::program() not allowed", addr);
6161
return MBED_ERROR_WRITE_PROTECTED;
6262
}
6363

6464
int ReadOnlyBlockDevice::erase(bd_addr_t addr, bd_size_t size)
6565
{
66-
MBED_ERROR(MAKE_ERROR(MODULE_BLOCK_DEVICE, MBED_ERROR_CODE_WRITE_PROTECTED), "ReadOnlyBlockDevice::erase() not allowed", addr);
66+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_BLOCK_DEVICE, MBED_ERROR_CODE_WRITE_PROTECTED), "ReadOnlyBlockDevice::erase() not allowed", addr);
6767
return MBED_ERROR_WRITE_PROTECTED;
6868
}
6969

‎hal/mbed_pinmap_common.c

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ void pinmap_pinout(PinName pin, const PinMap *map) {
2929
}
3030
map++;
3131
}
32-
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "could not pinout", pin);
32+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "could not pinout", pin);
3333
}
3434

3535
uint32_t pinmap_merge(uint32_t a, uint32_t b) {
@@ -44,7 +44,7 @@ uint32_t pinmap_merge(uint32_t a, uint32_t b) {
4444
return a;
4545

4646
// mis-match error case
47-
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap mis-match", a);
47+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap mis-match", a);
4848
return (uint32_t)NC;
4949
}
5050

@@ -64,7 +64,7 @@ uint32_t pinmap_peripheral(PinName pin, const PinMap* map) {
6464
return (uint32_t)NC;
6565
peripheral = pinmap_find_peripheral(pin, map);
6666
if ((uint32_t)NC == peripheral) // no mapping available
67-
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap not found for peripheral", peripheral);
67+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap not found for peripheral", peripheral);
6868
return peripheral;
6969
}
7070

@@ -84,6 +84,6 @@ uint32_t pinmap_function(PinName pin, const PinMap* map) {
8484
return (uint32_t)NC;
8585
function = pinmap_find_function(pin, map);
8686
if ((uint32_t)NC == function) // no mapping available
87-
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap not found for function", function);
87+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap not found for function", function);
8888
return function;
8989
}

‎hal/mbed_sleep_manager.c

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -161,7 +161,7 @@ void sleep_manager_lock_deep_sleep_internal(void)
161161
core_util_critical_section_enter();
162162
if (deep_sleep_lock == USHRT_MAX) {
163163
core_util_critical_section_exit();
164-
MBED_ERROR(MAKE_ERROR(MODULE_HAL, MBED_ERROR_CODE_OVERFLOW), "DeepSleepLock overflow (> USHRT_MAX)", deep_sleep_lock);
164+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_HAL, MBED_ERROR_CODE_OVERFLOW), "DeepSleepLock overflow (> USHRT_MAX)", deep_sleep_lock);
165165
}
166166
core_util_atomic_incr_u16(&deep_sleep_lock, 1);
167167
core_util_critical_section_exit();
@@ -172,7 +172,7 @@ void sleep_manager_unlock_deep_sleep_internal(void)
172172
core_util_critical_section_enter();
173173
if (deep_sleep_lock == 0) {
174174
core_util_critical_section_exit();
175-
MBED_ERROR(MAKE_ERROR(MODULE_HAL, MBED_ERROR_CODE_UNDERFLOW), "DeepSleepLock underflow (< 0)", deep_sleep_lock);
175+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_HAL, MBED_ERROR_CODE_UNDERFLOW), "DeepSleepLock underflow (< 0)", deep_sleep_lock);
176176
}
177177
core_util_atomic_decr_u16(&deep_sleep_lock, 1);
178178
core_util_critical_section_exit();

‎platform/DeepSleepLock.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,7 @@ class DeepSleepLock {
6969
sleep_manager_lock_deep_sleep();
7070
}
7171
if (0 == count) {
72-
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OVERFLOW), "DeepSleepLock overflow (> USHRT_MAX)", count);
72+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OVERFLOW), "DeepSleepLock overflow (> USHRT_MAX)", count);
7373
}
7474
}
7575

@@ -83,7 +83,7 @@ class DeepSleepLock {
8383
}
8484
if (count == USHRT_MAX) {
8585
core_util_critical_section_exit();
86-
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_UNDERFLOW), "DeepSleepLock underflow (< 0)", count);
86+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_UNDERFLOW), "DeepSleepLock underflow (< 0)", count);
8787
}
8888
}
8989
};

‎platform/Stream.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ Stream::Stream(const char *name) : FileLike(name), _file(NULL) {
2929
if (_file) {
3030
mbed_set_unbuffered_stream(_file);
3131
} else {
32-
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OPEN_FAILED), "Stream obj failure", _file);
32+
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OPEN_FAILED), "Stream obj failure", _file);
3333
}
3434
}
3535

0 commit comments

Comments
 (0)