lby/mr-library
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1.编码风格修改，重新格式化。

Browse Source
This commit is contained in:
MacRsh
2024-02-19 13:34:50 +08:00
parent b3722e4e23
commit dfee856535
27 changed files with 597 additions and 908 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
source/memory.c
View File

@@ -20,11 +20,7 @@ static uint8_t heap_mem[MR_CFG_HEAP_SIZE] = {0}; /**< Heap me
#define MR_HEAP_BLOCK_MIN_SIZE (sizeof(struct mr_heap_block) << 1)
static struct mr_heap_block heap_start = /**< Heap start block */
{
MR_NULL,
0,
MR_HEAP_BLOCK_FREE
};
{MR_NULL, 0, MR_HEAP_BLOCK_FREE};
/**
* @brief This function initialize the heap.
@@ -46,28 +42,25 @@ static void heap_insert_block(struct mr_heap_block *block)
struct mr_heap_block *block_prev = &heap_start;
/* Search for the previous block */
while (((block_prev->next != MR_NULL) && (block_prev->next < block)))
{
while (((block_prev->next != MR_NULL) && (block_prev->next < block))) {
block_prev = block_prev->next;
}
/* Insert the block */
if (block_prev->next != MR_NULL)
{
if (block_prev->next != MR_NULL) {
/* Merge with the previous block */
if ((void *)(((uint8_t *)block_prev) + sizeof(struct mr_heap_block) + block_prev->size) == (void *)block)
{
if ((void *)(((uint8_t *)block_prev) + sizeof(struct mr_heap_block) + block_prev->size) ==
(void *)block) {
block_prev->size += block->size + sizeof(struct mr_heap_block);
block = block_prev;
}
/* Merge with the next block */
if ((void *)(((uint8_t *)block) + sizeof(struct mr_heap_block) + block->size) == (void *)block_prev->next)
{
if ((void *)(((uint8_t *)block) + sizeof(struct mr_heap_block) + block->size) ==
(void *)block_prev->next) {
block->size += block_prev->next->size + sizeof(struct mr_heap_block);
block->next = block_prev->next->next;
if (block != block_prev)
{
if (block != block_prev) {
block_prev->next = block;
block = block_prev;
}
@@ -75,8 +68,7 @@ static void heap_insert_block(struct mr_heap_block *block)
}
/* Insert the block */
if (block != block_prev)
{
if (block != block_prev) {
block->next = block_prev->next;
block_prev->next = block;
}
@@ -97,8 +89,7 @@ MR_WEAK void *mr_malloc(size_t size)
mr_interrupt_disable();
/* Check size and residual memory */
if ((size == 0) || (size > (UINT32_MAX >> 1) || (block == MR_NULL)))
{
if ((size == 0) || (size > (UINT32_MAX >> 1) || (block == MR_NULL))) {
mr_interrupt_enable();
return MR_NULL;
}
@@ -107,10 +98,8 @@ MR_WEAK void *mr_malloc(size_t size)
size = MR_ALIGN_UP(size, 4);
/* Search for and take blocks that match the criteria */
while (block->size < size)
{
if (block->next == MR_NULL)
{
while (block->size < size) {
if (block->next == MR_NULL) {
mr_interrupt_enable();
return MR_NULL;
}
@@ -129,8 +118,7 @@ MR_WEAK void *mr_malloc(size_t size)
block->allocated = MR_HEAP_BLOCK_ALLOCATED;
/* Check if we need to allocate a new block */
if (residual > MR_HEAP_BLOCK_MIN_SIZE)
{
if (residual > MR_HEAP_BLOCK_MIN_SIZE) {
struct mr_heap_block *new_block = (struct mr_heap_block *)(((uint8_t *)memory) + size);
/* Set the new block information */
@@ -153,15 +141,14 @@ MR_WEAK void *mr_malloc(size_t size)
*/
MR_WEAK void mr_free(void *memory)
{
if (memory != MR_NULL)
{
struct mr_heap_block *block = (struct mr_heap_block *)((uint8_t *)memory - sizeof(struct mr_heap_block));
if (memory != MR_NULL) {
struct mr_heap_block *block = (struct mr_heap_block *)((uint8_t *)memory -
sizeof(struct mr_heap_block));
mr_interrupt_disable();
/* Check the block */
if (block->allocated == MR_HEAP_BLOCK_ALLOCATED && block->size != 0)
{
if (block->allocated == MR_HEAP_BLOCK_ALLOCATED && block->size != 0) {
block->allocated = MR_HEAP_BLOCK_FREE;
/* Insert the free block */
@@ -181,10 +168,10 @@ MR_WEAK void mr_free(void *memory)
*/
MR_WEAK size_t mr_malloc_usable_size(void *memory)
{
if (memory != MR_NULL)
{
if (memory != MR_NULL) {
/* Get the block information */
struct mr_heap_block *block = (struct mr_heap_block *)((uint8_t *)memory - sizeof(struct mr_heap_block));
struct mr_heap_block *block = (struct mr_heap_block *)((uint8_t *)memory -
sizeof(struct mr_heap_block));
return block->size;
}
return 0;
@@ -203,8 +190,7 @@ MR_WEAK void *mr_calloc(size_t num, size_t size)
size_t total = num * size;
void *memory = mr_malloc(total);
if (memory != MR_NULL)
{
if (memory != MR_NULL) {
memset(memory, 0, total);
}
return memory;
@@ -223,8 +209,7 @@ MR_WEAK void *mr_realloc(void *memory, size_t size)
size_t old_size = mr_malloc_usable_size(memory);
void *new_memory = mr_malloc(size);
if (new_memory != MR_NULL)
{
if (new_memory != MR_NULL) {
memcpy(new_memory, memory, old_size);
mr_free(memory);
}

233
source/service.c
View File

@@ -26,8 +26,7 @@ MR_INIT_EXPORT(end, "5.end");
void mr_auto_init(void)
{
/* Auto-initialization */
for (const mr_init_fn_t *fn = &_mr_auto_init_start; fn < &_mr_auto_init_end; fn++)
{
for (const mr_init_fn_t *fn = &_mr_auto_init_start; fn < &_mr_auto_init_end; fn++) {
(*fn)();
}
}
@@ -63,8 +62,7 @@ MR_WEAK void mr_delay_us(uint32_t us)
#else
#define MR_DELAY_COUNT (1)
#endif /* (MR_CFG_SYSCLK_FREQ > 1000000) */
for (volatile uint32_t i = 0; i < us * MR_DELAY_COUNT; i++)
{
for (volatile uint32_t i = 0; i < us * MR_DELAY_COUNT; i++) {
__asm__("nop");
}
#undef MR_DELAY_COUNT
@@ -78,8 +76,7 @@ MR_WEAK void mr_delay_us(uint32_t us)
*/
MR_WEAK void mr_delay_ms(uint32_t ms)
{
for (volatile uint32_t i = 0; i < ms; i++)
{
for (volatile uint32_t i = 0; i < ms; i++) {
mr_delay_us(1000);
}
}
@@ -97,8 +94,7 @@ MR_WEAK int mr_printf_output(const char *buf, size_t size)
static int desc = -1;
/* Try to open the serial port */
if (desc == -1)
{
if (desc == -1) {
#ifndef MR_CFG_PRINTF_DEV_NAME
#define MR_CFG_PRINTF_DEV_NAME "serial1"
#endif /* MR_CFG_PRINTF_DEV_NAME */
@@ -107,8 +103,7 @@ MR_WEAK int mr_printf_output(const char *buf, size_t size)
#else
int ret = mr_dev_open(MR_CFG_PRINTF_DEV_NAME, MR_O_RDWR | MR_O_NONBLOCK);
#endif /* MR_USING_PRINTF_NONBLOCKING */
if (ret < 0)
{
if (ret < 0) {
return ret;
}
desc = ret;
@@ -152,8 +147,7 @@ int mr_printf(const char *fmt, ...)
*/
const char *mr_strerror(int err)
{
switch (err)
{
switch (err) {
case MR_EOK:
return "ok";
case MR_ENOMEM:
@@ -191,16 +185,13 @@ const char *mr_strflags(int flags)
static char str[6] = {0};
strcpy(str, "-----");
if (MR_BIT_IS_SET(flags, MR_O_RDONLY))
{
if (MR_BIT_IS_SET(flags, MR_O_RDONLY)) {
str[1] = 'r';
}
if (MR_BIT_IS_SET(flags, MR_O_WRONLY))
{
if (MR_BIT_IS_SET(flags, MR_O_WRONLY)) {
str[2] = 'w';
}
if (MR_BIT_IS_SET(flags, MR_O_NONBLOCK))
{
if (MR_BIT_IS_SET(flags, MR_O_NONBLOCK)) {
str[3] = 'n';
}
return str;
@@ -238,25 +229,21 @@ int mr_ringbuf_allocate(struct mr_ringbuf *ringbuf, size_t size)
{
MR_ASSERT(ringbuf != MR_NULL);
if (size == mr_ringbuf_get_bufsz(ringbuf))
{
if (size == mr_ringbuf_get_bufsz(ringbuf)) {
mr_ringbuf_reset(ringbuf);
return MR_EOK;
}
/* Free old buffer */
if (ringbuf->size != 0)
{
mr_free(ringbuf->buffer);
mr_ringbuf_init(ringbuf, MR_NULL, 0);
}
/* Allocate new buffer */
void *pool = mr_malloc(size);
if (pool == MR_NULL && size != 0)
{
if ((pool == MR_NULL) && (size != 0)) {
return MR_ENOMEM;
}
/* Free old buffer */
if (ringbuf->size != 0) {
mr_free(ringbuf->buffer);
}
mr_ringbuf_init(ringbuf, pool, size);
return MR_EOK;
}
@@ -301,22 +288,17 @@ size_t mr_ringbuf_get_data_size(struct mr_ringbuf *ringbuf)
MR_ASSERT(ringbuf != MR_NULL);
/* Empty or full according to the mirror flag */
if (ringbuf->read_index == ringbuf->write_index)
{
if (ringbuf->read_mirror == ringbuf->write_mirror)
{
if (ringbuf->read_index == ringbuf->write_index) {
if (ringbuf->read_mirror == ringbuf->write_mirror) {
return 0;
} else
{
} else {
return ringbuf->size;
}
}
if (ringbuf->write_index > ringbuf->read_index)
{
if (ringbuf->write_index > ringbuf->read_index) {
return ringbuf->write_index - ringbuf->read_index;
} else
{
} else {
return ringbuf->size - ringbuf->read_index + ringbuf->write_index;
}
}
@@ -363,19 +345,16 @@ size_t mr_ringbuf_pop(struct mr_ringbuf *ringbuf, uint8_t *data)
MR_ASSERT(data != MR_NULL);
/* Get the buf size */
if (mr_ringbuf_get_data_size(ringbuf) == 0)
{
if (mr_ringbuf_get_data_size(ringbuf) == 0) {
return 0;
}
*data = ringbuf->buffer[ringbuf->read_index];
if (ringbuf->read_index == ringbuf->size - 1)
{
if (ringbuf->read_index == ringbuf->size - 1) {
ringbuf->read_mirror = ~ringbuf->read_mirror;
ringbuf->read_index = 0;
} else
{
} else {
ringbuf->read_index++;
}
return 1;
@@ -399,20 +378,17 @@ size_t mr_ringbuf_read(struct mr_ringbuf *ringbuf, void *buffer, size_t size)
/* Get the buf size */
size_t data_size = mr_ringbuf_get_data_size(ringbuf);
if (data_size == 0)
{
if (data_size == 0) {
return 0;
}
/* Adjust the number of bytes to read if it exceeds the available buf */
if (size > data_size)
{
if (size > data_size) {
size = data_size;
}
/* Copy the buf from the ringbuf to the buffer */
if ((ringbuf->size - ringbuf->read_index) > size)
{
if ((ringbuf->size - ringbuf->read_index) > size) {
memcpy(read_buffer, &ringbuf->buffer[ringbuf->read_index], size);
ringbuf->read_index += size;
return size;
@@ -441,19 +417,16 @@ size_t mr_ringbuf_push(struct mr_ringbuf *ringbuf, uint8_t data)
MR_ASSERT(ringbuf != MR_NULL);
/* Get the space size */
if (mr_ringbuf_get_space_size(ringbuf) == 0)
{
if (mr_ringbuf_get_space_size(ringbuf) == 0) {
return 0;
}
ringbuf->buffer[ringbuf->write_index] = data;
if (ringbuf->write_index == ringbuf->size - 1)
{
if (ringbuf->write_index == ringbuf->size - 1) {
ringbuf->write_mirror = ~ringbuf->write_mirror;
ringbuf->write_index = 0;
} else
{
} else {
ringbuf->write_index++;
}
return 1;
@@ -474,33 +447,27 @@ size_t mr_ringbuf_push_force(struct mr_ringbuf *ringbuf, uint8_t data)
MR_ASSERT(ringbuf != MR_NULL);
/* Get the buffer size */
if (mr_ringbuf_get_bufsz(ringbuf) == 0)
{
if (mr_ringbuf_get_bufsz(ringbuf) == 0) {
return 0;
}
/* Get the space size */
if (mr_ringbuf_get_space_size(ringbuf) == 0)
{
if (mr_ringbuf_get_space_size(ringbuf) == 0) {
state = 1;
}
ringbuf->buffer[ringbuf->write_index] = data;
if (ringbuf->write_index == ringbuf->size - 1)
{
if (ringbuf->write_index == ringbuf->size - 1) {
ringbuf->write_mirror = ~ringbuf->write_mirror;
ringbuf->write_index = 0;
if (state == 1)
{
if (state == 1) {
ringbuf->read_mirror = ~ringbuf->read_mirror;
ringbuf->read_index = ringbuf->write_index;
}
} else
{
} else {
ringbuf->write_index++;
if (state == 1)
{
if (state == 1) {
ringbuf->read_index = ringbuf->write_index;
}
}
@@ -525,27 +492,26 @@ size_t mr_ringbuf_write(struct mr_ringbuf *ringbuf, const void *buffer, size_t s
/* Get the space size */
size_t space_size = mr_ringbuf_get_space_size(ringbuf);
if (space_size == 0)
{
if (space_size == 0) {
return 0;
}
/* Adjust the number of bytes to write if it exceeds the available buf */
if (size > space_size)
{
if (size > space_size) {
size = space_size;
}
/* Copy the buf from the buffer to the ringbuf */
if ((ringbuf->size - ringbuf->write_index) > size)
{
if ((ringbuf->size - ringbuf->write_index) > size) {
memcpy(&ringbuf->buffer[ringbuf->write_index], write_buffer, size);
ringbuf->write_index += size;
return size;
}
memcpy(&ringbuf->buffer[ringbuf->write_index], write_buffer, ringbuf->size - ringbuf->write_index);
memcpy(&ringbuf->buffer[ringbuf->write_index],
write_buffer,
ringbuf->size - ringbuf->write_index);
memcpy(&ringbuf->buffer[0],
&write_buffer[ringbuf->size - ringbuf->write_index],
size - (ringbuf->size - ringbuf->write_index));
@@ -571,8 +537,7 @@ size_t mr_ringbuf_write_force(struct mr_ringbuf *ringbuf, const void *buffer, si
MR_ASSERT(ringbuf != MR_NULL);
MR_ASSERT((buffer != MR_NULL) || (size == 0));
if ((mr_ringbuf_get_bufsz(ringbuf) == 0) || (size == 0))
{
if ((mr_ringbuf_get_bufsz(ringbuf) == 0) || (size == 0)) {
return 0;
}
@@ -580,25 +545,24 @@ size_t mr_ringbuf_write_force(struct mr_ringbuf *ringbuf, const void *buffer, si
size_t space_size = mr_ringbuf_get_space_size(ringbuf);
/* If the buf exceeds the buffer space_size, the front buf is discarded */
if (size > ringbuf->size)
{
if (size > ringbuf->size) {
write_buffer = &write_buffer[size - ringbuf->size];
size = ringbuf->size;
}
/* Copy the buf from the buffer to the ringbuf */
if ((ringbuf->size - ringbuf->write_index) > size)
{
if ((ringbuf->size - ringbuf->write_index) > size) {
memcpy(&ringbuf->buffer[ringbuf->write_index], write_buffer, size);
ringbuf->write_index += size;
if (size > space_size)
{
if (size > space_size) {
ringbuf->read_index = ringbuf->write_index;
}
return size;
}
memcpy(&ringbuf->buffer[ringbuf->write_index], write_buffer, ringbuf->size - ringbuf->write_index);
memcpy(&ringbuf->buffer[ringbuf->write_index],
write_buffer,
ringbuf->size - ringbuf->write_index);
memcpy(&ringbuf->buffer[0],
&write_buffer[ringbuf->size - ringbuf->write_index],
size - (ringbuf->size - ringbuf->write_index));
@@ -606,10 +570,8 @@ size_t mr_ringbuf_write_force(struct mr_ringbuf *ringbuf, const void *buffer, si
ringbuf->write_mirror = ~ringbuf->write_mirror;
ringbuf->write_index = size - (ringbuf->size - ringbuf->write_index);
if (size > space_size)
{
if (ringbuf->write_index <= ringbuf->read_index)
{
if (size > space_size) {
if (ringbuf->write_index <= ringbuf->read_index) {
ringbuf->read_mirror = ~ringbuf->read_mirror;
}
@@ -620,8 +582,7 @@ size_t mr_ringbuf_write_force(struct mr_ringbuf *ringbuf, const void *buffer, si
static int mr_avl_get_height(struct mr_avl *node)
{
if (node == MR_NULL)
{
if (node == MR_NULL) {
return -1;
}
return node->height;
@@ -629,8 +590,7 @@ static int mr_avl_get_height(struct mr_avl *node)
static int mr_avl_get_balance(struct mr_avl *node)
{
if (node == MR_NULL)
{
if (node == MR_NULL) {
return 0;
}
return (mr_avl_get_height(node->left_child) - mr_avl_get_height(node->right_child));
@@ -643,7 +603,8 @@ static void mr_avl_left_rotate(struct mr_avl **node)
(*node)->right_child = right_child->left_child;
right_child->left_child = (*node);
(*node)->height = MR_MAX(mr_avl_get_height((*node)->left_child), mr_avl_get_height((*node)->right_child)) + 1;
(*node)->height = MR_MAX(mr_avl_get_height((*node)->left_child),
mr_avl_get_height((*node)->right_child)) + 1;
right_child->height = MR_MAX(mr_avl_get_height(right_child->left_child),
mr_avl_get_height(right_child->right_child)) + 1;
(*node) = right_child;
@@ -656,7 +617,8 @@ static void mr_avl_right_rotate(struct mr_avl **node)
(*node)->left_child = left_child->right_child;
left_child->right_child = (*node);
(*node)->height = MR_MAX(mr_avl_get_height((*node)->left_child), mr_avl_get_height((*node)->right_child)) + 1;
(*node)->height = MR_MAX(mr_avl_get_height((*node)->left_child),
mr_avl_get_height((*node)->right_child)) + 1;
left_child->height = MR_MAX(mr_avl_get_height(left_child->left_child),
mr_avl_get_height(left_child->right_child)) + 1;
(*node) = left_child;
@@ -689,46 +651,39 @@ void mr_avl_insert(struct mr_avl **tree, struct mr_avl *node)
MR_ASSERT(tree != MR_NULL);
MR_ASSERT(node != MR_NULL);
if ((*tree) == MR_NULL)
{
if ((*tree) == MR_NULL) {
(*tree) = node;
}
if (node->value < (*tree)->value)
{
if (node->value < (*tree)->value) {
mr_avl_insert(&(*tree)->left_child, node);
} else if (node->value > (*tree)->value)
{
} else if (node->value > (*tree)->value) {
mr_avl_insert(&(*tree)->right_child, node);
} else
{
} else {
return;
}
(*tree)->height = MR_MAX(mr_avl_get_height((*tree)->left_child), mr_avl_get_height((*tree)->right_child)) + 1;
(*tree)->height = MR_MAX(mr_avl_get_height((*tree)->left_child),
mr_avl_get_height((*tree)->right_child)) + 1;
int balance = mr_avl_get_balance((*tree));
if (balance > 1 && node->value < (*tree)->left_child->value)
{
if (balance > 1 && node->value < (*tree)->left_child->value) {
mr_avl_right_rotate(&(*tree));
return;
}
if (balance < -1 && node->value > (*tree)->right_child->value)
{
if (balance < -1 && node->value > (*tree)->right_child->value) {
mr_avl_left_rotate(&(*tree));
return;
}
if (balance > 1 && node->value > (*tree)->left_child->value)
{
if (balance > 1 && node->value > (*tree)->left_child->value) {
mr_avl_left_rotate(&(*tree)->left_child);
mr_avl_right_rotate(&(*tree));
return;
}
if (balance < -1 && node->value < (*tree)->right_child->value)
{
if (balance < -1 && node->value < (*tree)->right_child->value) {
mr_avl_right_rotate(&(*tree)->right_child);
mr_avl_left_rotate(&(*tree));
return;
@@ -746,27 +701,21 @@ void mr_avl_remove(struct mr_avl **tree, struct mr_avl *node)
MR_ASSERT(tree != MR_NULL);
MR_ASSERT(node != MR_NULL);
if (*tree == MR_NULL)
{
if (*tree == MR_NULL) {
return;
}
if (node->value < (*tree)->value)
{
if (node->value < (*tree)->value) {
mr_avl_remove(&(*tree)->left_child, node);
} else if (node->value > (*tree)->value)
{
} else if (node->value > (*tree)->value) {
mr_avl_remove(&(*tree)->right_child, node);
} else
{
if ((*tree)->left_child == MR_NULL)
{
} else {
if ((*tree)->left_child == MR_NULL) {
struct mr_avl *temp = (*tree)->right_child;
(*tree)->right_child = MR_NULL;
(*tree) = temp;
return;
} else if ((*tree)->right_child == MR_NULL)
{
} else if ((*tree)->right_child == MR_NULL) {
struct mr_avl *temp = (*tree)->left_child;
(*tree)->left_child = MR_NULL;
(*tree) = temp;
@@ -779,28 +728,25 @@ void mr_avl_remove(struct mr_avl **tree, struct mr_avl *node)
return;
}
(*tree)->height = MR_MAX(mr_avl_get_height((*tree)->left_child), mr_avl_get_height((*tree)->right_child)) + 1;
(*tree)->height = MR_MAX(mr_avl_get_height((*tree)->left_child),
mr_avl_get_height((*tree)->right_child)) + 1;
int balance = mr_avl_get_balance(*tree);
if (balance > 1 && mr_avl_get_balance((*tree)->left_child) >= 0)
{
if (balance > 1 && mr_avl_get_balance((*tree)->left_child) >= 0) {
mr_avl_right_rotate(tree);
}
if (balance > 1 && mr_avl_get_balance((*tree)->left_child) < 0)
{
if (balance > 1 && mr_avl_get_balance((*tree)->left_child) < 0) {
mr_avl_left_rotate(&(*tree)->left_child);
mr_avl_right_rotate(tree);
}
if (balance < -1 && mr_avl_get_balance((*tree)->right_child) <= 0)
{
if (balance < -1 && mr_avl_get_balance((*tree)->right_child) <= 0) {
mr_avl_left_rotate(tree);
}
if (balance < -1 && mr_avl_get_balance((*tree)->right_child) > 0)
{
if (balance < -1 && mr_avl_get_balance((*tree)->right_child) > 0) {
mr_avl_right_rotate(&(*tree)->right_child);
mr_avl_left_rotate(tree);
}
@@ -816,21 +762,17 @@ void mr_avl_remove(struct mr_avl **tree, struct mr_avl *node)
*/
struct mr_avl *mr_avl_find(struct mr_avl *tree, uint32_t value)
{
if (tree == MR_NULL)
{
if (tree == MR_NULL) {
return tree;
}
if (tree->value == value)
{
if (tree->value == value) {
return tree;
}
if (value < tree->value)
{
if (value < tree->value) {
return mr_avl_find(tree->left_child, value);
} else if (value > tree->value)
{
} else if (value > tree->value) {
return mr_avl_find(tree->right_child, value);
}
return MR_NULL;
@@ -847,18 +789,15 @@ size_t mr_avl_get_length(struct mr_avl *tree)
{
size_t length = 1;
if (tree == MR_NULL)
{
if (tree == MR_NULL) {
return 0;
}
if (tree->left_child != MR_NULL)
{
if (tree->left_child != MR_NULL) {
length += mr_avl_get_length(tree->left_child);
}
if (tree->right_child != MR_NULL)
{
if (tree->right_child != MR_NULL) {
length += mr_avl_get_length(tree->right_child);
}
return length;