Эх сурвалжийг харах

style: add clang-format config and standardize code style

Signed-off-by: nrush <1741598985@qq.com>
nrush 5 сар өмнө
parent
commit
8d97100cab

+ 688 - 0
.clang-format

@@ -0,0 +1,688 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# clang-format configuration file. Intended for clang-format >= 11.
+#
+# For more information, see:
+#
+#   Documentation/process/clang-format.rst
+#   https://clang.llvm.org/docs/ClangFormat.html
+#   https://clang.llvm.org/docs/ClangFormatStyleOptions.html
+#
+---
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
+AlignOperands: true
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: false
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeComma
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit: 128
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 8
+ContinuationIndentWidth: 8
+Cpp11BracedListStyle: false
+DerivePointerAlignment: false
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: false
+
+# Taken from:
+#   git grep -h '^#define [^[:space:]]*for_each[^[:space:]]*(' include/ tools/ \
+#   | sed "s,^#define \([^[:space:]]*for_each[^[:space:]]*\)(.*$,  - '\1'," \
+#   | LC_ALL=C sort -u
+ForEachMacros:
+  - '__ata_qc_for_each'
+  - '__bio_for_each_bvec'
+  - '__bio_for_each_segment'
+  - '__evlist__for_each_entry'
+  - '__evlist__for_each_entry_continue'
+  - '__evlist__for_each_entry_from'
+  - '__evlist__for_each_entry_reverse'
+  - '__evlist__for_each_entry_safe'
+  - '__for_each_mem_range'
+  - '__for_each_mem_range_rev'
+  - '__for_each_thread'
+  - '__hlist_for_each_rcu'
+  - '__map__for_each_symbol_by_name'
+  - '__perf_evlist__for_each_entry'
+  - '__perf_evlist__for_each_entry_reverse'
+  - '__perf_evlist__for_each_entry_safe'
+  - '__rq_for_each_bio'
+  - '__shost_for_each_device'
+  - 'apei_estatus_for_each_section'
+  - 'ata_for_each_dev'
+  - 'ata_for_each_link'
+  - 'ata_qc_for_each'
+  - 'ata_qc_for_each_raw'
+  - 'ata_qc_for_each_with_internal'
+  - 'ax25_for_each'
+  - 'ax25_uid_for_each'
+  - 'bio_for_each_bvec'
+  - 'bio_for_each_bvec_all'
+  - 'bio_for_each_folio_all'
+  - 'bio_for_each_integrity_vec'
+  - 'bio_for_each_segment'
+  - 'bio_for_each_segment_all'
+  - 'bio_list_for_each'
+  - 'bip_for_each_vec'
+  - 'bond_for_each_slave'
+  - 'bond_for_each_slave_rcu'
+  - 'bpf__perf_for_each_map'
+  - 'bpf__perf_for_each_map_named'
+  - 'bpf_for_each_spilled_reg'
+  - 'bpf_object__for_each_map'
+  - 'bpf_object__for_each_program'
+  - 'bpf_object__for_each_safe'
+  - 'bpf_perf_object__for_each'
+  - 'btree_for_each_safe128'
+  - 'btree_for_each_safe32'
+  - 'btree_for_each_safe64'
+  - 'btree_for_each_safel'
+  - 'card_for_each_dev'
+  - 'cgroup_taskset_for_each'
+  - 'cgroup_taskset_for_each_leader'
+  - 'cpufreq_for_each_efficient_entry_idx'
+  - 'cpufreq_for_each_entry'
+  - 'cpufreq_for_each_entry_idx'
+  - 'cpufreq_for_each_valid_entry'
+  - 'cpufreq_for_each_valid_entry_idx'
+  - 'css_for_each_child'
+  - 'css_for_each_descendant_post'
+  - 'css_for_each_descendant_pre'
+  - 'damon_for_each_region'
+  - 'damon_for_each_region_safe'
+  - 'damon_for_each_scheme'
+  - 'damon_for_each_scheme_safe'
+  - 'damon_for_each_target'
+  - 'damon_for_each_target_safe'
+  - 'data__for_each_file'
+  - 'data__for_each_file_new'
+  - 'data__for_each_file_start'
+  - 'device_for_each_child_node'
+  - 'displayid_iter_for_each'
+  - 'dma_fence_array_for_each'
+  - 'dma_fence_chain_for_each'
+  - 'dma_fence_unwrap_for_each'
+  - 'dma_resv_for_each_fence'
+  - 'dma_resv_for_each_fence_unlocked'
+  - 'do_for_each_ftrace_op'
+  - 'drm_atomic_crtc_for_each_plane'
+  - 'drm_atomic_crtc_state_for_each_plane'
+  - 'drm_atomic_crtc_state_for_each_plane_state'
+  - 'drm_atomic_for_each_plane_damage'
+  - 'drm_client_for_each_connector_iter'
+  - 'drm_client_for_each_modeset'
+  - 'drm_connector_for_each_possible_encoder'
+  - 'drm_for_each_bridge_in_chain'
+  - 'drm_for_each_connector_iter'
+  - 'drm_for_each_crtc'
+  - 'drm_for_each_crtc_reverse'
+  - 'drm_for_each_encoder'
+  - 'drm_for_each_encoder_mask'
+  - 'drm_for_each_fb'
+  - 'drm_for_each_legacy_plane'
+  - 'drm_for_each_plane'
+  - 'drm_for_each_plane_mask'
+  - 'drm_for_each_privobj'
+  - 'drm_mm_for_each_hole'
+  - 'drm_mm_for_each_node'
+  - 'drm_mm_for_each_node_in_range'
+  - 'drm_mm_for_each_node_safe'
+  - 'dsa_switch_for_each_available_port'
+  - 'dsa_switch_for_each_cpu_port'
+  - 'dsa_switch_for_each_port'
+  - 'dsa_switch_for_each_port_continue_reverse'
+  - 'dsa_switch_for_each_port_safe'
+  - 'dsa_switch_for_each_user_port'
+  - 'dsa_tree_for_each_user_port'
+  - 'dso__for_each_symbol'
+  - 'dsos__for_each_with_build_id'
+  - 'elf_hash_for_each_possible'
+  - 'elf_section__for_each_rel'
+  - 'elf_section__for_each_rela'
+  - 'elf_symtab__for_each_symbol'
+  - 'evlist__for_each_cpu'
+  - 'evlist__for_each_entry'
+  - 'evlist__for_each_entry_continue'
+  - 'evlist__for_each_entry_from'
+  - 'evlist__for_each_entry_reverse'
+  - 'evlist__for_each_entry_safe'
+  - 'flow_action_for_each'
+  - 'for_each_acpi_dev_match'
+  - 'for_each_active_dev_scope'
+  - 'for_each_active_drhd_unit'
+  - 'for_each_active_iommu'
+  - 'for_each_aggr_pgid'
+  - 'for_each_available_child_of_node'
+  - 'for_each_bench'
+  - 'for_each_bio'
+  - 'for_each_board_func_rsrc'
+  - 'for_each_btf_ext_rec'
+  - 'for_each_btf_ext_sec'
+  - 'for_each_bvec'
+  - 'for_each_card_auxs'
+  - 'for_each_card_auxs_safe'
+  - 'for_each_card_components'
+  - 'for_each_card_dapms'
+  - 'for_each_card_pre_auxs'
+  - 'for_each_card_prelinks'
+  - 'for_each_card_rtds'
+  - 'for_each_card_rtds_safe'
+  - 'for_each_card_widgets'
+  - 'for_each_card_widgets_safe'
+  - 'for_each_cgroup_storage_type'
+  - 'for_each_child_of_node'
+  - 'for_each_clear_bit'
+  - 'for_each_clear_bit_from'
+  - 'for_each_clear_bitrange'
+  - 'for_each_clear_bitrange_from'
+  - 'for_each_cmd'
+  - 'for_each_cmsghdr'
+  - 'for_each_collection'
+  - 'for_each_comp_order'
+  - 'for_each_compatible_node'
+  - 'for_each_component_dais'
+  - 'for_each_component_dais_safe'
+  - 'for_each_console'
+  - 'for_each_console_srcu'
+  - 'for_each_cpu'
+  - 'for_each_cpu_and'
+  - 'for_each_cpu_not'
+  - 'for_each_cpu_wrap'
+  - 'for_each_dapm_widgets'
+  - 'for_each_dedup_cand'
+  - 'for_each_dev_addr'
+  - 'for_each_dev_scope'
+  - 'for_each_dma_cap_mask'
+  - 'for_each_dpcm_be'
+  - 'for_each_dpcm_be_rollback'
+  - 'for_each_dpcm_be_safe'
+  - 'for_each_dpcm_fe'
+  - 'for_each_drhd_unit'
+  - 'for_each_dss_dev'
+  - 'for_each_efi_memory_desc'
+  - 'for_each_efi_memory_desc_in_map'
+  - 'for_each_element'
+  - 'for_each_element_extid'
+  - 'for_each_element_id'
+  - 'for_each_endpoint_of_node'
+  - 'for_each_event'
+  - 'for_each_event_tps'
+  - 'for_each_evictable_lru'
+  - 'for_each_fib6_node_rt_rcu'
+  - 'for_each_fib6_walker_rt'
+  - 'for_each_free_mem_pfn_range_in_zone'
+  - 'for_each_free_mem_pfn_range_in_zone_from'
+  - 'for_each_free_mem_range'
+  - 'for_each_free_mem_range_reverse'
+  - 'for_each_func_rsrc'
+  - 'for_each_group_evsel'
+  - 'for_each_group_member'
+  - 'for_each_hstate'
+  - 'for_each_if'
+  - 'for_each_inject_fn'
+  - 'for_each_insn'
+  - 'for_each_insn_prefix'
+  - 'for_each_intid'
+  - 'for_each_iommu'
+  - 'for_each_ip_tunnel_rcu'
+  - 'for_each_irq_nr'
+  - 'for_each_lang'
+  - 'for_each_link_codecs'
+  - 'for_each_link_cpus'
+  - 'for_each_link_platforms'
+  - 'for_each_lru'
+  - 'for_each_matching_node'
+  - 'for_each_matching_node_and_match'
+  - 'for_each_mem_pfn_range'
+  - 'for_each_mem_range'
+  - 'for_each_mem_range_rev'
+  - 'for_each_mem_region'
+  - 'for_each_member'
+  - 'for_each_memory'
+  - 'for_each_migratetype_order'
+  - 'for_each_missing_reg'
+  - 'for_each_net'
+  - 'for_each_net_continue_reverse'
+  - 'for_each_net_rcu'
+  - 'for_each_netdev'
+  - 'for_each_netdev_continue'
+  - 'for_each_netdev_continue_rcu'
+  - 'for_each_netdev_continue_reverse'
+  - 'for_each_netdev_feature'
+  - 'for_each_netdev_in_bond_rcu'
+  - 'for_each_netdev_rcu'
+  - 'for_each_netdev_reverse'
+  - 'for_each_netdev_safe'
+  - 'for_each_new_connector_in_state'
+  - 'for_each_new_crtc_in_state'
+  - 'for_each_new_mst_mgr_in_state'
+  - 'for_each_new_plane_in_state'
+  - 'for_each_new_plane_in_state_reverse'
+  - 'for_each_new_private_obj_in_state'
+  - 'for_each_new_reg'
+  - 'for_each_node'
+  - 'for_each_node_by_name'
+  - 'for_each_node_by_type'
+  - 'for_each_node_mask'
+  - 'for_each_node_state'
+  - 'for_each_node_with_cpus'
+  - 'for_each_node_with_property'
+  - 'for_each_nonreserved_multicast_dest_pgid'
+  - 'for_each_of_allnodes'
+  - 'for_each_of_allnodes_from'
+  - 'for_each_of_cpu_node'
+  - 'for_each_of_pci_range'
+  - 'for_each_old_connector_in_state'
+  - 'for_each_old_crtc_in_state'
+  - 'for_each_old_mst_mgr_in_state'
+  - 'for_each_old_plane_in_state'
+  - 'for_each_old_private_obj_in_state'
+  - 'for_each_oldnew_connector_in_state'
+  - 'for_each_oldnew_crtc_in_state'
+  - 'for_each_oldnew_mst_mgr_in_state'
+  - 'for_each_oldnew_plane_in_state'
+  - 'for_each_oldnew_plane_in_state_reverse'
+  - 'for_each_oldnew_private_obj_in_state'
+  - 'for_each_online_cpu'
+  - 'for_each_online_node'
+  - 'for_each_online_pgdat'
+  - 'for_each_path'
+  - 'for_each_pci_bridge'
+  - 'for_each_pci_dev'
+  - 'for_each_pcm_streams'
+  - 'for_each_physmem_range'
+  - 'for_each_populated_zone'
+  - 'for_each_possible_cpu'
+  - 'for_each_present_cpu'
+  - 'for_each_prime_number'
+  - 'for_each_prime_number_from'
+  - 'for_each_probe_cache_entry'
+  - 'for_each_process'
+  - 'for_each_process_thread'
+  - 'for_each_prop_codec_conf'
+  - 'for_each_prop_dai_codec'
+  - 'for_each_prop_dai_cpu'
+  - 'for_each_prop_dlc_codecs'
+  - 'for_each_prop_dlc_cpus'
+  - 'for_each_prop_dlc_platforms'
+  - 'for_each_property_of_node'
+  - 'for_each_reg'
+  - 'for_each_reg_filtered'
+  - 'for_each_registered_fb'
+  - 'for_each_requested_gpio'
+  - 'for_each_requested_gpio_in_range'
+  - 'for_each_reserved_mem_range'
+  - 'for_each_reserved_mem_region'
+  - 'for_each_rtd_codec_dais'
+  - 'for_each_rtd_components'
+  - 'for_each_rtd_cpu_dais'
+  - 'for_each_rtd_dais'
+  - 'for_each_script'
+  - 'for_each_sec'
+  - 'for_each_set_bit'
+  - 'for_each_set_bit_from'
+  - 'for_each_set_bitrange'
+  - 'for_each_set_bitrange_from'
+  - 'for_each_set_clump8'
+  - 'for_each_sg'
+  - 'for_each_sg_dma_page'
+  - 'for_each_sg_page'
+  - 'for_each_sgtable_dma_page'
+  - 'for_each_sgtable_dma_sg'
+  - 'for_each_sgtable_page'
+  - 'for_each_sgtable_sg'
+  - 'for_each_shell_test'
+  - 'for_each_sibling_event'
+  - 'for_each_subelement'
+  - 'for_each_subelement_extid'
+  - 'for_each_subelement_id'
+  - 'for_each_sublist'
+  - 'for_each_subsystem'
+  - 'for_each_supported_activate_fn'
+  - 'for_each_supported_inject_fn'
+  - 'for_each_test'
+  - 'for_each_thread'
+  - 'for_each_token'
+  - 'for_each_unicast_dest_pgid'
+  - 'for_each_vsi'
+  - 'for_each_wakeup_source'
+  - 'for_each_zone'
+  - 'for_each_zone_zonelist'
+  - 'for_each_zone_zonelist_nodemask'
+  - 'func_for_each_insn'
+  - 'fwnode_for_each_available_child_node'
+  - 'fwnode_for_each_child_node'
+  - 'fwnode_graph_for_each_endpoint'
+  - 'gadget_for_each_ep'
+  - 'genradix_for_each'
+  - 'genradix_for_each_from'
+  - 'hash_for_each'
+  - 'hash_for_each_possible'
+  - 'hash_for_each_possible_rcu'
+  - 'hash_for_each_possible_rcu_notrace'
+  - 'hash_for_each_possible_safe'
+  - 'hash_for_each_rcu'
+  - 'hash_for_each_safe'
+  - 'hashmap__for_each_entry'
+  - 'hashmap__for_each_entry_safe'
+  - 'hashmap__for_each_key_entry'
+  - 'hashmap__for_each_key_entry_safe'
+  - 'hctx_for_each_ctx'
+  - 'hists__for_each_format'
+  - 'hists__for_each_sort_list'
+  - 'hlist_bl_for_each_entry'
+  - 'hlist_bl_for_each_entry_rcu'
+  - 'hlist_bl_for_each_entry_safe'
+  - 'hlist_for_each'
+  - 'hlist_for_each_entry'
+  - 'hlist_for_each_entry_continue'
+  - 'hlist_for_each_entry_continue_rcu'
+  - 'hlist_for_each_entry_continue_rcu_bh'
+  - 'hlist_for_each_entry_from'
+  - 'hlist_for_each_entry_from_rcu'
+  - 'hlist_for_each_entry_rcu'
+  - 'hlist_for_each_entry_rcu_bh'
+  - 'hlist_for_each_entry_rcu_notrace'
+  - 'hlist_for_each_entry_safe'
+  - 'hlist_for_each_entry_srcu'
+  - 'hlist_for_each_safe'
+  - 'hlist_nulls_for_each_entry'
+  - 'hlist_nulls_for_each_entry_from'
+  - 'hlist_nulls_for_each_entry_rcu'
+  - 'hlist_nulls_for_each_entry_safe'
+  - 'i3c_bus_for_each_i2cdev'
+  - 'i3c_bus_for_each_i3cdev'
+  - 'idr_for_each_entry'
+  - 'idr_for_each_entry_continue'
+  - 'idr_for_each_entry_continue_ul'
+  - 'idr_for_each_entry_ul'
+  - 'in_dev_for_each_ifa_rcu'
+  - 'in_dev_for_each_ifa_rtnl'
+  - 'inet_bind_bucket_for_each'
+  - 'inet_lhash2_for_each_icsk'
+  - 'inet_lhash2_for_each_icsk_continue'
+  - 'inet_lhash2_for_each_icsk_rcu'
+  - 'interval_tree_for_each_double_span'
+  - 'interval_tree_for_each_span'
+  - 'intlist__for_each_entry'
+  - 'intlist__for_each_entry_safe'
+  - 'iopt_for_each_contig_area'
+  - 'kcore_copy__for_each_phdr'
+  - 'key_for_each'
+  - 'key_for_each_safe'
+  - 'klp_for_each_func'
+  - 'klp_for_each_func_safe'
+  - 'klp_for_each_func_static'
+  - 'klp_for_each_object'
+  - 'klp_for_each_object_safe'
+  - 'klp_for_each_object_static'
+  - 'kunit_suite_for_each_test_case'
+  - 'kvm_for_each_memslot'
+  - 'kvm_for_each_memslot_in_gfn_range'
+  - 'kvm_for_each_vcpu'
+  - 'libbpf_nla_for_each_attr'
+  - 'list_for_each'
+  - 'list_for_each_codec'
+  - 'list_for_each_codec_safe'
+  - 'list_for_each_continue'
+  - 'list_for_each_entry'
+  - 'list_for_each_entry_continue'
+  - 'list_for_each_entry_continue_rcu'
+  - 'list_for_each_entry_continue_reverse'
+  - 'list_for_each_entry_from'
+  - 'list_for_each_entry_from_rcu'
+  - 'list_for_each_entry_from_reverse'
+  - 'list_for_each_entry_lockless'
+  - 'list_for_each_entry_rcu'
+  - 'list_for_each_entry_reverse'
+  - 'list_for_each_entry_safe'
+  - 'list_for_each_entry_safe_continue'
+  - 'list_for_each_entry_safe_from'
+  - 'list_for_each_entry_safe_reverse'
+  - 'list_for_each_entry_srcu'
+  - 'list_for_each_from'
+  - 'list_for_each_prev'
+  - 'list_for_each_prev_safe'
+  - 'list_for_each_safe'
+  - 'llist_for_each'
+  - 'llist_for_each_entry'
+  - 'llist_for_each_entry_safe'
+  - 'llist_for_each_safe'
+  - 'map__for_each_symbol'
+  - 'map__for_each_symbol_by_name'
+  - 'map_for_each_event'
+  - 'map_for_each_metric'
+  - 'maps__for_each_entry'
+  - 'maps__for_each_entry_safe'
+  - 'mci_for_each_dimm'
+  - 'media_device_for_each_entity'
+  - 'media_device_for_each_intf'
+  - 'media_device_for_each_link'
+  - 'media_device_for_each_pad'
+  - 'msi_for_each_desc'
+  - 'nanddev_io_for_each_page'
+  - 'netdev_for_each_lower_dev'
+  - 'netdev_for_each_lower_private'
+  - 'netdev_for_each_lower_private_rcu'
+  - 'netdev_for_each_mc_addr'
+  - 'netdev_for_each_uc_addr'
+  - 'netdev_for_each_upper_dev_rcu'
+  - 'netdev_hw_addr_list_for_each'
+  - 'nft_rule_for_each_expr'
+  - 'nla_for_each_attr'
+  - 'nla_for_each_nested'
+  - 'nlmsg_for_each_attr'
+  - 'nlmsg_for_each_msg'
+  - 'nr_neigh_for_each'
+  - 'nr_neigh_for_each_safe'
+  - 'nr_node_for_each'
+  - 'nr_node_for_each_safe'
+  - 'of_for_each_phandle'
+  - 'of_property_for_each_string'
+  - 'of_property_for_each_u32'
+  - 'pci_bus_for_each_resource'
+  - 'pci_doe_for_each_off'
+  - 'pcl_for_each_chunk'
+  - 'pcl_for_each_segment'
+  - 'pcm_for_each_format'
+  - 'perf_config_items__for_each_entry'
+  - 'perf_config_sections__for_each_entry'
+  - 'perf_config_set__for_each_entry'
+  - 'perf_cpu_map__for_each_cpu'
+  - 'perf_evlist__for_each_entry'
+  - 'perf_evlist__for_each_entry_reverse'
+  - 'perf_evlist__for_each_entry_safe'
+  - 'perf_evlist__for_each_evsel'
+  - 'perf_evlist__for_each_mmap'
+  - 'perf_hpp_list__for_each_format'
+  - 'perf_hpp_list__for_each_format_safe'
+  - 'perf_hpp_list__for_each_sort_list'
+  - 'perf_hpp_list__for_each_sort_list_safe'
+  - 'perf_pmu__for_each_hybrid_pmu'
+  - 'ping_portaddr_for_each_entry'
+  - 'ping_portaddr_for_each_entry_rcu'
+  - 'plist_for_each'
+  - 'plist_for_each_continue'
+  - 'plist_for_each_entry'
+  - 'plist_for_each_entry_continue'
+  - 'plist_for_each_entry_safe'
+  - 'plist_for_each_safe'
+  - 'pnp_for_each_card'
+  - 'pnp_for_each_dev'
+  - 'protocol_for_each_card'
+  - 'protocol_for_each_dev'
+  - 'queue_for_each_hw_ctx'
+  - 'radix_tree_for_each_slot'
+  - 'radix_tree_for_each_tagged'
+  - 'rb_for_each'
+  - 'rbtree_postorder_for_each_entry_safe'
+  - 'rdma_for_each_block'
+  - 'rdma_for_each_port'
+  - 'rdma_umem_for_each_dma_block'
+  - 'resort_rb__for_each_entry'
+  - 'resource_list_for_each_entry'
+  - 'resource_list_for_each_entry_safe'
+  - 'rhl_for_each_entry_rcu'
+  - 'rhl_for_each_rcu'
+  - 'rht_for_each'
+  - 'rht_for_each_entry'
+  - 'rht_for_each_entry_from'
+  - 'rht_for_each_entry_rcu'
+  - 'rht_for_each_entry_rcu_from'
+  - 'rht_for_each_entry_safe'
+  - 'rht_for_each_from'
+  - 'rht_for_each_rcu'
+  - 'rht_for_each_rcu_from'
+  - 'rq_for_each_bvec'
+  - 'rq_for_each_segment'
+  - 'rq_list_for_each'
+  - 'rq_list_for_each_safe'
+  - 'scsi_for_each_prot_sg'
+  - 'scsi_for_each_sg'
+  - 'sctp_for_each_hentry'
+  - 'sctp_skb_for_each'
+  - 'sec_for_each_insn'
+  - 'sec_for_each_insn_continue'
+  - 'sec_for_each_insn_from'
+  - 'shdma_for_each_chan'
+  - 'shost_for_each_device'
+  - 'sk_for_each'
+  - 'sk_for_each_bound'
+  - 'sk_for_each_entry_offset_rcu'
+  - 'sk_for_each_from'
+  - 'sk_for_each_rcu'
+  - 'sk_for_each_safe'
+  - 'sk_nulls_for_each'
+  - 'sk_nulls_for_each_from'
+  - 'sk_nulls_for_each_rcu'
+  - 'snd_array_for_each'
+  - 'snd_pcm_group_for_each_entry'
+  - 'snd_soc_dapm_widget_for_each_path'
+  - 'snd_soc_dapm_widget_for_each_path_safe'
+  - 'snd_soc_dapm_widget_for_each_sink_path'
+  - 'snd_soc_dapm_widget_for_each_source_path'
+  - 'strlist__for_each_entry'
+  - 'strlist__for_each_entry_safe'
+  - 'sym_for_each_insn'
+  - 'sym_for_each_insn_continue_reverse'
+  - 'symbols__for_each_entry'
+  - 'tb_property_for_each'
+  - 'tcf_act_for_each_action'
+  - 'tcf_exts_for_each_action'
+  - 'udp_portaddr_for_each_entry'
+  - 'udp_portaddr_for_each_entry_rcu'
+  - 'usb_hub_for_each_child'
+  - 'v4l2_device_for_each_subdev'
+  - 'v4l2_m2m_for_each_dst_buf'
+  - 'v4l2_m2m_for_each_dst_buf_safe'
+  - 'v4l2_m2m_for_each_src_buf'
+  - 'v4l2_m2m_for_each_src_buf_safe'
+  - 'virtio_device_for_each_vq'
+  - 'while_for_each_ftrace_op'
+  - 'xa_for_each'
+  - 'xa_for_each_marked'
+  - 'xa_for_each_range'
+  - 'xa_for_each_start'
+  - 'xas_for_each'
+  - 'xas_for_each_conflict'
+  - 'xas_for_each_marked'
+  - 'xbc_array_for_each_value'
+  - 'xbc_for_each_key_value'
+  - 'xbc_node_for_each_array_value'
+  - 'xbc_node_for_each_child'
+  - 'xbc_node_for_each_key_value'
+  - 'xbc_node_for_each_subkey'
+  - 'zorro_for_each_dev'
+
+IncludeBlocks: Preserve
+IncludeCategories:
+  - Regex: '.*'
+    Priority: 1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentGotoLabels: false
+IndentPPDirectives: None
+IndentWidth: 8
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 8
+ObjCSpaceAfterProperty: true
+ObjCSpaceBeforeProtocolList: true
+
+# Taken from git's rules
+PenaltyBreakAssignment: 10
+PenaltyBreakBeforeFirstCallParameter: 30
+PenaltyBreakComment: 10
+PenaltyBreakFirstLessLess: 0
+PenaltyBreakString: 10
+PenaltyExcessCharacter: 100
+PenaltyReturnTypeOnItsOwnLine: 60
+
+PointerAlignment: Right
+ReflowComments: false
+SortIncludes: false
+SortUsingDeclarations: false
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatementsExceptForEachMacros
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Cpp03
+TabWidth: 8
+UseTab: Always
+...

