kingkevin
/
stm32f1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

global: fix ADD_SAFE macro and add function returning sum

This commit is contained in:
King Kévin 2020-12-07 19:10:04 +01:00
parent c085f2d292
commit fb088e6057
2 changed files with 118 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
global.c
View File

@ -28,6 +28,84 @@ static volatile uint8_t user_input_used = 0; /**< how much data has been receive
static volatile uint32_t sleep_duration = 0; /**< sleep duration count down (in SysTick interrupts) */
uint8_t addu8_safe(uint8_t a, uint8_t b)
{
if (a > UINT8_MAX - b) {
return UINT8_MAX;
} else {
return a + b;
}
}
uint16_t addu16_safe(uint16_t a, uint16_t b)
{
if (a > UINT16_MAX - b) {
return UINT16_MAX;
} else {
return a + b;
}
}
uint32_t addu32_safe(uint32_t a, uint32_t b)
{
if (a > UINT32_MAX - b) {
return UINT32_MAX;
} else {
return a + b;
}
}
int8_t adds8_safe(int8_t a, int8_t b)
{
if (b > 0) {
if (a > INT8_MAX - b) {
return INT8_MAX;
} else {
return a + b;
}
} else {
if (a < INT8_MIN + b) {
return INT8_MIN;
} else {
return a + b;
}
}
}
int16_t adds16_safe(int16_t a, int16_t b)
{
if (b > 0) {
if (a > INT16_MAX - b) {
return INT16_MAX;
} else {
return a + b;
}
} else {
if (a < INT16_MIN + b) {
return INT16_MIN;
} else {
return a + b;
}
}
}
int32_t adds32_safe(int32_t a, int32_t b)
{
if (b > 0) {
if (a > INT32_MAX - b) {
return INT32_MAX;
} else {
return a + b;
}
} else {
if (a < INT32_MIN + b) {
return INT32_MIN;
} else {
return a + b;
}
}
}
char* b2s(uint64_t binary, uint8_t rjust)
{
static char string[64 + 1] = {0}; // the string representation to return

43
global.h
View File

@ -24,11 +24,48 @@
/** integer underflow/overflow safe uint32_t addition (result to min/max on underflow/overflow) */
#define ADDU32_SAFE(a,b) {__typeof__ (a) _a = (a); __typeof__ (b) _b = (b); a = (_b > 0 ? ((_a > UINT32_MAX - _b) ? UINT32_MAX : (_a + _b)) : ((_a < _b) ? 0 : (_a - _b)));}
/** integer underflow/overflow safe int8_t addition (result to min/max on underflow/overflow) */
#define ADDS8_SAFE(a,b) {__typeof__ (a) _a = (a); __typeof__ (b) _b = (b); a = (_b > 0 ? ((_a > INT8_MAX - _b) ? INT8_MAX : (_a + _b)) : ((_a < INT8_MAX + _b) ? INT8_MAX : (_a - _b)));}
#define ADDS8_SAFE(a,b) {__typeof__ (a) _a = (a); __typeof__ (b) _b = (b); a = (_b > 0 ? ((_a > INT8_MAX - _b) ? INT8_MAX : (_a + _b)) : ((_a < INT8_MAX + _b) ? INT8_MAX : (_a + _b)));}
/** integer underflow/overflow safe int16_t addition (result to min/max on underflow/overflow) */
#define ADDS16_SAFE(a,b) {__typeof__ (a) _a = (a); __typeof__ (b) _b = (b); a = (_b > 0 ? ((_a > INT16_MAX - _b) ? INT16_MAX : (_a + _b)) : ((_a < INT16_MIN + _b) ? INT16_MIN : (_a - _b)));}
#define ADDS16_SAFE(a,b) {__typeof__ (a) _a = (a); __typeof__ (b) _b = (b); a = (_b > 0 ? ((_a > INT16_MAX - _b) ? INT16_MAX : (_a + _b)) : ((_a < INT16_MIN + _b) ? INT16_MIN : (_a + _b)));}
/** integer underflow/overflow safe int32_t addition (result to min/max on underflow/overflow) */
#define ADDS32_SAFE(a,b) {__typeof__ (a) _a = (a); __typeof__ (b) _b = (b); a = (_b > 0 ? ((_a > UINT32_MAX - _b) ? UINT32_MAX : (_a + _b)) : ((_a < INT32_MIN + _b) ? INT32_MIN : (_a - _b)));}
#define ADDS32_SAFE(a,b) {__typeof__ (a) _a = (a); __typeof__ (b) _b = (b); a = (_b > 0 ? ((_a > INT32_MAX - _b) ? INT32_MAX : (_a + _b)) : ((_a < INT32_MIN + _b) ? INT32_MIN : (_a + _b)));}
/** unsigned 8-bit integer overflow safe addition
* @param[in] a first part of addition
* @param[in] b second part of addition
* return result of addition, or type max on overflow
*/
uint8_t addu8_safe(uint8_t a, uint8_t b);
/** unsigned 16-bit integer overflow safe addition
* @param[in] a first part of addition
* @param[in] b second part of addition
* return result of addition, or type max on overflow
*/
uint16_t addu16_safe(uint16_t a, uint16_t b);
/** unsigned 8-bit integer overflow safe addition
* @param[in] a first part of addition
* @param[in] b second part of addition
* return result of addition, or type max on overflow
*/
uint32_t addu32_safe(uint32_t a, uint32_t b);
/** signed 8-bit integer underflow/overflow safe addition
* @param[in] a first part of addition
* @param[in] b second part of addition
* return result of addition, or type max on overflow
*/
int8_t adds8_safe(int8_t a, int8_t b);
/** signed 16-bit integer underflow/overflow safe addition
* @param[in] a first part of addition
* @param[in] b second part of addition
* return result of addition, or type max on overflow
*/
int16_t adds16_safe(int16_t a, int16_t b);
/** signed 32-bit integer underflow/overflow safe addition
* @param[in] a first part of addition
* @param[in] b second part of addition
* return result of addition, or type max on overflow
*/
int32_t adds32_safe(int32_t a, int32_t b);
/** build year as number */
#define COMPUTE_BUILD_YEAR \