diff options
77 files changed, 4034 insertions, 3035 deletions
diff --git a/.clang-format b/.clang-format index 559e7fa787..95320a7bbb 100644 --- a/.clang-format +++ b/.clang-format @@ -51,7 +51,7 @@ AllowShortEnumsOnASingleLine: false AllowShortFunctionsOnASingleLine: None AllowShortIfStatementsOnASingleLine: false AllowShortLambdasOnASingleLine: None -AllowShortLoopsOnASingleLine: false +AllowShortLoopsOnASingleLine: true AlwaysBreakAfterDefinitionReturnType: None AlwaysBreakAfterReturnType: None AlwaysBreakBeforeMultilineStrings: false @@ -76,7 +76,7 @@ BraceWrapping: BeforeCatch: true BeforeElse: true BeforeLambdaBody: true - BeforeWhile: true + BeforeWhile: false IndentBraces: false SplitEmptyFunction: true SplitEmptyRecord: true diff --git a/.github/workflows/format_check.yml b/.github/workflows/format_check.yml index 9d7983b159..dd15a3edec 100644 --- a/.github/workflows/format_check.yml +++ b/.github/workflows/format_check.yml @@ -30,7 +30,7 @@ jobs: - name: Install clang-format shell: bash run: | - python -m pip install clang-format + python -m pip install -r tools/ci/requirements-format.txt clang-format --version - name: Check clang-format diff --git a/.github/workflows/pr_clang_format.yml b/.github/workflows/pr_clang_format.yml index b94ee51103..ad697e3a10 100644 --- a/.github/workflows/pr_clang_format.yml +++ b/.github/workflows/pr_clang_format.yml @@ -39,8 +39,13 @@ jobs: token: ${{ secrets.GITHUB_TOKEN }} lfs: false + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.8' + - name: Install clang-format - run: sudo apt-get update && sudo apt-get install -y clang-format + run: python -m pip install -r tools/ci/requirements-format.txt - name: Check clang-format version run: | diff --git a/components/libc/posix/libdl/dlelf.c b/components/libc/posix/libdl/dlelf.c index 6490b32633..be4e9c776c 100644 --- a/components/libc/posix/libdl/dlelf.c +++ b/components/libc/posix/libdl/dlelf.c @@ -301,6 +301,48 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt } /** + * @brief Compute the size of the common block of a symbol table, and + * optionally the offset of one specific SHN_COMMON symbol inside it. + * + * SHN_COMMON symbols are tentative definitions of uninitialized global + * variables. The loader must allocate storage for them just like a static + * linker does: every common symbol is aligned to its st_value alignment + * requirement and occupies st_size bytes, packed one after another. + * + * @param symtab pointer to the symbol table + * @param nsym number of symbols in the table + * @param target symbol whose offset is wanted, or RT_NULL to get the total + * size of the common block + * @return offset of target in the common block, or the total size of the + * block when target is RT_NULL + */ +static rt_ubase_t dlmodule_common_block(Elf_Sym *symtab, rt_ubase_t nsym, + Elf_Sym *target) +{ + rt_ubase_t i, offset = 0; + + for (i = 0; i < nsym; i++) + { + if (symtab[i].st_shndx != SHN_COMMON) + { + continue; + } + + /* st_value of a SHN_COMMON symbol holds its alignment requirement */ + offset = RT_ALIGN(offset, symtab[i].st_value > 1 ? symtab[i].st_value : 1); + + if (target == &symtab[i]) + { + return offset; + } + + offset += symtab[i].st_size; + } + + return offset; +} + +/** * @brief Load a relocatable file into memory. * * @param module A pointer to a rt_dlmodule object for holding the module's information. @@ -319,8 +361,9 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt */ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module_ptr) { - rt_ubase_t index, rodata_addr = 0, bss_addr = 0, data_addr = 0; - rt_ubase_t module_addr = 0, module_size = 0; + rt_ubase_t index, common_addr = 0; + rt_ubase_t module_addr = 0, module_size = 0, common_align = 1; + rt_ubase_t *section_load_addr = RT_NULL; rt_uint8_t *ptr, *strtab, *shstrab; /* get the ELF image size */ @@ -349,6 +392,38 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module } } + /* account for common symbols (uninitialized global variables) */ + for (index = 0; index < elf_module->e_shnum; index++) + { + Elf_Sym *symtab; + rt_ubase_t i, nsym; + + if (shdr[index].sh_type != SHT_SYMTAB) + { + continue; + } + + symtab = (Elf_Sym *)((rt_uint8_t *)elf_module + shdr[index].sh_offset); + nsym = (rt_ubase_t)(shdr[index].sh_size / sizeof(Elf_Sym)); + for (i = 0; i < nsym; i++) + { + if ((symtab[i].st_shndx == SHN_COMMON) && + (symtab[i].st_value > common_align)) + { + common_align = symtab[i].st_value; + } + } + module_size += RT_ALIGN(dlmodule_common_block(symtab, nsym, RT_NULL), + sizeof(rt_ubase_t)); + } + + /* The actual base is known only after allocation. Reserve the worst-case + * padding needed to align the common block after all sections are loaded. */ + if (common_align > 1) + { + module_size += common_align - 1; + } + /* no text, data and bss on image */ if (module_size == 0) return RT_NULL; @@ -363,6 +438,14 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module } module->mem_size = module_size; + section_load_addr = rt_calloc(elf_module->e_shnum, + sizeof(*section_load_addr)); + if (section_load_addr == RT_NULL) + { + LOG_E("Module: allocate section address table failed.\n"); + return -RT_ENOMEM; + } + /* zero all space */ ptr = module->mem_space; rt_memset(ptr, 0, module_size); @@ -373,6 +456,7 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module /* load text section */ if (IS_PROG(shdr[index]) && IS_AX(shdr[index])) { + section_load_addr[index] = (rt_ubase_t)ptr; rt_memcpy(ptr, (rt_uint8_t *)elf_module + shdr[index].sh_offset, shdr[index].sh_size); @@ -383,36 +467,39 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module /* load rodata section */ if (IS_PROG(shdr[index]) && IS_ALLOC(shdr[index])) { + section_load_addr[index] = (rt_ubase_t)ptr; rt_memcpy(ptr, (rt_uint8_t *)elf_module + shdr[index].sh_offset, shdr[index].sh_size); - rodata_addr = (rt_ubase_t)ptr; - LOG_D("load rodata 0x%x, size %d, rodata 0x%x", ptr, - shdr[index].sh_size, *(rt_ubase_t *)rodata_addr); + LOG_D("load rodata 0x%x, size %d", ptr, shdr[index].sh_size); ptr += shdr[index].sh_size; } /* load data section */ if (IS_PROG(shdr[index]) && IS_AW(shdr[index])) { + section_load_addr[index] = (rt_ubase_t)ptr; rt_memcpy(ptr, (rt_uint8_t *)elf_module + shdr[index].sh_offset, shdr[index].sh_size); - data_addr = (rt_ubase_t)ptr; - LOG_D("load data 0x%x, size %d, data 0x%x", ptr, - shdr[index].sh_size, *(rt_ubase_t *)data_addr); + LOG_D("load data 0x%x, size %d", ptr, shdr[index].sh_size); ptr += shdr[index].sh_size; } /* load bss section */ if (IS_NOPROG(shdr[index]) && IS_AW(shdr[index])) { + section_load_addr[index] = (rt_ubase_t)ptr; rt_memset(ptr, 0, shdr[index].sh_size); - bss_addr = (rt_ubase_t)ptr; LOG_D("load bss 0x%x, size %d", ptr, shdr[index].sh_size); + ptr += shdr[index].sh_size; } } + /* the common block (uninitialized global variables) starts right after + * the loaded sections; it was zeroed together with the module space */ + common_addr = RT_ALIGN((rt_ubase_t)ptr, common_align); + /* set module entry */ module->entry_addr = (rt_dlmodule_entry_func_t)((rt_uint8_t *)module->mem_space + elf_module->e_entry - module_addr); @@ -431,6 +518,12 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module continue; #endif + /* Only relocate sections that were loaded into module memory. */ + if ((shdr[index].sh_info >= elf_module->e_shnum) || + (section_load_addr[shdr[index].sh_info] == 0)) + { + continue; + } /* get relocate item */ rel = (Elf_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset); @@ -452,6 +545,12 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module #elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64)) Elf_Sym *sym = &symtab[ELF64_R_SYM(rel->r_info)]; #endif + Elf_Rel target_rel = *rel; + + /* r_offset is relative to the section being relocated. Convert it + * to the module-relative offset expected by the arch relocator. */ + target_rel.r_offset += section_load_addr[shdr[index].sh_info] - + (rt_ubase_t)module->mem_space; LOG_D("relocate symbol: %s", strtab + sym->st_name); @@ -459,49 +558,39 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module { Elf_Addr addr = 0; - if ((ELF_ST_TYPE(sym->st_info) == STT_SECTION) || - (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)) + if (sym->st_shndx == SHN_COMMON) { - if (rt_strncmp((const char *)(shstrab + - shdr[sym->st_shndx].sh_name), ELF_RODATA, 8) == 0) - { - /* relocate rodata section */ - LOG_D("rodata"); - addr = (Elf_Addr)(rodata_addr + sym->st_value); - } - else if (rt_strncmp((const char *) - (shstrab + shdr[sym->st_shndx].sh_name), ELF_BSS, 5) == 0) - { - /* relocate bss section */ - LOG_D("bss"); - addr = (Elf_Addr)bss_addr + sym->st_value; - } - else if (rt_strncmp((const char *)(shstrab + shdr[sym->st_shndx].sh_name), - ELF_DATA, 6) == 0) - { - /* relocate data section */ - LOG_D("data"); - addr = (Elf_Addr)data_addr + sym->st_value; - } - - if (addr != 0) dlmodule_relocate(module, rel, addr); + /* SHN_COMMON is not a real section index. */ + LOG_D("common symbol"); + addr = (Elf_Addr)(common_addr + dlmodule_common_block( + symtab, + (rt_ubase_t)(shdr[shdr[index].sh_link].sh_size / sizeof(Elf_Sym)), + sym)); } - else if (ELF_ST_TYPE(sym->st_info) == STT_FUNC) + else if (((ELF_ST_TYPE(sym->st_info) == STT_SECTION) || + (ELF_ST_TYPE(sym->st_info) == STT_OBJECT) || + (ELF_ST_TYPE(sym->st_info) == STT_FUNC)) && + (sym->st_shndx < elf_module->e_shnum) && + (section_load_addr[sym->st_shndx] != 0)) { - addr = (Elf_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value); + /* For ET_REL, st_value is already the offset within the + * symbol's section; sh_addr must not be subtracted. */ + addr = (Elf_Addr)(section_load_addr[sym->st_shndx] + + sym->st_value); + } - /* relocate function */ - dlmodule_relocate(module, rel, addr); + if (addr != 0) + { + dlmodule_relocate(module, &target_rel, addr); } } else if (ELF_ST_TYPE(sym->st_info) == STT_FUNC) { /* relocate function */ - dlmodule_relocate(module, rel, - (Elf_Addr)((rt_uint8_t *) - module->mem_space - - module_addr - + sym->st_value)); + dlmodule_relocate(module, &target_rel, + (Elf_Addr)((rt_uint8_t *) + module->mem_space - + module_addr + sym->st_value)); } else { @@ -515,7 +604,7 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module addr = dlmodule_symbol_find((const char *)(strtab + sym->st_name)); if (addr != (Elf_Addr)RT_NULL) { - dlmodule_relocate(module, rel, addr); + dlmodule_relocate(module, &target_rel, addr); LOG_D("symbol addr 0x%x", addr); } else @@ -525,7 +614,7 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module else { addr = (Elf_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value); - dlmodule_relocate(module, rel, addr); + dlmodule_relocate(module, &target_rel, addr); } } @@ -533,5 +622,84 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module } } + /* construct the module symbol table from .symtab so that lookups such as + * dlsym() can resolve the module's global functions */ + shstrab = (rt_uint8_t *)module_ptr + shdr[elf_module->e_shstrndx].sh_offset; + for (index = 0; index < elf_module->e_shnum; index++) + { + if ((shdr[index].sh_type == SHT_SYMTAB) && + (rt_strcmp((const char *)(shstrab + shdr[index].sh_name), ELF_SYMTAB) == 0)) + { + break; + } + } + + if (index != elf_module->e_shnum) + { + Elf_Sym *symtab; + rt_ubase_t i, count = 0; + + symtab = (Elf_Sym *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset); + strtab = (rt_uint8_t *)module_ptr + shdr[shdr[index].sh_link].sh_offset; + + for (i = 0; i < shdr[index].sh_size / sizeof(Elf_Sym); i++) + { + if ((ELF_ST_BIND(symtab[i].st_info) == STB_GLOBAL) && + (ELF_ST_TYPE(symtab[i].st_info) == STT_FUNC) && + (symtab[i].st_shndx != SHN_UNDEF) && + (symtab[i].st_shndx < elf_module->e_shnum) && + (section_load_addr[symtab[i].st_shndx] != 0)) + { + count++; + } + } + + module->nsym = 0; + if (count > 0) + { + module->symtab = (struct rt_module_symtab *)rt_malloc( + count * sizeof(struct rt_module_symtab)); + if (module->symtab == RT_NULL) + { + LOG_E("Module: allocate symbol table failed.\n"); + rt_free(section_load_addr); + return -RT_ENOMEM; + } + + for (i = 0; i < shdr[index].sh_size / sizeof(Elf_Sym); i++) + { + rt_size_t length; + + if ((ELF_ST_BIND(symtab[i].st_info) != STB_GLOBAL) || + (ELF_ST_TYPE(symtab[i].st_info) != STT_FUNC) || + (symtab[i].st_shndx == SHN_UNDEF) || + (symtab[i].st_shndx >= elf_module->e_shnum) || + (section_load_addr[symtab[i].st_shndx] == 0)) + { + continue; + } + + length = rt_strlen((const char *)(strtab + symtab[i].st_name)) + 1; + + module->symtab[module->nsym].addr = + (void *)(section_load_addr[symtab[i].st_shndx] + + symtab[i].st_value); + module->symtab[module->nsym].name = rt_malloc(length); + if (module->symtab[module->nsym].name == RT_NULL) + { + LOG_E("Module: allocate symbol name failed.\n"); + rt_free(section_load_addr); + return -RT_ENOMEM; + } + rt_memset((void *)module->symtab[module->nsym].name, 0, length); + rt_memcpy((void *)module->symtab[module->nsym].name, + strtab + symtab[i].st_name, + length); + module->nsym++; + } + } + } + + rt_free(section_load_addr); return RT_EOK; } diff --git a/components/libc/posix/libdl/dlelf.h b/components/libc/posix/libdl/dlelf.h index 6b03271034..e5acaf7f57 100644 --- a/components/libc/posix/libdl/dlelf.h +++ b/components/libc/posix/libdl/dlelf.h @@ -202,6 +202,8 @@ typedef struct #define STT_HIPROC 15 #define STN_UNDEF 0 /* undefined */ +#define SHN_UNDEF 0x0000 /* undefined section */ +#define SHN_COMMON 0xfff2 /* common symbols (uninitialized globals) */ #define ELF_ST_BIND(info) ((info) >> 4) #define ELF_ST_TYPE(info) ((info) & 0xf) diff --git a/documentation/7.contribution/coding_style_cn.md b/documentation/7.contribution/coding_style_cn.md index 0b975a2e65..5cd59bfe35 100644 --- a/documentation/7.contribution/coding_style_cn.md +++ b/documentation/7.contribution/coding_style_cn.md @@ -291,6 +291,15 @@ rt_timer + 动词短语的形式表示能够应用于 timer 对象的方法。 RT-Thread 现在使用 clang-format 作为统一的代码格式化工具。提交 C/C++、头文件及相关源文件前，请优先使用仓库根目录的 `.clang-format` 配置进行格式化，不要再使用与该配置不一致的手工排版或旧的 astyle 参数。 +统一使用 clang-format **22.1.8**，版本固定在 `tools/ci/requirements-format.txt`。本地开发、格式检查 CI 和手动格式化工作流使用同一版本，避免不同版本产生格式差异。在仓库根目录安装并确认版本： + +```shell +python -m pip install -r tools/ci/requirements-format.txt +clang-format --version +``` + +编辑器也应使用上述安装的 clang-format 可执行文件。 + 常用命令如下： ```shell diff --git a/documentation/7.contribution/coding_style_en.md b/documentation/7.contribution/coding_style_en.md index c1953ed0aa..5934604579 100644 --- a/documentation/7.contribution/coding_style_en.md +++ b/documentation/7.contribution/coding_style_en.md @@ -218,6 +218,16 @@ submitting C/C++ source files, header files, and related source files, format them with the `.clang-format` configuration in the repository root. Do not use manual formatting or old astyle parameters that conflict with this configuration. +Use clang-format **22.1.8**, pinned in `tools/ci/requirements-format.txt`. +Local development, format checks, and the manual formatting workflow use the +same version to avoid formatting differences. Install it from the repository +root and verify the version: + + python -m pip install -r tools/ci/requirements-format.txt + clang-format --version + +Configure your editor to use the same installed clang-format executable. + Common commands: clang-format -style=file -i path/to/file.c diff --git a/src/clock.c b/src/clock.c index 7fd84441cd..b176692cc3 100644 --- a/src/clock.c +++ b/src/clock.c @@ -84,7 +84,9 @@ rt_tick_t rt_tick_get_delta(rt_tick_t base) { rt_tick_t tnow = rt_tick_get(); if (tnow >= base) + { return tnow - base; + } return RT_TICK_MAX - base + tnow + 1; } RTM_EXPORT(rt_tick_get_delta); diff --git a/src/components.c b/src/components.c index 167b2d4590..978afd0bcb 100644 --- a/src/components.c +++ b/src/components.c @@ -23,10 +23,10 @@ #ifdef RT_USING_USER_MAIN #ifndef RT_MAIN_THREAD_STACK_SIZE -#define RT_MAIN_THREAD_STACK_SIZE 2048 +#define RT_MAIN_THREAD_STACK_SIZE 2048 #endif /* RT_MAIN_THREAD_STACK_SIZE */ #ifndef RT_MAIN_THREAD_PRIORITY -#define RT_MAIN_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 3) +#define RT_MAIN_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX / 3) #endif /* RT_MAIN_THREAD_PRIORITY */ #if (RT_MAIN_THREAD_PRIORITY >= RT_THREAD_PRIORITY_MAX) #error "RT_MAIN_THREAD_PRIORITY must be < RT_THREAD_PRIORITY_MAX" @@ -93,7 +93,7 @@ void rt_components_board_init(void) #ifdef RT_DEBUGING_AUTO_INIT int result; const struct rt_init_desc *desc; - for (desc = &__rt_init_desc_rti_board_start; desc < &__rt_init_desc_rti_board_end; desc ++) + for (desc = &__rt_init_desc_rti_board_start; desc < &__rt_init_desc_rti_board_end; desc++) { rt_kprintf("initialize %s\n", desc->fn_name); result = desc->fn(); @@ -119,7 +119,7 @@ void rt_components_init(void) const struct rt_init_desc *desc; rt_kprintf("do components initialization.\n"); - for (desc = &__rt_init_desc_rti_board_end; desc < &__rt_init_desc_rti_end; desc ++) + for (desc = &__rt_init_desc_rti_board_end; desc < &__rt_init_desc_rti_end; desc++) { rt_kprintf("initialize %s\n", desc->fn_name); result = desc->fn(); @@ -128,7 +128,7 @@ void rt_components_init(void) #else volatile const init_fn_t *fn_ptr; - for (fn_ptr = &__rt_init_rti_board_end; fn_ptr < &__rt_init_rti_end; fn_ptr ++) + for (fn_ptr = &__rt_init_rti_board_end; fn_ptr < &__rt_init_rti_end; fn_ptr++) { (*fn_ptr)(); } @@ -171,8 +171,7 @@ int entry(void) #ifndef RT_USING_HEAP /* if there is not enable heap, we should use static thread and stack. */ -rt_align(RT_ALIGN_SIZE) -static rt_uint8_t main_thread_stack[RT_MAIN_THREAD_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static rt_uint8_t main_thread_stack[RT_MAIN_THREAD_STACK_SIZE]; struct rt_thread main_thread; #endif /* RT_USING_HEAP */ diff --git a/src/cpu_mp.c b/src/cpu_mp.c index a9f080874b..b08fb40b98 100644 --- a/src/cpu_mp.c +++ b/src/cpu_mp.c @@ -168,7 +168,7 @@ struct rt_cpu *rt_cpu_index(int index) rt_base_t rt_cpus_lock(void) { rt_base_t level; - struct rt_cpu* pcpu; + struct rt_cpu *pcpu; level = rt_hw_local_irq_disable(); pcpu = rt_cpu_self(); @@ -205,7 +205,7 @@ RTM_EXPORT(rt_cpus_lock); */ void rt_cpus_unlock(rt_base_t level) { - struct rt_cpu* pcpu = rt_cpu_self(); + struct rt_cpu *pcpu = rt_cpu_self(); if (pcpu->current_thread != RT_NULL) { @@ -261,7 +261,6 @@ RTM_EXPORT(rt_cpus_lock_status_restore); */ rt_base_t rt_cpu_get_id(void) { - RT_ASSERT(rt_sched_thread_is_binding(RT_NULL) || rt_hw_interrupt_is_disabled() || !rt_scheduler_is_available()); diff --git a/src/defunct.c b/src/defunct.c index 8fa7073b92..18d6869035 100644 --- a/src/defunct.c +++ b/src/defunct.c @@ -15,7 +15,7 @@ #ifndef SYSTEM_THREAD_STACK_SIZE #define SYSTEM_THREAD_STACK_SIZE IDLE_THREAD_STACK_SIZE #endif -static rt_list_t _rt_thread_defunct = RT_LIST_OBJECT_INIT(_rt_thread_defunct); +static rt_list_t _rt_thread_defunct = RT_LIST_OBJECT_INIT(_rt_thread_defunct); static struct rt_spinlock _defunct_spinlock; #if defined(RT_USING_SMP) || defined(RT_USING_SMART) static struct rt_thread rt_system_thread; @@ -46,9 +46,9 @@ void rt_thread_defunct_enqueue(rt_thread_t thread) */ rt_thread_t rt_thread_defunct_dequeue(void) { - rt_base_t level; + rt_base_t level; rt_thread_t thread = RT_NULL; - rt_list_t *l = &_rt_thread_defunct; + rt_list_t *l = &_rt_thread_defunct; level = rt_spin_lock_irqsave(&_defunct_spinlock); if (!rt_list_isempty(l)) @@ -71,7 +71,7 @@ void rt_defunct_execute(void) while (1) { rt_thread_t thread; - rt_bool_t object_is_systemobject; + rt_bool_t object_is_systemobject; void (*cleanup)(struct rt_thread *tid); #ifdef RT_USING_MODULE diff --git a/src/idle.c b/src/idle.c index 64ee6156c5..eed5bbc9fb 100644 --- a/src/idle.c +++ b/src/idle.c @@ -35,22 +35,21 @@ #endif /* RT_USING_HOOK */ #ifndef IDLE_THREAD_STACK_SIZE -#if defined (RT_USING_IDLE_HOOK) || defined(RT_USING_HEAP) -#define IDLE_THREAD_STACK_SIZE 256 +#if defined(RT_USING_IDLE_HOOK) || defined(RT_USING_HEAP) +#define IDLE_THREAD_STACK_SIZE 256 #else -#define IDLE_THREAD_STACK_SIZE 128 +#define IDLE_THREAD_STACK_SIZE 128 #endif /* (RT_USING_IDLE_HOOK) || defined(RT_USING_HEAP) */ #endif /* IDLE_THREAD_STACK_SIZE */ -#define _CPUS_NR RT_CPUS_NR +#define _CPUS_NR RT_CPUS_NR static struct rt_thread idle_thread[_CPUS_NR]; -rt_align(RT_ALIGN_SIZE) -static rt_uint8_t idle_thread_stack[_CPUS_NR][IDLE_THREAD_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static rt_uint8_t idle_thread_stack[_CPUS_NR][IDLE_THREAD_STACK_SIZE]; #ifdef RT_USING_IDLE_HOOK #ifndef RT_IDLE_HOOK_LIST_SIZE -#define RT_IDLE_HOOK_LIST_SIZE 4 +#define RT_IDLE_HOOK_LIST_SIZE 4 #endif /* RT_IDLE_HOOK_LIST_SIZE */ static void (*idle_hook_list[RT_IDLE_HOOK_LIST_SIZE])(void); @@ -147,7 +146,7 @@ static void idle_thread_entry(void *parameter) #endif /* RT_USING_IDLE_HOOK */ #if !defined(RT_USING_SMP) && !defined(RT_USING_SMART) - rt_defunct_execute(); + rt_defunct_execute(); #endif #ifdef RT_USING_PM @@ -180,18 +179,18 @@ void rt_thread_idle_init(void) #endif /* RT_NAME_MAX > 0 */ rt_thread_init(&idle_thread[i], #if RT_NAME_MAX > 0 - idle_thread_name, + idle_thread_name, #else - "tidle", + "tidle", #endif /* RT_NAME_MAX > 0 */ - idle_thread_entry, - RT_NULL, - &idle_thread_stack[i][0], - sizeof(idle_thread_stack[i]), - RT_THREAD_PRIORITY_MAX - 1, - 32); + idle_thread_entry, + RT_NULL, + &idle_thread_stack[i][0], + sizeof(idle_thread_stack[i]), + RT_THREAD_PRIORITY_MAX - 1, + 32); #ifdef RT_USING_SMP - rt_thread_control(&idle_thread[i], RT_THREAD_CTRL_BIND_CPU, (void*)i); + rt_thread_control(&idle_thread[i], RT_THREAD_CTRL_BIND_CPU, (void *)i); #endif /* RT_USING_SMP */ /* update */ @@ -243,7 +242,9 @@ rt_bool_t rt_thread_is_idle_thread(rt_thread_t thread) for (i = 0; i < _CPUS_NR; i++) { if (thread == &idle_thread[i]) + { return RT_TRUE; + } } } @@ -51,11 +51,11 @@ #include <rtthread.h> #include <rthw.h> -#define DBG_TAG "kernel.ipc" -#define DBG_LVL DBG_INFO +#define DBG_TAG "kernel.ipc" +#define DBG_LVL DBG_INFO #include <rtdbg.h> -#define GET_MESSAGEBYTE_ADDR(msg) ((struct rt_mq_message *) msg + 1) +#define GET_MESSAGEBYTE_ADDR(msg) ((struct rt_mq_message *)msg + 1) #if defined(RT_USING_HOOK) && defined(RT_HOOK_USING_FUNC_PTR) extern void (*rt_object_trytake_hook)(struct rt_object *object); extern void (*rt_object_take_hook)(struct rt_object *object); @@ -87,7 +87,6 @@ rt_inline rt_err_t _ipc_object_init(struct rt_ipc_object *ipc) return RT_EOK; } - /** * @brief Dequeue a thread from suspended list and set it to ready. The 2 are * taken as an atomic operation, so if a thread is returned, it's @@ -148,7 +147,6 @@ struct rt_thread *rt_susp_list_dequeue(rt_list_t *susp_list, rt_err_t thread_err return thread; } - /** * @brief This function will resume all suspended threads in the IPC object list, * including the suspended list of IPC object, and private list of mailbox etc. @@ -225,8 +223,7 @@ rt_err_t rt_susp_list_resume_all_irq(rt_list_t *susp_list, thread = rt_susp_list_dequeue(susp_list, thread_error); rt_spin_unlock_irqrestore(lock, level); - } - while (thread); + } while (thread); return RT_EOK; } @@ -252,32 +249,34 @@ rt_err_t rt_susp_list_enqueue(rt_list_t *susp_list, rt_thread_t thread, int ipc_ break; /* RT_IPC_FLAG_FIFO */ case RT_IPC_FLAG_PRIO: + { + struct rt_list_node *n; + struct rt_thread *sthread; + + /* find a suitable position */ + for (n = susp_list->next; n != susp_list; n = n->next) { - struct rt_list_node *n; - struct rt_thread *sthread; + sthread = RT_THREAD_LIST_NODE_ENTRY(n); - /* find a suitable position */ - for (n = susp_list->next; n != susp_list; n = n->next) + /* find out */ + if (rt_sched_thread_get_curr_prio(thread) < rt_sched_thread_get_curr_prio(sthread)) { - sthread = RT_THREAD_LIST_NODE_ENTRY(n); - - /* find out */ - if (rt_sched_thread_get_curr_prio(thread) < rt_sched_thread_get_curr_prio(sthread)) - { - /* insert this thread before the sthread */ - rt_list_insert_before(&RT_THREAD_LIST_NODE(sthread), &RT_THREAD_LIST_NODE(thread)); - break; - } + /* insert this thread before the sthread */ + rt_list_insert_before(&RT_THREAD_LIST_NODE(sthread), &RT_THREAD_LIST_NODE(thread)); + break; } + } - /* + /* * not found a suitable position, * append to the end of suspend_thread list */ - if (n == susp_list) - rt_list_insert_before(susp_list, &RT_THREAD_LIST_NODE(thread)); + if (n == susp_list) + { + rt_list_insert_before(susp_list, &RT_THREAD_LIST_NODE(thread)); } - break;/* RT_IPC_FLAG_PRIO */ + } + break; /* RT_IPC_FLAG_PRIO */ default: RT_ASSERT(0); @@ -305,7 +304,9 @@ void rt_susp_list_print(rt_list_t *list) rt_kprintf("%.*s", RT_NAME_MAX, thread->parent.name); if (node->next != list) + { rt_kprintf("/"); + } } rt_sched_unlock(slvl); @@ -314,17 +315,16 @@ void rt_susp_list_print(rt_list_t *list) #endif } - #ifdef RT_USING_SEMAPHORE /** * @addtogroup group_semaphore Semaphore * @{ */ -static void _sem_object_init(rt_sem_t sem, - rt_uint16_t value, - rt_uint8_t flag, - rt_uint16_t max_value) +static void _sem_object_init(rt_sem_t sem, + rt_uint16_t value, + rt_uint8_t flag, + rt_uint16_t max_value) { /* initialize ipc object */ _ipc_object_init(&(sem->parent)); @@ -376,10 +376,10 @@ static void _sem_object_init(rt_sem_t sem, * * @warning This function can ONLY be called from threads. */ -rt_err_t rt_sem_init(rt_sem_t sem, +rt_err_t rt_sem_init(rt_sem_t sem, const char *name, rt_uint32_t value, - rt_uint8_t flag) + rt_uint8_t flag) { RT_ASSERT(sem != RT_NULL); RT_ASSERT(value < 0x10000U); @@ -394,7 +394,6 @@ rt_err_t rt_sem_init(rt_sem_t sem, } RTM_EXPORT(rt_sem_init); - /** * @brief This function will detach a static semaphore object. * @@ -479,7 +478,9 @@ rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag) /* allocate object */ sem = (rt_sem_t)rt_object_allocate(RT_Object_Class_Semaphore, name); if (sem == RT_NULL) + { return sem; + } _sem_object_init(sem, value, flag, RT_SEM_VALUE_MAX); @@ -487,7 +488,6 @@ rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag) } RTM_EXPORT(rt_sem_create); - /** * @brief This function will delete a semaphore object and release the memory space. * @@ -530,7 +530,6 @@ rt_err_t rt_sem_delete(rt_sem_t sem) RTM_EXPORT(rt_sem_delete); #endif /* RT_USING_HEAP */ - /** * @brief This function will take a semaphore, if the semaphore is unavailable, the thread shall wait for * the semaphore up to a specified time. @@ -583,7 +582,7 @@ static rt_err_t _rt_sem_take(rt_sem_t sem, rt_int32_t timeout, int suspend_flag) if (sem->value > 0) { /* semaphore is available */ - sem->value --; + sem->value--; rt_spin_unlock_irqrestore(&(sem->spinlock), level); } else @@ -683,7 +682,6 @@ rt_err_t rt_sem_trytake(rt_sem_t sem) } RTM_EXPORT(rt_sem_trytake); - /** * @brief This function will release a semaphore. If there is thread suspended on the semaphore, it will get resumed. * @@ -723,9 +721,9 @@ rt_err_t rt_sem_release(rt_sem_t sem) } else { - if(sem->value < sem->max_value) + if (sem->value < sem->max_value) { - sem->value ++; /* increase value */ + sem->value++; /* increase value */ } else { @@ -738,13 +736,14 @@ rt_err_t rt_sem_release(rt_sem_t sem) /* resume a thread, re-schedule */ if (need_schedule == RT_TRUE) + { rt_schedule(); + } return RT_EOK; } RTM_EXPORT(rt_sem_release); - /** * @brief This function will set some extra attributions of a semaphore object. * @@ -845,7 +844,7 @@ rt_inline rt_uint8_t _mutex_update_priority(struct rt_mutex *mutex) } /* get highest priority inside its taken object and its init priority */ -rt_inline rt_uint8_t _thread_get_mutex_priority(struct rt_thread* thread) +rt_inline rt_uint8_t _thread_get_mutex_priority(struct rt_thread *thread) { rt_list_t *node = RT_NULL; struct rt_mutex *mutex = RT_NULL; @@ -871,7 +870,7 @@ rt_inline rt_uint8_t _thread_get_mutex_priority(struct rt_thread* thread) rt_inline void _thread_update_priority(struct rt_thread *thread, rt_uint8_t priority, int suspend_flag) { rt_err_t ret = -RT_ERROR; - struct rt_object* pending_obj = RT_NULL; + struct rt_object *pending_obj = RT_NULL; LOG_D("thread:%s priority -> %d", thread->parent.name, priority); @@ -886,7 +885,7 @@ rt_inline void _thread_update_priority(struct rt_thread *thread, rt_uint8_t prio if (pending_obj && rt_object_get_type(pending_obj) == RT_Object_Class_Mutex) { rt_uint8_t mutex_priority = 0xff; - struct rt_mutex* pending_mutex = (struct rt_mutex *)pending_obj; + struct rt_mutex *pending_mutex = (struct rt_mutex *)pending_obj; /* re-insert thread to suspended thread list to resort priority list */ rt_list_remove(&RT_THREAD_LIST_NODE(thread)); @@ -900,7 +899,7 @@ rt_inline void _thread_update_priority(struct rt_thread *thread, rt_uint8_t prio _mutex_update_priority(pending_mutex); /* change the priority of mutex owner thread */ LOG_D("mutex: %s priority -> %d", pending_mutex->parent.parent.name, - pending_mutex->priority); + pending_mutex->priority); mutex_priority = _thread_get_mutex_priority(pending_mutex->owner); if (mutex_priority != rt_sched_thread_get_curr_prio(pending_mutex->owner)) @@ -1021,9 +1020,9 @@ rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag) /* initialize ipc object */ _ipc_object_init(&(mutex->parent)); - mutex->owner = RT_NULL; + mutex->owner = RT_NULL; mutex->priority = 0xFF; - mutex->hold = 0; + mutex->hold = 0; mutex->ceiling_priority = 0xFF; rt_list_init(&(mutex->taken_list)); @@ -1035,7 +1034,6 @@ rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag) } RTM_EXPORT(rt_mutex_init); - /** * @brief This function will detach a static mutex object. * @@ -1142,7 +1140,6 @@ void rt_mutex_drop_thread(rt_mutex_t mutex, rt_thread_t thread) rt_spin_unlock(&(mutex->spinlock)); } - /** * @brief set the prioceiling attribute of the mutex. * @@ -1186,7 +1183,6 @@ rt_uint8_t rt_mutex_setprioceiling(rt_mutex_t mutex, rt_uint8_t priority) } RTM_EXPORT(rt_mutex_setprioceiling); - /** * @brief set the prioceiling attribute of the mutex. * @@ -1213,7 +1209,6 @@ rt_uint8_t rt_mutex_getprioceiling(rt_mutex_t mutex) } RTM_EXPORT(rt_mutex_getprioceiling); - #ifdef RT_USING_HEAP /** * @brief This function will create a mutex object. @@ -1245,14 +1240,16 @@ rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag) /* allocate object */ mutex = (rt_mutex_t)rt_object_allocate(RT_Object_Class_Mutex, name); if (mutex == RT_NULL) + { return mutex; + } /* initialize ipc object */ _ipc_object_init(&(mutex->parent)); - mutex->owner = RT_NULL; + mutex->owner = RT_NULL; mutex->priority = 0xFF; - mutex->hold = 0; + mutex->hold = 0; mutex->ceiling_priority = 0xFF; rt_list_init(&(mutex->taken_list)); @@ -1264,7 +1261,6 @@ rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag) } RTM_EXPORT(rt_mutex_create); - /** * @brief This function will delete a mutex object and release this memory space. * @@ -1302,7 +1298,6 @@ rt_err_t rt_mutex_delete(rt_mutex_t mutex) RTM_EXPORT(rt_mutex_delete); #endif /* RT_USING_HEAP */ - /** * @brief This function will take a mutex, if the mutex is unavailable, the thread shall wait for * the mutex up to a specified time. @@ -1357,7 +1352,7 @@ static rt_err_t _rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout, int suspend if (mutex->hold < RT_MUTEX_HOLD_MAX) { /* it's the same thread */ - mutex->hold ++; + mutex->hold++; } else { @@ -1371,15 +1366,17 @@ static rt_err_t _rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout, int suspend if (mutex->owner == RT_NULL) { /* set mutex owner and original priority */ - mutex->owner = thread; + mutex->owner = thread; mutex->priority = 0xff; - mutex->hold = 1; + mutex->hold = 1; if (mutex->ceiling_priority != 0xFF) { /* set the priority of thread to the ceiling priority */ if (mutex->ceiling_priority < rt_sched_thread_get_curr_prio(mutex->owner)) + { _thread_update_priority(mutex->owner, mutex->ceiling_priority, suspend_flag); + } } /* insert mutex to thread's taken object list */ @@ -1488,7 +1485,9 @@ static rt_err_t _rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout, int suspend * it had already reset its priority. So it's okay to skip */ if (mutex->owner && rt_sched_thread_get_curr_prio(mutex->owner) == rt_sched_thread_get_curr_prio(thread)) + { need_update = RT_TRUE; + } /* update the priority of mutex */ if (!rt_list_isempty(&mutex->parent.suspend_thread)) @@ -1577,7 +1576,6 @@ rt_err_t rt_mutex_trytake(rt_mutex_t mutex) } RTM_EXPORT(rt_mutex_trytake); - /** * @brief This function will release a mutex. If there is thread suspended on the mutex, the thread will be resumed. * @@ -1642,7 +1640,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex) } /* decrease hold */ - mutex->hold --; + mutex->hold--; /* if no hold */ if (mutex->hold == 0) { @@ -1685,11 +1683,11 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex) if (next_thread) { LOG_D("mutex_release: resume thread: %s", - next_thread->parent.name); + next_thread->parent.name); /* set new owner and put mutex into taken list of thread */ mutex->owner = next_thread; - mutex->hold = 1; + mutex->hold = 1; rt_list_insert_after(&next_thread->taken_object_list, &mutex->taken_list); /* cleanup pending object */ @@ -1724,7 +1722,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex) rt_sched_unlock(slvl); /* clear owner */ - mutex->owner = RT_NULL; + mutex->owner = RT_NULL; mutex->priority = 0xff; } } @@ -1733,13 +1731,14 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex) /* perform a schedule */ if (need_schedule == RT_TRUE) + { rt_schedule(); + } return RT_EOK; } RTM_EXPORT(rt_mutex_release); - /** * @brief This function will set some extra attributions of a mutex object. * @@ -1830,7 +1829,6 @@ rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag) } RTM_EXPORT(rt_event_init); - /** * @brief This function will detach a static event object. * @@ -1910,7 +1908,9 @@ rt_event_t rt_event_create(const char *name, rt_uint8_t flag) /* allocate object */ event = (rt_event_t)rt_object_allocate(RT_Object_Class_Event, name); if (event == RT_NULL) + { return event; + } /* set parent */ event->parent.parent.flag = flag; @@ -1926,7 +1926,6 @@ rt_event_t rt_event_create(const char *name, rt_uint8_t flag) } RTM_EXPORT(rt_event_create); - /** * @brief This function will delete an event object and release the memory space. * @@ -1967,7 +1966,6 @@ rt_err_t rt_event_delete(rt_event_t event) RTM_EXPORT(rt_event_delete); #endif /* RT_USING_HEAP */ - /** * @brief This function will send an event to the event object. * If there is a thread suspended on the event, the thread will be resumed. @@ -2000,7 +1998,9 @@ rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set) RT_ASSERT(rt_object_get_type(&event->parent.parent) == RT_Object_Class_Event); if (set == 0) + { return -RT_ERROR; + } need_schedule = RT_FALSE; @@ -2082,13 +2082,14 @@ rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set) /* do a schedule */ if (need_schedule == RT_TRUE) + { rt_schedule(); + } return RT_EOK; } RTM_EXPORT(rt_event_send); - /** * @brief This function will receive an event from event object. if the event is unavailable, the thread shall wait for * the event up to a specified time. @@ -2121,10 +2122,10 @@ RTM_EXPORT(rt_event_send); * @return Return the operation status. When the return value is RT_EOK, the operation is successful. * If the return value is any other values, it means that the semaphore release failed. */ -static rt_err_t _rt_event_recv(rt_event_t event, - rt_uint32_t set, - rt_uint8_t option, - rt_int32_t timeout, +static rt_err_t _rt_event_recv(rt_event_t event, + rt_uint32_t set, + rt_uint8_t option, + rt_int32_t timeout, rt_uint32_t *recved, int suspend_flag) { @@ -2141,7 +2142,9 @@ static rt_err_t _rt_event_recv(rt_event_t event, RT_DEBUG_SCHEDULER_AVAILABLE(RT_TRUE); if (set == 0) + { return -RT_ERROR; + } /* initialize status */ status = -RT_ERROR; @@ -2158,12 +2161,16 @@ static rt_err_t _rt_event_recv(rt_event_t event, if (option & RT_EVENT_FLAG_AND) { if ((event->set & set) == set) + { status = RT_EOK; + } } else if (option & RT_EVENT_FLAG_OR) { if (event->set & set) + { status = RT_EOK; + } } else { @@ -2177,7 +2184,9 @@ static rt_err_t _rt_event_recv(rt_event_t event, /* set received event */ if (recved) + { *recved = (event->set & set); + } /* fill thread event info */ thread->event_set = (event->set & set); @@ -2185,7 +2194,9 @@ static rt_err_t _rt_event_recv(rt_event_t event, /* received event */ if (option & RT_EVENT_FLAG_CLEAR) + { event->set &= ~set; + } } else if (timeout == 0) { @@ -2199,7 +2210,7 @@ static rt_err_t _rt_event_recv(rt_event_t event, else { /* fill thread event info */ - thread->event_set = set; + thread->event_set = set; thread->event_info = option; /* put thread to suspended thread list */ @@ -2238,7 +2249,9 @@ static rt_err_t _rt_event_recv(rt_event_t event, /* set received event */ if (recved) + { *recved = thread->event_set; + } } rt_spin_unlock_irqrestore(&(event->spinlock), level); @@ -2248,31 +2261,31 @@ static rt_err_t _rt_event_recv(rt_event_t event, return thread->error; } -rt_err_t rt_event_recv(rt_event_t event, - rt_uint32_t set, - rt_uint8_t option, - rt_int32_t timeout, +rt_err_t rt_event_recv(rt_event_t event, + rt_uint32_t set, + rt_uint8_t option, + rt_int32_t timeout, rt_uint32_t *recved) { return _rt_event_recv(event, set, option, timeout, recved, RT_UNINTERRUPTIBLE); } RTM_EXPORT(rt_event_recv); -rt_err_t rt_event_recv_interruptible(rt_event_t event, - rt_uint32_t set, - rt_uint8_t option, - rt_int32_t timeout, - rt_uint32_t *recved) +rt_err_t rt_event_recv_interruptible(rt_event_t event, + rt_uint32_t set, + rt_uint8_t option, + rt_int32_t timeout, + rt_uint32_t *recved) { return _rt_event_recv(event, set, option, timeout, recved, RT_INTERRUPTIBLE); } RTM_EXPORT(rt_event_recv_interruptible); -rt_err_t rt_event_recv_killable(rt_event_t event, - rt_uint32_t set, - rt_uint8_t option, - rt_int32_t timeout, - rt_uint32_t *recved) +rt_err_t rt_event_recv_killable(rt_event_t event, + rt_uint32_t set, + rt_uint8_t option, + rt_int32_t timeout, + rt_uint32_t *recved) { return _rt_event_recv(event, set, option, timeout, recved, RT_KILLABLE); } @@ -2370,10 +2383,10 @@ RTM_EXPORT(rt_event_control); * @warning This function can ONLY be called from threads. */ rt_err_t rt_mb_init(rt_mailbox_t mb, - const char *name, - void *msgpool, - rt_size_t size, - rt_uint8_t flag) + const char *name, + void *msgpool, + rt_size_t size, + rt_uint8_t flag) { RT_ASSERT(mb != RT_NULL); RT_ASSERT((flag == RT_IPC_FLAG_FIFO) || (flag == RT_IPC_FLAG_PRIO)); @@ -2388,10 +2401,10 @@ rt_err_t rt_mb_init(rt_mailbox_t mb, _ipc_object_init(&(mb->parent)); /* initialize mailbox */ - mb->msg_pool = (rt_ubase_t *)msgpool; - mb->size = (rt_uint16_t)size; - mb->entry = 0; - mb->in_offset = 0; + mb->msg_pool = (rt_ubase_t *)msgpool; + mb->size = (rt_uint16_t)size; + mb->entry = 0; + mb->in_offset = 0; mb->out_offset = 0; /* initialize an additional list of sender suspend thread */ @@ -2402,7 +2415,6 @@ rt_err_t rt_mb_init(rt_mailbox_t mb, } RTM_EXPORT(rt_mb_init); - /** * @brief This function will detach a static mailbox object. * @@ -2487,7 +2499,9 @@ rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag) /* allocate object */ mb = (rt_mailbox_t)rt_object_allocate(RT_Object_Class_MailBox, name); if (mb == RT_NULL) + { return mb; + } /* set parent */ mb->parent.parent.flag = flag; @@ -2496,7 +2510,7 @@ rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag) _ipc_object_init(&(mb->parent)); /* initialize mailbox */ - mb->size = (rt_uint16_t)size; + mb->size = (rt_uint16_t)size; mb->msg_pool = (rt_ubase_t *)RT_KERNEL_MALLOC(mb->size * sizeof(rt_ubase_t)); if (mb->msg_pool == RT_NULL) { @@ -2505,8 +2519,8 @@ rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag) return RT_NULL; } - mb->entry = 0; - mb->in_offset = 0; + mb->entry = 0; + mb->in_offset = 0; mb->out_offset = 0; /* initialize an additional list of sender suspend thread */ @@ -2517,7 +2531,6 @@ rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag) } RTM_EXPORT(rt_mb_create); - /** * @brief This function will delete a mailbox object and release the memory space. * @@ -2565,7 +2578,6 @@ rt_err_t rt_mb_delete(rt_mailbox_t mb) RTM_EXPORT(rt_mb_delete); #endif /* RT_USING_HEAP */ - /** * @brief This function will send an mail to the mailbox object. If there is a thread suspended on the mailbox, * the thread will be resumed. @@ -2590,9 +2602,9 @@ RTM_EXPORT(rt_mb_delete); * @warning This function can be called in interrupt context and thread context. */ static rt_err_t _rt_mb_send_wait(rt_mailbox_t mb, - rt_ubase_t value, - rt_int32_t timeout, - int suspend_flag) + rt_ubase_t value, + rt_int32_t timeout, + int suspend_flag) { struct rt_thread *thread; rt_base_t level; @@ -2683,21 +2695,25 @@ static rt_err_t _rt_mb_send_wait(rt_mailbox_t mb, tick_delta = rt_tick_get() - tick_delta; timeout -= tick_delta; if (timeout < 0) + { timeout = 0; + } } } /* set ptr */ mb->msg_pool[mb->in_offset] = value; /* increase input offset */ - ++ mb->in_offset; + ++mb->in_offset; if (mb->in_offset >= mb->size) + { mb->in_offset = 0; + } - if(mb->entry < RT_MB_ENTRY_MAX) + if (mb->entry < RT_MB_ENTRY_MAX) { /* increase message entry */ - mb->entry ++; + mb->entry++; } else { @@ -2722,24 +2738,24 @@ static rt_err_t _rt_mb_send_wait(rt_mailbox_t mb, } rt_err_t rt_mb_send_wait(rt_mailbox_t mb, - rt_ubase_t value, - rt_int32_t timeout) + rt_ubase_t value, + rt_int32_t timeout) { return _rt_mb_send_wait(mb, value, timeout, RT_UNINTERRUPTIBLE); } RTM_EXPORT(rt_mb_send_wait); rt_err_t rt_mb_send_wait_interruptible(rt_mailbox_t mb, - rt_ubase_t value, - rt_int32_t timeout) + rt_ubase_t value, + rt_int32_t timeout) { return _rt_mb_send_wait(mb, value, timeout, RT_INTERRUPTIBLE); } RTM_EXPORT(rt_mb_send_wait_interruptible); rt_err_t rt_mb_send_wait_killable(rt_mailbox_t mb, - rt_ubase_t value, - rt_int32_t timeout) + rt_ubase_t value, + rt_int32_t timeout) { return _rt_mb_send_wait(mb, value, timeout, RT_KILLABLE); } @@ -2816,7 +2832,7 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value) /* rewind to the previous position */ if (mb->out_offset > 0) { - mb->out_offset --; + mb->out_offset--; } else { @@ -2827,7 +2843,7 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value) mb->msg_pool[mb->out_offset] = value; /* increase message entry */ - mb->entry ++; + mb->entry++; /* resume suspended thread */ if (!rt_list_isempty(&mb->parent.suspend_thread)) @@ -2846,7 +2862,6 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value) } RTM_EXPORT(rt_mb_urgent); - /** * @brief This function will receive a mail from mailbox object, if there is no mail in mailbox object, * the thread shall wait for a specified time. @@ -2964,7 +2979,9 @@ static rt_err_t _rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeo tick_delta = rt_tick_get() - tick_delta; timeout -= tick_delta; if (timeout < 0) + { timeout = 0; + } } } @@ -2972,14 +2989,16 @@ static rt_err_t _rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeo *value = mb->msg_pool[mb->out_offset]; /* increase output offset */ - ++ mb->out_offset; + ++mb->out_offset; if (mb->out_offset >= mb->size) + { mb->out_offset = 0; + } /* decrease message entry */ - if(mb->entry > 0) + if (mb->entry > 0) { - mb->entry --; + mb->entry--; } /* resume suspended thread */ @@ -3054,8 +3073,8 @@ rt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg) rt_susp_list_resume_all(&(mb->suspend_sender_thread), RT_ERROR); /* re-init mailbox */ - mb->entry = 0; - mb->in_offset = 0; + mb->entry = 0; + mb->in_offset = 0; mb->out_offset = 0; rt_spin_unlock_irqrestore(&(mb->spinlock), level); @@ -3120,12 +3139,12 @@ RTM_EXPORT(rt_mb_control); * * @warning This function can ONLY be called from threads. */ -rt_err_t rt_mq_init(rt_mq_t mq, +rt_err_t rt_mq_init(rt_mq_t mq, const char *name, - void *msgpool, - rt_size_t msg_size, - rt_size_t pool_size, - rt_uint8_t flag) + void *msgpool, + rt_size_t msg_size, + rt_size_t pool_size, + rt_uint8_t flag) { struct rt_mq_message *head; rt_base_t temp; @@ -3163,7 +3182,7 @@ rt_err_t rt_mq_init(rt_mq_t mq, /* initialize message empty list */ mq->msg_queue_free = RT_NULL; - for (temp = 0; temp < mq->max_msgs; temp ++) + for (temp = 0; temp < mq->max_msgs; temp++) { head = (struct rt_mq_message *)((rt_uint8_t *)mq->msg_pool + temp * (msg_align_size + sizeof(struct rt_mq_message))); @@ -3182,7 +3201,6 @@ rt_err_t rt_mq_init(rt_mq_t mq, } RTM_EXPORT(rt_mq_init); - /** * @brief This function will detach a static messagequeue object. * @@ -3258,9 +3276,9 @@ RTM_EXPORT(rt_mq_detach); * @warning This function can NOT be called in interrupt context. You can use macor RT_DEBUG_NOT_IN_INTERRUPT to check it. */ rt_mq_t rt_mq_create(const char *name, - rt_size_t msg_size, - rt_size_t max_msgs, - rt_uint8_t flag) + rt_size_t msg_size, + rt_size_t max_msgs, + rt_uint8_t flag) { struct rt_messagequeue *mq; struct rt_mq_message *head; @@ -3274,7 +3292,9 @@ rt_mq_t rt_mq_create(const char *name, /* allocate object */ mq = (rt_mq_t)rt_object_allocate(RT_Object_Class_MessageQueue, name); if (mq == RT_NULL) + { return mq; + } /* set parent */ mq->parent.parent.flag = flag; @@ -3304,7 +3324,7 @@ rt_mq_t rt_mq_create(const char *name, /* initialize message empty list */ mq->msg_queue_free = RT_NULL; - for (temp = 0; temp < mq->max_msgs; temp ++) + for (temp = 0; temp < mq->max_msgs; temp++) { head = (struct rt_mq_message *)((rt_uint8_t *)mq->msg_pool + temp * (msg_align_size + sizeof(struct rt_mq_message))); @@ -3323,7 +3343,6 @@ rt_mq_t rt_mq_create(const char *name, } RTM_EXPORT(rt_mq_create); - /** * @brief This function will delete a messagequeue object and release the memory. * @@ -3430,7 +3449,9 @@ static rt_err_t _rt_mq_send_wait(rt_mq_t mq, /* greater than one message size */ if (size > mq->msg_size) + { return -RT_ERROR; + } /* initialize delta tick */ tick_delta = 0; @@ -3510,7 +3531,9 @@ static rt_err_t _rt_mq_send_wait(rt_mq_t mq, tick_delta = rt_tick_get() - tick_delta; timeout -= tick_delta; if (timeout < 0) + { timeout = 0; + } } } @@ -3532,7 +3555,9 @@ static rt_err_t _rt_mq_send_wait(rt_mq_t mq, #ifdef RT_USING_MESSAGEQUEUE_PRIORITY msg->prio = prio; if (mq->msg_queue_head == RT_NULL) + { mq->msg_queue_head = msg; + } struct rt_mq_message *node, *prev_node = RT_NULL; for (node = mq->msg_queue_head; node != RT_NULL; node = node->next) @@ -3540,16 +3565,22 @@ static rt_err_t _rt_mq_send_wait(rt_mq_t mq, if (node->prio < msg->prio) { if (prev_node == RT_NULL) + { mq->msg_queue_head = msg; + } else + { prev_node->next = msg; + } msg->next = node; break; } if (node->next == RT_NULL) { if (node != msg) + { node->next = msg; + } mq->msg_queue_tail = msg; break; } @@ -3567,13 +3598,15 @@ static rt_err_t _rt_mq_send_wait(rt_mq_t mq, mq->msg_queue_tail = msg; /* if the head is empty, set head */ if (mq->msg_queue_head == RT_NULL) + { mq->msg_queue_head = msg; + } #endif - if(mq->entry < RT_MQ_ENTRY_MAX) + if (mq->entry < RT_MQ_ENTRY_MAX) { /* increase message entry */ - mq->entry ++; + mq->entry++; } else { @@ -3597,28 +3630,28 @@ static rt_err_t _rt_mq_send_wait(rt_mq_t mq, return RT_EOK; } -rt_err_t rt_mq_send_wait(rt_mq_t mq, +rt_err_t rt_mq_send_wait(rt_mq_t mq, const void *buffer, - rt_size_t size, - rt_int32_t timeout) + rt_size_t size, + rt_int32_t timeout) { return _rt_mq_send_wait(mq, buffer, size, 0, timeout, RT_UNINTERRUPTIBLE); } RTM_EXPORT(rt_mq_send_wait); -rt_err_t rt_mq_send_wait_interruptible(rt_mq_t mq, - const void *buffer, - rt_size_t size, - rt_int32_t timeout) +rt_err_t rt_mq_send_wait_interruptible(rt_mq_t mq, + const void *buffer, + rt_size_t size, + rt_int32_t timeout) { return _rt_mq_send_wait(mq, buffer, size, 0, timeout, RT_INTERRUPTIBLE); } RTM_EXPORT(rt_mq_send_wait_interruptible); -rt_err_t rt_mq_send_wait_killable(rt_mq_t mq, - const void *buffer, - rt_size_t size, - rt_int32_t timeout) +rt_err_t rt_mq_send_wait_killable(rt_mq_t mq, + const void *buffer, + rt_size_t size, + rt_int32_t timeout) { return _rt_mq_send_wait(mq, buffer, size, 0, timeout, RT_KILLABLE); } @@ -3693,7 +3726,9 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size) /* greater than one message size */ if (size > mq->msg_size) + { return -RT_ERROR; + } RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mq->parent.parent))); @@ -3726,12 +3761,14 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size) /* if there is no tail */ if (mq->msg_queue_tail == RT_NULL) + { mq->msg_queue_tail = msg; + } - if(mq->entry < RT_MQ_ENTRY_MAX) + if (mq->entry < RT_MQ_ENTRY_MAX) { /* increase message entry */ - mq->entry ++; + mq->entry++; } else { @@ -3891,7 +3928,9 @@ static rt_ssize_t _rt_mq_recv(rt_mq_t mq, tick_delta = rt_tick_get() - tick_delta; timeout -= tick_delta; if (timeout < 0) + { timeout = 0; + } } } @@ -3902,12 +3941,14 @@ static rt_ssize_t _rt_mq_recv(rt_mq_t mq, mq->msg_queue_head = msg->next; /* reach queue tail, set to NULL */ if (mq->msg_queue_tail == msg) + { mq->msg_queue_tail = RT_NULL; + } /* decrease message entry */ - if(mq->entry > 0) + if (mq->entry > 0) { - mq->entry --; + mq->entry--; } rt_spin_unlock_irqrestore(&(mq->spinlock), level); @@ -3916,13 +3957,17 @@ static rt_ssize_t _rt_mq_recv(rt_mq_t mq, len = ((struct rt_mq_message *)msg)->length; if (len > size) + { len = size; + } /* copy message */ rt_memcpy(buffer, GET_MESSAGEBYTE_ADDR(msg), len); #ifdef RT_USING_MESSAGEQUEUE_PRIORITY if (prio != RT_NULL) + { *prio = msg->prio; + } #endif level = rt_spin_lock_irqsave(&(mq->spinlock)); /* put message to free list */ @@ -3950,28 +3995,28 @@ static rt_ssize_t _rt_mq_recv(rt_mq_t mq, return len; } -rt_ssize_t rt_mq_recv(rt_mq_t mq, - void *buffer, - rt_size_t size, - rt_int32_t timeout) +rt_ssize_t rt_mq_recv(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout) { return _rt_mq_recv(mq, buffer, size, 0, timeout, RT_UNINTERRUPTIBLE); } RTM_EXPORT(rt_mq_recv); -rt_ssize_t rt_mq_recv_interruptible(rt_mq_t mq, - void *buffer, - rt_size_t size, - rt_int32_t timeout) +rt_ssize_t rt_mq_recv_interruptible(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout) { return _rt_mq_recv(mq, buffer, size, 0, timeout, RT_INTERRUPTIBLE); } RTM_EXPORT(rt_mq_recv_interruptible); -rt_ssize_t rt_mq_recv_killable(rt_mq_t mq, - void *buffer, - rt_size_t size, - rt_int32_t timeout) +rt_ssize_t rt_mq_recv_killable(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout) { return _rt_mq_recv(mq, buffer, size, 0, timeout, RT_KILLABLE); } @@ -4040,7 +4085,9 @@ rt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg) mq->msg_queue_head = msg->next; /* reach queue tail, set to NULL */ if (mq->msg_queue_tail == msg) + { mq->msg_queue_tail = RT_NULL; + } /* put message to free list */ msg->next = (struct rt_mq_message *)mq->msg_queue_free; @@ -20,8 +20,8 @@ #include <rthw.h> #include <rtthread.h> -#define DBG_TAG "kernel.irq" -#define DBG_LVL DBG_INFO +#define DBG_TAG "kernel.irq" +#define DBG_LVL DBG_INFO #include <rtdbg.h> #if defined(RT_USING_HOOK) && defined(RT_HOOK_USING_FUNC_PTR) @@ -100,13 +100,12 @@ void *rt_interrupt_context_get(void) rt_weak void rt_interrupt_enter(void) { rt_atomic_add(&(rt_interrupt_nest), 1); - RT_OBJECT_HOOK_CALL(rt_interrupt_enter_hook,()); + RT_OBJECT_HOOK_CALL(rt_interrupt_enter_hook, ()); LOG_D("irq has come..., irq current nest:%d", (rt_int32_t)rt_atomic_load(&(rt_interrupt_nest))); } RTM_EXPORT(rt_interrupt_enter); - /** * @brief This function will be invoked by BSP, when leave interrupt service routine * @@ -117,14 +116,12 @@ RTM_EXPORT(rt_interrupt_enter); rt_weak void rt_interrupt_leave(void) { LOG_D("irq is going to leave, irq current nest:%d", - (rt_int32_t)rt_atomic_load(&(rt_interrupt_nest))); - RT_OBJECT_HOOK_CALL(rt_interrupt_leave_hook,()); + (rt_int32_t)rt_atomic_load(&(rt_interrupt_nest))); + RT_OBJECT_HOOK_CALL(rt_interrupt_leave_hook, ()); rt_atomic_sub(&(rt_interrupt_nest), 1); - } RTM_EXPORT(rt_interrupt_leave); - /** * @brief This function will return the nest of interrupt. * diff --git a/src/klibc/kerrno.c b/src/klibc/kerrno.c index 49a73c6d40..ddd8556ad4 100644 --- a/src/klibc/kerrno.c +++ b/src/klibc/kerrno.c @@ -28,8 +28,8 @@ static volatile int __rt_errno; */ struct _errno_str_t { - rt_err_t error; /**< Error code of type rt_err_t, representing different kinds of errors. */ - const char *str; /**< Pointer to the error description string. */ + rt_err_t error; /**< Error code of type rt_err_t, representing different kinds of errors. */ + const char *str; /**< Pointer to the error description string. */ }; /** @@ -39,23 +39,22 @@ struct _errno_str_t * corresponding error description strings. These mappings can be used at runtime * to provide more readable error information. */ -static struct _errno_str_t rt_errno_strs[] = -{ - {RT_EOK , "OK "}, /**< Operation successful. */ - {RT_ERROR , "ERROR "}, /**< General error. */ - {RT_ETIMEOUT, "ETIMOUT"}, /**< Operation timed out. */ - {RT_EFULL , "ERSFULL"}, /**< Resource is full. */ - {RT_EEMPTY , "ERSEPTY"}, /**< Resource is empty. */ - {RT_ENOMEM , "ENOMEM "}, /**< Not enough memory. */ - {RT_ENOSYS , "ENOSYS "}, /**< Function not implemented. */ - {RT_EBUSY , "EBUSY "}, /**< Resource is busy. */ - {RT_EIO , "EIO "}, /**< Input/output error. */ - {RT_EINTR , "EINTRPT"}, /**< Interrupted system call. */ - {RT_EINVAL , "EINVAL "}, /**< Invalid argument. */ - {RT_ENOENT , "ENOENT "}, /**< No such file or directory. */ - {RT_ENOSPC , "ENOSPC "}, /**< No space left on device. */ - {RT_EPERM , "EPERM "}, /**< Operation not permitted. */ - {RT_ETRAP , "ETRAP "}, /**< Trap error. */ +static struct _errno_str_t rt_errno_strs[] = { + { RT_EOK, "OK " }, /**< Operation successful. */ + { RT_ERROR, "ERROR " }, /**< General error. */ + { RT_ETIMEOUT, "ETIMOUT" }, /**< Operation timed out. */ + { RT_EFULL, "ERSFULL" }, /**< Resource is full. */ + { RT_EEMPTY, "ERSEPTY" }, /**< Resource is empty. */ + { RT_ENOMEM, "ENOMEM " }, /**< Not enough memory. */ + { RT_ENOSYS, "ENOSYS " }, /**< Function not implemented. */ + { RT_EBUSY, "EBUSY " }, /**< Resource is busy. */ + { RT_EIO, "EIO " }, /**< Input/output error. */ + { RT_EINTR, "EINTRPT" }, /**< Interrupted system call. */ + { RT_EINVAL, "EINVAL " }, /**< Invalid argument. */ + { RT_ENOENT, "ENOENT " }, /**< No such file or directory. */ + { RT_ENOSPC, "ENOSPC " }, /**< No space left on device. */ + { RT_EPERM, "EPERM " }, /**< Operation not permitted. */ + { RT_ETRAP, "ETRAP " }, /**< Trap error. */ }; /** @@ -70,12 +69,16 @@ const char *rt_strerror(rt_err_t error) int i = 0; if (error < 0) + { error = -error; + } for (i = 0; i < sizeof(rt_errno_strs) / sizeof(rt_errno_strs[0]); i++) { if (rt_errno_strs[i].error == error) + { return rt_errno_strs[i].str; + } } return "EUNKNOW"; @@ -153,7 +156,7 @@ int *_rt_errno(void) tid = rt_thread_self(); if (tid != RT_NULL) { - return (int *) & (tid->error); + return (int *)&(tid->error); } return (int *)&__rt_errno; diff --git a/src/klibc/kstdio.c b/src/klibc/kstdio.c index 257b1ff1a8..153d62444b 100644 --- a/src/klibc/kstdio.c +++ b/src/klibc/kstdio.c @@ -51,7 +51,7 @@ RTM_EXPORT(rt_snprintf); */ int rt_vsprintf(char *buf, const char *format, va_list arg_ptr) { - return rt_vsnprintf(buf, (size_t) - 1, format, arg_ptr); + return rt_vsnprintf(buf, (size_t)-1, format, arg_ptr); } RTM_EXPORT(rt_vsprintf); diff --git a/src/klibc/kstring.c b/src/klibc/kstring.c index b6d553ffa3..09cbdddfd6 100644 --- a/src/klibc/kstring.c +++ b/src/klibc/kstring.c @@ -10,15 +10,15 @@ #include <rtthread.h> -#if defined(RT_KLIBC_USING_LIBC_MEMSET) || \ - defined(RT_KLIBC_USING_LIBC_MEMCPY) || \ +#if defined(RT_KLIBC_USING_LIBC_MEMSET) || \ + defined(RT_KLIBC_USING_LIBC_MEMCPY) || \ defined(RT_KLIBC_USING_LIBC_MEMMOVE) || \ - defined(RT_KLIBC_USING_LIBC_MEMCMP) || \ - defined(RT_KLIBC_USING_LIBC_STRSTR) || \ + defined(RT_KLIBC_USING_LIBC_MEMCMP) || \ + defined(RT_KLIBC_USING_LIBC_STRSTR) || \ defined(RT_KLIBC_USING_LIBC_STRNCPY) || \ - defined(RT_KLIBC_USING_LIBC_STRCPY) || \ + defined(RT_KLIBC_USING_LIBC_STRCPY) || \ defined(RT_KLIBC_USING_LIBC_STRNCMP) || \ - defined(RT_KLIBC_USING_LIBC_STRCMP) || \ + defined(RT_KLIBC_USING_LIBC_STRCMP) || \ defined(RT_KLIBC_USING_LIBC_STRLEN) #include <string.h> #endif @@ -44,20 +44,22 @@ void *rt_memset(void *s, int c, size_t count) char *xs = (char *)s; while (count--) + { *xs++ = c; + } return s; #else -#define LBLOCKSIZE (sizeof(rt_ubase_t)) -#define UNALIGNED(X) ((long)X & (LBLOCKSIZE - 1)) -#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE) +#define LBLOCKSIZE (sizeof(rt_ubase_t)) +#define UNALIGNED(X) ((long)X & (LBLOCKSIZE - 1)) +#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE) unsigned int i = 0; char *m = (char *)s; unsigned long buffer = 0; unsigned long *aligned_addr = RT_NULL; - unsigned char d = (unsigned int)c & (unsigned char)(-1); /* To avoid sign extension, copy C to an + unsigned char d = (unsigned int)c & (unsigned char)(-1); /* To avoid sign extension, copy C to an unsigned variable. (unsigned)((char)(-1))=0xFF for 8bit and =0xFFFF for 16bit: word independent */ RT_ASSERT(LBLOCKSIZE == 2 || LBLOCKSIZE == 4 || LBLOCKSIZE == 8); @@ -72,7 +74,7 @@ void *rt_memset(void *s, int c, size_t count) */ for (i = 0; i < LBLOCKSIZE; i++) { - *(((unsigned char *)&buffer)+i) = d; + *(((unsigned char *)&buffer) + i) = d; } while (count >= LBLOCKSIZE * 4) @@ -132,21 +134,25 @@ void *rt_memcpy(void *dst, const void *src, size_t count) if (tmp <= s || tmp > (s + count)) { while (count--) - *tmp ++ = *s ++; + { + *tmp++ = *s++; + } } else { - for (len = count; len > 0; len --) + for (len = count; len > 0; len--) + { tmp[len - 1] = s[len - 1]; + } } return dst; #else #define UNALIGNED(X, Y) \ - (((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1))) -#define BIGBLOCKSIZE (sizeof (long) << 2) -#define LITTLEBLOCKSIZE (sizeof (long)) + (((long)X & (sizeof(long) - 1)) | ((long)Y & (sizeof(long) - 1))) +#define BIGBLOCKSIZE (sizeof(long) << 2) +#define LITTLEBLOCKSIZE (sizeof(long)) #define TOO_SMALL(LEN) ((LEN) < BIGBLOCKSIZE) char *dst_ptr = (char *)dst; @@ -185,7 +191,9 @@ void *rt_memcpy(void *dst, const void *src, size_t count) } while (len--) + { *dst_ptr++ = *src_ptr++; + } return dst; #undef UNALIGNED @@ -224,12 +232,16 @@ void *rt_memmove(void *dest, const void *src, size_t n) s += n; while (n--) + { *(--tmp) = *(--s); + } } else { while (n--) + { *tmp++ = *s++; + } } return dest; @@ -262,8 +274,12 @@ int rt_memcmp(const void *cs, const void *ct, size_t count) int res = 0; for (su1 = (const unsigned char *)cs, su2 = (const unsigned char *)ct; 0 < count; ++su1, ++su2, count--) + { if ((res = *su1 - *su2) != 0) + { break; + } + } return res; #endif /* RT_KLIBC_USING_LIBC_MEMCMP */ @@ -298,13 +314,13 @@ char *rt_strstr(const char *s1, const char *s2) l1 = rt_strlen(s1); while (l1 >= l2) { - l1 --; + l1--; if (!rt_memcmp(s1, s2, l2)) { return (char *)s1; } - s1 ++; + s1++; } return RT_NULL; @@ -335,11 +351,14 @@ int rt_strcasecmp(const char *a, const char *b) ca = *a++ & 0xff; cb = *b++ & 0xff; if (ca >= 'A' && ca <= 'Z') + { ca += 'a' - 'A'; + } if (cb >= 'A' && cb <= 'Z') + { cb += 'a' - 'A'; - } - while (ca == cb && ca != '\0'); + } + } while (ca == cb && ca != '\0'); return ca - cb; } @@ -449,7 +468,7 @@ int rt_strncmp(const char *cs, const char *ct, size_t count) break; } - count --; + count--; } return res; diff --git a/src/klibc/rt_vsnprintf_std.c b/src/klibc/rt_vsnprintf_std.c index 481c99013b..56e2f3eb3f 100644 --- a/src/klibc/rt_vsnprintf_std.c +++ b/src/klibc/rt_vsnprintf_std.c @@ -57,14 +57,14 @@ // 'ntoa' conversion buffer size, this must be big enough to hold one converted // numeric number including padded zeros (dynamically created on stack) #ifndef RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE -#define RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE 32 +#define RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE 32 #endif // size of the fixed (on-stack) buffer for printing individual decimal numbers. // this must be big enough to hold one converted floating-point value including // padded zeros. #ifndef RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE -#define RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE 32 +#define RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE 32 #endif // Support for the decimal notation floating point conversion specifiers (%f, %F) @@ -84,7 +84,7 @@ // Default precision for the floating point conversion specifiers (the C standard sets this at 6) #ifndef RT_KLIBC_USING_VSNPRINTF_FLOAT_PRECISION -#define RT_KLIBC_USING_VSNPRINTF_FLOAT_PRECISION 6 +#define RT_KLIBC_USING_VSNPRINTF_FLOAT_PRECISION 6 #endif // According to the C languages standard, printf() and related functions must be able to print any @@ -124,88 +124,87 @@ #define PRINTF_PREFER_EXPONENTIAL true // The following will convert the number-of-digits into an exponential-notation literal -#define PRINTF_CONCATENATE(s1, s2) s1##s2 +#define PRINTF_CONCATENATE(s1, s2) s1##s2 #define PRINTF_EXPAND_THEN_CONCATENATE(s1, s2) PRINTF_CONCATENATE(s1, s2) -#define PRINTF_FLOAT_NOTATION_THRESHOLD PRINTF_EXPAND_THEN_CONCATENATE(1e,RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL) +#define PRINTF_FLOAT_NOTATION_THRESHOLD PRINTF_EXPAND_THEN_CONCATENATE(1e, RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL) // internal flag definitions -#define FLAGS_ZEROPAD (1U << 0U) -#define FLAGS_LEFT (1U << 1U) -#define FLAGS_PLUS (1U << 2U) -#define FLAGS_SPACE (1U << 3U) -#define FLAGS_HASH (1U << 4U) -#define FLAGS_UPPERCASE (1U << 5U) -#define FLAGS_CHAR (1U << 6U) -#define FLAGS_SHORT (1U << 7U) -#define FLAGS_INT (1U << 8U) +#define FLAGS_ZEROPAD (1U << 0U) +#define FLAGS_LEFT (1U << 1U) +#define FLAGS_PLUS (1U << 2U) +#define FLAGS_SPACE (1U << 3U) +#define FLAGS_HASH (1U << 4U) +#define FLAGS_UPPERCASE (1U << 5U) +#define FLAGS_CHAR (1U << 6U) +#define FLAGS_SHORT (1U << 7U) +#define FLAGS_INT (1U << 8U) // Only used with RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS -#define FLAGS_LONG (1U << 9U) +#define FLAGS_LONG (1U << 9U) #define FLAGS_LONG_LONG (1U << 10U) #define FLAGS_PRECISION (1U << 11U) #define FLAGS_ADAPT_EXP (1U << 12U) #define FLAGS_POINTER (1U << 13U) // Note: Similar, but not identical, effect as FLAGS_HASH -#define FLAGS_SIGNED (1U << 14U) +#define FLAGS_SIGNED (1U << 14U) // Only used with RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS #define FLAGS_INT8 FLAGS_CHAR -#if (SHRT_MAX == 32767LL) -#define FLAGS_INT16 FLAGS_SHORT -#elif (INT_MAX == 32767LL) -#define FLAGS_INT16 FLAGS_INT -#elif (LONG_MAX == 32767LL) -#define FLAGS_INT16 FLAGS_LONG -#elif (LLONG_MAX == 32767LL) -#define FLAGS_INT16 FLAGS_LONG_LONG +#if (SHRT_MAX == 32767LL) +#define FLAGS_INT16 FLAGS_SHORT +#elif (INT_MAX == 32767LL) +#define FLAGS_INT16 FLAGS_INT +#elif (LONG_MAX == 32767LL) +#define FLAGS_INT16 FLAGS_LONG +#elif (LLONG_MAX == 32767LL) +#define FLAGS_INT16 FLAGS_LONG_LONG #else #error "No basic integer type has a size of 16 bits exactly" #endif -#if (SHRT_MAX == 2147483647LL) -#define FLAGS_INT32 FLAGS_SHORT -#elif (INT_MAX == 2147483647LL) -#define FLAGS_INT32 FLAGS_INT -#elif (LONG_MAX == 2147483647LL) -#define FLAGS_INT32 FLAGS_LONG -#elif (LLONG_MAX == 2147483647LL) -#define FLAGS_INT32 FLAGS_LONG_LONG +#if (SHRT_MAX == 2147483647LL) +#define FLAGS_INT32 FLAGS_SHORT +#elif (INT_MAX == 2147483647LL) +#define FLAGS_INT32 FLAGS_INT +#elif (LONG_MAX == 2147483647LL) +#define FLAGS_INT32 FLAGS_LONG +#elif (LLONG_MAX == 2147483647LL) +#define FLAGS_INT32 FLAGS_LONG_LONG #else #error "No basic integer type has a size of 32 bits exactly" #endif -#if (SHRT_MAX == 9223372036854775807LL) -#define FLAGS_INT64 FLAGS_SHORT -#elif (INT_MAX == 9223372036854775807LL) -#define FLAGS_INT64 FLAGS_INT -#elif (LONG_MAX == 9223372036854775807LL) -#define FLAGS_INT64 FLAGS_LONG -#elif (LLONG_MAX == 9223372036854775807LL) -#define FLAGS_INT64 FLAGS_LONG_LONG +#if (SHRT_MAX == 9223372036854775807LL) +#define FLAGS_INT64 FLAGS_SHORT +#elif (INT_MAX == 9223372036854775807LL) +#define FLAGS_INT64 FLAGS_INT +#elif (LONG_MAX == 9223372036854775807LL) +#define FLAGS_INT64 FLAGS_LONG +#elif (LLONG_MAX == 9223372036854775807LL) +#define FLAGS_INT64 FLAGS_LONG_LONG #else #error "No basic integer type has a size of 64 bits exactly" #endif #endif // RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - typedef unsigned int printf_flags_t; -#define BASE_BINARY 2 -#define BASE_OCTAL 8 -#define BASE_DECIMAL 10 -#define BASE_HEX 16 +#define BASE_BINARY 2 +#define BASE_OCTAL 8 +#define BASE_DECIMAL 10 +#define BASE_HEX 16 typedef uint8_t numeric_base_t; #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG typedef unsigned long long printf_unsigned_value_t; -typedef long long printf_signed_value_t; +typedef long long printf_signed_value_t; #else typedef unsigned long printf_unsigned_value_t; -typedef long printf_signed_value_t; +typedef long printf_signed_value_t; #endif // The printf()-family functions return an `int`; it is therefore @@ -215,9 +214,9 @@ typedef long printf_signed_value_t; // of these buffers. instead, we use: typedef unsigned int printf_size_t; #define PRINTF_MAX_POSSIBLE_BUFFER_SIZE INT_MAX - // If we were to nitpick, this would actually be INT_MAX + 1, - // since INT_MAX is the maximum return value, which excludes the - // trailing '\0'. +// If we were to nitpick, this would actually be INT_MAX + 1, +// since INT_MAX is the maximum return value, which excludes the +// trailing '\0'. #if defined(RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS) || defined(RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS) #include <float.h> @@ -230,28 +229,29 @@ typedef unsigned int printf_size_t; #define DOUBLE_SIZE_IN_BITS 32 typedef uint32_t double_uint_t; -#define DOUBLE_EXPONENT_MASK 0xFFU -#define DOUBLE_BASE_EXPONENT 127 +#define DOUBLE_EXPONENT_MASK 0xFFU +#define DOUBLE_BASE_EXPONENT 127 #define DOUBLE_MAX_SUBNORMAL_EXPONENT_OF_10 -38 -#define DOUBLE_MAX_SUBNORMAL_POWER_OF_10 1e-38 +#define DOUBLE_MAX_SUBNORMAL_POWER_OF_10 1e-38 #elif DBL_MANT_DIG == 53 -#define DOUBLE_SIZE_IN_BITS 64 +#define DOUBLE_SIZE_IN_BITS 64 typedef uint64_t double_uint_t; -#define DOUBLE_EXPONENT_MASK 0x7FFU -#define DOUBLE_BASE_EXPONENT 1023 +#define DOUBLE_EXPONENT_MASK 0x7FFU +#define DOUBLE_BASE_EXPONENT 1023 #define DOUBLE_MAX_SUBNORMAL_EXPONENT_OF_10 -308 -#define DOUBLE_MAX_SUBNORMAL_POWER_OF_10 ((double)1e-308L) +#define DOUBLE_MAX_SUBNORMAL_POWER_OF_10 ((double)1e-308L) #else #error "Unsupported double type configuration" #endif #define DOUBLE_STORED_MANTISSA_BITS (DBL_MANT_DIG - 1) -typedef union { - double_uint_t U; - double F; +typedef union +{ + double_uint_t U; + double F; } double_with_bit_access; // This is unnecessary in C99, since compound initializers can be used, @@ -261,33 +261,33 @@ typedef union { // 3. If you try to use it as C++, only C++20 supports compound literals static inline double_with_bit_access get_bit_access(double x) { - double_with_bit_access dwba; - dwba.F = x; - return dwba; + double_with_bit_access dwba; + dwba.F = x; + return dwba; } static inline int get_sign_bit(double x) { - // The sign is stored in the highest bit - return (int) (get_bit_access(x).U >> (DOUBLE_SIZE_IN_BITS - 1)); + // The sign is stored in the highest bit + return (int)(get_bit_access(x).U >> (DOUBLE_SIZE_IN_BITS - 1)); } static inline int get_exp2(double_with_bit_access x) { - // The exponent in an IEEE-754 floating-point number occupies a contiguous - // sequence of bits (e.g. 52..62 for 64-bit doubles), but with a non-trivial representation: An - // unsigned offset from some negative value (with the extremal offset values reserved for - // special use). - return (int)((x.U >> DOUBLE_STORED_MANTISSA_BITS ) & DOUBLE_EXPONENT_MASK) - DOUBLE_BASE_EXPONENT; + // The exponent in an IEEE-754 floating-point number occupies a contiguous + // sequence of bits (e.g. 52..62 for 64-bit doubles), but with a non-trivial representation: An + // unsigned offset from some negative value (with the extremal offset values reserved for + // special use). + return (int)((x.U >> DOUBLE_STORED_MANTISSA_BITS) & DOUBLE_EXPONENT_MASK) - DOUBLE_BASE_EXPONENT; } -#define PRINTF_ABS(_x) ( (_x) > 0 ? (_x) : -(_x) ) +#define PRINTF_ABS(_x) ((_x) > 0 ? (_x) : -(_x)) #endif // (RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS || RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS) // Note in particular the behavior here on LONG_MIN or LLONG_MIN; it is valid // and well-defined, but if you're not careful you can easily trigger undefined // behavior with -LONG_MIN or -LLONG_MIN -#define ABS_FOR_PRINTING(_x) ((printf_unsigned_value_t) ( (_x) > 0 ? (_x) : -((printf_signed_value_t)_x) )) +#define ABS_FOR_PRINTING(_x) ((printf_unsigned_value_t)((_x) > 0 ? (_x) : -((printf_signed_value_t)_x))) // wrapper (used as buffer) for output function type // @@ -297,298 +297,334 @@ static inline int get_exp2(double_with_bit_access x) // 3. function is non-null // // ... otherwise bad things will happen. -typedef struct { - void (*function)(char c, void* extra_arg); - void* extra_function_arg; - char* buffer; - printf_size_t pos; - printf_size_t max_chars; +typedef struct +{ + void (*function)(char c, void *extra_arg); + void *extra_function_arg; + char *buffer; + printf_size_t pos; + printf_size_t max_chars; } output_gadget_t; // Note: This function currently assumes it is not passed a '\0' c, // or alternatively, that '\0' can be passed to the function in the output // gadget. The former assumption holds within the printf library. It also // assumes that the output gadget has been properly initialized. -static inline void putchar_via_gadget(output_gadget_t* gadget, char c) +static inline void putchar_via_gadget(output_gadget_t *gadget, char c) { - printf_size_t write_pos = gadget->pos++; + printf_size_t write_pos = gadget->pos++; // We're _always_ increasing pos, so as to count how may characters // _would_ have been written if not for the max_chars limitation - if (write_pos >= gadget->max_chars) { - return; - } - if (gadget->function != NULL) { - // No check for c == '\0' . - gadget->function(c, gadget->extra_function_arg); - } - else { - // it must be the case that gadget->buffer != NULL , due to the constraint - // on output_gadget_t ; and note we're relying on write_pos being non-negative. - gadget->buffer[write_pos] = c; - } + if (write_pos >= gadget->max_chars) + { + return; + } + if (gadget->function != NULL) + { + // No check for c == '\0' . + gadget->function(c, gadget->extra_function_arg); + } + else + { + // it must be the case that gadget->buffer != NULL , due to the constraint + // on output_gadget_t ; and note we're relying on write_pos being non-negative. + gadget->buffer[write_pos] = c; + } } // Possibly-write the string-terminating '\0' character -static inline void append_termination_with_gadget(output_gadget_t* gadget) +static inline void append_termination_with_gadget(output_gadget_t *gadget) { - if (gadget->function != NULL || gadget->max_chars == 0) { - return; - } - if (gadget->buffer == NULL) { - return; - } - printf_size_t null_char_pos = gadget->pos < gadget->max_chars ? gadget->pos : gadget->max_chars - 1; - gadget->buffer[null_char_pos] = '\0'; + if (gadget->function != NULL || gadget->max_chars == 0) + { + return; + } + if (gadget->buffer == NULL) + { + return; + } + printf_size_t null_char_pos = gadget->pos < gadget->max_chars ? gadget->pos : gadget->max_chars - 1; + gadget->buffer[null_char_pos] = '\0'; } static inline output_gadget_t discarding_gadget(void) { - output_gadget_t gadget; - gadget.function = NULL; - gadget.extra_function_arg = NULL; - gadget.buffer = NULL; - gadget.pos = 0; - gadget.max_chars = 0; - return gadget; + output_gadget_t gadget; + gadget.function = NULL; + gadget.extra_function_arg = NULL; + gadget.buffer = NULL; + gadget.pos = 0; + gadget.max_chars = 0; + return gadget; } -static inline output_gadget_t buffer_gadget(char* buffer, size_t buffer_size) +static inline output_gadget_t buffer_gadget(char *buffer, size_t buffer_size) { - printf_size_t usable_buffer_size = (buffer_size > PRINTF_MAX_POSSIBLE_BUFFER_SIZE) ? - PRINTF_MAX_POSSIBLE_BUFFER_SIZE : (printf_size_t) buffer_size; - output_gadget_t result = discarding_gadget(); - if (buffer != NULL) { - result.buffer = buffer; - result.max_chars = usable_buffer_size; - } - return result; + printf_size_t usable_buffer_size = (buffer_size > PRINTF_MAX_POSSIBLE_BUFFER_SIZE) ? PRINTF_MAX_POSSIBLE_BUFFER_SIZE : (printf_size_t)buffer_size; + output_gadget_t result = discarding_gadget(); + if (buffer != NULL) + { + result.buffer = buffer; + result.max_chars = usable_buffer_size; + } + return result; } // internal secure strlen // @return The length of the string (excluding the terminating 0) limited by 'maxsize' // @note strlen uses size_t, but wes only use this function with printf_size_t // variables - hence the signature. -static inline printf_size_t strnlen_s_(const char* str, printf_size_t maxsize) +static inline printf_size_t strnlen_s_(const char *str, printf_size_t maxsize) { - const char* s; - for (s = str; *s && maxsize--; ++s); - return (printf_size_t)(s - str); + const char *s; + for (s = str; *s && maxsize--; ++s); + return (printf_size_t)(s - str); } - // internal test if char is a digit (0-9) // @return true if char is a digit static inline bool is_digit_(char ch) { - return (ch >= '0') && (ch <= '9'); + return (ch >= '0') && (ch <= '9'); } - // internal ASCII string to printf_size_t conversion -static printf_size_t atou_(const char** str) +static printf_size_t atou_(const char **str) { - printf_size_t i = 0U; - while (is_digit_(**str)) { - i = i * 10U + (printf_size_t)(*((*str)++) - '0'); - } - return i; + printf_size_t i = 0U; + while (is_digit_(**str)) + { + i = i * 10U + (printf_size_t)(*((*str)++) - '0'); + } + return i; } - // output the specified string in reverse, taking care of any zero-padding -static void out_rev_(output_gadget_t* output, const char* buf, printf_size_t len, printf_size_t width, printf_flags_t flags) +static void out_rev_(output_gadget_t *output, const char *buf, printf_size_t len, printf_size_t width, printf_flags_t flags) { - const printf_size_t start_pos = output->pos; + const printf_size_t start_pos = output->pos; - // pad spaces up to given width - if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) { - for (printf_size_t i = len; i < width; i++) { - putchar_via_gadget(output, ' '); + // pad spaces up to given width + if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) + { + for (printf_size_t i = len; i < width; i++) + { + putchar_via_gadget(output, ' '); + } } - } - // reverse string - while (len) { - putchar_via_gadget(output, buf[--len]); - } + // reverse string + while (len) + { + putchar_via_gadget(output, buf[--len]); + } - // append pad spaces up to given width - if (flags & FLAGS_LEFT) { - while (output->pos - start_pos < width) { - putchar_via_gadget(output, ' '); + // append pad spaces up to given width + if (flags & FLAGS_LEFT) + { + while (output->pos - start_pos < width) + { + putchar_via_gadget(output, ' '); + } } - } } - // Invoked by print_integer after the actual number has been printed, performing necessary // work on the number's prefix (as the number is initially printed in reverse order) -static void print_integer_finalization(output_gadget_t* output, char* buf, printf_size_t len, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) +static void print_integer_finalization(output_gadget_t *output, char *buf, printf_size_t len, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) { - printf_size_t unpadded_len = len; + printf_size_t unpadded_len = len; - // pad with leading zeros - { - if (!(flags & FLAGS_LEFT)) { - if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) { - width--; - } - while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) { - buf[len++] = '0'; - } - } + // pad with leading zeros + { + if (!(flags & FLAGS_LEFT)) + { + if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) + { + width--; + } + while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) + { + buf[len++] = '0'; + } + } - while ((len < precision) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) { - buf[len++] = '0'; - } + while ((len < precision) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) + { + buf[len++] = '0'; + } - if (base == BASE_OCTAL && (len > unpadded_len)) { - // Since we've written some zeros, we've satisfied the alternative format leading space requirement - flags &= ~FLAGS_HASH; + if (base == BASE_OCTAL && (len > unpadded_len)) + { + // Since we've written some zeros, we've satisfied the alternative format leading space requirement + flags &= ~FLAGS_HASH; + } } - } - // handle hash - if (flags & (FLAGS_HASH | FLAGS_POINTER)) { - if (!(flags & FLAGS_PRECISION) && len && ((len == precision) || (len == width))) { - // Let's take back some padding digits to fit in what will eventually - // be the format-specific prefix - if (unpadded_len < len) { - len--; // This should suffice for BASE_OCTAL - } - if (len && (base == BASE_HEX || base == BASE_BINARY) && (unpadded_len < len)) { - len--; // ... and an extra one for 0x or 0b - } - } - if ((base == BASE_HEX) && !(flags & FLAGS_UPPERCASE) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) { - buf[len++] = 'x'; - } - else if ((base == BASE_HEX) && (flags & FLAGS_UPPERCASE) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) { - buf[len++] = 'X'; - } - else if ((base == BASE_BINARY) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) { - buf[len++] = 'b'; - } - if (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE) { - buf[len++] = '0'; + // handle hash + if (flags & (FLAGS_HASH | FLAGS_POINTER)) + { + if (!(flags & FLAGS_PRECISION) && len && ((len == precision) || (len == width))) + { + // Let's take back some padding digits to fit in what will eventually + // be the format-specific prefix + if (unpadded_len < len) + { + len--; // This should suffice for BASE_OCTAL + } + if (len && (base == BASE_HEX || base == BASE_BINARY) && (unpadded_len < len)) + { + len--; // ... and an extra one for 0x or 0b + } + } + if ((base == BASE_HEX) && !(flags & FLAGS_UPPERCASE) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) + { + buf[len++] = 'x'; + } + else if ((base == BASE_HEX) && (flags & FLAGS_UPPERCASE) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) + { + buf[len++] = 'X'; + } + else if ((base == BASE_BINARY) && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)) + { + buf[len++] = 'b'; + } + if (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE) + { + buf[len++] = '0'; + } } - } - if (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE) { - if (negative) { - buf[len++] = '-'; - } - else if (flags & FLAGS_PLUS) { - buf[len++] = '+'; // ignore the space if the '+' exists - } - else if (flags & FLAGS_SPACE) { - buf[len++] = ' '; + if (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE) + { + if (negative) + { + buf[len++] = '-'; + } + else if (flags & FLAGS_PLUS) + { + buf[len++] = '+'; // ignore the space if the '+' exists + } + else if (flags & FLAGS_SPACE) + { + buf[len++] = ' '; + } } - } - out_rev_(output, buf, len, width, flags); + out_rev_(output, buf, len, width, flags); } // An internal itoa-like function -static void print_integer(output_gadget_t* output, printf_unsigned_value_t value, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) +static void print_integer(output_gadget_t *output, printf_unsigned_value_t value, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) { - char buf[RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE]; - printf_size_t len = 0U; + char buf[RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE]; + printf_size_t len = 0U; - if (!value) { - if ( !(flags & FLAGS_PRECISION) ) { - buf[len++] = '0'; - flags &= ~FLAGS_HASH; - // We drop this flag this since either the alternative and regular modes of the specifier - // don't differ on 0 values, or (in the case of octal) we've already provided the special - // handling for this mode. + if (!value) + { + if (!(flags & FLAGS_PRECISION)) + { + buf[len++] = '0'; + flags &= ~FLAGS_HASH; + // We drop this flag this since either the alternative and regular modes of the specifier + // don't differ on 0 values, or (in the case of octal) we've already provided the special + // handling for this mode. + } + else if (base == BASE_HEX) + { + flags &= ~FLAGS_HASH; + // We drop this flag this since either the alternative and regular modes of the specifier + // don't differ on 0 values + } } - else if (base == BASE_HEX) { - flags &= ~FLAGS_HASH; - // We drop this flag this since either the alternative and regular modes of the specifier - // don't differ on 0 values + else + { + do + { + const char digit = (char)(value % base); + buf[len++] = (char)(digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10); + value /= base; + } while (value && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)); } - } - else { - do { - const char digit = (char)(value % base); - buf[len++] = (char)(digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10); - value /= base; - } while (value && (len < RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE)); - } - print_integer_finalization(output, buf, len, negative, base, precision, width, flags); + print_integer_finalization(output, buf, len, negative, base, precision, width, flags); } #if defined(RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS) || defined(RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS) // Stores a fixed-precision representation of a double relative // to a fixed precision (which cannot be determined by examining this structure) -struct double_components { - int_fast64_t integral; - int_fast64_t fractional; +struct double_components +{ + int_fast64_t integral; + int_fast64_t fractional; // ... truncation of the actual fractional part of the double value, scaled // by the precision value - bool is_negative; + bool is_negative; }; -#define NUM_DECIMAL_DIGITS_IN_INT64_T 18 -#define PRINTF_MAX_PRECOMPUTED_POWER_OF_10 NUM_DECIMAL_DIGITS_IN_INT64_T +#define NUM_DECIMAL_DIGITS_IN_INT64_T 18 +#define PRINTF_MAX_PRECOMPUTED_POWER_OF_10 NUM_DECIMAL_DIGITS_IN_INT64_T static const double powers_of_10[NUM_DECIMAL_DIGITS_IN_INT64_T] = { - 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, - 1e09, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17 + 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, + 1e09, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17 }; #define PRINTF_MAX_SUPPORTED_PRECISION NUM_DECIMAL_DIGITS_IN_INT64_T - 1 - // Break up a double number - which is known to be a finite non-negative number - // into its base-10 parts: integral - before the decimal point, and fractional - after it. // Taken the precision into account, but does not change it even internally. static struct double_components get_components(double number, printf_size_t precision) { - struct double_components number_; - number_.is_negative = get_sign_bit(number); - double abs_number = (number_.is_negative) ? -number : number; - number_.integral = (int_fast64_t)abs_number; - double remainder = (abs_number - (double) number_.integral) * powers_of_10[precision]; - number_.fractional = (int_fast64_t)remainder; + struct double_components number_; + number_.is_negative = get_sign_bit(number); + double abs_number = (number_.is_negative) ? -number : number; + number_.integral = (int_fast64_t)abs_number; + double remainder = (abs_number - (double)number_.integral) * powers_of_10[precision]; + number_.fractional = (int_fast64_t)remainder; - remainder -= (double) number_.fractional; + remainder -= (double)number_.fractional; - if (remainder > 0.5) { - ++number_.fractional; - // handle rollover, e.g. case 0.99 with precision 1 is 1.0 - if ((double) number_.fractional >= powers_of_10[precision]) { - number_.fractional = 0; - ++number_.integral; + if (remainder > 0.5) + { + ++number_.fractional; + // handle rollover, e.g. case 0.99 with precision 1 is 1.0 + if ((double)number_.fractional >= powers_of_10[precision]) + { + number_.fractional = 0; + ++number_.integral; + } + } + else if ((remainder == 0.5) && ((number_.fractional == 0U) || (number_.fractional & 1U))) + { + // if halfway, round up if odd OR if last digit is 0 + ++number_.fractional; } - } - else if ((remainder == 0.5) && ((number_.fractional == 0U) || (number_.fractional & 1U))) { - // if halfway, round up if odd OR if last digit is 0 - ++number_.fractional; - } - if (precision == 0U) { - remainder = abs_number - (double) number_.integral; - if ((!(remainder < 0.5) || (remainder > 0.5)) && (number_.integral & 1)) { - // exactly 0.5 and ODD, then round up - // 1.5 -> 2, but 2.5 -> 2 - ++number_.integral; + if (precision == 0U) + { + remainder = abs_number - (double)number_.integral; + if ((!(remainder < 0.5) || (remainder > 0.5)) && (number_.integral & 1)) + { + // exactly 0.5 and ODD, then round up + // 1.5 -> 2, but 2.5 -> 2 + ++number_.integral; + } } - } - return number_; + return number_; } #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS -struct scaling_factor { - double raw_factor; - bool multiply; // if true, need to multiply by raw_factor; otherwise need to divide by it +struct scaling_factor +{ + double raw_factor; + bool multiply; // if true, need to multiply by raw_factor; otherwise need to divide by it }; static double apply_scaling(double num, struct scaling_factor normalization) { - return normalization.multiply ? num * normalization.raw_factor : num / normalization.raw_factor; + return normalization.multiply ? num * normalization.raw_factor : num / normalization.raw_factor; } static double unapply_scaling(double normalized, struct scaling_factor normalization) @@ -598,7 +634,7 @@ static double unapply_scaling(double normalized, struct scaling_factor normaliza #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" #endif - return normalization.multiply ? normalized / normalization.raw_factor : normalized * normalization.raw_factor; + return normalization.multiply ? normalized / normalization.raw_factor : normalized * normalization.raw_factor; #if defined(__GNUC__) && !defined(__clang__) && !defined(__ARMCC_VERSION) /* GCC */ #pragma GCC diagnostic pop #endif @@ -606,156 +642,182 @@ static double unapply_scaling(double normalized, struct scaling_factor normaliza static struct scaling_factor update_normalization(struct scaling_factor sf, double extra_multiplicative_factor) { - struct scaling_factor result; - if (sf.multiply) { - result.multiply = true; - result.raw_factor = sf.raw_factor * extra_multiplicative_factor; - } - else { - int factor_exp2 = get_exp2(get_bit_access(sf.raw_factor)); - int extra_factor_exp2 = get_exp2(get_bit_access(extra_multiplicative_factor)); - - // Divide the larger-exponent raw raw_factor by the smaller - if (PRINTF_ABS(factor_exp2) > PRINTF_ABS(extra_factor_exp2)) { - result.multiply = false; - result.raw_factor = sf.raw_factor / extra_multiplicative_factor; + struct scaling_factor result; + if (sf.multiply) + { + result.multiply = true; + result.raw_factor = sf.raw_factor * extra_multiplicative_factor; } - else { - result.multiply = true; - result.raw_factor = extra_multiplicative_factor / sf.raw_factor; + else + { + int factor_exp2 = get_exp2(get_bit_access(sf.raw_factor)); + int extra_factor_exp2 = get_exp2(get_bit_access(extra_multiplicative_factor)); + + // Divide the larger-exponent raw raw_factor by the smaller + if (PRINTF_ABS(factor_exp2) > PRINTF_ABS(extra_factor_exp2)) + { + result.multiply = false; + result.raw_factor = sf.raw_factor / extra_multiplicative_factor; + } + else + { + result.multiply = true; + result.raw_factor = extra_multiplicative_factor / sf.raw_factor; + } } - } - return result; + return result; } static struct double_components get_normalized_components(bool negative, printf_size_t precision, double non_normalized, struct scaling_factor normalization, int floored_exp10) { - struct double_components components; - components.is_negative = negative; - double scaled = apply_scaling(non_normalized, normalization); + struct double_components components; + components.is_negative = negative; + double scaled = apply_scaling(non_normalized, normalization); - bool close_to_representation_extremum = ( (-floored_exp10 + (int) precision) >= DBL_MAX_10_EXP - 1 ); - if (close_to_representation_extremum) { - // We can't have a normalization factor which also accounts for the precision, i.e. moves - // some decimal digits into the mantissa, since it's unrepresentable, or nearly unrepresentable. - // So, we'll give up early on getting extra precision... - return get_components(negative ? -scaled : scaled, precision); - } - components.integral = (int_fast64_t) scaled; - double remainder = non_normalized - unapply_scaling((double) components.integral, normalization); - double prec_power_of_10 = powers_of_10[precision]; - struct scaling_factor account_for_precision = update_normalization(normalization, prec_power_of_10); - double scaled_remainder = apply_scaling(remainder, account_for_precision); - double rounding_threshold = 0.5; + bool close_to_representation_extremum = ((-floored_exp10 + (int)precision) >= DBL_MAX_10_EXP - 1); + if (close_to_representation_extremum) + { + // We can't have a normalization factor which also accounts for the precision, i.e. moves + // some decimal digits into the mantissa, since it's unrepresentable, or nearly unrepresentable. + // So, we'll give up early on getting extra precision... + return get_components(negative ? -scaled : scaled, precision); + } + components.integral = (int_fast64_t)scaled; + double remainder = non_normalized - unapply_scaling((double)components.integral, normalization); + double prec_power_of_10 = powers_of_10[precision]; + struct scaling_factor account_for_precision = update_normalization(normalization, prec_power_of_10); + double scaled_remainder = apply_scaling(remainder, account_for_precision); + double rounding_threshold = 0.5; - components.fractional = (int_fast64_t) scaled_remainder; // when precision == 0, the assigned value should be 0 - scaled_remainder -= (double) components.fractional; //when precision == 0, this will not change scaled_remainder + components.fractional = (int_fast64_t)scaled_remainder; // when precision == 0, the assigned value should be 0 + scaled_remainder -= (double)components.fractional; //when precision == 0, this will not change scaled_remainder - components.fractional += (scaled_remainder >= rounding_threshold); - if (scaled_remainder == rounding_threshold) { - // banker's rounding: Round towards the even number (making the mean error 0) - components.fractional &= ~((int_fast64_t) 0x1); - } - // handle rollover, e.g. the case of 0.99 with precision 1 becoming (0,100), - // and must then be corrected into (1, 0). - // Note: for precision = 0, this will "translate" the rounding effect from - // the fractional part to the integral part where it should actually be - // felt (as prec_power_of_10 is 1) - if ((double) components.fractional >= prec_power_of_10) { - components.fractional = 0; - ++components.integral; - } - return components; + components.fractional += (scaled_remainder >= rounding_threshold); + if (scaled_remainder == rounding_threshold) + { + // banker's rounding: Round towards the even number (making the mean error 0) + components.fractional &= ~((int_fast64_t)0x1); + } + // handle rollover, e.g. the case of 0.99 with precision 1 becoming (0,100), + // and must then be corrected into (1, 0). + // Note: for precision = 0, this will "translate" the rounding effect from + // the fractional part to the integral part where it should actually be + // felt (as prec_power_of_10 is 1) + if ((double)components.fractional >= prec_power_of_10) + { + components.fractional = 0; + ++components.integral; + } + return components; } #endif // RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS static void print_broken_up_decimal( - struct double_components number_, output_gadget_t* output, printf_size_t precision, - printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len) + struct double_components number_, output_gadget_t *output, printf_size_t precision, + printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len) { - if (precision != 0U) { - // do fractional part, as an unsigned number + if (precision != 0U) + { + // do fractional part, as an unsigned number - printf_size_t count = precision; + printf_size_t count = precision; - // %g/%G mandates we skip the trailing 0 digits... - if ((flags & FLAGS_ADAPT_EXP) && !(flags & FLAGS_HASH) && (number_.fractional > 0)) { - while(true) { - int_fast64_t digit = number_.fractional % 10U; - if (digit != 0) { - break; + // %g/%G mandates we skip the trailing 0 digits... + if ((flags & FLAGS_ADAPT_EXP) && !(flags & FLAGS_HASH) && (number_.fractional > 0)) + { + while (true) + { + int_fast64_t digit = number_.fractional % 10U; + if (digit != 0) + { + break; + } + --count; + number_.fractional /= 10U; + } + // ... and even the decimal point if there are no + // non-zero fractional part digits (see below) } - --count; - number_.fractional /= 10U; - } - // ... and even the decimal point if there are no - // non-zero fractional part digits (see below) - } - - if (number_.fractional > 0 || !(flags & FLAGS_ADAPT_EXP) || (flags & FLAGS_HASH) ) { - while (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) { - --count; - buf[len++] = (char)('0' + number_.fractional % 10U); - if (!(number_.fractional /= 10U)) { - break; + if (number_.fractional > 0 || !(flags & FLAGS_ADAPT_EXP) || (flags & FLAGS_HASH)) + { + while (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) + { + --count; + buf[len++] = (char)('0' + number_.fractional % 10U); + if (!(number_.fractional /= 10U)) + { + break; + } + } + // add extra 0s + while ((len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) && (count > 0U)) + { + buf[len++] = '0'; + --count; + } + if (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) + { + buf[len++] = '.'; + } } - } - // add extra 0s - while ((len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) && (count > 0U)) { - buf[len++] = '0'; - --count; - } - if (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) { - buf[len++] = '.'; - } } - } - else { - if ((flags & FLAGS_HASH) && (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE)) { - buf[len++] = '.'; + else + { + if ((flags & FLAGS_HASH) && (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE)) + { + buf[len++] = '.'; + } } - } - // Write the integer part of the number (it comes after the fractional - // since the character order is reversed) - while (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) { - buf[len++] = (char)('0' + (number_.integral % 10)); - if (!(number_.integral /= 10)) { - break; + // Write the integer part of the number (it comes after the fractional + // since the character order is reversed) + while (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) + { + buf[len++] = (char)('0' + (number_.integral % 10)); + if (!(number_.integral /= 10)) + { + break; + } } - } - // pad leading zeros - if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) { - if (width && (number_.is_negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) { - width--; - } - while ((len < width) && (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE)) { - buf[len++] = '0'; + // pad leading zeros + if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) + { + if (width && (number_.is_negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) + { + width--; + } + while ((len < width) && (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE)) + { + buf[len++] = '0'; + } } - } - if (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) { - if (number_.is_negative) { - buf[len++] = '-'; - } - else if (flags & FLAGS_PLUS) { - buf[len++] = '+'; // ignore the space if the '+' exists - } - else if (flags & FLAGS_SPACE) { - buf[len++] = ' '; + if (len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) + { + if (number_.is_negative) + { + buf[len++] = '-'; + } + else if (flags & FLAGS_PLUS) + { + buf[len++] = '+'; // ignore the space if the '+' exists + } + else if (flags & FLAGS_SPACE) + { + buf[len++] = ' '; + } } - } - out_rev_(output, buf, len, width, flags); + out_rev_(output, buf, len, width, flags); } - // internal ftoa for fixed decimal floating point -static void print_decimal_number(output_gadget_t* output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char* buf, printf_size_t len) +// internal ftoa for fixed decimal floating point +static void print_decimal_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len) { - struct double_components value_ = get_components(number, precision); - print_broken_up_decimal(value_, output, precision, width, flags, buf, len); + struct double_components value_ = get_components(number, precision); + print_broken_up_decimal(value_, output, precision, width, flags, buf, len); } #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS @@ -764,570 +826,692 @@ static void print_decimal_number(output_gadget_t* output, double number, printf_ // floor value is representable by an int. static int bastardized_floor(double x) { - if (x >= 0) { return (int) x; } - int n = (int) x; - return ( ((double) n) == x ) ? n : n-1; + if (x >= 0) + { + return (int)x; + } + int n = (int)x; + return (((double)n) == x) ? n : n - 1; } // Computes the base-10 logarithm of the input number - which must be an actual // positive number (not infinity or NaN, nor a sub-normal) static double log10_of_positive(double positive_number) { - // The implementation follows David Gay (https://www.ampl.com/netlib/fp/dtoa.c). - // - // Since log_10 ( M * 2^x ) = log_10(M) + x , we can separate the components of - // our input number, and need only solve log_10(M) for M between 1 and 2 (as - // the base-2 mantissa is always 1-point-something). In that limited range, a - // Taylor series expansion of log10(x) should serve us well enough; and we'll - // take the mid-point, 1.5, as the point of expansion. + // The implementation follows David Gay (https://www.ampl.com/netlib/fp/dtoa.c). + // + // Since log_10 ( M * 2^x ) = log_10(M) + x , we can separate the components of + // our input number, and need only solve log_10(M) for M between 1 and 2 (as + // the base-2 mantissa is always 1-point-something). In that limited range, a + // Taylor series expansion of log10(x) should serve us well enough; and we'll + // take the mid-point, 1.5, as the point of expansion. - double_with_bit_access dwba = get_bit_access(positive_number); - // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c) - int exp2 = get_exp2(dwba); - // drop the exponent, so dwba.F comes into the range [1,2) - dwba.U = (dwba.U & (((double_uint_t) (1) << DOUBLE_STORED_MANTISSA_BITS) - 1U)) | - ((double_uint_t) DOUBLE_BASE_EXPONENT << DOUBLE_STORED_MANTISSA_BITS); - double z = (dwba.F - 1.5); - return ( - // Taylor expansion around 1.5: - 0.1760912590556812420 // Expansion term 0: ln(1.5) / ln(10) - + z * 0.2895296546021678851 // Expansion term 1: (M - 1.5) * 2/3 / ln(10) + double_with_bit_access dwba = get_bit_access(positive_number); + // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c) + int exp2 = get_exp2(dwba); + // drop the exponent, so dwba.F comes into the range [1,2) + dwba.U = (dwba.U & (((double_uint_t)(1) << DOUBLE_STORED_MANTISSA_BITS) - 1U)) | + ((double_uint_t)DOUBLE_BASE_EXPONENT << DOUBLE_STORED_MANTISSA_BITS); + double z = (dwba.F - 1.5); + return ( + // Taylor expansion around 1.5: + 0.1760912590556812420 // Expansion term 0: ln(1.5) / ln(10) + + z * 0.2895296546021678851 // Expansion term 1: (M - 1.5) * 2/3 / ln(10) #if RT_KLIBC_USING_VSNPRINTF_LOG10_TAYLOR_TERMS > 2 - - z*z * 0.0965098848673892950 // Expansion term 2: (M - 1.5)^2 * 2/9 / ln(10) + - z * z * 0.0965098848673892950 // Expansion term 2: (M - 1.5)^2 * 2/9 / ln(10) #if RT_KLIBC_USING_VSNPRINTF_LOG10_TAYLOR_TERMS > 3 - + z*z*z * 0.0428932821632841311 // Expansion term 2: (M - 1.5)^3 * 8/81 / ln(10) + + z * z * z * 0.0428932821632841311 // Expansion term 2: (M - 1.5)^3 * 8/81 / ln(10) #endif #endif - // exact log_2 of the exponent x, with logarithm base change - + exp2 * 0.30102999566398119521 // = exp2 * log_10(2) = exp2 * ln(2)/ln(10) - ); + // exact log_2 of the exponent x, with logarithm base change + + exp2 * 0.30102999566398119521 // = exp2 * log_10(2) = exp2 * ln(2)/ln(10) + ); } - static double pow10_of_int(int floored_exp10) { - // A crude hack for avoiding undesired behavior with barely-normal or slightly-subnormal values. - if (floored_exp10 == DOUBLE_MAX_SUBNORMAL_EXPONENT_OF_10) { - return DOUBLE_MAX_SUBNORMAL_POWER_OF_10; - } - // Compute 10^(floored_exp10) but (try to) make sure that doesn't overflow - double_with_bit_access dwba; - int exp2 = bastardized_floor(floored_exp10 * 3.321928094887362 + 0.5); - const double z = floored_exp10 * 2.302585092994046 - exp2 * 0.6931471805599453; - const double z2 = z * z; - dwba.U = ((double_uint_t)(exp2) + DOUBLE_BASE_EXPONENT) << DOUBLE_STORED_MANTISSA_BITS; - // compute exp(z) using continued fractions, - // see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex - dwba.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14))))); - return dwba.F; + // A crude hack for avoiding undesired behavior with barely-normal or slightly-subnormal values. + if (floored_exp10 == DOUBLE_MAX_SUBNORMAL_EXPONENT_OF_10) + { + return DOUBLE_MAX_SUBNORMAL_POWER_OF_10; + } + // Compute 10^(floored_exp10) but (try to) make sure that doesn't overflow + double_with_bit_access dwba; + int exp2 = bastardized_floor(floored_exp10 * 3.321928094887362 + 0.5); + const double z = floored_exp10 * 2.302585092994046 - exp2 * 0.6931471805599453; + const double z2 = z * z; + dwba.U = ((double_uint_t)(exp2) + DOUBLE_BASE_EXPONENT) << DOUBLE_STORED_MANTISSA_BITS; + // compute exp(z) using continued fractions, + // see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex + dwba.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14))))); + return dwba.F; } -static void print_exponential_number(output_gadget_t* output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char* buf, printf_size_t len) +static void print_exponential_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len) { - const bool negative = get_sign_bit(number); - // This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it - double abs_number = negative ? -number : number; - - int floored_exp10; - bool abs_exp10_covered_by_powers_table; - struct scaling_factor normalization; + const bool negative = get_sign_bit(number); + // This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it + double abs_number = negative ? -number : number; + int floored_exp10; + bool abs_exp10_covered_by_powers_table; + struct scaling_factor normalization; - // Determine the decimal exponent - if (abs_number == 0.0) { - // TODO: This is a special-case for 0.0 (and -0.0); but proper handling is required for denormals more generally. - floored_exp10 = 0; // ... and no need to set a normalization factor or check the powers table - } - else { - double exp10 = log10_of_positive(abs_number); - floored_exp10 = bastardized_floor(exp10); - double p10 = pow10_of_int(floored_exp10); - // correct for rounding errors - if (abs_number < p10) { - floored_exp10--; - p10 /= 10; + // Determine the decimal exponent + if (abs_number == 0.0) + { + // TODO: This is a special-case for 0.0 (and -0.0); but proper handling is required for denormals more generally. + floored_exp10 = 0; // ... and no need to set a normalization factor or check the powers table + } + else + { + double exp10 = log10_of_positive(abs_number); + floored_exp10 = bastardized_floor(exp10); + double p10 = pow10_of_int(floored_exp10); + // correct for rounding errors + if (abs_number < p10) + { + floored_exp10--; + p10 /= 10; + } + abs_exp10_covered_by_powers_table = PRINTF_ABS(floored_exp10) < PRINTF_MAX_PRECOMPUTED_POWER_OF_10; + normalization.raw_factor = abs_exp10_covered_by_powers_table ? powers_of_10[PRINTF_ABS(floored_exp10)] : p10; } - abs_exp10_covered_by_powers_table = PRINTF_ABS(floored_exp10) < PRINTF_MAX_PRECOMPUTED_POWER_OF_10; - normalization.raw_factor = abs_exp10_covered_by_powers_table ? powers_of_10[PRINTF_ABS(floored_exp10)] : p10; - } - // We now begin accounting for the widths of the two parts of our printed field: - // the decimal part after decimal exponent extraction, and the base-10 exponent part. - // For both of these, the value of 0 has a special meaning, but not the same one: - // a 0 exponent-part width means "don't print the exponent"; a 0 decimal-part width - // means "use as many characters as necessary". + // We now begin accounting for the widths of the two parts of our printed field: + // the decimal part after decimal exponent extraction, and the base-10 exponent part. + // For both of these, the value of 0 has a special meaning, but not the same one: + // a 0 exponent-part width means "don't print the exponent"; a 0 decimal-part width + // means "use as many characters as necessary". - bool fall_back_to_decimal_only_mode = false; - if (flags & FLAGS_ADAPT_EXP) { - int required_significant_digits = (precision == 0) ? 1 : (int) precision; - // Should we want to fall-back to "%f" mode, and only print the decimal part? - fall_back_to_decimal_only_mode = (floored_exp10 >= -4 && floored_exp10 < required_significant_digits); - // Now, let's adjust the precision - // This also decided how we adjust the precision value - as in "%g" mode, - // "precision" is the number of _significant digits_, and this is when we "translate" - // the precision value to an actual number of decimal digits. - int precision_ = fall_back_to_decimal_only_mode ? - (int) precision - 1 - floored_exp10 : - (int) precision - 1; // the presence of the exponent ensures only one significant digit comes before the decimal point - precision = (precision_ > 0 ? (unsigned) precision_ : 0U); - flags |= FLAGS_PRECISION; // make sure print_broken_up_decimal respects our choice above - } + bool fall_back_to_decimal_only_mode = false; + if (flags & FLAGS_ADAPT_EXP) + { + int required_significant_digits = (precision == 0) ? 1 : (int)precision; + // Should we want to fall-back to "%f" mode, and only print the decimal part? + fall_back_to_decimal_only_mode = (floored_exp10 >= -4 && floored_exp10 < required_significant_digits); + // Now, let's adjust the precision + // This also decided how we adjust the precision value - as in "%g" mode, + // "precision" is the number of _significant digits_, and this is when we "translate" + // the precision value to an actual number of decimal digits. + int precision_ = fall_back_to_decimal_only_mode ? (int)precision - 1 - floored_exp10 : (int)precision - 1; // the presence of the exponent ensures only one significant digit comes before the decimal point + precision = (precision_ > 0 ? (unsigned)precision_ : 0U); + flags |= FLAGS_PRECISION; // make sure print_broken_up_decimal respects our choice above + } - normalization.multiply = (floored_exp10 < 0 && abs_exp10_covered_by_powers_table); - bool should_skip_normalization = (fall_back_to_decimal_only_mode || floored_exp10 == 0); - struct double_components decimal_part_components = - should_skip_normalization ? - get_components(negative ? -abs_number : abs_number, precision) : - get_normalized_components(negative, precision, abs_number, normalization, floored_exp10); + normalization.multiply = (floored_exp10 < 0 && abs_exp10_covered_by_powers_table); + bool should_skip_normalization = (fall_back_to_decimal_only_mode || floored_exp10 == 0); + struct double_components decimal_part_components = + should_skip_normalization ? get_components(negative ? -abs_number : abs_number, precision) : get_normalized_components(negative, precision, abs_number, normalization, floored_exp10); - // Account for roll-over, e.g. rounding from 9.99 to 100.0 - which effects - // the exponent and may require additional tweaking of the parts - if (fall_back_to_decimal_only_mode) { - if ((flags & FLAGS_ADAPT_EXP) && floored_exp10 >= -1 && decimal_part_components.integral == powers_of_10[floored_exp10 + 1]) { - floored_exp10++; // Not strictly necessary, since floored_exp10 is no longer really used - precision--; - // ... and it should already be the case that decimal_part_components.fractional == 0 + // Account for roll-over, e.g. rounding from 9.99 to 100.0 - which effects + // the exponent and may require additional tweaking of the parts + if (fall_back_to_decimal_only_mode) + { + if ((flags & FLAGS_ADAPT_EXP) && floored_exp10 >= -1 && decimal_part_components.integral == powers_of_10[floored_exp10 + 1]) + { + floored_exp10++; // Not strictly necessary, since floored_exp10 is no longer really used + precision--; + // ... and it should already be the case that decimal_part_components.fractional == 0 + } + // TODO: What about rollover strictly within the fractional part? } - // TODO: What about rollover strictly within the fractional part? - } - else { - if (decimal_part_components.integral >= 10) { - floored_exp10++; - decimal_part_components.integral = 1; - decimal_part_components.fractional = 0; + else + { + if (decimal_part_components.integral >= 10) + { + floored_exp10++; + decimal_part_components.integral = 1; + decimal_part_components.fractional = 0; + } } - } - // the floored_exp10 format is "E%+03d" and largest possible floored_exp10 value for a 64-bit double - // is "307" (for 2^1023), so we set aside 4-5 characters overall - printf_size_t exp10_part_width = fall_back_to_decimal_only_mode ? 0U : (PRINTF_ABS(floored_exp10) < 100) ? 4U : 5U; + // the floored_exp10 format is "E%+03d" and largest possible floored_exp10 value for a 64-bit double + // is "307" (for 2^1023), so we set aside 4-5 characters overall + printf_size_t exp10_part_width = fall_back_to_decimal_only_mode ? 0U : (PRINTF_ABS(floored_exp10) < 100) ? 4U + : 5U; - printf_size_t decimal_part_width = - ((flags & FLAGS_LEFT) && exp10_part_width) ? - // We're padding on the right, so the width constraint is the exponent part's - // problem, not the decimal part's, so we'll use as many characters as we need: - 0U : - // We're padding on the left; so the width constraint is the decimal part's - // problem. Well, can both the decimal part and the exponent part fit within our overall width? - ((width > exp10_part_width) ? - // Yes, so we limit our decimal part's width. - // (Note this is trivially valid even if we've fallen back to "%f" mode) - width - exp10_part_width : - // No; we just give up on any restriction on the decimal part and use as many - // characters as we need - 0U); + printf_size_t decimal_part_width = + ((flags & FLAGS_LEFT) && exp10_part_width) ? + // We're padding on the right, so the width constraint is the exponent part's + // problem, not the decimal part's, so we'll use as many characters as we need: + 0U + : + // We're padding on the left; so the width constraint is the decimal part's + // problem. Well, can both the decimal part and the exponent part fit within our overall width? + ((width > exp10_part_width) ? + // Yes, so we limit our decimal part's width. + // (Note this is trivially valid even if we've fallen back to "%f" mode) + width - exp10_part_width + : + // No; we just give up on any restriction on the decimal part and use as many + // characters as we need + 0U); - const printf_size_t printed_exponential_start_pos = output->pos; - print_broken_up_decimal(decimal_part_components, output, precision, decimal_part_width, flags, buf, len); + const printf_size_t printed_exponential_start_pos = output->pos; + print_broken_up_decimal(decimal_part_components, output, precision, decimal_part_width, flags, buf, len); - if (! fall_back_to_decimal_only_mode) { - putchar_via_gadget(output, (flags & FLAGS_UPPERCASE) ? 'E' : 'e'); - print_integer(output, - ABS_FOR_PRINTING(floored_exp10), - floored_exp10 < 0, 10, 0, exp10_part_width - 1, - FLAGS_ZEROPAD | FLAGS_PLUS); - if (flags & FLAGS_LEFT) { - // We need to right-pad with spaces to meet the width requirement - while (output->pos - printed_exponential_start_pos < width) { - putchar_via_gadget(output, ' '); - } + if (!fall_back_to_decimal_only_mode) + { + putchar_via_gadget(output, (flags & FLAGS_UPPERCASE) ? 'E' : 'e'); + print_integer(output, + ABS_FOR_PRINTING(floored_exp10), + floored_exp10 < 0, 10, 0, exp10_part_width - 1, + FLAGS_ZEROPAD | FLAGS_PLUS); + if (flags & FLAGS_LEFT) + { + // We need to right-pad with spaces to meet the width requirement + while (output->pos - printed_exponential_start_pos < width) + { + putchar_via_gadget(output, ' '); + } + } } - } } -#endif // RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS +#endif // RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS -static void print_floating_point(output_gadget_t* output, double value, printf_size_t precision, printf_size_t width, printf_flags_t flags, bool prefer_exponential) +static void print_floating_point(output_gadget_t *output, double value, printf_size_t precision, printf_size_t width, printf_flags_t flags, bool prefer_exponential) { - char buf[RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE]; - printf_size_t len = 0U; + char buf[RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE]; + printf_size_t len = 0U; - // test for special values - if (value != value) { - out_rev_(output, "nan", 3, width, flags); - return; - } - if (value < -DBL_MAX) { - out_rev_(output, "fni-", 4, width, flags); - return; - } - if (value > DBL_MAX) { - out_rev_(output, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags); - return; - } + // test for special values + if (value != value) + { + out_rev_(output, "nan", 3, width, flags); + return; + } + if (value < -DBL_MAX) + { + out_rev_(output, "fni-", 4, width, flags); + return; + } + if (value > DBL_MAX) + { + out_rev_(output, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags); + return; + } - if (!prefer_exponential && - ((value > PRINTF_FLOAT_NOTATION_THRESHOLD) || (value < -PRINTF_FLOAT_NOTATION_THRESHOLD))) { - // The required behavior of standard printf is to print _every_ integral-part digit -- which could mean - // printing hundreds of characters, overflowing any fixed internal buffer and necessitating a more complicated - // implementation. + if (!prefer_exponential && + ((value > PRINTF_FLOAT_NOTATION_THRESHOLD) || (value < -PRINTF_FLOAT_NOTATION_THRESHOLD))) + { + // The required behavior of standard printf is to print _every_ integral-part digit -- which could mean + // printing hundreds of characters, overflowing any fixed internal buffer and necessitating a more complicated + // implementation. #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - print_exponential_number(output, value, precision, width, flags, buf, len); + print_exponential_number(output, value, precision, width, flags, buf, len); #endif - return; - } + return; + } - // set default precision, if not set explicitly - if (!(flags & FLAGS_PRECISION)) { - precision = RT_KLIBC_USING_VSNPRINTF_FLOAT_PRECISION; - } + // set default precision, if not set explicitly + if (!(flags & FLAGS_PRECISION)) + { + precision = RT_KLIBC_USING_VSNPRINTF_FLOAT_PRECISION; + } - // limit precision so that our integer holding the fractional part does not overflow - while ((len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) && (precision > PRINTF_MAX_SUPPORTED_PRECISION)) { - buf[len++] = '0'; // This respects the precision in terms of result length only - precision--; - } + // limit precision so that our integer holding the fractional part does not overflow + while ((len < RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE) && (precision > PRINTF_MAX_SUPPORTED_PRECISION)) + { + buf[len++] = '0'; // This respects the precision in terms of result length only + precision--; + } #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - if (prefer_exponential) - print_exponential_number(output, value, precision, width, flags, buf, len); - else + if (prefer_exponential) + { + print_exponential_number(output, value, precision, width, flags, buf, len); + } + else #endif - print_decimal_number(output, value, precision, width, flags, buf, len); + print_decimal_number(output, value, precision, width, flags, buf, len); } -#endif // (RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS || RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS) +#endif // (RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS || RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS) // Advances the format pointer past the flags, and returns the parsed flags // due to the characters passed -static printf_flags_t parse_flags(const char** format) +static printf_flags_t parse_flags(const char **format) { - printf_flags_t flags = 0U; - do { - switch (**format) { - case '0': flags |= FLAGS_ZEROPAD; (*format)++; break; - case '-': flags |= FLAGS_LEFT; (*format)++; break; - case '+': flags |= FLAGS_PLUS; (*format)++; break; - case ' ': flags |= FLAGS_SPACE; (*format)++; break; - case '#': flags |= FLAGS_HASH; (*format)++; break; - default : return flags; - } - } while (true); + printf_flags_t flags = 0U; + do + { + switch (**format) + { + case '0': + flags |= FLAGS_ZEROPAD; + (*format)++; + break; + case '-': + flags |= FLAGS_LEFT; + (*format)++; + break; + case '+': + flags |= FLAGS_PLUS; + (*format)++; + break; + case ' ': + flags |= FLAGS_SPACE; + (*format)++; + break; + case '#': + flags |= FLAGS_HASH; + (*format)++; + break; + default: + return flags; + } + } while (true); } -static inline void format_string_loop(output_gadget_t* output, const char* format, va_list args) +static inline void format_string_loop(output_gadget_t *output, const char *format, va_list args) { #ifdef RT_KLIBC_USING_VSNPRINTF_CHECK_NUL_IN_FORMAT_SPECIFIER -#define ADVANCE_IN_FORMAT_STRING(cptr_) do { (cptr_)++; if (!*(cptr_)) return; } while(0) +#define ADVANCE_IN_FORMAT_STRING(cptr_) \ + do \ + { \ + (cptr_)++; \ + if (!*(cptr_)) \ + return; \ + } while (0) #else #define ADVANCE_IN_FORMAT_STRING(cptr_) (cptr_)++ #endif + while (*format) + { + if (*format != '%') + { + // A regular content character + putchar_via_gadget(output, *format); + format++; + continue; + } + // We're parsing a format specifier: %[flags][width][.precision][length] + ADVANCE_IN_FORMAT_STRING(format); - while (*format) - { - if (*format != '%') { - // A regular content character - putchar_via_gadget(output, *format); - format++; - continue; - } - // We're parsing a format specifier: %[flags][width][.precision][length] - ADVANCE_IN_FORMAT_STRING(format); - - printf_flags_t flags = parse_flags(&format); + printf_flags_t flags = parse_flags(&format); - // evaluate width field - printf_size_t width = 0U; - if (is_digit_(*format)) { - width = (printf_size_t) atou_(&format); - } - else if (*format == '*') { - const int w = va_arg(args, int); - if (w < 0) { - flags |= FLAGS_LEFT; // reverse padding - width = (printf_size_t)-w; - } - else { - width = (printf_size_t)w; - } - ADVANCE_IN_FORMAT_STRING(format); - } + // evaluate width field + printf_size_t width = 0U; + if (is_digit_(*format)) + { + width = (printf_size_t)atou_(&format); + } + else if (*format == '*') + { + const int w = va_arg(args, int); + if (w < 0) + { + flags |= FLAGS_LEFT; // reverse padding + width = (printf_size_t)-w; + } + else + { + width = (printf_size_t)w; + } + ADVANCE_IN_FORMAT_STRING(format); + } - // evaluate precision field - printf_size_t precision = 0U; - if (*format == '.') { - flags |= FLAGS_PRECISION; - ADVANCE_IN_FORMAT_STRING(format); - if (is_digit_(*format)) { - precision = (printf_size_t) atou_(&format); - } - else if (*format == '*') { - const int precision_ = va_arg(args, int); - precision = precision_ > 0 ? (printf_size_t) precision_ : 0U; - ADVANCE_IN_FORMAT_STRING(format); - } - } + // evaluate precision field + printf_size_t precision = 0U; + if (*format == '.') + { + flags |= FLAGS_PRECISION; + ADVANCE_IN_FORMAT_STRING(format); + if (is_digit_(*format)) + { + precision = (printf_size_t)atou_(&format); + } + else if (*format == '*') + { + const int precision_ = va_arg(args, int); + precision = precision_ > 0 ? (printf_size_t)precision_ : 0U; + ADVANCE_IN_FORMAT_STRING(format); + } + } - // evaluate length field - switch (*format) { + // evaluate length field + switch (*format) + { #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - case 'I' : { - ADVANCE_IN_FORMAT_STRING(format); - // Greedily parse for size in bits: 8, 16, 32 or 64 - switch(*format) { - case '8': flags |= FLAGS_INT8; + case 'I': + { ADVANCE_IN_FORMAT_STRING(format); + // Greedily parse for size in bits: 8, 16, 32 or 64 + switch (*format) + { + case '8': + flags |= FLAGS_INT8; + ADVANCE_IN_FORMAT_STRING(format); + break; + case '1': + ADVANCE_IN_FORMAT_STRING(format); + if (*format == '6') + { + format++; + flags |= FLAGS_INT16; + } + break; + case '3': + ADVANCE_IN_FORMAT_STRING(format); + if (*format == '2') + { + ADVANCE_IN_FORMAT_STRING(format); + flags |= FLAGS_INT32; + } + break; + case '6': + ADVANCE_IN_FORMAT_STRING(format); + if (*format == '4') + { + ADVANCE_IN_FORMAT_STRING(format); + flags |= FLAGS_INT64; + } + break; + default: + break; + } break; - case '1': + } +#endif + case 'l': + flags |= FLAGS_LONG; ADVANCE_IN_FORMAT_STRING(format); - if (*format == '6') { format++; flags |= FLAGS_INT16; } + if (*format == 'l') + { + flags |= FLAGS_LONG_LONG; + ADVANCE_IN_FORMAT_STRING(format); + } break; - case '3': + case 'h': + flags |= FLAGS_SHORT; ADVANCE_IN_FORMAT_STRING(format); - if (*format == '2') { ADVANCE_IN_FORMAT_STRING(format); flags |= FLAGS_INT32; } + if (*format == 'h') + { + flags |= FLAGS_CHAR; + ADVANCE_IN_FORMAT_STRING(format); + } break; - case '6': + case 't': + flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); ADVANCE_IN_FORMAT_STRING(format); - if (*format == '4') { ADVANCE_IN_FORMAT_STRING(format); flags |= FLAGS_INT64; } break; - default: break; - } - break; - } -#endif - case 'l' : - flags |= FLAGS_LONG; - ADVANCE_IN_FORMAT_STRING(format); - if (*format == 'l') { - flags |= FLAGS_LONG_LONG; - ADVANCE_IN_FORMAT_STRING(format); - } - break; - case 'h' : - flags |= FLAGS_SHORT; - ADVANCE_IN_FORMAT_STRING(format); - if (*format == 'h') { - flags |= FLAGS_CHAR; - ADVANCE_IN_FORMAT_STRING(format); + case 'j': + flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); + ADVANCE_IN_FORMAT_STRING(format); + break; + case 'z': + flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); + ADVANCE_IN_FORMAT_STRING(format); + break; + default: + break; } - break; - case 't' : - flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); - ADVANCE_IN_FORMAT_STRING(format); - break; - case 'j' : - flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); - ADVANCE_IN_FORMAT_STRING(format); - break; - case 'z' : - flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG); - ADVANCE_IN_FORMAT_STRING(format); - break; - default: - break; - } - // evaluate specifier - switch (*format) { - case 'd' : - case 'i' : - case 'u' : - case 'x' : - case 'X' : - case 'o' : - case 'b' : { - - if (*format == 'd' || *format == 'i') { - flags |= FLAGS_SIGNED; - } + // evaluate specifier + switch (*format) + { + case 'd': + case 'i': + case 'u': + case 'x': + case 'X': + case 'o': + case 'b': + { + if (*format == 'd' || *format == 'i') + { + flags |= FLAGS_SIGNED; + } - numeric_base_t base; - if (*format == 'x' || *format == 'X') { - base = BASE_HEX; - } - else if (*format == 'o') { - base = BASE_OCTAL; - } - else if (*format == 'b') { - base = BASE_BINARY; - } - else { - base = BASE_DECIMAL; - flags &= ~FLAGS_HASH; // decimal integers have no alternative presentation - } + numeric_base_t base; + if (*format == 'x' || *format == 'X') + { + base = BASE_HEX; + } + else if (*format == 'o') + { + base = BASE_OCTAL; + } + else if (*format == 'b') + { + base = BASE_BINARY; + } + else + { + base = BASE_DECIMAL; + flags &= ~FLAGS_HASH; // decimal integers have no alternative presentation + } - if (*format == 'X') { - flags |= FLAGS_UPPERCASE; - } + if (*format == 'X') + { + flags |= FLAGS_UPPERCASE; + } - format++; - // ignore '0' flag when precision is given - if (flags & FLAGS_PRECISION) { - flags &= ~FLAGS_ZEROPAD; - } + format++; + // ignore '0' flag when precision is given + if (flags & FLAGS_PRECISION) + { + flags &= ~FLAGS_ZEROPAD; + } - if (flags & FLAGS_SIGNED) { - // A signed specifier: d, i or possibly I + bit size if enabled + if (flags & FLAGS_SIGNED) + { + // A signed specifier: d, i or possibly I + bit size if enabled - if (flags & FLAGS_LONG_LONG) { + if (flags & FLAGS_LONG_LONG) + { #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - const long long value = va_arg(args, long long); - print_integer(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags); + const long long value = va_arg(args, long long); + print_integer(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags); #endif - } - else if (flags & FLAGS_LONG) { - const long value = va_arg(args, long); - print_integer(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags); - } - else { - // We never try to interpret the argument as something potentially-smaller than int, - // due to integer promotion rules: Even if the user passed a short int, short unsigned - // etc. - these will come in after promotion, as int's (or unsigned for the case of - // short unsigned when it has the same size as int) - const int value = - (flags & FLAGS_CHAR) ? (signed char) va_arg(args, int) : - (flags & FLAGS_SHORT) ? (short int) va_arg(args, int) : - va_arg(args, int); - print_integer(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags); - } - } - else { - // An unsigned specifier: u, x, X, o, b + } + else if (flags & FLAGS_LONG) + { + const long value = va_arg(args, long); + print_integer(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags); + } + else + { + // We never try to interpret the argument as something potentially-smaller than int, + // due to integer promotion rules: Even if the user passed a short int, short unsigned + // etc. - these will come in after promotion, as int's (or unsigned for the case of + // short unsigned when it has the same size as int) + const int value = + (flags & FLAGS_CHAR) ? (signed char)va_arg(args, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(args, int) + : va_arg(args, int); + print_integer(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags); + } + } + else + { + // An unsigned specifier: u, x, X, o, b - flags &= ~(FLAGS_PLUS | FLAGS_SPACE); + flags &= ~(FLAGS_PLUS | FLAGS_SPACE); - if (flags & FLAGS_LONG_LONG) { + if (flags & FLAGS_LONG_LONG) + { #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - print_integer(output, (printf_unsigned_value_t) va_arg(args, unsigned long long), false, base, precision, width, flags); + print_integer(output, (printf_unsigned_value_t)va_arg(args, unsigned long long), false, base, precision, width, flags); #endif - } - else if (flags & FLAGS_LONG) { - print_integer(output, (printf_unsigned_value_t) va_arg(args, unsigned long), false, base, precision, width, flags); - } - else { - const unsigned int value = - (flags & FLAGS_CHAR) ? (unsigned char)va_arg(args, unsigned int) : - (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(args, unsigned int) : - va_arg(args, unsigned int); - print_integer(output, (printf_unsigned_value_t) value, false, base, precision, width, flags); - } + } + else if (flags & FLAGS_LONG) + { + print_integer(output, (printf_unsigned_value_t)va_arg(args, unsigned long), false, base, precision, width, flags); + } + else + { + const unsigned int value = + (flags & FLAGS_CHAR) ? (unsigned char)va_arg(args, unsigned int) : (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(args, unsigned int) + : va_arg(args, unsigned int); + print_integer(output, (printf_unsigned_value_t)value, false, base, precision, width, flags); + } + } + break; } - break; - } #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - case 'f' : - case 'F' : - if (*format == 'F') flags |= FLAGS_UPPERCASE; - print_floating_point(output, va_arg(args, double), precision, width, flags, PRINTF_PREFER_DECIMAL); - format++; - break; + case 'f': + case 'F': + if (*format == 'F') + { + flags |= FLAGS_UPPERCASE; + } + print_floating_point(output, va_arg(args, double), precision, width, flags, PRINTF_PREFER_DECIMAL); + format++; + break; #endif #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - case 'e': - case 'E': - case 'g': - case 'G': - if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP; - if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE; - print_floating_point(output, va_arg(args, double), precision, width, flags, PRINTF_PREFER_EXPONENTIAL); - format++; - break; -#endif // RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - case 'c' : { - printf_size_t l = 1U; - // pre padding - if (!(flags & FLAGS_LEFT)) { - while (l++ < width) { - putchar_via_gadget(output, ' '); - } - } - // char output - putchar_via_gadget(output, (char) va_arg(args, int) ); - // post padding - if (flags & FLAGS_LEFT) { - while (l++ < width) { - putchar_via_gadget(output, ' '); - } + case 'e': + case 'E': + case 'g': + case 'G': + if ((*format == 'g') || (*format == 'G')) + { + flags |= FLAGS_ADAPT_EXP; + } + if ((*format == 'E') || (*format == 'G')) + { + flags |= FLAGS_UPPERCASE; + } + print_floating_point(output, va_arg(args, double), precision, width, flags, PRINTF_PREFER_EXPONENTIAL); + format++; + break; +#endif // RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS + case 'c': + { + printf_size_t l = 1U; + // pre padding + if (!(flags & FLAGS_LEFT)) + { + while (l++ < width) + { + putchar_via_gadget(output, ' '); + } + } + // char output + putchar_via_gadget(output, (char)va_arg(args, int)); + // post padding + if (flags & FLAGS_LEFT) + { + while (l++ < width) + { + putchar_via_gadget(output, ' '); + } + } + format++; + break; } - format++; - break; - } - case 's' : { - const char* p = va_arg(args, char*); - if (p == NULL) { - out_rev_(output, ")llun(", 6, width, flags); - } - else { - printf_size_t l = strnlen_s_(p, precision ? precision : PRINTF_MAX_POSSIBLE_BUFFER_SIZE); - // pre padding - if (flags & FLAGS_PRECISION) { - l = (l < precision ? l : precision); - } - if (!(flags & FLAGS_LEFT)) { - while (l++ < width) { - putchar_via_gadget(output, ' '); + case 's': + { + const char *p = va_arg(args, char *); + if (p == NULL) + { + out_rev_(output, ")llun(", 6, width, flags); } - } - // string output - while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision)) { - putchar_via_gadget(output, *(p++)); - --precision; - } - // post padding - if (flags & FLAGS_LEFT) { - while (l++ < width) { - putchar_via_gadget(output, ' '); + else + { + printf_size_t l = strnlen_s_(p, precision ? precision : PRINTF_MAX_POSSIBLE_BUFFER_SIZE); + // pre padding + if (flags & FLAGS_PRECISION) + { + l = (l < precision ? l : precision); + } + if (!(flags & FLAGS_LEFT)) + { + while (l++ < width) + { + putchar_via_gadget(output, ' '); + } + } + // string output + while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision)) + { + putchar_via_gadget(output, *(p++)); + --precision; + } + // post padding + if (flags & FLAGS_LEFT) + { + while (l++ < width) + { + putchar_via_gadget(output, ' '); + } + } } - } + format++; + break; } - format++; - break; - } - case 'p' : { - width = sizeof(void*) * 2U + 2; // 2 hex chars per byte + the "0x" prefix - flags |= FLAGS_ZEROPAD | FLAGS_POINTER; - uintptr_t value = (uintptr_t)va_arg(args, void*); - (value == (uintptr_t) NULL) ? - out_rev_(output, ")lin(", 5, width, flags) : - print_integer(output, (printf_unsigned_value_t) value, false, BASE_HEX, precision, width, flags); - format++; - break; - } + case 'p': + { + width = sizeof(void *) * 2U + 2; // 2 hex chars per byte + the "0x" prefix + flags |= FLAGS_ZEROPAD | FLAGS_POINTER; + uintptr_t value = (uintptr_t)va_arg(args, void *); + (value == (uintptr_t)NULL) ? out_rev_(output, ")lin(", 5, width, flags) : print_integer(output, (printf_unsigned_value_t)value, false, BASE_HEX, precision, width, flags); + format++; + break; + } - case '%' : - putchar_via_gadget(output, '%'); - format++; - break; + case '%': + putchar_via_gadget(output, '%'); + format++; + break; - // Many people prefer to disable support for %n, as it lets the caller - // engineer a write to an arbitrary location, of a value the caller - // effectively controls - which could be a security concern in some cases. + // Many people prefer to disable support for %n, as it lets the caller + // engineer a write to an arbitrary location, of a value the caller + // effectively controls - which could be a security concern in some cases. #ifdef RT_KLIBC_USING_VSNPRINTF_WRITEBACK_SPECIFIER - case 'n' : { - if (flags & FLAGS_CHAR) *(va_arg(args, char*)) = (char) output->pos; - else if (flags & FLAGS_SHORT) *(va_arg(args, short*)) = (short) output->pos; - else if (flags & FLAGS_LONG) *(va_arg(args, long*)) = (long) output->pos; + case 'n': + { + if (flags & FLAGS_CHAR) + { + *(va_arg(args, char *)) = (char)output->pos; + } + else if (flags & FLAGS_SHORT) + { + *(va_arg(args, short *)) = (short)output->pos; + } + else if (flags & FLAGS_LONG) + { + *(va_arg(args, long *)) = (long)output->pos; + } #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - else if (flags & FLAGS_LONG_LONG) *(va_arg(args, long long*)) = (long long int) output->pos; + else if (flags & FLAGS_LONG_LONG) + { + *(va_arg(args, long long *)) = (long long int)output->pos; + } #endif // RT_KLIBC_USING_VSNPRINTF_LONGLONG - else *(va_arg(args, int*)) = (int) output->pos; - format++; - break; - } + else + { + *(va_arg(args, int *)) = (int)output->pos; + } + format++; + break; + } #endif // RT_KLIBC_USING_VSNPRINTF_WRITEBACK_SPECIFIER - default : - putchar_via_gadget(output, *format); - format++; - break; + default: + putchar_via_gadget(output, *format); + format++; + break; + } } - } } // internal vsnprintf - used for implementing _all library functions -static int vsnprintf_impl(output_gadget_t* output, const char* format, va_list args) +static int vsnprintf_impl(output_gadget_t *output, const char *format, va_list args) { - // Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is - // possible to call this function with a non-zero pos value for some "remedial printing". - format_string_loop(output, format, args); + // Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is + // possible to call this function with a non-zero pos value for some "remedial printing". + format_string_loop(output, format, args); - // termination - append_termination_with_gadget(output); + // termination + append_termination_with_gadget(output); - // return written chars without terminating \0 - return (int)output->pos; + // return written chars without terminating \0 + return (int)output->pos; } /////////////////////////////////////////////////////////////////////////////// @@ -1347,6 +1531,6 @@ static int vsnprintf_impl(output_gadget_t* output, const char* format, va_list a */ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) { - output_gadget_t gadget = buffer_gadget(buf, size); - return vsnprintf_impl(&gadget, fmt, args); + output_gadget_t gadget = buffer_gadget(buf, size); + return vsnprintf_impl(&gadget, fmt, args); } diff --git a/src/klibc/rt_vsnprintf_tiny.c b/src/klibc/rt_vsnprintf_tiny.c index 36811048a9..0d4fdda67f 100644 --- a/src/klibc/rt_vsnprintf_tiny.c +++ b/src/klibc/rt_vsnprintf_tiny.c @@ -10,7 +10,7 @@ #include <rtthread.h> -#define _ISDIGIT(c) ((unsigned)((c) - '0') < 10) +#define _ISDIGIT(c) ((unsigned)((c) - '0') < 10) /** * @brief This function will duplicate a string. @@ -45,37 +45,39 @@ rt_inline int skip_atoi(const char **s) { int i = 0; while (_ISDIGIT(**s)) + { i = i * 10 + *((*s)++) - '0'; + } return i; } -#define ZEROPAD (1 << 0) /* pad with zero */ -#define SIGN (1 << 1) /* unsigned/signed long */ -#define PLUS (1 << 2) /* show plus */ -#define SPACE (1 << 3) /* space if plus */ -#define LEFT (1 << 4) /* left justified */ -#define SPECIAL (1 << 5) /* 0x */ -#define LARGE (1 << 6) /* use 'ABCDEF' instead of 'abcdef' */ +#define ZEROPAD (1 << 0) /* pad with zero */ +#define SIGN (1 << 1) /* unsigned/signed long */ +#define PLUS (1 << 2) /* show plus */ +#define SPACE (1 << 3) /* space if plus */ +#define LEFT (1 << 4) /* left justified */ +#define SPECIAL (1 << 5) /* 0x */ +#define LARGE (1 << 6) /* use 'ABCDEF' instead of 'abcdef' */ static char *print_number(char *buf, char *end, #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - unsigned long long num, + unsigned long long num, #else - unsigned long num, + unsigned long num, #endif /* RT_KLIBC_USING_VSNPRINTF_LONGLONG */ - int base, - int qualifier, - int s, - int precision, - int type) + int base, + int qualifier, + int s, + int precision, + int type) { char c = 0, sign = 0; #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - char tmp[64] = {0}; + char tmp[64] = { 0 }; #else - char tmp[32] = {0}; + char tmp[32] = { 0 }; #endif /* RT_KLIBC_USING_VSNPRINTF_LONGLONG */ int precision_bak = precision; const char *digits = RT_NULL; @@ -158,7 +160,9 @@ static char *print_number(char *buf, else { while (num != 0) + { tmp[i++] = digits[divide(&num, base)]; + } } if (i > precision) @@ -181,7 +185,7 @@ static char *print_number(char *buf, *buf = ' '; } - ++ buf; + ++buf; } } @@ -191,8 +195,8 @@ static char *print_number(char *buf, { *buf = sign; } - -- size; - ++ buf; + --size; + ++buf; } if (type & SPECIAL) @@ -200,17 +204,23 @@ static char *print_number(char *buf, if (base == 2) { if (buf < end) + { *buf = '0'; - ++ buf; + } + ++buf; if (buf < end) + { *buf = 'b'; - ++ buf; + } + ++buf; } else if (base == 8) { if (buf < end) + { *buf = '0'; - ++ buf; + } + ++buf; } else if (base == 16) { @@ -219,12 +229,12 @@ static char *print_number(char *buf, *buf = '0'; } - ++ buf; + ++buf; if (buf < end) { *buf = type & LARGE ? 'X' : 'x'; } - ++ buf; + ++buf; } } @@ -238,7 +248,7 @@ static char *print_number(char *buf, *buf = c; } - ++ buf; + ++buf; } } @@ -249,7 +259,7 @@ static char *print_number(char *buf, *buf = '0'; } - ++ buf; + ++buf; } /* put number in the temporary buffer */ @@ -260,7 +270,7 @@ static char *print_number(char *buf, *buf = tmp[i]; } - ++ buf; + ++buf; } while (size-- > 0) @@ -270,7 +280,7 @@ static char *print_number(char *buf, *buf = ' '; } - ++ buf; + ++buf; } return buf; @@ -306,11 +316,11 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) char *str = RT_NULL, *end = RT_NULL, c = 0; const char *s = RT_NULL; - rt_uint8_t base = 0; /* the base of number */ - rt_uint8_t flags = 0; /* flags to print number */ - rt_uint8_t qualifier = 0; /* 'h', 'l', or 'L' for integer fields */ - rt_int32_t field_width = 0; /* width of output field */ - int precision = 0; /* min. # of digits for integers and max for a string */ + rt_uint8_t base = 0; /* the base of number */ + rt_uint8_t flags = 0; /* flags to print number */ + rt_uint8_t qualifier = 0; /* 'h', 'l', or 'L' for integer fields */ + rt_int32_t field_width = 0; /* width of output field */ + int precision = 0; /* min. # of digits for integers and max for a string */ str = buf; end = buf + size; @@ -318,11 +328,11 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) /* Make sure end is always >= buf */ if (end < buf) { - end = ((char *) - 1); + end = ((char *)-1); size = end - buf; } - for (; *fmt ; ++fmt) + for (; *fmt; ++fmt) { if (*fmt != '%') { @@ -331,7 +341,7 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) *str = *fmt; } - ++ str; + ++str; continue; } @@ -342,12 +352,30 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) { /* skips the first '%' also */ ++fmt; - if (*fmt == '-') flags |= LEFT; - else if (*fmt == '+') flags |= PLUS; - else if (*fmt == ' ') flags |= SPACE; - else if (*fmt == '#') flags |= SPECIAL; - else if (*fmt == '0') flags |= ZEROPAD; - else break; + if (*fmt == '-') + { + flags |= LEFT; + } + else if (*fmt == '+') + { + flags |= PLUS; + } + else if (*fmt == ' ') + { + flags |= SPACE; + } + else if (*fmt == '#') + { + flags |= SPECIAL; + } + else if (*fmt == '0') + { + flags |= ZEROPAD; + } + else + { + break; + } } /* get field width */ @@ -423,8 +451,11 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) { while (--field_width > 0) { - if (str < end) *str = ' '; - ++ str; + if (str < end) + { + *str = ' '; + } + ++str; } } @@ -434,13 +465,16 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) { *str = c; } - ++ str; + ++str; /* put width */ while (--field_width > 0) { - if (str < end) *str = ' '; - ++ str; + if (str < end) + { + *str = ' '; + } + ++str; } continue; @@ -462,22 +496,31 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) { while (len < field_width--) { - if (str < end) *str = ' '; - ++ str; + if (str < end) + { + *str = ' '; + } + ++str; } } for (i = 0; i < len; ++i) { - if (str < end) *str = *s; - ++ str; - ++ s; + if (str < end) + { + *str = *s; + } + ++str; + ++s; } while (len < field_width--) { - if (str < end) *str = ' '; - ++ str; + if (str < end) + { + *str = ' '; + } + ++str; } continue; @@ -498,7 +541,7 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) { *str = '%'; } - ++ str; + ++str; continue; /* integer number formats - set up the flags and "break" */ @@ -533,7 +576,7 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) { *str = '%'; } - ++ str; + ++str; if (*fmt) { @@ -541,11 +584,11 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) { *str = *fmt; } - ++ str; + ++str; } else { - -- fmt; + --fmt; } continue; } @@ -608,4 +651,4 @@ int rt_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) } #if (defined(__GNUC__) && !defined(__ARMCC_VERSION) /* GCC */) && (__GNUC__ >= 7) #pragma GCC diagnostic pop /* ignored "-Wimplicit-fallthrough" */ -#endif /* (defined(__GNUC__) && !defined(__ARMCC_VERSION)) && (__GNUC__ >= 7 */ +#endif /* (defined(__GNUC__) && !defined(__ARMCC_VERSION)) && (__GNUC__ >= 7 */ diff --git a/src/klibc/rt_vsscanf.c b/src/klibc/rt_vsscanf.c index 8369b65249..84708ff5f2 100644 --- a/src/klibc/rt_vsscanf.c +++ b/src/klibc/rt_vsscanf.c @@ -16,7 +16,7 @@ #include <rtthread.h> #include <stdlib.h> /* for strtod */ -#include <ctype.h> /* for isspace */ +#include <ctype.h> /* for isspace */ #include <stdarg.h> /* for va_list */ #define FORMAT_NIL_STR "(nil)" @@ -33,68 +33,74 @@ #define SHORTSHORT 0x4000 /* hh: char */ #define UNSIGNED 0x8000 /* %[oupxX] conversions */ -#define SIGNOK 0x40 /* +/- is (still) legal */ -#define NDIGITS 0x80 /* no digits detected */ -#define PFXOK 0x100 /* 0x prefix is (still) legal */ -#define NZDIGITS 0x200 /* no zero digits detected */ +#define SIGNOK 0x40 /* +/- is (still) legal */ +#define NDIGITS 0x80 /* no digits detected */ +#define PFXOK 0x100 /* 0x prefix is (still) legal */ +#define NZDIGITS 0x200 /* no zero digits detected */ -#define CT_CHAR 0 /* %c conversion */ -#define CT_CCL 1 /* %[...] conversion */ -#define CT_STRING 2 /* %s conversion */ -#define CT_INT 3 /* %[dioupxX] conversion */ -#define CT_FLOAT 4 /* %[aefgAEFG] conversion */ -#define CT_NONE 5 /* No conversion (ex. %n) */ +#define CT_CHAR 0 /* %c conversion */ +#define CT_CCL 1 /* %[...] conversion */ +#define CT_STRING 2 /* %s conversion */ +#define CT_INT 3 /* %[dioupxX] conversion */ +#define CT_FLOAT 4 /* %[aefgAEFG] conversion */ +#define CT_NONE 5 /* No conversion (ex. %n) */ static const unsigned char *__sccl(char *tab, const unsigned char *fmt) { int c, n, v; c = *fmt++; - if (c == '^') { + if (c == '^') + { v = 1; c = *fmt++; } - else { + else + { v = 0; } rt_memset(tab, (uint8_t)v, 256); - if (c == 0) { + if (c == 0) + { return (fmt - 1); } v = 1 - v; tab[c] = v; - for (;;) { + for (;;) + { n = *fmt++; - switch (n) { + switch (n) + { + case 0: + return (fmt - 1); - case 0: - return (fmt - 1); - - case '-': - n = *fmt; - if ((n == ']') || (n < c)) { - c = '-'; - tab[c] = v; - break; - } - fmt++; - - do { - tab[++c] = v; - } while (c < n); - c = n; + case '-': + n = *fmt; + if ((n == ']') || (n < c)) + { + c = '-'; + tab[c] = v; break; + } + fmt++; - case ']': - return (fmt); + do + { + tab[++c] = v; + } while (c < n); + c = n; + break; - default: - c = n; - tab[c] = v; - break; + case ']': + return (fmt); + + default: + c = n; + tab[c] = v; + break; } } } @@ -115,15 +121,19 @@ static int scanf_parse(char *ccltab, const char *inp, int *inr, char const *fmt0 nconversions = 0; nread = 0; base = 0; - for (;;) { + for (;;) + { int convType = CT_NONE; c = *fmt++; - if (c == '\0') { + if (c == '\0') + { return (nassigned); } - if (isspace(c) != 0) { - while ((*inr > 0) && (isspace((int)*inp) != 0)) { + if (isspace(c) != 0) + { + while ((*inr > 0) && (isspace((int)*inp) != 0)) + { nread++; (*inr)--; inp++; @@ -131,12 +141,15 @@ static int scanf_parse(char *ccltab, const char *inp, int *inr, char const *fmt0 continue; } - if (c != '%') { - if (*inr <= 0) { + if (c != '%') + { + if (*inr <= 0) + { return (nconversions != 0 ? nassigned : -1); } - if (*inp != c) { + if (*inp != c) + { return nassigned; } @@ -148,18 +161,23 @@ static int scanf_parse(char *ccltab, const char *inp, int *inr, char const *fmt0 width = 0; flags = 0; - for (;;) { + for (;;) + { c = *fmt++; - if (c == '\0') { + if (c == '\0') + { return nassigned; } - if (c == '%') { - if (*inr <= 0) { + if (c == '%') + { + if (*inr <= 0) + { return (nconversions != 0 ? nassigned : -1); } - if (*inp != c) { + if (*inp != c) + { return nassigned; } @@ -169,516 +187,603 @@ static int scanf_parse(char *ccltab, const char *inp, int *inr, char const *fmt0 break; } - switch (c) { - case '*': - flags |= SUPPRESS; - continue; + switch (c) + { + case '*': + flags |= SUPPRESS; + continue; - case 'l': - if ((flags & LONG) != 0) { - flags &= ~LONG; - flags |= LONGLONG; - } - else { - flags |= LONG; - } - continue; + case 'l': + if ((flags & LONG) != 0) + { + flags &= ~LONG; + flags |= LONGLONG; + } + else + { + flags |= LONG; + } + continue; - case 'L': - flags |= LONGDOUBLE; - continue; + case 'L': + flags |= LONGDOUBLE; + continue; - case 'q': - case 'j': - flags |= LONGLONG; - continue; + case 'q': + case 'j': + flags |= LONGLONG; + continue; - case 't': - flags |= PTRDIFF; - continue; + case 't': + flags |= PTRDIFF; + continue; - case 'z': - if (sizeof(rt_size_t) == sizeof(uint64_t)) { - flags |= LONGLONG; - } - continue; + case 'z': + if (sizeof(rt_size_t) == sizeof(uint64_t)) + { + flags |= LONGLONG; + } + continue; - case 'h': - if ((flags & SHORT) != 0) { - flags &= ~SHORT; - flags |= SHORTSHORT; - } - else { - flags |= SHORT; - } - continue; + case 'h': + if ((flags & SHORT) != 0) + { + flags &= ~SHORT; + flags |= SHORTSHORT; + } + else + { + flags |= SHORT; + } + continue; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - width = width * 10 + c - '0'; - continue; - default: - break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + width = width * 10 + c - '0'; + continue; + default: + break; } /* conversions */ - switch (c) { - case 'd': - convType = CT_INT; - base = 10; - break; - - case 'i': - convType = CT_INT; - base = 0; - break; + switch (c) + { + case 'd': + convType = CT_INT; + base = 10; + break; - case 'o': - convType = CT_INT; - flags |= UNSIGNED; - base = 8; - break; + case 'i': + convType = CT_INT; + base = 0; + break; - case 'u': - convType = CT_INT; - flags |= UNSIGNED; - base = 10; - break; + case 'o': + convType = CT_INT; + flags |= UNSIGNED; + base = 8; + break; - case 'X': - case 'x': - flags |= PFXOK; /* enable 0x prefixing */ - convType = CT_INT; - flags |= UNSIGNED; - base = 16; - break; + case 'u': + convType = CT_INT; + flags |= UNSIGNED; + base = 10; + break; - case 'A': - case 'E': - case 'F': - case 'G': - case 'a': - case 'e': - case 'f': - case 'g': - convType = CT_FLOAT; - break; + case 'X': + case 'x': + flags |= PFXOK; /* enable 0x prefixing */ + convType = CT_INT; + flags |= UNSIGNED; + base = 16; + break; + case 'A': + case 'E': + case 'F': + case 'G': + case 'a': + case 'e': + case 'f': + case 'g': + convType = CT_FLOAT; + break; - case 's': - convType = CT_STRING; - break; + case 's': + convType = CT_STRING; + break; - case '[': - fmt = __sccl(ccltab, fmt); - flags |= NOSKIP; - convType = CT_CCL; - break; + case '[': + fmt = __sccl(ccltab, fmt); + flags |= NOSKIP; + convType = CT_CCL; + break; - case 'c': - flags |= NOSKIP; - convType = CT_CHAR; - break; + case 'c': + flags |= NOSKIP; + convType = CT_CHAR; + break; - case 'p': - flags |= POINTER | PFXOK | UNSIGNED; - convType = CT_INT; - base = 16; - break; + case 'p': + flags |= POINTER | PFXOK | UNSIGNED; + convType = CT_INT; + base = 16; + break; - case 'n': - nconversions++; - if ((flags & SUPPRESS) != 0) { - break; - } - if ((flags & SHORTSHORT) != 0) { - *va_arg(ap, char *) = nread; - } - else if ((flags & SHORT) != 0) { - *va_arg(ap, short *) = nread; - } - else if ((flags & LONG) != 0) { - *va_arg(ap, long *) = nread; - } - else if ((flags & LONGLONG) != 0) { - *va_arg(ap, long long *) = nread; - } - else if ((flags & PTRDIFF) != 0) { - *va_arg(ap, ptrdiff_t *) = nread; - } - else { - *va_arg(ap, int *) = nread; - } + case 'n': + nconversions++; + if ((flags & SUPPRESS) != 0) + { break; + } + if ((flags & SHORTSHORT) != 0) + { + *va_arg(ap, char *) = nread; + } + else if ((flags & SHORT) != 0) + { + *va_arg(ap, short *) = nread; + } + else if ((flags & LONG) != 0) + { + *va_arg(ap, long *) = nread; + } + else if ((flags & LONGLONG) != 0) + { + *va_arg(ap, long long *) = nread; + } + else if ((flags & PTRDIFF) != 0) + { + *va_arg(ap, ptrdiff_t *) = nread; + } + else + { + *va_arg(ap, int *) = nread; + } + break; - default: - /* Character not a conversion specifier; end parsing */ - return nassigned; + default: + /* Character not a conversion specifier; end parsing */ + return nassigned; } break; } - if (convType == CT_NONE) { + if (convType == CT_NONE) + { continue; } - if (*inr <= 0) { + if (*inr <= 0) + { return (nconversions != 0 ? nassigned : -1); } - if ((flags & NOSKIP) == 0) { - while (isspace((int)*inp) != 0) { + if ((flags & NOSKIP) == 0) + { + while (isspace((int)*inp) != 0) + { nread++; - if (--(*inr) > 0) { + if (--(*inr) > 0) + { inp++; } - else { + else + { return (nconversions != 0 ? nassigned : -1); } } } /* do the conversion */ - switch (convType) { - case CT_CHAR: - if (width == 0) { - width = 1; - } + switch (convType) + { + case CT_CHAR: + if (width == 0) + { + width = 1; + } - if (*inr <= 0) { - return (nconversions != 0 ? nassigned : -1); - } + if (*inr <= 0) + { + return (nconversions != 0 ? nassigned : -1); + } - if (width > *inr) { - width = *inr; - } + if (width > *inr) + { + width = *inr; + } - if ((flags & SUPPRESS) == 0) { - rt_memcpy(va_arg(ap, char *), inp, width); - nassigned++; - } + if ((flags & SUPPRESS) == 0) + { + rt_memcpy(va_arg(ap, char *), inp, width); + nassigned++; + } - *inr -= width; - inp += width; - nread += width; - nconversions++; - break; + *inr -= width; + inp += width; + nread += width; + nconversions++; + break; - case CT_CCL: - if (width == 0) { - width = (rt_size_t)~0; - } - if ((flags & SUPPRESS) != 0) { - n = 0; - while (ccltab[(unsigned char)*inp] != 0) { - n++; - (*inr)--; - inp++; - if (--width == 0) { - break; - } - if (*inr <= 0) { - if (n == 0) { - return (nconversions != 0 ? nassigned : -1); - } - break; - } - } - if (n == 0) { - return nassigned; + case CT_CCL: + if (width == 0) + { + width = (rt_size_t)~0; + } + if ((flags & SUPPRESS) != 0) + { + n = 0; + while (ccltab[(unsigned char)*inp] != 0) + { + n++; + (*inr)--; + inp++; + if (--width == 0) + { + break; } - } - else { - p0 = p = va_arg(ap, char *); - while (ccltab[(unsigned char)*inp] != 0) { - (*inr)--; - *p++ = *inp++; - if (--width == 0) { - break; + if (*inr <= 0) + { + if (n == 0) + { + return (nconversions != 0 ? nassigned : -1); } - if (*inr <= 0) { - if (p == p0) { - return (nconversions != 0 ? nassigned : -1); - } - break; - } - } - n = p - p0; - if (n == 0) { - return nassigned; + break; } - *p = 0; - nassigned++; } - nread += n; - nconversions++; - break; - - case CT_STRING: - if (width == 0) { - width = (rt_size_t)~0; + if (n == 0) + { + return nassigned; } - if ((flags & SUPPRESS) != 0) { - while (isspace((int)*inp) == 0) { - nread++; - (*inr)--; - inp++; - if (--width == 0) { - break; - } - if (*inr <= 0) { - break; - } + } + else + { + p0 = p = va_arg(ap, char *); + while (ccltab[(unsigned char)*inp] != 0) + { + (*inr)--; + *p++ = *inp++; + if (--width == 0) + { + break; } - } - else { - p0 = p = va_arg(ap, char *); - while (isspace((int)*inp) == 0) { - (*inr)--; - *p++ = *inp++; - if (--width == 0) { - break; - } - if (*inr <= 0) { - break; + if (*inr <= 0) + { + if (p == p0) + { + return (nconversions != 0 ? nassigned : -1); } + break; } - *p = 0; - nread += p - p0; - nassigned++; - } - nconversions++; - continue; - - case CT_INT: - if (((flags & POINTER) != 0) && ((*inr) >= FORMAT_NIL_STR_LEN) && (rt_strncmp(FORMAT_NIL_STR, inp, FORMAT_NIL_STR_LEN) == 0)) { - *va_arg(ap, void **) = RT_NULL; - nassigned++; - nconversions++; - nread += FORMAT_NIL_STR_LEN; - inp += FORMAT_NIL_STR_LEN; - (*inr) -= FORMAT_NIL_STR_LEN; - break; - } - - if (--width > (sizeof(buf) - 2)) { - width = sizeof(buf) - 2; } - width++; - - if ((flags & SUPPRESS) != 0) { - width = ~0; + n = p - p0; + if (n == 0) + { + return nassigned; } + *p = 0; + nassigned++; + } + nread += n; + nconversions++; + break; - flags |= SIGNOK | NDIGITS | NZDIGITS; - for (p = buf; width; width--) { - int ok = 0; - c = *inp; - switch (c) { - case '0': - if (base == 0) { - base = 8; - flags |= PFXOK; - } - if ((flags & NZDIGITS) != 0) { - flags &= ~(SIGNOK | NZDIGITS | NDIGITS); - } - else { - flags &= ~(SIGNOK | PFXOK | NDIGITS); - } - ok = 1; - break; - - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - base = basefix[base]; - flags &= ~(SIGNOK | PFXOK | NDIGITS); - ok = 1; - break; - - case '8': - case '9': - base = basefix[base]; - if (base <= 8) { - break; /* not legal here */ - } - flags &= ~(SIGNOK | PFXOK | NDIGITS); - ok = 1; - break; - - case 'A': - case 'B': - case 'C': - case 'D': - case 'E': - case 'F': - case 'a': - case 'b': - case 'c': - case 'd': - case 'e': - case 'f': - if (base <= 10) { - break; - } - flags &= ~(SIGNOK | PFXOK | NDIGITS); - ok = 1; - break; - - case '+': - case '-': - if ((flags & SIGNOK) != 0) { - flags &= ~SIGNOK; - ok = 1; - } - break; - - case 'x': - case 'X': - if (((flags & PFXOK) != 0) && (p == buf + 1)) { - base = 16; /* if %i */ - flags &= ~PFXOK; - ok = 1; - } - break; + case CT_STRING: + if (width == 0) + { + width = (rt_size_t)~0; + } + if ((flags & SUPPRESS) != 0) + { + while (isspace((int)*inp) == 0) + { + nread++; + (*inr)--; + inp++; + if (--width == 0) + { + break; } - if (!ok) + if (*inr <= 0) + { break; - - if ((flags & SUPPRESS) == 0) { - *p++ = c; } - if (--(*inr) > 0) { - inp++; + } + } + else + { + p0 = p = va_arg(ap, char *); + while (isspace((int)*inp) == 0) + { + (*inr)--; + *p++ = *inp++; + if (--width == 0) + { + break; } - else { + if (*inr <= 0) + { break; } } - if ((flags & NDIGITS) != 0) { - return (nconversions != 0 ? nassigned : -1); - } + *p = 0; + nread += p - p0; + nassigned++; + } + nconversions++; + continue; - c = ((unsigned char *)p)[-1]; - if ((c == 'x') || (c == 'X')) { - --p; - inp--; - (*inr)++; - } + case CT_INT: + if (((flags & POINTER) != 0) && ((*inr) >= FORMAT_NIL_STR_LEN) && (rt_strncmp(FORMAT_NIL_STR, inp, FORMAT_NIL_STR_LEN) == 0)) + { + *va_arg(ap, void **) = RT_NULL; + nassigned++; + nconversions++; + nread += FORMAT_NIL_STR_LEN; + inp += FORMAT_NIL_STR_LEN; + (*inr) -= FORMAT_NIL_STR_LEN; + break; + } - if ((flags & SUPPRESS) == 0) { - uint64_t res; + if (--width > (sizeof(buf) - 2)) + { + width = sizeof(buf) - 2; + } + width++; - *p = 0; - if ((flags & UNSIGNED) == 0) { - res = strtoll(buf, (char **)RT_NULL, base); - } - else { - res = strtoull(buf, (char **)RT_NULL, base); - } - if ((flags & POINTER) != 0) { - *va_arg(ap, void **) = (void *)(unsigned long)res; + if ((flags & SUPPRESS) != 0) + { + width = ~0; + } + + flags |= SIGNOK | NDIGITS | NZDIGITS; + for (p = buf; width; width--) + { + int ok = 0; + c = *inp; + switch (c) + { + case '0': + if (base == 0) + { + base = 8; + flags |= PFXOK; } - else if ((flags & SHORTSHORT) != 0) { - *va_arg(ap, char *) = res; + if ((flags & NZDIGITS) != 0) + { + flags &= ~(SIGNOK | NZDIGITS | NDIGITS); } - else if ((flags & SHORT) != 0) { - *va_arg(ap, short *) = res; + else + { + flags &= ~(SIGNOK | PFXOK | NDIGITS); } - else if ((flags & LONG) != 0) { - *va_arg(ap, long *) = res; + ok = 1; + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + base = basefix[base]; + flags &= ~(SIGNOK | PFXOK | NDIGITS); + ok = 1; + break; + + case '8': + case '9': + base = basefix[base]; + if (base <= 8) + { + break; /* not legal here */ } - else if ((flags & LONGLONG) != 0) { - *va_arg(ap, long long *) = res; + flags &= ~(SIGNOK | PFXOK | NDIGITS); + ok = 1; + break; + + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + if (base <= 10) + { + break; } - else if ((flags & PTRDIFF) != 0) { - *va_arg(ap, ptrdiff_t *) = res; + flags &= ~(SIGNOK | PFXOK | NDIGITS); + ok = 1; + break; + + case '+': + case '-': + if ((flags & SIGNOK) != 0) + { + flags &= ~SIGNOK; + ok = 1; } - else { - *va_arg(ap, int *) = res; + break; + + case 'x': + case 'X': + if (((flags & PFXOK) != 0) && (p == buf + 1)) + { + base = 16; /* if %i */ + flags &= ~PFXOK; + ok = 1; } - nassigned++; + break; + } + if (!ok) + { + break; } - nread += p - buf; - nconversions++; - break; + if ((flags & SUPPRESS) == 0) + { + *p++ = c; + } + if (--(*inr) > 0) + { + inp++; + } + else + { + break; + } + } + if ((flags & NDIGITS) != 0) + { + return (nconversions != 0 ? nassigned : -1); + } - case CT_FLOAT: { - union { - float f; - double d; - long double ld; - } res; + c = ((unsigned char *)p)[-1]; + if ((c == 'x') || (c == 'X')) + { + --p; + inp--; + (*inr)++; + } - const char *srcbuf = inp; - if ((width != 0) && (width < *inr)) { - /* TODO: handle larger widths */ - if (width > (sizeof(buf) - 1)) { - return (nconversions != 0 ? nassigned : -1); - } + if ((flags & SUPPRESS) == 0) + { + uint64_t res; - rt_memcpy(buf, inp, width); - buf[width] = '\0'; - srcbuf = buf; + *p = 0; + if ((flags & UNSIGNED) == 0) + { + res = strtoll(buf, (char **)RT_NULL, base); } - - int is_zero; - if ((flags & LONGDOUBLE) != 0) { - res.ld = strtold(srcbuf, &p); - is_zero = res.ld == 0; + else + { + res = strtoull(buf, (char **)RT_NULL, base); } - else if ((flags & LONG) != 0) { - res.d = strtod(srcbuf, &p); - is_zero = res.d == 0; + if ((flags & POINTER) != 0) + { + *va_arg(ap, void **) = (void *)(unsigned long)res; } - else { - res.f = strtof(srcbuf, &p); - is_zero = res.f == 0; + else if ((flags & SHORTSHORT) != 0) + { + *va_arg(ap, char *) = res; } + else if ((flags & SHORT) != 0) + { + *va_arg(ap, short *) = res; + } + else if ((flags & LONG) != 0) + { + *va_arg(ap, long *) = res; + } + else if ((flags & LONGLONG) != 0) + { + *va_arg(ap, long long *) = res; + } + else if ((flags & PTRDIFF) != 0) + { + *va_arg(ap, ptrdiff_t *) = res; + } + else + { + *va_arg(ap, int *) = res; + } + nassigned++; + } + + nread += p - buf; + nconversions++; + break; - if (is_zero && (srcbuf == p)) { + case CT_FLOAT: + { + union + { + float f; + double d; + long double ld; + } res; + + const char *srcbuf = inp; + if ((width != 0) && (width < *inr)) + { + /* TODO: handle larger widths */ + if (width > (sizeof(buf) - 1)) + { return (nconversions != 0 ? nassigned : -1); } - int consumed = p - srcbuf; - *inr -= consumed; - inp += consumed; - nread += consumed; - nconversions++; - if ((flags & SUPPRESS) == 0) { - if ((flags & LONGDOUBLE) != 0) { - *va_arg(ap, long double *) = res.ld; - } - else if ((flags & LONG) != 0) { - *va_arg(ap, double *) = res.d; - } - else { - *va_arg(ap, float *) = res.f; - } + rt_memcpy(buf, inp, width); + buf[width] = '\0'; + srcbuf = buf; + } + + int is_zero; + if ((flags & LONGDOUBLE) != 0) + { + res.ld = strtold(srcbuf, &p); + is_zero = res.ld == 0; + } + else if ((flags & LONG) != 0) + { + res.d = strtod(srcbuf, &p); + is_zero = res.d == 0; + } + else + { + res.f = strtof(srcbuf, &p); + is_zero = res.f == 0; + } + + if (is_zero && (srcbuf == p)) + { + return (nconversions != 0 ? nassigned : -1); + } - nassigned++; + int consumed = p - srcbuf; + *inr -= consumed; + inp += consumed; + nread += consumed; + nconversions++; + if ((flags & SUPPRESS) == 0) + { + if ((flags & LONGDOUBLE) != 0) + { + *va_arg(ap, long double *) = res.ld; + } + else if ((flags & LONG) != 0) + { + *va_arg(ap, double *) = res.d; + } + else + { + *va_arg(ap, float *) = res.f; } - break; + nassigned++; } - default: - break; + break; + } + + default: + break; } } /* never reached */ @@ -689,7 +794,8 @@ int rt_vsscanf(const char *str, const char *format, va_list ap) int ret, nremain; char *ccltab = rt_malloc(256); - if (ccltab == RT_NULL) { + if (ccltab == RT_NULL) + { return -1; } diff --git a/src/klibc/utest/TC_rt_memcmp.c b/src/klibc/utest/TC_rt_memcmp.c index c89fe3123f..4537bcd9ff 100644 --- a/src/klibc/utest/TC_rt_memcmp.c +++ b/src/klibc/utest/TC_rt_memcmp.c @@ -14,7 +14,7 @@ static void TC_rt_memcmp_str(void) { - const char* s = "abc 123"; + const char *s = "abc 123"; uassert_int_equal(rt_memcmp("abc", "abc", 4), 0); uassert_int_equal(rt_memcmp(s, "abc", 3), 0); @@ -28,9 +28,9 @@ static void TC_rt_memcmp_str(void) static void TC_rt_memcmp_int_array(void) { - int arr1[] = {1, 2, 3, 4, 5}; - int arr2[] = {1, 2, 3, 4, 5}; - int arr3[] = {1, 2, 3, 4, 6}; + int arr1[] = { 1, 2, 3, 4, 5 }; + int arr2[] = { 1, 2, 3, 4, 5 }; + int arr3[] = { 1, 2, 3, 4, 6 }; uassert_int_equal(rt_memcmp(arr1, arr2, sizeof(arr1)), 0); uassert_value_less(rt_memcmp(arr1, arr3, sizeof(arr1)), 0); @@ -39,32 +39,34 @@ static void TC_rt_memcmp_int_array(void) static void TC_rt_memcmp_float_array(void) { - float arr1[] = {1.0f, 2.0f, 3.0f}; - float arr2[] = {1.0f, 2.0f, 3.0f}; - float arr3[] = {1.0f, 2.0f, 3.1f}; + float arr1[] = { 1.0f, 2.0f, 3.0f }; + float arr2[] = { 1.0f, 2.0f, 3.0f }; + float arr3[] = { 1.0f, 2.0f, 3.1f }; uassert_int_equal(rt_memcmp(arr1, arr2, sizeof(arr1)), 0); uassert_value_less(rt_memcmp(arr1, arr3, sizeof(arr1)), 0); uassert_value_greater(rt_memcmp(arr3, arr1, sizeof(arr1)), 0); } -typedef struct { +typedef struct +{ int id; float value; } Item; static void TC_rt_memcmp_struct_array(void) { - Item arr1[] = {{1, 1.0f}, {2, 2.0f}}; - Item arr2[] = {{1, 1.0f}, {2, 2.0f}}; - Item arr3[] = {{1, 1.0f}, {2, 2.1f}}; + Item arr1[] = { { 1, 1.0f }, { 2, 2.0f } }; + Item arr2[] = { { 1, 1.0f }, { 2, 2.0f } }; + Item arr3[] = { { 1, 1.0f }, { 2, 2.1f } }; uassert_int_equal(rt_memcmp(arr1, arr2, sizeof(arr1)), 0); uassert_value_less(rt_memcmp(arr1, arr3, sizeof(arr1)), 0); uassert_value_greater(rt_memcmp(arr3, arr1, sizeof(arr1)), 0); } -typedef struct { +typedef struct +{ int id; float value; char name[10]; @@ -72,21 +74,23 @@ typedef struct { static void TC_rt_memcmp_mixed_array(void) { - MixedItem arr1[] = {{1, 1.0f, "item1"}, {2, 2.0f, "item2"}}; - MixedItem arr2[] = {{1, 1.0f, "item1"}, {2, 2.0f, "item2"}}; - MixedItem arr3[] = {{1, 1.0f, "item1"}, {2, 2.1f, "item2"}}; + MixedItem arr1[] = { { 1, 1.0f, "item1" }, { 2, 2.0f, "item2" } }; + MixedItem arr2[] = { { 1, 1.0f, "item1" }, { 2, 2.0f, "item2" } }; + MixedItem arr3[] = { { 1, 1.0f, "item1" }, { 2, 2.1f, "item2" } }; uassert_int_equal(rt_memcmp(arr1, arr2, sizeof(arr1)), 0); uassert_value_less(rt_memcmp(arr1, arr3, sizeof(arr1)), 0); uassert_value_greater(rt_memcmp(arr3, arr1, sizeof(arr1)), 0); } -typedef struct { +typedef struct +{ int id; float score; } Student; -typedef struct { +typedef struct +{ Student students[3]; char className[10]; } Class; @@ -94,17 +98,17 @@ typedef struct { static void TC_rt_memcmp_nested_struct_array(void) { Class class1 = { - .students = {{1, 90.5}, {2, 85.0}, {3, 92.0}}, + .students = { { 1, 90.5 }, { 2, 85.0 }, { 3, 92.0 } }, .className = "ClassA" }; Class class2 = { - .students = {{1, 90.5}, {2, 85.0}, {3, 92.0}}, + .students = { { 1, 90.5 }, { 2, 85.0 }, { 3, 92.0 } }, .className = "ClassA" }; Class class3 = { - .students = {{1, 90.5}, {2, 85.1}, {3, 92.0}}, + .students = { { 1, 90.5 }, { 2, 85.1 }, { 3, 92.0 } }, .className = "ClassA" }; @@ -131,7 +135,8 @@ static void TC_rt_memcmp_large_array(void) uassert_not_null(arr1); uassert_not_null(arr2); - for (int i = 0; i < LARGE_ARRAY_SIZE; i++) { + for (int i = 0; i < LARGE_ARRAY_SIZE; i++) + { arr1[i] = i; arr2[i] = i; } diff --git a/src/klibc/utest/TC_rt_memcpy.c b/src/klibc/utest/TC_rt_memcpy.c index 7c53bea6e1..5606885caf 100644 --- a/src/klibc/utest/TC_rt_memcpy.c +++ b/src/klibc/utest/TC_rt_memcpy.c @@ -12,9 +12,9 @@ #include <rtthread.h> #include <utest.h> -#define N 80 /**< Define the constant N for buffer size as 80 */ +#define N 80 /**< Define the constant N for buffer size as 80 */ #define TEST_BUF_SIZE 512 /**< Define the constant TEST_BUF_SIZE as 512 */ -static char *buf; /**< Define a static buffer of 512 bytes, initialized to 0 */ +static char *buf; /**< Define a static buffer of 512 bytes, initialized to 0 */ static rt_err_t utest_tc_init(void) { @@ -37,10 +37,10 @@ static rt_err_t utest_tc_cleanup(void) */ static void test_align(unsigned dalign, unsigned salign, size_t len) { - char *src = (char *)RT_ALIGN((rt_ubase_t)buf, 64); /**< Source buffer starting address, 64-byte aligned */ - char *dst = (char *)RT_ALIGN(((rt_ubase_t)buf + 128), 64); /**< Destination buffer starting address, 64-byte aligned from buf+128 */ + char *src = (char *)RT_ALIGN((rt_ubase_t)buf, 64); /**< Source buffer starting address, 64-byte aligned */ + char *dst = (char *)RT_ALIGN(((rt_ubase_t)buf + 128), 64); /**< Destination buffer starting address, 64-byte aligned from buf+128 */ char *want = (char *)RT_ALIGN(((rt_ubase_t)buf + 256), 64); /**< Expected result buffer starting address, 64-byte aligned from buf+256 */ - char *p; /**< Pointer to receive the return value of rt_memcpy */ + char *p; /**< Pointer to receive the return value of rt_memcpy */ unsigned i; /** Assert that the source alignment offset plus length does not exceed N */ @@ -49,14 +49,14 @@ static void test_align(unsigned dalign, unsigned salign, size_t len) uassert_false(dalign + len > N); /** Initialize all buffers with '#' or ' ' */ - for(i = 0; i < N; i++) + for (i = 0; i < N; i++) { src[i] = '#'; dst[i] = want[i] = ' '; } /** Set data in the specified alignment offsets of the source and expected result buffers */ - for(i = 0; i < len; i++) + for (i = 0; i < len; i++) { src[salign + i] = want[dalign + i] = (char)('0' + i); } @@ -68,7 +68,7 @@ static void test_align(unsigned dalign, unsigned salign, size_t len) uassert_ptr_equal(p, dst + dalign); /** Assert that the content of the destination buffer matches the expected result buffer */ - for(i = 0; i < N; i++) + for (i = 0; i < N; i++) { uassert_int_equal(dst[i], want[i]); } @@ -79,11 +79,11 @@ static void test_align(unsigned dalign, unsigned salign, size_t len) */ static void TC_rt_memcpy_align(void) { - for(unsigned i = 0; i < 16; i++) /**< Iterate over source alignment offsets from 0 to 15 */ + for (unsigned i = 0; i < 16; i++) /**< Iterate over source alignment offsets from 0 to 15 */ { - for(unsigned j = 0; j < 16; j++) /**< Iterate over destination alignment offsets from 0 to 15 */ + for (unsigned j = 0; j < 16; j++) /**< Iterate over destination alignment offsets from 0 to 15 */ { - for(size_t k = 0; k < 64; k++) /**< Iterate over data lengths from 0 to 63 */ + for (size_t k = 0; k < 64; k++) /**< Iterate over data lengths from 0 to 63 */ { test_align(i, j, k); /**< Call the test_align function */ } @@ -94,7 +94,7 @@ static void TC_rt_memcpy_align(void) static void TC_rt_memcpy_str(void) { const char src[] = "Hello, memcpy!"; - char dest[20] = {0}; + char dest[20] = { 0 }; rt_memcpy(dest, src, sizeof(src)); uassert_true(rt_strcmp(src, dest) == 0); } diff --git a/src/klibc/utest/TC_rt_memmove.c b/src/klibc/utest/TC_rt_memmove.c index ecb916cb27..2486664f29 100644 --- a/src/klibc/utest/TC_rt_memmove.c +++ b/src/klibc/utest/TC_rt_memmove.c @@ -15,7 +15,7 @@ static void TC_rt_memmove_basic(void) { char src[] = "Hello"; - char dest[10] = {0}; + char dest[10] = { 0 }; rt_memmove(dest, src, rt_strlen(src) + 1); uassert_str_equal(dest, "Hello"); } @@ -73,7 +73,7 @@ static void TC_rt_memmove_null_dest(void) static void TC_rt_memmove_too_long(void) { char src[] = "Short"; - char dest[10] = {0}; + char dest[10] = { 0 }; rt_memmove(dest, src, sizeof(src) + 5); /* Should only copy up to src length */ uassert_str_equal(dest, "Short"); uassert_int_equal(dest[5], 0); /* Ensure no buffer overflow */ @@ -87,7 +87,7 @@ static void TC_rt_memmove_empty_string(void) rt_memmove(dest, src, rt_strlen(src) + 1); /* Expect dest to only contain '\0' at the start */ - uassert_str_equal(dest, ""); /* Destination should now be an empty string */ + uassert_str_equal(dest, ""); /* Destination should now be an empty string */ uassert_int_equal(dest[0], '\0'); /* First character should be '\0' */ } diff --git a/src/klibc/utest/TC_rt_memset.c b/src/klibc/utest/TC_rt_memset.c index 94c2269e09..8b56fb8b81 100644 --- a/src/klibc/utest/TC_rt_memset.c +++ b/src/klibc/utest/TC_rt_memset.c @@ -43,12 +43,12 @@ static void test_align(int align, size_t len) uassert_false(len + 64 > (size_t)(buf + TEST_BUF_SIZE - s)); uassert_false(len + 64 > (size_t)(buf2 + TEST_BUF_SIZE - want)); - for(i = 0; i < TEST_BUF_SIZE; i++) + for (i = 0; i < TEST_BUF_SIZE; i++) { buf[i] = buf2[i] = ' '; } - for(i = 0; i < (int)len; i++) + for (i = 0; i < (int)len; i++) { want[i] = '#'; } @@ -57,7 +57,7 @@ static void test_align(int align, size_t len) uassert_ptr_equal(p, s); - for(i = -64; i < (int)len + 64; i++) + for (i = -64; i < (int)len + 64; i++) { uassert_int_equal(s[i], want[i]); } @@ -65,9 +65,9 @@ static void test_align(int align, size_t len) static void TC_rt_memcpy_align(void) { - for(int i = 0; i < 16; i++) + for (int i = 0; i < 16; i++) { - for(size_t j = 0; j < 200; j++) + for (size_t j = 0; j < 200; j++) { test_align(i, j); } @@ -77,7 +77,7 @@ static void TC_rt_memcpy_align(void) static void test_input(char c) { rt_memset(buf, c, 10); - for(int i = 0; i < 10; i++) + for (int i = 0; i < 10; i++) { uassert_int_equal(buf[i], c); } diff --git a/src/klibc/utest/TC_rt_sprintf.c b/src/klibc/utest/TC_rt_sprintf.c index d8bba42c08..5b3fe5c0d7 100644 --- a/src/klibc/utest/TC_rt_sprintf.c +++ b/src/klibc/utest/TC_rt_sprintf.c @@ -60,156 +60,157 @@ extremal_unsigned_integer_values #define base_buffer_size 100 -#define SPRINTF_CHECK(expected, buffer, format, ...) \ -do { \ - rt_memset(buffer, 0xCC, base_buffer_size); \ - rt_sprintf(buffer, format, ##__VA_ARGS__); \ - uassert_str_equal(expected, buffer); \ -} while (0) +#define SPRINTF_CHECK(expected, buffer, format, ...) \ + do \ + { \ + rt_memset(buffer, 0xCC, base_buffer_size); \ + rt_sprintf(buffer, format, ##__VA_ARGS__); \ + uassert_str_equal(expected, buffer); \ + } while (0) #define SPRINTF_TEST_CASE_NAME(testname) TC_##testname -#define SPRINTF_TEST_CASE(testname) static void SPRINTF_TEST_CASE_NAME(testname)(void) +#define SPRINTF_TEST_CASE(testname) static void SPRINTF_TEST_CASE_NAME(testname)(void) SPRINTF_TEST_CASE(space_flag) { char buffer[base_buffer_size]; - SPRINTF_CHECK(" 42", buffer, "% d", 42); - SPRINTF_CHECK("-42", buffer, "% d", -42); - SPRINTF_CHECK(" 42", buffer, "% 5d", 42); - SPRINTF_CHECK(" -42", buffer, "% 5d", -42); - SPRINTF_CHECK(" 42", buffer, "% 15d", 42); - SPRINTF_CHECK(" -42", buffer, "% 15d", -42); - SPRINTF_CHECK(" -42", buffer, "% 15d", -42); + SPRINTF_CHECK(" 42", buffer, "% d", 42); + SPRINTF_CHECK("-42", buffer, "% d", -42); + SPRINTF_CHECK(" 42", buffer, "% 5d", 42); + SPRINTF_CHECK(" -42", buffer, "% 5d", -42); + SPRINTF_CHECK(" 42", buffer, "% 15d", 42); + SPRINTF_CHECK(" -42", buffer, "% 15d", -42); + SPRINTF_CHECK(" -42", buffer, "% 15d", -42); #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - SPRINTF_CHECK(" -42.987", buffer, "% 15.3f", -42.987); - SPRINTF_CHECK(" 42.987", buffer, "% 15.3f", 42.987); + SPRINTF_CHECK(" -42.987", buffer, "% 15.3f", -42.987); + SPRINTF_CHECK(" 42.987", buffer, "% 15.3f", 42.987); #endif - SPRINTF_CHECK(" 1024", buffer, "% d", 1024); - SPRINTF_CHECK("-1024", buffer, "% d", -1024); - SPRINTF_CHECK(" 1024", buffer, "% i", 1024); - SPRINTF_CHECK("-1024", buffer, "% i", -1024); + SPRINTF_CHECK(" 1024", buffer, "% d", 1024); + SPRINTF_CHECK("-1024", buffer, "% d", -1024); + SPRINTF_CHECK(" 1024", buffer, "% i", 1024); + SPRINTF_CHECK("-1024", buffer, "% i", -1024); } SPRINTF_TEST_CASE(space_flag__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK("Hello testing", buffer, "% s", "Hello testing"); - SPRINTF_CHECK("1024", buffer, "% u", 1024); + SPRINTF_CHECK("Hello testing", buffer, "% s", "Hello testing"); + SPRINTF_CHECK("1024", buffer, "% u", 1024); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK("1024", buffer, "% I16u", (uint16_t) 1024); - SPRINTF_CHECK("1024", buffer, "% I32u", (uint32_t) 1024); - SPRINTF_CHECK("1024", buffer, "% I64u", (uint64_t) 1024); + SPRINTF_CHECK("1024", buffer, "% I16u", (uint16_t)1024); + SPRINTF_CHECK("1024", buffer, "% I32u", (uint32_t)1024); + SPRINTF_CHECK("1024", buffer, "% I64u", (uint64_t)1024); #endif - SPRINTF_CHECK("4294966272", buffer, "% u", 4294966272U); + SPRINTF_CHECK("4294966272", buffer, "% u", 4294966272U); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK("4294966272", buffer, "% I32u", (uint32_t) 4294966272U); - SPRINTF_CHECK("4294966272", buffer, "% I64u", (uint64_t) 4294966272U); + SPRINTF_CHECK("4294966272", buffer, "% I32u", (uint32_t)4294966272U); + SPRINTF_CHECK("4294966272", buffer, "% I64u", (uint64_t)4294966272U); #endif - SPRINTF_CHECK("777", buffer, "% o", 511); - SPRINTF_CHECK("37777777001", buffer, "% o", 4294966785U); - SPRINTF_CHECK("1234abcd", buffer, "% x", 305441741); - SPRINTF_CHECK("edcb5433", buffer, "% x", 3989525555U); - SPRINTF_CHECK("1234ABCD", buffer, "% X", 305441741); - SPRINTF_CHECK("EDCB5433", buffer, "% X", 3989525555U); - SPRINTF_CHECK("x", buffer, "% c", 'x'); + SPRINTF_CHECK("777", buffer, "% o", 511); + SPRINTF_CHECK("37777777001", buffer, "% o", 4294966785U); + SPRINTF_CHECK("1234abcd", buffer, "% x", 305441741); + SPRINTF_CHECK("edcb5433", buffer, "% x", 3989525555U); + SPRINTF_CHECK("1234ABCD", buffer, "% X", 305441741); + SPRINTF_CHECK("EDCB5433", buffer, "% X", 3989525555U); + SPRINTF_CHECK("x", buffer, "% c", 'x'); } SPRINTF_TEST_CASE(plus_flag) { char buffer[base_buffer_size]; - SPRINTF_CHECK("+42", buffer, "%+d", 42); - SPRINTF_CHECK("-42", buffer, "%+d", -42); - SPRINTF_CHECK(" +42", buffer, "%+5d", 42); - SPRINTF_CHECK(" -42", buffer, "%+5d", -42); - SPRINTF_CHECK(" +42", buffer, "%+15d", 42); - SPRINTF_CHECK(" -42", buffer, "%+15d", -42); - SPRINTF_CHECK("+1024", buffer, "%+d", 1024); - SPRINTF_CHECK("-1024", buffer, "%+d", -1024); - SPRINTF_CHECK("+1024", buffer, "%+i", 1024); - SPRINTF_CHECK("-1024", buffer, "%+i", -1024); + SPRINTF_CHECK("+42", buffer, "%+d", 42); + SPRINTF_CHECK("-42", buffer, "%+d", -42); + SPRINTF_CHECK(" +42", buffer, "%+5d", 42); + SPRINTF_CHECK(" -42", buffer, "%+5d", -42); + SPRINTF_CHECK(" +42", buffer, "%+15d", 42); + SPRINTF_CHECK(" -42", buffer, "%+15d", -42); + SPRINTF_CHECK("+1024", buffer, "%+d", 1024); + SPRINTF_CHECK("-1024", buffer, "%+d", -1024); + SPRINTF_CHECK("+1024", buffer, "%+i", 1024); + SPRINTF_CHECK("-1024", buffer, "%+i", -1024); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK("+1024", buffer, "%+I16d", (int16_t) 1024); - SPRINTF_CHECK("-1024", buffer, "%+I16d", (int16_t) -1024); - SPRINTF_CHECK("+1024", buffer, "%+I32d", (int32_t) 1024); - SPRINTF_CHECK("-1024", buffer, "%+I32d", (int32_t) -1024); - SPRINTF_CHECK("+1024", buffer, "%+I64d", (int64_t) 1024); - SPRINTF_CHECK("-1024", buffer, "%+I64d", (int64_t) -1024); + SPRINTF_CHECK("+1024", buffer, "%+I16d", (int16_t)1024); + SPRINTF_CHECK("-1024", buffer, "%+I16d", (int16_t)-1024); + SPRINTF_CHECK("+1024", buffer, "%+I32d", (int32_t)1024); + SPRINTF_CHECK("-1024", buffer, "%+I32d", (int32_t)-1024); + SPRINTF_CHECK("+1024", buffer, "%+I64d", (int64_t)1024); + SPRINTF_CHECK("-1024", buffer, "%+I64d", (int64_t)-1024); #endif - SPRINTF_CHECK("+", buffer, "%+.0d", 0); + SPRINTF_CHECK("+", buffer, "%+.0d", 0); } SPRINTF_TEST_CASE(plus_flag__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK("Hello testing", buffer, "%+s", "Hello testing"); - SPRINTF_CHECK("1024", buffer, "%+u", 1024); + SPRINTF_CHECK("Hello testing", buffer, "%+s", "Hello testing"); + SPRINTF_CHECK("1024", buffer, "%+u", 1024); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK("1024", buffer, "%+I32u", (uint32_t) 1024); + SPRINTF_CHECK("1024", buffer, "%+I32u", (uint32_t)1024); #endif - SPRINTF_CHECK("4294966272", buffer, "%+u", 4294966272U); + SPRINTF_CHECK("4294966272", buffer, "%+u", 4294966272U); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK("4294966272", buffer, "%+I32u", (uint32_t) 4294966272U); + SPRINTF_CHECK("4294966272", buffer, "%+I32u", (uint32_t)4294966272U); #endif - SPRINTF_CHECK("777", buffer, "%+o", 511); - SPRINTF_CHECK("37777777001", buffer, "%+o", 4294966785U); - SPRINTF_CHECK("1234abcd", buffer, "%+x", 305441741); - SPRINTF_CHECK("edcb5433", buffer, "%+x", 3989525555U); - SPRINTF_CHECK("1234ABCD", buffer, "%+X", 305441741); - SPRINTF_CHECK("EDCB5433", buffer, "%+X", 3989525555U); - SPRINTF_CHECK("x", buffer, "%+c", 'x'); + SPRINTF_CHECK("777", buffer, "%+o", 511); + SPRINTF_CHECK("37777777001", buffer, "%+o", 4294966785U); + SPRINTF_CHECK("1234abcd", buffer, "%+x", 305441741); + SPRINTF_CHECK("edcb5433", buffer, "%+x", 3989525555U); + SPRINTF_CHECK("1234ABCD", buffer, "%+X", 305441741); + SPRINTF_CHECK("EDCB5433", buffer, "%+X", 3989525555U); + SPRINTF_CHECK("x", buffer, "%+c", 'x'); } SPRINTF_TEST_CASE(zero_flag) { char buffer[base_buffer_size]; - SPRINTF_CHECK("42", buffer, "%0d", 42); - SPRINTF_CHECK("42", buffer, "%0ld", 42L); - SPRINTF_CHECK("-42", buffer, "%0d", -42); - SPRINTF_CHECK("00042", buffer, "%05d", 42); - SPRINTF_CHECK("-0042", buffer, "%05d", -42); - SPRINTF_CHECK("000000000000042", buffer, "%015d", 42); - SPRINTF_CHECK("-00000000000042", buffer, "%015d", -42); + SPRINTF_CHECK("42", buffer, "%0d", 42); + SPRINTF_CHECK("42", buffer, "%0ld", 42L); + SPRINTF_CHECK("-42", buffer, "%0d", -42); + SPRINTF_CHECK("00042", buffer, "%05d", 42); + SPRINTF_CHECK("-0042", buffer, "%05d", -42); + SPRINTF_CHECK("000000000000042", buffer, "%015d", 42); + SPRINTF_CHECK("-00000000000042", buffer, "%015d", -42); #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - SPRINTF_CHECK("000000000042.12", buffer, "%015.2f", 42.1234); - SPRINTF_CHECK("00000000042.988", buffer, "%015.3f", 42.9876); - SPRINTF_CHECK("-00000042.98760", buffer, "%015.5f", -42.9876); + SPRINTF_CHECK("000000000042.12", buffer, "%015.2f", 42.1234); + SPRINTF_CHECK("00000000042.988", buffer, "%015.3f", 42.9876); + SPRINTF_CHECK("-00000042.98760", buffer, "%015.5f", -42.9876); #endif } SPRINTF_TEST_CASE(minus_flag) { char buffer[base_buffer_size]; - SPRINTF_CHECK("42", buffer, "%-d", 42); - SPRINTF_CHECK("-42", buffer, "%-d", -42); - SPRINTF_CHECK("42 ", buffer, "%-5d", 42); - SPRINTF_CHECK("-42 ", buffer, "%-5d", -42); - SPRINTF_CHECK("42 ", buffer, "%-15d", 42); - SPRINTF_CHECK("-42 ", buffer, "%-15d", -42); + SPRINTF_CHECK("42", buffer, "%-d", 42); + SPRINTF_CHECK("-42", buffer, "%-d", -42); + SPRINTF_CHECK("42 ", buffer, "%-5d", 42); + SPRINTF_CHECK("-42 ", buffer, "%-5d", -42); + SPRINTF_CHECK("42 ", buffer, "%-15d", 42); + SPRINTF_CHECK("-42 ", buffer, "%-15d", -42); } SPRINTF_TEST_CASE(minus_flag_and_non_standard_zero_modifier_for_integers) { char buffer[base_buffer_size]; - SPRINTF_CHECK("42", buffer, "%-0d", 42); - SPRINTF_CHECK("-42", buffer, "%-0d", -42); - SPRINTF_CHECK("42 ", buffer, "%-05d", 42); - SPRINTF_CHECK("-42 ", buffer, "%-05d", -42); - SPRINTF_CHECK("42 ", buffer, "%-015d", 42); - SPRINTF_CHECK("-42 ", buffer, "%-015d", -42); - SPRINTF_CHECK("42", buffer, "%0-d", 42); - SPRINTF_CHECK("-42", buffer, "%0-d", -42); - SPRINTF_CHECK("42 ", buffer, "%0-5d", 42); - SPRINTF_CHECK("-42 ", buffer, "%0-5d", -42); - SPRINTF_CHECK("42 ", buffer, "%0-15d", 42); - SPRINTF_CHECK("-42 ", buffer, "%0-15d", -42); + SPRINTF_CHECK("42", buffer, "%-0d", 42); + SPRINTF_CHECK("-42", buffer, "%-0d", -42); + SPRINTF_CHECK("42 ", buffer, "%-05d", 42); + SPRINTF_CHECK("-42 ", buffer, "%-05d", -42); + SPRINTF_CHECK("42 ", buffer, "%-015d", 42); + SPRINTF_CHECK("-42 ", buffer, "%-015d", -42); + SPRINTF_CHECK("42", buffer, "%0-d", 42); + SPRINTF_CHECK("-42", buffer, "%0-d", -42); + SPRINTF_CHECK("42 ", buffer, "%0-5d", 42); + SPRINTF_CHECK("-42 ", buffer, "%0-5d", -42); + SPRINTF_CHECK("42 ", buffer, "%0-15d", 42); + SPRINTF_CHECK("-42 ", buffer, "%0-15d", -42); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - SPRINTF_CHECK("-4.200e+01 ", buffer, "%0-15.3e", -42.); - SPRINTF_CHECK("-42 ", buffer, "%0-15.3g", -42.); + SPRINTF_CHECK("-4.200e+01 ", buffer, "%0-15.3e", -42.); + SPRINTF_CHECK("-42 ", buffer, "%0-15.3g", -42.); #else - SPRINTF_CHECK("e", buffer, "%0-15.3e", -42.); - SPRINTF_CHECK("g", buffer, "%0-15.3g", -42.); + SPRINTF_CHECK("e", buffer, "%0-15.3e", -42.); + SPRINTF_CHECK("g", buffer, "%0-15.3g", -42.); #endif /* RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS */ #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ } @@ -218,41 +219,41 @@ SPRINTF_TEST_CASE(sharp_flag) { char buffer[base_buffer_size]; #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("0", buffer, "%#o", 0); - SPRINTF_CHECK("0", buffer, "%#0o", 0); + SPRINTF_CHECK("0", buffer, "%#o", 0); + SPRINTF_CHECK("0", buffer, "%#0o", 0); #endif - SPRINTF_CHECK("0", buffer, "%#.0o", 0); + SPRINTF_CHECK("0", buffer, "%#.0o", 0); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("0", buffer, "%#.1o", 0); - SPRINTF_CHECK(" 0", buffer, "%#4o", 0); - SPRINTF_CHECK("0000", buffer, "%#.4o", 0); + SPRINTF_CHECK("0", buffer, "%#.1o", 0); + SPRINTF_CHECK(" 0", buffer, "%#4o", 0); + SPRINTF_CHECK("0000", buffer, "%#.4o", 0); #endif - SPRINTF_CHECK("01", buffer, "%#o", 1); - SPRINTF_CHECK("01", buffer, "%#0o", 1); + SPRINTF_CHECK("01", buffer, "%#o", 1); + SPRINTF_CHECK("01", buffer, "%#0o", 1); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("01", buffer, "%#.0o", 1); + SPRINTF_CHECK("01", buffer, "%#.0o", 1); #endif - SPRINTF_CHECK("01", buffer, "%#.1o", 1); - SPRINTF_CHECK(" 01", buffer, "%#4o", 1); + SPRINTF_CHECK("01", buffer, "%#.1o", 1); + SPRINTF_CHECK(" 01", buffer, "%#4o", 1); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("0001", buffer, "%#.4o", 1); + SPRINTF_CHECK("0001", buffer, "%#.4o", 1); #endif - SPRINTF_CHECK("0x1001", buffer, "%#04x", 0x1001); - SPRINTF_CHECK("01001", buffer, "%#04o", 01001); + SPRINTF_CHECK("0x1001", buffer, "%#04x", 0x1001); + SPRINTF_CHECK("01001", buffer, "%#04o", 01001); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("", buffer, "%#.0x", 0); + SPRINTF_CHECK("", buffer, "%#.0x", 0); #endif - SPRINTF_CHECK("0x0000614e", buffer, "%#.8x", 0x614e); + SPRINTF_CHECK("0x0000614e", buffer, "%#.8x", 0x614e); } SPRINTF_TEST_CASE(sharp_flag__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK("0b110", buffer, "%#b", 6); - SPRINTF_CHECK("0b11111111", buffer, "%#010b", 0xff); - SPRINTF_CHECK("0b011111111", buffer, "%#011b", 0xff); - SPRINTF_CHECK("077", buffer, "%#03o", 077); - SPRINTF_CHECK("0077", buffer, "%#04o", 077); + SPRINTF_CHECK("0b110", buffer, "%#b", 6); + SPRINTF_CHECK("0b11111111", buffer, "%#010b", 0xff); + SPRINTF_CHECK("0b011111111", buffer, "%#011b", 0xff); + SPRINTF_CHECK("077", buffer, "%#03o", 077); + SPRINTF_CHECK("0077", buffer, "%#04o", 077); } #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG @@ -260,72 +261,72 @@ SPRINTF_TEST_CASE(sharp_flag_with_long_long) { char buffer[base_buffer_size]; #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("0", buffer, "%#llo", (long long) 0); - SPRINTF_CHECK("0", buffer, "%#0llo", (long long) 0); + SPRINTF_CHECK("0", buffer, "%#llo", (long long)0); + SPRINTF_CHECK("0", buffer, "%#0llo", (long long)0); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ - SPRINTF_CHECK("0", buffer, "%#.0llo", (long long) 0); + SPRINTF_CHECK("0", buffer, "%#.0llo", (long long)0); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("0", buffer, "%#.1llo", (long long) 0); - SPRINTF_CHECK(" 0", buffer, "%#4llo", (long long) 0); - SPRINTF_CHECK("0000", buffer, "%#.4llo", (long long) 0); + SPRINTF_CHECK("0", buffer, "%#.1llo", (long long)0); + SPRINTF_CHECK(" 0", buffer, "%#4llo", (long long)0); + SPRINTF_CHECK("0000", buffer, "%#.4llo", (long long)0); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ - SPRINTF_CHECK("01", buffer, "%#llo", (long long) 1); - SPRINTF_CHECK("01", buffer, "%#0llo", (long long) 1); + SPRINTF_CHECK("01", buffer, "%#llo", (long long)1); + SPRINTF_CHECK("01", buffer, "%#0llo", (long long)1); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("01", buffer, "%#.0llo", (long long) 1); + SPRINTF_CHECK("01", buffer, "%#.0llo", (long long)1); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ - SPRINTF_CHECK("01", buffer, "%#.1llo", (long long) 1); - SPRINTF_CHECK(" 01", buffer, "%#4llo", (long long) 1); + SPRINTF_CHECK("01", buffer, "%#.1llo", (long long)1); + SPRINTF_CHECK(" 01", buffer, "%#4llo", (long long)1); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("0001", buffer, "%#.4llo", (long long) 1); + SPRINTF_CHECK("0001", buffer, "%#.4llo", (long long)1); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ - SPRINTF_CHECK("0x1001", buffer, "%#04llx", (long long) 0x1001); - SPRINTF_CHECK("01001", buffer, "%#04llo", (long long) 01001); + SPRINTF_CHECK("0x1001", buffer, "%#04llx", (long long)0x1001); + SPRINTF_CHECK("01001", buffer, "%#04llo", (long long)01001); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("", buffer, "%#.0llx", (long long) 0); + SPRINTF_CHECK("", buffer, "%#.0llx", (long long)0); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ - SPRINTF_CHECK("0x0000614e", buffer, "%#.8llx", (long long) 0x614e); + SPRINTF_CHECK("0x0000614e", buffer, "%#.8llx", (long long)0x614e); } SPRINTF_TEST_CASE(sharp_flag_with_long_long__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK("0b110", buffer, "%#llb", (long long) 6); + SPRINTF_CHECK("0b110", buffer, "%#llb", (long long)6); } #endif /* RT_KLIBC_USING_VSNPRINTF_LONGLONG */ SPRINTF_TEST_CASE(specifier) { char buffer[base_buffer_size]; - SPRINTF_CHECK("Hello testing", buffer, "Hello testing"); - SPRINTF_CHECK("Hello testing", buffer, "%s", "Hello testing"); - SPRINTF_CHECK("(null)", buffer, "%s", (const char *) RT_NULL); - SPRINTF_CHECK("1024", buffer, "%d", 1024); + SPRINTF_CHECK("Hello testing", buffer, "Hello testing"); + SPRINTF_CHECK("Hello testing", buffer, "%s", "Hello testing"); + SPRINTF_CHECK("(null)", buffer, "%s", (const char *)RT_NULL); + SPRINTF_CHECK("1024", buffer, "%d", 1024); #if INT_MAX >= 2147483647LL - SPRINTF_CHECK("2147483647", buffer, "%d", 2147483647); - SPRINTF_CHECK("4294966272", buffer, "%u", 4294966272U); - SPRINTF_CHECK("37777777001", buffer, "%o", 4294966785U); - SPRINTF_CHECK("1234abcd", buffer, "%x", 305441741); - SPRINTF_CHECK("edcb5433", buffer, "%x", 3989525555U); - SPRINTF_CHECK("1234ABCD", buffer, "%X", 305441741); - SPRINTF_CHECK("EDCB5433", buffer, "%X", 3989525555U); + SPRINTF_CHECK("2147483647", buffer, "%d", 2147483647); + SPRINTF_CHECK("4294966272", buffer, "%u", 4294966272U); + SPRINTF_CHECK("37777777001", buffer, "%o", 4294966785U); + SPRINTF_CHECK("1234abcd", buffer, "%x", 305441741); + SPRINTF_CHECK("edcb5433", buffer, "%x", 3989525555U); + SPRINTF_CHECK("1234ABCD", buffer, "%X", 305441741); + SPRINTF_CHECK("EDCB5433", buffer, "%X", 3989525555U); #endif - SPRINTF_CHECK("-1024", buffer, "%d", -1024); - SPRINTF_CHECK("1024", buffer, "%i", 1024); - SPRINTF_CHECK("-1024", buffer, "%i", -1024); - SPRINTF_CHECK("1024", buffer, "%u", 1024); - SPRINTF_CHECK("777", buffer, "%o", 511); - SPRINTF_CHECK("%", buffer, "%%"); + SPRINTF_CHECK("-1024", buffer, "%d", -1024); + SPRINTF_CHECK("1024", buffer, "%i", 1024); + SPRINTF_CHECK("-1024", buffer, "%i", -1024); + SPRINTF_CHECK("1024", buffer, "%u", 1024); + SPRINTF_CHECK("777", buffer, "%o", 511); + SPRINTF_CHECK("%", buffer, "%%"); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK("127", buffer, "%I8d", (int8_t) 127LL); + SPRINTF_CHECK("127", buffer, "%I8d", (int8_t)127LL); #if (SHRT_MAX >= 32767) - SPRINTF_CHECK("32767", buffer, "%I16d", (int16_t) 32767LL); + SPRINTF_CHECK("32767", buffer, "%I16d", (int16_t)32767LL); #endif #if (LLONG_MAX >= 2147483647) - SPRINTF_CHECK("2147483647", buffer, "%I32d", (int32_t) 2147483647LL); + SPRINTF_CHECK("2147483647", buffer, "%I32d", (int32_t)2147483647LL); #if (LLONG_MAX >= 9223372036854775807LL) - SPRINTF_CHECK("9223372036854775807", buffer, "%I64d", (int64_t) 9223372036854775807LL); + SPRINTF_CHECK("9223372036854775807", buffer, "%I64d", (int64_t)9223372036854775807LL); #endif #endif #endif /* RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS */ @@ -335,116 +336,116 @@ SPRINTF_TEST_CASE(width) { char buffer[base_buffer_size]; #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("Hello testing", buffer, "%1s", "Hello testing"); + SPRINTF_CHECK("Hello testing", buffer, "%1s", "Hello testing"); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ - SPRINTF_CHECK("1024", buffer, "%1d", 1024); - SPRINTF_CHECK("-1024", buffer, "%1d", -1024); - SPRINTF_CHECK("1024", buffer, "%1i", 1024); - SPRINTF_CHECK("-1024", buffer, "%1i", -1024); - SPRINTF_CHECK("1024", buffer, "%1u", 1024); + SPRINTF_CHECK("1024", buffer, "%1d", 1024); + SPRINTF_CHECK("-1024", buffer, "%1d", -1024); + SPRINTF_CHECK("1024", buffer, "%1i", 1024); + SPRINTF_CHECK("-1024", buffer, "%1i", -1024); + SPRINTF_CHECK("1024", buffer, "%1u", 1024); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK("1024", buffer, "%1I16u", (uint16_t) 1024); - SPRINTF_CHECK("1024", buffer, "%1I32u", (uint32_t) 1024); - SPRINTF_CHECK("1024", buffer, "%1I64u", (uint64_t) 1024); + SPRINTF_CHECK("1024", buffer, "%1I16u", (uint16_t)1024); + SPRINTF_CHECK("1024", buffer, "%1I32u", (uint32_t)1024); + SPRINTF_CHECK("1024", buffer, "%1I64u", (uint64_t)1024); #endif /* RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS */ - SPRINTF_CHECK("4294966272", buffer, "%1u", 4294966272U); + SPRINTF_CHECK("4294966272", buffer, "%1u", 4294966272U); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK("4294966272", buffer, "%1I32u", (uint32_t) 4294966272U); - SPRINTF_CHECK("4294966272", buffer, "%1I64u", (uint64_t) 4294966272U); + SPRINTF_CHECK("4294966272", buffer, "%1I32u", (uint32_t)4294966272U); + SPRINTF_CHECK("4294966272", buffer, "%1I64u", (uint64_t)4294966272U); #endif /* RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS */ - SPRINTF_CHECK("777", buffer, "%1o", 511); - SPRINTF_CHECK("37777777001", buffer, "%1o", 4294966785U); - SPRINTF_CHECK("1234abcd", buffer, "%1x", 305441741); - SPRINTF_CHECK("edcb5433", buffer, "%1x", 3989525555U); - SPRINTF_CHECK("1234ABCD", buffer, "%1X", 305441741); - SPRINTF_CHECK("EDCB5433", buffer, "%1X", 3989525555U); - SPRINTF_CHECK("x", buffer, "%1c", 'x'); + SPRINTF_CHECK("777", buffer, "%1o", 511); + SPRINTF_CHECK("37777777001", buffer, "%1o", 4294966785U); + SPRINTF_CHECK("1234abcd", buffer, "%1x", 305441741); + SPRINTF_CHECK("edcb5433", buffer, "%1x", 3989525555U); + SPRINTF_CHECK("1234ABCD", buffer, "%1X", 305441741); + SPRINTF_CHECK("EDCB5433", buffer, "%1X", 3989525555U); + SPRINTF_CHECK("x", buffer, "%1c", 'x'); } SPRINTF_TEST_CASE(width_20) { char buffer[base_buffer_size]; - SPRINTF_CHECK(" Hello", buffer, "%20s", "Hello"); - SPRINTF_CHECK(" 1024", buffer, "%20d", 1024); - SPRINTF_CHECK(" -1024", buffer, "%20d", -1024); - SPRINTF_CHECK(" 1024", buffer, "%20i", 1024); - SPRINTF_CHECK(" -1024", buffer, "%20i", -1024); - SPRINTF_CHECK(" 0", buffer, "%20i", 0); - SPRINTF_CHECK(" 1024", buffer, "%20u", 1024); + SPRINTF_CHECK(" Hello", buffer, "%20s", "Hello"); + SPRINTF_CHECK(" 1024", buffer, "%20d", 1024); + SPRINTF_CHECK(" -1024", buffer, "%20d", -1024); + SPRINTF_CHECK(" 1024", buffer, "%20i", 1024); + SPRINTF_CHECK(" -1024", buffer, "%20i", -1024); + SPRINTF_CHECK(" 0", buffer, "%20i", 0); + SPRINTF_CHECK(" 1024", buffer, "%20u", 1024); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK(" 1024", buffer, "%20I16u", (uint16_t) 1024); - SPRINTF_CHECK(" 1024", buffer, "%20I32u", (uint32_t) 1024); - SPRINTF_CHECK(" 1024", buffer, "%20I64u", (uint64_t) 1024); + SPRINTF_CHECK(" 1024", buffer, "%20I16u", (uint16_t)1024); + SPRINTF_CHECK(" 1024", buffer, "%20I32u", (uint32_t)1024); + SPRINTF_CHECK(" 1024", buffer, "%20I64u", (uint64_t)1024); #endif /* RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS */ - SPRINTF_CHECK(" 4294966272", buffer, "%20u", 4294966272U); + SPRINTF_CHECK(" 4294966272", buffer, "%20u", 4294966272U); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK(" 4294966272", buffer, "%20I32u", (uint32_t) 4294966272U); - SPRINTF_CHECK(" 4294966272", buffer, "%20I64u", (uint64_t) 4294966272U); + SPRINTF_CHECK(" 4294966272", buffer, "%20I32u", (uint32_t)4294966272U); + SPRINTF_CHECK(" 4294966272", buffer, "%20I64u", (uint64_t)4294966272U); #endif /* RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS */ - SPRINTF_CHECK(" 777", buffer, "%20o", 511); - SPRINTF_CHECK(" 37777777001", buffer, "%20o", 4294966785U); - SPRINTF_CHECK(" 1234abcd", buffer, "%20x", 305441741); - SPRINTF_CHECK(" edcb5433", buffer, "%20x", 3989525555U); - SPRINTF_CHECK(" 1234ABCD", buffer, "%20X", 305441741); - SPRINTF_CHECK(" EDCB5433", buffer, "%20X", 3989525555U); - SPRINTF_CHECK(" 0", buffer, "%20X", 0); - SPRINTF_CHECK(" 0", buffer, "%20X", 0U); + SPRINTF_CHECK(" 777", buffer, "%20o", 511); + SPRINTF_CHECK(" 37777777001", buffer, "%20o", 4294966785U); + SPRINTF_CHECK(" 1234abcd", buffer, "%20x", 305441741); + SPRINTF_CHECK(" edcb5433", buffer, "%20x", 3989525555U); + SPRINTF_CHECK(" 1234ABCD", buffer, "%20X", 305441741); + SPRINTF_CHECK(" EDCB5433", buffer, "%20X", 3989525555U); + SPRINTF_CHECK(" 0", buffer, "%20X", 0); + SPRINTF_CHECK(" 0", buffer, "%20X", 0U); #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - SPRINTF_CHECK(" 0", buffer, "%20llX", 0ULL); + SPRINTF_CHECK(" 0", buffer, "%20llX", 0ULL); #endif /* RT_KLIBC_USING_VSNPRINTF_LONGLONG */ - SPRINTF_CHECK(" x", buffer, "%20c", 'x'); + SPRINTF_CHECK(" x", buffer, "%20c", 'x'); } SPRINTF_TEST_CASE(width_asterisk_20) { char buffer[base_buffer_size]; - SPRINTF_CHECK(" Hello", buffer, "%*s", 20, "Hello"); - SPRINTF_CHECK(" 1024", buffer, "%*d", 20, 1024); - SPRINTF_CHECK(" -1024", buffer, "%*d", 20, -1024); - SPRINTF_CHECK(" 1024", buffer, "%*i", 20, 1024); - SPRINTF_CHECK(" -1024", buffer, "%*i", 20, -1024); - SPRINTF_CHECK(" 1024", buffer, "%*u", 20, 1024); + SPRINTF_CHECK(" Hello", buffer, "%*s", 20, "Hello"); + SPRINTF_CHECK(" 1024", buffer, "%*d", 20, 1024); + SPRINTF_CHECK(" -1024", buffer, "%*d", 20, -1024); + SPRINTF_CHECK(" 1024", buffer, "%*i", 20, 1024); + SPRINTF_CHECK(" -1024", buffer, "%*i", 20, -1024); + SPRINTF_CHECK(" 1024", buffer, "%*u", 20, 1024); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK(" 1024", buffer, "%*I16u", 20, (uint16_t) 1024); - SPRINTF_CHECK(" 1024", buffer, "%*I32u", 20, (uint32_t) 1024); - SPRINTF_CHECK(" 1024", buffer, "%*I64u", 20, (uint64_t) 1024); + SPRINTF_CHECK(" 1024", buffer, "%*I16u", 20, (uint16_t)1024); + SPRINTF_CHECK(" 1024", buffer, "%*I32u", 20, (uint32_t)1024); + SPRINTF_CHECK(" 1024", buffer, "%*I64u", 20, (uint64_t)1024); #endif /* RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS */ - SPRINTF_CHECK(" 4294966272", buffer, "%*u", 20, 4294966272U); + SPRINTF_CHECK(" 4294966272", buffer, "%*u", 20, 4294966272U); #ifdef RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - SPRINTF_CHECK(" 4294966272", buffer, "%*I32u", 20, (uint32_t) 4294966272U); - SPRINTF_CHECK(" 4294966272", buffer, "%*I64u", 20, (uint64_t) 4294966272U); + SPRINTF_CHECK(" 4294966272", buffer, "%*I32u", 20, (uint32_t)4294966272U); + SPRINTF_CHECK(" 4294966272", buffer, "%*I64u", 20, (uint64_t)4294966272U); #endif /* RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS */ - SPRINTF_CHECK(" 777", buffer, "%*o", 20, 511); - SPRINTF_CHECK(" 37777777001", buffer, "%*o", 20, 4294966785U); - SPRINTF_CHECK(" 1234abcd", buffer, "%*x", 20, 305441741); - SPRINTF_CHECK(" edcb5433", buffer, "%*x", 20, 3989525555U); - SPRINTF_CHECK(" 1234ABCD", buffer, "%*X", 20, 305441741); - SPRINTF_CHECK(" EDCB5433", buffer, "%*X", 20, 3989525555U); - SPRINTF_CHECK(" x", buffer, "%*c", 20, 'x'); + SPRINTF_CHECK(" 777", buffer, "%*o", 20, 511); + SPRINTF_CHECK(" 37777777001", buffer, "%*o", 20, 4294966785U); + SPRINTF_CHECK(" 1234abcd", buffer, "%*x", 20, 305441741); + SPRINTF_CHECK(" edcb5433", buffer, "%*x", 20, 3989525555U); + SPRINTF_CHECK(" 1234ABCD", buffer, "%*X", 20, 305441741); + SPRINTF_CHECK(" EDCB5433", buffer, "%*X", 20, 3989525555U); + SPRINTF_CHECK(" x", buffer, "%*c", 20, 'x'); } SPRINTF_TEST_CASE(width_minus_20) { char buffer[base_buffer_size]; - SPRINTF_CHECK("Hello ", buffer, "%-20s", "Hello"); - SPRINTF_CHECK("1024 ", buffer, "%-20d", 1024); - SPRINTF_CHECK("-1024 ", buffer, "%-20d", -1024); - SPRINTF_CHECK("1024 ", buffer, "%-20i", 1024); - SPRINTF_CHECK("-1024 ", buffer, "%-20i", -1024); - SPRINTF_CHECK("1024 ", buffer, "%-20u", 1024); + SPRINTF_CHECK("Hello ", buffer, "%-20s", "Hello"); + SPRINTF_CHECK("1024 ", buffer, "%-20d", 1024); + SPRINTF_CHECK("-1024 ", buffer, "%-20d", -1024); + SPRINTF_CHECK("1024 ", buffer, "%-20i", 1024); + SPRINTF_CHECK("-1024 ", buffer, "%-20i", -1024); + SPRINTF_CHECK("1024 ", buffer, "%-20u", 1024); #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - SPRINTF_CHECK("1024.1234 ", buffer, "%-20.4f", 1024.1234); + SPRINTF_CHECK("1024.1234 ", buffer, "%-20.4f", 1024.1234); #endif /* RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS */ - SPRINTF_CHECK("4294966272 ", buffer, "%-20u", 4294966272U); - SPRINTF_CHECK("777 ", buffer, "%-20o", 511); - SPRINTF_CHECK("37777777001 ", buffer, "%-20o", 4294966785U); - SPRINTF_CHECK("1234abcd ", buffer, "%-20x", 305441741); - SPRINTF_CHECK("edcb5433 ", buffer, "%-20x", 3989525555U); - SPRINTF_CHECK("1234ABCD ", buffer, "%-20X", 305441741); - SPRINTF_CHECK("EDCB5433 ", buffer, "%-20X", 3989525555U); - SPRINTF_CHECK("x ", buffer, "%-20c", 'x'); - SPRINTF_CHECK("| 9| |9 | | 9|", buffer, "|%5d| |%-2d| |%5d|", 9, 9, 9); - SPRINTF_CHECK("| 10| |10| | 10|", buffer, "|%5d| |%-2d| |%5d|", 10, 10, 10); + SPRINTF_CHECK("4294966272 ", buffer, "%-20u", 4294966272U); + SPRINTF_CHECK("777 ", buffer, "%-20o", 511); + SPRINTF_CHECK("37777777001 ", buffer, "%-20o", 4294966785U); + SPRINTF_CHECK("1234abcd ", buffer, "%-20x", 305441741); + SPRINTF_CHECK("edcb5433 ", buffer, "%-20x", 3989525555U); + SPRINTF_CHECK("1234ABCD ", buffer, "%-20X", 305441741); + SPRINTF_CHECK("EDCB5433 ", buffer, "%-20X", 3989525555U); + SPRINTF_CHECK("x ", buffer, "%-20c", 'x'); + SPRINTF_CHECK("| 9| |9 | | 9|", buffer, "|%5d| |%-2d| |%5d|", 9, 9, 9); + SPRINTF_CHECK("| 10| |10| | 10|", buffer, "|%5d| |%-2d| |%5d|", 10, 10, 10); SPRINTF_CHECK("| 9| |9 | | 9|", buffer, "|%5d| |%-12d| |%5d|", 9, 9, 9); SPRINTF_CHECK("| 10| |10 | | 10|", buffer, "|%5d| |%-12d| |%5d|", 10, 10, 10); } @@ -452,115 +453,115 @@ SPRINTF_TEST_CASE(width_minus_20) SPRINTF_TEST_CASE(width_0_minus_20) { char buffer[base_buffer_size]; - SPRINTF_CHECK("Hello ", buffer, "%0-20s", "Hello"); - SPRINTF_CHECK("1024 ", buffer, "%0-20d", 1024); - SPRINTF_CHECK("-1024 ", buffer, "%0-20d", -1024); - SPRINTF_CHECK("1024 ", buffer, "%0-20i", 1024); - SPRINTF_CHECK("-1024 ", buffer, "%0-20i", -1024); - SPRINTF_CHECK("1024 ", buffer, "%0-20u", 1024); - SPRINTF_CHECK("4294966272 ", buffer, "%0-20u", 4294966272U); - SPRINTF_CHECK("777 ", buffer, "%0-20o", 511); - SPRINTF_CHECK("37777777001 ", buffer, "%0-20o", 4294966785U); - SPRINTF_CHECK("1234abcd ", buffer, "%0-20x", 305441741); - SPRINTF_CHECK("edcb5433 ", buffer, "%0-20x", 3989525555U); - SPRINTF_CHECK("1234ABCD ", buffer, "%0-20X", 305441741); - SPRINTF_CHECK("EDCB5433 ", buffer, "%0-20X", 3989525555U); - SPRINTF_CHECK("x ", buffer, "%0-20c", 'x'); + SPRINTF_CHECK("Hello ", buffer, "%0-20s", "Hello"); + SPRINTF_CHECK("1024 ", buffer, "%0-20d", 1024); + SPRINTF_CHECK("-1024 ", buffer, "%0-20d", -1024); + SPRINTF_CHECK("1024 ", buffer, "%0-20i", 1024); + SPRINTF_CHECK("-1024 ", buffer, "%0-20i", -1024); + SPRINTF_CHECK("1024 ", buffer, "%0-20u", 1024); + SPRINTF_CHECK("4294966272 ", buffer, "%0-20u", 4294966272U); + SPRINTF_CHECK("777 ", buffer, "%0-20o", 511); + SPRINTF_CHECK("37777777001 ", buffer, "%0-20o", 4294966785U); + SPRINTF_CHECK("1234abcd ", buffer, "%0-20x", 305441741); + SPRINTF_CHECK("edcb5433 ", buffer, "%0-20x", 3989525555U); + SPRINTF_CHECK("1234ABCD ", buffer, "%0-20X", 305441741); + SPRINTF_CHECK("EDCB5433 ", buffer, "%0-20X", 3989525555U); + SPRINTF_CHECK("x ", buffer, "%0-20c", 'x'); } SPRINTF_TEST_CASE(padding_20) { char buffer[base_buffer_size]; - SPRINTF_CHECK("00000000000000001024", buffer, "%020d", 1024); - SPRINTF_CHECK("-0000000000000001024", buffer, "%020d", -1024); - SPRINTF_CHECK("00000000000000001024", buffer, "%020i", 1024); - SPRINTF_CHECK("-0000000000000001024", buffer, "%020i", -1024); - SPRINTF_CHECK("00000000000000001024", buffer, "%020u", 1024); - SPRINTF_CHECK("00000000004294966272", buffer, "%020u", 4294966272U); - SPRINTF_CHECK("00000000000000000777", buffer, "%020o", 511); - SPRINTF_CHECK("00000000037777777001", buffer, "%020o", 4294966785U); - SPRINTF_CHECK("0000000000001234abcd", buffer, "%020x", 305441741); - SPRINTF_CHECK("000000000000edcb5433", buffer, "%020x", 3989525555U); - SPRINTF_CHECK("0000000000001234ABCD", buffer, "%020X", 305441741); - SPRINTF_CHECK("000000000000EDCB5433", buffer, "%020X", 3989525555U); + SPRINTF_CHECK("00000000000000001024", buffer, "%020d", 1024); + SPRINTF_CHECK("-0000000000000001024", buffer, "%020d", -1024); + SPRINTF_CHECK("00000000000000001024", buffer, "%020i", 1024); + SPRINTF_CHECK("-0000000000000001024", buffer, "%020i", -1024); + SPRINTF_CHECK("00000000000000001024", buffer, "%020u", 1024); + SPRINTF_CHECK("00000000004294966272", buffer, "%020u", 4294966272U); + SPRINTF_CHECK("00000000000000000777", buffer, "%020o", 511); + SPRINTF_CHECK("00000000037777777001", buffer, "%020o", 4294966785U); + SPRINTF_CHECK("0000000000001234abcd", buffer, "%020x", 305441741); + SPRINTF_CHECK("000000000000edcb5433", buffer, "%020x", 3989525555U); + SPRINTF_CHECK("0000000000001234ABCD", buffer, "%020X", 305441741); + SPRINTF_CHECK("000000000000EDCB5433", buffer, "%020X", 3989525555U); } SPRINTF_TEST_CASE(padding_dot_20) { char buffer[base_buffer_size]; - SPRINTF_CHECK("00000000000000001024", buffer, "%.20d", 1024); - SPRINTF_CHECK("-00000000000000001024", buffer, "%.20d", -1024); - SPRINTF_CHECK("00000000000000001024", buffer, "%.20i", 1024); - SPRINTF_CHECK("-00000000000000001024", buffer, "%.20i", -1024); - SPRINTF_CHECK("00000000000000001024", buffer, "%.20u", 1024); - SPRINTF_CHECK("00000000004294966272", buffer, "%.20u", 4294966272U); - SPRINTF_CHECK("00000000000000000777", buffer, "%.20o", 511); - SPRINTF_CHECK("00000000037777777001", buffer, "%.20o", 4294966785U); - SPRINTF_CHECK("0000000000001234abcd", buffer, "%.20x", 305441741); - SPRINTF_CHECK("000000000000edcb5433", buffer, "%.20x", 3989525555U); - SPRINTF_CHECK("0000000000001234ABCD", buffer, "%.20X", 305441741); - SPRINTF_CHECK("000000000000EDCB5433", buffer, "%.20X", 3989525555U); + SPRINTF_CHECK("00000000000000001024", buffer, "%.20d", 1024); + SPRINTF_CHECK("-00000000000000001024", buffer, "%.20d", -1024); + SPRINTF_CHECK("00000000000000001024", buffer, "%.20i", 1024); + SPRINTF_CHECK("-00000000000000001024", buffer, "%.20i", -1024); + SPRINTF_CHECK("00000000000000001024", buffer, "%.20u", 1024); + SPRINTF_CHECK("00000000004294966272", buffer, "%.20u", 4294966272U); + SPRINTF_CHECK("00000000000000000777", buffer, "%.20o", 511); + SPRINTF_CHECK("00000000037777777001", buffer, "%.20o", 4294966785U); + SPRINTF_CHECK("0000000000001234abcd", buffer, "%.20x", 305441741); + SPRINTF_CHECK("000000000000edcb5433", buffer, "%.20x", 3989525555U); + SPRINTF_CHECK("0000000000001234ABCD", buffer, "%.20X", 305441741); + SPRINTF_CHECK("000000000000EDCB5433", buffer, "%.20X", 3989525555U); } SPRINTF_TEST_CASE(padding_sharp_020__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK("00000000000000001024", buffer, "%#020d", 1024); - SPRINTF_CHECK("-0000000000000001024", buffer, "%#020d", -1024); - SPRINTF_CHECK("00000000000000001024", buffer, "%#020i", 1024); - SPRINTF_CHECK("-0000000000000001024", buffer, "%#020i", -1024); - SPRINTF_CHECK("00000000000000001024", buffer, "%#020u", 1024); - SPRINTF_CHECK("00000000004294966272", buffer, "%#020u", 4294966272U); + SPRINTF_CHECK("00000000000000001024", buffer, "%#020d", 1024); + SPRINTF_CHECK("-0000000000000001024", buffer, "%#020d", -1024); + SPRINTF_CHECK("00000000000000001024", buffer, "%#020i", 1024); + SPRINTF_CHECK("-0000000000000001024", buffer, "%#020i", -1024); + SPRINTF_CHECK("00000000000000001024", buffer, "%#020u", 1024); + SPRINTF_CHECK("00000000004294966272", buffer, "%#020u", 4294966272U); } SPRINTF_TEST_CASE(padding_sharp_020) { char buffer[base_buffer_size]; - SPRINTF_CHECK("00000000000000000777", buffer, "%#020o", 511); - SPRINTF_CHECK("00000000037777777001", buffer, "%#020o", 4294966785U); - SPRINTF_CHECK("0x00000000001234abcd", buffer, "%#020x", 305441741); - SPRINTF_CHECK("0x0000000000edcb5433", buffer, "%#020x", 3989525555U); - SPRINTF_CHECK("0X00000000001234ABCD", buffer, "%#020X", 305441741); - SPRINTF_CHECK("0X0000000000EDCB5433", buffer, "%#020X", 3989525555U); + SPRINTF_CHECK("00000000000000000777", buffer, "%#020o", 511); + SPRINTF_CHECK("00000000037777777001", buffer, "%#020o", 4294966785U); + SPRINTF_CHECK("0x00000000001234abcd", buffer, "%#020x", 305441741); + SPRINTF_CHECK("0x0000000000edcb5433", buffer, "%#020x", 3989525555U); + SPRINTF_CHECK("0X00000000001234ABCD", buffer, "%#020X", 305441741); + SPRINTF_CHECK("0X0000000000EDCB5433", buffer, "%#020X", 3989525555U); } SPRINTF_TEST_CASE(padding_sharp_20__non_standard_format) { - char buffer[base_buffer_size]; - SPRINTF_CHECK(" 1024", buffer, "%#20d", 1024); - SPRINTF_CHECK(" -1024", buffer, "%#20d", -1024); - SPRINTF_CHECK(" 1024", buffer, "%#20i", 1024); - SPRINTF_CHECK(" -1024", buffer, "%#20i", -1024); - SPRINTF_CHECK(" 1024", buffer, "%#20u", 1024); - SPRINTF_CHECK(" 4294966272", buffer, "%#20u", 4294966272U); + char buffer[base_buffer_size]; + SPRINTF_CHECK(" 1024", buffer, "%#20d", 1024); + SPRINTF_CHECK(" -1024", buffer, "%#20d", -1024); + SPRINTF_CHECK(" 1024", buffer, "%#20i", 1024); + SPRINTF_CHECK(" -1024", buffer, "%#20i", -1024); + SPRINTF_CHECK(" 1024", buffer, "%#20u", 1024); + SPRINTF_CHECK(" 4294966272", buffer, "%#20u", 4294966272U); } SPRINTF_TEST_CASE(padding_sharp_20) { char buffer[base_buffer_size]; - SPRINTF_CHECK(" 0777", buffer, "%#20o", 511); - SPRINTF_CHECK(" 037777777001", buffer, "%#20o", 4294966785U); - SPRINTF_CHECK(" 0x1234abcd", buffer, "%#20x", 305441741); - SPRINTF_CHECK(" 0xedcb5433", buffer, "%#20x", 3989525555U); - SPRINTF_CHECK(" 0X1234ABCD", buffer, "%#20X", 305441741); - SPRINTF_CHECK(" 0XEDCB5433", buffer, "%#20X", 3989525555U); + SPRINTF_CHECK(" 0777", buffer, "%#20o", 511); + SPRINTF_CHECK(" 037777777001", buffer, "%#20o", 4294966785U); + SPRINTF_CHECK(" 0x1234abcd", buffer, "%#20x", 305441741); + SPRINTF_CHECK(" 0xedcb5433", buffer, "%#20x", 3989525555U); + SPRINTF_CHECK(" 0X1234ABCD", buffer, "%#20X", 305441741); + SPRINTF_CHECK(" 0XEDCB5433", buffer, "%#20X", 3989525555U); } SPRINTF_TEST_CASE(padding_20_point_5) { char buffer[base_buffer_size]; - SPRINTF_CHECK(" 01024", buffer, "%20.5d", 1024); - SPRINTF_CHECK(" -01024", buffer, "%20.5d", -1024); - SPRINTF_CHECK(" 01024", buffer, "%20.5i", 1024); - SPRINTF_CHECK(" -01024", buffer, "%20.5i", -1024); - SPRINTF_CHECK(" 01024", buffer, "%20.5u", 1024); - SPRINTF_CHECK(" 4294966272", buffer, "%20.5u", 4294966272U); - SPRINTF_CHECK(" 00777", buffer, "%20.5o", 511); - SPRINTF_CHECK(" 37777777001", buffer, "%20.5o", 4294966785U); - SPRINTF_CHECK(" 1234abcd", buffer, "%20.5x", 305441741); - SPRINTF_CHECK(" 00edcb5433", buffer, "%20.10x", 3989525555U); - SPRINTF_CHECK(" 1234ABCD", buffer, "%20.5X", 305441741); - SPRINTF_CHECK(" 00EDCB5433", buffer, "%20.10X", 3989525555U); + SPRINTF_CHECK(" 01024", buffer, "%20.5d", 1024); + SPRINTF_CHECK(" -01024", buffer, "%20.5d", -1024); + SPRINTF_CHECK(" 01024", buffer, "%20.5i", 1024); + SPRINTF_CHECK(" -01024", buffer, "%20.5i", -1024); + SPRINTF_CHECK(" 01024", buffer, "%20.5u", 1024); + SPRINTF_CHECK(" 4294966272", buffer, "%20.5u", 4294966272U); + SPRINTF_CHECK(" 00777", buffer, "%20.5o", 511); + SPRINTF_CHECK(" 37777777001", buffer, "%20.5o", 4294966785U); + SPRINTF_CHECK(" 1234abcd", buffer, "%20.5x", 305441741); + SPRINTF_CHECK(" 00edcb5433", buffer, "%20.10x", 3989525555U); + SPRINTF_CHECK(" 1234ABCD", buffer, "%20.5X", 305441741); + SPRINTF_CHECK(" 00EDCB5433", buffer, "%20.10X", 3989525555U); } SPRINTF_TEST_CASE(padding_negative_numbers) @@ -568,16 +569,16 @@ SPRINTF_TEST_CASE(padding_negative_numbers) char buffer[base_buffer_size]; /* space padding */ - SPRINTF_CHECK("-5", buffer, "% 1d", -5); - SPRINTF_CHECK("-5", buffer, "% 2d", -5); - SPRINTF_CHECK(" -5", buffer, "% 3d", -5); - SPRINTF_CHECK(" -5", buffer, "% 4d", -5); + SPRINTF_CHECK("-5", buffer, "% 1d", -5); + SPRINTF_CHECK("-5", buffer, "% 2d", -5); + SPRINTF_CHECK(" -5", buffer, "% 3d", -5); + SPRINTF_CHECK(" -5", buffer, "% 4d", -5); /* zero padding */ - SPRINTF_CHECK("-5", buffer, "%01d", -5); - SPRINTF_CHECK("-5", buffer, "%02d", -5); - SPRINTF_CHECK("-05", buffer, "%03d", -5); - SPRINTF_CHECK("-005", buffer, "%04d", -5); + SPRINTF_CHECK("-5", buffer, "%01d", -5); + SPRINTF_CHECK("-5", buffer, "%02d", -5); + SPRINTF_CHECK("-05", buffer, "%03d", -5); + SPRINTF_CHECK("-005", buffer, "%04d", -5); } #if defined(RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS) || \ @@ -588,33 +589,33 @@ SPRINTF_TEST_CASE(float_padding_negative_numbers) /* space padding */ #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - SPRINTF_CHECK("-5.0", buffer, "% 3.1f", -5.); - SPRINTF_CHECK("-5.0", buffer, "% 4.1f", -5.); - SPRINTF_CHECK(" -5.0", buffer, "% 5.1f", -5.); + SPRINTF_CHECK("-5.0", buffer, "% 3.1f", -5.); + SPRINTF_CHECK("-5.0", buffer, "% 4.1f", -5.); + SPRINTF_CHECK(" -5.0", buffer, "% 5.1f", -5.); #endif #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - SPRINTF_CHECK(" -5", buffer, "% 6.1g", -5.); - SPRINTF_CHECK("-5.0e+00", buffer, "% 6.1e", -5.); - SPRINTF_CHECK(" -5.0e+00", buffer, "% 10.1e", -5.); + SPRINTF_CHECK(" -5", buffer, "% 6.1g", -5.); + SPRINTF_CHECK("-5.0e+00", buffer, "% 6.1e", -5.); + SPRINTF_CHECK(" -5.0e+00", buffer, "% 10.1e", -5.); #endif /* zero padding */ #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - SPRINTF_CHECK("-5.0", buffer, "%03.1f", -5.); - SPRINTF_CHECK("-5.0", buffer, "%04.1f", -5.); - SPRINTF_CHECK("-05.0", buffer, "%05.1f", -5.); + SPRINTF_CHECK("-5.0", buffer, "%03.1f", -5.); + SPRINTF_CHECK("-5.0", buffer, "%04.1f", -5.); + SPRINTF_CHECK("-05.0", buffer, "%05.1f", -5.); /* zero padding no decimal point */ - SPRINTF_CHECK("-5", buffer, "%01.0f", -5.); - SPRINTF_CHECK("-5", buffer, "%02.0f", -5.); - SPRINTF_CHECK("-05", buffer, "%03.0f", -5.); + SPRINTF_CHECK("-5", buffer, "%01.0f", -5.); + SPRINTF_CHECK("-5", buffer, "%02.0f", -5.); + SPRINTF_CHECK("-05", buffer, "%03.0f", -5.); #endif #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - SPRINTF_CHECK("-005.0e+00", buffer, "%010.1e", -5.); - SPRINTF_CHECK("-05E+00", buffer, "%07.0E", -5.); - SPRINTF_CHECK("-05", buffer, "%03.0g", -5.); + SPRINTF_CHECK("-005.0e+00", buffer, "%010.1e", -5.); + SPRINTF_CHECK("-05E+00", buffer, "%07.0E", -5.); + SPRINTF_CHECK("-05", buffer, "%03.0g", -5.); #endif } @@ -625,13 +626,13 @@ SPRINTF_TEST_CASE(infinity_and_not_a_number_values) /* test special-case floats using math.h macros */ #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS // SPRINTF_CHECK(" nan", buffer, "%8f", (double) NAN); - SPRINTF_CHECK(" inf", buffer, "%8f", (double) INFINITY); - SPRINTF_CHECK("-inf ", buffer, "%-8f", (double) -INFINITY); + SPRINTF_CHECK(" inf", buffer, "%8f", (double)INFINITY); + SPRINTF_CHECK("-inf ", buffer, "%-8f", (double)-INFINITY); #endif /* RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS */ #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS // SPRINTF_CHECK(" nan", buffer, "%8e", (double) NAN); - SPRINTF_CHECK(" inf", buffer, "%8e", (double) INFINITY); - SPRINTF_CHECK("-inf ", buffer, "%-8e", (double) -INFINITY); + SPRINTF_CHECK(" inf", buffer, "%8e", (double)INFINITY); + SPRINTF_CHECK("-inf ", buffer, "%-8e", (double)-INFINITY); #endif /* RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS */ } @@ -639,39 +640,39 @@ SPRINTF_TEST_CASE(floating_point_specifiers_precision_and_flags) { char buffer[base_buffer_size]; #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - SPRINTF_CHECK("3.1415", buffer, "%.4f", 3.1415354); - SPRINTF_CHECK("30343.142", buffer, "%.3f", 30343.1415354); - SPRINTF_CHECK("34", buffer, "%.0f", 34.1415354); - SPRINTF_CHECK("1", buffer, "%.0f", 1.3); - SPRINTF_CHECK("2", buffer, "%.0f", 1.55); - SPRINTF_CHECK("1.6", buffer, "%.1f", 1.64); - SPRINTF_CHECK("42.90", buffer, "%.2f", 42.8952); - SPRINTF_CHECK("42.895200000", buffer, "%.9f", 42.8952); - SPRINTF_CHECK("42.8952230000", buffer, "%.10f", 42.895223); - SPRINTF_CHECK("42.895223123457", buffer, "%.12f", 42.89522312345678); - SPRINTF_CHECK("42477.371093750000000", buffer, "%020.15f", 42477.37109375); - SPRINTF_CHECK("42.895223876543", buffer, "%.12f", 42.89522387654321); - SPRINTF_CHECK(" 42.90", buffer, "%6.2f", 42.8952); - SPRINTF_CHECK("+42.90", buffer, "%+6.2f", 42.8952); - SPRINTF_CHECK("+42.9", buffer, "%+5.1f", 42.9252); - SPRINTF_CHECK("42.500000", buffer, "%f", 42.5); - SPRINTF_CHECK("42.5", buffer, "%.1f", 42.5); - SPRINTF_CHECK("42167.000000", buffer, "%f", 42167.0); - SPRINTF_CHECK("-12345.987654321", buffer, "%.9f", -12345.987654321); - SPRINTF_CHECK("4.0", buffer, "%.1f", 3.999); - SPRINTF_CHECK("4", buffer, "%.0f", 3.5); - SPRINTF_CHECK("4", buffer, "%.0f", 4.5); - SPRINTF_CHECK("3", buffer, "%.0f", 3.49); - SPRINTF_CHECK("3.5", buffer, "%.1f", 3.49); - SPRINTF_CHECK("a0.5 ", buffer, "a%-5.1f", 0.5); - SPRINTF_CHECK("a0.5 end", buffer, "a%-5.1fend", 0.5); + SPRINTF_CHECK("3.1415", buffer, "%.4f", 3.1415354); + SPRINTF_CHECK("30343.142", buffer, "%.3f", 30343.1415354); + SPRINTF_CHECK("34", buffer, "%.0f", 34.1415354); + SPRINTF_CHECK("1", buffer, "%.0f", 1.3); + SPRINTF_CHECK("2", buffer, "%.0f", 1.55); + SPRINTF_CHECK("1.6", buffer, "%.1f", 1.64); + SPRINTF_CHECK("42.90", buffer, "%.2f", 42.8952); + SPRINTF_CHECK("42.895200000", buffer, "%.9f", 42.8952); + SPRINTF_CHECK("42.8952230000", buffer, "%.10f", 42.895223); + SPRINTF_CHECK("42.895223123457", buffer, "%.12f", 42.89522312345678); + SPRINTF_CHECK("42477.371093750000000", buffer, "%020.15f", 42477.37109375); + SPRINTF_CHECK("42.895223876543", buffer, "%.12f", 42.89522387654321); + SPRINTF_CHECK(" 42.90", buffer, "%6.2f", 42.8952); + SPRINTF_CHECK("+42.90", buffer, "%+6.2f", 42.8952); + SPRINTF_CHECK("+42.9", buffer, "%+5.1f", 42.9252); + SPRINTF_CHECK("42.500000", buffer, "%f", 42.5); + SPRINTF_CHECK("42.5", buffer, "%.1f", 42.5); + SPRINTF_CHECK("42167.000000", buffer, "%f", 42167.0); + SPRINTF_CHECK("-12345.987654321", buffer, "%.9f", -12345.987654321); + SPRINTF_CHECK("4.0", buffer, "%.1f", 3.999); + SPRINTF_CHECK("4", buffer, "%.0f", 3.5); + SPRINTF_CHECK("4", buffer, "%.0f", 4.5); + SPRINTF_CHECK("3", buffer, "%.0f", 3.49); + SPRINTF_CHECK("3.5", buffer, "%.1f", 3.49); + SPRINTF_CHECK("a0.5 ", buffer, "a%-5.1f", 0.5); + SPRINTF_CHECK("a0.5 end", buffer, "a%-5.1fend", 0.5); /* %f for double */ - SPRINTF_CHECK("42.895223123457", buffer, "%.12f", 42.89522312345678); + SPRINTF_CHECK("42.895223123457", buffer, "%.12f", 42.89522312345678); /* %F for double */ - SPRINTF_CHECK("42.895223123457", buffer, "%.12F", 42.89522312345678); + SPRINTF_CHECK("42.895223123457", buffer, "%.12F", 42.89522312345678); /* %lf for double */ - SPRINTF_CHECK("42.895223123457", buffer, "%.12lf", 42.89522312345678); + SPRINTF_CHECK("42.895223123457", buffer, "%.12lf", 42.89522312345678); /* %Lf for long double */ // TODO: fix me // SPRINTF_CHECK("42.895223123457", buffer, "%.12Lf", 42.89522312345678l); @@ -679,55 +680,55 @@ SPRINTF_TEST_CASE(floating_point_specifiers_precision_and_flags) #endif /* RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS */ #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - SPRINTF_CHECK("0.5", buffer, "%.4g", 0.5); - SPRINTF_CHECK("1", buffer, "%.4g", 1.0); - SPRINTF_CHECK("12345.7", buffer, "%G", 12345.678); - SPRINTF_CHECK("12345.68", buffer, "%.7G", 12345.678); - SPRINTF_CHECK("1.2346E+08", buffer, "%.5G", 123456789.); - SPRINTF_CHECK("12345", buffer, "%.6G", 12345.); - SPRINTF_CHECK(" +1.235e+08", buffer, "%+12.4g", 123456789.); - SPRINTF_CHECK("0.0012", buffer, "%.2G", 0.001234); - SPRINTF_CHECK(" +0.001234", buffer, "%+10.4G", 0.001234); - SPRINTF_CHECK("+001.234e-05", buffer, "%+012.4g", 0.00001234); + SPRINTF_CHECK("0.5", buffer, "%.4g", 0.5); + SPRINTF_CHECK("1", buffer, "%.4g", 1.0); + SPRINTF_CHECK("12345.7", buffer, "%G", 12345.678); + SPRINTF_CHECK("12345.68", buffer, "%.7G", 12345.678); + SPRINTF_CHECK("1.2346E+08", buffer, "%.5G", 123456789.); + SPRINTF_CHECK("12345", buffer, "%.6G", 12345.); + SPRINTF_CHECK(" +1.235e+08", buffer, "%+12.4g", 123456789.); + SPRINTF_CHECK("0.0012", buffer, "%.2G", 0.001234); + SPRINTF_CHECK(" +0.001234", buffer, "%+10.4G", 0.001234); + SPRINTF_CHECK("+001.234e-05", buffer, "%+012.4g", 0.00001234); /* Note: The following two values are _barely_ normal; make their mantissa 1.1 and they lose their normality. */ - SPRINTF_CHECK("-1.23e-308", buffer, "%.3g", -1.2345e-308); - SPRINTF_CHECK("+1.230E+308", buffer, "%+.3E", 1.23e+308); - SPRINTF_CHECK("1.000e+01", buffer, "%.3e", 9.9996); - SPRINTF_CHECK("0", buffer, "%g", 0.); + SPRINTF_CHECK("-1.23e-308", buffer, "%.3g", -1.2345e-308); + SPRINTF_CHECK("+1.230E+308", buffer, "%+.3E", 1.23e+308); + SPRINTF_CHECK("1.000e+01", buffer, "%.3e", 9.9996); + SPRINTF_CHECK("0", buffer, "%g", 0.); // SPRINTF_CHECK("-0", buffer, "%g", -0.); - SPRINTF_CHECK("+0", buffer, "%+g", 0.); + SPRINTF_CHECK("+0", buffer, "%+g", 0.); // SPRINTF_CHECK("-0", buffer, "%+g", -0.); - SPRINTF_CHECK("-4e+04", buffer, "%.1g", -40661.5); - SPRINTF_CHECK("-4.e+04", buffer, "%#.1g", -40661.5); - SPRINTF_CHECK("100.", buffer, "%#.3g", 99.998580932617187500); + SPRINTF_CHECK("-4e+04", buffer, "%.1g", -40661.5); + SPRINTF_CHECK("-4.e+04", buffer, "%#.1g", -40661.5); + SPRINTF_CHECK("100.", buffer, "%#.3g", 99.998580932617187500); // TODO: fix me // SPRINTF_CHECK("1.e01", buffer, "%# 01.1g", 9.8); /* Note: The following value is _barely_ normal; make the mantissa 1.1 and it loses its normality. */ - SPRINTF_CHECK("1.2345678901e-308", buffer, "%.10e", 1.2345678901e-308); + SPRINTF_CHECK("1.2345678901e-308", buffer, "%.10e", 1.2345678901e-308); /* Rounding-focused checks */ - SPRINTF_CHECK("4.895512e+04", buffer, "%e", 48955.125); - SPRINTF_CHECK("9.2524e+04", buffer, "%.4e", 92523.5); - SPRINTF_CHECK("-8.380923438e+04", buffer, "%.9e", -83809.234375); + SPRINTF_CHECK("4.895512e+04", buffer, "%e", 48955.125); + SPRINTF_CHECK("9.2524e+04", buffer, "%.4e", 92523.5); + SPRINTF_CHECK("-8.380923438e+04", buffer, "%.9e", -83809.234375); /* %g for double */ - SPRINTF_CHECK("100.", buffer, "%#.3g", 99.998580932617187500); + SPRINTF_CHECK("100.", buffer, "%#.3g", 99.998580932617187500); /* %G for double */ - SPRINTF_CHECK("100.", buffer, "%#.3G", 99.998580932617187500); + SPRINTF_CHECK("100.", buffer, "%#.3G", 99.998580932617187500); /* %lg for double */ - SPRINTF_CHECK("100.", buffer, "%#.3lg", 99.998580932617187500); + SPRINTF_CHECK("100.", buffer, "%#.3lg", 99.998580932617187500); /* %Lg for long double */ // TODO: fix me // SPRINTF_CHECK("100.", buffer, "%#.3Lg", 99.998580932617187500l); // SPRINTF_CHECK("100.", buffer, "%#.3Lg", 99.998580932617187500L); /* %e for double */ - SPRINTF_CHECK("-8.380923438e+04", buffer, "%.9e", -83809.234375); + SPRINTF_CHECK("-8.380923438e+04", buffer, "%.9e", -83809.234375); /* %E for double */ - SPRINTF_CHECK("-8.380923438E+04", buffer, "%.9E", -83809.234375); + SPRINTF_CHECK("-8.380923438E+04", buffer, "%.9E", -83809.234375); /* %le for double */ - SPRINTF_CHECK("-8.380923438e+04", buffer, "%.9le", -83809.234375); + SPRINTF_CHECK("-8.380923438e+04", buffer, "%.9le", -83809.234375); /* %Le for long double */ // TODO: fix me // SPRINTF_CHECK("-8.380923438e+04", buffer, "%.9Le", -83809.234375l); @@ -740,20 +741,20 @@ SPRINTF_TEST_CASE(floating_point_specifiers_with_31_to_32_bit_integer_values) { char buffer[base_buffer_size]; #if RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL >= 10 - SPRINTF_CHECK("2147483647", buffer, "%.10f", 2147483647.0); /* 2^31 - 1 */ - SPRINTF_CHECK("2147483648", buffer, "%.10f", 2147483648.0); /* 2^31 */ - SPRINTF_CHECK("4294967295", buffer, "%.10f", 4294967295.0); /* 2^32 - 1 */ - SPRINTF_CHECK("4294967296", buffer, "%.10f", 4294967296.0); /* 2^32 */ + SPRINTF_CHECK("2147483647", buffer, "%.10f", 2147483647.0); /* 2^31 - 1 */ + SPRINTF_CHECK("2147483648", buffer, "%.10f", 2147483648.0); /* 2^31 */ + SPRINTF_CHECK("4294967295", buffer, "%.10f", 4294967295.0); /* 2^32 - 1 */ + SPRINTF_CHECK("4294967296", buffer, "%.10f", 4294967296.0); /* 2^32 */ #else - SPRINTF_CHECK("2.1474836470e+09", buffer, "%.10f", 2147483647.0); /* 2^31 - 1 */ - SPRINTF_CHECK("2.1474836480e+09", buffer, "%.10f", 2147483648.0); /* 2^31 */ - SPRINTF_CHECK("4.2949672950e+09", buffer, "%.10f", 4294967295.0); /* 2^32 - 1 */ - SPRINTF_CHECK("4.2949672960e+09", buffer, "%.10f", 4294967296.0); /* 2^32 */ -#endif /* RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL */ - SPRINTF_CHECK("2147483647", buffer, "%.10g", 2147483647.0); /* 2^31 - 1 */ - SPRINTF_CHECK("2147483648", buffer, "%.10g", 2147483648.0); /* 2^31 */ - SPRINTF_CHECK("4294967295", buffer, "%.10g", 4294967295.0); /* 2^32 - 1 */ - SPRINTF_CHECK("4294967296", buffer, "%.10g", 4294967296.0); /* 2^32 */ + SPRINTF_CHECK("2.1474836470e+09", buffer, "%.10f", 2147483647.0); /* 2^31 - 1 */ + SPRINTF_CHECK("2.1474836480e+09", buffer, "%.10f", 2147483648.0); /* 2^31 */ + SPRINTF_CHECK("4.2949672950e+09", buffer, "%.10f", 4294967295.0); /* 2^32 - 1 */ + SPRINTF_CHECK("4.2949672960e+09", buffer, "%.10f", 4294967296.0); /* 2^32 */ +#endif /* RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL */ + SPRINTF_CHECK("2147483647", buffer, "%.10g", 2147483647.0); /* 2^31 - 1 */ + SPRINTF_CHECK("2147483648", buffer, "%.10g", 2147483648.0); /* 2^31 */ + SPRINTF_CHECK("4294967295", buffer, "%.10g", 4294967295.0); /* 2^32 - 1 */ + SPRINTF_CHECK("4294967296", buffer, "%.10g", 4294967296.0); /* 2^32 */ } SPRINTF_TEST_CASE(fallback_from_decimal_to_exponential) @@ -761,46 +762,61 @@ SPRINTF_TEST_CASE(fallback_from_decimal_to_exponential) char buffer[base_buffer_size]; /* Check for 1 * 1000 */ - if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 3) { - SPRINTF_CHECK("1e+3", buffer, "%.0f", (double) ((int64_t) 1 * 1000)); - } else { - SPRINTF_CHECK("1000", buffer, "%.0f", (double) ((int64_t) 1 * 1000)); + if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 3) + { + SPRINTF_CHECK("1e+3", buffer, "%.0f", (double)((int64_t)1 * 1000)); + } + else + { + SPRINTF_CHECK("1000", buffer, "%.0f", (double)((int64_t)1 * 1000)); } /* Check for 1 * 1000 * 1000 */ - if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 6) { - SPRINTF_CHECK("1e+6", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000)); - } else { - SPRINTF_CHECK("1000000", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000)); + if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 6) + { + SPRINTF_CHECK("1e+6", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000)); + } + else + { + SPRINTF_CHECK("1000000", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000)); } /* Check for 1 * 1000 * 1000 * 1000 */ - if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 9) { - SPRINTF_CHECK("1e+9", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000 * 1000)); - } else { - SPRINTF_CHECK("1000000000", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000 * 1000)); + if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 9) + { + SPRINTF_CHECK("1e+9", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000 * 1000)); + } + else + { + SPRINTF_CHECK("1000000000", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000 * 1000)); } /* Check for 1 * 1000 * 1000 * 1000 * 1000 */ - if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 12) { + if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 12) + { #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - SPRINTF_CHECK("1e+12", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000 * 1000 * 1000)); + SPRINTF_CHECK("1e+12", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000 * 1000 * 1000)); #else - SPRINTF_CHECK("", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000 * 1000 * 1000)); + SPRINTF_CHECK("", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000 * 1000 * 1000)); #endif - } else { - SPRINTF_CHECK("1000000000000", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000 * 1000 * 1000)); + } + else + { + SPRINTF_CHECK("1000000000000", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000 * 1000 * 1000)); } /* Check for 1 * 1000 * 1000 * 1000 * 1000 * 1000 */ - if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 15) { + if (RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL < 15) + { #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - SPRINTF_CHECK("1e+15", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000 * 1000 * 1000 * 1000)); + SPRINTF_CHECK("1e+15", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000 * 1000 * 1000 * 1000)); #else - SPRINTF_CHECK("", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000 * 1000 * 1000 * 1000)); + SPRINTF_CHECK("", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000 * 1000 * 1000 * 1000)); #endif - } else { - SPRINTF_CHECK("1000000000000000", buffer, "%.0f", (double) ((int64_t) 1 * 1000 * 1000 * 1000 * 1000 * 1000)); + } + else + { + SPRINTF_CHECK("1000000000000000", buffer, "%.0f", (double)((int64_t)1 * 1000 * 1000 * 1000 * 1000 * 1000)); } /* Check for a value which should definitely be out of range for float */ @@ -817,18 +833,18 @@ SPRINTF_TEST_CASE(tiny_floating_point_values) { char buffer[base_buffer_size]; - SPRINTF_CHECK("1e-23", buffer, "%.0e", 1.380651569e-23); - SPRINTF_CHECK("1.4e-23", buffer, "%.1e", 1.380651569e-23); - SPRINTF_CHECK("1.38e-23", buffer, "%.2e", 1.380651569e-23); - SPRINTF_CHECK("1.381e-23", buffer, "%.3e", 1.380651569e-23); - SPRINTF_CHECK("1.3807e-23", buffer, "%.4e", 1.380651569e-23); - SPRINTF_CHECK("1.38065e-23", buffer, "%.5e", 1.380651569e-23); - SPRINTF_CHECK("1.380652e-23", buffer, "%.6e", 1.380651569e-23); - SPRINTF_CHECK("1.3806516e-23", buffer, "%.7e", 1.380651569e-23); - SPRINTF_CHECK("1.38065157e-23", buffer, "%.8e", 1.380651569e-23); - SPRINTF_CHECK("1.380651569e-23", buffer, "%.9e", 1.380651569e-23); - SPRINTF_CHECK("1.3806515690e-23", buffer, "%.10e", 1.380651569e-23); - SPRINTF_CHECK("1.38065156900e-23", buffer, "%.11e", 1.380651569e-23); + SPRINTF_CHECK("1e-23", buffer, "%.0e", 1.380651569e-23); + SPRINTF_CHECK("1.4e-23", buffer, "%.1e", 1.380651569e-23); + SPRINTF_CHECK("1.38e-23", buffer, "%.2e", 1.380651569e-23); + SPRINTF_CHECK("1.381e-23", buffer, "%.3e", 1.380651569e-23); + SPRINTF_CHECK("1.3807e-23", buffer, "%.4e", 1.380651569e-23); + SPRINTF_CHECK("1.38065e-23", buffer, "%.5e", 1.380651569e-23); + SPRINTF_CHECK("1.380652e-23", buffer, "%.6e", 1.380651569e-23); + SPRINTF_CHECK("1.3806516e-23", buffer, "%.7e", 1.380651569e-23); + SPRINTF_CHECK("1.38065157e-23", buffer, "%.8e", 1.380651569e-23); + SPRINTF_CHECK("1.380651569e-23", buffer, "%.9e", 1.380651569e-23); + SPRINTF_CHECK("1.3806515690e-23", buffer, "%.10e", 1.380651569e-23); + SPRINTF_CHECK("1.38065156900e-23", buffer, "%.11e", 1.380651569e-23); } #endif /* RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS */ #endif /* RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS || RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS */ @@ -837,106 +853,106 @@ SPRINTF_TEST_CASE(tiny_floating_point_values) SPRINTF_TEST_CASE(length) { char buffer[base_buffer_size]; - SPRINTF_CHECK("", buffer, "%.0s", "Hello testing"); - SPRINTF_CHECK(" ", buffer, "%20.0s", "Hello testing"); - SPRINTF_CHECK("", buffer, "%.s", "Hello testing"); - SPRINTF_CHECK(" ", buffer, "%20.s", "Hello testing"); - SPRINTF_CHECK(" 1024", buffer, "%20.0d", 1024); - SPRINTF_CHECK(" -1024", buffer, "%20.0d", -1024); - SPRINTF_CHECK(" ", buffer, "%20.d", 0); - SPRINTF_CHECK(" 1024", buffer, "%20.0i", 1024); - SPRINTF_CHECK(" -1024", buffer, "%20.i", -1024); - SPRINTF_CHECK(" ", buffer, "%20.i", 0); - SPRINTF_CHECK(" 1024", buffer, "%20.u", 1024); - SPRINTF_CHECK(" 4294966272", buffer, "%20.0u", 4294966272U); - SPRINTF_CHECK(" ", buffer, "%20.u", 0U); - SPRINTF_CHECK(" 777", buffer, "%20.o", 511); - SPRINTF_CHECK(" 37777777001", buffer, "%20.0o", 4294966785U); - SPRINTF_CHECK(" ", buffer, "%20.o", 0U); - SPRINTF_CHECK(" 1234abcd", buffer, "%20.x", 305441741); + SPRINTF_CHECK("", buffer, "%.0s", "Hello testing"); + SPRINTF_CHECK(" ", buffer, "%20.0s", "Hello testing"); + SPRINTF_CHECK("", buffer, "%.s", "Hello testing"); + SPRINTF_CHECK(" ", buffer, "%20.s", "Hello testing"); + SPRINTF_CHECK(" 1024", buffer, "%20.0d", 1024); + SPRINTF_CHECK(" -1024", buffer, "%20.0d", -1024); + SPRINTF_CHECK(" ", buffer, "%20.d", 0); + SPRINTF_CHECK(" 1024", buffer, "%20.0i", 1024); + SPRINTF_CHECK(" -1024", buffer, "%20.i", -1024); + SPRINTF_CHECK(" ", buffer, "%20.i", 0); + SPRINTF_CHECK(" 1024", buffer, "%20.u", 1024); + SPRINTF_CHECK(" 4294966272", buffer, "%20.0u", 4294966272U); + SPRINTF_CHECK(" ", buffer, "%20.u", 0U); + SPRINTF_CHECK(" 777", buffer, "%20.o", 511); + SPRINTF_CHECK(" 37777777001", buffer, "%20.0o", 4294966785U); + SPRINTF_CHECK(" ", buffer, "%20.o", 0U); + SPRINTF_CHECK(" 1234abcd", buffer, "%20.x", 305441741); SPRINTF_CHECK(" 1234abcd", - buffer, "%50.x", 305441741); + buffer, "%50.x", 305441741); SPRINTF_CHECK(" 1234abcd 12345", - buffer, "%50.x%10.u", 305441741, 12345); - SPRINTF_CHECK(" edcb5433", buffer, "%20.0x", 3989525555U); - SPRINTF_CHECK(" ", buffer, "%20.x", 0U); - SPRINTF_CHECK(" 1234ABCD", buffer, "%20.X", 305441741); - SPRINTF_CHECK(" EDCB5433", buffer, "%20.0X", 3989525555U); - SPRINTF_CHECK(" ", buffer, "%20.X", 0U); + buffer, "%50.x%10.u", 305441741, 12345); + SPRINTF_CHECK(" edcb5433", buffer, "%20.0x", 3989525555U); + SPRINTF_CHECK(" ", buffer, "%20.x", 0U); + SPRINTF_CHECK(" 1234ABCD", buffer, "%20.X", 305441741); + SPRINTF_CHECK(" EDCB5433", buffer, "%20.0X", 3989525555U); + SPRINTF_CHECK(" ", buffer, "%20.X", 0U); } SPRINTF_TEST_CASE(length__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK(" ", buffer, "%02.0u", 0U); - SPRINTF_CHECK(" ", buffer, "%02.0d", 0); + SPRINTF_CHECK(" ", buffer, "%02.0u", 0U); + SPRINTF_CHECK(" ", buffer, "%02.0d", 0); } SPRINTF_TEST_CASE(unknown_flag__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK("kmarco", buffer, "%kmarco", 42, 37); + SPRINTF_CHECK("kmarco", buffer, "%kmarco", 42, 37); } SPRINTF_TEST_CASE(string_length__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK(".2s", buffer, "%.4.2s", "123456"); + SPRINTF_CHECK(".2s", buffer, "%.4.2s", "123456"); } #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ SPRINTF_TEST_CASE(integer_types) { char buffer[base_buffer_size]; - SPRINTF_CHECK("0", buffer, "%i", 0); - SPRINTF_CHECK("1234", buffer, "%i", 1234); - SPRINTF_CHECK("32767", buffer, "%i", 32767); - SPRINTF_CHECK("-32767", buffer, "%i", -32767); - SPRINTF_CHECK("30", buffer, "%li", 30L); - SPRINTF_CHECK("-2147483647", buffer, "%li", -2147483647L); - SPRINTF_CHECK("2147483647", buffer, "%li", 2147483647L); + SPRINTF_CHECK("0", buffer, "%i", 0); + SPRINTF_CHECK("1234", buffer, "%i", 1234); + SPRINTF_CHECK("32767", buffer, "%i", 32767); + SPRINTF_CHECK("-32767", buffer, "%i", -32767); + SPRINTF_CHECK("30", buffer, "%li", 30L); + SPRINTF_CHECK("-2147483647", buffer, "%li", -2147483647L); + SPRINTF_CHECK("2147483647", buffer, "%li", 2147483647L); #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - SPRINTF_CHECK("30", buffer, "%lli", 30LL); + SPRINTF_CHECK("30", buffer, "%lli", 30LL); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("-9223372036854775807", buffer, "%lli", -9223372036854775807LL); - SPRINTF_CHECK("9223372036854775807", buffer, "%lli", 9223372036854775807LL); + SPRINTF_CHECK("-9223372036854775807", buffer, "%lli", -9223372036854775807LL); + SPRINTF_CHECK("9223372036854775807", buffer, "%lli", 9223372036854775807LL); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ #endif /* RT_KLIBC_USING_VSNPRINTF_LONGLONG */ - SPRINTF_CHECK("100000", buffer, "%lu", 100000L); - SPRINTF_CHECK("4294967295", buffer, "%lu", 0xFFFFFFFFL); + SPRINTF_CHECK("100000", buffer, "%lu", 100000L); + SPRINTF_CHECK("4294967295", buffer, "%lu", 0xFFFFFFFFL); #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - SPRINTF_CHECK("281474976710656", buffer, "%llu", 281474976710656LLU); - SPRINTF_CHECK("18446744073709551615", buffer, "%llu", 18446744073709551615LLU); + SPRINTF_CHECK("281474976710656", buffer, "%llu", 281474976710656LLU); + SPRINTF_CHECK("18446744073709551615", buffer, "%llu", 18446744073709551615LLU); #endif /* RT_KLIBC_USING_VSNPRINTF_LONGLONG */ - SPRINTF_CHECK("2147483647", buffer, "%zu", (size_t) 2147483647UL); - SPRINTF_CHECK("2147483647", buffer, "%zd", (size_t) 2147483647UL); - SPRINTF_CHECK("-2147483647", buffer, "%zi", (ssize_t) -2147483647L); - SPRINTF_CHECK("165140", buffer, "%o", 60000); - SPRINTF_CHECK("57060516", buffer, "%lo", 12345678L); - SPRINTF_CHECK("12345678", buffer, "%lx", 0x12345678L); + SPRINTF_CHECK("2147483647", buffer, "%zu", (size_t)2147483647UL); + SPRINTF_CHECK("2147483647", buffer, "%zd", (size_t)2147483647UL); + SPRINTF_CHECK("-2147483647", buffer, "%zi", (ssize_t)-2147483647L); + SPRINTF_CHECK("165140", buffer, "%o", 60000); + SPRINTF_CHECK("57060516", buffer, "%lo", 12345678L); + SPRINTF_CHECK("12345678", buffer, "%lx", 0x12345678L); #ifdef RT_KLIBC_USING_VSNPRINTF_LONGLONG - SPRINTF_CHECK("1234567891234567", buffer, "%llx", 0x1234567891234567LLU); + SPRINTF_CHECK("1234567891234567", buffer, "%llx", 0x1234567891234567LLU); #endif /* RT_KLIBC_USING_VSNPRINTF_LONGLONG */ - SPRINTF_CHECK("abcdefab", buffer, "%lx", 0xabcdefabL); - SPRINTF_CHECK("ABCDEFAB", buffer, "%lX", 0xabcdefabL); - SPRINTF_CHECK("v", buffer, "%c", 'v'); - SPRINTF_CHECK("wv", buffer, "%cv", 'w'); - SPRINTF_CHECK("A Test", buffer, "%s", "A Test"); + SPRINTF_CHECK("abcdefab", buffer, "%lx", 0xabcdefabL); + SPRINTF_CHECK("ABCDEFAB", buffer, "%lX", 0xabcdefabL); + SPRINTF_CHECK("v", buffer, "%c", 'v'); + SPRINTF_CHECK("wv", buffer, "%cv", 'w'); + SPRINTF_CHECK("A Test", buffer, "%s", "A Test"); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("255", buffer, "%hhu", (unsigned char) 0xFFU); + SPRINTF_CHECK("255", buffer, "%hhu", (unsigned char)0xFFU); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ - SPRINTF_CHECK("4660", buffer, "%hu", (unsigned short) 0x1234u); - SPRINTF_CHECK("Test100 65535", buffer, "%s%hhi %hu", "Test", (char) 100, (unsigned short) 0xFFFF); + SPRINTF_CHECK("4660", buffer, "%hu", (unsigned short)0x1234u); + SPRINTF_CHECK("Test100 65535", buffer, "%s%hhi %hu", "Test", (char)100, (unsigned short)0xFFFF); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("a", buffer, "%tx", &buffer[10] - &buffer[0]); - SPRINTF_CHECK("-2147483647", buffer, "%ji", (intmax_t) -2147483647L); + SPRINTF_CHECK("a", buffer, "%tx", &buffer[10] - &buffer[0]); + SPRINTF_CHECK("-2147483647", buffer, "%ji", (intmax_t)-2147483647L); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ } SPRINTF_TEST_CASE(types__non_standard_format) { char buffer[base_buffer_size]; - SPRINTF_CHECK("1110101001100000", buffer, "%b", 60000); + SPRINTF_CHECK("1110101001100000", buffer, "%b", 60000); SPRINTF_CHECK("101111000110000101001110", buffer, "%lb", 12345678L); } @@ -946,21 +962,24 @@ SPRINTF_TEST_CASE(pointer) /* Test for pointer value 0x1234U */ SPRINTF_CHECK((sizeof(void *) == 4U) ? "0x00001234" : "0x0000000000001234", - buffer, "%p", (void *) 0x1234U); + buffer, "%p", (void *)0x1234U); /* Test for pointer value 0x12345678U */ SPRINTF_CHECK((sizeof(void *) == 4U) ? "0x12345678" : "0x0000000012345678", - buffer, "%p", (void *) 0x12345678U); + buffer, "%p", (void *)0x12345678U); /* Test for pointer range 0x12345678U to 0x7EDCBA98U */ SPRINTF_CHECK((sizeof(void *) == 4U) ? "0x12345678-0x7edcba98" : "0x0000000012345678-0x000000007edcba98", - buffer, "%p-%p", (void *) 0x12345678U, (void *) 0x7EDCBA98U); + buffer, "%p-%p", (void *)0x12345678U, (void *)0x7EDCBA98U); /* Test for maximum uintptr_t value 0xFFFFFFFFU */ - if (sizeof(uintptr_t) == sizeof(uint64_t)) { - SPRINTF_CHECK("0x00000000ffffffff", buffer, "%p", (void *) (uintptr_t) 0xFFFFFFFFU); - } else { - SPRINTF_CHECK("0xffffffff", buffer, "%p", (void *) (uintptr_t) 0xFFFFFFFFU); + if (sizeof(uintptr_t) == sizeof(uint64_t)) + { + SPRINTF_CHECK("0x00000000ffffffff", buffer, "%p", (void *)(uintptr_t)0xFFFFFFFFU); + } + else + { + SPRINTF_CHECK("0xffffffff", buffer, "%p", (void *)(uintptr_t)0xFFFFFFFFU); } #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD @@ -972,37 +991,37 @@ SPRINTF_TEST_CASE(pointer) SPRINTF_TEST_CASE(string_length) { char buffer[base_buffer_size]; - SPRINTF_CHECK("This", buffer, "%.4s", "This is a test"); - SPRINTF_CHECK("test", buffer, "%.4s", "test"); - SPRINTF_CHECK("123", buffer, "%.7s", "123"); - SPRINTF_CHECK("", buffer, "%.7s", ""); - SPRINTF_CHECK("1234ab", buffer, "%.4s%.2s", "123456", "abcdef"); - SPRINTF_CHECK("123", buffer, "%.*s", 3, "123456"); + SPRINTF_CHECK("This", buffer, "%.4s", "This is a test"); + SPRINTF_CHECK("test", buffer, "%.4s", "test"); + SPRINTF_CHECK("123", buffer, "%.7s", "123"); + SPRINTF_CHECK("", buffer, "%.7s", ""); + SPRINTF_CHECK("1234ab", buffer, "%.4s%.2s", "123456", "abcdef"); + SPRINTF_CHECK("123", buffer, "%.*s", 3, "123456"); #ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - SPRINTF_CHECK("(null)", buffer, "%.*s", 3, (const char *) RT_NULL); + SPRINTF_CHECK("(null)", buffer, "%.*s", 3, (const char *)RT_NULL); #else - SPRINTF_CHECK("(nu", buffer, "%.*s", 3, (const char *) RT_NULL); + SPRINTF_CHECK("(nu", buffer, "%.*s", 3, (const char *)RT_NULL); #endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ } SPRINTF_TEST_CASE(misc) { char buffer[base_buffer_size]; - SPRINTF_CHECK("53000atest-20 bit", buffer, "%u%u%ctest%d %s", 5, 3000, 'a', -20, "bit"); + SPRINTF_CHECK("53000atest-20 bit", buffer, "%u%u%ctest%d %s", 5, 3000, 'a', -20, "bit"); #ifdef RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - SPRINTF_CHECK("0.33", buffer, "%.*f", 2, 0.33333333); - SPRINTF_CHECK("1", buffer, "%.*d", -1, 1); - SPRINTF_CHECK("foo", buffer, "%.3s", "foobar"); - SPRINTF_CHECK(" ", buffer, "% .0d", 0); - SPRINTF_CHECK(" 00004", buffer, "%10.5d", 4); - SPRINTF_CHECK("hi x", buffer, "%*sx", -3, "hi"); - SPRINTF_CHECK("00123 ", buffer, "%-20.5i", 123); + SPRINTF_CHECK("0.33", buffer, "%.*f", 2, 0.33333333); + SPRINTF_CHECK("1", buffer, "%.*d", -1, 1); + SPRINTF_CHECK("foo", buffer, "%.3s", "foobar"); + SPRINTF_CHECK(" ", buffer, "% .0d", 0); + SPRINTF_CHECK(" 00004", buffer, "%10.5d", 4); + SPRINTF_CHECK("hi x", buffer, "%*sx", -3, "hi"); + SPRINTF_CHECK("00123 ", buffer, "%-20.5i", 123); SPRINTF_CHECK("-67224.546875000000000000", buffer, "%.18f", -67224.546875); #endif /* RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS */ #ifdef RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - SPRINTF_CHECK("0.33", buffer, "%.*g", 2, 0.33333333); - SPRINTF_CHECK("3.33e-01", buffer, "%.*e", 2, 0.33333333); - SPRINTF_CHECK("0.000000e+00", buffer, "%e", 0.0); + SPRINTF_CHECK("0.33", buffer, "%.*g", 2, 0.33333333); + SPRINTF_CHECK("3.33e-01", buffer, "%.*e", 2, 0.33333333); + SPRINTF_CHECK("0.000000e+00", buffer, "%e", 0.0); // SPRINTF_CHECK("-0.000000e+00", buffer, "%e", -0.0); #endif /* RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS */ } diff --git a/src/klibc/utest/TC_rt_sscanf.c b/src/klibc/utest/TC_rt_sscanf.c index 8468acd965..5380ef6cc7 100644 --- a/src/klibc/utest/TC_rt_sscanf.c +++ b/src/klibc/utest/TC_rt_sscanf.c @@ -141,7 +141,7 @@ static void TC_rt_sscanf_suppression(void) static void TC_rt_sscanf_match_set(void) { const char str[] = "abc123"; - char buffer[10] = {0}; + char buffer[10] = { 0 }; int result = rt_sscanf(str, "%[a-z]", buffer); uassert_int_equal(result, 1); uassert_str_equal(buffer, "abc"); diff --git a/src/kservice.c b/src/kservice.c index 0e3ed63f94..edc685e2ff 100644 --- a/src/kservice.c +++ b/src/kservice.c @@ -37,11 +37,11 @@ #define RT_HW_INCLUDE_CPUPORT #include <rthw.h> -#define DBG_TAG "kernel.service" +#define DBG_TAG "kernel.service" #ifdef RT_DEBUG_DEVICE -#define DBG_LVL DBG_LOG +#define DBG_LVL DBG_LOG #else -#define DBG_LVL DBG_WARNING +#define DBG_LVL DBG_WARNING #endif /* defined (RT_DEBUG_DEVICE) */ #include <rtdbg.h> @@ -65,15 +65,15 @@ static rt_device_t _console_device = RT_NULL; rt_weak void rt_hw_us_delay(rt_uint32_t us) { - (void) us; + (void)us; LOG_W("rt_hw_us_delay() doesn't support for this board." - "Please consider implementing rt_hw_us_delay() in another file."); + "Please consider implementing rt_hw_us_delay() in another file."); } rt_weak void rt_hw_cpu_reset(void) { LOG_W("rt_hw_cpu_reset() doesn't support for this board." - "Please consider implementing rt_hw_cpu_reset() in another file."); + "Please consider implementing rt_hw_cpu_reset() in another file."); return; } @@ -81,7 +81,7 @@ rt_weak void rt_hw_cpu_shutdown(void) { LOG_I("CPU shutdown..."); LOG_W("Using default rt_hw_cpu_shutdown()." - "Please consider implementing rt_hw_cpu_shutdown() in another file."); + "Please consider implementing rt_hw_cpu_shutdown() in another file."); rt_hw_interrupt_disable(); RT_ASSERT(0); return; @@ -93,15 +93,19 @@ rt_weak void rt_hw_cpu_shutdown(void) #ifndef RT_HW_BACKTRACE_FRAME_GET_SELF #ifdef __GNUC__ - #define RT_HW_BACKTRACE_FRAME_GET_SELF(frame) do { \ - (frame)->fp = (rt_uintptr_t)__builtin_frame_address(0U); \ - (frame)->pc = ({__label__ pc; pc: (rt_uintptr_t)&&pc;}); \ +#define RT_HW_BACKTRACE_FRAME_GET_SELF(frame) \ + do \ + { \ + (frame)->fp = (rt_uintptr_t)__builtin_frame_address(0U); \ + (frame)->pc = ({__label__ pc; pc: (rt_uintptr_t)&&pc; }); \ } while (0) #else - #define RT_HW_BACKTRACE_FRAME_GET_SELF(frame) do { \ - (frame)->fp = 0; \ - (frame)->pc = 0; \ +#define RT_HW_BACKTRACE_FRAME_GET_SELF(frame) \ + do \ + { \ + (frame)->fp = 0; \ + (frame)->pc = 0; \ } while (0) #endif /* __GNUC__ */ @@ -430,13 +434,15 @@ RTM_EXPORT(rt_kprintf); */ rt_weak rt_err_t rt_backtrace(void) { - struct rt_hw_backtrace_frame frame = {0}; + struct rt_hw_backtrace_frame frame = { 0 }; rt_thread_t thread = rt_thread_self(); /* cppcheck-suppress uninitvar */ RT_HW_BACKTRACE_FRAME_GET_SELF(&frame); if (!frame.fp) + { return -RT_EINVAL; + } /* we don't want this frame to be printed which is nearly garbage info */ rt_hw_backtrace_frame_unwind(thread, &frame); @@ -490,7 +496,6 @@ rt_weak rt_err_t rt_backtrace_formatted_print(rt_ubase_t *buffer, long buflen) return RT_EOK; } - /** * @brief Print backtrace from frame to the given buffer * @@ -512,10 +517,12 @@ rt_weak rt_err_t rt_backtrace_to_buffer(rt_thread_t thread, long buflen) { long nesting = 0; - struct rt_hw_backtrace_frame cur_frame = {0}; + struct rt_hw_backtrace_frame cur_frame = { 0 }; if (!thread) + { return -RT_EINVAL; + } RT_ASSERT(rt_object_get_type(&thread->parent) == RT_Object_Class_Thread); @@ -525,11 +532,14 @@ rt_weak rt_err_t rt_backtrace_to_buffer(rt_thread_t thread, /* cppcheck-suppress uninitvar */ RT_HW_BACKTRACE_FRAME_GET_SELF(frame); if (!frame->fp) + { return -RT_EINVAL; + } } /* discard frames as required. The inner most is always threw. */ - do { + do + { rt_hw_backtrace_frame_unwind(thread, frame); } while (skip-- > 0); @@ -544,7 +554,9 @@ rt_weak rt_err_t rt_backtrace_to_buffer(rt_thread_t thread, } if (nesting < buflen) + { *buffer = RT_NULL; + } return RT_EOK; } @@ -791,8 +803,7 @@ static void cmd_backtrace_format_pid(rt_uintptr_t pid, char *buf, rt_size_t size { digits[count++] = hex[pid & 0xf]; pid >>= 4; - } - while ((pid != 0) && (count < sizeof(digits))); + } while ((pid != 0) && (count < sizeof(digits))); buf[0] = '0'; buf[1] = 'x'; @@ -856,8 +867,7 @@ static rt_bool_t cmd_backtrace_parse_pid(const char *arg, rt_uintptr_t *pid) static rt_thread_t cmd_backtrace_find_thread(rt_uintptr_t pid) { - struct cmd_backtrace_find_ctx ctx = - { + struct cmd_backtrace_find_ctx ctx = { .pid = pid, .thread = RT_NULL, }; @@ -867,7 +877,7 @@ static rt_thread_t cmd_backtrace_find_thread(rt_uintptr_t pid) return ctx.thread; } -static void cmd_backtrace(int argc, char** argv) +static void cmd_backtrace(int argc, char **argv) { rt_uintptr_t pid; rt_thread_t target; @@ -880,11 +890,11 @@ static void cmd_backtrace(int argc, char** argv) if (argc == 1) { rt_kprintf("[INFO] No thread specified\n" - "[HELP] You can use commands like: backtrace %p\n" - "Printing backtrace of calling stack...\n", - rt_thread_self()); + "[HELP] You can use commands like: backtrace %p\n" + "Printing backtrace of calling stack...\n", + rt_thread_self()); rt_backtrace(); - return ; + return; } else { @@ -896,7 +906,7 @@ static void cmd_backtrace(int argc, char** argv) if (!cmd_backtrace_parse_pid(argv[1], &pid)) { rt_kprintf("Invalid input: %s\n", argv[1]); - return ; + return; } target = cmd_backtrace_find_thread(pid); @@ -1007,9 +1017,13 @@ rt_inline rt_base_t _heap_lock(void) return rt_spin_lock_irqsave(&_heap_spinlock); #elif defined(RT_USING_MUTEX) if (rt_thread_self()) + { return rt_mutex_take(&_lock, RT_WAITING_FOREVER); + } else + { return RT_EOK; + } #else rt_enter_critical(); return RT_EOK; @@ -1023,7 +1037,9 @@ rt_inline void _heap_unlock(rt_base_t level) #elif defined(RT_USING_MUTEX) RT_ASSERT(level == RT_EOK); if (rt_thread_self()) + { rt_mutex_release(&_lock); + } #else rt_exit_critical(); #endif @@ -1032,7 +1048,7 @@ rt_inline void _heap_unlock(rt_base_t level) #ifdef RT_USING_UTESTCASES /* export to utest to observe the inner statements */ #ifdef _MSC_VER -#define rt_heap_lock() _heap_lock() +#define rt_heap_lock() _heap_lock() #define rt_heap_unlock() _heap_unlock() #else rt_base_t rt_heap_lock(void) __attribute__((alias("_heap_lock"))); @@ -1043,68 +1059,81 @@ void rt_heap_unlock(rt_base_t level) __attribute__((alias("_heap_unlock"))); #if defined(RT_USING_SMALL_MEM_AS_HEAP) static rt_smem_t system_heap; rt_inline void _smem_info(rt_size_t *total, - rt_size_t *used, rt_size_t *max_used) + rt_size_t *used, rt_size_t *max_used) { if (total) + { *total = system_heap->total; + } if (used) + { *used = system_heap->used; + } if (max_used) + { *max_used = system_heap->max; + } } #define _MEM_INIT(_name, _start, _size) \ system_heap = rt_smem_init(_name, _start, _size) -#define _MEM_MALLOC(_size) \ +#define _MEM_MALLOC(_size) \ rt_smem_alloc(system_heap, _size) -#define _MEM_REALLOC(_ptr, _newsize)\ +#define _MEM_REALLOC(_ptr, _newsize) \ rt_smem_realloc(system_heap, _ptr, _newsize) #define _MEM_FREE(_ptr) \ rt_smem_free(_ptr) -#define _MEM_INFO(_total, _used, _max) \ +#define _MEM_INFO(_total, _used, _max) \ _smem_info(_total, _used, _max) #elif defined(RT_USING_MEMHEAP_AS_HEAP) static struct rt_memheap system_heap; void *_memheap_alloc(struct rt_memheap *heap, rt_size_t size); void _memheap_free(void *rmem); void *_memheap_realloc(struct rt_memheap *heap, void *rmem, rt_size_t newsize); -#define _MEM_INIT(_name, _start, _size) \ - do {\ +#define _MEM_INIT(_name, _start, _size) \ + do \ + { \ rt_memheap_init(&system_heap, _name, _start, _size); \ - system_heap.locked = RT_TRUE; \ - } while(0) -#define _MEM_MALLOC(_size) \ + system_heap.locked = RT_TRUE; \ + } while (0) +#define _MEM_MALLOC(_size) \ _memheap_alloc(&system_heap, _size) -#define _MEM_REALLOC(_ptr, _newsize) \ +#define _MEM_REALLOC(_ptr, _newsize) \ _memheap_realloc(&system_heap, _ptr, _newsize) -#define _MEM_FREE(_ptr) \ +#define _MEM_FREE(_ptr) \ _memheap_free(_ptr) -#define _MEM_INFO(_total, _used, _max) \ +#define _MEM_INFO(_total, _used, _max) \ rt_memheap_info(&system_heap, _total, _used, _max) #elif defined(RT_USING_SLAB_AS_HEAP) static rt_slab_t system_heap; rt_inline void _slab_info(rt_size_t *total, - rt_size_t *used, rt_size_t *max_used) + rt_size_t *used, rt_size_t *max_used) { if (total) + { *total = system_heap->total; + } if (used) + { *used = system_heap->used; + } if (max_used) + { *max_used = system_heap->max; + } } #define _MEM_INIT(_name, _start, _size) \ system_heap = rt_slab_init(_name, _start, _size) -#define _MEM_MALLOC(_size) \ +#define _MEM_MALLOC(_size) \ rt_slab_alloc(system_heap, _size) -#define _MEM_REALLOC(_ptr, _newsize) \ +#define _MEM_REALLOC(_ptr, _newsize) \ rt_slab_realloc(system_heap, _ptr, _newsize) #define _MEM_FREE(_ptr) \ rt_slab_free(system_heap, _ptr) -#define _MEM_INFO _slab_info +#define _MEM_INFO _slab_info #else #define _MEM_INIT(...) -#define _MEM_MALLOC(...) RT_NULL -#define _MEM_REALLOC(...) RT_NULL +#define _MEM_MALLOC(...) RT_NULL +#define _MEM_REALLOC(...) RT_NULL #define _MEM_FREE(...) #define _MEM_INFO(...) #endif @@ -1119,7 +1148,7 @@ rt_inline void _slab_info(rt_size_t *total, void rt_system_heap_init_generic(void *begin_addr, void *end_addr) { rt_uintptr_t begin_align = RT_ALIGN((rt_uintptr_t)begin_addr, RT_ALIGN_SIZE); - rt_uintptr_t end_align = RT_ALIGN_DOWN((rt_uintptr_t)end_addr, RT_ALIGN_SIZE); + rt_uintptr_t end_align = RT_ALIGN_DOWN((rt_uintptr_t)end_addr, RT_ALIGN_SIZE); RT_ASSERT(end_align > begin_align); @@ -1243,7 +1272,10 @@ rt_weak void rt_free(void *ptr) /* call 'rt_free' hook */ RT_OBJECT_HOOK_CALL(rt_free_hook, (&ptr)); /* NULL check */ - if (ptr == RT_NULL) return; + if (ptr == RT_NULL) + { + return; + } /* Enter critical zone */ level = _heap_lock(); _MEM_FREE(ptr); @@ -1323,7 +1355,7 @@ rt_weak void *rt_malloc_align(rt_size_t size, rt_size_t align) rt_size_t align_size = 0; /* sizeof pointer */ - uintptr_size = sizeof(void*); + uintptr_size = sizeof(void *); uintptr_size -= 1; /* align the alignment size to uintptr size byte */ @@ -1366,8 +1398,11 @@ rt_weak void rt_free_align(void *ptr) void *real_ptr = RT_NULL; /* NULL check */ - if (ptr == RT_NULL) return; - real_ptr = (void *) * (rt_uintptr_t *)((rt_uintptr_t)ptr - sizeof(void *)); + if (ptr == RT_NULL) + { + return; + } + real_ptr = (void *)*(rt_uintptr_t *)((rt_uintptr_t)ptr - sizeof(void *)); rt_free(real_ptr); } RTM_EXPORT(rt_free_align); @@ -1425,13 +1460,12 @@ int __rt_fls(int val) #ifndef RT_USING_CPU_FFS #ifdef RT_USING_TINY_FFS -const rt_uint8_t __lowest_bit_bitmap[] = -{ - /* 0 - 7 */ 0, 1, 2, 27, 3, 24, 28, 32, - /* 8 - 15 */ 4, 17, 25, 31, 29, 12, 32, 14, - /* 16 - 23 */ 5, 8, 18, 32, 26, 23, 32, 16, - /* 24 - 31 */ 30, 11, 13, 7, 32, 22, 15, 10, - /* 32 - 36 */ 6, 21, 9, 20, 19 +const rt_uint8_t __lowest_bit_bitmap[] = { + /* 0 - 7 */ 0, 1, 2, 27, 3, 24, 28, 32, + /* 8 - 15 */ 4, 17, 25, 31, 29, 12, 32, 14, + /* 16 - 23 */ 5, 8, 18, 32, 26, 23, 32, 16, + /* 24 - 31 */ 30, 11, 13, 7, 32, 22, 15, 10, + /* 32 - 36 */ 6, 21, 9, 20, 19 }; /** @@ -1451,8 +1485,7 @@ int __rt_ffs(int value) return __lowest_bit_bitmap[(rt_uint32_t)(value & (value - 1) ^ value) % 37]; } #else -const rt_uint8_t __lowest_bit_bitmap[] = -{ +const rt_uint8_t __lowest_bit_bitmap[] = { /* 00 */ 0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, /* 10 */ 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, /* 20 */ 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, @@ -50,22 +50,22 @@ #include <rthw.h> #include <rtthread.h> -#if defined (RT_USING_SMALL_MEM) +#if defined(RT_USING_SMALL_MEM) -#define DBG_TAG "kernel.mem" -#define DBG_LVL DBG_INFO +#define DBG_TAG "kernel.mem" +#define DBG_LVL DBG_INFO #include <rtdbg.h> struct rt_small_mem_item { - rt_uintptr_t pool_ptr; /**< small memory object addr */ - rt_size_t next; /**< next free item */ - rt_size_t prev; /**< prev free item */ + rt_uintptr_t pool_ptr; /**< small memory object addr */ + rt_size_t next; /**< next free item */ + rt_size_t prev; /**< prev free item */ #ifdef RT_USING_MEMTRACE #ifdef ARCH_CPU_64BIT - rt_uint8_t thread[8]; /**< thread name */ + rt_uint8_t thread[8]; /**< thread name */ #else - rt_uint8_t thread[4]; /**< thread name */ + rt_uint8_t thread[4]; /**< thread name */ #endif /* ARCH_CPU_64BIT */ #endif /* RT_USING_MEMTRACE */ }; @@ -75,29 +75,28 @@ struct rt_small_mem_item */ struct rt_small_mem { - struct rt_memory parent; /**< inherit from rt_memory */ - rt_uint8_t *heap_ptr; /**< pointer to the heap */ - struct rt_small_mem_item *heap_end; - struct rt_small_mem_item *lfree; - rt_size_t mem_size_aligned; /**< aligned memory size */ + struct rt_memory parent; /**< inherit from rt_memory */ + rt_uint8_t *heap_ptr; /**< pointer to the heap */ + struct rt_small_mem_item *heap_end; + struct rt_small_mem_item *lfree; + rt_size_t mem_size_aligned; /**< aligned memory size */ }; #define MIN_SIZE (sizeof(rt_uintptr_t) + sizeof(rt_size_t) + sizeof(rt_size_t)) #define MEM_MASK ((~(rt_size_t)0) - 1) -#define MEM_USED(_mem) ((((rt_uintptr_t)(_mem)) & MEM_MASK) | 0x1) -#define MEM_FREED(_mem) ((((rt_uintptr_t)(_mem)) & MEM_MASK) | 0x0) -#define MEM_ISUSED(_mem) \ - (((rt_uintptr_t)(((struct rt_small_mem_item *)(_mem))->pool_ptr)) & (~MEM_MASK)) -#define MEM_POOL(_mem) \ +#define MEM_USED(_mem) ((((rt_uintptr_t)(_mem)) & MEM_MASK) | 0x1) +#define MEM_FREED(_mem) ((((rt_uintptr_t)(_mem)) & MEM_MASK) | 0x0) +#define MEM_ISUSED(_mem) \ + (((rt_uintptr_t)(((struct rt_small_mem_item *)(_mem))->pool_ptr)) & (~MEM_MASK)) +#define MEM_POOL(_mem) \ ((struct rt_small_mem *)(((rt_uintptr_t)(((struct rt_small_mem_item *)(_mem))->pool_ptr)) & (MEM_MASK))) -#define MEM_SIZE(_heap, _mem) \ - (((struct rt_small_mem_item *)(_mem))->next - ((rt_uintptr_t)(_mem) - \ - (rt_uintptr_t)((_heap)->heap_ptr)) - RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE)) +#define MEM_SIZE(_heap, _mem) \ + (((struct rt_small_mem_item *)(_mem))->next - ((rt_uintptr_t)(_mem) - (rt_uintptr_t)((_heap)->heap_ptr)) - RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE)) -#define MIN_SIZE_ALIGNED RT_ALIGN(MIN_SIZE, RT_ALIGN_SIZE) -#define SIZEOF_STRUCT_MEM RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE) +#define MIN_SIZE_ALIGNED RT_ALIGN(MIN_SIZE, RT_ALIGN_SIZE) +#define SIZEOF_STRUCT_MEM RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE) #ifdef RT_USING_MEMTRACE rt_inline void rt_smem_setname(struct rt_small_mem_item *mem, const char *name) @@ -108,13 +107,16 @@ rt_inline void rt_smem_setname(struct rt_small_mem_item *mem, const char *name) name = ""; } - for (index = 0; index < sizeof(mem->thread); index ++) + for (index = 0; index < sizeof(mem->thread); index++) { - if (name[index] == '\0') break; + if (name[index] == '\0') + { + break; + } mem->thread[index] = name[index]; } - for (; index < sizeof(mem->thread); index ++) + for (; index < sizeof(mem->thread); index++) { mem->thread[index] = ' '; } @@ -172,9 +174,9 @@ static void plug_holes(struct rt_small_mem *m, struct rt_small_mem_item *mem) * * @return Return a pointer to the memory object. When the return value is RT_NULL, it means the init failed. */ -rt_smem_t rt_smem_init(const char *name, - void *begin_addr, - rt_size_t size) +rt_smem_t rt_smem_init(const char *name, + void *begin_addr, + rt_size_t size) { struct rt_small_mem_item *mem; struct rt_small_mem *small_mem; @@ -183,7 +185,7 @@ rt_smem_t rt_smem_init(const char *name, small_mem = (struct rt_small_mem *)RT_ALIGN((rt_uintptr_t)begin_addr, RT_ALIGN_SIZE); start_addr = (rt_uintptr_t)small_mem + sizeof(*small_mem); begin_align = RT_ALIGN((rt_uintptr_t)start_addr, RT_ALIGN_SIZE); - end_align = RT_ALIGN_DOWN((rt_uintptr_t)begin_addr + size, RT_ALIGN_SIZE); + end_align = RT_ALIGN_DOWN((rt_uintptr_t)begin_addr + size, RT_ALIGN_SIZE); /* alignment addr */ if ((end_align > (2 * SIZEOF_STRUCT_MEM)) && @@ -212,22 +214,22 @@ rt_smem_t rt_smem_init(const char *name, small_mem->heap_ptr = (rt_uint8_t *)begin_align; LOG_D("mem init, heap begin address 0x%x, size %d", - (rt_uintptr_t)small_mem->heap_ptr, small_mem->mem_size_aligned); + (rt_uintptr_t)small_mem->heap_ptr, small_mem->mem_size_aligned); /* initialize the start of the heap */ - mem = (struct rt_small_mem_item *)small_mem->heap_ptr; + mem = (struct rt_small_mem_item *)small_mem->heap_ptr; mem->pool_ptr = MEM_FREED(small_mem); - mem->next = small_mem->mem_size_aligned + SIZEOF_STRUCT_MEM; - mem->prev = 0; + mem->next = small_mem->mem_size_aligned + SIZEOF_STRUCT_MEM; + mem->prev = 0; #ifdef RT_USING_MEMTRACE rt_smem_setname(mem, "INIT"); #endif /* RT_USING_MEMTRACE */ /* initialize the end of the heap */ - small_mem->heap_end = (struct rt_small_mem_item *)&small_mem->heap_ptr[mem->next]; + small_mem->heap_end = (struct rt_small_mem_item *)&small_mem->heap_ptr[mem->next]; small_mem->heap_end->pool_ptr = MEM_USED(small_mem); - small_mem->heap_end->next = small_mem->mem_size_aligned + SIZEOF_STRUCT_MEM; - small_mem->heap_end->prev = small_mem->mem_size_aligned + SIZEOF_STRUCT_MEM; + small_mem->heap_end->next = small_mem->mem_size_aligned + SIZEOF_STRUCT_MEM; + small_mem->heap_end->prev = small_mem->mem_size_aligned + SIZEOF_STRUCT_MEM; #ifdef RT_USING_MEMTRACE rt_smem_setname(small_mem->heap_end, "INIT"); #endif /* RT_USING_MEMTRACE */ @@ -280,7 +282,9 @@ void *rt_smem_alloc(rt_smem_t m, rt_size_t size) struct rt_small_mem *small_mem; if (size == 0) + { return RT_NULL; + } RT_ASSERT(m != RT_NULL); RT_ASSERT(rt_object_get_type(&m->parent) == RT_Object_Class_Memory); @@ -292,7 +296,9 @@ void *rt_smem_alloc(rt_smem_t m, rt_size_t size) /* every data block must be at least MIN_SIZE_ALIGNED long */ if (size < MIN_SIZE_ALIGNED) + { size = MIN_SIZE_ALIGNED; + } if (size > small_mem->mem_size_aligned) { @@ -328,7 +334,7 @@ void *rt_smem_alloc(rt_smem_t m, rt_size_t size) ptr2 = ptr + SIZEOF_STRUCT_MEM + size; /* create mem2 struct */ - mem2 = (struct rt_small_mem_item *)&small_mem->heap_ptr[ptr2]; + mem2 = (struct rt_small_mem_item *)&small_mem->heap_ptr[ptr2]; mem2->pool_ptr = MEM_FREED(small_mem); mem2->next = mem->next; mem2->prev = ptr; @@ -345,7 +351,9 @@ void *rt_smem_alloc(rt_smem_t m, rt_size_t size) } small_mem->parent.used += (size + SIZEOF_STRUCT_MEM); if (small_mem->parent.max < small_mem->parent.used) + { small_mem->parent.max = small_mem->parent.used; + } } else { @@ -358,22 +366,30 @@ void *rt_smem_alloc(rt_smem_t m, rt_size_t size) */ small_mem->parent.used += mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr); if (small_mem->parent.max < small_mem->parent.used) + { small_mem->parent.max = small_mem->parent.used; + } } /* set small memory object */ mem->pool_ptr = MEM_USED(small_mem); #ifdef RT_USING_MEMTRACE if (rt_thread_self()) + { rt_smem_setname(mem, rt_thread_self()->parent.name); + } else + { rt_smem_setname(mem, "NONE"); + } #endif /* RT_USING_MEMTRACE */ if (mem == small_mem->lfree) { /* Find next free block after mem and update lowest free pointer */ while (MEM_ISUSED(small_mem->lfree) && small_mem->lfree != small_mem->heap_end) + { small_mem->lfree = (struct rt_small_mem_item *)&small_mem->heap_ptr[small_mem->lfree->next]; + } RT_ASSERT(((small_mem->lfree == small_mem->heap_end) || (!MEM_ISUSED(small_mem->lfree)))); } @@ -382,8 +398,8 @@ void *rt_smem_alloc(rt_smem_t m, rt_size_t size) RT_ASSERT((((rt_uintptr_t)mem) & (RT_ALIGN_SIZE - 1)) == 0); LOG_D("allocate memory at 0x%x, size: %d", - (rt_uintptr_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM), - (rt_uintptr_t)(mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr))); + (rt_uintptr_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM), + (rt_uintptr_t)(mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr))); /* return the memory data except mem struct */ return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM; @@ -434,7 +450,9 @@ void *rt_smem_realloc(rt_smem_t m, void *rmem, rt_size_t newsize) /* allocate a new memory block */ if (rmem == RT_NULL) + { return rt_smem_alloc(&small_mem->parent, newsize); + } RT_ASSERT((((rt_uintptr_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0); RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)small_mem->heap_ptr); @@ -505,7 +523,9 @@ void rt_smem_free(void *rmem) struct rt_small_mem *small_mem; if (rmem == RT_NULL) + { return; + } RT_ASSERT((((rt_uintptr_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0); @@ -522,8 +542,8 @@ void rt_smem_free(void *rmem) RT_ASSERT(MEM_POOL(&small_mem->heap_ptr[mem->next]) == small_mem); LOG_D("release memory 0x%x, size: %d", - (rt_uintptr_t)rmem, - (rt_uintptr_t)(mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr))); + (rt_uintptr_t)rmem, + (rt_uintptr_t)(mem->next - ((rt_uint8_t *)mem - small_mem->heap_ptr))); /* ... and is now unused. */ mem->pool_ptr = MEM_FREED(small_mem); @@ -565,7 +585,7 @@ static int memcheck(int argc, char *argv[]) information = rt_object_get_information(RT_Object_Class_Memory); for (node = information->object_list.next; node != &(information->object_list); - node = node->next) + node = node->next) { object = rt_list_entry(node, struct rt_object, list); /* find the specified object */ @@ -575,7 +595,7 @@ static int memcheck(int argc, char *argv[]) } /* mem object */ m = (struct rt_small_mem *)object; - if(rt_strncmp(m->parent.algorithm, "small", RT_NAME_MAX) != 0) + if (rt_strncmp(m->parent.algorithm, "small", RT_NAME_MAX) != 0) { continue; } @@ -584,9 +604,18 @@ static int memcheck(int argc, char *argv[]) for (mem = (struct rt_small_mem_item *)m->heap_ptr; mem != m->heap_end; mem = (struct rt_small_mem_item *)&m->heap_ptr[mem->next]) { position = (rt_uintptr_t)mem - (rt_uintptr_t)m->heap_ptr; - if (position < 0) goto __exit; - if (position > (int)m->mem_size_aligned) goto __exit; - if (MEM_POOL(mem) != m) goto __exit; + if (position < 0) + { + goto __exit; + } + if (position > (int)m->mem_size_aligned) + { + goto __exit; + } + if (MEM_POOL(mem) != m) + { + goto __exit; + } } } rt_hw_interrupt_enable(level); @@ -618,7 +647,7 @@ static int memtrace(int argc, char **argv) information = rt_object_get_information(RT_Object_Class_Memory); for (node = information->object_list.next; node != &(information->object_list); - node = node->next) + node = node->next) { object = rt_list_entry(node, struct rt_object, list); /* find the specified object */ @@ -628,7 +657,7 @@ static int memtrace(int argc, char **argv) } /* mem object */ m = (struct rt_small_mem *)object; - if(rt_strncmp(m->parent.algorithm, "small", RT_NAME_MAX) != 0) + if (rt_strncmp(m->parent.algorithm, "small", RT_NAME_MAX) != 0) { continue; } @@ -648,17 +677,27 @@ static int memtrace(int argc, char **argv) rt_kprintf("[0x%08x - ", mem); if (size < 1024) + { rt_kprintf("%5d", size); + } else if (size < 1024 * 1024) + { rt_kprintf("%4dK", size / 1024); + } else + { rt_kprintf("%4dM", size / (1024 * 1024)); + } rt_kprintf("] %c%c%c%c", mem->thread[0], mem->thread[1], mem->thread[2], mem->thread[3]); if (MEM_POOL(mem) != m) + { rt_kprintf(": ***\n"); + } else + { rt_kprintf("\n"); + } } } return 0; diff --git a/src/memheap.c b/src/memheap.c index 1c7d1de0ed..ff37d48553 100644 --- a/src/memheap.c +++ b/src/memheap.c @@ -26,22 +26,22 @@ #ifdef RT_USING_MEMHEAP -#define DBG_TAG "kernel.memheap" -#define DBG_LVL DBG_INFO +#define DBG_TAG "kernel.memheap" +#define DBG_LVL DBG_INFO #include <rtdbg.h> /* dynamic pool magic and mask */ -#define RT_MEMHEAP_MAGIC 0x1ea01ea0 -#define RT_MEMHEAP_MASK 0xFFFFFFFE -#define RT_MEMHEAP_USED 0x01 -#define RT_MEMHEAP_FREED 0x00 +#define RT_MEMHEAP_MAGIC 0x1ea01ea0 +#define RT_MEMHEAP_MASK 0xFFFFFFFE +#define RT_MEMHEAP_USED 0x01 +#define RT_MEMHEAP_FREED 0x00 -#define RT_MEMHEAP_IS_USED(i) ((i)->magic & RT_MEMHEAP_USED) -#define RT_MEMHEAP_MINIALLOC RT_ALIGN(12, RT_ALIGN_SIZE) +#define RT_MEMHEAP_IS_USED(i) ((i)->magic & RT_MEMHEAP_USED) +#define RT_MEMHEAP_MINIALLOC RT_ALIGN(12, RT_ALIGN_SIZE) -#define RT_MEMHEAP_SIZE RT_ALIGN(sizeof(struct rt_memheap_item), RT_ALIGN_SIZE) -#define MEMITEM_SIZE(item) ((rt_uintptr_t)item->next - (rt_uintptr_t)item - RT_MEMHEAP_SIZE) -#define MEMITEM(ptr) (struct rt_memheap_item*)((rt_uint8_t*)ptr - RT_MEMHEAP_SIZE) +#define RT_MEMHEAP_SIZE RT_ALIGN(sizeof(struct rt_memheap_item), RT_ALIGN_SIZE) +#define MEMITEM_SIZE(item) ((rt_uintptr_t)item->next - (rt_uintptr_t)item - RT_MEMHEAP_SIZE) +#define MEMITEM(ptr) (struct rt_memheap_item *)((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE) static void _remove_next_ptr(volatile struct rt_memheap_item *next_ptr) { @@ -77,9 +77,9 @@ static void _remove_next_ptr(volatile struct rt_memheap_item *next_ptr) * @return RT_EOK */ rt_err_t rt_memheap_init(struct rt_memheap *memheap, - const char *name, - void *start_addr, - rt_size_t size) + const char *name, + void *start_addr, + rt_size_t size) { struct rt_memheap_item *item; @@ -88,17 +88,17 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap, /* initialize pool object */ rt_object_init(&(memheap->parent), RT_Object_Class_MemHeap, name); - memheap->start_addr = start_addr; - memheap->pool_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE); + memheap->start_addr = start_addr; + memheap->pool_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE); memheap->available_size = memheap->pool_size - (2 * RT_MEMHEAP_SIZE); - memheap->max_used_size = memheap->pool_size - memheap->available_size; + memheap->max_used_size = memheap->pool_size - memheap->available_size; /* initialize the free list header */ - item = &(memheap->free_header); - item->magic = (RT_MEMHEAP_MAGIC | RT_MEMHEAP_FREED); - item->pool_ptr = memheap; - item->next = RT_NULL; - item->prev = RT_NULL; + item = &(memheap->free_header); + item->magic = (RT_MEMHEAP_MAGIC | RT_MEMHEAP_FREED); + item->pool_ptr = memheap; + item->next = RT_NULL; + item->prev = RT_NULL; item->next_free = item; item->prev_free = item; @@ -106,11 +106,11 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap, memheap->free_list = item; /* initialize the first big memory block */ - item = (struct rt_memheap_item *)start_addr; - item->magic = (RT_MEMHEAP_MAGIC | RT_MEMHEAP_FREED); - item->pool_ptr = memheap; - item->next = RT_NULL; - item->prev = RT_NULL; + item = (struct rt_memheap_item *)start_addr; + item->magic = (RT_MEMHEAP_MAGIC | RT_MEMHEAP_FREED); + item->pool_ptr = memheap; + item->next = RT_NULL; + item->prev = RT_NULL; item->next_free = item; item->prev_free = item; @@ -118,8 +118,7 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap, rt_memset(item->owner_thread_name, ' ', sizeof(item->owner_thread_name)); #endif /* RT_USING_MEMTRACE */ - item->next = (struct rt_memheap_item *) - ((rt_uint8_t *)item + memheap->available_size + RT_MEMHEAP_SIZE); + item->next = (struct rt_memheap_item *)((rt_uint8_t *)item + memheap->available_size + RT_MEMHEAP_SIZE); item->prev = item->next; /* block list header */ @@ -129,17 +128,17 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap, item->next_free = memheap->free_list->next_free; item->prev_free = memheap->free_list; memheap->free_list->next_free->prev_free = item; - memheap->free_list->next_free = item; + memheap->free_list->next_free = item; /* move to the end of memory pool to build a small tailer block, * which prevents block merging */ item = item->next; /* it's a used memory block */ - item->magic = (RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED); - item->pool_ptr = memheap; - item->next = (struct rt_memheap_item *)start_addr; - item->prev = (struct rt_memheap_item *)start_addr; + item->magic = (RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED); + item->pool_ptr = memheap; + item->next = (struct rt_memheap_item *)start_addr; + item->prev = (struct rt_memheap_item *)start_addr; /* not in free list */ item->next_free = item->prev_free = RT_NULL; @@ -196,7 +195,9 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size) /* align allocated size */ size = RT_ALIGN(size, RT_ALIGN_SIZE); if (size < RT_MEMHEAP_MINIALLOC) + { size = RT_MEMHEAP_MINIALLOC; + } LOG_D("allocate %d on heap:%8.*s", size, RT_NAME_MAX, heap->parent.name); @@ -242,8 +243,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size) struct rt_memheap_item *new_ptr; /* split the block. */ - new_ptr = (struct rt_memheap_item *) - (((rt_uint8_t *)header_ptr) + size + RT_MEMHEAP_SIZE); + new_ptr = (struct rt_memheap_item *)(((rt_uint8_t *)header_ptr) + size + RT_MEMHEAP_SIZE); LOG_D("split: block[0x%08x] nextm[0x%08x] prevm[0x%08x] to new[0x%08x]", header_ptr, @@ -262,10 +262,10 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size) #endif /* RT_USING_MEMTRACE */ /* break down the block list */ - new_ptr->prev = header_ptr; - new_ptr->next = header_ptr->next; + new_ptr->prev = header_ptr; + new_ptr->next = header_ptr->next; header_ptr->next->prev = new_ptr; - header_ptr->next = new_ptr; + header_ptr->next = new_ptr; /* remove header ptr from free list */ header_ptr->next_free->prev_free = header_ptr->prev_free; @@ -277,7 +277,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size) new_ptr->next_free = heap->free_list->next_free; new_ptr->prev_free = heap->free_list; heap->free_list->next_free->prev_free = new_ptr; - heap->free_list->next_free = new_ptr; + heap->free_list->next_free = new_ptr; LOG_D("new ptr: next_free 0x%08x, prev_free 0x%08x", new_ptr->next_free, new_ptr->prev_free); @@ -287,14 +287,18 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size) size - RT_MEMHEAP_SIZE; if (heap->pool_size - heap->available_size > heap->max_used_size) + { heap->max_used_size = heap->pool_size - heap->available_size; + } } else { /* decrement the entire free size from the available bytes count. */ heap->available_size = heap->available_size - free_size; if (heap->pool_size - heap->available_size > heap->max_used_size) + { heap->max_used_size = heap->pool_size - heap->available_size; + } /* remove header_ptr from free list */ LOG_D("one block: block[0x%08x], next_free 0x%08x, prev_free 0x%08x", @@ -313,9 +317,13 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size) #ifdef RT_USING_MEMTRACE if (rt_thread_self()) + { rt_memcpy(header_ptr->owner_thread_name, rt_thread_self()->parent.name, sizeof(header_ptr->owner_thread_name)); + } else + { rt_memcpy(header_ptr->owner_thread_name, "NONE", sizeof(header_ptr->owner_thread_name)); + } #endif /* RT_USING_MEMTRACE */ if (heap->locked == RT_FALSE) @@ -378,7 +386,9 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) /* align allocated size */ newsize = RT_ALIGN(newsize, RT_ALIGN_SIZE); if (newsize < RT_MEMHEAP_MINIALLOC) + { newsize = RT_MEMHEAP_MINIALLOC; + } if (ptr == RT_NULL) { @@ -386,8 +396,7 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) } /* get memory block header and get the size of memory block */ - header_ptr = (struct rt_memheap_item *) - ((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE); + header_ptr = (struct rt_memheap_item *)((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE); oldsize = MEMITEM_SIZE(header_ptr); /* re-allocate memory */ if (newsize > oldsize) @@ -433,7 +442,9 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) /* decrement the entire free size from the available bytes count. */ heap->available_size = heap->available_size - (newsize - oldsize); if (heap->pool_size - heap->available_size > heap->max_used_size) + { heap->max_used_size = heap->pool_size - heap->available_size; + } /* remove next_ptr from free list */ LOG_D("remove block: block[0x%08x], next_free 0x%08x, prev_free 0x%08x", @@ -461,16 +472,16 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) rt_memset((void *)next_ptr->owner_thread_name, ' ', sizeof(next_ptr->owner_thread_name)); #endif /* RT_USING_MEMTRACE */ - next_ptr->prev = header_ptr; - next_ptr->next = header_ptr->next; + next_ptr->prev = header_ptr; + next_ptr->next = header_ptr->next; header_ptr->next->prev = (struct rt_memheap_item *)next_ptr; - header_ptr->next = (struct rt_memheap_item *)next_ptr; + header_ptr->next = (struct rt_memheap_item *)next_ptr; /* insert next_ptr to free list */ next_ptr->next_free = heap->free_list->next_free; next_ptr->prev_free = heap->free_list; heap->free_list->next_free->prev_free = (struct rt_memheap_item *)next_ptr; - heap->free_list->next_free = (struct rt_memheap_item *)next_ptr; + heap->free_list->next_free = (struct rt_memheap_item *)next_ptr; LOG_D("new ptr: next_free 0x%08x, prev_free 0x%08x", next_ptr->next_free, next_ptr->prev_free); @@ -503,7 +514,9 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) /* don't split when there is less than one node space left */ if (newsize + RT_MEMHEAP_SIZE + RT_MEMHEAP_MINIALLOC >= oldsize) + { return ptr; + } if (heap->locked == RT_FALSE) { @@ -518,8 +531,7 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) } /* split the block. */ - new_ptr = (struct rt_memheap_item *) - (((rt_uint8_t *)header_ptr) + newsize + RT_MEMHEAP_SIZE); + new_ptr = (struct rt_memheap_item *)(((rt_uint8_t *)header_ptr) + newsize + RT_MEMHEAP_SIZE); LOG_D("split: block[0x%08x] nextm[0x%08x] prevm[0x%08x] to new[0x%08x]", header_ptr, @@ -537,10 +549,10 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) #endif /* RT_USING_MEMTRACE */ /* break down the block list */ - new_ptr->prev = header_ptr; - new_ptr->next = header_ptr->next; + new_ptr->prev = header_ptr; + new_ptr->next = header_ptr->next; header_ptr->next->prev = new_ptr; - header_ptr->next = new_ptr; + header_ptr->next = new_ptr; /* determine if the block can be merged with the next neighbor. */ if (!RT_MEMHEAP_IS_USED(new_ptr->next)) @@ -555,7 +567,7 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) header_ptr, header_ptr->next_free, header_ptr->prev_free); free_ptr->next->prev = new_ptr; - new_ptr->next = free_ptr->next; + new_ptr->next = free_ptr->next; /* remove free ptr from free list */ free_ptr->next_free->prev_free = free_ptr->prev_free; @@ -566,7 +578,7 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize) new_ptr->next_free = heap->free_list->next_free; new_ptr->prev_free = heap->free_list; heap->free_list->next_free->prev_free = new_ptr; - heap->free_list->next_free = new_ptr; + heap->free_list->next_free = new_ptr; LOG_D("new free ptr: next_free 0x%08x, prev_free 0x%08x", new_ptr->next_free, new_ptr->prev_free); @@ -599,20 +611,22 @@ void rt_memheap_free(void *ptr) rt_bool_t insert_header; /* NULL check */ - if (ptr == RT_NULL) return; + if (ptr == RT_NULL) + { + return; + } /* set initial status as OK */ insert_header = RT_TRUE; - new_ptr = RT_NULL; - header_ptr = (struct rt_memheap_item *) - ((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE); + new_ptr = RT_NULL; + header_ptr = (struct rt_memheap_item *)((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE); LOG_D("free memory: memory[0x%08x], block[0x%08x]", ptr, header_ptr); /* check magic */ if (header_ptr->magic != (RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED) || - (header_ptr->next->magic & RT_MEMHEAP_MASK) != RT_MEMHEAP_MAGIC) + (header_ptr->next->magic & RT_MEMHEAP_MASK) != RT_MEMHEAP_MAGIC) { LOG_D("bad magic:0x%08x @ memheap", header_ptr->magic); @@ -636,7 +650,7 @@ void rt_memheap_free(void *ptr) { rt_set_errno(result); - return ; + return; } } @@ -677,7 +691,7 @@ void rt_memheap_free(void *ptr) new_ptr, new_ptr->next_free, new_ptr->prev_free); new_ptr->next->prev = header_ptr; - header_ptr->next = new_ptr->next; + header_ptr->next = new_ptr->next; /* remove new ptr from free list */ new_ptr->next_free->prev_free = new_ptr->prev_free; @@ -689,7 +703,7 @@ void rt_memheap_free(void *ptr) struct rt_memheap_item *n = heap->free_list->next_free; #if defined(RT_MEMHEAP_BEST_MODE) rt_size_t blk_size = MEMITEM_SIZE(header_ptr); - for (;n != heap->free_list; n = n->next_free) + for (; n != heap->free_list; n = n->next_free) { rt_size_t m = MEMITEM_SIZE(n); if (blk_size <= m) @@ -752,13 +766,19 @@ void rt_memheap_info(struct rt_memheap *heap, } if (total != RT_NULL) + { *total = heap->pool_size; + } - if (used != RT_NULL) + if (used != RT_NULL) + { *used = heap->pool_size - heap->available_size; + } if (max_used != RT_NULL) + { *max_used = heap->max_used_size; + } if (heap->locked == RT_FALSE) { @@ -788,20 +808,24 @@ void *_memheap_alloc(struct rt_memheap *heap, rt_size_t size) /* try to allocate on other memory heap */ information = rt_object_get_information(RT_Object_Class_MemHeap); RT_ASSERT(information != RT_NULL); - for (node = information->object_list.next; + for (node = information->object_list.next; node != &(information->object_list); - node = node->next) + node = node->next) { object = rt_list_entry(node, struct rt_object, list); - _heap = (struct rt_memheap *)object; + _heap = (struct rt_memheap *)object; /* not allocate in the default system heap */ if (heap == _heap) + { continue; + } ptr = rt_memheap_alloc(_heap, size); if (ptr != RT_NULL) + { break; + } } } #endif /* RT_USING_MEMHEAP_AUTO_BINDING */ @@ -825,7 +849,9 @@ void *_memheap_realloc(struct rt_memheap *heap, void *rmem, rt_size_t newsize) struct rt_memheap_item *header_ptr; if (rmem == RT_NULL) + { return _memheap_alloc(heap, newsize); + } if (newsize == 0) { @@ -834,8 +860,7 @@ void *_memheap_realloc(struct rt_memheap *heap, void *rmem, rt_size_t newsize) } /* get old memory item */ - header_ptr = (struct rt_memheap_item *) - ((rt_uint8_t *)rmem - RT_MEMHEAP_SIZE); + header_ptr = (struct rt_memheap_item *)((rt_uint8_t *)rmem - RT_MEMHEAP_SIZE); new_ptr = rt_memheap_realloc(header_ptr->pool_ptr, rmem, newsize); if (new_ptr == RT_NULL && newsize != 0) @@ -849,9 +874,13 @@ void *_memheap_realloc(struct rt_memheap *heap, void *rmem, rt_size_t newsize) /* get the size of old memory block */ oldsize = MEMITEM_SIZE(header_ptr); if (newsize > oldsize) + { rt_memcpy(new_ptr, rmem, oldsize); + } else + { rt_memcpy(new_ptr, rmem, newsize); + } _memheap_free(rmem); } @@ -882,13 +911,15 @@ static int memheapcheck(int argc, char *argv[]) heap = (struct rt_memheap *)rt_list_entry(node, struct rt_object, list); /* find the specified object */ if (name != RT_NULL && rt_strncmp(name, heap->parent.name, RT_NAME_MAX) != 0) + { continue; + } /* check memheap */ for (item = heap->block_list; item->next != heap->block_list; item = item->next) { /* check magic */ if (!((item->magic & (RT_MEMHEAP_MAGIC | RT_MEMHEAP_FREED)) == (RT_MEMHEAP_MAGIC | RT_MEMHEAP_FREED) || - (item->magic & (RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED)) == (RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED))) + (item->magic & (RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED)) == (RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED))) { has_bad = RT_TRUE; break; @@ -902,8 +933,8 @@ static int memheapcheck(int argc, char *argv[]) /* check next and prev */ if (!((rt_uintptr_t)item->next <= (rt_uintptr_t)((rt_uintptr_t)heap->start_addr + heap->pool_size) && (rt_uintptr_t)item->prev >= (rt_uintptr_t)heap->start_addr) && - (rt_uintptr_t)item->next == RT_ALIGN((rt_uintptr_t)item->next, RT_ALIGN_SIZE) && - (rt_uintptr_t)item->prev == RT_ALIGN((rt_uintptr_t)item->prev, RT_ALIGN_SIZE)) + (rt_uintptr_t)item->next == RT_ALIGN((rt_uintptr_t)item->next, RT_ALIGN_SIZE) && + (rt_uintptr_t)item->prev == RT_ALIGN((rt_uintptr_t)item->prev, RT_ALIGN_SIZE)) { has_bad = RT_TRUE; break; @@ -946,7 +977,9 @@ static int memheaptrace(int argc, char *argv[]) mh = (struct rt_memheap *)rt_list_entry(node, struct rt_object, list); /* find the specified object */ if (name != RT_NULL && rt_strncmp(name, mh->parent.name, RT_NAME_MAX) != 0) + { continue; + } /* memheap dump */ rt_kprintf("\nmemory heap address:\n"); rt_kprintf("name : %s\n", mh->parent.name); @@ -963,29 +996,39 @@ static int memheaptrace(int argc, char *argv[]) if ((header_ptr->magic & RT_MEMHEAP_MASK) != RT_MEMHEAP_MAGIC) { rt_kprintf("[0x%p - incorrect magic: 0x%08x\n", - header_ptr, header_ptr->magic); + header_ptr, header_ptr->magic); break; } /* get current memory block size */ block_size = MEMITEM_SIZE(header_ptr); if (block_size < 0) + { break; + } rt_kprintf("[0x%p - ", header_ptr); if (block_size < 1024) + { rt_kprintf("%5d", block_size); + } else if (block_size < 1024 * 1024) + { rt_kprintf("%4dK", block_size / 1024); + } else if (block_size < 1024 * 1024 * 100) - rt_kprintf("%2d.%dM", block_size / (1024 * 1024), (block_size % (1024 * 1024) * 10) / (1024 * 1024)); + { + rt_kprintf("%2d.%dM", block_size / (1024 * 1024), (block_size % (1024 * 1024) * 10) / (1024 * 1024)); + } else + { rt_kprintf("%4dM", block_size / (1024 * 1024)); + } /* dump thread name */ rt_kprintf("] %c%c%c%c\n", - header_ptr->owner_thread_name[0], - header_ptr->owner_thread_name[1], - header_ptr->owner_thread_name[2], - header_ptr->owner_thread_name[3]); + header_ptr->owner_thread_name[0], + header_ptr->owner_thread_name[1], + header_ptr->owner_thread_name[2], + header_ptr->owner_thread_name[3]); } } return 0; diff --git a/src/mempool.c b/src/mempool.c index b980a08aa5..3e1a976355 100644 --- a/src/mempool.c +++ b/src/mempool.c @@ -82,10 +82,10 @@ void rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block)) * @return RT_EOK */ rt_err_t rt_mp_init(struct rt_mempool *mp, - const char *name, - void *start, - rt_size_t size, - rt_size_t block_size) + const char *name, + void *start, + rt_size_t size, + rt_size_t block_size) { rt_uint8_t *block_ptr; rt_size_t offset; @@ -109,14 +109,14 @@ rt_err_t rt_mp_init(struct rt_mempool *mp, /* align to align size byte */ mp->block_total_count = mp->size / (mp->block_size + sizeof(rt_uint8_t *)); - mp->block_free_count = mp->block_total_count; + mp->block_free_count = mp->block_total_count; /* initialize suspended thread list */ rt_list_init(&(mp->suspend_thread)); /* initialize free block list */ block_ptr = (rt_uint8_t *)mp->start_address; - for (offset = 0; offset < mp->block_total_count; offset ++) + for (offset = 0; offset < mp->block_total_count; offset++) { *(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *))) = (rt_uint8_t *)(block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *))); @@ -174,8 +174,8 @@ RTM_EXPORT(rt_mp_detach); * @return the created mempool object */ rt_mp_t rt_mp_create(const char *name, - rt_size_t block_count, - rt_size_t block_size) + rt_size_t block_count, + rt_size_t block_size) { rt_uint8_t *block_ptr; struct rt_mempool *mp; @@ -191,12 +191,14 @@ rt_mp_t rt_mp_create(const char *name, mp = (struct rt_mempool *)rt_object_allocate(RT_Object_Class_MemPool, name); /* allocate object failed */ if (mp == RT_NULL) + { return RT_NULL; + } /* initialize memory pool */ - block_size = RT_ALIGN(block_size, RT_ALIGN_SIZE); + block_size = RT_ALIGN(block_size, RT_ALIGN_SIZE); mp->block_size = block_size; - mp->size = (block_size + sizeof(rt_uint8_t *)) * block_count; + mp->size = (block_size + sizeof(rt_uint8_t *)) * block_count; /* allocate memory */ mp->start_address = rt_malloc((block_size + sizeof(rt_uint8_t *)) * @@ -210,21 +212,19 @@ rt_mp_t rt_mp_create(const char *name, } mp->block_total_count = block_count; - mp->block_free_count = mp->block_total_count; + mp->block_free_count = mp->block_total_count; /* initialize suspended thread list */ rt_list_init(&(mp->suspend_thread)); /* initialize free block list */ block_ptr = (rt_uint8_t *)mp->start_address; - for (offset = 0; offset < mp->block_total_count; offset ++) + for (offset = 0; offset < mp->block_total_count; offset++) { - *(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *))) - = block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *)); + *(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *))) = block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *)); } - *(rt_uint8_t **)(block_ptr + (offset - 1) * (block_size + sizeof(rt_uint8_t *))) - = RT_NULL; + *(rt_uint8_t **)(block_ptr + (offset - 1) * (block_size + sizeof(rt_uint8_t *))) = RT_NULL; mp->block_list = block_ptr; rt_spin_lock_init(&(mp->spinlock)); @@ -332,13 +332,17 @@ void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time) rt_schedule(); if (thread->error != RT_EOK) + { return RT_NULL; + } if (time > 0) { time -= rt_tick_get() - before_sleep; if (time < 0) + { time = 0; + } } level = rt_spin_lock_irqsave(&(mp->spinlock)); } @@ -377,18 +381,21 @@ void rt_mp_free(void *block) rt_base_t level; /* parameter check */ - if (block == RT_NULL) return; + if (block == RT_NULL) + { + return; + } /* get the control block of pool which the block belongs to */ block_ptr = (rt_uint8_t **)((rt_uint8_t *)block - sizeof(rt_uint8_t *)); - mp = (struct rt_mempool *)*block_ptr; + mp = (struct rt_mempool *)*block_ptr; RT_OBJECT_HOOK_CALL(rt_mp_free_hook, (mp, block)); level = rt_spin_lock_irqsave(&(mp->spinlock)); /* increase the free block count */ - mp->block_free_count ++; + mp->block_free_count++; /* link the block into the block list */ *block_ptr = mp->block_list; diff --git a/src/object.c b/src/object.c index 507a47894e..373148221d 100644 --- a/src/object.c +++ b/src/object.c @@ -29,8 +29,8 @@ #include <lwp.h> #endif -#define DBG_TAG "kernel.obj" -#define DBG_LVL DBG_ERROR +#define DBG_TAG "kernel.obj" +#define DBG_LVL DBG_ERROR #include <rtdbg.h> struct rt_custom_object @@ -45,106 +45,105 @@ struct rt_custom_object */ enum rt_object_info_type { - RT_Object_Info_Thread = 0, /**< The object is a thread. */ + RT_Object_Info_Thread = 0, /**< The object is a thread. */ #ifdef RT_USING_SEMAPHORE - RT_Object_Info_Semaphore, /**< The object is a semaphore. */ + RT_Object_Info_Semaphore, /**< The object is a semaphore. */ #endif #ifdef RT_USING_MUTEX - RT_Object_Info_Mutex, /**< The object is a mutex. */ + RT_Object_Info_Mutex, /**< The object is a mutex. */ #endif #ifdef RT_USING_EVENT - RT_Object_Info_Event, /**< The object is a event. */ + RT_Object_Info_Event, /**< The object is a event. */ #endif #ifdef RT_USING_MAILBOX - RT_Object_Info_MailBox, /**< The object is a mail box. */ + RT_Object_Info_MailBox, /**< The object is a mail box. */ #endif #ifdef RT_USING_MESSAGEQUEUE - RT_Object_Info_MessageQueue, /**< The object is a message queue. */ + RT_Object_Info_MessageQueue, /**< The object is a message queue. */ #endif #ifdef RT_USING_MEMHEAP - RT_Object_Info_MemHeap, /**< The object is a memory heap */ + RT_Object_Info_MemHeap, /**< The object is a memory heap */ #endif #ifdef RT_USING_MEMPOOL - RT_Object_Info_MemPool, /**< The object is a memory pool. */ + RT_Object_Info_MemPool, /**< The object is a memory pool. */ #endif #ifdef RT_USING_DEVICE - RT_Object_Info_Device, /**< The object is a device */ + RT_Object_Info_Device, /**< The object is a device */ #endif - RT_Object_Info_Timer, /**< The object is a timer. */ + RT_Object_Info_Timer, /**< The object is a timer. */ #ifdef RT_USING_MODULE - RT_Object_Info_Module, /**< The object is a module. */ + RT_Object_Info_Module, /**< The object is a module. */ #endif #ifdef RT_USING_HEAP - RT_Object_Info_Memory, /**< The object is a memory. */ + RT_Object_Info_Memory, /**< The object is a memory. */ #endif #ifdef RT_USING_SMART - RT_Object_Info_Channel, /**< The object is a IPC channel */ - RT_Object_Info_ProcessGroup, /**< The object is a process group */ - RT_Object_Info_Session, /**< The object is a session */ + RT_Object_Info_Channel, /**< The object is a IPC channel */ + RT_Object_Info_ProcessGroup, /**< The object is a process group */ + RT_Object_Info_Session, /**< The object is a session */ #endif #ifdef RT_USING_HEAP - RT_Object_Info_Custom, /**< The object is a custom object */ + RT_Object_Info_Custom, /**< The object is a custom object */ #endif - RT_Object_Info_Unknown, /**< The object is unknown. */ + RT_Object_Info_Unknown, /**< The object is unknown. */ }; -#define _OBJ_CONTAINER_LIST_INIT(c) \ - {&(_object_container[c].object_list), &(_object_container[c].object_list)} +#define _OBJ_CONTAINER_LIST_INIT(c) \ + { &(_object_container[c].object_list), &(_object_container[c].object_list) } -static struct rt_object_information _object_container[RT_Object_Info_Unknown] = -{ +static struct rt_object_information _object_container[RT_Object_Info_Unknown] = { /* initialize object container - thread */ - {RT_Object_Class_Thread, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Thread), sizeof(struct rt_thread), RT_SPINLOCK_INIT}, + { RT_Object_Class_Thread, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Thread), sizeof(struct rt_thread), RT_SPINLOCK_INIT }, #ifdef RT_USING_SEMAPHORE /* initialize object container - semaphore */ - {RT_Object_Class_Semaphore, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Semaphore), sizeof(struct rt_semaphore), RT_SPINLOCK_INIT}, + { RT_Object_Class_Semaphore, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Semaphore), sizeof(struct rt_semaphore), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_MUTEX /* initialize object container - mutex */ - {RT_Object_Class_Mutex, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Mutex), sizeof(struct rt_mutex), RT_SPINLOCK_INIT}, + { RT_Object_Class_Mutex, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Mutex), sizeof(struct rt_mutex), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_EVENT /* initialize object container - event */ - {RT_Object_Class_Event, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Event), sizeof(struct rt_event), RT_SPINLOCK_INIT}, + { RT_Object_Class_Event, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Event), sizeof(struct rt_event), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_MAILBOX /* initialize object container - mailbox */ - {RT_Object_Class_MailBox, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MailBox), sizeof(struct rt_mailbox), RT_SPINLOCK_INIT}, + { RT_Object_Class_MailBox, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MailBox), sizeof(struct rt_mailbox), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_MESSAGEQUEUE /* initialize object container - message queue */ - {RT_Object_Class_MessageQueue, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MessageQueue), sizeof(struct rt_messagequeue), RT_SPINLOCK_INIT}, + { RT_Object_Class_MessageQueue, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MessageQueue), sizeof(struct rt_messagequeue), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_MEMHEAP /* initialize object container - memory heap */ - {RT_Object_Class_MemHeap, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MemHeap), sizeof(struct rt_memheap), RT_SPINLOCK_INIT}, + { RT_Object_Class_MemHeap, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MemHeap), sizeof(struct rt_memheap), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_MEMPOOL /* initialize object container - memory pool */ - {RT_Object_Class_MemPool, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MemPool), sizeof(struct rt_mempool), RT_SPINLOCK_INIT}, + { RT_Object_Class_MemPool, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MemPool), sizeof(struct rt_mempool), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_DEVICE /* initialize object container - device */ - {RT_Object_Class_Device, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Device), sizeof(struct rt_device), RT_SPINLOCK_INIT}, + { RT_Object_Class_Device, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Device), sizeof(struct rt_device), RT_SPINLOCK_INIT }, #endif /* initialize object container - timer */ - {RT_Object_Class_Timer, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Timer), sizeof(struct rt_timer), RT_SPINLOCK_INIT}, + { RT_Object_Class_Timer, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Timer), sizeof(struct rt_timer), RT_SPINLOCK_INIT }, #ifdef RT_USING_MODULE /* initialize object container - module */ - {RT_Object_Class_Module, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Module), sizeof(struct rt_dlmodule), RT_SPINLOCK_INIT}, + { RT_Object_Class_Module, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Module), sizeof(struct rt_dlmodule), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_HEAP /* initialize object container - small memory */ - {RT_Object_Class_Memory, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Memory), sizeof(struct rt_memory), RT_SPINLOCK_INIT}, + { RT_Object_Class_Memory, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Memory), sizeof(struct rt_memory), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_SMART /* initialize object container - module */ - {RT_Object_Class_Channel, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Channel), sizeof(struct rt_channel), RT_SPINLOCK_INIT}, - {RT_Object_Class_ProcessGroup, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_ProcessGroup), sizeof(struct rt_processgroup), RT_SPINLOCK_INIT}, - {RT_Object_Class_Session, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Session), sizeof(struct rt_session), RT_SPINLOCK_INIT}, + { RT_Object_Class_Channel, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Channel), sizeof(struct rt_channel), RT_SPINLOCK_INIT }, + { RT_Object_Class_ProcessGroup, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_ProcessGroup), sizeof(struct rt_processgroup), RT_SPINLOCK_INIT }, + { RT_Object_Class_Session, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Session), sizeof(struct rt_session), RT_SPINLOCK_INIT }, #endif #ifdef RT_USING_HEAP - {RT_Object_Class_Custom, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Custom), sizeof(struct rt_custom_object), RT_SPINLOCK_INIT}, + { RT_Object_Class_Custom, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Custom), sizeof(struct rt_custom_object), RT_SPINLOCK_INIT }, #endif }; @@ -253,8 +252,13 @@ rt_object_get_information(enum rt_object_class_type type) type = (enum rt_object_class_type)(type & ~RT_Object_Class_Static); - for (index = 0; index < RT_Object_Info_Unknown; index ++) - if (_object_container[index].type == type) return &_object_container[index]; + for (index = 0; index < RT_Object_Info_Unknown; index++) + { + if (_object_container[index].type == type) + { + return &_object_container[index]; + } + } return RT_NULL; } @@ -276,12 +280,15 @@ int rt_object_get_length(enum rt_object_class_type type) struct rt_object_information *information = RT_NULL; information = rt_object_get_information((enum rt_object_class_type)type); - if (information == RT_NULL) return 0; + if (information == RT_NULL) + { + return 0; + } level = rt_spin_lock_irqsave(&(information->spinlock)); rt_list_for_each(node, &(information->object_list)) { - count ++; + count++; } rt_spin_unlock_irqrestore(&(information->spinlock), level); @@ -311,10 +318,16 @@ int rt_object_get_pointers(enum rt_object_class_type type, rt_object_t *pointers struct rt_list_node *node = RT_NULL; struct rt_object_information *information = RT_NULL; - if (maxlen <= 0) return 0; + if (maxlen <= 0) + { + return 0; + } information = rt_object_get_information(type); - if (information == RT_NULL) return 0; + if (information == RT_NULL) + { + return 0; + } level = rt_spin_lock_irqsave(&(information->spinlock)); /* retrieve pointer of object */ @@ -323,9 +336,12 @@ int rt_object_get_pointers(enum rt_object_class_type type, rt_object_t *pointers object = rt_list_entry(node, struct rt_object, list); pointers[index] = object; - index ++; + index++; - if (index >= maxlen) break; + if (index >= maxlen) + { + break; + } } rt_spin_unlock_irqrestore(&(information->spinlock), level); @@ -352,9 +368,9 @@ RTM_EXPORT(rt_object_get_pointers); * name is specified by RT_NAME_MAX. The system does not care if it * uses '\0' as a terminal symbol. */ -void rt_object_init(struct rt_object *object, +void rt_object_init(struct rt_object *object, enum rt_object_class_type type, - const char *name) + const char *name) { rt_base_t level; rt_size_t obj_name_len; @@ -376,9 +392,9 @@ void rt_object_init(struct rt_object *object, /* enter critical */ level = rt_spin_lock_irqsave(&(information->spinlock)); /* try to find object */ - for (node = information->object_list.next; - node != &(information->object_list); - node = node->next) + for (node = information->object_list.next; + node != &(information->object_list); + node = node->next) { struct rt_object *obj; @@ -396,7 +412,7 @@ void rt_object_init(struct rt_object *object, if (name) { obj_name_len = rt_strlen(name); - if(obj_name_len > RT_NAME_MAX - 1) + if (obj_name_len > RT_NAME_MAX - 1) { LOG_E("Object name %s exceeds RT_NAME_MAX=%d, consider increasing RT_NAME_MAX.", name, RT_NAME_MAX); } @@ -511,7 +527,7 @@ rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name) if (name) { obj_name_len = rt_strlen(name); - if(obj_name_len > RT_NAME_MAX - 1) + if (obj_name_len > RT_NAME_MAX - 1) { LOG_E("Object name %s exceeds RT_NAME_MAX=%d, consider increasing RT_NAME_MAX.", name, RT_NAME_MAX); } @@ -563,7 +579,6 @@ void rt_object_delete(rt_object_t object) RT_OBJECT_HOOK_CALL(rt_object_detach_hook, (object)); - information = rt_object_get_information((enum rt_object_class_type)object->type); RT_ASSERT(information != RT_NULL); @@ -598,7 +613,9 @@ rt_bool_t rt_object_is_systemobject(rt_object_t object) RT_ASSERT(object != RT_NULL); if (object->type & RT_Object_Class_Static) + { return RT_TRUE; + } return RT_FALSE; } @@ -712,15 +729,16 @@ static rt_err_t _match_name(struct rt_object *obj, void *data) */ rt_object_t rt_object_find(const char *name, rt_uint8_t type) { - struct _obj_find_param param = - { + struct _obj_find_param param = { .match_name = name, .matched_obj = RT_NULL, }; /* parameter check */ if (name == RT_NULL || rt_object_get_information(type) == RT_NULL) + { return RT_NULL; + } /* which is invoke in interrupt status */ RT_DEBUG_NOT_IN_INTERRUPT; diff --git a/src/scheduler_comm.c b/src/scheduler_comm.c index 5986f5a62c..11bc1ecbbb 100644 --- a/src/scheduler_comm.c +++ b/src/scheduler_comm.c @@ -366,9 +366,9 @@ static rt_err_t _rt_sched_update_priority(struct rt_thread *thread, rt_uint8_t p /* recalculate priority attribute */ #if RT_THREAD_PRIORITY_MAX > 32 - RT_SCHED_PRIV(thread).number = RT_SCHED_PRIV(thread).current_priority >> 3; /* 5bit */ + RT_SCHED_PRIV(thread).number = RT_SCHED_PRIV(thread).current_priority >> 3; /* 5bit */ RT_SCHED_PRIV(thread).number_mask = 1 << RT_SCHED_PRIV(thread).number; - RT_SCHED_PRIV(thread).high_mask = 1 << (RT_SCHED_PRIV(thread).current_priority & 0x07); /* 3bit */ + RT_SCHED_PRIV(thread).high_mask = 1 << (RT_SCHED_PRIV(thread).current_priority & 0x07); /* 3bit */ #else RT_SCHED_PRIV(thread).number_mask = 1 << RT_SCHED_PRIV(thread).current_priority; #endif /* RT_THREAD_PRIORITY_MAX > 32 */ @@ -387,9 +387,9 @@ static rt_err_t _rt_sched_update_priority(struct rt_thread *thread, rt_uint8_t p /* recalculate priority attribute */ #if RT_THREAD_PRIORITY_MAX > 32 - RT_SCHED_PRIV(thread).number = RT_SCHED_PRIV(thread).current_priority >> 3; /* 5bit */ + RT_SCHED_PRIV(thread).number = RT_SCHED_PRIV(thread).current_priority >> 3; /* 5bit */ RT_SCHED_PRIV(thread).number_mask = 1 << RT_SCHED_PRIV(thread).number; - RT_SCHED_PRIV(thread).high_mask = 1 << (RT_SCHED_PRIV(thread).current_priority & 0x07); /* 3bit */ + RT_SCHED_PRIV(thread).high_mask = 1 << (RT_SCHED_PRIV(thread).current_priority & 0x07); /* 3bit */ #else RT_SCHED_PRIV(thread).number_mask = 1 << RT_SCHED_PRIV(thread).current_priority; #endif /* RT_THREAD_PRIORITY_MAX > 32 */ @@ -499,8 +499,7 @@ void rt_scheduler_stack_check(struct rt_thread *thread) /* If hook handled the overflow successfully, don't enter infinite loop */ if (hook_result != RT_EOK) { - while (dummy) - ; + while (dummy); } } #endif /* RT_USING_HW_STACK_GUARD */ diff --git a/src/scheduler_mp.c b/src/scheduler_mp.c index 4bcbafad6d..4ff5a05ff1 100644 --- a/src/scheduler_mp.c +++ b/src/scheduler_mp.c @@ -39,8 +39,8 @@ #include <rtthread.h> #include <rthw.h> -#define DBG_TAG "kernel.scheduler" -#define DBG_LVL DBG_INFO +#define DBG_TAG "kernel.scheduler" +#define DBG_LVL DBG_INFO #include <rtdbg.h> rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX]; @@ -48,16 +48,18 @@ static struct rt_spinlock _mp_scheduler_lock; #define SCHEDULER_LOCK_FLAG(percpu) ((percpu)->sched_lock_flag) -#define SCHEDULER_ENTER_CRITICAL(curthr) \ - do \ - { \ - if (curthr) RT_SCHED_CTX(curthr).critical_lock_nest++; \ +#define SCHEDULER_ENTER_CRITICAL(curthr) \ + do \ + { \ + if (curthr) \ + RT_SCHED_CTX(curthr).critical_lock_nest++; \ } while (0) -#define SCHEDULER_EXIT_CRITICAL(curthr) \ - do \ - { \ - if (curthr) RT_SCHED_CTX(curthr).critical_lock_nest--; \ +#define SCHEDULER_EXIT_CRITICAL(curthr) \ + do \ + { \ + if (curthr) \ + RT_SCHED_CTX(curthr).critical_lock_nest--; \ } while (0) #define SCHEDULER_CONTEXT_LOCK(percpu) \ @@ -202,7 +204,7 @@ rt_inline rt_base_t _get_global_highest_ready_prio(void) return highest_ready_priority; } -rt_inline rt_base_t _get_local_highest_ready_prio(struct rt_cpu* pcpu) +rt_inline rt_base_t _get_local_highest_ready_prio(struct rt_cpu *pcpu) { rt_ubase_t number; rt_ubase_t local_highest_ready_priority; @@ -226,7 +228,7 @@ rt_inline rt_base_t _get_global_highest_ready_prio(void) return __rt_ffs(rt_thread_ready_priority_group) - 1; } -rt_inline rt_base_t _get_local_highest_ready_prio(struct rt_cpu* pcpu) +rt_inline rt_base_t _get_local_highest_ready_prio(struct rt_cpu *pcpu) { return __rt_ffs(pcpu->priority_group) - 1; } @@ -236,11 +238,11 @@ rt_inline rt_base_t _get_local_highest_ready_prio(struct rt_cpu* pcpu) /* * get the highest priority thread in ready queue */ -static struct rt_thread* _scheduler_get_highest_priority_thread(rt_ubase_t *highest_prio) +static struct rt_thread *_scheduler_get_highest_priority_thread(rt_ubase_t *highest_prio) { struct rt_thread *highest_priority_thread; rt_ubase_t highest_ready_priority, local_highest_ready_priority; - struct rt_cpu* pcpu = rt_cpu_self(); + struct rt_cpu *pcpu = rt_cpu_self(); highest_ready_priority = _get_global_highest_ready_prio(); local_highest_ready_priority = _get_local_highest_ready_prio(pcpu); @@ -286,7 +288,7 @@ static void _sched_insert_thread_locked(struct rt_thread *thread) if ((RT_SCHED_CTX(thread).stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY) { /* already in ready queue */ - return ; + return; } else if (RT_SCHED_CTX(thread).oncpu != RT_CPU_DETACHED) { @@ -295,13 +297,13 @@ static void _sched_insert_thread_locked(struct rt_thread *thread) * this is a RUNNING thread. So here we reset it's status and let it go. */ RT_SCHED_CTX(thread).stat = RT_THREAD_RUNNING | (RT_SCHED_CTX(thread).stat & ~RT_THREAD_STAT_MASK); - return ; + return; } /* READY thread, insert to ready queue */ RT_SCHED_CTX(thread).stat = RT_THREAD_READY | (RT_SCHED_CTX(thread).stat & ~RT_THREAD_STAT_MASK); - cpu_id = rt_hw_cpu_id(); + cpu_id = rt_hw_cpu_id(); bind_cpu = RT_SCHED_CTX(thread).bind_cpu; /* insert thread to ready list */ @@ -313,7 +315,7 @@ static void _sched_insert_thread_locked(struct rt_thread *thread) rt_thread_ready_priority_group |= RT_SCHED_PRIV(thread).number_mask; /* there is no time slices left(YIELD), inserting thread before ready list*/ - if((RT_SCHED_CTX(thread).stat & RT_THREAD_STAT_YIELD_MASK) != 0) + if ((RT_SCHED_CTX(thread).stat & RT_THREAD_STAT_YIELD_MASK) != 0) { rt_list_insert_before(&(rt_thread_priority_table[RT_SCHED_PRIV(thread).current_priority]), &RT_THREAD_LIST_NODE(thread)); @@ -338,7 +340,7 @@ static void _sched_insert_thread_locked(struct rt_thread *thread) pcpu->priority_group |= RT_SCHED_PRIV(thread).number_mask; /* there is no time slices left(YIELD), inserting thread before ready list*/ - if((RT_SCHED_CTX(thread).stat & RT_THREAD_STAT_YIELD_MASK) != 0) + if ((RT_SCHED_CTX(thread).stat & RT_THREAD_STAT_YIELD_MASK) != 0) { rt_list_insert_before(&(rt_cpu_index(bind_cpu)->priority_table[RT_SCHED_PRIV(thread).current_priority]), &RT_THREAD_LIST_NODE(thread)); @@ -435,15 +437,15 @@ void rt_system_scheduler_init(void) rt_spin_lock_init(&_mp_scheduler_lock); - for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++) + for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset++) { rt_list_init(&rt_thread_priority_table[offset]); } for (cpu = 0; cpu < RT_CPUS_NR; cpu++) { - struct rt_cpu *pcpu = rt_cpu_index(cpu); - for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++) + struct rt_cpu *pcpu = rt_cpu_index(cpu); + for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset++) { rt_list_init(&pcpu->priority_table[offset]); } @@ -566,7 +568,9 @@ rt_err_t rt_sched_lock(rt_sched_lock_level_t *plvl) { rt_base_t level; if (!plvl) + { return -RT_EINVAL; + } SCHEDULER_LOCK(level); *plvl = level; @@ -642,8 +646,7 @@ static rt_thread_t _prepare_context_switch_locked(int cpu_id, if ((RT_SCHED_CTX(current_thread).stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING) { /* check if current thread can be running on current core again */ - if (RT_SCHED_CTX(current_thread).bind_cpu == RT_CPUS_NR - || RT_SCHED_CTX(current_thread).bind_cpu == cpu_id) + if (RT_SCHED_CTX(current_thread).bind_cpu == RT_CPUS_NR || RT_SCHED_CTX(current_thread).bind_cpu == cpu_id) { /* if current_thread is the highest runnable thread */ if (RT_SCHED_PRIV(current_thread).current_priority < highest_ready_priority) @@ -777,12 +780,12 @@ static void _sched_thread_process_signal(struct rt_thread *current_thread) /* lock is released above */ } -#define SCHED_THREAD_PREPROCESS_SIGNAL(pcpu, curthr) \ - do \ - { \ - SCHEDULER_CONTEXT_LOCK(pcpu); \ - _sched_thread_preprocess_signal(curthr); \ - SCHEDULER_CONTEXT_UNLOCK(pcpu); \ +#define SCHED_THREAD_PREPROCESS_SIGNAL(pcpu, curthr) \ + do \ + { \ + SCHEDULER_CONTEXT_LOCK(pcpu); \ + _sched_thread_preprocess_signal(curthr); \ + SCHEDULER_CONTEXT_UNLOCK(pcpu); \ } while (0) #define SCHED_THREAD_PREPROCESS_SIGNAL_LOCKED(curthr) \ _sched_thread_preprocess_signal(curthr) @@ -822,12 +825,12 @@ rt_err_t rt_sched_unlock_n_resched(rt_sched_lock_level_t level) { struct rt_thread *to_thread; struct rt_thread *current_thread; - struct rt_cpu *pcpu; - int cpu_id; - rt_err_t error = RT_EOK; + struct rt_cpu *pcpu; + int cpu_id; + rt_err_t error = RT_EOK; cpu_id = rt_hw_cpu_id(); - pcpu = rt_cpu_index(cpu_id); + pcpu = rt_cpu_index(cpu_id); current_thread = pcpu->current_thread; if (!current_thread) @@ -923,15 +926,15 @@ void rt_schedule(void) rt_base_t level; struct rt_thread *to_thread; struct rt_thread *current_thread; - struct rt_cpu *pcpu; - int cpu_id; + struct rt_cpu *pcpu; + int cpu_id; /* enter ciritical region of percpu scheduling context */ level = rt_hw_local_irq_disable(); /* get percpu scheduling context */ cpu_id = rt_hw_cpu_id(); - pcpu = rt_cpu_index(cpu_id); + pcpu = rt_cpu_index(cpu_id); current_thread = pcpu->current_thread; /* whether do switch in interrupt */ @@ -939,7 +942,7 @@ void rt_schedule(void) { pcpu->irq_switch_flag = 1; rt_hw_local_irq_enable(level); - return ; /* -RT_ESCHEDISR */ + return; /* -RT_ESCHEDISR */ } /* forbid any recursive entries of schedule() */ @@ -1015,16 +1018,16 @@ void rt_schedule(void) */ void rt_scheduler_do_irq_switch(void *context) { - int cpu_id; - rt_base_t level; - struct rt_cpu *pcpu; + int cpu_id; + rt_base_t level; + struct rt_cpu *pcpu; struct rt_thread *to_thread; struct rt_thread *current_thread; level = rt_hw_local_irq_disable(); cpu_id = rt_hw_cpu_id(); - pcpu = rt_cpu_index(cpu_id); + pcpu = rt_cpu_index(cpu_id); current_thread = pcpu->current_thread; /* forbid any recursive entries of schedule() */ @@ -1147,7 +1150,7 @@ void rt_sched_thread_init_priv(struct rt_thread *thread, rt_uint32_t tick, rt_ui /* priority init */ RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX); - RT_SCHED_PRIV(thread).init_priority = priority; + RT_SCHED_PRIV(thread).init_priority = priority; RT_SCHED_PRIV(thread).current_priority = priority; /* don't add to scheduler queue as init thread */ @@ -1166,7 +1169,6 @@ void rt_sched_thread_init_priv(struct rt_thread *thread, rt_uint32_t tick, rt_ui /* lock init */ RT_SCHED_CTX(thread).critical_lock_nest = 0; #endif /* RT_USING_SMP */ - } /** @@ -1190,9 +1192,9 @@ void rt_sched_thread_init_priv(struct rt_thread *thread, rt_uint32_t tick, rt_ui void rt_sched_thread_startup(struct rt_thread *thread) { #if RT_THREAD_PRIORITY_MAX > 32 - RT_SCHED_PRIV(thread).number = RT_SCHED_PRIV(thread).current_priority >> 3; /* 5bit */ + RT_SCHED_PRIV(thread).number = RT_SCHED_PRIV(thread).current_priority >> 3; /* 5bit */ RT_SCHED_PRIV(thread).number_mask = 1L << RT_SCHED_PRIV(thread).number; - RT_SCHED_PRIV(thread).high_mask = 1L << (RT_SCHED_PRIV(thread).current_priority & 0x07); /* 3bit */ + RT_SCHED_PRIV(thread).high_mask = 1L << (RT_SCHED_PRIV(thread).current_priority & 0x07); /* 3bit */ #else RT_SCHED_PRIV(thread).number_mask = 1L << RT_SCHED_PRIV(thread).current_priority; #endif /* RT_THREAD_PRIORITY_MAX > 32 */ @@ -1220,7 +1222,7 @@ void rt_sched_thread_startup(struct rt_thread *thread) */ void rt_sched_post_ctx_switch(struct rt_thread *thread) { - struct rt_cpu* pcpu = rt_cpu_self(); + struct rt_cpu *pcpu = rt_cpu_self(); rt_thread_t from_thread = pcpu->current_thread; RT_ASSERT(rt_hw_interrupt_is_disabled()); @@ -1269,13 +1271,13 @@ void rt_exit_critical_safe(rt_base_t critical_level) int dummy = 1; _critical_error_occurred = 1; - rt_kprintf("%s: un-compatible critical level\n" \ + rt_kprintf("%s: un-compatible critical level\n" "\tCurrent %d\n\tCaller %d\n", __func__, RT_SCHED_CTX(current_thread).critical_lock_nest, critical_level); rt_backtrace(); - while (dummy) ; + while (dummy); } } rt_exit_critical(); @@ -1427,7 +1429,9 @@ void rt_exit_critical(void) FREE_THREAD_SELF(level); if (need_resched) + { rt_schedule(); + } } else { diff --git a/src/scheduler_up.c b/src/scheduler_up.c index 8560166fd1..5b45c7743b 100644 --- a/src/scheduler_up.c +++ b/src/scheduler_up.c @@ -39,8 +39,8 @@ #include <rtthread.h> #include <rthw.h> -#define DBG_TAG "kernel.scheduler" -#define DBG_LVL DBG_INFO +#define DBG_TAG "kernel.scheduler" +#define DBG_LVL DBG_INFO #include <rtdbg.h> rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX]; @@ -101,7 +101,7 @@ void rt_scheduler_switch_sethook(void (*hook)(struct rt_thread *tid)) * @{ */ -static struct rt_thread* _scheduler_get_highest_priority_thread(rt_ubase_t *highest_prio) +static struct rt_thread *_scheduler_get_highest_priority_thread(rt_ubase_t *highest_prio) { struct rt_thread *highest_priority_thread; rt_ubase_t highest_ready_priority; @@ -144,7 +144,9 @@ rt_err_t rt_sched_lock(rt_sched_lock_level_t *plvl) { rt_base_t level; if (!plvl) + { return -RT_EINVAL; + } level = rt_hw_interrupt_disable(); *plvl = level; @@ -215,7 +217,7 @@ void rt_system_scheduler_init(void) LOG_D("start scheduler: max priority 0x%02x", RT_THREAD_PRIORITY_MAX); - for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++) + for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset++) { rt_list_init(&rt_thread_priority_table[offset]); } @@ -310,8 +312,7 @@ void rt_schedule(void) { to_thread = curr_thread; } - else if (RT_SCHED_PRIV(curr_thread).current_priority == highest_ready_priority - && (RT_SCHED_CTX(curr_thread).stat & RT_THREAD_STAT_YIELD_MASK) == 0) + else if (RT_SCHED_PRIV(curr_thread).current_priority == highest_ready_priority && (RT_SCHED_CTX(curr_thread).stat & RT_THREAD_STAT_YIELD_MASK) == 0) { to_thread = curr_thread; } @@ -325,7 +326,7 @@ void rt_schedule(void) { /* if the destination thread is not the same as current thread */ rt_current_priority = (rt_uint8_t)highest_ready_priority; - from_thread = curr_thread; + from_thread = curr_thread; rt_cpu_self()->current_thread = to_thread; RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (from_thread, to_thread)); @@ -346,11 +347,11 @@ void rt_schedule(void) /* switch to new thread */ interrupt_nest = rt_interrupt_get_nest(); LOG_D("[%d]switch to priority#%d " - "thread:%.*s(sp:0x%08x), " - "from thread:%.*s(sp: 0x%08x)", - interrupt_nest, highest_ready_priority, - RT_NAME_MAX, to_thread->parent.name, to_thread->sp, - RT_NAME_MAX, from_thread->parent.name, from_thread->sp); + "thread:%.*s(sp:0x%08x), " + "from thread:%.*s(sp: 0x%08x)", + interrupt_nest, highest_ready_priority, + RT_NAME_MAX, to_thread->parent.name, to_thread->sp, + RT_NAME_MAX, from_thread->parent.name, from_thread->sp); RT_SCHEDULER_STACK_CHECK(to_thread); @@ -361,7 +362,7 @@ void rt_schedule(void) RT_OBJECT_HOOK_CALL(rt_scheduler_switch_hook, (from_thread)); rt_hw_context_switch((rt_uintptr_t)&from_thread->sp, - (rt_uintptr_t)&to_thread->sp); + (rt_uintptr_t)&to_thread->sp); /* enable interrupt */ rt_hw_interrupt_enable(level); @@ -392,7 +393,7 @@ void rt_schedule(void) LOG_D("switch in interrupt"); rt_hw_context_switch_interrupt((rt_uintptr_t)&from_thread->sp, - (rt_uintptr_t)&to_thread->sp, from_thread, to_thread); + (rt_uintptr_t)&to_thread->sp, from_thread, to_thread); } } else @@ -435,9 +436,9 @@ __exit: void rt_sched_thread_startup(struct rt_thread *thread) { #if RT_THREAD_PRIORITY_MAX > 32 - RT_SCHED_PRIV(thread).number = RT_SCHED_PRIV(thread).current_priority >> 3; /* 5bit */ + RT_SCHED_PRIV(thread).number = RT_SCHED_PRIV(thread).current_priority >> 3; /* 5bit */ RT_SCHED_PRIV(thread).number_mask = 1L << RT_SCHED_PRIV(thread).number; - RT_SCHED_PRIV(thread).high_mask = 1L << (RT_SCHED_PRIV(thread).current_priority & 0x07); /* 3bit */ + RT_SCHED_PRIV(thread).high_mask = 1L << (RT_SCHED_PRIV(thread).current_priority & 0x07); /* 3bit */ #else RT_SCHED_PRIV(thread).number_mask = 1L << RT_SCHED_PRIV(thread).current_priority; #endif /* RT_THREAD_PRIORITY_MAX > 32 */ @@ -465,7 +466,7 @@ void rt_sched_thread_init_priv(struct rt_thread *thread, rt_uint32_t tick, rt_ui /* priority init */ RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX); - RT_SCHED_PRIV(thread).init_priority = priority; + RT_SCHED_PRIV(thread).init_priority = priority; RT_SCHED_PRIV(thread).current_priority = priority; /* don't add to scheduler queue as init thread */ @@ -507,7 +508,7 @@ void rt_sched_insert_thread(struct rt_thread *thread) /* READY thread, insert to ready queue */ RT_SCHED_CTX(thread).stat = RT_THREAD_READY | (RT_SCHED_CTX(thread).stat & ~RT_THREAD_STAT_MASK); /* there is no time slices left(YIELD), inserting thread before ready list*/ - if((RT_SCHED_CTX(thread).stat & RT_THREAD_STAT_YIELD_MASK) != 0) + if ((RT_SCHED_CTX(thread).stat & RT_THREAD_STAT_YIELD_MASK) != 0) { rt_list_insert_before(&(rt_thread_priority_table[RT_SCHED_PRIV(thread).current_priority]), &RT_THREAD_LIST_NODE(thread)); @@ -516,7 +517,7 @@ void rt_sched_insert_thread(struct rt_thread *thread) else { rt_list_insert_after(&(rt_thread_priority_table[RT_SCHED_PRIV(thread).current_priority]), - &RT_THREAD_LIST_NODE(thread)); + &RT_THREAD_LIST_NODE(thread)); } LOG_D("insert thread[%.*s], the priority: %d", @@ -605,13 +606,13 @@ void rt_exit_critical_safe(rt_base_t critical_level) int dummy = 1; _critical_error_occurred = 1; - rt_kprintf("%s: un-compatible critical level\n" \ + rt_kprintf("%s: un-compatible critical level\n" "\tCurrent %d\n\tCaller %d\n", __func__, rt_scheduler_lock_nest, critical_level); rt_backtrace(); - while (dummy) ; + while (dummy); } } rt_hw_interrupt_enable(level); @@ -635,7 +636,7 @@ void rt_exit_critical_safe(rt_base_t critical_level) rt_exit_critical(); } -#endif/* RT_DEBUGING_CRITICAL */ +#endif /* RT_DEBUGING_CRITICAL */ RTM_EXPORT(rt_exit_critical_safe); /** @@ -686,7 +687,7 @@ void rt_exit_critical(void) /* disable interrupt */ level = rt_hw_interrupt_disable(); - rt_scheduler_lock_nest --; + rt_scheduler_lock_nest--; if (rt_scheduler_lock_nest <= 0) { rt_scheduler_lock_nest = 0; diff --git a/src/signal.c b/src/signal.c index ea3b283c8a..30736372a7 100644 --- a/src/signal.c +++ b/src/signal.c @@ -19,23 +19,23 @@ #ifdef RT_USING_SIGNALS #ifndef RT_SIG_INFO_MAX - #ifdef ARCH_CPU_64BIT - #define RT_SIG_INFO_MAX 64 - #else - #define RT_SIG_INFO_MAX 32 - #endif /* ARCH_CPU_64BIT */ +#ifdef ARCH_CPU_64BIT +#define RT_SIG_INFO_MAX 64 +#else +#define RT_SIG_INFO_MAX 32 +#endif /* ARCH_CPU_64BIT */ #endif /* RT_SIG_INFO_MAX */ -#define DBG_TAG "SIGN" -#define DBG_LVL DBG_WARNING +#define DBG_TAG "SIGN" +#define DBG_LVL DBG_WARNING #include <rtdbg.h> #ifdef RT_USING_MUSLLIBC - #define sig_mask(sig_no) (1u << (sig_no - 1)) +#define sig_mask(sig_no) (1u << (sig_no - 1)) #else - #define sig_mask(sig_no) (1u << sig_no) +#define sig_mask(sig_no) (1u << sig_no) #endif -#define sig_valid(sig_no) (sig_no >= 0 && sig_no < RT_SIG_MAX) +#define sig_valid(sig_no) (sig_no >= 0 && sig_no < RT_SIG_MAX) static struct rt_spinlock _thread_signal_lock = RT_SPINLOCK_INIT; @@ -53,7 +53,7 @@ static void _signal_default_handler(int signo) { RT_UNUSED(signo); LOG_I("handled signo[%d] with default action.", signo); - return ; + return; } static void _signal_entry(void *parameter) @@ -78,7 +78,7 @@ static void _signal_entry(void *parameter) #ifdef RT_USING_SMP rt_hw_context_switch_to((rt_uintptr_t)¶meter, tid); #else - rt_hw_context_switch_to((rt_uintptr_t)&(tid->sp)); + rt_hw_context_switch_to((rt_uintptr_t) & (tid->sp)); #endif /* RT_USING_SMP */ } @@ -176,17 +176,17 @@ static void _signal_deliver(rt_thread_t tid) } #ifdef RT_USING_SMP -void *rt_signal_check(void* context) +void *rt_signal_check(void *context) { rt_sched_lock_level_t level; int cpu_id; - struct rt_cpu* pcpu; + struct rt_cpu *pcpu; struct rt_thread *current_thread; level = rt_spin_lock_irqsave(&_thread_signal_lock); cpu_id = rt_cpu_get_id(); - pcpu = rt_cpu_index(cpu_id); + pcpu = rt_cpu_index(cpu_id); current_thread = pcpu->current_thread; if (pcpu->irq_nest) @@ -205,7 +205,7 @@ void *rt_signal_check(void* context) rt_spin_unlock_irqrestore(&_thread_signal_lock, level); sig_context = rt_hw_stack_init((void *)_signal_entry, context, - (void*)((char*)context - 32), RT_NULL); + (void *)((char *)context - 32), RT_NULL); return sig_context; } } @@ -236,7 +236,10 @@ rt_sighandler_t rt_signal_install(int signo, rt_sighandler_t handler) rt_sighandler_t old = RT_NULL; rt_thread_t tid = rt_thread_self(); - if (!sig_valid(signo)) return SIG_ERR; + if (!sig_valid(signo)) + { + return SIG_ERR; + } level = rt_spin_lock_irqsave(&_thread_signal_lock); if (tid->sig_vectors == RT_NULL) @@ -252,9 +255,18 @@ rt_sighandler_t rt_signal_install(int signo, rt_sighandler_t handler) { old = tid->sig_vectors[signo]; - if (handler == SIG_IGN) tid->sig_vectors[signo] = RT_NULL; - else if (handler == SIG_DFL) tid->sig_vectors[signo] = _signal_default_handler; - else tid->sig_vectors[signo] = handler; + if (handler == SIG_IGN) + { + tid->sig_vectors[signo] = RT_NULL; + } + else if (handler == SIG_DFL) + { + tid->sig_vectors[signo] = _signal_default_handler; + } + else + { + tid->sig_vectors[signo] = handler; + } } rt_spin_unlock_irqrestore(&_thread_signal_lock, level); @@ -341,7 +353,7 @@ int rt_signal_wait(const rt_sigset_t *set, rt_siginfo_t *si, rt_int32_t timeout) RT_DEBUG_IN_THREAD_CONTEXT; /* parameters check */ - if (set == NULL || *set == 0 || si == NULL ) + if (set == NULL || *set == 0 || si == NULL) { ret = -RT_EINVAL; goto __done_return; @@ -353,7 +365,10 @@ int rt_signal_wait(const rt_sigset_t *set, rt_siginfo_t *si, rt_int32_t timeout) level = rt_spin_lock_irqsave(&_thread_signal_lock); /* already pending */ - if (tid->sig_pending & *set) goto __done; + if (tid->sig_pending & *set) + { + goto __done; + } if (timeout == 0) { @@ -407,10 +422,13 @@ __done: signo = si_node->si.si_signo; if (sig_mask(signo) & *set) { - *si = si_node->si; + *si = si_node->si; LOG_D("sigwait: %d sig raised!", signo); - if (si_prev) si_prev->list.next = si_node->list.next; + if (si_prev) + { + si_prev->list.next = si_node->list.next; + } else { struct siginfo_node *node_next; @@ -441,7 +459,7 @@ __done: { si_node = RT_NULL; } - } + } __done_int: rt_spin_unlock_irqrestore(&_thread_signal_lock, level); @@ -469,21 +487,31 @@ void rt_thread_handle_sig(rt_bool_t clean_state) rt_sighandler_t handler; si_node = (struct siginfo_node *)tid->si_list; - if (!si_node) break; + if (!si_node) + { + break; + } /* remove this sig info node from list */ if (si_node->list.next == RT_NULL) + { tid->si_list = RT_NULL; + } else + { tid->si_list = (void *)rt_slist_entry(si_node->list.next, struct siginfo_node, list); + } - signo = si_node->si.si_signo; + signo = si_node->si.si_signo; handler = tid->sig_vectors[signo]; tid->sig_pending &= ~sig_mask(signo); rt_spin_unlock_irqrestore(&_thread_signal_lock, level); LOG_D("handle signal: %d, handler 0x%08x", signo, handler); - if (handler) handler(signo); + if (handler) + { + handler(signo); + } level = rt_spin_lock_irqsave(&_thread_signal_lock); error = -RT_EINTR; @@ -518,7 +546,7 @@ void rt_thread_alloc_sig(rt_thread_t tid) vectors = (rt_sighandler_t *)RT_KERNEL_MALLOC(sizeof(rt_sighandler_t) * RT_SIG_MAX); RT_ASSERT(vectors != RT_NULL); - for (index = 0; index < RT_SIG_MAX; index ++) + for (index = 0; index < RT_SIG_MAX; index++) { vectors[index] = _signal_default_handler; } @@ -597,11 +625,14 @@ int rt_thread_kill(rt_thread_t tid, int sig) struct siginfo_node *si_node; RT_ASSERT(tid != RT_NULL); - if (!sig_valid(sig)) return -RT_EINVAL; + if (!sig_valid(sig)) + { + return -RT_EINVAL; + } LOG_I("send signal: %d", sig); si.si_signo = sig; - si.si_code = SI_USER; + si.si_code = SI_USER; si.si_value.sival_ptr = RT_NULL; level = rt_spin_lock_irqsave(&_thread_signal_lock); @@ -609,13 +640,17 @@ int rt_thread_kill(rt_thread_t tid, int sig) { /* whether already emits this signal? */ struct rt_slist_node *node; - struct siginfo_node *entry; + struct siginfo_node *entry; si_node = (struct siginfo_node *)tid->si_list; if (si_node) + { node = (struct rt_slist_node *)&si_node->list; + } else + { node = RT_NULL; + } /* update sig info */ for (; (node) != RT_NULL; node = node->next) @@ -631,7 +666,7 @@ int rt_thread_kill(rt_thread_t tid, int sig) } rt_spin_unlock_irqrestore(&_thread_signal_lock, level); - si_node = (struct siginfo_node *) rt_mp_alloc(_siginfo_pool, 0); + si_node = (struct siginfo_node *)rt_mp_alloc(_siginfo_pool, 0); if (si_node) { rt_slist_init(&(si_node->list)); diff --git a/src/slab.c b/src/slab.c index 115baf9557..c48247f026 100644 --- a/src/slab.c +++ b/src/slab.c @@ -57,8 +57,8 @@ #ifdef RT_USING_SLAB -#define DBG_TAG "kernel.slab" -#define DBG_LVL DBG_INFO +#define DBG_TAG "kernel.slab" +#define DBG_LVL DBG_INFO #include <rtdbg.h> /* @@ -115,27 +115,27 @@ * + ability to allocate arbitrarily large chunks of memory */ -#define ZALLOC_SLAB_MAGIC 0x51ab51ab -#define ZALLOC_ZONE_LIMIT (16 * 1024) /* max slab-managed alloc */ -#define ZALLOC_MIN_ZONE_SIZE (32 * 1024) /* minimum zone size */ -#define ZALLOC_MAX_ZONE_SIZE (128 * 1024) /* maximum zone size */ -#define ZONE_RELEASE_THRESH 2 /* threshold number of zones */ +#define ZALLOC_SLAB_MAGIC 0x51ab51ab +#define ZALLOC_ZONE_LIMIT (16 * 1024) /* max slab-managed alloc */ +#define ZALLOC_MIN_ZONE_SIZE (32 * 1024) /* minimum zone size */ +#define ZALLOC_MAX_ZONE_SIZE (128 * 1024) /* maximum zone size */ +#define ZONE_RELEASE_THRESH 2 /* threshold number of zones */ /* * Misc constants. Note that allocations that are exact multiples of * RT_MM_PAGE_SIZE, or exceed the zone limit, fall through to the kmem module. */ -#define MIN_CHUNK_SIZE 8 /* in bytes */ -#define MIN_CHUNK_MASK (MIN_CHUNK_SIZE - 1) +#define MIN_CHUNK_SIZE 8 /* in bytes */ +#define MIN_CHUNK_MASK (MIN_CHUNK_SIZE - 1) /* * Array of descriptors that describe the contents of each page */ -#define PAGE_TYPE_FREE 0x00 -#define PAGE_TYPE_SMALL 0x01 -#define PAGE_TYPE_LARGE 0x02 +#define PAGE_TYPE_FREE 0x00 +#define PAGE_TYPE_SMALL 0x01 +#define PAGE_TYPE_LARGE 0x02 -#define btokup(addr) \ +#define btokup(addr) \ (&slab->memusage[((rt_uintptr_t)(addr) - slab->heap_start) >> RT_MM_PAGE_BITS]) /** @@ -147,17 +147,17 @@ */ struct rt_slab_zone { - rt_uint32_t z_magic; /**< magic number for sanity check */ - rt_uint32_t z_nfree; /**< total free chunks / ualloc space in zone */ - rt_uint32_t z_nmax; /**< maximum free chunks */ - struct rt_slab_zone *z_next; /**< zoneary[] link if z_nfree non-zero */ - rt_uint8_t *z_baseptr; /**< pointer to start of chunk array */ + rt_uint32_t z_magic; /**< magic number for sanity check */ + rt_uint32_t z_nfree; /**< total free chunks / ualloc space in zone */ + rt_uint32_t z_nmax; /**< maximum free chunks */ + struct rt_slab_zone *z_next; /**< zoneary[] link if z_nfree non-zero */ + rt_uint8_t *z_baseptr; /**< pointer to start of chunk array */ - rt_uint32_t z_uindex; /**< current initial allocation index */ - rt_uint32_t z_chunksize; /**< chunk size for validation */ + rt_uint32_t z_uindex; /**< current initial allocation index */ + rt_uint32_t z_chunksize; /**< chunk size for validation */ - rt_uint32_t z_zoneindex; /**< zone index */ - struct rt_slab_chunk *z_freechunk; /**< free chunk list */ + rt_uint32_t z_zoneindex; /**< zone index */ + struct rt_slab_chunk *z_freechunk; /**< free chunk list */ }; /* @@ -170,8 +170,8 @@ struct rt_slab_chunk struct rt_slab_memusage { - rt_uint32_t type: 2 ; /**< page type */ - rt_uint32_t size: 30; /**< pages allocated or offset from zone */ + rt_uint32_t type : 2; /**< page type */ + rt_uint32_t size : 30; /**< pages allocated or offset from zone */ }; /* @@ -179,31 +179,31 @@ struct rt_slab_memusage */ struct rt_slab_page { - struct rt_slab_page *next; /**< next valid page */ - rt_size_t page; /**< number of page */ + struct rt_slab_page *next; /**< next valid page */ + rt_size_t page; /**< number of page */ /* dummy */ char dummy[RT_MM_PAGE_SIZE - (sizeof(struct rt_slab_page *) + sizeof(rt_size_t))]; }; -#define RT_SLAB_NZONES 72 /* number of zones */ +#define RT_SLAB_NZONES 72 /* number of zones */ /* * slab object */ struct rt_slab { - struct rt_memory parent; /**< inherit from rt_memory */ - rt_uintptr_t heap_start; /**< memory start address */ - rt_uintptr_t heap_end; /**< memory end address */ - struct rt_slab_memusage *memusage; - struct rt_slab_zone *zone_array[RT_SLAB_NZONES]; /* linked list of zones NFree > 0 */ - struct rt_slab_zone *zone_free; /* whole zones that have become free */ - rt_uint32_t zone_free_cnt; - rt_uint32_t zone_size; - rt_uint32_t zone_limit; - rt_uint32_t zone_page_cnt; - struct rt_slab_page *page_list; + struct rt_memory parent; /**< inherit from rt_memory */ + rt_uintptr_t heap_start; /**< memory start address */ + rt_uintptr_t heap_end; /**< memory end address */ + struct rt_slab_memusage *memusage; + struct rt_slab_zone *zone_array[RT_SLAB_NZONES]; /* linked list of zones NFree > 0 */ + struct rt_slab_zone *zone_free; /* whole zones that have become free */ + rt_uint32_t zone_free_cnt; + rt_uint32_t zone_size; + rt_uint32_t zone_limit; + rt_uint32_t zone_page_cnt; + struct rt_slab_page *page_list; }; /** @@ -220,17 +220,19 @@ void *rt_slab_page_alloc(rt_slab_t m, rt_size_t npages) struct rt_slab *slab = (struct rt_slab *)m; if (npages == 0) + { return RT_NULL; + } for (prev = &slab->page_list; (b = *prev) != RT_NULL; prev = &(b->next)) { if (b->page > npages) { /* splite pages */ - n = b + npages; + n = b + npages; n->next = b->next; n->page = b->page - npages; - *prev = n; + *prev = n; break; } @@ -276,7 +278,7 @@ void rt_slab_page_free(rt_slab_t m, void *addr, rt_size_t npages) if (b + (b->page += npages) == b->next) { b->page += b->next->page; - b->next = b->next->next; + b->next = b->next->next; } return; } @@ -285,17 +287,19 @@ void rt_slab_page_free(rt_slab_t m, void *addr, rt_size_t npages) { n->page = b->page + npages; n->next = b->next; - *prev = n; + *prev = n; return; } if (b > n + npages) + { break; + } } n->page = npages; n->next = b; - *prev = n; + *prev = n; } /* @@ -331,7 +335,7 @@ rt_slab_t rt_slab_init(const char *name, void *begin_addr, rt_size_t size) start_addr = (rt_uintptr_t)slab + sizeof(*slab); /* align begin and end addr to page */ begin_align = RT_ALIGN((rt_uintptr_t)start_addr, RT_MM_PAGE_SIZE); - end_align = RT_ALIGN_DOWN((rt_uintptr_t)begin_addr + size, RT_MM_PAGE_SIZE); + end_align = RT_ALIGN_DOWN((rt_uintptr_t)begin_addr + size, RT_MM_PAGE_SIZE); if (begin_align >= end_align) { rt_kprintf("slab init errr. wrong address[0x%x - 0x%x]\n", @@ -340,7 +344,7 @@ rt_slab_t rt_slab_init(const char *name, void *begin_addr, rt_size_t size) } limsize = end_align - begin_align; - npages = limsize / RT_MM_PAGE_SIZE; + npages = limsize / RT_MM_PAGE_SIZE; LOG_D("heap[0x%x - 0x%x], size 0x%x, 0x%x pages", begin_align, end_align, limsize, npages); @@ -361,11 +365,15 @@ rt_slab_t rt_slab_init(const char *name, void *begin_addr, rt_size_t size) /* calculate zone size */ slab->zone_size = ZALLOC_MIN_ZONE_SIZE; while (slab->zone_size < ZALLOC_MAX_ZONE_SIZE && (slab->zone_size << 1) < (limsize / 1024)) + { slab->zone_size <<= 1; + } slab->zone_limit = slab->zone_size / 4; if (slab->zone_limit > ZALLOC_ZONE_LIMIT) + { slab->zone_limit = ZALLOC_ZONE_LIMIT; + } slab->zone_page_cnt = slab->zone_size / RT_MM_PAGE_SIZE; @@ -373,8 +381,8 @@ rt_slab_t rt_slab_init(const char *name, void *begin_addr, rt_size_t size) slab->zone_size, slab->zone_page_cnt); /* allocate slab->memusage array */ - limsize = npages * sizeof(struct rt_slab_memusage); - limsize = RT_ALIGN(limsize, RT_MM_PAGE_SIZE); + limsize = npages * sizeof(struct rt_slab_memusage); + limsize = RT_ALIGN(limsize, RT_MM_PAGE_SIZE); slab->memusage = rt_slab_page_alloc((rt_slab_t)(&slab->parent), limsize / RT_MM_PAGE_SIZE); LOG_D("slab->memusage 0x%x, size 0x%x", @@ -497,7 +505,9 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size) /* zero size, return RT_NULL */ if (size == 0) + { return RT_NULL; + } /* * Handle large allocations directly. There should not be very many of @@ -509,7 +519,9 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size) chunk = rt_slab_page_alloc(m, size >> RT_MM_PAGE_BITS); if (chunk == RT_NULL) + { return RT_NULL; + } /* set kup */ kup = btokup(chunk); @@ -523,7 +535,9 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size) /* mem stat */ slab->parent.used += size; if (slab->parent.used > slab->parent.max) + { slab->parent.max = slab->parent.used; + } return chunk; } @@ -573,7 +587,9 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size) /* mem stats */ slab->parent.used += z->z_chunksize; if (slab->parent.used > slab->parent.max) + { slab->parent.max = slab->parent.used; + } return chunk; } @@ -593,7 +609,7 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size) { /* remove zone from free zone list */ slab->zone_free = z->z_next; - -- slab->zone_free_cnt; + --slab->zone_free_cnt; } else { @@ -608,12 +624,12 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size) (rt_uintptr_t)z); /* set message usage */ - for (off = 0, kup = btokup(z); off < slab->zone_page_cnt; off ++) + for (off = 0, kup = btokup(z); off < slab->zone_page_cnt; off++) { kup->type = PAGE_TYPE_SMALL; kup->size = off; - kup ++; + kup++; } } @@ -628,16 +644,20 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size) * Otherwise just 8-byte align the data. */ if ((size | (size - 1)) + 1 == (size << 1)) + { off = (off + size - 1) & ~(size - 1); + } else + { off = (off + MIN_CHUNK_MASK) & ~MIN_CHUNK_MASK; + } - z->z_magic = ZALLOC_SLAB_MAGIC; + z->z_magic = ZALLOC_SLAB_MAGIC; z->z_zoneindex = zi; - z->z_nmax = (slab->zone_size - off) / size; - z->z_nfree = z->z_nmax - 1; - z->z_baseptr = (rt_uint8_t *)z + off; - z->z_uindex = 0; + z->z_nmax = (slab->zone_size - off) / size; + z->z_nfree = z->z_nmax - 1; + z->z_baseptr = (rt_uint8_t *)z + off; + z->z_uindex = 0; z->z_chunksize = size; chunk = (struct rt_slab_chunk *)(z->z_baseptr + z->z_uindex * size); @@ -648,7 +668,9 @@ void *rt_slab_alloc(rt_slab_t m, rt_size_t size) /* mem stats */ slab->parent.used += z->z_chunksize; if (slab->parent.used > slab->parent.max) + { slab->parent.max = slab->parent.used; + } } return chunk; @@ -674,7 +696,9 @@ void *rt_slab_realloc(rt_slab_t m, void *ptr, rt_size_t size) struct rt_slab *slab = (struct rt_slab *)m; if (ptr == RT_NULL) + { return rt_slab_alloc(m, size); + } if (size == 0) { @@ -693,7 +717,9 @@ void *rt_slab_realloc(rt_slab_t m, void *ptr, rt_size_t size) osize = kup->size << RT_MM_PAGE_BITS; if ((nptr = rt_slab_alloc(m, size)) == RT_NULL) + { return RT_NULL; + } rt_memcpy(nptr, ptr, size > osize ? osize : size); rt_slab_free(m, ptr); @@ -702,12 +728,14 @@ void *rt_slab_realloc(rt_slab_t m, void *ptr, rt_size_t size) else if (kup->type == PAGE_TYPE_SMALL) { z = (struct rt_slab_zone *)(((rt_uintptr_t)ptr & ~RT_MM_PAGE_MASK) - - kup->size * RT_MM_PAGE_SIZE); + kup->size * RT_MM_PAGE_SIZE); RT_ASSERT(z->z_magic == ZALLOC_SLAB_MAGIC); zoneindex(&size); if (z->z_chunksize == size) + { return (ptr); /* same chunk */ + } /* * Allocate memory for the new request size. Note that zoneindex has @@ -715,7 +743,9 @@ void *rt_slab_realloc(rt_slab_t m, void *ptr, rt_size_t size) * should optimize our bcopy(). Then copy and return the new pointer. */ if ((nptr = rt_slab_alloc(m, size)) == RT_NULL) + { return RT_NULL; + } rt_memcpy(nptr, ptr, size > z->z_chunksize ? z->z_chunksize : size); rt_slab_free(m, ptr); @@ -744,7 +774,9 @@ void rt_slab_free(rt_slab_t m, void *ptr) /* free a RT_NULL pointer */ if (ptr == RT_NULL) - return ; + { + return; + } /* get memory usage */ #if (DBG_LVL == DBG_LOG) @@ -753,7 +785,7 @@ void rt_slab_free(rt_slab_t m, void *ptr) LOG_D("free a memory 0x%x and align to 0x%x, kup index %d", (rt_uintptr_t)ptr, (rt_uintptr_t)addr, - ((rt_uintptr_t)(addr) - slab->heap_start) >> RT_MM_PAGE_BITS); + ((rt_uintptr_t)(addr)-slab->heap_start) >> RT_MM_PAGE_BITS); } #endif /* DBG_LVL == DBG_LOG */ @@ -780,11 +812,11 @@ void rt_slab_free(rt_slab_t m, void *ptr) /* zone case. get out zone. */ z = (struct rt_slab_zone *)(((rt_uintptr_t)ptr & ~RT_MM_PAGE_MASK) - - kup->size * RT_MM_PAGE_SIZE); + kup->size * RT_MM_PAGE_SIZE); RT_ASSERT(z->z_magic == ZALLOC_SLAB_MAGIC); - chunk = (struct rt_slab_chunk *)ptr; - chunk->c_next = z->z_freechunk; + chunk = (struct rt_slab_chunk *)ptr; + chunk->c_next = z->z_freechunk; z->z_freechunk = chunk; /* mem stats */ slab->parent.used -= z->z_chunksize; @@ -814,8 +846,7 @@ void rt_slab_free(rt_slab_t m, void *ptr) (rt_uintptr_t)z, z->z_zoneindex); /* remove zone from zone array list */ - for (pz = &slab->zone_array[z->z_zoneindex]; z != *pz; pz = &(*pz)->z_next) - ; + for (pz = &slab->zone_array[z->z_zoneindex]; z != *pz; pz = &(*pz)->z_next); *pz = z->z_next; /* reset zone */ @@ -825,23 +856,23 @@ void rt_slab_free(rt_slab_t m, void *ptr) z->z_next = slab->zone_free; slab->zone_free = z; - ++ slab->zone_free_cnt; + ++slab->zone_free_cnt; /* release zone to page allocator */ if (slab->zone_free_cnt > ZONE_RELEASE_THRESH) { register rt_uint32_t i; - z = slab->zone_free; + z = slab->zone_free; slab->zone_free = z->z_next; - -- slab->zone_free_cnt; + --slab->zone_free_cnt; /* set message usage */ - for (i = 0, kup = btokup(z); i < slab->zone_page_cnt; i ++) + for (i = 0, kup = btokup(z); i < slab->zone_page_cnt; i++) { kup->type = PAGE_TYPE_FREE; kup->size = 0; - kup ++; + kup++; } /* release pages */ diff --git a/src/timer.c b/src/timer.c index 0ffd06edd4..88a377d75c 100644 --- a/src/timer.c +++ b/src/timer.c @@ -27,8 +27,8 @@ #include <rtthread.h> #include <rthw.h> -#define DBG_TAG "kernel.timer" -#define DBG_LVL DBG_INFO +#define DBG_TAG "kernel.timer" +#define DBG_LVL DBG_INFO #include <rtdbg.h> #ifndef RT_USING_TIMER_ALL_SOFT @@ -40,11 +40,11 @@ static struct rt_spinlock _htimer_lock; #ifdef RT_USING_TIMER_SOFT #ifndef RT_TIMER_THREAD_STACK_SIZE -#define RT_TIMER_THREAD_STACK_SIZE 512 +#define RT_TIMER_THREAD_STACK_SIZE 512 #endif /* RT_TIMER_THREAD_STACK_SIZE */ #ifndef RT_TIMER_THREAD_PRIO -#define RT_TIMER_THREAD_PRIO 0 +#define RT_TIMER_THREAD_PRIO 0 #endif /* RT_TIMER_THREAD_PRIO */ /* soft timer list */ @@ -52,8 +52,7 @@ static rt_list_t _soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL]; static struct rt_spinlock _stimer_lock; static struct rt_thread _timer_thread; static struct rt_semaphore _soft_timer_sem; -rt_align(RT_ALIGN_SIZE) -static rt_uint8_t _timer_thread_stack[RT_TIMER_THREAD_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static rt_uint8_t _timer_thread_stack[RT_TIMER_THREAD_STACK_SIZE]; #endif /* RT_USING_TIMER_SOFT */ #if defined(RT_USING_HOOK) && defined(RT_HOOK_USING_FUNC_PTR) @@ -93,7 +92,7 @@ void rt_timer_exit_sethook(void (*hook)(struct rt_timer *timer)) /**@}*/ #endif /* RT_USING_HOOK */ -rt_inline struct rt_spinlock* _timerlock_idx(struct rt_timer *timer) +rt_inline struct rt_spinlock *_timerlock_idx(struct rt_timer *timer) { #ifdef RT_USING_TIMER_ALL_SOFT return &_stimer_lock; @@ -130,27 +129,27 @@ rt_inline struct rt_spinlock* _timerlock_idx(struct rt_timer *timer) */ static void _timer_init(rt_timer_t timer, void (*timeout)(void *parameter), - void *parameter, - rt_tick_t time, + void *parameter, + rt_tick_t time, rt_uint8_t flag) { int i; #ifdef RT_USING_TIMER_ALL_SOFT - flag |= RT_TIMER_FLAG_SOFT_TIMER; + flag |= RT_TIMER_FLAG_SOFT_TIMER; #endif /* set flag */ - timer->parent.flag = flag; + timer->parent.flag = flag; /* set deactivated */ timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED; timer->timeout_func = timeout; - timer->parameter = parameter; + timer->parameter = parameter; timer->timeout_tick = 0; - timer->init_tick = time; + timer->init_tick = time; /* initialize timer list */ for (i = 0; i < RT_TIMER_SKIP_LIST_LEVEL; i++) @@ -213,7 +212,9 @@ static int _timer_count_height(struct rt_timer *timer) for (i = 0; i < RT_TIMER_SKIP_LIST_LEVEL; i++) { if (!rt_list_isempty(&timer->row[i])) + { cnt++; + } } return cnt; } @@ -264,12 +265,12 @@ void rt_timer_dump(rt_list_t timer_heads[]) * @param flag is the flag of timer * */ -void rt_timer_init(rt_timer_t timer, +void rt_timer_init(rt_timer_t timer, const char *name, void (*timeout)(void *parameter), - void *parameter, - rt_tick_t time, - rt_uint8_t flag) + void *parameter, + rt_tick_t time, + rt_uint8_t flag) { /* parameter check */ RT_ASSERT(timer != RT_NULL); @@ -344,9 +345,9 @@ RTM_EXPORT(rt_timer_detach); */ rt_timer_t rt_timer_create(const char *name, void (*timeout)(void *parameter), - void *parameter, - rt_tick_t time, - rt_uint8_t flag) + void *parameter, + rt_tick_t time, + rt_uint8_t flag) { struct rt_timer *timer; @@ -422,11 +423,11 @@ static rt_err_t _timer_start(rt_list_t *timer_list, rt_timer_t timer) timer->timeout_tick = rt_tick_get() + timer->init_tick; - row_head[0] = &timer_list[0]; + row_head[0] = &timer_list[0]; for (row_lvl = 0; row_lvl < RT_TIMER_SKIP_LIST_LEVEL; row_lvl++) { for (; row_head[row_lvl] != timer_list[row_lvl].prev; - row_head[row_lvl] = row_head[row_lvl]->next) + row_head[row_lvl] = row_head[row_lvl]->next) { struct rt_timer *t; rt_list_t *p = row_head[row_lvl]->next; @@ -449,7 +450,9 @@ static rt_err_t _timer_start(rt_list_t *timer_list, rt_timer_t timer) } } if (row_lvl != RT_TIMER_SKIP_LIST_LEVEL - 1) + { row_head[row_lvl + 1] = row_head[row_lvl] + 1; + } } /* Interestingly, this super simple timer insert counter works very very @@ -464,10 +467,14 @@ static rt_err_t _timer_start(rt_list_t *timer_list, rt_timer_t timer) for (row_lvl = 2; row_lvl <= RT_TIMER_SKIP_LIST_LEVEL; row_lvl++) { if (!(tst_nr & RT_TIMER_SKIP_LIST_MASK)) + { rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - row_lvl], &(timer->row[RT_TIMER_SKIP_LIST_LEVEL - row_lvl])); + } else + { break; + } /* Shift over the bits we have tested. Works well with 1 bit and 2 * bits. */ tst_nr >>= (RT_TIMER_SKIP_LIST_MASK + 1) >> 1; @@ -547,7 +554,10 @@ static void _timer_check(rt_list_t *timer_list, struct rt_spinlock *lock) _timer_start(timer_list, t); } } - else break; + else + { + break; + } } rt_spin_unlock_irqrestore(lock, level); } @@ -699,7 +709,7 @@ rt_err_t rt_timer_control(rt_timer_t timer, int cmd, void *arg) break; case RT_TIMER_CTRL_GET_STATE: - if(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED) + if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED) { /*timer is start and run*/ *(rt_uint32_t *)arg = RT_TIMER_FLAG_ACTIVATED; @@ -712,14 +722,14 @@ rt_err_t rt_timer_control(rt_timer_t timer, int cmd, void *arg) break; case RT_TIMER_CTRL_GET_REMAIN_TIME: - *(rt_tick_t *)arg = timer->timeout_tick; + *(rt_tick_t *)arg = timer->timeout_tick; break; case RT_TIMER_CTRL_GET_FUNC: *(void **)arg = (void *)timer->timeout_func; break; case RT_TIMER_CTRL_SET_FUNC: - timer->timeout_func = (void (*)(void*))arg; + timer->timeout_func = (void (*)(void *))arg; break; case RT_TIMER_CTRL_GET_PARM: @@ -852,7 +862,7 @@ void rt_system_timer_thread_init(void) } rt_spin_lock_init(&_stimer_lock); rt_sem_init(&_soft_timer_sem, "stimer", 0, RT_IPC_FLAG_PRIO); - rt_sem_control(&_soft_timer_sem, RT_IPC_CMD_SET_VLIMIT, (void*)1); + rt_sem_control(&_soft_timer_sem, RT_IPC_CMD_SET_VLIMIT, (void *)1); /* start software timer thread */ rt_thread_init(&_timer_thread, "timer", diff --git a/src/utest/atomic_tc.c b/src/utest/atomic_tc.c index ebf050fe0d..9336f79243 100644 --- a/src/utest/atomic_tc.c +++ b/src/utest/atomic_tc.c @@ -43,12 +43,12 @@ #include "rtatomic.h" #include <rthw.h> -#define THREAD_PRIORITY 25 -#define THREAD_TIMESLICE 1 -#define THREAD_STACKSIZE UTEST_THR_STACK_SIZE +#define THREAD_PRIORITY 25 +#define THREAD_TIMESLICE 1 +#define THREAD_STACKSIZE UTEST_THR_STACK_SIZE /* convenience macro - return either 64-bit or 32-bit value */ -#define ATOMIC_WORD(val_if_64, val_if_32) \ +#define ATOMIC_WORD(val_if_64, val_if_32) \ ((rt_atomic_t)((sizeof(void *) == sizeof(uint64_t)) ? (val_if_64) : (val_if_32))) static rt_atomic_t count = 0; diff --git a/src/utest/event_tc.c b/src/utest/event_tc.c index 248a3e7c11..7a8d619d3f 100644 --- a/src/utest/event_tc.c +++ b/src/utest/event_tc.c @@ -43,36 +43,32 @@ #include <stdlib.h> #define THREAD_STACKSIZE UTEST_THR_STACK_SIZE -#define EVENT_FLAG3 (1 << 3) -#define EVENT_FLAG5 (1 << 5) +#define EVENT_FLAG3 (1 << 3) +#define EVENT_FLAG5 (1 << 5) -static struct rt_event static_event = {0}; +static struct rt_event static_event = { 0 }; #ifdef RT_USING_HEAP static rt_event_t dynamic_event = RT_NULL; static rt_uint32_t dynamic_event_recv_thread_finish = 0, dynamic_event_send_thread_finish = 0; -rt_align(RT_ALIGN_SIZE) -static char thread3_stack[UTEST_THR_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static char thread3_stack[UTEST_THR_STACK_SIZE]; static struct rt_thread thread3; -rt_align(RT_ALIGN_SIZE) -static char thread4_stack[UTEST_THR_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static char thread4_stack[UTEST_THR_STACK_SIZE]; static struct rt_thread thread4; #endif /* RT_USING_HEAP */ static rt_uint32_t recv_event_times1 = 0, recv_event_times2 = 0; static rt_uint32_t static_event_recv_thread_finish = 0, static_event_send_thread_finish = 0; -rt_align(RT_ALIGN_SIZE) -static char thread1_stack[UTEST_THR_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static char thread1_stack[UTEST_THR_STACK_SIZE]; static struct rt_thread thread1; -rt_align(RT_ALIGN_SIZE) -static char thread2_stack[UTEST_THR_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static char thread2_stack[UTEST_THR_STACK_SIZE]; static struct rt_thread thread2; -#define THREAD_PRIORITY 9 -#define THREAD_TIMESLICE 5 +#define THREAD_PRIORITY 9 +#define THREAD_TIMESLICE 5 static void test_event_init(void) { @@ -161,13 +157,12 @@ static void thread2_send_static_event(void *param) static_event_send_thread_finish = 1; } - static void test_static_event_send_recv(void) { rt_err_t result = RT_EOK; - result = rt_event_init(&static_event, "event", RT_IPC_FLAG_PRIO); - if (result != RT_EOK) + result = rt_event_init(&static_event, "event", RT_IPC_FLAG_PRIO); + if (result != RT_EOK) { uassert_false(1); } diff --git a/src/utest/hooklist_tc.c b/src/utest/hooklist_tc.c index 76a73f72ea..c747678035 100644 --- a/src/utest/hooklist_tc.c +++ b/src/utest/hooklist_tc.c @@ -89,7 +89,7 @@ static rt_err_t cleanup_thr_tobe_inited(void) while (thr_tobe_inited_cleaned == RT_FALSE && timeout > 0) { rt_thread_mdelay(1); - timeout --; + timeout--; } if (thr_tobe_inited_cleaned == RT_FALSE) diff --git a/src/utest/irq_tc.c b/src/utest/irq_tc.c index 7a225dbf15..2a3c41d798 100644 --- a/src/utest/irq_tc.c +++ b/src/utest/irq_tc.c @@ -74,11 +74,11 @@ static volatile uint32_t max_get_nest_count = 0; static void irq_callback() { - if(rt_interrupt_get_nest() > max_get_nest_count) + if (rt_interrupt_get_nest() > max_get_nest_count) { max_get_nest_count = rt_interrupt_get_nest(); } - irq_count ++; + irq_count++; } static void irq_test(void) @@ -116,15 +116,14 @@ static void interrupt_test(void) rt_interrupt_leave_sethook(irq_callback); irq_count = 0; level = rt_hw_interrupt_disable(); - while(i) + while (i) { - i --; + i--; } uassert_int_equal(0, irq_count); rt_hw_interrupt_enable(level); rt_interrupt_enter_sethook(RT_NULL); rt_interrupt_leave_sethook(RT_NULL); - } static void testcase(void) { diff --git a/src/utest/mailbox_tc.c b/src/utest/mailbox_tc.c index 9c4a30af8e..b51ee6e515 100644 --- a/src/utest/mailbox_tc.c +++ b/src/utest/mailbox_tc.c @@ -60,16 +60,14 @@ static rt_mailbox_t test_dynamic_mb; static uint8_t static_mb_recv_thread_finish, static_mb_send_thread_finish; static uint8_t dynamic_mb_recv_thread_finish, dynamic_mb_send_thread_finish; -rt_align(RT_ALIGN_SIZE) -static char thread1_stack[UTEST_THR_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static char thread1_stack[UTEST_THR_STACK_SIZE]; static struct rt_thread thread1; -rt_align(RT_ALIGN_SIZE) -static char thread2_stack[UTEST_THR_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static char thread2_stack[UTEST_THR_STACK_SIZE]; static struct rt_thread thread2; -#define THREAD_PRIORITY 9 -#define THREAD_TIMESLICE 5 +#define THREAD_PRIORITY 9 +#define THREAD_TIMESLICE 5 static rt_thread_t mb_send = RT_NULL; static rt_thread_t mb_recv = RT_NULL; @@ -353,11 +351,11 @@ static void test_dynamic_mailbox_send_recv(void) } mb_recv = rt_thread_create("mb_recv_thread", - thread3_recv_dynamic_mb, - RT_NULL, - UTEST_THR_STACK_SIZE, - THREAD_PRIORITY - 1, - THREAD_TIMESLICE); + thread3_recv_dynamic_mb, + RT_NULL, + UTEST_THR_STACK_SIZE, + THREAD_PRIORITY - 1, + THREAD_TIMESLICE); if (mb_recv == RT_NULL) { uassert_false(1); @@ -365,11 +363,11 @@ static void test_dynamic_mailbox_send_recv(void) rt_thread_startup(mb_recv); mb_send = rt_thread_create("mb_send_thread", - thread4_send_dynamic_mb, - RT_NULL, - UTEST_THR_STACK_SIZE, - THREAD_PRIORITY - 1, - THREAD_TIMESLICE); + thread4_send_dynamic_mb, + RT_NULL, + UTEST_THR_STACK_SIZE, + THREAD_PRIORITY - 1, + THREAD_TIMESLICE); if (mb_send == RT_NULL) { uassert_false(1); diff --git a/src/utest/mem_tc.c b/src/utest/mem_tc.c index c10a1130de..1e7c92cea3 100644 --- a/src/utest/mem_tc.c +++ b/src/utest/mem_tc.c @@ -90,30 +90,29 @@ struct rt_small_mem_item { - rt_ubase_t pool_ptr; /**< small memory object addr */ - rt_size_t next; /**< next free item */ - rt_size_t prev; /**< prev free item */ + rt_ubase_t pool_ptr; /**< small memory object addr */ + rt_size_t next; /**< next free item */ + rt_size_t prev; /**< prev free item */ #ifdef RT_USING_MEMTRACE #ifdef ARCH_CPU_64BIT - rt_uint8_t thread[8]; /**< thread name */ + rt_uint8_t thread[8]; /**< thread name */ #else - rt_uint8_t thread[4]; /**< thread name */ + rt_uint8_t thread[4]; /**< thread name */ #endif /* ARCH_CPU_64BIT */ #endif /* RT_USING_MEMTRACE */ }; struct rt_small_mem { - struct rt_memory parent; /**< inherit from rt_memory */ - rt_uint8_t *heap_ptr; /**< pointer to the heap */ - struct rt_small_mem_item *heap_end; - struct rt_small_mem_item *lfree; - rt_size_t mem_size_aligned; /**< aligned memory size */ + struct rt_memory parent; /**< inherit from rt_memory */ + rt_uint8_t *heap_ptr; /**< pointer to the heap */ + struct rt_small_mem_item *heap_end; + struct rt_small_mem_item *lfree; + rt_size_t mem_size_aligned; /**< aligned memory size */ }; -#define MEM_SIZE(_heap, _mem) \ - (((struct rt_small_mem_item *)(_mem))->next - ((rt_ubase_t)(_mem) - \ - (rt_ubase_t)((_heap)->heap_ptr)) - RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE)) +#define MEM_SIZE(_heap, _mem) \ + (((struct rt_small_mem_item *)(_mem))->next - ((rt_ubase_t)(_mem) - (rt_ubase_t)((_heap)->heap_ptr)) - RT_ALIGN(sizeof(struct rt_small_mem_item), RT_ALIGN_SIZE)) #define TEST_MEM_SIZE 1024 @@ -143,7 +142,9 @@ static int _mem_cmp(void *ptr, rt_uint8_t v, rt_size_t size) while (size-- != 0) { if (*(rt_uint8_t *)ptr != v) + { return *(rt_uint8_t *)ptr - v; + } } return 0; } @@ -371,8 +372,8 @@ struct mem_alloc_head rt_tick_t interval; }; -#define MEM_RANG_ALLOC_BLK_MIN 2 -#define MEM_RANG_ALLOC_BLK_MAX 5 +#define MEM_RANG_ALLOC_BLK_MIN 2 +#define MEM_RANG_ALLOC_BLK_MAX 5 #define MEM_RANG_ALLOC_TEST_TIME 5 static void mem_alloc_test(void) @@ -393,7 +394,7 @@ static void mem_alloc_test(void) uassert_not_null(buf); uassert_int_equal(RT_ALIGN((rt_ubase_t)buf, RT_ALIGN_SIZE), (rt_ubase_t)buf); rt_memset(buf, 0xAA, TEST_MEM_SIZE); - heap = (struct rt_small_mem *)rt_smem_init("mem_tc", buf, TEST_MEM_SIZE); + heap = (struct rt_small_mem *)rt_smem_init("mem_tc", buf, TEST_MEM_SIZE); total_size = max_block(heap); uassert_int_not_equal(total_size, 0); /* test run */ @@ -430,7 +431,7 @@ static void mem_alloc_test(void) } rt_memset(ctx, 0xAA, ctx->size); rt_smem_free(ctx); - head.count --; + head.count--; } continue; } @@ -464,7 +465,7 @@ static void mem_alloc_test(void) } rt_memset(ctx, 0xAA, ctx->size); rt_smem_free(ctx); - head.count --; + head.count--; } } } @@ -481,7 +482,7 @@ static void mem_alloc_test(void) } rt_memset(ctx, 0xAA, ctx->size); rt_smem_free(ctx); - head.count --; + head.count--; } uassert_int_equal(head.count, 0); uassert_int_equal(max_block(heap), total_size); @@ -491,8 +492,8 @@ static void mem_alloc_test(void) rt_free(buf); } -#define MEM_RANG_REALLOC_BLK_MIN 0 -#define MEM_RANG_REALLOC_BLK_MAX 5 +#define MEM_RANG_REALLOC_BLK_MIN 0 +#define MEM_RANG_REALLOC_BLK_MAX 5 #define MEM_RANG_REALLOC_TEST_TIME 5 struct mem_realloc_context @@ -531,7 +532,7 @@ static void mem_realloc_test(void) uassert_not_null(buf); uassert_int_equal(RT_ALIGN((rt_ubase_t)buf, RT_ALIGN_SIZE), (rt_ubase_t)buf); rt_memset(buf, 0xAA, TEST_MEM_SIZE); - heap = (struct rt_small_mem *)rt_smem_init("mem_tc", buf, TEST_MEM_SIZE); + heap = (struct rt_small_mem *)rt_smem_init("mem_tc", buf, TEST_MEM_SIZE); total_size = max_block(heap); uassert_int_not_equal(total_size, 0); /* init ctx tab */ diff --git a/src/utest/memheap_tc.c b/src/utest/memheap_tc.c index cb78934270..20d8fe35cd 100644 --- a/src/utest/memheap_tc.c +++ b/src/utest/memheap_tc.c @@ -62,17 +62,17 @@ #include <stdlib.h> #include "utest.h" -#define HEAP_SIZE (64 * 1024) -#define HEAP_ALIGN (4) -#define SLICE_NUM (40) -#define TEST_TIMES (100000) -#define HEAP_NAME "heap1" -#define SLICE_SIZE_MAX (HEAP_SIZE/SLICE_NUM) +#define HEAP_SIZE (64 * 1024) +#define HEAP_ALIGN (4) +#define SLICE_NUM (40) +#define TEST_TIMES (100000) +#define HEAP_NAME "heap1" +#define SLICE_SIZE_MAX (HEAP_SIZE / SLICE_NUM) static void memheap_test(void) { struct rt_memheap heap1; - void * ptr_start; + void *ptr_start; void *ptr[SLICE_NUM]; int i, cnt = 0; @@ -116,7 +116,7 @@ static void memheap_test(void) ptr[ptr_index] = rt_memheap_realloc(&heap1, ptr[ptr_index], slice_size); } } - cnt ++; + cnt++; if (cnt % (TEST_TIMES / 10) == 0) { rt_kprintf(">"); diff --git a/src/utest/mempool_tc.c b/src/utest/mempool_tc.c index ca619731c1..8e5705904e 100644 --- a/src/utest/mempool_tc.c +++ b/src/utest/mempool_tc.c @@ -53,9 +53,9 @@ #define MEMPOOL_BLOCK_COUNT 32 #define MEMPOOL_SIZE (MEMPOOL_BLOCK_SIZE + sizeof(rt_uint8_t *)) * MEMPOOL_BLOCK_COUNT -static rt_uint8_t mempool_static[MEMPOOL_SIZE]; +static rt_uint8_t mempool_static[MEMPOOL_SIZE]; static struct rt_mempool mp_static; -static rt_mp_t mp_dynamic; +static rt_mp_t mp_dynamic; /* Static memory pool test */ static void test_mp_static_init(void) @@ -138,7 +138,7 @@ static void test_mp_boundary_alloc_exceed(void) { void *blocks[MEMPOOL_BLOCK_COUNT]; void *extra_block; - int i; + int i; /* Allocate all blocks */ for (i = 0; i < MEMPOOL_BLOCK_COUNT; i++) @@ -178,7 +178,7 @@ static void test_mp_boundary_free_invalid(void) static void test_mp_stress_alloc_free(void) { void *blocks[MEMPOOL_BLOCK_COUNT]; - int i, j; + int i, j; for (j = 0; j < 100; j++) /* Repeat 100 times */ { diff --git a/src/utest/messagequeue_tc.c b/src/utest/messagequeue_tc.c index df17705dbb..118ead210a 100644 --- a/src/utest/messagequeue_tc.c +++ b/src/utest/messagequeue_tc.c @@ -53,8 +53,8 @@ #define THREAD_STACKSIZE UTEST_THR_STACK_SIZE -#define MSG_SIZE 4 -#define MAX_MSGS 5 +#define MSG_SIZE 4 +#define MAX_MSGS 5 static struct rt_messagequeue static_mq; static rt_uint8_t mq_buf[RT_MQ_BUF_SIZE(MSG_SIZE, MAX_MSGS)]; @@ -65,8 +65,8 @@ static rt_uint8_t mq_send_stack[UTEST_THR_STACK_SIZE]; static rt_uint8_t mq_recv_stack[UTEST_THR_STACK_SIZE]; static struct rt_event finish_e; -#define MQSEND_FINISH 0x01 -#define MQRECV_FINIHS 0x02 +#define MQSEND_FINISH 0x01 +#define MQRECV_FINIHS 0x02 #ifdef RT_USING_HEAP static rt_mq_t dynamic_mq; @@ -75,7 +75,7 @@ static rt_mq_t dynamic_mq; static void test_mq_init(void) { rt_err_t ret; - ret = rt_mq_init(&static_mq,"testmq1", mq_buf, MSG_SIZE, sizeof(mq_buf), RT_IPC_FLAG_FIFO); + ret = rt_mq_init(&static_mq, "testmq1", mq_buf, MSG_SIZE, sizeof(mq_buf), RT_IPC_FLAG_FIFO); uassert_true(ret == RT_EOK); } @@ -89,7 +89,7 @@ static void test_mq_create(void) static void mq_send_case(rt_mq_t testmq) { - rt_uint32_t send_buf[MAX_MSGS+1] = {0}; + rt_uint32_t send_buf[MAX_MSGS + 1] = { 0 }; rt_err_t ret = RT_EOK; for (int var = 0; var < MAX_MSGS; ++var) @@ -155,7 +155,7 @@ static void mq_send_entry(void *param) mq_send_case(&static_mq); #ifdef RT_USING_HEAP - if(dynamic_mq != RT_NULL) + if (dynamic_mq != RT_NULL) { mq_send_case(dynamic_mq); } @@ -166,7 +166,7 @@ static void mq_send_entry(void *param) static void mq_recv_case(rt_mq_t testmq) { - rt_uint32_t recv_buf[MAX_MSGS+1] = {0}; + rt_uint32_t recv_buf[MAX_MSGS + 1] = { 0 }; rt_ssize_t ret = RT_EOK; for (int var = 0; var < MAX_MSGS + 1; ++var) @@ -203,7 +203,7 @@ static void mq_recv_entry(void *param) mq_recv_case(&static_mq); #ifdef RT_USING_HEAP - if(dynamic_mq != RT_NULL) + if (dynamic_mq != RT_NULL) { mq_recv_case(dynamic_mq); } @@ -235,14 +235,18 @@ static void test_mq_delete(void) static rt_err_t utest_tc_init(void) { - rt_err_t ret ; + rt_err_t ret; ret = rt_thread_init(&mq_send_thread, "mq_send", mq_send_entry, RT_NULL, mq_send_stack, sizeof(mq_send_stack), 22, 20); - if(ret != RT_EOK) + if (ret != RT_EOK) + { return -RT_ERROR; + } ret = rt_thread_init(&mq_recv_thread, "mq_recv", mq_recv_entry, RT_NULL, mq_recv_stack, sizeof(mq_recv_stack), 23, 20); - if(ret != RT_EOK) + if (ret != RT_EOK) + { return -RT_ERROR; + } #ifdef RT_USING_SMP rt_thread_control(&mq_send_thread, RT_THREAD_CTRL_BIND_CPU, (void *)0); @@ -250,8 +254,10 @@ static rt_err_t utest_tc_init(void) #endif ret = rt_event_init(&finish_e, "finish", RT_IPC_FLAG_FIFO); - if(ret != RT_EOK) - return -RT_ERROR; + if (ret != RT_EOK) + { + return -RT_ERROR; + } return RT_EOK; } diff --git a/src/utest/mutex_pi_tc.c b/src/utest/mutex_pi_tc.c index a854df7ce0..ce550f09bf 100644 --- a/src/utest/mutex_pi_tc.c +++ b/src/utest/mutex_pi_tc.c @@ -49,7 +49,7 @@ #define THREAD_STACKSIZE 4096 #endif -#define MUTEX_NUM 3 +#define MUTEX_NUM 3 #define THREAD_NUM 5 static struct rt_mutex _mutex[MUTEX_NUM]; @@ -79,7 +79,7 @@ static void test_thread_entry(void *para) uassert_true(ret == RT_EOK); uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == RT_SCHED_PRIV(rt_thread_self()).init_priority); - _sync_flag ++; + _sync_flag++; } static void test_main_thread_entry(void *para) @@ -94,60 +94,60 @@ static void test_main_thread_entry(void *para) ret = rt_mutex_take(&_mutex[0], RT_WAITING_FOREVER); uassert_true(ret == RT_EOK); uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 12); - rt_thread_mdelay(100); // wait for t0 take mutex0 + rt_thread_mdelay(100); // wait for t0 take mutex0 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 12); ret = rt_mutex_take(&_mutex[1], RT_WAITING_FOREVER); uassert_true(ret == RT_EOK); uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 12); - rt_thread_mdelay(100); // wait for t1 take mutex1 + rt_thread_mdelay(100); // wait for t1 take mutex1 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 9); ret = rt_mutex_take(&_mutex[2], RT_WAITING_FOREVER); uassert_true(ret == RT_EOK); uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 9); - rt_thread_mdelay(100); // wait for t2 take mutex2 + rt_thread_mdelay(100); // wait for t2 take mutex2 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 8); - rt_thread_mdelay(100); // wait for t3 take mutex0 + rt_thread_mdelay(100); // wait for t3 take mutex0 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 7); - rt_thread_mdelay(100); // wait for t4 take mutex1 + rt_thread_mdelay(100); // wait for t4 take mutex1 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 7); rt_thread_mdelay(100); - rt_mutex_release(&_mutex[0]); // give _mutex0 to t3 + rt_mutex_release(&_mutex[0]); // give _mutex0 to t3 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 8); rt_thread_mdelay(100); - rt_mutex_release(&_mutex[1]); // give _mutex1 to t1 + rt_mutex_release(&_mutex[1]); // give _mutex1 to t1 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 8); rt_thread_mdelay(50); - rt_mutex_take(&_mutex[1], RT_WAITING_FOREVER); // re-get _mutex1, which is hold by t1 + rt_mutex_take(&_mutex[1], RT_WAITING_FOREVER); // re-get _mutex1, which is hold by t1 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 8); - rt_mutex_release(&_mutex[1]); // give _mutex1 to thread t1 + rt_mutex_release(&_mutex[1]); // give _mutex1 to thread t1 uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 8); rt_thread_mdelay(100); rt_mutex_release(&_mutex[2]); uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 12); - _sync_flag ++; + _sync_flag++; } static void test_mutex_pi(void) { rt_thread_t t_main; rt_thread_t t[THREAD_NUM]; - rt_uint8_t prio[THREAD_NUM] = {13, 9, 8, 7, 11}; // prio of threads + rt_uint8_t prio[THREAD_NUM] = { 13, 9, 8, 7, 11 }; // prio of threads for (int i = 0; i < MUTEX_NUM; i++) { rt_mutex_init(&_mutex[i], "test1", 0); } - _sync_flag = 0; + _sync_flag = 0; t_main = rt_thread_create("t_main", test_main_thread_entry, RT_NULL, THREAD_STACKSIZE, 12, 10000); uassert_true(t_main != RT_NULL); @@ -186,7 +186,7 @@ static void test_main_timeout_entry(void *para) rt_thread_mdelay(100); uassert_true(RT_SCHED_PRIV(rt_thread_self()).current_priority == 12); rt_mutex_release(&_timeout_mutex); - _sync_flag ++; + _sync_flag++; } static void test_timeout_entry(void *para) @@ -196,7 +196,7 @@ static void test_timeout_entry(void *para) rt_thread_mdelay(50); ret = rt_mutex_take(&_timeout_mutex, rt_tick_from_millisecond(100)); uassert_true(ret == -RT_ETIMEOUT); - _sync_flag ++; + _sync_flag++; } static void test_mutex_pi_timeout(void) @@ -222,7 +222,7 @@ static void test_mutex_pi_timeout(void) } #define TC_THREAD_NUM 4 -#define TC_MUTEX_NUM TC_THREAD_NUM +#define TC_MUTEX_NUM TC_THREAD_NUM static rt_thread_t t[TC_THREAD_NUM], t_hi_prio; static struct rt_mutex m[TC_MUTEX_NUM]; @@ -249,7 +249,7 @@ static void test_recursive_mutex_depend_entry(void *para) rt_mutex_release(&m[id - 1]); rt_mutex_release(&m[id]); } - _sync_flag ++; + _sync_flag++; } static void test_recursive_mutex_depend_hi_pri_entry(void *para) @@ -257,7 +257,7 @@ static void test_recursive_mutex_depend_hi_pri_entry(void *para) rt_thread_mdelay(100); rt_err_t err = rt_mutex_take(&m[TC_MUTEX_NUM - 1], rt_tick_from_millisecond(100)); uassert_true(err == -RT_ETIMEOUT); - _sync_flag ++; + _sync_flag++; } static void test_mutex_pi_recursive_prio_update(void) @@ -300,7 +300,7 @@ static void test_mutex_pi_recursive_prio_update(void) { rt_mutex_detach(&m[i]); } - _sync_flag ++; + _sync_flag++; } static void test_mutex_waiter_to_wakeup_entry(void *para) @@ -308,7 +308,7 @@ static void test_mutex_waiter_to_wakeup_entry(void *para) rt_thread_mdelay(100); rt_err_t err = rt_mutex_take(&m[TC_MUTEX_NUM - 1], RT_WAITING_FOREVER); uassert_true(err == -RT_EINTR); - _sync_flag ++; + _sync_flag++; } static void wakeup_func(void *para) diff --git a/src/utest/mutex_tc.c b/src/utest/mutex_tc.c index 02cf557199..c910d6afc0 100644 --- a/src/utest/mutex_tc.c +++ b/src/utest/mutex_tc.c @@ -126,7 +126,9 @@ static void test_static_mutex_take(void) /* take mutex and not release */ result = rt_mutex_take(&static_mutex, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } rt_thread_t tid = rt_thread_create("mutex_th", static_mutex_take_entry, @@ -150,7 +152,9 @@ static void test_static_mutex_take(void) result = rt_mutex_detach(&static_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } uassert_true(RT_TRUE); } @@ -190,12 +194,16 @@ static void test_static_mutex_release(void) /* take mutex */ result = rt_mutex_take(&static_mutex, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } /* release mutex */ result = rt_mutex_release(&static_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } rt_thread_t tid = rt_thread_create("mutex_th", static_mutex_release_entry, @@ -219,7 +227,9 @@ static void test_static_mutex_release(void) result = rt_mutex_detach(&static_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } uassert_true(RT_TRUE); } @@ -255,7 +265,9 @@ static void test_static_mutex_trytake(void) /* take mutex and not release */ result = rt_mutex_take(&static_mutex, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } rt_thread_t tid = rt_thread_create("mutex_th", static_mutex_trytake_entry, @@ -279,7 +291,9 @@ static void test_static_mutex_trytake(void) result = rt_mutex_detach(&static_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } uassert_true(RT_TRUE); } @@ -365,7 +379,9 @@ static void test_static_pri_reverse(void) 10 - 1, 10); if (tid1 != RT_NULL) + { rt_thread_startup(tid1); + } /* thread2 */ tid2 = rt_thread_create("thread2", @@ -375,7 +391,9 @@ static void test_static_pri_reverse(void) 10, 10); if (tid2 != RT_NULL) + { rt_thread_startup(tid2); + } /* thread3 */ tid3 = rt_thread_create("thread3", @@ -385,7 +403,9 @@ static void test_static_pri_reverse(void) 10 + 1, 10); if (tid3 != RT_NULL) + { rt_thread_startup(tid3); + } while (_sync_flag != 3) { @@ -394,7 +414,9 @@ static void test_static_pri_reverse(void) result = rt_mutex_detach(&static_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } uassert_true(RT_TRUE); } @@ -466,7 +488,9 @@ static void test_dynamic_mutex_take(void) /* take mutex and not release */ result = rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } rt_thread_t tid = rt_thread_create("mutex_th", dynamic_mutex_take_entry, @@ -490,7 +514,9 @@ static void test_dynamic_mutex_take(void) result = rt_mutex_delete(dynamic_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } uassert_true(RT_TRUE); } @@ -529,12 +555,16 @@ static void test_dynamic_mutex_release(void) /* take mutex */ result = rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } /* release mutex */ result = rt_mutex_release(dynamic_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } rt_thread_t tid = rt_thread_create("mutex_th", dynamic_mutex_release_entry, @@ -558,7 +588,9 @@ static void test_dynamic_mutex_release(void) result = rt_mutex_delete(dynamic_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } uassert_true(RT_TRUE); } @@ -593,7 +625,9 @@ static void test_dynamic_mutex_trytake(void) /* take mutex and not release */ result = rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } rt_thread_t tid = rt_thread_create("mutex_th", dynamic_mutex_trytake_entry, @@ -617,7 +651,9 @@ static void test_dynamic_mutex_trytake(void) result = rt_mutex_delete(dynamic_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } uassert_true(RT_TRUE); } @@ -698,7 +734,9 @@ static void test_dynamic_pri_reverse(void) 10 - 1, 10); if (tid1 != RT_NULL) + { rt_thread_startup(tid1); + } /* thread2 */ tid2 = rt_thread_create("thread2", @@ -708,7 +746,9 @@ static void test_dynamic_pri_reverse(void) 10, 10); if (tid2 != RT_NULL) + { rt_thread_startup(tid2); + } /* thread3 */ tid3 = rt_thread_create("thread3", @@ -718,7 +758,9 @@ static void test_dynamic_pri_reverse(void) 10 + 1, 10); if (tid3 != RT_NULL) + { rt_thread_startup(tid3); + } while (_sync_flag != 3) { @@ -727,7 +769,9 @@ static void test_dynamic_pri_reverse(void) result = rt_mutex_delete(dynamic_mutex); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } uassert_true(RT_TRUE); } @@ -770,7 +814,9 @@ static void test_recurse_lock(void) _sync_flag = -1; if (tid != RT_NULL) + { rt_thread_startup(tid); + } result = rt_mutex_release(&static_mutex); uassert_true(result == RT_EOK); diff --git a/src/utest/object_tc.c b/src/utest/object_tc.c index cabacd2610..d1b2f08fb9 100644 --- a/src/utest/object_tc.c +++ b/src/utest/object_tc.c @@ -74,9 +74,9 @@ #include <rtthread.h> #include <string.h> -#define TEST_RT_NAME_MAX RT_NAME_MAX -#define OBJECT_STRESS_BATCH 24 -#define OBJECT_STRESS_ROUNDS 3 +#define TEST_RT_NAME_MAX RT_NAME_MAX +#define OBJECT_STRESS_BATCH 24 +#define OBJECT_STRESS_ROUNDS 3 #define OBJECT_THREAD_STACK_SIZE 1024 #ifndef ARRAY_SIZE @@ -89,21 +89,29 @@ static rt_uint32_t name_counter; static rt_bool_t name_in_use(const char *name, enum rt_object_class_type type) { if (!name) + { return RT_FALSE; + } if (rt_object_find(name, (rt_uint8_t)type)) + { return RT_TRUE; + } if (type == RT_Object_Class_Thread) { if (rt_thread_find((char *)name)) + { return RT_TRUE; + } } #ifdef RT_USING_DEVICE if (type == RT_Object_Class_Device) { if (rt_device_find(name)) + { return RT_TRUE; + } } #endif @@ -118,7 +126,9 @@ static rt_err_t generate_unique_name(char *buf, rt_size_t prefix_len, max_prefix_len; if (!buf || !prefix || size < TEST_RT_NAME_MAX) + { return -RT_EINVAL; + } /* Reserve space for up to 5-digit counter (99999) plus '\0' */ max_prefix_len = TEST_RT_NAME_MAX - 6; @@ -126,7 +136,9 @@ static rt_err_t generate_unique_name(char *buf, /* Limit prefix length to fit within name constraints */ if (prefix_len > max_prefix_len) + { prefix_len = max_prefix_len; + } for (int i = 0; i < 2000; i++) { @@ -135,7 +147,9 @@ static rt_err_t generate_unique_name(char *buf, buf[TEST_RT_NAME_MAX - 1] = '\0'; if (!name_in_use(buf, type)) + { return RT_EOK; + } } return -RT_ENOMEM; @@ -257,9 +271,13 @@ static void test_object_find_operations(void) static void test_object_info_enumeration(void) { - enum { STATIC_OBJ_COUNT = 2, DYNAMIC_OBJ_COUNT = 2 }; + enum + { + STATIC_OBJ_COUNT = 2, + DYNAMIC_OBJ_COUNT = 2 + }; struct rt_object static_objs[STATIC_OBJ_COUNT]; - rt_object_t dyn_objs[DYNAMIC_OBJ_COUNT] = {RT_NULL}; + rt_object_t dyn_objs[DYNAMIC_OBJ_COUNT] = { RT_NULL }; char names[STATIC_OBJ_COUNT + DYNAMIC_OBJ_COUNT][TEST_RT_NAME_MAX]; int baseline; @@ -339,7 +357,9 @@ static void test_object_info_enumeration(void) for (int i = 0; i < DYNAMIC_OBJ_COUNT; i++) { if (dyn_objs[i]) + { rt_object_delete(dyn_objs[i]); + } } } @@ -348,7 +368,7 @@ static void test_object_type_handling(void) struct rt_object obj; char name[TEST_RT_NAME_MAX]; char name_buf[TEST_RT_NAME_MAX]; - char small_buf[4] = {0}; + char small_buf[4] = { 0 }; rt_err_t ret; uassert_true(generate_unique_name(name, sizeof(name), "typ", RT_Object_Class_Thread) == RT_EOK); @@ -390,15 +410,21 @@ static rt_err_t for_each_iter(struct rt_object *obj, void *data) struct for_each_ctx *ctx = (struct for_each_ctx *)data; if (!ctx || !ctx->target) + { return -RT_EINVAL; + } if (rt_strcmp(obj->name, ctx->target) == 0) { ctx->matched = RT_TRUE; if (ctx->mode == 0) + { return 1; /* early break */ + } else + { return -RT_ERROR; + } } return RT_EOK; @@ -406,7 +432,7 @@ static rt_err_t for_each_iter(struct rt_object *obj, void *data) static void test_object_error_paths(void) { - rt_object_t list_sample[2] = {RT_NULL}; + rt_object_t list_sample[2] = { RT_NULL }; struct rt_object obj; char name[TEST_RT_NAME_MAX]; struct for_each_ctx ctx; @@ -463,7 +489,7 @@ static void test_custom_object_lifecycle(void) static void test_object_pressure(void) { - rt_object_t objects[OBJECT_STRESS_BATCH] = {RT_NULL}; + rt_object_t objects[OBJECT_STRESS_BATCH] = { RT_NULL }; char names[OBJECT_STRESS_BATCH][TEST_RT_NAME_MAX]; int baseline = rt_object_get_length(RT_Object_Class_Thread); diff --git a/src/utest/perf/context_switch_tc.c b/src/utest/perf/context_switch_tc.c index c095edec21..cc52db13c1 100644 --- a/src/utest/perf/context_switch_tc.c +++ b/src/utest/perf/context_switch_tc.c @@ -53,8 +53,10 @@ static rt_sem_t complete_sem = RT_NULL; static void local_modify_time(rt_perf_t *perf) { - if(perf) + if (perf) + { perf->real_time = perf->real_time - perf->tmp_time; + } } static void perf_thread_event1(void *parameter) @@ -78,7 +80,7 @@ static void perf_thread_event2(void *parameter) rt_sem_release(sem2); rt_perf_stop(perf); - rt_mutex_take(perf->lock,RT_WAITING_FOREVER); + rt_mutex_take(perf->lock, RT_WAITING_FOREVER); perf->count -= 1; perf->tmp_time = perf->real_time; rt_mutex_release(perf->lock); @@ -96,10 +98,10 @@ rt_err_t context_switch_test(rt_perf_t *perf) rt_thread_t thread1 = RT_NULL; rt_thread_t thread2 = RT_NULL; -# if __STDC_VERSION__ >= 199901L - rt_strcpy(perf->name,__func__); +#if __STDC_VERSION__ >= 199901L + rt_strcpy(perf->name, __func__); #else - rt_strcpy(perf->name,"context_switch_test"); + rt_strcpy(perf->name, "context_switch_test"); #endif perf->local_modify = local_modify_time; @@ -108,7 +110,7 @@ rt_err_t context_switch_test(rt_perf_t *perf) complete_sem = rt_sem_create("complete_sem", 0, RT_IPC_FLAG_FIFO); thread1 = rt_thread_create("perf_thread_event1", perf_thread_event1, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); if (thread1 == RT_NULL) { LOG_E("perf_thread_event1 create failed."); @@ -116,7 +118,7 @@ rt_err_t context_switch_test(rt_perf_t *perf) } thread2 = rt_thread_create("perf_thread_event2", perf_thread_event2, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); if (thread2 == RT_NULL) { LOG_E("perf_thread_event2 create failed."); diff --git a/src/utest/perf/irq_latency_tc.c b/src/utest/perf/irq_latency_tc.c index a6b61b1c5f..4a33b6e1d1 100644 --- a/src/utest/perf/irq_latency_tc.c +++ b/src/utest/perf/irq_latency_tc.c @@ -50,13 +50,15 @@ static rt_device_t hw_dev = RT_NULL; static rt_sem_t complete_sem = RT_NULL; -static rt_clock_timerval_t timeout = {0}; +static rt_clock_timerval_t timeout = { 0 }; static rt_perf_t *perf_local = RT_NULL; static void modify_time(rt_perf_t *perf) { - if(perf) + if (perf) + { perf->real_time = perf->real_time - perf->tmp_time; + } } static rt_err_t timer_callback(rt_device_t dev, rt_size_t size) @@ -73,10 +75,10 @@ static rt_err_t timer_callback(rt_device_t dev, rt_size_t size) rt_err_t rt_perf_irq_latency(rt_perf_t *perf) { -# if __STDC_VERSION__ >= 199901L - rt_strcpy(perf->name,__func__); +#if __STDC_VERSION__ >= 199901L + rt_strcpy(perf->name, __func__); #else - rt_strcpy(perf->name,"rt_perf_irq_latency"); + rt_strcpy(perf->name, "rt_perf_irq_latency"); #endif int ret = RT_EOK; rt_clock_timer_mode_t mode = CLOCK_TIMER_MODE_PERIOD; @@ -92,9 +94,9 @@ rt_err_t rt_perf_irq_latency(rt_perf_t *perf) complete_sem = rt_sem_create("complete", 0, RT_IPC_FLAG_FIFO); timeout.sec = 0; - timeout.usec = 50; /* No modification is necessary here, use the fixed value */ + timeout.usec = 50; /* No modification is necessary here, use the fixed value */ - rt_mutex_take(perf->lock,RT_WAITING_FOREVER); + rt_mutex_take(perf->lock, RT_WAITING_FOREVER); perf_local->tmp_time = (rt_uint32_t)(timeout.sec * 1000000u + timeout.usec); perf_local->local_modify = modify_time; rt_mutex_release(perf->lock); diff --git a/src/utest/perf/perf_tc.c b/src/utest/perf/perf_tc.c index 65e0fa4673..b88abf5ed7 100644 --- a/src/utest/perf/perf_tc.c +++ b/src/utest/perf/perf_tc.c @@ -70,7 +70,7 @@ testcase_function test_func_ptrs[] = { rt_perf_thread_event, rt_perf_thread_mq, rt_perf_thread_mbox, - rt_perf_irq_latency, /* Timer Interrupt Source */ + rt_perf_irq_latency, /* Timer Interrupt Source */ RT_NULL }; @@ -89,7 +89,9 @@ void rt_perf_start_impl(rt_perf_t *perf, rt_clock_timerval_t *timeout) if (hw_dev) { if (timeout == RT_NULL) + { timeout = &timeout_s; + } rt_device_write(hw_dev, 0, timeout, sizeof(rt_clock_timerval_t)); } perf->begin_time = rt_perf_get_timer_us(); @@ -100,7 +102,9 @@ void rt_perf_stop(rt_perf_t *perf) perf->real_time = rt_perf_get_timer_us() - perf->begin_time; if (perf->local_modify) + { perf->local_modify(perf); + } if (perf->real_time > perf->max_time) { perf->max_time = perf->real_time; @@ -115,7 +119,9 @@ void rt_perf_stop(rt_perf_t *perf) perf->tot_time += perf->real_time; if (hw_dev) + { rt_device_control(hw_dev, CLOCK_TIMER_CTRL_STOP, NULL); + } } static rt_int32_t split_double(double num, rt_uint32_t type) @@ -148,9 +154,13 @@ void rt_perf_dump(rt_perf_t *perf) } if (perf->count) + { perf->avg_time = (double)perf->tot_time / perf->count; + } else + { perf->avg_time = 0.0; + } rt_sprintf(avg_str, "%u.%04u", GET_INT(perf->avg_time), GET_DECIMALS(perf->avg_time)); @@ -219,7 +229,7 @@ static rt_err_t utest_tc_init(void) return ret; } - timeout_s.sec = 10; /* No modification is necessary here, use the fixed value */ + timeout_s.sec = 10; /* No modification is necessary here, use the fixed value */ timeout_s.usec = 0; return ret; @@ -228,7 +238,9 @@ static rt_err_t utest_tc_init(void) static rt_err_t utest_tc_cleanup(void) { if (hw_dev) + { rt_device_close(hw_dev); + } return RT_EOK; } diff --git a/src/utest/perf/perf_tc.h b/src/utest/perf/perf_tc.h index 0dc20e0d30..d5b5cb5fbf 100644 --- a/src/utest/perf/perf_tc.h +++ b/src/utest/perf/perf_tc.h @@ -16,9 +16,9 @@ #include <rtservice.h> #include <rttypes.h> -#define THREAD_STACK_SIZE 2048 -#define THREAD_PRIORITY 10 -#define THREAD_TIMESLICE 5 +#define THREAD_STACK_SIZE 2048 +#define THREAD_PRIORITY 10 +#define THREAD_TIMESLICE 5 typedef struct rt_perf { char name[64]; @@ -29,7 +29,7 @@ typedef struct rt_perf volatile rt_uint32_t min_time; volatile rt_uint32_t count; volatile double avg_time; - volatile rt_uint32_t tmp_time; /* Temporary data */ + volatile rt_uint32_t tmp_time; /* Temporary data */ rt_mutex_t lock; void (*local_modify)(struct rt_perf *perf); rt_bool_t dump_head; @@ -37,7 +37,7 @@ typedef struct rt_perf void rt_perf_start_impl(rt_perf_t *perf, rt_clock_timerval_t *timeout); void rt_perf_stop(rt_perf_t *perf); -void rt_perf_dump( rt_perf_t *perf); +void rt_perf_dump(rt_perf_t *perf); static inline void rt_perf_start(rt_perf_t *perf) { diff --git a/src/utest/perf/thread_event_tc.c b/src/utest/perf/thread_event_tc.c index 016c4b831c..65a9bb6b59 100644 --- a/src/utest/perf/thread_event_tc.c +++ b/src/utest/perf/thread_event_tc.c @@ -48,7 +48,7 @@ #include <utest_assert.h> #include <perf_tc.h> -#define EVENT_FLAG (1 << 0) +#define EVENT_FLAG (1 << 0) static rt_event_t perf_thread_event = RT_NULL; static rt_sem_t sem1 = RT_NULL; static rt_sem_t complete_sem = RT_NULL; @@ -61,8 +61,8 @@ static void perf_thread_event1(void *parameter) while (1) { ret = rt_event_recv(perf_thread_event, EVENT_FLAG, - (RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR), - RT_WAITING_FOREVER, &recv); + (RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR), + RT_WAITING_FOREVER, &recv); rt_perf_stop(perf); if (ret != RT_EOK) { @@ -102,10 +102,10 @@ rt_err_t rt_perf_thread_event(rt_perf_t *perf) rt_thread_t thread1 = RT_NULL; rt_thread_t thread2 = RT_NULL; -# if __STDC_VERSION__ >= 199901L - rt_strcpy(perf->name,__func__); +#if __STDC_VERSION__ >= 199901L + rt_strcpy(perf->name, __func__); #else - rt_strcpy(perf->name,"rt_perf_thread_event"); + rt_strcpy(perf->name, "rt_perf_thread_event"); #endif perf_thread_event = rt_event_create("perf_thread_event", RT_IPC_FLAG_PRIO); @@ -119,7 +119,7 @@ rt_err_t rt_perf_thread_event(rt_perf_t *perf) complete_sem = rt_sem_create("complete", 0, RT_IPC_FLAG_FIFO); thread1 = rt_thread_create("perf_thread_event1", perf_thread_event1, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); if (thread1 == RT_NULL) { LOG_E("perf_thread_event1 create failed."); @@ -127,7 +127,7 @@ rt_err_t rt_perf_thread_event(rt_perf_t *perf) } thread2 = rt_thread_create("perf_thread_event2", perf_thread_event2, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); if (thread2 == RT_NULL) { LOG_E("perf_thread_event2 create failed."); diff --git a/src/utest/perf/thread_mbox_tc.c b/src/utest/perf/thread_mbox_tc.c index 4b39451b53..0181c2f140 100644 --- a/src/utest/perf/thread_mbox_tc.c +++ b/src/utest/perf/thread_mbox_tc.c @@ -99,10 +99,10 @@ rt_err_t rt_perf_thread_mbox(rt_perf_t *perf) rt_thread_t thread1 = RT_NULL; rt_thread_t thread2 = RT_NULL; -# if __STDC_VERSION__ >= 199901L - rt_strcpy(perf->name,__func__); +#if __STDC_VERSION__ >= 199901L + rt_strcpy(perf->name, __func__); #else - rt_strcpy(perf->name,"rt_perf_thread_mbox"); + rt_strcpy(perf->name, "rt_perf_thread_mbox"); #endif perf_thread_mbox = rt_mb_create("perf_thread_mbox", 1, RT_IPC_FLAG_PRIO); @@ -116,7 +116,7 @@ rt_err_t rt_perf_thread_mbox(rt_perf_t *perf) complete_sem = rt_sem_create("complete", 0, RT_IPC_FLAG_FIFO); thread1 = rt_thread_create("perf_thread_mbox1", perf_thread_mbox1, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); if (thread1 == RT_NULL) { LOG_E("perf_thread_mbox1 create failed."); @@ -124,7 +124,7 @@ rt_err_t rt_perf_thread_mbox(rt_perf_t *perf) } thread2 = rt_thread_create("perf_thread_mbox2", perf_thread_mbox2, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); if (thread2 == RT_NULL) { LOG_E("perf_thread_mbox2 create failed."); diff --git a/src/utest/perf/thread_mq_tc.c b/src/utest/perf/thread_mq_tc.c index 3dcf099f3c..f46851b9d4 100644 --- a/src/utest/perf/thread_mq_tc.c +++ b/src/utest/perf/thread_mq_tc.c @@ -99,10 +99,10 @@ rt_err_t rt_perf_thread_mq(rt_perf_t *perf) rt_thread_t thread1 = RT_NULL; rt_thread_t thread2 = RT_NULL; -# if __STDC_VERSION__ >= 199901L - rt_strcpy(perf->name,__func__); +#if __STDC_VERSION__ >= 199901L + rt_strcpy(perf->name, __func__); #else - rt_strcpy(perf->name,"rt_perf_thread_mq"); + rt_strcpy(perf->name, "rt_perf_thread_mq"); #endif perf_thread_mq = rt_mq_create("perf_thread_mq", 1, 1, RT_IPC_FLAG_PRIO); @@ -116,7 +116,7 @@ rt_err_t rt_perf_thread_mq(rt_perf_t *perf) complete_sem = rt_sem_create("complete", 0, RT_IPC_FLAG_FIFO); thread1 = rt_thread_create("perf_thread_mq1", perf_thread_mq1, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); if (thread1 == RT_NULL) { LOG_E("perf_thread_mq1 create failed."); @@ -124,7 +124,7 @@ rt_err_t rt_perf_thread_mq(rt_perf_t *perf) } thread2 = rt_thread_create("perf_thread_mq2", perf_thread_mq2, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); if (thread2 == RT_NULL) { LOG_E("perf_thread_mq2 create failed."); diff --git a/src/utest/perf/thread_sem_tc.c b/src/utest/perf/thread_sem_tc.c index 5048d6e537..c35c3fd2a0 100644 --- a/src/utest/perf/thread_sem_tc.c +++ b/src/utest/perf/thread_sem_tc.c @@ -52,7 +52,7 @@ static rt_sem_t perf_thread_sem = RT_NULL; static rt_event_t perf_thread_event = RT_NULL; static rt_sem_t complete_sem = RT_NULL; -#define EVENT_FLAG (1 << 0) +#define EVENT_FLAG (1 << 0) static void perf_thread_sem1(void *parameter) { rt_err_t ret = RT_EOK; @@ -62,7 +62,7 @@ static void perf_thread_sem1(void *parameter) { ret = rt_sem_take(perf_thread_sem, RT_WAITING_FOREVER); rt_perf_stop(perf); - if(ret != RT_EOK) + if (ret != RT_EOK) { LOG_E("Sem recv error!"); rt_sem_delete(perf_thread_sem); @@ -92,9 +92,9 @@ static void perf_thread_sem2(void *parameter) return; } ret = rt_event_recv(perf_thread_event, EVENT_FLAG, - (RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR), - RT_WAITING_FOREVER, &recv); - if(ret != RT_EOK) + (RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR), + RT_WAITING_FOREVER, &recv); + if (ret != RT_EOK) { LOG_E("Event reception failed"); rt_event_delete(perf_thread_event); @@ -111,10 +111,10 @@ rt_err_t rt_perf_thread_sem(rt_perf_t *perf) rt_thread_t thread1 = RT_NULL; rt_thread_t thread2 = RT_NULL; -# if __STDC_VERSION__ >= 199901L - rt_strcpy(perf->name,__func__); +#if __STDC_VERSION__ >= 199901L + rt_strcpy(perf->name, __func__); #else - rt_strcpy(perf->name,"rt_perf_thread_sem"); + rt_strcpy(perf->name, "rt_perf_thread_sem"); #endif perf_thread_sem = rt_sem_create("perf_thread_sem", 0, RT_IPC_FLAG_FIFO); @@ -128,7 +128,7 @@ rt_err_t rt_perf_thread_sem(rt_perf_t *perf) complete_sem = rt_sem_create("complete", 0, RT_IPC_FLAG_FIFO); thread1 = rt_thread_create("perf_thread_sem1", perf_thread_sem1, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); if (thread1 == RT_NULL) { LOG_E("perf_thread_sem1 create failed."); @@ -136,7 +136,7 @@ rt_err_t rt_perf_thread_sem(rt_perf_t *perf) } thread2 = rt_thread_create("perf_thread_sem2", perf_thread_sem2, perf, - THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); + THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE); if (thread2 == RT_NULL) { LOG_E("perf_thread_sem2 create failed."); diff --git a/src/utest/sched_mtx_tc.c b/src/utest/sched_mtx_tc.c index bc62084b2d..1208fb16eb 100644 --- a/src/utest/sched_mtx_tc.c +++ b/src/utest/sched_mtx_tc.c @@ -64,12 +64,12 @@ * Stressful Test for Mutex */ -#define TEST_SECONDS 30 -#define TEST_LOOP_TICKS (TEST_SECONDS * RT_TICK_PER_SECOND) -#define TEST_THREAD_COUNTS (RT_CPUS_NR) -#define TEST_PROGRESS_COUNTS (36) -#define TEST_PROGRESS_ON (TEST_LOOP_TICKS/TEST_PROGRESS_COUNTS) -#define TEST_PRIORITY_HIGHEST (UTEST_THR_PRIORITY+1) +#define TEST_SECONDS 30 +#define TEST_LOOP_TICKS (TEST_SECONDS * RT_TICK_PER_SECOND) +#define TEST_THREAD_COUNTS (RT_CPUS_NR) +#define TEST_PROGRESS_COUNTS (36) +#define TEST_PROGRESS_ON (TEST_LOOP_TICKS / TEST_PROGRESS_COUNTS) +#define TEST_PRIORITY_HIGHEST (UTEST_THR_PRIORITY + 1) #define TEST_RANDOM_LATENCY_MAX (1000 * 1000) static struct rt_semaphore _thr_exit_sem; @@ -117,7 +117,9 @@ static void mutex_stress_tc(void) rt_thread_delay(1); if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0) + { uassert_true(1); + } } /* trigger exit request for all sub-threads */ diff --git a/src/utest/sched_sem_tc.c b/src/utest/sched_sem_tc.c index 4a2fd00f2b..11e47e96fc 100644 --- a/src/utest/sched_sem_tc.c +++ b/src/utest/sched_sem_tc.c @@ -66,10 +66,10 @@ #include "rthw.h" #include "utest.h" -#define KERN_TEST_CONFIG_LOOP_TIMES 160 -#define KERN_TEST_CONCURRENT_THREADS (RT_CPUS_NR * 2) -#define KERN_TEST_CONFIG_HIGHEST_PRIO 3 -#define KERN_TEST_CONFIG_LOWEST_PRIO (RT_THREAD_PRIORITY_MAX - 2) +#define KERN_TEST_CONFIG_LOOP_TIMES 160 +#define KERN_TEST_CONCURRENT_THREADS (RT_CPUS_NR * 2) +#define KERN_TEST_CONFIG_HIGHEST_PRIO 3 +#define KERN_TEST_CONFIG_LOWEST_PRIO (RT_THREAD_PRIORITY_MAX - 2) #define TEST_LEVEL_COUNTS (KERN_TEST_CONFIG_LOWEST_PRIO - KERN_TEST_CONFIG_HIGHEST_PRIO + 1) #if TEST_LEVEL_COUNTS <= RT_CPUS_NR @@ -149,7 +149,6 @@ static void _thread_entry(void *param) } else if (level == TEST_LEVEL_COUNTS - 1) { - for (size_t i = 0; i < KERN_TEST_CONFIG_LOOP_TIMES; i++) { /* waiting for our resource first */ @@ -225,10 +224,12 @@ static rt_err_t utest_tc_init(void) _thread_entry, (void *)i, UTEST_THR_STACK_SIZE, - KERN_TEST_CONFIG_HIGHEST_PRIO+i, + KERN_TEST_CONFIG_HIGHEST_PRIO + i, 5); if (!_thread_matrix[i][j]) + { uassert_not_null(_thread_matrix[i][j]); + } } } return RT_EOK; diff --git a/src/utest/sched_thread_tc.c b/src/utest/sched_thread_tc.c index 9c3f74eef9..93a7ec2f86 100644 --- a/src/utest/sched_thread_tc.c +++ b/src/utest/sched_thread_tc.c @@ -62,10 +62,10 @@ #include <rtthread.h> #include "utest.h" -#define TEST_LOOP_TIMES (100 * 1000) +#define TEST_LOOP_TIMES (100 * 1000) #define TEST_PROGRESS_COUNTS (36) -#define TEST_THREAD_COUNT (RT_CPUS_NR * 1) -#define TEST_PROGRESS_ON (TEST_LOOP_TIMES*TEST_THREAD_COUNT/TEST_PROGRESS_COUNTS) +#define TEST_THREAD_COUNT (RT_CPUS_NR * 1) +#define TEST_PROGRESS_ON (TEST_LOOP_TIMES * TEST_THREAD_COUNT / TEST_PROGRESS_COUNTS) static struct rt_semaphore _thr_exit_sem; static rt_atomic_t _progress_counter; @@ -87,7 +87,9 @@ static void _thread_entry1(void *param) rt_exit_critical_safe(critical_level); if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0) + { uassert_true(1); + } } rt_sem_release(&_thr_exit_sem); @@ -109,7 +111,9 @@ static void _thread_entry2(void *param) rt_exit_critical_safe(critical_level); if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0) + { uassert_true(1); + } } rt_sem_release(&_thr_exit_sem); diff --git a/src/utest/sched_timed_mtx_tc.c b/src/utest/sched_timed_mtx_tc.c index 1b4b24b6d4..7cd35c86c5 100644 --- a/src/utest/sched_timed_mtx_tc.c +++ b/src/utest/sched_timed_mtx_tc.c @@ -59,10 +59,10 @@ #include <stdlib.h> #include "utest.h" -#define TEST_SECONDS 10 -#define TEST_LOOP_TICKS (TEST_SECONDS * RT_TICK_PER_SECOND) +#define TEST_SECONDS 10 +#define TEST_LOOP_TICKS (TEST_SECONDS * RT_TICK_PER_SECOND) #define TEST_PROGRESS_COUNTS (36) -#define TEST_PROGRESS_ON (TEST_LOOP_TICKS*2/TEST_PROGRESS_COUNTS) +#define TEST_PROGRESS_ON (TEST_LOOP_TICKS * 2 / TEST_PROGRESS_COUNTS) static struct rt_semaphore _thr_exit_sem; static struct rt_mutex _ipc_primitive; @@ -92,8 +92,7 @@ static void _wait_until_edge(void) do { current = rt_tick_get(); - } - while (current == entry_level); + } while (current == entry_level); /* give a random latency for test */ random_latency = rand() % 1000 * 1000; @@ -102,7 +101,9 @@ static void _wait_until_edge(void) { current = rt_tick_get(); if (current != entry_level) + { break; + } } } @@ -146,7 +147,9 @@ static void _producer_entry(void *param) rt_mutex_release(&_ipc_primitive); if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0) + { uassert_true(1); + } } rt_sem_release(&_thr_exit_sem); @@ -213,7 +216,9 @@ static void _consumer_entry(void *param) } if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0) + { uassert_true(1); + } } rt_sem_release(&_thr_exit_sem); diff --git a/src/utest/sched_timed_sem_tc.c b/src/utest/sched_timed_sem_tc.c index 147b7c238f..22db980765 100644 --- a/src/utest/sched_timed_sem_tc.c +++ b/src/utest/sched_timed_sem_tc.c @@ -61,10 +61,10 @@ #include <stdlib.h> #include "utest.h" -#define TEST_SECONDS 10 -#define TEST_LOOP_TICKS (TEST_SECONDS * RT_TICK_PER_SECOND) +#define TEST_SECONDS 10 +#define TEST_LOOP_TICKS (TEST_SECONDS * RT_TICK_PER_SECOND) #define TEST_PROGRESS_COUNTS (36) -#define TEST_PROGRESS_ON (TEST_LOOP_TICKS*2/TEST_PROGRESS_COUNTS) +#define TEST_PROGRESS_ON (TEST_LOOP_TICKS * 2 / TEST_PROGRESS_COUNTS) static struct rt_semaphore _thr_exit_sem; static struct rt_semaphore _ipc_sem; @@ -89,8 +89,7 @@ static void _wait_until_edge(void) do { current = rt_tick_get(); - } - while (current == entry_level); + } while (current == entry_level); /* give a random latency for test */ random_latency = rand(); @@ -99,7 +98,9 @@ static void _wait_until_edge(void) { current = rt_tick_get(); if (current != entry_level) + { break; + } } } @@ -112,7 +113,9 @@ static void _producer_entry(void *param) rt_sem_release(&_ipc_sem); if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0) + { uassert_true(1); + } } rt_sem_release(&_thr_exit_sem); @@ -132,11 +135,15 @@ static void _consumer_entry(void *param) else { if (error != RT_EOK) + { uassert_true(0); + } } if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0) + { uassert_true(1); + } } rt_sem_release(&_thr_exit_sem); diff --git a/src/utest/semaphore_tc.c b/src/utest/semaphore_tc.c index 356a729936..fef43800b3 100644 --- a/src/utest/semaphore_tc.c +++ b/src/utest/semaphore_tc.c @@ -124,11 +124,15 @@ static void test_static_semaphore_take(void) /* first take */ result = rt_sem_take(&static_semaphore, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } /* second take */ result = rt_sem_take(&static_semaphore, 100); if (-RT_ETIMEOUT != result) + { uassert_true(RT_FALSE); + } } else { @@ -150,11 +154,15 @@ static void test_static_semaphore_trytake(void) /* first take */ result = rt_sem_trytake(&static_semaphore); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } /* second take */ result = rt_sem_trytake(&static_semaphore); if (-RT_ETIMEOUT != result) + { uassert_true(RT_FALSE); + } } else { @@ -176,17 +184,23 @@ static void test_static_semaphore_release(void) /* first take */ result = rt_sem_take(&static_semaphore, 100); if (-RT_ETIMEOUT != result) + { uassert_true(RT_FALSE); + } /* release */ result = rt_sem_release(&static_semaphore); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } /* second take */ result = rt_sem_take(&static_semaphore, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } } else { @@ -273,9 +287,13 @@ static void test_static_semaphore_release_isr(void) RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT); /* start tiemr */ if (hardware_timer) + { rt_timer_start(hardware_timer); + } if (software_timer) + { rt_timer_start(software_timer); + } result = rt_sem_init(&static_semaphore, "static_sem", 0, RT_IPC_FLAG_PRIO); if (RT_EOK == result) @@ -373,11 +391,15 @@ static void test_dynamic_semaphore_take(void) /* first take */ result = rt_sem_take(dynamic_semaphore, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } /* second take */ result = rt_sem_take(dynamic_semaphore, 100); if (-RT_ETIMEOUT != result) + { uassert_true(RT_FALSE); + } } else { @@ -399,11 +421,15 @@ static void test_dynamic_semaphore_trytake(void) /* first take */ result = rt_sem_trytake(dynamic_semaphore); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } /* second take */ result = rt_sem_trytake(dynamic_semaphore); if (-RT_ETIMEOUT != result) + { uassert_true(RT_FALSE); + } } else { @@ -425,17 +451,23 @@ static void test_dynamic_semaphore_release(void) /* first take */ result = rt_sem_take(dynamic_semaphore, 100); if (-RT_ETIMEOUT != result) + { uassert_true(RT_FALSE); + } /* release */ result = rt_sem_release(dynamic_semaphore); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } /* second take */ result = rt_sem_take(dynamic_semaphore, RT_WAITING_FOREVER); if (RT_EOK != result) + { uassert_true(RT_FALSE); + } } else { @@ -522,9 +554,13 @@ static void test_dynamic_semaphore_release_isr(void) RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT); /* start tiemr */ if (hardware_timer) + { rt_timer_start(hardware_timer); + } if (software_timer) + { rt_timer_start(software_timer); + } dynamic_semaphore = rt_sem_create("static_sem", 0, RT_IPC_FLAG_PRIO); if (RT_NULL != dynamic_semaphore) diff --git a/src/utest/signal_tc.c b/src/utest/signal_tc.c index 7ace71d603..c7aecb8aae 100644 --- a/src/utest/signal_tc.c +++ b/src/utest/signal_tc.c @@ -223,7 +223,7 @@ static void rt_signal_kill_test(void) uassert_int_equal(receive_sig, signo); } /* case 8:rt_signal_kill, kill illegal thread, return failed; */ -// uassert_true(rt_thread_kill((rt_thread_t)-1, signo) == -RT_ERROR); + // uassert_true(rt_thread_kill((rt_thread_t)-1, signo) == -RT_ERROR); /* case 9:rt_signal_kill, kill illegal signo, return -RT_EINVAL; */ uassert_true(rt_thread_kill(rt_thread_self(), -1) == -RT_EINVAL); diff --git a/src/utest/slab_tc.c b/src/utest/slab_tc.c index b5ff3f1f4e..1345736996 100644 --- a/src/utest/slab_tc.c +++ b/src/utest/slab_tc.c @@ -55,7 +55,9 @@ static int _mem_cmp(void *ptr, rt_uint8_t v, rt_size_t size) while (size-- != 0) { if (*(rt_uint8_t *)ptr != v) + { return *(rt_uint8_t *)ptr - v; + } } return 0; } @@ -76,8 +78,8 @@ struct slab_alloc_head rt_tick_t interval; }; -#define SLAB_RANG_ALLOC_BLK_MIN 2 -#define SLAB_RANG_ALLOC_BLK_MAX 5 +#define SLAB_RANG_ALLOC_BLK_MIN 2 +#define SLAB_RANG_ALLOC_BLK_MAX 5 #define SLAB_RANG_ALLOC_TEST_TIME 5 static void slab_alloc_test(void) @@ -133,7 +135,7 @@ static void slab_alloc_test(void) } rt_memset(ctx, 0xAA, ctx->size); rt_slab_free(heap, ctx); - head.count --; + head.count--; } continue; } @@ -167,7 +169,7 @@ static void slab_alloc_test(void) } rt_memset(ctx, 0xAA, ctx->size); rt_slab_free(heap, ctx); - head.count --; + head.count--; } } } @@ -184,7 +186,7 @@ static void slab_alloc_test(void) } rt_memset(ctx, 0xAA, ctx->size); rt_slab_free(heap, ctx); - head.count --; + head.count--; } uassert_int_equal(head.count, 0); // slab heap deinit @@ -193,8 +195,8 @@ static void slab_alloc_test(void) rt_free(buf); } -#define SLAB_RANG_REALLOC_BLK_MIN 0 -#define SLAB_RANG_REALLOC_BLK_MAX 5 +#define SLAB_RANG_REALLOC_BLK_MIN 0 +#define SLAB_RANG_REALLOC_BLK_MAX 5 #define SLAB_RANG_REALLOC_TEST_TIME 5 struct slab_realloc_context diff --git a/src/utest/smp/smp_affinity_pri1_tc.c b/src/utest/smp/smp_affinity_pri1_tc.c index 5f3c55804c..8836b5c649 100644 --- a/src/utest/smp/smp_affinity_pri1_tc.c +++ b/src/utest/smp/smp_affinity_pri1_tc.c @@ -48,13 +48,13 @@ static int run_num = 10; #define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE #define THREAD_PRIORITY 2 -#define LOW_PRIORITY 30 -#define THIGH_PRIORITY 10 -static rt_thread_t threads[RT_CPUS_NR]; -static rt_thread_t temp_thread; +#define LOW_PRIORITY 30 +#define THIGH_PRIORITY 10 +static rt_thread_t threads[RT_CPUS_NR]; +static rt_thread_t temp_thread; static struct rt_spinlock lock; -static int thread_inc = 0; -static int num = 0; +static int thread_inc = 0; +static int num = 0; static void thread_temp_entry(void *parameter) { @@ -71,7 +71,7 @@ static void thread_temp_entry(void *parameter) static void thread_entry(void *parameter) { - int id = 0; + int id = 0; int para = *(int *)parameter; while (1) { @@ -104,9 +104,9 @@ static void thread_entry(void *parameter) static void smp_affinity_pri1_tc(void) { - static int params[RT_CPUS_NR] = {0}; + static int params[RT_CPUS_NR] = { 0 }; char thread_name[8]; - int i; + int i; for (i = 0; i < RT_CPUS_NR; i++) { diff --git a/src/utest/smp/smp_affinity_pri2_tc.c b/src/utest/smp/smp_affinity_pri2_tc.c index 0b40018c0b..c39f7255f1 100644 --- a/src/utest/smp/smp_affinity_pri2_tc.c +++ b/src/utest/smp/smp_affinity_pri2_tc.c @@ -47,14 +47,14 @@ static int run_num = 10; #define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE #define THREAD_PRIORITY 2 -#define LOW_PRIORITY 30 -#define THIGH_PRIORITY 10 -static rt_thread_t threads[RT_CPUS_NR]; -static rt_thread_t temp_thread; +#define LOW_PRIORITY 30 +#define THIGH_PRIORITY 10 +static rt_thread_t threads[RT_CPUS_NR]; +static rt_thread_t temp_thread; static struct rt_spinlock lock; -static int thread_inc = 0; -static int run_flag = 0; -static int num = 0; +static int thread_inc = 0; +static int run_flag = 0; +static int num = 0; static void thread_temp_entry(void *parameter) { @@ -64,7 +64,7 @@ static void thread_temp_entry(void *parameter) static void thread_entry(void *parameter) { - int id = 0; + int id = 0; int para = *(int *)parameter; while (1) { @@ -96,9 +96,9 @@ static void thread_entry(void *parameter) static void smp_affinity_pri2_tc(void) { - static int params[RT_CPUS_NR] = {0}; + static int params[RT_CPUS_NR] = { 0 }; char thread_name[8]; - int i; + int i; for (i = 0; i < RT_CPUS_NR; i++) { diff --git a/src/utest/smp/smp_assigned_idle_cores_tc.c b/src/utest/smp/smp_assigned_idle_cores_tc.c index 94092959f9..62d739d7ec 100644 --- a/src/utest/smp/smp_assigned_idle_cores_tc.c +++ b/src/utest/smp/smp_assigned_idle_cores_tc.c @@ -49,9 +49,9 @@ #define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE #define THREAD_PRIORITY 20 static rt_thread_t threads[RT_CPUS_NR - 1]; -static int tick = 0; +static int tick = 0; static rt_align(sizeof(rt_ubase_t)) int finish_flag = 0; -static int num = 0; +static int num = 0; /* thread entry function */ static void thread_entry(void *parameter) { @@ -69,9 +69,9 @@ static void thread_entry(void *parameter) static void thread_on_idle_core_tc(void) { - static int params[RT_CPUS_NR] = {0}; - char thread_name[8]; - int i; + static int params[RT_CPUS_NR] = { 0 }; + char thread_name[8]; + int i; /* Initialise the thread entry parameters */ for (i = 0; i < RT_CPUS_NR; i++) @@ -91,7 +91,7 @@ static void thread_on_idle_core_tc(void) } } /* Waiting for test cases to finish */ - while (finish_flag != (1<<(RT_CPUS_NR-1))-1); + while (finish_flag != (1 << (RT_CPUS_NR - 1)) - 1); /* Output the current core running threads */ extern long list_thread(void); list_thread(); diff --git a/src/utest/smp/smp_bind_affinity_tc.c b/src/utest/smp/smp_bind_affinity_tc.c index 5a54a2722f..9d5c527ec6 100644 --- a/src/utest/smp/smp_bind_affinity_tc.c +++ b/src/utest/smp/smp_bind_affinity_tc.c @@ -47,11 +47,11 @@ static int run_num = 100; #define THREAD_PRIORITY 20 static rt_thread_t threads[RT_CPUS_NR]; static struct rt_spinlock lock; -static int thread_inc[RT_CPUS_NR] = {0}; -static int thread_tic[RT_CPUS_NR] = {0}; -static rt_uint32_t thread_core_mask[RT_CPUS_NR] = {0}; +static int thread_inc[RT_CPUS_NR] = { 0 }; +static int thread_tic[RT_CPUS_NR] = { 0 }; +static rt_uint32_t thread_core_mask[RT_CPUS_NR] = { 0 }; static rt_atomic_t finsh_flag; -static int num = 0; +static int num = 0; static void thread_entry(void *parameter) { @@ -89,9 +89,9 @@ static void thread_entry(void *parameter) static void thread_bind_affinity_tc(void) { - static int params[RT_CPUS_NR] = {0}; - char thread_name[8]; - int i, j; + static int params[RT_CPUS_NR] = { 0 }; + char thread_name[8]; + int i, j; for (i = 0; i < RT_CPUS_NR; i++) { diff --git a/src/utest/smp/smp_interrupt_pri_tc.c b/src/utest/smp/smp_interrupt_pri_tc.c index bbef5db6c9..2ae9b64259 100644 --- a/src/utest/smp/smp_interrupt_pri_tc.c +++ b/src/utest/smp/smp_interrupt_pri_tc.c @@ -66,8 +66,8 @@ #define RT_SPI_PRI_HIGH 120 #define RT_SPI_PRI_LOW 140 -static int mode = 0; -static int ipi_val[2] = {0, 0}; +static int mode = 0; +static int ipi_val[2] = { 0, 0 }; /* Software Interrupt 1 Service Functions */ static void rt_scheduler_ipi1_handler(int vector, void *param) @@ -108,7 +108,9 @@ static void int_pri1_tc(void) pri2 = rt_hw_interrupt_get_priority(RT_SPI_2); if (pri1 < pri2) + { uassert_true(pri1 < pri2); + } /* Trigger interrupt */ rt_hw_ipi_send(RT_SPI_1, 0x1); @@ -125,7 +127,9 @@ static void int_pri2_tc(void) pri2 = rt_hw_interrupt_get_priority(RT_SPI_2); if (pri1 < pri2) + { uassert_true(pri1 < pri2); + } rt_base_t level = rt_hw_local_irq_disable(); /* Trigger interrupt */ diff --git a/src/utest/smp/smp_spinlock_tc.c b/src/utest/smp/smp_spinlock_tc.c index e6aa702bf0..da7a7b72bc 100644 --- a/src/utest/smp/smp_spinlock_tc.c +++ b/src/utest/smp/smp_spinlock_tc.c @@ -42,11 +42,11 @@ #define THREAD_PRIORITY 20 #define THREAD_TIMESLICE 20 #define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE -static rt_thread_t thread1; -static rt_thread_t thread2; -static rt_uint8_t finsh_flag = 0; +static rt_thread_t thread1; +static rt_thread_t thread2; +static rt_uint8_t finsh_flag = 0; static struct rt_spinlock lock; -static rt_uint8_t number1, number2 = 0; +static rt_uint8_t number1, number2 = 0; static void rt_thread_entry1(void *parameter) { diff --git a/src/utest/smp/smp_thread_preemption_tc.c b/src/utest/smp/smp_thread_preemption_tc.c index b8493d9be2..19ab090cb4 100644 --- a/src/utest/smp/smp_thread_preemption_tc.c +++ b/src/utest/smp/smp_thread_preemption_tc.c @@ -44,10 +44,10 @@ #define THREAD_PRIORITY_HIGH 21 #define THREAD_PRIORITY_LOW 30 -#define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE +#define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE -static rt_thread_t threads[2]; -static volatile rt_uint8_t finish_flag = 0; +static rt_thread_t threads[2]; +static volatile rt_uint8_t finish_flag = 0; static struct rt_spinlock lock; /* High Priority Thread */ @@ -78,15 +78,15 @@ static void thread_preemptions_tc(void) { /* Creating low-priority thread */ threads[0] = rt_thread_create("tlow", thread_low_entry, RT_NULL, THREAD_STACK_SIZE, THREAD_PRIORITY_LOW, 10); - if (threads[0] != RT_NULL) + if (threads[0] != RT_NULL) { uassert_true(1); - rt_thread_startup(threads[0] ); + rt_thread_startup(threads[0]); } rt_thread_delay(5); /* Creating high-priority thread */ - threads[1] = rt_thread_create("thigh", thread_high_entry, RT_NULL, THREAD_STACK_SIZE, THREAD_PRIORITY_HIGH, 10); + threads[1] = rt_thread_create("thigh", thread_high_entry, RT_NULL, THREAD_STACK_SIZE, THREAD_PRIORITY_HIGH, 10); if (threads[1] != RT_NULL) { uassert_true(1); diff --git a/src/utest/thread_overflow_tc.c b/src/utest/thread_overflow_tc.c index 520cf89160..e79881f2c6 100644 --- a/src/utest/thread_overflow_tc.c +++ b/src/utest/thread_overflow_tc.c @@ -15,10 +15,10 @@ #define TEST_STACK_SIZE UTEST_THR_STACK_SIZE /* Test thread stack overflow */ -static rt_thread_t test_thread = RT_NULL; -static rt_thread_t fake_thread = RT_NULL; /* Dynamic fake thread */ +static rt_thread_t test_thread = RT_NULL; +static rt_thread_t fake_thread = RT_NULL; /* Dynamic fake thread */ static volatile rt_bool_t overflow_detected = RT_FALSE; -static volatile rt_bool_t test_completed = RT_FALSE; +static volatile rt_bool_t test_completed = RT_FALSE; /* Stack overflow detection hook - returns RT_EOK to continue, other values to halt */ static rt_err_t stack_overflow_hook(struct rt_thread *thread) @@ -240,8 +240,8 @@ cleanup: static rt_err_t utest_tc_init(void) { overflow_detected = RT_FALSE; - test_completed = RT_FALSE; - test_thread = RT_NULL; + test_completed = RT_FALSE; + test_thread = RT_NULL; rt_kprintf("Stack overflow test case initialized\n"); return RT_EOK; @@ -267,7 +267,7 @@ static rt_err_t utest_tc_cleanup(void) } overflow_detected = RT_FALSE; - test_completed = RT_FALSE; + test_completed = RT_FALSE; rt_kprintf("Stack overflow test case cleanup completed\n"); return RT_EOK; diff --git a/src/utest/thread_suspend_tc.c b/src/utest/thread_suspend_tc.c index e6d9850468..ac12d049ca 100644 --- a/src/utest/thread_suspend_tc.c +++ b/src/utest/thread_suspend_tc.c @@ -17,24 +17,24 @@ #define TEST_THREAD_PRIORITY 25 /* Global variables for normal usage test */ -static rt_thread_t target_thread = RT_NULL; -static rt_thread_t monitor_thread = RT_NULL; -static rt_sem_t sync_sem = RT_NULL; -static volatile rt_uint32_t work_counter = 0; -static volatile rt_bool_t suspend_test_done = RT_FALSE; -static volatile rt_bool_t suspend_success = RT_FALSE; -static volatile rt_bool_t resume_success = RT_FALSE; +static rt_thread_t target_thread = RT_NULL; +static rt_thread_t monitor_thread = RT_NULL; +static rt_sem_t sync_sem = RT_NULL; +static volatile rt_uint32_t work_counter = 0; +static volatile rt_bool_t suspend_test_done = RT_FALSE; +static volatile rt_bool_t suspend_success = RT_FALSE; +static volatile rt_bool_t resume_success = RT_FALSE; /* Global variables for deadlock test */ -static rt_mutex_t test_mutex = RT_NULL; -static rt_thread_t holder_thread = RT_NULL; -static rt_thread_t waiter_thread = RT_NULL; -static volatile rt_uint32_t shared_counter = 0; -static volatile rt_bool_t holder_got_mutex = RT_FALSE; -static volatile rt_bool_t deadlock_detected = RT_FALSE; -static volatile rt_bool_t test_completed = RT_FALSE; -static volatile rt_bool_t thread_started = RT_FALSE; -static volatile rt_bool_t thread_should_exit = RT_FALSE; +static rt_mutex_t test_mutex = RT_NULL; +static rt_thread_t holder_thread = RT_NULL; +static rt_thread_t waiter_thread = RT_NULL; +static volatile rt_uint32_t shared_counter = 0; +static volatile rt_bool_t holder_got_mutex = RT_FALSE; +static volatile rt_bool_t deadlock_detected = RT_FALSE; +static volatile rt_bool_t test_completed = RT_FALSE; +static volatile rt_bool_t thread_started = RT_FALSE; +static volatile rt_bool_t thread_should_exit = RT_FALSE; /* Target work thread - the thread to be suspended */ static void target_work_thread(void *parameter) @@ -160,7 +160,7 @@ static void mutex_waiter_thread(void *parameter) void simple_thread_entry(void *param) { volatile rt_bool_t *flag = (volatile rt_bool_t *)param; - *flag = RT_TRUE; + *flag = RT_TRUE; /* Keep the thread running until it's suspended and deleted */ while (1) @@ -173,10 +173,10 @@ void simple_thread_entry(void *param) static void test_suspend_force_normal_usage(void) { /* Reset global variables */ - work_counter = 0; + work_counter = 0; suspend_test_done = RT_FALSE; - suspend_success = RT_FALSE; - resume_success = RT_FALSE; + suspend_success = RT_FALSE; + resume_success = RT_FALSE; /* Create synchronization semaphore */ sync_sem = rt_sem_create("sync", 0, RT_IPC_FLAG_FIFO); @@ -244,7 +244,7 @@ static void test_suspend_force_api_basic(void) rt_thread_t api_thread; /* Reset global variables */ - thread_started = RT_FALSE; + thread_started = RT_FALSE; thread_should_exit = RT_FALSE; /* Create a simple test thread */ @@ -283,7 +283,7 @@ static void test_suspend_force_api_basic(void) } /* Reset global variables for next test */ - thread_started = RT_FALSE; + thread_started = RT_FALSE; thread_should_exit = RT_FALSE; } @@ -339,10 +339,10 @@ static void test_suspend_force_not_started_thread(void) static void test_suspend_force_deadlock_risk(void) { /* Reset global variables */ - shared_counter = 0; - holder_got_mutex = RT_FALSE; + shared_counter = 0; + holder_got_mutex = RT_FALSE; deadlock_detected = RT_FALSE; - test_completed = RT_FALSE; + test_completed = RT_FALSE; /* Create mutex */ test_mutex = rt_mutex_create("test_mutex", RT_IPC_FLAG_PRIO); @@ -431,15 +431,15 @@ static rt_err_t utest_tc_init(void) static rt_err_t utest_tc_cleanup(void) { /* Reset all global variables to ensure clean state between tests */ - work_counter = 0; - suspend_test_done = RT_FALSE; - suspend_success = RT_FALSE; - resume_success = RT_FALSE; - shared_counter = 0; - holder_got_mutex = RT_FALSE; - deadlock_detected = RT_FALSE; - test_completed = RT_FALSE; - thread_started = RT_FALSE; + work_counter = 0; + suspend_test_done = RT_FALSE; + suspend_success = RT_FALSE; + resume_success = RT_FALSE; + shared_counter = 0; + holder_got_mutex = RT_FALSE; + deadlock_detected = RT_FALSE; + test_completed = RT_FALSE; + thread_started = RT_FALSE; thread_should_exit = RT_FALSE; /* Clean up any remaining resources - safety check */ @@ -456,10 +456,10 @@ static rt_err_t utest_tc_cleanup(void) } /* Ensure all thread pointers are NULL */ - target_thread = RT_NULL; + target_thread = RT_NULL; monitor_thread = RT_NULL; - holder_thread = RT_NULL; - waiter_thread = RT_NULL; + holder_thread = RT_NULL; + waiter_thread = RT_NULL; /* Give system time to complete cleanup */ rt_thread_mdelay(50); diff --git a/src/utest/thread_tc.c b/src/utest/thread_tc.c index 7e859d40f3..5b3e002120 100644 --- a/src/utest/thread_tc.c +++ b/src/utest/thread_tc.c @@ -1,4 +1,4 @@ - /* +/* * Copyright (c) 2006-2021, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 @@ -58,19 +58,18 @@ #include <stdlib.h> #include "utest.h" -#define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE -#define THREAD_TIMESLICE 10 +#define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE +#define THREAD_TIMESLICE 10 -rt_align(RT_ALIGN_SIZE) -static char thread2_stack[UTEST_THR_STACK_SIZE]; +rt_align(RT_ALIGN_SIZE) static char thread2_stack[UTEST_THR_STACK_SIZE]; static struct rt_thread thread2; #ifdef RT_USING_HEAP - static rt_thread_t tid1 = RT_NULL; - static rt_thread_t tid3 = RT_NULL; - static rt_thread_t tid4 = RT_NULL; - static rt_thread_t tid5 = RT_NULL; - static rt_thread_t tid6 = RT_NULL; - static rt_thread_t tid7 = RT_NULL; +static rt_thread_t tid1 = RT_NULL; +static rt_thread_t tid3 = RT_NULL; +static rt_thread_t tid4 = RT_NULL; +static rt_thread_t tid5 = RT_NULL; +static rt_thread_t tid6 = RT_NULL; +static rt_thread_t tid7 = RT_NULL; #endif /* RT_USING_HEAP */ static volatile rt_uint32_t tid3_delay_pass_flag = 0; @@ -80,7 +79,7 @@ static volatile rt_uint32_t tid6_finish_flag = 0; static volatile rt_uint32_t thread5_source = 0; #ifndef RT_USING_SMP - static volatile rt_uint32_t thread_yield_flag = 0; +static volatile rt_uint32_t thread_yield_flag = 0; #endif static volatile rt_uint32_t entry_idle_hook_times = 0; static rt_thread_t __current_thread; @@ -232,13 +231,13 @@ __exit: static void idle_hook(void) { - entry_idle_hook_times ++; + entry_idle_hook_times++; } static void thread4_entry(void *parameter) { rt_uint32_t delay_times = 5; - while (delay_times --) + while (delay_times--) { rt_thread_mdelay(300); } @@ -287,7 +286,7 @@ static void thread5_entry(void *parameter) { while (1) { - thread5_source ++; + thread5_source++; rt_thread_delay(5); if (thread5_source == 5) { @@ -298,7 +297,7 @@ static void thread5_entry(void *parameter) static void thread6_entry(void *parameter) { - while (++ thread5_source <= 9); + while (++thread5_source <= 9); tid6_finish_flag = 1; } @@ -420,7 +419,7 @@ __exit: static void thread8_entry(void *parameter) { - for (; count < 10; count ++); + for (; count < 10; count++); } static void test_thread_priority(void) @@ -445,7 +444,7 @@ static void test_thread_priority(void) if (ret_startup != RT_EOK) { uassert_false(ret_startup != RT_EOK); - return ; + return; } uassert_true(count == 10); @@ -521,7 +520,10 @@ static void test_timeslice_threadA_entry(void *parameter) { rt_thread_delay(2); timeslice_cntA++; - if (timeslice_cntA > 10) return; + if (timeslice_cntA > 10) + { + return; + } } } static void test_timeslice_threadB1_entry(void *parameter) @@ -529,7 +531,10 @@ static void test_timeslice_threadB1_entry(void *parameter) while (1) { timeslice_cntB1++; - if (timeslice_cntA > 10) return; + if (timeslice_cntA > 10) + { + return; + } } } static void test_timeslice_threadB2_entry(void *parameter) @@ -537,7 +542,10 @@ static void test_timeslice_threadB2_entry(void *parameter) while (1) { timeslice_cntB2++; - if (timeslice_cntA > 10) return; + if (timeslice_cntA > 10) + { + return; + } } } @@ -551,7 +559,7 @@ void test_timeslice(void) timeslice_cntB2 = 0; tidA = rt_thread_create("timeslice", test_timeslice_threadA_entry, RT_NULL, - 2048, UTEST_THR_PRIORITY + 1, 10); + 2048, UTEST_THR_PRIORITY + 1, 10); if (!tidA) { LOG_E("rt_thread_create failed!"); @@ -564,11 +572,11 @@ void test_timeslice(void) { LOG_E("rt_thread_startup failed!"); uassert_false(1); - return ; + return; } tidB1 = rt_thread_create("timeslice", test_timeslice_threadB1_entry, RT_NULL, - 2048, UTEST_THR_PRIORITY + 2, 2); + 2048, UTEST_THR_PRIORITY + 2, 2); if (!tidB1) { LOG_E("rt_thread_create failed!"); @@ -581,11 +589,11 @@ void test_timeslice(void) { LOG_E("rt_thread_startup failed!"); uassert_false(1); - return ; + return; } tidB2 = rt_thread_create("timeslice", test_timeslice_threadB2_entry, RT_NULL, - 2048, UTEST_THR_PRIORITY + 2, 2); + 2048, UTEST_THR_PRIORITY + 2, 2); if (!tidB2) { LOG_E("rt_thread_create failed!"); @@ -598,11 +606,12 @@ void test_timeslice(void) { LOG_E("rt_thread_startup failed!"); uassert_false(1); - return ; + return; } - do{ + do + { rt_thread_delay(2 * 20); - }while(timeslice_cntA <= 10); + } while (timeslice_cntA <= 10); rt_kprintf("A:%d,B1:%d,B2:%d\n", timeslice_cntA, timeslice_cntB1, timeslice_cntB2); diff = abs(timeslice_cntB1 - timeslice_cntB2); @@ -620,7 +629,9 @@ static void test_thread_yield_inc_entry(void *parameter) while (1) { if (loop++ > 10001) + { break; + } yield_count++; rt_thread_yield(); } @@ -647,13 +658,15 @@ static void test_thread_yield_entry(void *parameter) { LOG_E("rt_thread_startup failed!"); uassert_false(1); - return ; + return; } while (1) { if (loop++ > 10000) + { break; + } count_before = yield_count; rt_thread_yield(); @@ -687,7 +700,7 @@ void test_thread_yield_nosmp(void) { LOG_E("rt_thread_startup failed!"); uassert_false(1); - return ; + return; } uassert_true(thread_yield_flag == 1); @@ -793,7 +806,6 @@ static void testcase(void) // UTEST_UNIT_RUN(test_timeslice); /* Can not running in Github Action QEMU */ } - UTEST_TC_EXPORT(testcase, "core.thread_tc", utest_tc_init, utest_tc_cleanup, 1000); /********************* end of file ************************/ diff --git a/src/utest/timer_tc.c b/src/utest/timer_tc.c index 6ceeeb442d..3ce4226f18 100644 --- a/src/utest/timer_tc.c +++ b/src/utest/timer_tc.c @@ -557,10 +557,10 @@ static void test_dynamic_timer_start_twice(void) for (int i = 0; i < sizeof(timer_flag_oneshot); i++) { timer.dynamic_timer = rt_timer_create("dynamic_timer", - timer_oneshot, - &timer, - time_out, - timer_flag_oneshot[i]); + timer_oneshot, + &timer, + time_out, + timer_flag_oneshot[i]); /* calc expect tick */ timer.expect_tick = rt_tick_get() + time_out; @@ -603,10 +603,10 @@ static void test_dynamic_timer_op_in_callback(void) for (int i = 0; i < sizeof(timer_flag_oneshot); i++) { timer.dynamic_timer = rt_timer_create("dynamic_timer", - timer_start_in_callback, - &timer, - time_out, - timer_flag_oneshot[i]); + timer_start_in_callback, + &timer, + time_out, + timer_flag_oneshot[i]); /* calc expect tick */ timer.expect_tick = rt_tick_get() + time_out; @@ -634,10 +634,10 @@ static void test_dynamic_timer_op_in_callback(void) for (int i = 0; i < sizeof(timer_flag_periodic); i++) { timer.dynamic_timer = rt_timer_create("dynamic_timer", - timer_start_stop_in_callback, - &timer, - time_out, - timer_flag_periodic[i]); + timer_start_stop_in_callback, + &timer, + time_out, + timer_flag_periodic[i]); /* calc expect tick */ timer.expect_tick = rt_tick_get() + time_out; @@ -662,7 +662,7 @@ static void test_dynamic_timer_op_in_callback(void) } #endif /* RT_USING_HEAP */ -#define TEST_TIME_S 60 // test 60 seconds +#define TEST_TIME_S 60 // test 60 seconds #define STRESS_TIMERS 100 static struct rt_timer stress_timer[STRESS_TIMERS]; @@ -688,18 +688,18 @@ static void test_timer_stress(void) rt_ubase_t cur_tick; rt_ubase_t next_print_time; - LOG_I("timer stress test begin, it will take %d seconds", 3*TEST_TIME_S); + LOG_I("timer stress test begin, it will take %d seconds", 3 * TEST_TIME_S); for (int i = 0; i < sizeof(timer_flag_periodic); i++) { for (int j = 0; j < STRESS_TIMERS; j++) { rt_timer_init(&stress_timer[j], - "stress_timer", - timer_stress, - &stress_timer[j], - j + 1, - timer_flag_periodic[i]); + "stress_timer", + timer_stress, + &stress_timer[j], + j + 1, + timer_flag_periodic[i]); } start = rt_tick_get(); @@ -718,7 +718,7 @@ static void test_timer_stress(void) rt_timer_stop(&stress_timer[j]); } } - iters ++; + iters++; cur_tick = rt_tick_get(); if (cur_tick > next_print_time) { diff --git a/tools/ci/requirements-format.txt b/tools/ci/requirements-format.txt new file mode 100644 index 0000000000..cd89ecb715 --- /dev/null +++ b/tools/ci/requirements-format.txt @@ -0,0 +1 @@ +clang-format==22.1.8 |