+ 9 - 24
examples/nr_micro_shell_commands.c

@@ -41,32 +41,22 @@
 void shell_ls_cmd(char argc, char *argv)
 {
 	unsigned int i = 0;
-	if (argc > 1)
-	{
-		if (!strcmp("cmd", &argv[argv[1]]))
-		{
-
-			for (i = 0; nr_shell.static_cmd[i].fp != NULL; i++)
-			{
-				shell_printf("%s",nr_shell.static_cmd[i].cmd);
+	if (argc > 1) {
+		if (!strcmp("cmd", &argv[argv[1]])) {
+			for (i = 0; nr_shell.static_cmd[i].fp != NULL; i++) {
+				shell_printf("%s", nr_shell.static_cmd[i].cmd);
 				shell_printf("\r\n");
 			}
-		}
-		else if (!strcmp("-v", &argv[argv[1]]))
-		{
+		} else if (!strcmp("-v", &argv[argv[1]])) {
 			shell_printf("ls version 1.0.\r\n");
-		}
-		else if (!strcmp("-h", &argv[argv[1]]))
-		{
+		} else if (!strcmp("-h", &argv[argv[1]])) {
 			shell_printf("useage: ls [options]\r\n");
 			shell_printf("options: \r\n");
 			shell_printf("\t -h \t: show help\r\n");
 			shell_printf("\t -v \t: show version\r\n");
 			shell_printf("\t cmd \t: show all commands\r\n");
 		}
-	}
-	else
-	{
+	} else {
 		shell_printf("ls need more arguments!\r\n");
 	}
 }
@@ -78,8 +68,7 @@ void shell_test_cmd(char argc, char *argv)
 {
 	unsigned int i;
 	shell_printf("test command:\r\n");
-	for (i = 0; i < argc; i++)
-	{
+	for (i = 0; i < argc; i++) {
 		shell_printf("paras %d: %s\r\n", i, &(argv[argv[i]]));
 	}
 }
@@ -88,11 +77,7 @@ void shell_test_cmd(char argc, char *argv)
 NR_SHELL_CMD_EXPORT(ls, shell_ls_cmd);
 NR_SHELL_CMD_EXPORT(test, shell_test_cmd);
 #else
-const static_cmd_st static_cmd[] =
-	{
-		{"ls", shell_ls_cmd},
-		{"test", shell_test_cmd},
-		{"\0", NULL}};
+const static_cmd_st static_cmd[] = { { "ls", shell_ls_cmd }, { "test", shell_test_cmd }, { "\0", NULL } };
 #endif
 
 /******************* (C) COPYRIGHT 2019 Nrush *****END OF FILE*****************/

+ 6 - 7
examples/simulator/simulator.c

@@ -3,11 +3,10 @@
 
 int main(void)
 {
-    char c;
-    shell_init();
-    while(1)
-    {
-        c = getchar();
-        shell(c);
-    }
+	char c;
+	shell_init();
+	while (1) {
+		c = getchar();
+		shell(c);
+	}
 }

+ 5 - 6
inc/ansi.h

@@ -35,19 +35,18 @@
 #define __ansi_h
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 /* Includes ------------------------------------------------------------------*/
 #include "ansi_port.h"
 #include "stdio.h"
 
-    char ansi_get_char(char x, ansi_st *ansi);
-    void ansi_init(ansi_st *ansi);
-    void ansi_clear_current_line(ansi_st *ansi);
+char ansi_get_char(char x, ansi_st *ansi);
+void ansi_init(ansi_st *ansi);
+void ansi_clear_current_line(ansi_st *ansi);
 
-    extern ansi_st nr_ansi;
+extern ansi_st nr_ansi;
 
 #ifdef __cplusplus
 }

+ 16 - 23
inc/ansi_def.h

@@ -35,14 +35,12 @@
  * 
  */
 
-
 /* Define to prevent recursive inclusion -------------------------------------*/
 #ifndef __ansi_def_h
 #define __ansi_def_h
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 /* Includes ------------------------------------------------------------------*/
@@ -51,24 +49,19 @@ extern "C"
 #define NR_ANSI_CTRL_MAX_LEN 20
 #define NR_ANSI_MAX_EX_DATA_NUM 1
 
-    enum
-    {
-        ANSI_ENABLE_SHOW,
-        ANSI_DISABLE_SHOW
-    };
+enum { ANSI_ENABLE_SHOW, ANSI_DISABLE_SHOW };
 
-    typedef struct nr_ansi_struct
-    {
-        short p;
-        unsigned int counter;
-        char current_line[NR_ANSI_LINE_SIZE];
+typedef struct nr_ansi_struct {
+	short p;
+	unsigned int counter;
+	char current_line[NR_ANSI_LINE_SIZE];
 
-        char combine_buf[NR_ANSI_CTRL_MAX_LEN];
-        char cmd_num;
-        char combine_state;
-    } ansi_st;
+	char combine_buf[NR_ANSI_CTRL_MAX_LEN];
+	char cmd_num;
+	char combine_state;
+} ansi_st;
 
-    typedef void (*ansi_fun_t)(ansi_st *);
+typedef void (*ansi_fun_t)(ansi_st *);
 
 #define NR_ANSI_SET_TEXT(cmd) ((const char *)"\033["##cmd##"m") /** the form of set text font */
 
@@ -112,13 +105,13 @@ extern "C"
 #define NR_ANSI_HIDE_COURSER "\033[?25l"
 #define NR_ANSI_SHOW_COURSER "\033[?25h"
 
-#define NR_ANSI_SET_FONT(cmd) ((const char *)"\033["#cmd"I")
-#define NR_ANSI_CLR_R_NCHAR(cmd) ((const char *)"\033["#cmd"X")
-#define NR_ANSI_CLR_R_MV_L_NCHAR(cmd) ((const char *)"\033["#cmd"P")
+#define NR_ANSI_SET_FONT(cmd) ((const char *)"\033[" #cmd "I")
+#define NR_ANSI_CLR_R_NCHAR(cmd) ((const char *)"\033[" #cmd "X")
+#define NR_ANSI_CLR_R_MV_L_NCHAR(cmd) ((const char *)"\033[" #cmd "P")
 
 /** move course code */
-#define NR_ANSI_MV_L_N(n) ((const char *)"\033["#n"D")
-#define NR_ANSI_MV_R_N(n) ((const char *)"\033["#n"C")
+#define NR_ANSI_MV_L_N(n) ((const char *)"\033[" #n "D")
+#define NR_ANSI_MV_R_N(n) ((const char *)"\033[" #n "C")
 
 #define NR_ANSI_NORMAL "0"
 #define NR_ANSI_SONG "1"

+ 13 - 14
inc/ansi_port.h

@@ -35,24 +35,23 @@
 #define __ansi_port_h
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-    /* Includes ------------------------------------------------------------------*/
+/* Includes ------------------------------------------------------------------*/
 #include "ansi_def.h"
 
-    void nr_ansi_ctrl_common_slover(ansi_st *ansi);
-    void nr_ansi_in_newline(ansi_st *ansi);
-    void nr_ansi_in_backspace(ansi_st *ansi);
-    void nr_ansi_in_up(ansi_st *ansi);
-    void nr_ansi_in_down(ansi_st *ansi);
-    void nr_ansi_in_left(ansi_st *ansi);
-    void nr_ansi_in_right(ansi_st *ansi);
-    void nr_ansi_in_tab(ansi_st *ansi);
-    void nr_ansi_in_enter(ansi_st *ansi);
-    void nr_ansi_in__(ansi_st *ansi);
-    void nr_ansi_common_char_slover(ansi_st *ansi, char x);
+void nr_ansi_ctrl_common_slover(ansi_st *ansi);
+void nr_ansi_in_newline(ansi_st *ansi);
+void nr_ansi_in_backspace(ansi_st *ansi);
+void nr_ansi_in_up(ansi_st *ansi);
+void nr_ansi_in_down(ansi_st *ansi);
+void nr_ansi_in_left(ansi_st *ansi);
+void nr_ansi_in_right(ansi_st *ansi);
+void nr_ansi_in_tab(ansi_st *ansi);
+void nr_ansi_in_enter(ansi_st *ansi);
+void nr_ansi_in__(ansi_st *ansi);
+void nr_ansi_common_char_slover(ansi_st *ansi, char x);
 
 /** special characters functions \b,\n,\r,\t*/
 #define nr_ansi_in_bsb_function nr_ansi_in_backspace

+ 54 - 63
inc/nr_micro_shell.h

@@ -35,11 +35,10 @@
 #define __nr_micro_shell_h
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-    /* Includes ------------------------------------------------------------------*/
+/* Includes ------------------------------------------------------------------*/
 #include "stdio.h"
 #include "nr_micro_shell_config.h"
 #include "ansi.h"
@@ -48,61 +47,58 @@ extern "C"
 #define shell_printf(fmt, args...) printf(fmt, ##args);
 #endif
 
-    typedef void (*shell_fun_t)(char, char *);
+typedef void (*shell_fun_t)(char, char *);
 
-    typedef struct static_cmd_function_struct
-    {
-        char cmd[NR_SHELL_CMD_NAME_MAX_LENGTH];
-        void (*fp)(char argc, char *argv);
-        char *description;
-    } static_cmd_st;
+typedef struct static_cmd_function_struct {
+	char cmd[NR_SHELL_CMD_NAME_MAX_LENGTH];
+	void (*fp)(char argc, char *argv);
+	char *description;
+} static_cmd_st;
 
-    typedef struct shell_history_queue_struct
-    {
-        unsigned short int fp;
-        unsigned short int rp;
+typedef struct shell_history_queue_struct {
+	unsigned short int fp;
+	unsigned short int rp;
 
-        unsigned short int len;
-        unsigned short int index;
+	unsigned short int len;
+	unsigned short int index;
 
-        unsigned short int store_front;
-        unsigned short int store_rear;
-        unsigned short int store_num;
+	unsigned short int store_front;
+	unsigned short int store_rear;
+	unsigned short int store_num;
 
-        char queue[NR_SHELL_MAX_CMD_HISTORY_NUM + 1];
-        char buf[NR_SHELL_CMD_HISTORY_BUF_LENGTH + 1];
+	char queue[NR_SHELL_MAX_CMD_HISTORY_NUM + 1];
+	char buf[NR_SHELL_CMD_HISTORY_BUF_LENGTH + 1];
 
-    } shell_his_queue_st;
+} shell_his_queue_st;
 
-    typedef struct nr_shell
-    {
-        char user_name[NR_SHELL_USER_NAME_MAX_LENGTH];
-        const static_cmd_st *static_cmd;
-        shell_his_queue_st cmd_his;
-    } shell_st;
+typedef struct nr_shell {
+	char user_name[NR_SHELL_USER_NAME_MAX_LENGTH];
+	const static_cmd_st *static_cmd;
+	shell_his_queue_st cmd_his;
+} shell_st;
 
-    void _shell_init(shell_st *shell);
-    void shell_parser(shell_st *shell, char *str);
-    char *shell_cmd_complete(shell_st *shell, char *str);
-    void shell_his_queue_init(shell_his_queue_st *queue);
-    void shell_his_queue_add_cmd(shell_his_queue_st *queue, char *str);
-    unsigned short int shell_his_queue_search_cmd(shell_his_queue_st *queue, char *str);
-    void shell_his_copy_queue_item(shell_his_queue_st *queue, unsigned short i, char *str_buf);
+void _shell_init(shell_st *shell);
+void shell_parser(shell_st *shell, char *str);
+char *shell_cmd_complete(shell_st *shell, char *str);
+void shell_his_queue_init(shell_his_queue_st *queue);
+void shell_his_queue_add_cmd(shell_his_queue_st *queue, char *str);
+unsigned short int shell_his_queue_search_cmd(shell_his_queue_st *queue, char *str);
+void shell_his_copy_queue_item(shell_his_queue_st *queue, unsigned short i, char *str_buf);
 
-    extern shell_st nr_shell;
+extern shell_st nr_shell;
 
-#define shell_init()            \
-    {                           \
-        ansi_init(&nr_ansi);    \
-        _shell_init(&nr_shell); \
-    }
+#define shell_init()                    \
+	{                               \
+		ansi_init(&nr_ansi);    \
+		_shell_init(&nr_shell); \
+	}
 
 #if NR_SHELL_END_OF_LINE == 1
 #define NR_SHELL_END_CHAR '\r'
 #else
 #define NR_SHELL_END_CHAR '\n'
 #endif
-	
+
 #if NR_SHELL_END_OF_LINE == 0
 #define NR_SHELL_NEXT_LINE "\n"
 #endif
@@ -110,39 +106,34 @@ extern "C"
 #if NR_SHELL_END_OF_LINE == 1
 #define NR_SHELL_NEXT_LINE "\r\n"
 #endif
-	
+
 #if NR_SHELL_END_OF_LINE == 2
 #define NR_SHELL_NEXT_LINE "\r\n"
 #endif
 
-#define shell(c)                                             \
-    {                                                        \
-        if (ansi_get_char(c, &nr_ansi) == NR_SHELL_END_CHAR) \
-        {                                                    \
-            shell_parser(&nr_shell, nr_ansi.current_line);   \
-            ansi_clear_current_line(&nr_ansi);               \
-        }                                                    \
-    }
+#define shell(c)                                                       \
+	{                                                              \
+		if (ansi_get_char(c, &nr_ansi) == NR_SHELL_END_CHAR) { \
+			shell_parser(&nr_shell, nr_ansi.current_line); \
+			ansi_clear_current_line(&nr_ansi);             \
+		}                                                      \
+	}
 
 #ifdef USING_RT_THREAD
-    int rt_nr_shell_system_init(void);
+int rt_nr_shell_system_init(void);
 #endif
 
 #define NR_USED __attribute__((used))
 #define NR_SECTION(x) __attribute__((section(".rodata.nr_shell_cmd" x)))
-#define NR_SHELL_CMD_EXPORT_START(cmd, func) \
-    NR_USED const static_cmd_st _nr_cmd_start_ NR_SECTION("0.end") = {#cmd, NULL}
-#define NR_SHELL_CMD_EXPORT(cmd, func) \
-    NR_USED const static_cmd_st _nr_cmd_##cmd NR_SECTION("1") = {#cmd, func}
-#define NR_SHELL_CMD_EXPORT_END(cmd, func) \
-    NR_USED const static_cmd_st _nr_cmd_end_ NR_SECTION("1.end") = {#cmd, NULL}
-
-    
+#define NR_SHELL_CMD_EXPORT_START(cmd, func) NR_USED const static_cmd_st _nr_cmd_start_ NR_SECTION("0.end") = { #cmd, NULL }
+#define NR_SHELL_CMD_EXPORT(cmd, func) NR_USED const static_cmd_st _nr_cmd_##cmd NR_SECTION("1") = { #cmd, func }
+#define NR_SHELL_CMD_EXPORT_END(cmd, func) NR_USED const static_cmd_st _nr_cmd_end_ NR_SECTION("1.end") = { #cmd, NULL }
+
 #ifdef NR_SHELL_USING_EXPORT_CMD
-	extern const static_cmd_st _nr_cmd_start_;
-#define nr_cmd_start_add (&_nr_cmd_start_+1)
+extern const static_cmd_st _nr_cmd_start_;
+#define nr_cmd_start_add (&_nr_cmd_start_ + 1)
 #else
-	extern const static_cmd_st static_cmd[];
+extern const static_cmd_st static_cmd[];
 #define nr_cmd_start_add (&static_cmd[0])
 #endif
 

+ 3 - 5
inc/nr_micro_shell_config.h

@@ -35,17 +35,15 @@
 #define __nr_micro_shell_config_h
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-    /* Includes ------------------------------------------------------------------*/
+/* Includes ------------------------------------------------------------------*/
 #ifndef NR_MICRO_SHELL_SIMULATOR
 #include <rtconfig.h>
 #include <rtthread.h>
 #endif
 
-
 #ifdef PKG_USING_NR_MICRO_SHELL
 
 /* use nr_micro_shell in rt_thread. */
@@ -151,4 +149,4 @@ The end of line.
 #endif
 
 #endif
-    /******************* (C) COPYRIGHT 2019 Ji Youzhou *****END OF FILE*****************/
+/******************* (C) COPYRIGHT 2019 Ji Youzhou *****END OF FILE*****************/

+ 65 - 105
src/ansi.c

@@ -36,133 +36,93 @@
 
 ansi_st nr_ansi;
 
-const char nr_ansi_in_cmd[] = {'m', 'I', 'A', 'B', 'C', 'D', 'X', 'K', 'M', 'P', 'J', '@', 'L', 'l', 'h', 'n', 'H', 's', 'u', '~','\0'};
-void (*const nr_ansi_in_cmd_fun[])(ansi_st *) =
-    {
-        nr_ansi_in_m_function,
-        nr_ansi_in_I_function,
-        nr_ansi_in_A_function,
-        nr_ansi_in_B_function,
-        nr_ansi_in_C_function,
-        nr_ansi_in_D_function,
-        nr_ansi_in_X_function,
-        nr_ansi_in_K_function,
-        nr_ansi_in_M_function,
-        nr_ansi_in_P_function,
-        nr_ansi_in_J_function,
-        nr_ansi_in_at_function,
-        nr_ansi_in_L_function,
-        nr_ansi_in_l_function,
-        nr_ansi_in_h_function,
-        nr_ansi_in_n_function,
-        nr_ansi_in_H_function,
-        nr_ansi_in_s_function,
-        nr_ansi_in_u_function,
-		nr_ansi_in___function,
-	};
-
-const char nr_ansi_in_special_symbol[] = {'\b', '\n', '\r', '\t', '\0'};
-void (*const nr_ansi_in_special_symbol_fun[])(ansi_st *) =
-    {
-        nr_ansi_in_bsb_function,
-        nr_ansi_in_bsn_function,
-        nr_ansi_in_bsr_function,
-        nr_ansi_in_bst_function};
+const char nr_ansi_in_cmd[] = { 'm', 'I', 'A', 'B', 'C', 'D', 'X', 'K', 'M', 'P', 'J',
+				'@', 'L', 'l', 'h', 'n', 'H', 's', 'u', '~', '\0' };
+void (*const nr_ansi_in_cmd_fun[])(ansi_st *) = {
+	nr_ansi_in_m_function, nr_ansi_in_I_function,  nr_ansi_in_A_function, nr_ansi_in_B_function, nr_ansi_in_C_function,
+	nr_ansi_in_D_function, nr_ansi_in_X_function,  nr_ansi_in_K_function, nr_ansi_in_M_function, nr_ansi_in_P_function,
+	nr_ansi_in_J_function, nr_ansi_in_at_function, nr_ansi_in_L_function, nr_ansi_in_l_function, nr_ansi_in_h_function,
+	nr_ansi_in_n_function, nr_ansi_in_H_function,  nr_ansi_in_s_function, nr_ansi_in_u_function, nr_ansi_in___function,
+};
+
+const char nr_ansi_in_special_symbol[] = { '\b', '\n', '\r', '\t', '\0' };
+void (*const nr_ansi_in_special_symbol_fun[])(ansi_st *) = { nr_ansi_in_bsb_function, nr_ansi_in_bsn_function,
+							     nr_ansi_in_bsr_function, nr_ansi_in_bst_function };
 
 int ansi_search_char(char x, const char *buf)
 {
-    int i = 0;
-    for (i = 0; (buf[i] != x) && (buf[i] != '\0'); i++)
-        ;
-    if (buf[i] != '\0')
-    {
-        return i;
-    }
-    else
-    {
-        return -1;
-    }
+	int i = 0;
+	for (i = 0; (buf[i] != x) && (buf[i] != '\0'); i++)
+		;
+	if (buf[i] != '\0') {
+		return i;
+	} else {
+		return -1;
+	}
 }
 
-enum
-{
-    ANSI_NO_CTRL_CHAR,
+enum {
+	ANSI_NO_CTRL_CHAR,
 	ANSI_MAYBE_CTRL_CHAR,
-    ANSI_WAIT_CTRL_CHAR_END,
+	ANSI_WAIT_CTRL_CHAR_END,
 };
 
 void ansi_init(ansi_st *ansi)
 {
-    ansi->counter = 0;
-    ansi->p = -1;
+	ansi->counter = 0;
+	ansi->p = -1;
 
-    ansi->current_line[ansi->counter] = '\0';
+	ansi->current_line[ansi->counter] = '\0';
 
-    ansi->cmd_num = 0;
-    ansi->combine_state = ANSI_NO_CTRL_CHAR;
+	ansi->cmd_num = 0;
+	ansi->combine_state = ANSI_NO_CTRL_CHAR;
 }
 
 void ansi_clear_current_line(ansi_st *ansi)
 {
-    ansi->counter = 0;
-    ansi->p = -1;
+	ansi->counter = 0;
+	ansi->p = -1;
 
-    ansi->current_line[ansi->counter] = '\0';
+	ansi->current_line[ansi->counter] = '\0';
 }
 
 char ansi_get_char(char x, ansi_st *ansi)
 {
-    int cmd_id = -1;
-
-    if (ansi->combine_state == ANSI_NO_CTRL_CHAR)
-    {
-        cmd_id = ansi_search_char(x, nr_ansi_in_special_symbol);
-        if (cmd_id >= 0)
-        {
-            if (nr_ansi_in_special_symbol_fun[cmd_id] != NULL)
-            {
-                nr_ansi_in_special_symbol_fun[cmd_id](ansi);
-            }
-        }
-        else if (x == '\033')
-        {
-            ansi->combine_state = ANSI_WAIT_CTRL_CHAR_END;
-            ansi->combine_buf[ansi->cmd_num] = x;
+	int cmd_id = -1;
+
+	if (ansi->combine_state == ANSI_NO_CTRL_CHAR) {
+		cmd_id = ansi_search_char(x, nr_ansi_in_special_symbol);
+		if (cmd_id >= 0) {
+			if (nr_ansi_in_special_symbol_fun[cmd_id] != NULL) {
+				nr_ansi_in_special_symbol_fun[cmd_id](ansi);
+			}
+		} else if (x == '\033') {
+			ansi->combine_state = ANSI_WAIT_CTRL_CHAR_END;
+			ansi->combine_buf[ansi->cmd_num] = x;
 			ansi->cmd_num++;
-        }
-        else
-        {
-			nr_ansi_common_char_slover(ansi,x);
-        }
-    }
-    else if (ansi->combine_state == ANSI_WAIT_CTRL_CHAR_END)
-    {
-        ansi->combine_buf[ansi->cmd_num] = x;
-
-        if (('a' <= x && 'z' >= x) || ('A' <= x && 'Z' >= x) || x== '~')
-        {
-            cmd_id = ansi_search_char(x, nr_ansi_in_cmd);
-            nr_ansi_in_cmd_fun[cmd_id](ansi);
-
-            ansi->cmd_num = 0;
-            ansi->combine_state = ANSI_NO_CTRL_CHAR;
-        }
-        else if (ansi->cmd_num > 18)
-        {
-            ansi->cmd_num = 0;
-            ansi->combine_state = ANSI_NO_CTRL_CHAR;
-        }
-        else
-        {
-            ansi->cmd_num++;
-        }
-    }
-    else
-    {
-        ansi->combine_state = ANSI_NO_CTRL_CHAR;
-    }
-
-    return x;
+		} else {
+			nr_ansi_common_char_slover(ansi, x);
+		}
+	} else if (ansi->combine_state == ANSI_WAIT_CTRL_CHAR_END) {
+		ansi->combine_buf[ansi->cmd_num] = x;
+
+		if (('a' <= x && 'z' >= x) || ('A' <= x && 'Z' >= x) || x == '~') {
+			cmd_id = ansi_search_char(x, nr_ansi_in_cmd);
+			nr_ansi_in_cmd_fun[cmd_id](ansi);
+
+			ansi->cmd_num = 0;
+			ansi->combine_state = ANSI_NO_CTRL_CHAR;
+		} else if (ansi->cmd_num > 18) {
+			ansi->cmd_num = 0;
+			ansi->combine_state = ANSI_NO_CTRL_CHAR;
+		} else {
+			ansi->cmd_num++;
+		}
+	} else {
+		ansi->combine_state = ANSI_NO_CTRL_CHAR;
+	}
+
+	return x;
 }
 
 /******************* (C) COPYRIGHT 2019 Ji Youzhou *****END OF FILE*****************/

+ 115 - 140
src/ansi_port.c

@@ -40,60 +40,51 @@
 // show string
 void ansi_show_str(char *str, unsigned int len)
 {
-    unsigned int i;
-    for (i = 0; i < len; i++)
-    {
-        ansi_show_char(str[i]);
-    }
+	unsigned int i;
+	for (i = 0; i < len; i++) {
+		ansi_show_char(str[i]);
+	}
 }
 
-void nr_ansi_common_char_slover(ansi_st *ansi,char x)
+void nr_ansi_common_char_slover(ansi_st *ansi, char x)
 {
 	unsigned int i;
-	
-	if (ansi->counter < NR_ANSI_LINE_SIZE - 2)
-    {
-        if (ansi->p < ansi->counter)
-        {
-            for (i = ansi->counter; i > ansi->p; i--)
-            {
-                ansi->current_line[i] = ansi->current_line[i - 1];
-            }
-        }
-
-        ansi->p++;
-        ansi->counter++;
-
-        ansi->current_line[ansi->p] = x;
-
-        ansi->current_line[ansi->counter] = '\0';
-		if(ansi->p+1 < ansi->counter)
-		{
+
+	if (ansi->counter < NR_ANSI_LINE_SIZE - 2) {
+		if (ansi->p < ansi->counter) {
+			for (i = ansi->counter; i > ansi->p; i--) {
+				ansi->current_line[i] = ansi->current_line[i - 1];
+			}
+		}
+
+		ansi->p++;
+		ansi->counter++;
+
+		ansi->current_line[ansi->p] = x;
+
+		ansi->current_line[ansi->counter] = '\0';
+		if (ansi->p + 1 < ansi->counter) {
 			shell_printf("\033[1@");
 		}
 
-        #ifndef NR_MICRO_SHELL_SIMULATOR	
-        ansi_show_char(x);
-        #endif	
-    }
-    else
-    {
-        ansi->counter = NR_ANSI_LINE_SIZE - 3;
-        if (ansi->p >= ansi->counter)
-        {
-            ansi->p = ansi->counter - 1;
-        }
-        ansi->current_line[ansi->counter] = '\0';
-    }
+#ifndef NR_MICRO_SHELL_SIMULATOR
+		ansi_show_char(x);
+#endif
+	} else {
+		ansi->counter = NR_ANSI_LINE_SIZE - 3;
+		if (ansi->p >= ansi->counter) {
+			ansi->p = ansi->counter - 1;
+		}
+		ansi->current_line[ansi->counter] = '\0';
+	}
 }
 
 void nr_ansi_ctrl_common_slover(ansi_st *ansi)
 {
-    unsigned int i;
-    for (i = 0; i < ansi->cmd_num; i++)
-    {
-        ansi_show_char((*(ansi->combine_buf + i)));
-    }
+	unsigned int i;
+	for (i = 0; i < ansi->cmd_num; i++) {
+		ansi_show_char((*(ansi->combine_buf + i)));
+	}
 }
 
 // line break '\r' processing
@@ -101,13 +92,13 @@ void nr_ansi_in_enter(ansi_st *ansi)
 {
 #if NR_SHELL_END_OF_LINE == 1
 	ansi->p = -1;
-    ansi->counter = 0;
+	ansi->counter = 0;
 
-    nr_shell.cmd_his.index = nr_shell.cmd_his.len;
-    ansi_show_char('\r');
-    ansi_show_char('\n');
+	nr_shell.cmd_his.index = nr_shell.cmd_his.len;
+	ansi_show_char('\r');
+	ansi_show_char('\n');
 #else
-    ansi_show_char('\r');
+	ansi_show_char('\r');
 #endif
 }
 
@@ -115,15 +106,15 @@ void nr_ansi_in_enter(ansi_st *ansi)
 void nr_ansi_in_newline(ansi_st *ansi)
 {
 	ansi->p = -1;
-    ansi->counter = 0;
+	ansi->counter = 0;
 
-    nr_shell.cmd_his.index = nr_shell.cmd_his.len;
-#ifndef NR_MICRO_SHELL_SIMULATOR	
+	nr_shell.cmd_his.index = nr_shell.cmd_his.len;
+#ifndef NR_MICRO_SHELL_SIMULATOR
 #if NR_SHELL_END_OF_LINE != 1
-    ansi_show_char('\r');
-    ansi_show_char('\n');
+	ansi_show_char('\r');
+	ansi_show_char('\n');
 #else
-    ansi_show_char('\n');
+	ansi_show_char('\n');
 #endif
 #endif
 }
@@ -131,153 +122,137 @@ void nr_ansi_in_newline(ansi_st *ansi)
 // Backspace '\b' processing
 void nr_ansi_in_backspace(ansi_st *ansi)
 {
-    unsigned int i;
+	unsigned int i;
 
-    if (ansi->p >= 0)
-    {
-        for (i = ansi->p; i < ansi->counter; i++)
-        {
-            ansi->current_line[i] = ansi->current_line[i + 1];
-        }
+	if (ansi->p >= 0) {
+		for (i = ansi->p; i < ansi->counter; i++) {
+			ansi->current_line[i] = ansi->current_line[i + 1];
+		}
 
-        ansi->p--;
-        ansi->counter--;
+		ansi->p--;
+		ansi->counter--;
 
-        ansi_show_char('\b');
+		ansi_show_char('\b');
 #if NR_SHLL_FULL_ANSI == 1
-        shell_printf(NR_ANSI_CLR_R_MV_L_NCHAR(1));
+		shell_printf(NR_ANSI_CLR_R_MV_L_NCHAR(1));
 #endif
-    }
+	}
 }
 
 // up key processing
 void nr_ansi_in_up(ansi_st *ansi)
 {
-    if (nr_shell.cmd_his.index > 0)
-    {
+	if (nr_shell.cmd_his.index > 0) {
 #if NR_SHLL_FULL_ANSI == 1
-        shell_printf("\033[%dD", ansi->p + 1);
-        shell_printf(NR_ANSI_CLEAR_RIGHT);
+		shell_printf("\033[%dD", ansi->p + 1);
+		shell_printf(NR_ANSI_CLEAR_RIGHT);
 #else
-        shell_printf("\r\n");
-        shell_printf(nr_shell.user_name);
+		shell_printf("\r\n");
+		shell_printf(nr_shell.user_name);
 #endif
 
-        shell_his_copy_queue_item(&nr_shell.cmd_his, nr_shell.cmd_his.index, ansi->current_line);
-        ansi->counter = strlen(ansi->current_line);
-        ansi->p = ansi->counter - 1;
+		shell_his_copy_queue_item(&nr_shell.cmd_his, nr_shell.cmd_his.index, ansi->current_line);
+		ansi->counter = strlen(ansi->current_line);
+		ansi->p = ansi->counter - 1;
+
+		ansi_show_str(ansi->current_line, ansi->counter);
 
-        ansi_show_str(ansi->current_line, ansi->counter);
-		
 		nr_shell.cmd_his.index--;
-        nr_shell.cmd_his.index = (nr_shell.cmd_his.index == 0) ? nr_shell.cmd_his.len : nr_shell.cmd_his.index;
-    }
+		nr_shell.cmd_his.index = (nr_shell.cmd_his.index == 0) ? nr_shell.cmd_his.len : nr_shell.cmd_his.index;
+	}
 }
 
 // down key processing
 void nr_ansi_in_down(ansi_st *ansi)
 {
-    if (nr_shell.cmd_his.index > 0)
-    {
+	if (nr_shell.cmd_his.index > 0) {
 #if NR_SHLL_FULL_ANSI == 1
-        shell_printf("\033[%dD", ansi->p + 1);
-        shell_printf(NR_ANSI_CLEAR_RIGHT);
+		shell_printf("\033[%dD", ansi->p + 1);
+		shell_printf(NR_ANSI_CLEAR_RIGHT);
 #else
-        shell_printf("\r\n");
-        shell_printf(nr_shell.user_name);
+		shell_printf("\r\n");
+		shell_printf(nr_shell.user_name);
 #endif
 
-        shell_his_copy_queue_item(&nr_shell.cmd_his, nr_shell.cmd_his.index, ansi->current_line);
-        ansi->counter = strlen(ansi->current_line);
-        ansi->p = ansi->counter - 1;
+		shell_his_copy_queue_item(&nr_shell.cmd_his, nr_shell.cmd_his.index, ansi->current_line);
+		ansi->counter = strlen(ansi->current_line);
+		ansi->p = ansi->counter - 1;
+
+		ansi_show_str(ansi->current_line, ansi->counter);
 
-        ansi_show_str(ansi->current_line, ansi->counter);
-		
 		nr_shell.cmd_his.index++;
-        nr_shell.cmd_his.index = (nr_shell.cmd_his.index > nr_shell.cmd_his.len) ? 1 : nr_shell.cmd_his.index;
-    }
+		nr_shell.cmd_his.index = (nr_shell.cmd_his.index > nr_shell.cmd_his.len) ? 1 : nr_shell.cmd_his.index;
+	}
 }
 
 // left key <- processing
 void nr_ansi_in_left(ansi_st *ansi)
 {
-    if (ansi->p > -1)
-    {
-        ansi->p--;
+	if (ansi->p > -1) {
+		ansi->p--;
 #if NR_SHLL_FULL_ANSI == 1
-        shell_printf("\033[1D");
+		shell_printf("\033[1D");
 #endif
-    }
+	}
 }
 
 // right key <- processing
 void nr_ansi_in_right(ansi_st *ansi)
 {
-    if (ansi->p < (int)(ansi->counter - 1))
-    {
-        ansi->p++;
+	if (ansi->p < (int)(ansi->counter - 1)) {
+		ansi->p++;
 #if NR_SHLL_FULL_ANSI == 1
-        shell_printf("\033[1C");
+		shell_printf("\033[1C");
 #endif
-    }
+	}
 }
 
 // tab key processing
 void nr_ansi_in_tab(ansi_st *ansi)
 {
-    unsigned char i;
-    char *cmd;
-    cmd = shell_cmd_complete(&nr_shell, ansi->current_line);
-    if (cmd != NULL)
-    {
-
-        if (ansi->counter == 0)
-        {
-            shell_printf("\r\n");
-            for (i = 0; nr_shell.static_cmd[i].fp != NULL; i++)
-            {
-                shell_printf("%s",nr_shell.static_cmd[i].cmd);
-                shell_printf("\r\n");
-            }
-
-            shell_printf("%s",nr_shell.user_name);
-        }
-        else
-        {
+	unsigned char i;
+	char *cmd;
+	cmd = shell_cmd_complete(&nr_shell, ansi->current_line);
+	if (cmd != NULL) {
+		if (ansi->counter == 0) {
+			shell_printf("\r\n");
+			for (i = 0; nr_shell.static_cmd[i].fp != NULL; i++) {
+				shell_printf("%s", nr_shell.static_cmd[i].cmd);
+				shell_printf("\r\n");
+			}
+
+			shell_printf("%s", nr_shell.user_name);
+		} else {
 #if NR_SHLL_FULL_ANSI == 1
-            shell_printf("\033[%dD", ansi->p + 1);
-            shell_printf(NR_ANSI_CLEAR_RIGHT);
+			shell_printf("\033[%dD", ansi->p + 1);
+			shell_printf(NR_ANSI_CLEAR_RIGHT);
 #else
-            shell_printf("\r\n");
-            shell_printf("%s",nr_shell.user_name);
+			shell_printf("\r\n");
+			shell_printf("%s", nr_shell.user_name);
 #endif
-            ansi->counter = strlen(cmd);
-            ansi->p = ansi->counter - 1;
-            strcpy(ansi->current_line, cmd);
+			ansi->counter = strlen(cmd);
+			ansi->p = ansi->counter - 1;
+			strcpy(ansi->current_line, cmd);
 
-            ansi_show_str(ansi->current_line, ansi->counter);
-        }
-    }
+			ansi_show_str(ansi->current_line, ansi->counter);
+		}
+	}
 }
 
 /*ansi delete*/
 void nr_ansi_in__(ansi_st *ansi)
 {
 	unsigned int i;
-	if(ansi->combine_buf[2] == '3')
-	{
-		for(i = ansi->p+1;i<ansi->counter;i++)
-		{
-			ansi->current_line[i] = ansi->current_line[i+1];
+	if (ansi->combine_buf[2] == '3') {
+		for (i = ansi->p + 1; i < ansi->counter; i++) {
+			ansi->current_line[i] = ansi->current_line[i + 1];
 		}
-		if((short)ansi->counter > ansi->p)
-		{
+		if ((short)ansi->counter > ansi->p) {
 			ansi->counter--;
 #if NR_SHLL_FULL_ANSI == 1
-			ansi_show_str("\033[1P",4);
+			ansi_show_str("\033[1P", 4);
 #endif
 		}
-		
 	}
 }
 

+ 53 - 104
src/nr_micro_shell.c

@@ -35,14 +35,12 @@
 #include <string.h>
 #include <ctype.h>
 
+NR_SHELL_CMD_EXPORT_START(0, NULL);
+NR_SHELL_CMD_EXPORT_END(n, NULL);
 
-NR_SHELL_CMD_EXPORT_START(0,NULL);
-NR_SHELL_CMD_EXPORT_END(n,NULL);
-
-shell_st nr_shell =
-    {
-        .user_name = NR_SHELL_USER_NAME,
-        .static_cmd = nr_cmd_start_add,
+shell_st nr_shell = {
+	.user_name = NR_SHELL_USER_NAME,
+	.static_cmd = nr_cmd_start_add,
 };
 
 static char *nr_shell_strtok(char *string_org, const char *demial)
@@ -53,49 +51,37 @@ static char *nr_shell_strtok(char *string_org, const char *demial)
 	unsigned char map[32];
 	int count;
 
-	for (count = 0; count < 32; count++)
-	{
+	for (count = 0; count < 32; count++) {
 		map[count] = 0;
 	}
-	do
-	{
+	do {
 		map[*ctrl >> 3] |= (1 << (*ctrl & 7));
 	} while (*ctrl++);
-	if (string_org)
-	{
+	if (string_org) {
 		str = (unsigned char *)string_org;
-	}
-	else
-	{
+	} else {
 		str = last;
 	}
-	while ((map[*str >> 3] & (1 << (*str & 7))) && *str)
-	{
+	while ((map[*str >> 3] & (1 << (*str & 7))) && *str) {
 		str++;
 	}
 	string_org = (char *)str;
-	for (; *str; str++)
-	{
-		if (map[*str >> 3] & (1 << (*str & 7)))
-		{
+	for (; *str; str++) {
+		if (map[*str >> 3] & (1 << (*str & 7))) {
 			*str++ = '\0';
 			break;
 		}
 	}
 	last = str;
-	if (string_org == (char *)str)
-	{
+	if (string_org == (char *)str) {
 		return NULL;
-	}
-	else
-	{
+	} else {
 		return string_org;
 	}
 }
 
 void _shell_init(shell_st *shell)
 {
-
 #ifdef NR_SHELL_SHOW_LOG
 	shell_printf(" _   _ ____    __  __ _                  ____  _          _ _ \r\n");
 	shell_printf("| \\ | |  _ \\  |  \\/  (_) ___ _ __ ___   / ___|| |__   ___| | |\r\n");
@@ -105,7 +91,7 @@ void _shell_init(shell_st *shell)
 	shell_printf("                                                              \r\n");
 #endif
 
-	shell_printf("%s",shell->user_name);
+	shell_printf("%s", shell->user_name);
 	shell_his_queue_init(&shell->cmd_his);
 	shell_his_queue_add_cmd(&shell->cmd_his, "ls cmd");
 	shell->cmd_his.index = 1;
@@ -114,10 +100,8 @@ void _shell_init(shell_st *shell)
 shell_fun_t shell_search_cmd(shell_st *shell, char *str)
 {
 	unsigned int i = 0;
-	while (shell->static_cmd[i].fp != NULL)
-	{
-		if (!strcmp(str, shell->static_cmd[i].cmd))
-		{
+	while (shell->static_cmd[i].fp != NULL) {
+		if (!strcmp(str, shell->static_cmd[i].cmd)) {
 			return shell->static_cmd[i].fp;
 		}
 		i++;
@@ -134,38 +118,31 @@ void shell_parser(shell_st *shell, char *str)
 	shell_fun_t fp;
 	char index = NR_SHELL_CMD_PARAS_MAX_NUM;
 
-	if (shell_his_queue_search_cmd(&shell->cmd_his, str) == 0 && str[0] != '\0')
-	{
+	if (shell_his_queue_search_cmd(&shell->cmd_his, str) == 0 && str[0] != '\0') {
 		shell_his_queue_add_cmd(&shell->cmd_his, str);
 	}
 
-	if (strlen(str) > NR_SHELL_CMD_LINE_MAX_LENGTH)
-	{
-		shell_printf("this command is too long."NR_SHELL_NEXT_LINE);
-		shell_printf("%s",shell->user_name);
+	if (strlen(str) > NR_SHELL_CMD_LINE_MAX_LENGTH) {
+		shell_printf("this command is too long." NR_SHELL_NEXT_LINE);
+		shell_printf("%s", shell->user_name);
 		return;
 	}
 
 	token = nr_shell_strtok(token, " ");
 	fp = shell_search_cmd(shell, str);
 
-	if (fp == NULL)
-	{
-		if (isalpha(str[0]))
-		{
-			shell_printf("no command named: %s"NR_SHELL_NEXT_LINE, token);
+	if (fp == NULL) {
+		if (isalpha(str[0])) {
+			shell_printf("no command named: %s" NR_SHELL_NEXT_LINE, token);
 		}
-	}
-	else
-	{
+	} else {
 		argv[argc] = index;
 		strcpy(argv + index, str);
 		index += strlen(str) + 1;
 		argc++;
 
 		token = nr_shell_strtok(NULL, " ");
-		while (token != NULL)
-		{
+		while (token != NULL) {
 			argv[argc] = index;
 			strcpy(argv + index, token);
 			index += strlen(token) + 1;
@@ -174,12 +151,11 @@ void shell_parser(shell_st *shell, char *str)
 		}
 	}
 
-	if (fp != NULL)
-	{
+	if (fp != NULL) {
 		fp(argc, argv);
 	}
 
-	shell_printf("%s",shell->user_name);
+	shell_printf("%s", shell->user_name);
 }
 
 char *shell_cmd_complete(shell_st *shell, char *str)
@@ -189,16 +165,13 @@ char *shell_cmd_complete(shell_st *shell, char *str)
 	char *best_matched = NULL;
 	unsigned char min_position = 255;
 
-	for (i = 0; shell->static_cmd[i].cmd[0] != '\0'; i++)
-	{
+	for (i = 0; shell->static_cmd[i].cmd[0] != '\0'; i++) {
 		temp = NULL;
 		temp = strstr(shell->static_cmd[i].cmd, str);
-		if (temp != NULL && ((unsigned long)temp - (unsigned long)(&shell->static_cmd[i]) < min_position))
-		{
+		if (temp != NULL && ((unsigned long)temp - (unsigned long)(&shell->static_cmd[i]) < min_position)) {
 			min_position = (unsigned long)temp - (unsigned long)(&shell->static_cmd[i]);
 			best_matched = (char *)&shell->static_cmd[i];
-			if (min_position == 0)
-			{
+			if (min_position == 0) {
 				break;
 			}
 		}
@@ -225,24 +198,18 @@ void shell_his_queue_add_cmd(shell_his_queue_st *queue, char *str)
 
 	str_len = strlen(str);
 
-	if (str_len > NR_SHELL_CMD_HISTORY_BUF_LENGTH)
-	{
+	if (str_len > NR_SHELL_CMD_HISTORY_BUF_LENGTH) {
 		return;
 	}
 
-	while (str_len > (NR_SHELL_CMD_HISTORY_BUF_LENGTH - queue->store_num) || queue->len == NR_SHELL_MAX_CMD_HISTORY_NUM)
-	{
-
+	while (str_len > (NR_SHELL_CMD_HISTORY_BUF_LENGTH - queue->store_num) || queue->len == NR_SHELL_MAX_CMD_HISTORY_NUM) {
 		queue->fp++;
 		queue->fp = (queue->fp > NR_SHELL_MAX_CMD_HISTORY_NUM) ? 0 : queue->fp;
 		queue->len--;
 
-		if (queue->store_front <= queue->queue[queue->fp])
-		{
+		if (queue->store_front <= queue->queue[queue->fp]) {
 			queue->store_num -= queue->queue[queue->fp] - queue->store_front;
-		}
-		else
-		{
+		} else {
 			queue->store_num -= queue->queue[queue->fp] + NR_SHELL_CMD_HISTORY_BUF_LENGTH - queue->store_front + 1;
 		}
 
@@ -254,8 +221,7 @@ void shell_his_queue_add_cmd(shell_his_queue_st *queue, char *str)
 	queue->rp = (queue->rp > NR_SHELL_MAX_CMD_HISTORY_NUM) ? 0 : queue->rp;
 	queue->len++;
 
-	for (i = 0; i < str_len; i++)
-	{
+	for (i = 0; i < str_len; i++) {
 		queue->buf[queue->store_rear] = str[i];
 		queue->store_rear++;
 		queue->store_rear = (queue->store_rear > NR_SHELL_CMD_HISTORY_BUF_LENGTH) ? 0 : queue->store_rear;
@@ -275,37 +241,27 @@ unsigned short int shell_his_queue_search_cmd(shell_his_queue_st *queue, char *s
 	unsigned short int matched_id = 0;
 	unsigned short int buf_index;
 
-	if (queue->len == 0)
-	{
+	if (queue->len == 0) {
 		return matched_id;
-	}
-	else
-	{
+	} else {
 		str_len = strlen(str);
-		for (i = 0; i < queue->len; i++)
-		{
+		for (i = 0; i < queue->len; i++) {
 			start = queue->queue[index_temp];
 			index_temp++;
 			index_temp = (index_temp > NR_SHELL_MAX_CMD_HISTORY_NUM) ? 0 : index_temp;
 			end = queue->queue[index_temp];
 
-			if (start <= end)
-			{
+			if (start <= end) {
 				cmd_len = end - start;
-			}
-			else
-			{
+			} else {
 				cmd_len = NR_SHELL_CMD_HISTORY_BUF_LENGTH + 1 - start + end;
 			}
 
-			if (cmd_len == str_len)
-			{
+			if (cmd_len == str_len) {
 				matched_id = i + 1;
 				buf_index = start;
-				for (j = 0; j < str_len; j++)
-				{
-					if (queue->buf[buf_index] != str[j])
-					{
+				for (j = 0; j < str_len; j++) {
+					if (queue->buf[buf_index] != str[j]) {
 						matched_id = 0;
 						break;
 					}
@@ -314,8 +270,7 @@ unsigned short int shell_his_queue_search_cmd(shell_his_queue_st *queue, char *s
 					buf_index = (buf_index > NR_SHELL_CMD_HISTORY_BUF_LENGTH) ? 0 : buf_index;
 				}
 
-				if (matched_id != 0)
-				{
+				if (matched_id != 0) {
 					return matched_id;
 				}
 			}
@@ -332,34 +287,28 @@ void shell_his_copy_queue_item(shell_his_queue_st *queue, unsigned short i, char
 	unsigned short end;
 	unsigned short j;
 
-	if (i <= queue->len)
-	{
+	if (i <= queue->len) {
 		index_temp = queue->fp + i - 1;
-		index_temp = (index_temp > NR_SHELL_MAX_CMD_HISTORY_NUM) ? (index_temp - NR_SHELL_MAX_CMD_HISTORY_NUM - 1) : index_temp;
+		index_temp = (index_temp > NR_SHELL_MAX_CMD_HISTORY_NUM) ? (index_temp - NR_SHELL_MAX_CMD_HISTORY_NUM - 1) :
+									   index_temp;
 
 		start = queue->queue[index_temp];
 		index_temp++;
 		index_temp = (index_temp > NR_SHELL_MAX_CMD_HISTORY_NUM) ? 0 : index_temp;
 		end = queue->queue[index_temp];
 
-		if (start < end)
-		{
-			for (j = start; j < end; j++)
-			{
+		if (start < end) {
+			for (j = start; j < end; j++) {
 				str_buf[j - start] = queue->buf[j];
 			}
 
 			str_buf[j - start] = '\0';
-		}
-		else
-		{
-			for (j = start; j < NR_SHELL_CMD_HISTORY_BUF_LENGTH + 1; j++)
-			{
+		} else {
+			for (j = start; j < NR_SHELL_CMD_HISTORY_BUF_LENGTH + 1; j++) {
 				str_buf[j - start] = queue->buf[j];
 			}
 
-			for (j = 0; j < end; j++)
-			{
+			for (j = 0; j < end; j++) {
 				str_buf[j + NR_SHELL_CMD_HISTORY_BUF_LENGTH + 1 - start] = queue->buf[j];
 			}