pax_global_header00006660000000000000000000000064143407213650014517gustar00rootroot0000000000000052 comment=5e1d2eccffae9ef5ddc6311dc01b9647af620994 uncrustify-uncrustify-0.76.0/000077500000000000000000000000001434072136500162355ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/.editorconfig000066400000000000000000000000551434072136500207120ustar00rootroot00000000000000[src/*] indent_style = space indent_size = 3 uncrustify-uncrustify-0.76.0/.gitattributes000066400000000000000000000004501434072136500211270ustar00rootroot00000000000000* text=auto tests/** -text src/** eol=lf scripts/** eol=lf tests/**/*.cfg eol=lf tests/*.test eol=lf *.sh eol=lf *.bat eol=crlfuncrustify-uncrustify-0.76.0/.github/000077500000000000000000000000001434072136500175755ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/.github/ISSUE_TEMPLATE000066400000000000000000000025621434072136500217100ustar00rootroot00000000000000[//]: # " If the issue is connected to existing Uncrustify options please, if possible, add the" [//]: # " following information to ease up the process:" [//]: # " • a link to a debug file:" [//]: # " generated with: 'uncrustify -p debug.txt -c pathToUsedConfig.cfg -f toBeFormatedFile.cpp' " [//]: # " Example: [debug.txt](https://linkToTheFile)" [//]: # " Example hosters for debug files: pastebin.com, gist.github.com, ..." [//]: # " The used config file is included in the debug file and does not need to be included here." [//]: # [//]: # " • include a small but complete test file that will be uncrustifyed" [//]: # " • include the generated results" [//]: # " • include the expected results" [//]: # [//]: # " ✋ please add a line containing ``` above and below of each of those three code sections" [//]: # [//]: # " • include the current version of your Uncrustify executable" [//]: # " printout via 'uncrustify -v'" [//]: # " Example: current version: uncrustify 0.63" [//]: # " or if possible additionally with the git sha of the commit" [//]: # " current version: uncrustify 0.63 dc7b412" [//]: # [//]: # " • if possible include a version that worked" [//]: # " Example: working version: uncrustify 0.63" [//]: # " or" [//]: # " working version: uncrustify 0.63 2a5e88f" uncrustify-uncrustify-0.76.0/.github/workflows/000077500000000000000000000000001434072136500216325ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/.github/workflows/uncrustify_test.yml000066400000000000000000000016071434072136500256330ustar00rootroot00000000000000name: uncrustify_test on: [push, pull_request] # Cancel any in-progress CI runs for a PR if it is updated concurrency: group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.head_ref || github.sha }} cancel-in-progress: true jobs: uncrustify: name: ${{ matrix.build_type }} - ${{ matrix.generator }} strategy: matrix: include: - build_type: Debug generator: Ninja - build_type: Release generator: Unix Makefiles runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: seanmiddleditch/gha-setup-ninja@master - name: cmake-part-and-tests env: BADGE: linux run: | cmake -B build -G "${{ matrix.generator }}" -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} cmake --build build cd build ../scripts/run_ctest.py uncrustify-uncrustify-0.76.0/.gitignore000066400000000000000000000016521434072136500202310ustar00rootroot00000000000000# "Default" build tree /build/ # PyCharm help directory venv/ # PyCharm .run directory .run/ # Compiled Python code *.pyc # Testing framework (if run_tests.py is run from the source tree) results/ results_2/ # Static analysis and code coverage /tests/pclint/ /cov-int gcov_test/ # SlickEdit workspace history and tag files *.vtg *.vpwh* # for projects that use Waf for building: http://code.google.com/p/waf/ .waf-* .lock* waf* # KDevelop *.kdev4 .kdev4/ # XCode *.xcodeproj/*.pbxuser *.xcodeproj/*.perspectivev3 *.xcodeproj/*.mode1v3 *.xcodeproj/*.tm_build_errors *.tmproj *.xcworkspace xcuserdata # Sublime *.sublime-workspace # Eclipse Configuration .cproject .project .settings # backup files # texteditor (kate, etc.) *~ # git mergetool.keepBackup or KDiff3 *.orig # uncrustified files *.uncrustify # CLion .idea/ cmake-build-*/ # Vim *.swp # Clangd /.cache/clangd/ # Compilation database compile_commands.json uncrustify-uncrustify-0.76.0/.travis.yml000066400000000000000000000122311434072136500203450ustar00rootroot00000000000000language: cpp sudo: false matrix: include: # bionic 18 # 2 - os: linux dist: Bionic env: BADGE=linux BUILD_TYPE=debug addons: apt: update: true packages: - ninja-build # Clang 4.0 address sanitizer # 3 - os: linux dist: Bionic env: BADGE=linux BUILD_TYPE=asan C_COMPILER=clang-4.0 CXX_COMPILER=clang++-4.0 addons: apt: sources: - ubuntu-toolchain-r-test - llvm-toolchain-precise-4.0 packages: - clang-4.0 # GCC 6 # 4 - os: linux dist: Bionic env: BADGE=linux C_COMPILER=gcc-6 CXX_COMPILER=g++-6 addons: apt: update: true sources: - ubuntu-toolchain-r-test packages: - gcc-6 - g++-6 - ninja-build # OSX # 5 - os: osx env: BADGE=osx BUILD_TYPE=debug # 6 - os: osx env: BADGE=osx BUILD_TYPE=release # focal 20 # 7 - os: linux dist: focal env: BADGE=linux BUILD_TYPE=debug addons: apt: update: true packages: - ninja-build # 8 - os: linux dist: focal env: BADGE=linux BUILD_TYPE=release addons: apt: update: true packages: - ninja-build # 9 - os: linux dist: focal env: BADGE=linux BUILD_TYPE=release NO_MACRO_VARARG=1 ### Clang address sanitizer ### 10 ##- os: linux ## dist: focal ## env: BADGE=linux BUILD_TYPE=asan C_COMPILER=clang-12.0 CXX_COMPILER=clang++-12.0 ## addons: ## apt: ## sources: ## - ubuntu-toolchain-r-test ## - llvm-toolchain-precise-12.0 ## packages: ## - clang-12.0 # mingw-w64 Win64 cross-compile # 11 - os: linux dist: focal env: BADGE=linux BUILD_TYPE=cross C_COMPILER=x86_64-w64-mingw32-gcc CXX_COMPILER=x86_64-w64-mingw32-g++ addons: apt: packages: - mingw-w64 - binutils-mingw-w64 - binutils-mingw-w64-i686 - binutils-mingw-w64-x86-64 - gcc-mingw-w64 - gcc-mingw-w64-i686 - gcc-mingw-w64-x86-64 - g++-mingw-w64 - g++-mingw-w64-i686 - g++-mingw-w64-x86-64 # 12 - os: linux dist: focal env: BUILD_TYPE=coverage COVERALLS_TOKEN="Dy94SOU3ajc1VbIy1wnWaNaeIUzfgdtEg" compiler: gcc branches: only: - master before_install: - | if [ "x${BUILD_TYPE}" == "xcoverage" ]; then sudo apt-get update sudo apt-get install -qy python3-pip lcov pip3 install --user --upgrade setuptools pip3 install --user --upgrade pip pip3 install --user PyYAML pip3 install --user --upgrade cpp-coveralls fi - if [ -n "${C_COMPILER}" ]; then export CC="${C_COMPILER}"; fi - if [ -n "${CXX_COMPILER}" ]; then export CXX="${CXX_COMPILER}"; fi - ${CXX} --version - cmake --version - mkdir build - cd build - type -p ninja && export GENERATOR=-GNinja || true before_script: # to stop the script after an error/warning - set -e # workarounds for OSX traivs build failure issues: # 1. rvm overrides cd with a function so that it can hook into it to run some scripts from the new # working directory. The workaround is to revert it to the builtin shell one. - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then unset -f cd; fi # 2. Redefine shell_session_update as a dummy function to avoid travis error: # /Users/travis/.rvm/scripts/functions/support: line 57: shell_session_update: command not found. - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then shell_session_update() { :; }; fi # prepare make files with cmake - |- case "${BUILD_TYPE}" in "coverage") cmake ${GENERATOR} -DCMAKE_BUILD_TYPE=Debug -DENABLE_CODECOVERAGE=ON .. ;; "asan") cmake ${GENERATOR} -DCMAKE_BUILD_TYPE=Debug -DENABLE_SANITIZER=address .. ;; "ubsan") cmake ${GENERATOR} -DCMAKE_BUILD_TYPE=Debug -DENABLE_SANITIZER=undefined .. ;; "cross") cmake ${GENERATOR} -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-mingw64.cmake -DCMAKE_EXE_LINKER_FLAGS="-static -s" .. ;; "release") cmake ${GENERATOR} -DCMAKE_BUILD_TYPE=Release .. ;; *) cmake ${GENERATOR} .. ;; esac script: # build - if [ -f build.ninja ]; then ninja -v; else make VERBOSE=1; fi # run all tests - if [ "x${BUILD_TYPE}" != "xcross" ]; then ../scripts/run_ctest.py; fi # collect coverage (needs to be after running tests) - if [ "x${BUILD_TYPE}" == "xcoverage" ]; then make coverage; fi # DO NOT REMOVE (debugging purposes) #- /home/travis/build/uncrustify/uncrustify/build/uncrustify -l cs -c /home/travis/build/uncrustify/uncrustify/tests/config/U10-Cpp.cfg -f /home/travis/build/uncrustify/uncrustify/tests/input/cs/newlines.mm -L A after_success: # publish coverage data to coveralls - if [ "x${BUILD_TYPE}" == "xcoverage" ]; then cd ../ && coveralls -l build/cmake_coverage.output -t $COVERALLS_TOKEN; fi uncrustify-uncrustify-0.76.0/AUTHORS000066400000000000000000000046031434072136500173100ustar00rootroot00000000000000Author: 2005 - 2016 : Ben Gardner Maintenance: Guy Maurel Michele Calgaro Matthew Woehlke until 2022-11-22: Other collaborators: Alan Fineberg Alexander GQ Gerasiov Alex Henrie André Berg Andrei Alexandrescu Andrey Starodubtsev Anirban Pramanick Antti Tapaninen Arne Forlie Arseniy Shestakov asobhy atauzki Aurélien Gâteau Benio Ben Iofel Ben Mayo Beren Minor Bi-Ruei, Chiu Biswa96 Biswapriyo Nath B. Kevin Hardman Bogdan Popescu Brandon Slack Brendan Long Brian Kelley CharlieYJH Chris Lalancette Clemens Rabe Clint Lawrence Code Able Cody Schafer Corentin Noël Dandielo Daniel Chumak Daniele Bartolini Dan Rose Dave Lee David Catmull David E. O'Brien David Lechner David Schaefgen Dirk Thomas Dittrich, Rico Dmitry Marakasov Dmitry Povolotsky Dmytro Povolotskyi Dundar Göc Dženan Zukić Eism Emerson Knapp Emmanuel Christophe epac-tom Ethan Gao Florin Pop Frank J. T. Wojcik Gary Ash Ger Hobbelt Hackerpilot Hannes Schmidt hghdev Huang-Ming Huang Husk3r Ilya Lyubimov Ingo Brückl Ivan Nazarenko Ivan Romanov Jakub Schmidtke Jan Weiß Jason JavDevGames Jeremy H Jeremy T Hilliker Jim Meyering Jiri Hruska jodi.the.tigger@gmail.com Jody Hagins Joel Ostraat Joergen Ibsen Johnny Oskarsson Jonas Hurrelmann Joshua Gross Joshua Parker Julian Picht Kalle Raiskila Keepun Kevin Wong krys Laurent Tréguier Lauri Kasanen lbmaian Leon Breedt Lorenz Haas Lykurg Maciej Bogusz Marco Stephan Marcus Nilsson Marek Fort Marius Zwicker Mark Stegeman Markus Geimer Martin Simonovsky Martin Storsjo Matthew McDole Matthew Woehlke Maxim Mikityanskiy Max Smolens MeXx Michaël Peeters Michele Calgaro Mihai Popescu Mike Mike Gelfand Mirko König mjbogusz MrTheMake Nate neok-m4700 Nico Decker Oleg Liatte Oleg Smolsky Owen Rudge Pat Notz Patrick Rohr Paul Cercueil Paul Smith Pavel Geiger Paweł Benetkiewicz PerfectCarl Peter Bruin Peter Hartley Peter Jonas Peter Kolbus Peter Tao Peter Waller Piet Van Reepingen PMheart Randolph R. Settgast Randolph Settgast RaveTheTadpole Ray Strode Richard Maxwell Ricky Lopez Roland Schulz Roman Gordienko Ryan Maxwell Samish Chandra Kolli Samish Kolli Scott Bilas Sebastian Andersson S. Gilles Shazron Abdullah Siddharth Kannan Slávek Banko Spark-NF Stefan Koch Stefan Nunninger Stephen Gilles Steven Lee Suhaib Ishaque t-bltg Tim Hütz Timotheus Pokorra Todd Richmond Twigz U-RDEC\ParkerJS Vadim Zeitlin Viktor Kireev Vincent Rouillé Vojtěch Balík Vyacheslav Shegai Waldir Pimenta Yannick Bühler uncrustify-uncrustify-0.76.0/BUGS000066400000000000000000000045121434072136500167220ustar00rootroot00000000000000------------------------------------------------------------------------------- BUGS: Post any bugs to the issue tracker found on the project's GitHub page: https://github.com/uncrustify/uncrustify/issues Before you do so, try running with the latest code from git. The bug might have already been fixed. If it hasn't already been reported, then you'll need to file a bug report. First, reduce your input file to the minimum that still causes the problem. This is important, as a 1000-line input file is much more difficult to diagnose than a 5-line file. Next, rename your functions, change your strings, comments, etc, to protect any trade secrets or whatnot. If you attach an input file with a bug, it will most likely appear as a future test case. Finally, create a bug report. Here's what I like to see in a bug report. 1. The type of problem (crash, bad formatting, etc) 2. The version of uncrustify you tested with (ie, the git hash) 3. The operating system 4. The input file or code snippet, including the language (C, C++, Java, etc) 5. The configuration file you used. If it isn't one of the 'standard' ones, then attach it. 6. The expected output (not needed for crash bugs) If you are the code writing type (and you are, since you are using a code formatting tool), I'd like you to take a quick look and see if you can pinpoint the source of the problem. Here is what I do when I get a bug report. 1. Check for options that control the desired behavior. About half the time a user missed an option. 2. Run with the supplied input and config to verify the problem. $ uncrustify -c bug.cfg -f bug.c 2a. For a crash-bug, I create a core dump to quickly find the offending code. $ ulimit -c unlimited $ uncrustify -c bug.cfg -f bug.c $ gdb uncrustify core 3. Formatting bugs usually land in one of three catagories. a. Incorrectly labeled chunks b. Bad formatting logic or unexpected input c. Missing options Debugging help: I run with the "-p" option to get a dump of the chunks. $ uncrustify -c bug.cfg -f bug.c -p parsed.txt This tells me the configuration and how each chunk is labeled, indented, and otherwise processed. I also selectively turn on log levels (the -L command line option) to aid debugging of specific areas of interest. Don't turn on all log levels -- the result is excessive and not at all helpful. uncrustify-uncrustify-0.76.0/CMakeLists.txt000066400000000000000000000323551434072136500210050ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.2) project(uncrustify) if("${PROJECT_SOURCE_DIR}" STREQUAL "${PROJECT_BINARY_DIR}") message(FATAL_ERROR " In-source builds are not supported, please remove the `CMakeFiles' folder and `CMakeCache.txt', and create a folder for the build: mkdir build; cd build; cmake .. ") endif() include(CheckCXXCompilerFlag) include(CheckIncludeFileCXX) include(CheckSymbolExists) include(CheckCXXSymbolExists) include(CheckTypeSize) include(CTest) if( ${CMAKE_VERSION} VERSION_LESS "3.12" ) find_package( PythonInterp ) if( NOT PYTHON_EXECUTABLE ) message( FATAL_ERROR "Python is required, but was not found on your system" ) endif() else( ) find_package(Python3 REQUIRED) set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE}) endif() # # Check compiler flags # if(MSVC) add_definitions(/D_CRT_SECURE_NO_WARNINGS /D_CRT_NONSTDC_NO_WARNINGS /wd4267) add_definitions(/utf-8) elseif(CMAKE_COMPILER_IS_GNUCXX) set(gcc_warning_flags -Wall -Wextra -Wshadow -Wpointer-arith -Wcast-qual -Wcast-align -Wc++11-extensions ) foreach(flag ${gcc_warning_flags}) string(REGEX REPLACE "[^a-zA-Z0-9]+" "_" flag_var "CXXFLAG_${flag}") CHECK_CXX_COMPILER_FLAG("${flag}" ${flag_var}) if(${flag_var}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") endif() unset(flag_var) endforeach() if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-field-initializers") endif() unset(gcc_warning_flags) elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") endif() set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED YES) if(ENABLE_SANITIZER) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O1 -fno-omit-frame-pointer -fsanitize=${ENABLE_SANITIZER}") endif() #set(UNCRUSTIFY_SEPARATE_TESTS "True") include_directories( ${PROJECT_BINARY_DIR}/src ${PROJECT_SOURCE_DIR}/src ${PROJECT_BINARY_DIR} ) # # Determine config # if(WIN32) # Windows builds use src/windows_compat.h instead of config.h else() # Generate config.h set(avail_headers "") set(headers inttypes.h memory.h stdint.h stdlib.h strings.h string.h sys/stat.h sys/types.h unistd.h utime.h ) foreach(header ${headers}) string(TOUPPER "${header}" header_uc) string(REGEX REPLACE "[^A-Z0-9_]" "_" include_var "HAVE_${header_uc}") check_include_file_cxx("${header}" ${include_var}) if(${include_var}) list(APPEND avail_headers ${header}) endif() unset(include_var) unset(header_uc) endforeach() unset(headers) check_include_file("stdbool.h" HAVE_STDBOOL_H) set(symbols memset strcasecmp strchr strdup strerror strtol strtoul ) foreach(symbol ${symbols}) string(TOUPPER "${symbol}" symbol_uc) string(REGEX REPLACE "[^A-Z0-9_]" "_" symbol_var "HAVE_${symbol_uc}") check_cxx_symbol_exists("${symbol}" "${avail_headers}" ${symbol_var}) unset(symbol_var) unset(symbol_uc) endforeach() unset(symbols) unset(avail_headers) check_type_size(_Bool _BOOL LANGUAGE C) configure_file(src/config.h.in config.h @ONLY) endif() # # Generate uncrustify_version.h # set(UNCRUSTIFY_VERSION "0.76.0_f") option(NoGitVersionString "Do not use make_version.py and git to build a version string" OFF) if(NoGitVersionString) configure_file(src/uncrustify_version.h.in uncrustify_version.h @ONLY) add_custom_target(generate_version_header) # Dummy target else() # Add target to generate version header; # do this every build to ensure git SHA is up to date add_custom_target(generate_version_header BYPRODUCTS "${PROJECT_BINARY_DIR}/uncrustify_version.h" COMMAND ${CMAKE_COMMAND} -D PYTHON_EXECUTABLE:STRING=${PYTHON_EXECUTABLE} -D SOURCE_DIR:PATH="${PROJECT_SOURCE_DIR}" -D INPUT:PATH="${PROJECT_SOURCE_DIR}/src/uncrustify_version.h.in" -D OUTPUT:PATH="${PROJECT_BINARY_DIR}/uncrustify_version.h" -D UNCRUSTIFY_VERSION:STRING="${UNCRUSTIFY_VERSION}" -P ${PROJECT_SOURCE_DIR}/cmake/GenerateVersionHeader.cmake COMMENT "Generating version header" ) set_source_files_properties( "${PROJECT_BINARY_DIR}/uncrustify_version.h" PROPERTIES GENERATED TRUE ) endif() # # Generate token_names.h # add_custom_command( OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/token_names.h" COMMAND ${CMAKE_COMMAND} "-Dsrc_file=${PROJECT_SOURCE_DIR}/src/token_enum.h" "-Ddst_file=${CMAKE_CURRENT_BINARY_DIR}/token_names.h" -P "${PROJECT_SOURCE_DIR}/cmake/GenerateTokenNames.cmake" MAIN_DEPENDENCY src/token_enum.h COMMENT "Generating token_names.h" ) # Set up commands for generated source files function(py_gen OUTPUT SCRIPT INPUT) set(out "${PROJECT_BINARY_DIR}/src/${OUTPUT}") set(deps "${PROJECT_SOURCE_DIR}/src/${INPUT}") get_filename_component(outdir "${out}" DIRECTORY) foreach(arg IN LISTS ARGN) if (IS_ABSOLUTE "${arg}") list(APPEND deps "${arg}") else() list(APPEND deps "${PROJECT_SOURCE_DIR}/src/${arg}") endif() endforeach() add_custom_command( OUTPUT "${out}" COMMAND ${CMAKE_COMMAND} -E make_directory "${outdir}" COMMAND ${PYTHON_EXECUTABLE} "${PROJECT_SOURCE_DIR}/scripts/${SCRIPT}" "${out}" ${deps} DEPENDS ${deps} "${PROJECT_SOURCE_DIR}/scripts/${SCRIPT}" MAIN_DEPENDENCY src/${INPUT} COMMENT "Generating ${OUTPUT}" ) endfunction() py_gen(punctuator_table.h make_punctuator_table.py symbols_table.h ) py_gen(options.cpp make_options.py options.h options.cpp.in ) py_gen(option_enum.h make_option_enum.py option.h option_enum.h.in ) py_gen(option_enum.cpp make_option_enum.py option.h option_enum.cpp.in ) py_gen(../etc/uncrustify.xml make_katehl.py ../etc/uncrustify.xml.in "${PROJECT_BINARY_DIR}/uncrustify_version.h" options.h option.h token_enum.h ) # # Uncrustify # set(uncrustify_sources src/align_add.cpp src/align_asm_colon.cpp src/align_assign.cpp src/align_braced_init_list.cpp src/align.cpp src/align_eigen_comma_init.cpp src/align_func_params.cpp src/align_func_proto.cpp src/align_init_brace.cpp src/align_left_shift.cpp src/align_log_al.cpp src/align_nl_cont.cpp src/align_oc_decl_colon.cpp src/align_oc_msg_colons.cpp src/align_oc_msg_spec.cpp src/align_preprocessor.cpp src/align_same_func_call_params.cpp src/align_stack.cpp src/align_struct_initializers.cpp src/align_tab_column.cpp src/align_tools.cpp src/align_trailing_comments.cpp src/align_typedefs.cpp src/align_var_def_brace.cpp src/args.cpp src/backup.cpp src/brace_cleanup.cpp src/braces.cpp src/calculate_closing_brace_position.cpp src/change_int_types.cpp src/chunk.cpp src/ChunkStack.cpp src/combine.cpp src/combine_fix_mark.cpp src/combine_labels.cpp src/combine_tools.cpp src/combine_skip.cpp src/compat_posix.cpp src/compat_win32.cpp src/cs_top_is_question.cpp src/detect.cpp src/enum_cleanup.cpp src/EnumStructUnionParser.cpp src/EnumStructUnionParser.h src/flag_braced_init_list.cpp src/flag_decltype.cpp src/flag_parens.cpp src/frame_list.cpp src/indent.cpp src/keywords.cpp src/lang_pawn.cpp src/language_tools.cpp src/logger.cpp src/logmask.cpp src/log_rules.cpp src/mark_question_colon.cpp src/md5.cpp src/newlines.cpp src/option.cpp src/options_for_QT.cpp src/output.cpp src/parameter_pack_cleanup.cpp src/parens.cpp src/parent_for_pp.cpp src/ParseFrame.cpp src/pragma_cleanup.cpp src/pcf_flags.cpp src/punctuators.cpp src/quick_align_again.cpp src/remove_duplicate_include.cpp src/remove_extra_returns.cpp src/rewrite_infinite_loops.cpp src/semicolons.cpp src/sorting.cpp src/space.cpp src/tokenize_cleanup.cpp src/tokenize.cpp src/uncrustify.cpp src/uncrustify_emscripten.cpp src/uncrustify_types.cpp src/unc_ctype.cpp src/unc_text.cpp src/unc_tools.cpp src/unicode.cpp src/universalindentgui.cpp src/width.cpp ${PROJECT_BINARY_DIR}/src/options.cpp ${PROJECT_BINARY_DIR}/src/option_enum.cpp ) set(uncrustify_headers src/add_space_table.h src/align_add.h src/align_asm_colon.h src/align_assign.h src/align_braced_init_list.h src/align_func_params.h src/align_func_proto.h src/align.h src/align_eigen_comma_init.h src/align_init_brace.h src/align_left_shift.h src/align_log_al.h src/align_nl_cont.h src/align_oc_decl_colon.h src/align_oc_msg_colons.h src/align_oc_msg_spec.h src/align_preprocessor.h src/align_same_func_call_params.h src/align_stack.h src/align_struct_initializers.h src/align_tab_column.h src/align_tools.h src/align_trailing_comments.h src/align_typedefs.h src/align_var_def_brace.h src/args.h src/backup.h src/base_types.h src/brace_cleanup.h src/braces.h src/calculate_closing_brace_position.h src/change_int_types.h src/char_table.h src/chunk.h src/ChunkStack.h src/combine.h src/combine_fix_mark.h src/combine_labels.h src/combine_skip.h src/combine_tools.h src/compat.h src/cs_top_is_question.h src/detect.h src/enum_cleanup.h src/enum_flags.h src/error_types.h src/flag_braced_init_list.h src/flag_decltype.h src/flag_parens.h src/frame_list.h src/indent.h src/keywords.h src/lang_pawn.h src/language_tools.h src/ListManager.h src/logger.h src/log_levels.h src/logmask.h src/log_rules.h src/mark_question_colon.h src/md5.h src/newlines.h src/option.h src/options_for_QT.h src/options.h src/output.h src/parameter_pack_cleanup.h src/parens.h src/parent_for_pp.h src/ParseFrame.h src/pragma_cleanup.h src/pcf_flags.h src/prototypes.h src/punctuators.h src/quick_align_again.h src/remove_duplicate_include.h src/remove_extra_returns.h src/rewrite_infinite_loops.h src/semicolons.h src/sorting.h src/space.h src/symbols_table.h src/token_enum.h src/tokenize_cleanup.h src/tokenize.h src/unc_ctype.h src/uncrustify.h src/uncrustify_limits.h src/uncrustify_types.h src/unc_text.h src/unc_tools.h src/unicode.h src/universalindentgui.h src/width.h src/windows_compat.h ${PROJECT_BINARY_DIR}/src/option_enum.h ${PROJECT_BINARY_DIR}/uncrustify_version.h ) set(uncrustify_docs "${PROJECT_SOURCE_DIR}/AUTHORS" "${PROJECT_SOURCE_DIR}/BUGS" "${PROJECT_SOURCE_DIR}/ChangeLog" "${PROJECT_SOURCE_DIR}/COPYING" "${PROJECT_SOURCE_DIR}/HELP" "${PROJECT_SOURCE_DIR}/README.md" ) add_executable(uncrustify ${uncrustify_sources} ${uncrustify_headers}) add_dependencies(uncrustify generate_version_header) set_property(TARGET uncrustify APPEND PROPERTY COMPILE_DEFINITIONS $<$,$>:DEBUG> ) # # Generate uncrustify.1 # configure_file(man/uncrustify.1.in uncrustify.1 @ONLY) # # Generate uncrustify.xml (katepart highlighting file) # add_custom_target(katehl DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/etc/uncrustify.xml ) # # Tests # if(BUILD_TESTING) enable_testing() add_subdirectory(tests) endif() # # Coverage # OPTION(ENABLE_CODECOVERAGE "Enable code coverage testing support") if(ENABLE_CODECOVERAGE) set(CODECOVERAGE_DEPENDS uncrustify) include(${CMAKE_SOURCE_DIR}/cmake/CodeCoverage.cmake) endif(ENABLE_CODECOVERAGE) # # Build command to run uncrustify on its own sources # add_custom_target(format-sources) foreach(source IN LISTS uncrustify_sources uncrustify_headers) get_filename_component(source_name ${source} NAME) add_custom_target(format-${source_name} COMMAND uncrustify -c forUncrustifySources.cfg -lCPP --no-backup ${source} COMMENT "Formatting ${source}" WORKING_DIRECTORY ${uncrustify_SOURCE_DIR} ) add_dependencies(format-sources format-${source_name}) endforeach() # # Package # set(CPACK_PACKAGE_NAME "uncrustify") set(CPACK_PACKAGE_VERSION "${UNCRUSTIFY_VERSION}") set(CPACK_PACKAGE_VENDOR "Ben Gardner") set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Code beautifier") set(CPACK_PACKAGE_DESCRIPTION_FILE "${PROJECT_SOURCE_DIR}/README.md") set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING") set(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README.md") set(CPACK_SOURCE_IGNORE_FILES "/\\\\.git/;/\\\\.hg/;/tests/results/;/build.*/") if(CMAKE_SYSTEM_NAME STREQUAL "Windows") set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY FALSE) set(CPACK_GENERATOR "ZIP") endif() include(CPack) # # Install # if(MSVC) install(TARGETS uncrustify DESTINATION ".") install(FILES ${uncrustify_docs} DESTINATION "." ) install(FILES "${PROJECT_SOURCE_DIR}/documentation/htdocs/index.html" DESTINATION "doc" ) install(DIRECTORY "${PROJECT_SOURCE_DIR}/etc/" DESTINATION "cfg" FILES_MATCHING PATTERN "*.cfg" ) else() include(GNUInstallDirs) install(TARGETS uncrustify RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" ) install(FILES "${CMAKE_CURRENT_BINARY_DIR}/uncrustify.1" DESTINATION "${CMAKE_INSTALL_MANDIR}/man1" ) install(DIRECTORY "${PROJECT_SOURCE_DIR}/etc/" DESTINATION "${CMAKE_INSTALL_DOCDIR}/examples" FILES_MATCHING PATTERN "*.cfg" ) install(FILES ${uncrustify_docs} DESTINATION "${CMAKE_INSTALL_DOCDIR}" ) endif() # # Uninstall # add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${PROJECT_SOURCE_DIR}/cmake/uninstall.cmake") # # add to build the compile_commands.json file, to be used by clang-tidy # set(CMAKE_EXPORT_COMPILE_COMMANDS "ON" CACHE BOOL "to create the compile_commands.json file" FORCE) uncrustify-uncrustify-0.76.0/CODEOWNERS000066400000000000000000000000751434072136500176320ustar00rootroot00000000000000* @gmaurel @mwoehlke-kitware @micheleCTDEAdmin uncrustify-uncrustify-0.76.0/CONTRIBUTING.md000066400000000000000000000076721434072136500205020ustar00rootroot00000000000000# Contributing to Uncrustify ## How to contribute There are lots of ways to contribute to Uncrustify: - Report Issues - Propose Features or Improvements - Submit Pull Requests ## Making changes * Pull latest [master][master] and create a new branch: - Branch name _should_ use lowercase, using `-` to separate words and not `_`. Other special characters _should_ be avoided. (However, feel free to use option names verbatim in branch names; `_` _should_ be used when part of an option name.) - A hierarchical structure _may_ be designated using `/` (e.g. `area/topic`), although this is uncommon. The last part of the name can be keywords like `bugfix`, `feature`, `optim`, `docs`, `refactor`, `test`, etc. - Branches _should_ be named after _what_ the change is about. - Branches _should not_ be named after the issue number, developer name, etc. * Organize your work: - Specialize your branch to target only one thing. Split your work in multiple branches if necessary. - Make commits of logical units. - Avoid "fix-up" commits. Instead, rewrite your history so that the original commit is "clean". - Try to write a [quality commit message][commits]: + Separate subject line from body with a blank line. + Limit subject line to 50 characters. + Capitalize the subject line. + Do not end the subject line with a period. + Use imperative present tense in the subject line. A proper subject can complete the sentence "If applied, this commit will, [subject]". + Wrap the body at 72 characters. + Include motivation for the change and contrast its implementation with previous behavior. Explain the _what_ and _why_ instead of _how_. - If the git diff command, or the diff part of the git gui, don't produce accurate output, it might be necessary to add some lines to the ~/.gitconfig file: [diff] algorithm = patience [gui] diffopts = --patience * Add or update unit tests: - All behavioral changes should come with a unit test that verifies that the new feature or fixed issue works as expected. - Consider improving existing tests if it makes sense to do so. - Any unused test number may be used, however it is preferred to keep related tests together, if possible. - Read [Writing Tests][tests] for more details. * Polish your work: - The code should be clean, with documentation where needed. - The change must be complete (no upcoming fix-up commits). - Functional changes should always be accompanied by tests (see above). Changes without tests should explain why tests are not present. (Changes that are non-functional, such as documentation changes, can usually omit tests without justification.) * Prepare a Pull Request (PR): - To reduce the likelihood of conflicts and test failures, consider rebasing your work on top of latest master before creating a PR. - Verify that your code is working properly by running `ctest` in your build directory. (Changes that fail CI will _not_ be merged. Running the tests locally will help to avoid this.) You can change the level of logging by changing the line 104 and 109 of the file tests/test_uncrustify/test.py to another value. - The PR title should represent _what_ is being changed (a rephrasing of the branch name if set correctly). - The PR description should document the _why_ the change needed to be done and not _how_, which should be obvious by doing the code review. - After commiting a new PR, one may have a look to the results: https://coveralls.io/github/uncrustify/uncrustify [master]: https://github.com/uncrustify/uncrustify/tree/master [commits]: https://chris.beams.io/posts/git-commit/ [tests]: https://github.com/uncrustify/uncrustify/wiki/Writing-Tests uncrustify-uncrustify-0.76.0/COPYING000066400000000000000000000431101434072136500172670ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. uncrustify-uncrustify-0.76.0/ChangeLog000066400000000000000000002140061434072136500200120ustar00rootroot00000000000000Change highlights in uncrustify-0.76.0 (November 2022) ------------------------------------------------------------------------------- 1aea3d1fcb55dc2ca40dfe2b1d548685a415ef3a Added : nl_collapse_empty_body_functions Apr 29 2022 c7f5df072f56bb0e3a9b897e16b8e5fc283f3bcf Added : set_numbering_for_html_output May 29 2022 92e4a36a5a78d9af523008aeb71e7acfe199269a Added : mod_infinite_loop Jun 22 2022 6e807bcec01382b164562c8ae5939d2b5ee76877 Added : mod_short_int Jun 28 2022 Added : mod_long_int Jun 28 2022 Added : mod_unsigned_int Jun 28 2022 Added : mod_signed_int Jun 28 2022 baad5db83faf5fb771cea8898760ad582227ccda Added : mod_int_prefer_int_on_left Jul 6 2022 Added : mod_int_long Jul 6 2022 Added : mod_int_signed Jul 6 2022 Added : mod_int_unsigned Jul 6 2022 Added : mod_int_short Jul 6 2022 e6a5458d32ca26c8b7d24f514115ebc36fce2348 Added : nl_oc_msg_args_min_params Jul 9 2022 862369a315763ce1286732da3713414cd2533227 Added : pp_space_after Jul 14 2022 Added : pp_space_before Jul 14 2022 Removed : pp_space Jul 14 2022 be0d1664f901d1cbfa7bf7697a883adf4b709444 Added : nl_throw_expr Jul 19 2022 Added : mod_paren_on_throw Jul 19 2022 9e65feefa2d66c5d08049e53468cae682f66800d Added : debug_sort_the_tracks Aug 2 2022 b58f1298a3ddcd256ecb0688f6b18ca7c623f594 Removed : pp_space_before Aug 6 2022 a31e5c100de768b4fec45a3e1c2d1e008824b2c6 Added : nl_var_def_blk_end_func_top Aug 11 2022 Removed : nl_func_var_def_blk Aug 11 2022 56e2159b29c372ebd1e240d427c842b5bb0b2147 Added : pp_indent_with_tabs Sep 6 2022 35075d50967014dd7127640d2505bca5dc21dfe5 Added : pp_multiline_define_body_indent Sep 15 2022 5b88110f5bb685a9b298b247207e32c305366d18 Added : nl_oc_msg_args_max_code_width Sep 20 2022 0c8e5e827d3b5a007247ef3d5ed937cf18378680 Added : debug_decode_the_flags Oct 9 2022 Change highlights in uncrustify-0.75.0 (May 2022) ------------------------------------------------------------------------------- 52131d9fa22fd0c655ae2510563ff85306d4bd27 Added : mod_move_case_return Nov 25 2021 d0008e933daca163ef8f7258f526e75fb8b5b160 Added : sp_ptr_star_func_type Dec 8 2021 a17751ae534cb7d1a8b505a111d7b8b50c9842d4 Added : pp_indent_at_level0 Dec 14 2021 498c1b3a6c96c9dd8ec13a4c0f616acdb7a03cc5 Added : align_braced_init_list_thresh Dec 16 2021 Added : align_braced_init_list_span Dec 16 2021 8e811b9a57bc43d280aa592d8838cff93227968e Added : align_assign_on_multi_var_defs Dec 18 2021 75d3c536789ef23d2d8568d891a4e3ba73aa7045 Added : sp_byref_paren Dec 24 2021 d8507bb212aa317dce0f51227b8fd862354e03c2 Added : sp_not_not Dec 28 2021 d9e2ae9aad5481f9da818909893e2f55d51ba392 Added : indent_ignore_comma_paren Jan 4 2022 Added : indent_ignore_comma_brace Jan 4 2022 8eff5202a58732e17f063af8360ff3e2691713aa Added : indent_ignore_bool_paren Jan 13 2022 2c02f5c8285882ddf756992d842db12d0f98188a Added : indent_ignore_arith Jan 18 2022 0664cacee7689cf838425e83f38fb84f5e71bc63 Added : mod_full_paren_return_bool Jan 21 2022 Added : mod_full_paren_assign_bool Jan 21 2022 d593f257e88161a3ed1cff15b354c85e3da68992 Added : sp_type_colon Jan 25 2022 026162b8da51660126863b42d00245e21a47d7c0 Removed : indent_ignore_comma_paren Jan 28 2022 Removed : indent_ignore_bool_paren Jan 28 2022 Removed : indent_ignore_comma_brace Jan 28 2022 6cb50031c5e2e3681d69c3dafdbb865a5b6b6a2c Added : indent_ignore_semicolon Feb 1 2022 b6f55dd25fb6a12c7f81c0090f8ee42e8823ee93 Added : sp_enum_brace Feb 2 2022 8aa0522fcc2ad468f1122943443f5ebf426fffc1 Added : indent_ignore_before_class_colon Feb 4 2022 133fe55d6fc0b2e1695bd7a70ccd6d2dcd1b2262 Added : indent_ignore_before_constr_colon Feb 4 2022 c95460809c74a73459c61712ff2d9142dff101d7 Added : indent_ignore_bool Feb 25 2022 b37091110063b5c24b64516a49af09b8ca3cc18c Added : indent_ignore_first_continue Feb 25 2022 e84f08879a7cf53b0301099a64faadeacf04a3a5 Added : indent_ignore_assign Mar 1 2022 6ef69ee2a359f2e1bd8517ba4af25b969951fa71 Added : indent_ignore_case_brace Mar 9 2022 02a5e50419fd1bf7c9bf0ff9d208035b47db6fbf Added : indent_namespace_inner_only Apr 12 2022 9040b9f068a179c3a09e0cf202a5ed7f91b2a12b Added : pp_warn_unbalanced_if Apr 15 2022 df2ef721c95105b62a9e0cb0e9985947a739a44b Removed : sp_type_question Apr 30 2022 Change highlights in uncrustify-0.74.0 (November 2021) ------------------------------------------------------------------------------- 4714d5d673d5b9c8f45d70c179f508d60130b18a Added : nl_before_struct Mar 12 2021 dbb2903a94668e147b588d3eebc3be917ac4ebca Added : nl_before_ignore_after_case Jun 22 2021 e97b93418c03cde680d6fd46209d7e43c5e09bfe Added : sp_before_ptr_star_trailing Jul 1 2021 Added : sp_after_ptr_star_trailing Jul 1 2021 dd5a7c3b2ab64b903e888a264693a9edb7a98ee5 Added : sp_sparen_paren Jul 19 2021 94941c2f9aa8952debab1f8257eb0625bc459392 Added : pp_indent_in_guard Jul 28 2021 84d3b9276c007642c4bb73ff562008253e4fe014 Added : indent_single_line_comments_before Jul 31 2021 Added : indent_single_line_comments_after Jul 31 2021 Removed : indent_sing_line_comments Jul 31 2021 0d956a006d64fddd4f8131e6a16a23f7e447cca3 Added : sp_after_ellipsis Jul 31 2021 40bbb979ecf7ad36128150f5540a462c890d5e2c Added : mod_remove_duplicate_include Aug 15 2021 97d24f3a05a53521ff2ce94928534f4bab0cc0af Added : sp_between_semi_for_empty Aug 22 2021 63109e6253387480b8bfe7f73a7f2949865fc380 Added : nl_before_brace_open Aug 27 2021 03c9ac261c9282b3cf5e92d69de70d6b4566d8e9 Added : cmt_trailing_single_line_c_to_cpp Sep 1 2021 1525722486dba45aa053f2c83e3015fa64880443 Added : sp_ellipsis_parameter_pack Sep 16 2021 Added : sp_parameter_pack_ellipsis Sep 16 2021 2e33ac4314dfbfc18c56ec694b0eba3e6a1318f5 Added : sp_byref_ellipsis Sep 21 2021 Added : sp_ptr_type_ellipsis Sep 21 2021 f19bf09cdce5822cf3d71065cb3900ea52f6e5c7 Added : indent_ctor_init_following Sep 30 2021 b1274c20bea3f8e2a8d6cd05cbb23c8d66f187a7 Added : sp_before_emb_cmt Oct 8 2021 Added : sp_num_after_emb_cmt Oct 8 2021 Added : sp_before_tr_cmt Oct 8 2021 Added : sp_num_before_emb_cmt Oct 8 2021 Added : sp_num_before_tr_cmt Oct 8 2021 Added : sp_after_emb_cmt Oct 8 2021 Removed : sp_before_tr_emb_cmt Oct 8 2021 Removed : sp_num_before_tr_emb_cmt Oct 8 2021 563d72fcae6e0aad6e5f0ff998992a48a6767986 Added : pp_include_at_level Oct 11 2021 28486dbadcc4d0ff9376776eb63f3c3bd800cf2d Added : sp_return Oct 12 2021 86105064d13fc60d14cfd134a8c3d402e7d27492 Added : indent_comment_align_thresh Oct 13 2021 964db2ac20372c45621a55313cdfb1eeb8298800 Added : indent_comment Oct 18 2021 92b9047256ece8d9ace2da5c743be2b9cc2b54d8 Added : align_func_proto_amp_style Oct 23 2021 Added : align_func_proto_star_style Oct 23 2021 094c79e06f6ec3111684b37b77063cf7af658105 Added : indent_case_comment Oct 26 2021 7eb595caa38ced024a42ba1602d69e0387b8e3a1 Added : indent_switch_body Nov 3 2021 cf845deb008b45783ff94a1986131eb180fb54a8 Added : sp_inside_for_close Nov 6 2021 Added : sp_inside_for Nov 6 2021 Added : sp_inside_for_open Nov 6 2021 2caaa17866c3b421de7e28670e85c8f8dade5a77 Added : indent_ignore_label Nov 10 2021 d8436ef370027bcfd289b19037c39ffdaf0ad4ff Added : sp_ptr_star_func_var Nov 15 2021 Change highlights in uncrustify-0.73.0 (May 2021) ------------------------------------------------------------------------------- b514f25120b12db7b1ca57cdb93dd929a5bf43c4 Added : indent_before_class_colon Nov 16 2020 39c969b69663f6e6cee9673e23d349a308edc44a Added : sp_cmt_cpp_region Dec 9 2020 9ca37d0c32729570de2e51c97338bc567e124ae3 Added : cmt_sp_before_doxygen_javadoc_tags Dec 24 2020 Added : cmt_align_doxygen_javadoc_tags Dec 24 2020 84e2c750d19b47bbe2547141b092855ec1f64424 Added : cmt_reflow_fold_regex_file Dec 24 2020 3a8e33a12839ca3bac2e1e0b49eb279362a2ab89 Added : processing_cmt_as_regex Dec 31 2020 c622135751824705979d37681fe16d9a60e3d77a Added : cmt_reflow_indent_to_paragraph_start Jan 9 2021 9c0799aa096b68550507980a32a529099caf97c5 Added : sp_cpp_lambda_argument_list Jan 19 2021 02054b1085166903e8c1384308ac7922cb57bd59 Added : nl_do_leave_one_liners Jan 29 2021 6a4d27914fca0c64273fad979355e16021626f8a Added : debug_truncate Feb 7 2021 a711e96ef7be6afc9f014c4c7e1e5ea5347aad0d Added : indent_comma_brace Mar 9 2021 Change highlights in uncrustify-0.72.0 (November 2020) ------------------------------------------------------------------------------- new command option: --debug-csv-format : Dump debug info to file in csv-delimited format. b29dfb58d6bebb79a961d0e709543a152d260dbc Added : nl_inside_empty_func Aug 4 2020 5068a4a78d7770a7292ea7a016ab7ca0bf49cbf7 Added : debug_timeout Sep 1 2020 cf3e5acfb4d55b47b25b7e7daa2844e2998b47cc Added : sp_inside_square_empty Sep 8 2020 b66c26c669bf9752f468115f1e6444481c0b9e6d Added : align_eigen_comma_init Sep 9 2020 7b5fd82fa5d6fc035ddfb7c087c5aeb7cf6f4bd7 Added : pos_shift Sep 16 2020 b61b7952835be3451cd1131baeda7b54cb61a50e Added : donot_indent_func_def_close_paren Sep 26 2020 85001632261196dc1c2f3760dc9180e4c443f9ba Added : donot_add_nl_before_cpp_comment Oct 14 2020 Change highlights in uncrustify-0.71.0 (May 2020) ------------------------------------------------------------------------------- 6bcfb640d908038402869cb3be7bd80adcdb4708 Added : align_oc_msg_colon_xcode_like Nov 29 2019 2fd5aaf255e1d0369842f54ae8d444bcbc079c7b Added : indent_compound_literal_return Nov 19 2019 4b74315b6cf8e91801b663c4171c1e0a9e12ea5b Added : indent_sparen_extra Nov 19 2019 f012dd24e2d116d867404667ce15c3309466046f Added : sp_word_brace_init_lst Jan 21 2020 Removed : sp_word_brace Jan 21 2020 466b8bcf5f8ee04686d2d7af62b5ce76241c777d Added : nl_func_call_args Jan 24 2020 807e27e81112f28ae71b21f43718a1b859ad473a Added : sp_before_oc_proto_list Feb 4 2020 94f18ac9c0c7c7fab64f14425aea69f0f49bb240 Added : indent_off_after_assign Feb 7 2020 25e20f9e4ab389c06fc76bcf0dcb3fe07ab91aea Added : indent_off_after_return Feb 7 2020 cee950462787ab3b7725c5fb77fa38b992527e99 Added : indent_oc_inside_msg_sel Feb 10 2020 2d04118314be95654f29fb32ae50b8cd46af8682 Added : nl_func_call_args_multi_line_ignore_closures Dec 17 2019 369192830c01beedcfe87c432f9c26637c1e6587 Added : indent_inside_ternary_operator Dec 9 2019 100db726b938d263c6c7f07530385dec0cdd711e Added : use_form_feed_no_more_as_whitespace_character Feb 21 2020 24e27fe8cdda55e422b1db659f255da353b3022c Added : debug_max_number_of_loops Feb 27 2020 30da6cafa6b0819c48a02513cadbc256a5b450c5 Added : debug_line_number_to_protocol Mar 17 2020 f5d8ee093eb521ecc0c57060b0009dd5f05e039e Added : mod_sort_incl_import_prioritize_filename Mar 27 2020 8d595cb0721b299db8f1169c22d38d45df899a51 Added : mod_sort_incl_import_ignore_extension Mar 27 2020 9f8b7754f03aa970ede730a5cd4e2cbd94f139cc Added : mod_sort_incl_import_prioritize_extensionless Mar 27 2020 6d5829551886ee9e643e5d6019c5389dfa738c3b Added : mod_sort_incl_import_prioritize_angle_over_quotes Mar 27 2020 27b33d779e7aa33c1ebc39a52e54c3a95bc153d4 Added : mod_sort_incl_import_grouping_enabled Mar 27 2020 ac62be9498fa195a54c0e2c76c438c641d68a917 Added : disable_processing_nl_cont Apr 12 2020 e2b17b724e00c6180c6bd6cb5b592e969c47b6a9 Added : nl_before_opening_brace_func_class_def Apr 22 2020 981c761da5a4a71b059361a883c4bfff69148c49 Added : nl_before_whole_file_endif Apr 24 2020 Added : nl_after_whole_file_endif Apr 24 2020 Added : nl_after_whole_file_ifdef Apr 24 2020 Added : nl_before_whole_file_ifdef Apr 24 2020 d55e9d21cd6377a38f741854baf1a561b984de36 Added : nl_func_call_end Apr 29 2020 Change highlights in uncrustify-0.70.1 (November 2019) ------------------------------------------------------------------------------- 5114ea856acd79cbf52fd4261b83d423fafd98da Added : nl_before_member Nov 17 2019 Added : nl_after_member Nov 17 2019 1e911250996a7138e33006af1b664362b255f4b5 Added : nl_template_end_multi_line Nov 17 2019 Added : nl_template_start_multi_line Nov 17 2019 Added : nl_template_args_multi_line Nov 17 2019 948bc227c46f89207346ad596e6199acb12d162f Added : sp_before_vardef_square Nov 18 2019 1ff6fc2da0b1cdef35089a2d6ac3364fbba304be Added : nl_template_start Nov 21 2019 Added : nl_template_args Nov 21 2019 Added : nl_template_end Nov 21 2019 Removed : nl_template_end_multi_line Nov 21 2019 Removed : nl_template_start_multi_line Nov 21 2019 Removed : nl_template_args_multi_line Nov 21 2019 2df82073bb1e3bc85f75c2165a541ba906f76b8d Added : indent_macro_brace Nov 18 2019 8cb5f1be52bcbcca4148cf0514b103dec5313c55 Added : indent_switch_break_with_case Nov 25 2019 Change highlights in uncrustify-0.70.0 (is not released) ------------------------------------------------------------------------------- 710b9b90d063e1fac853b77ad9509bed37ff31ee Added : mod_sort_case_sensitive May 12 2019 40c028454904f4fc87bd93b9703eaeb58fa57dd0 Added : sp_before_square_asm_block Jul 29 2019 b9b7f2fffb2c73925906ca7e5c8536d03c93c4bc Added : nl_multi_line_sparen_open Aug 3 2019 Added : nl_multi_line_sparen_close Aug 3 2019 83a014197001ea815f92d977fc30aa36dec39e1b Added : sp_cpp_lambda_square_paren Aug 20 2019 Added : sp_cpp_lambda_square_brace Aug 20 2019 Added : sp_cpp_lambda_paren_brace Aug 20 2019 Removed : sp_cpp_lambda_paren Aug 20 2019 8b6455c08c4f70b04b03b48c32fa14b9014354b4 Added : use_sp_after_angle_always Sep 13 2019 264ec3c988b5667c971b0d6508b17d0c9337c82c Added : sp_cpp_lambda_fparen Sep 13 2019 883ccefc3bf8c8cdf6b159f280e22c2d72ce83f5 Added : sp_func_type_paren Oct 11 2019 8284db41edbb777829f26d247470c75d3d317641 Added : nl_before_namespace Oct 8 2019 Added : nl_after_namespace Oct 8 2019 3af190ceda3f8025028b5f8aae7541d35bda39c7 Added : nl_template_class_def Oct 2 2019 Added : nl_template_func_def_special Oct 2 2019 Added : nl_template_using Oct 2 2019 Added : nl_template_func_def Oct 2 2019 Added : nl_template_class_decl Oct 2 2019 Added : nl_template_var Oct 2 2019 Added : nl_template_class_decl_special Oct 2 2019 Added : nl_template_func Oct 2 2019 Added : nl_template_func_decl_special Oct 2 2019 Added : nl_template_func_decl Oct 2 2019 Added : nl_template_class_def_special Oct 2 2019 e9bc08c3baa3b7545a592b5e1d0d23e530c58b7f Added : sp_trailing_return Oct 23 2019 d783ecfe7f08b525eb882ff3a7c6525d8866d54b Added : nl_oc_before_interface Oct 28 2019 Added : nl_oc_before_implementation Oct 28 2019 Added : nl_oc_before_end Oct 28 2019 3741e59342c5741020b84eba147b0c1dfde0154b Added : indent_func_def_param_paren_pos_threshold Nov 6 2019 829b4124c02e36156489d06a8b33e3552e58d30b Added : sp_brace_close_while Nov 8 2019 Added : sp_while_paren_open Nov 8 2019 Added : sp_do_brace_open Nov 8 2019 ea6f4ac515c0ad5651be020a3295dcae01c3baf9 Added : nl_create_list_one_liner Nov 11 2019 Change highlights in uncrustify-0.69.0 (May 2019) ------------------------------------------------------------------------------- Changing option: - The option name is changed from 'align_assign_func_proto' to 'align_assign_func_proto_span' Mar 4 17:19:40 2019 New options: - align_constr_value_gap Apr 24 2019 - align_constr_value_span Apr 24 2019 - align_constr_value_thresh Apr 24 2019 - align_func_proto_thresh Apr 5 2019 - indent_col1_multi_string_literal Mar 31 2019 - sp_paren_noexcept Jan 13 2019 - sp_paren_qualifier Jan 11 2019 - sp_type_question Jan 11 2019 - sp_inside_angle_empty Dec 27 2018 - nl_fdef_brace_cond Nov 29 2018 - nl_func_call_start Nov 29 2018 Change highlights in uncrustify-0.68 (November 2018) ------------------------------------------------------------------------------- New options: - align_same_func_call_params_span Nov 9 - align_same_func_call_params_thresh Nov 9 - nl_class_leave_one_liner_groups Oct 17 - nl_inside_namespace Aug 26 - sp_return_brace Aug 21 - align_assign_decl_func Jul 24 - sp_brace_brace Jul 23 - sp_after_decltype Jul 22 - sp_decltype_paren Jul 22 - align_right_cmt_same_level Jul 14 - nl_oc_mdef_brace Jul 8 - mod_enum_last_comma Jul 8 - sp_type_ellipsis Jun 15 - sp_paren_ellipsis Jun 15 - sp_sizeof_ellipsis Jun 15 - sp_sizeof_ellipsis_paren Jun 15 - indent_continue_class_head May 30 Bugfix: - Issue # 1709, 1713, 1729, 1736, 1739, 1740, 1748, 1752, 1755, 1758, 1760, 1762, 1763, 1776, 1778, 1782, 1783, 1784, 1786, 1788, 1789, 1804, 1827, 1832, 1838, 1839, 1854, 1865, 1867, 1870, 1875, 1876, 1888, 1904, 1916, 1917, 1918, 1919, 1942, 1946, 1947, 1958, 1960, 1962, 1965, 1969, 1979, 1982, 1985, 1997, 2000, 2001, 2009, 2014, 2015, 2024, 2028, 2032, 2033, 2035, 2037, 2046, 2055 Change highlights in uncrustify-0.67 (May 2018) ------------------------------------------------------------------------------- Changing option: Removed option: New options: - indent_first_for_expr Apr 29 - indent_semicolon_for_paren Apr 29 - nl_oc_interface_brace Apr 13 - nl_oc_implementation_brace Apr 13 - indent_cpp_lambda_only_once Mar 24 - indent_cs_delegate_body Mar 18 - sp_after_noexcept Mar 18 - indent_single_newlines Mar 6 - sp_after_ptr_block_caret Feb 24 - sp_after_oc_synchronized Feb 24 - sp_inside_square_oc_array Feb 23 - sp_oc_catch_paren Feb 23 - sp_oc_catch_brace Feb 23 - sp_oc_brace_catch Feb 23 - nl_oc_catch_brace Feb 23 - nl_oc_brace_catch Feb 23 - nl_cs_property_leave_one_liners Feb 16 - indent_member_single Feb 10 - sp_func_call_user_paren_paren Feb 5 - sp_func_call_user_inside_fparen Feb 5 - sp_inside_braces_oc_dict Feb 5 - nl_create_func_def_one_liner Jan 17 - nl_namespace_two_to_one_liner Jan 15 - nl_squeeze_paren_close Jan 15 - sp_fparen_brace_initializer Jan 12 - sp_cpp_before_struct_binding 2018 Jan 12 - indent_align_paren Dec 14 - nl_tsquare_brace Dec 9 - indent_single_after_return Nov 28 - indent_off_after_return_new Nov 28 - indent_ignore_asm_block 2017 Nov 05 New keyword: - __unused Apr 21 - @synchronized Feb 24 - @available Feb 23 - fixed Feb 16 - @protected Feb 4 - @public Feb 4 - __autoreleasing Feb 4 - __bridge Feb 4 - __bridge_retained Feb 4 - __bridge_transfer Feb 4 - __declspec Feb 4 - __has_include Feb 4 - __has_include_next Feb 4 - __strong Feb 4 - __typeof Feb 4 - __unsafe_unretained Feb 4 - __weak Feb 4 - self Feb 4 - unsafe_unretained 2018 Feb 4 - where 2017 Dec 6 Bugfix: - Debian issue #881249 "FTBFS on armel/i386/mips64el/s390x: cpp_33057 fails" is fixed - Adopt many bugfix and tests from UT: 10000, 10002, 10003, 10004, 10005, 10006, 10007, 10008, 10009, 10011, 10012, 10013, 10014, 10015, 10016, 10018, 10019, 10020, 10021, 10022, 10023, 10024, 10025, 10027, 10028, 10029, 10030, 10031, 10032, 10033, 10034, 10035, 10036, 10039, 10044, 10045, 10046, 10047, 10048, 10049, 10050, 10051, 10052, 10053, 10054, 10054, 10055, 10056, 10057, 10058, 10060, 10062, 10063, 10065, 10066, 10067, 10069, 10070, 10071, 10072, 10073, 10074, 10075, 10076, 10077, 10078, 10079, 10080, 10100, 10102, 10103, 10104, 60001, 60002, 60003, 60004, 60005, 60006, 60007, 60008, 60009, 60011, 60012, 60013, 60014, 60015, 60016, 60017, 60018, 60019, 60020, 60021, 60022, 60023, 60024, 60025, 60026, 60027, 60028, 60029, 60030, 60031, 60032, 60033, 60034, 60036, 60037, 60038, 60039, 60040 New: - Add crash handling for Windows Change highlights in uncrustify-0.66 (November 2017) ------------------------------------------------------------------------------- New options: - sp_arith_additive Oct 17 - sp_angle_colon Oct 17 - nl_func_call_empty Sep 30 - nl_func_call_paren_empty Sep 30 - align_func_params_span Sep 29 - align_func_params_thresh Sep 29 - align_func_params_gap Sep 29 - nl_func_call_paren Jul 25 - indent_paren_after_func_def Jul 21 - indent_paren_after_func_decl Jul 21 - indent_paren_after_func_call Jul 21 - nl_func_paren_empty Jul 07 - nl_func_def_paren_empty Jul 07 - indent_switch_pp Jun 22 - pp_indent_case Jun 22 - pp_indent_func_def Jun 22 - pp_indent_extern Jun 22 - pp_indent_brace Jun 22 Changing option: - The option name is changed from 'align_number_left' to 'align_number_right' Bugfix: - Issue # 548, 1098, 1103, 1108, 1112, 1127, 1134, 1158, 1165, 1170, 1187, 1200, 1203, 1236, 1249, 1310, 1315, 1340, 1349, 1352, 1366 are fixed Change highlights in uncrustify-0.65 (May 2017) ------------------------------------------------------------------------------- New options: - nl_before_if_closing_paren May 12 - sp_after_type_brace_init_lst_open May 09 - sp_before_type_brace_init_lst_close May 09 - sp_inside_type_brace_init_lst May 09 - sp_type_brace_init_lst May 09 - nl_type_brace_init_lst May 09 - nl_type_brace_init_lst_open May 09 - nl_type_brace_init_lst_close May 09 - mod_sort_oc_property_class_weight May 05 - mod_full_brace_nl_block_rem_mlcond Mar 17 - sp_inside_newop_paren_open Mar 13 - sp_inside_newop_paren Mar 13 - sp_after_newop_paren Mar 13 - sp_inside_newop_paren_close Mar 13 - pp_ignore_define_body Feb 18 - sp_enum_colon Feb 13 - nl_enum_class Feb 13 - nl_enum_class_identifier Feb 13 - nl_enum_identifier_colon Feb 13 - nl_enum_colon_type Feb 13 - indent_param Feb 01 - include_category_0 Jan 24 - include_category_1 Jan 24 - include_category_2 2017 Jan 24 - force_tab_after_define 2016 Dec 29 - nl_max_blank_in_func Nov 26 - indent_ternary_operator Nov 24 - indent_using_block Oct 20 New: - emscripten interface - removal of autogen / configure build - list options that are now AT_UNUM type - change option name from align_number_left to align_number_right Removed option: - dont_protect_xcode_code_placeholders Removed MS calling convention keywords: - __cdecl, __clrcall, __fastcall, __stdcall, __thiscall, __vectorcall Bugfix: - Issue # 324, 398, 404, 497, 525, 575, 633, 638, 643, 646, 663, 666, 679, 682, 687, 726, 752, 753, 793, 815, 825, 842, 857, 859, 869, 870, 889, 902, 916, 917, 928, 935, 938, 940, 972, 1002, 1005, 1020, 1030, 1032, 1041, 1068, 1117, 1139 are fixed - Proposal #381, 876 are adopted. Change highlights in uncrustify-0.64 (October 2016) ------------------------------------------------------------------------------- New: - Support for new C#6 language elements. (Bug #672) Expression filter with the keyword 'when' in try/catch is now supported. Null conditional operator (?.) is now supported. New options: - align_var_class_span Aug 23 - align_var_class_thresh Aug 23 - align_var_class_gap Aug 23 - pos_enum_comma Aug 14 - indent_token_after_brace Aug 3 - cmt_multi_first_len_minimum Aug 2 - nl_enum_own_lines Aug 1 - nl_func_class_scope Jul 26 - nl_squeeze_ifdef_top_level Jul 24 - sp_super_paren Jul 21 - sp_this_paren Jul 21 - sp_angle_paren_empty Jul 21 - sp_after_operator_sym_empty Jul 20 - sp_skip_vbrace_tokens Jul 13 - indent_cs_delegate_brace Jul 9 - cmt_insert_before_inlines Jun 29 - cmt_insert_before_ctor_dtor Jun 29 - mod_full_brace_if_chain_only Jun 28 - nl_func_decl_start_multi_line Jun 28 - nl_func_def_start_multi_line Jun 28 - nl_func_decl_args_multi_line Jun 28 - nl_func_def_args_multi_line Jun 28 - nl_func_decl_end_multi_line Jun 28 - nl_func_def_end_multi_line Jun 28 - nl_func_call_start_multi_line Jun 28 - nl_func_call_args_multi_line Jun 28 - nl_func_call_end_multi_line Jun 28 - use_options_overriding_for_qt_macros Jun 16 - sp_func_def_paren_empty Jun 15 - sp_func_proto_paren_empty Jun 15 - sp_func_class_paren_empty Jun 15 - nl_oc_block_brace May 26 - nl_split_if_one_liner May 26 - nl_split_for_one_line May 24 - nl_split_while_one_liner May 24 - nl_after_func_class_proto May 12 - nl_after_func_class_proto_group May 12 2016 Bugfix: - Bugs #620, #651, #654, #662, #663, #664, #670, #671, #672, #674 are fixed - Issues #322, #323, #359, #405, #408, #412, #478, #481, #495, #503, #509, #512, #513, #514, #518, #519, #520, #521, #522, #524, #529, #530, #533, #536, #539, #542, #543, #544, #546, #568 are fixed - Proposals #409, #477 are implemented - Issue #411 is partialy fixed Change highlights in uncrustify-0.63 (Mar 2016) ------------------------------------------------------------------------------- New: - The branch uncrustify4Qt is now merged. - A configuration file for the sources of uncrustify is provided: forUncrustifySources.cfg - Some considerations about the problem "stable" are described at forUncrustifySources.txt - Simplify expressions such as: if ((cpd.lang_flags & LANG_PAWN) != 0) to if (cpd.lang_flags & LANG_PAWN) - introduce CT_STDCALL to work with typedef void (__stdcall *func)(); Bug # 633 - introduce some more MS calling conventions: __cdecl, __clrcall, __fastcall, __thiscall, __vectorcall https://msdn.microsoft.com/en-us/library/984x0h58.aspx New options: - nl_before_func_class_def Apr 16 - nl_before_func_class_proto Apr 16 - nl_before_func_body_def Apr 25 - nl_before_func_body_proto Apr 25 - use_indent_continue_only_once Mar 7 2016 Bugfix: - Simplify some more expressions. - Bugfix for win32 for the flags. - make test c/ 00617 stable - make test c/ 02501 stable - The issue #467 and the test tests/output/c/02100-i2c-core.c are not yet fixed. - uncrustify all the sources with forUncrustifySources.cfg - better descriptions for options - bug #631 is fixed - produce a better dump output - DbConfig::configuredDatabase()->apply(db); is NOT a declaration of a variable - bug # 657 is fixed: change 'mode' if necessary for 'pos_class_comma' - fix 3 calls of unc_add_option for "align_oc_msg_colon_span", "indent_oc_block_msg", "indent_oc_msg_colon" - bugs #664, #662, #654, #653, #651 and #633 are fixed Reverse: - space: drop vbrace tokens... 2014-09-01 06:33:17 I cannot anderstand this change. It makes some troubles: Bug # 637 No test file for it found Reverse the change until more informations could be found Change: - CT_DC_MEMBER + CT_FOR into CT_DC_MEMBER + CT_FUNC_CALL Some more Qt-macros: - Q_GADGET - for_each Change highlights in uncrustify4Qt-0.62 (Oct 2015) ------------------------------------------------------------------------------- This is an extention of uncrustify to support Qt-macros - Q_OBJECT - Q_EMIT - SLOT - SIGNAL - Q_FOREACH - Q_FOREVER Change highlights in uncrustify4Qt-0.62 (Oct 2015) ------------------------------------------------------------------------------- New options: - use_indent_func_call_param Change highlights in uncrustify-0.62 (2 Feb 2016) ------------------------------------------------------------------------------- This release is just a roll-up of the past year. Many bugs were squashed and many options were added. New options: - string_replace_tab_chars - disable_processing_cmt - enable_processing_cmt - enable_digraphs - indent_class_on_colon - indent_shift - indent_min_vbrace_open - indent_vbrace_open_on_tabstop - sp_after_mdatype_commas - sp_before_mdatype_commas - sp_between_mdatype_commas - sp_cmt_cpp_doxygen - sp_cmt_cpp_qttr - sp_between_new_paren - nl_while_leave_one_liners - nl_synchronized_brace - nl_before_synchronized - nl_after_synchronized - nl_after_label_colon Change highlights in uncrustify-0.61 (22 Dec 2014) ------------------------------------------------------------------------------- This release is just a roll-up of the past two years. Many bugs were squashed and many options were added. New options: - indent_paren_open_brace - indent_namespace_single_indent - indent_constr_colon - indent_oc_msg_prioritize_first_colon - indent_oc_block_msg_xcode_style - indent_oc_block_msg_from_keyword - indent_oc_block_msg_from_colon - indent_oc_block_msg_from_caret - indent_oc_block_msg_from_brace - sp_enum_paren - sp_cparen_oparen - sp_after_ptr_star_qualifier - sp_after_constr_colon - sp_before_constr_colon - sp_fparen_dbrace - sp_word_brace - sp_word_brace_ns - sp_cond_colon_before - sp_cond_colon_after - sp_cond_question_before - sp_cond_question_after - sp_cond_ternary_short - align_keep_extra_space - nl_cpp_lambda_leave_one_liners - nl_brace_square - nl_brace_fparen - nl_constr_init_args - nl_cpp_ldef_brace - nl_paren_dbrace_open - nl_constr_colon - pos_constr_comma - pos_constr_colon - mod_add_long_namespace_closebrace_comment - cmt_convert_tab_to_spaces Change highlights in uncrustify-0.60 (1 Jan 2013) ------------------------------------------------------------------------------- Objective C support was greatly enhanced in this release. Many bugs were squashed and many options were added. New options: - align_oc_msg_colon_first - align_pp_define_together - indent_ctor_init_leading - indent_func_def_force_col1 - indent_oc_block - indent_oc_block_msg - indent_oc_msg_colon - ls_code_width - nl_after_annotation - nl_before_return - nl_between_annotation - nl_brace_struct_var - nl_oc_msg_args - nl_oc_msg_leave_one_liner - nl_remove_extra_newlines - nl_scope_brace - nl_typedef_blk_end - nl_typedef_blk_in - nl_typedef_blk_start - nl_unittest_brace - nl_var_def_blk_end - nl_var_def_blk_in - nl_var_def_blk_start - nl_version_brace - sp_after_for_colon - sp_after_oc_dict_colon - sp_after_oc_msg_receiver - sp_after_oc_property - sp_after_throw - sp_after_tparen_close - sp_annotation_paren - sp_before_for_colon - sp_before_oc_dict_colon - sp_before_pp_stringify - sp_before_template_paren - sp_cpp_lambda_assign - sp_cpp_lambda_paren - sp_extern_paren - sp_inside_sparen_open - sp_inside_tparen - sp_permit_cpp11_shift - sp_ptr_star_paren Changed default: - sp_pp_stringify = ignore (was add) See commit.log for details. Change highlights in uncrustify-0.59 (4 Oct 2011) ------------------------------------------------------------------------------- The biggest change in this release was to rework the string handling to add proper support for UTF-8 and UTF-16. New options: - nl_case_colon_brace - indent_ctor_init - sp_before_tr_emb_cmt - sp_num_before_tr_emb_cmt - utf8_bom - utf8_byte - utf8_force - sp_after_new - nl_after_struct - nl_after_class - nl_property_brace - nl_after_func_body_class See commit.log for details. Change highlights in uncrustify-0.58 (19 May 2011) ------------------------------------------------------------------------------- New options: - tok_split_gte - sp_catch_paren - sp_scope_paren - sp_version_paren - cmt_insert_oc_msg_header See commit.log for details. Change highlights in uncrustify-0.57 (25 Nov 2010) ------------------------------------------------------------------------------- New options: - sp_func_call_paren_empty - nl_func_def_start - nl_func_def_start_single - nl_func_def_paren - nl_func_def_args - nl_func_def_empty - nl_func_def_end - nl_func_def_end_single See commit.log for details. Change highlights in uncrustify-0.56 (27 Mar 2010) ------------------------------------------------------------------------------- New options: - indent_continue - indent_cmt_with_tabs - indent_first_bool_expr - indent_braces_no_class - indent_braces_no_struct - indent_var_def_cont - sp_assign_default - sp_after_oc_at_sel_parens - sp_inside_oc_at_sel_parens - align_oc_decl_colon - nl_after_vbrace_close - nl_using_brace - mod_full_brace_using See commit.log for details. Change highlights in uncrustify-0.55 (27 Nov 2009) ------------------------------------------------------------------------------- - See the GIT history for a full list of changes - Fix align_left_shift with array indexes - Objective C changes (Andre Berg) - Fix a close paren added inside a preprocessor line - Fix handling of 'mutable' - New options - sp_endif_cmt - nl_func_decl_start_single - nl_func_decl_end_single - nl_after_vbrace_open_empty - Improved options - sp_before_ellipsis - nl_struct_brace - align_on_tabstop - align_with_tabs - align_left_shift - nl_func_type_name - nl_create_if_one_liner - pos_assign Changes in uncrustify-0.54 (16 Oct 2009) ------------------------------------------------------------------------------- - Add mod_case_brace - Add sp_after_semi_for and sp_after_semi - Add align_oc_msg_colon - ObjC: Do not set the parent of everything in a message at OC_MSG (was breaking casts) - ObjC: sp_before_square does not apply in "if (i < [a count])" - Fix crash bug in chunk_get_prev() at the start of the file - Fix issue with #if COND followed by a cast on the next line - Add nl_func_decl_empty - Add nl_func_type_name_class - Add cmt_reflow_mode (Ger Hobbelt) - A case statement starts an expression. Fixes "case -1:" - Improve semicolon removal test - fix marking of brace/paren pairs that have a preproc inside - fix nl_func_type_name where the return type contains a template - Add mod_full_brace_if_chain - fix detection of deref in a macro function - fix detection of "std::vector functions;" - Remove extra semicolons on an 'else if' - Add sp_before_ellipsis - treat a constructor the same as a function regarding nl_func_decl_* - Add nl_brace_brace - Allow any number of spaces between multi-line comments when combining them - Add pos_compare - Add pos_conditional - Fix indent_relative_single_line_comments - Add sp_after_oc_return_type and sp_after_oc_at_sel (Andre Berg) - Add indent_namespace_level (James LewisMoss) - Add indent_namespace_limit (Maciej Libera) Changes in uncrustify-0.53 (16 May 2009) ------------------------------------------------------------------------------- - Fix sp_inside_braces* options, which were broken by the fix to issue #2629652 - Fix sp_after_cast, which was broken by a previous fix - Be a little more agressive in removing unecessary semicolons - Fix one case where the parser leaves a preprocessor #define - Fix indent of line starting with '(' after a function name - Add align_var_def_attribute - Fix nl_func_type_name for function without a return type (ie, cast operator) - Reset up state variables after processing a file - Fix a case where a semicolon was incorrectly removed - Fix a case where braces were incorrectly removed - Fix handling of 'force' setting for many newline options - Add func_wrap type for use with 'set func_wrap FSUB' - Add type_wrap type for use with 'set type_wrap STACK_OF' - Make file replacement more atomic - write to a temp file then rename - With the 'replace' option, only replace if the file content changes - Handle C# wide literal string prefix S"foo" - Handle the ObjC '@protocol' the same as '@interface' - Add 'make check' and 'make clean' (Ger Hobbelt) - Add align_right_cmt_at_col (Ger Hobbelt) - Add sp_pp_concat and sp_pp_stringify (Ger Hobbelt) - Add mod_add_long_ifdef_{else,endif}_comment (Ger Hobbelt) - Objective C improvements (Etienne Samson) - Only mess with escaped newlines in a comment if inside a preprocessor - Fix pos_xxx options when a preprocessor is near - Apply Debian patch to man file - Fix '<<' indenting/aligning (moved from indent.cpp to align.cpp) - Rework the sp_before_nl_cont option - Fix a few other bugs Changes in uncrustify-0.52 (28 Feb 2009) ------------------------------------------------------------------------------- - Add sp_before_assign and sp_after_assign - Add sp_enum_before_assign and sp_enum_after_assign - Add indent_var_def_blk - Add sp_inside_sparen_close for the 'CGAL' style - First pass at supporting ECMAScript (.es) files - Add support for the C# '??' operator - Fix conflict between nl_after_func_proto_group and nl_squeeze_ifdef - Add sp_cmt_cpp_start - Add align_on_operator - Fix nl_func_type_name for operators - Allow '$' to be part of identifiers (global change) - Fix detection of the '*' in 'int a = b[0] * c;' - Fix and improve the description of nl_multi_line_cond - Fix handling of global namespace type such as '::sockaddr' - Add nl_after_brace_close - Add nl_func_scope_name - Add cmt_insert_file_footer Changes in uncrustify-0.51 (27 Nov 2008) ------------------------------------------------------------------------------- - Prefer to split at ',' and then '=' in for() statements if at paren level - Fix a NULL deref crash - Fix nl_namespace_brace when something trails the open brace - Get sp_after_sparen and sp_sparen_brace to play well together - Ignore trailing comments when inserting the function header comment - Combine two C comments when they have no space between them "/***//***/" - Add cmt_insert_before_preproc - Add mod_remove_empty_return - Add nl_comment_func_def - Fix aligning of anonymous bit fields - Add indent_align_assign - Add sp_before_case_colon - Fix D 'invariant' handling - Add sp_invariant_after_paren and sp_invariant_paren - Fix handling of the C# [assembly: xxx] construct - Fix handling of the C# 'base()' construct - Add sp_range for the D '..' range operator as in [start .. end] - Update $(fclass) and $(function) to handle operators - Improve handling of inserted comments - Enable 'finally' blocks for C# - Add nl_after_try_catch_finally - Add nl_between_get_set and nl_around_cs_property Changes in uncrustify-0.50 (25-Oct-2008) ------------------------------------------------------------------------------- - Fix sp_before_unnamed_ptr_star in 'char ** n' - Fix crash when a open brace is at the end of a file - ObjC class definitions do not need { } - Fix ObjC msg detection - Add sp_after_ptr_star_func, sp_before_ptr_star_func - Add sp_after_byref_func, sp_before_byref_func - Treat an ObjC msg decl more like a function def - Add indent_func_const, indent_func_throw (Thanks, Ron) - Fix detection of prototype inside extern or namespace braces - Add align_left_shift to handle aligning of '<<' - Add sp_cpp_cast_paren - Add support for ObjC '@property' statements - Add sp_brace_typedef and sp_case_label - Merge in the lastest UniversalIndent support (Thanks, Thomas!) - Fix extra '\r' in multi-line comments and strings - Add sp_throw_paren - Assume a '<' in a preprocessor can't be part of a template - Don't align a constructor with class variables - Fix ending column error when tokenizing strings Changes in uncrustify-0.49 (22-Aug-2008) ------------------------------------------------------------------------------- - Allow the MSVC++ '64' suffix on numbers - Initialize align_stack class members for the MSVC++ compiler - Indent a line that starts with '=' - Add pos_arith and pos_assign (Thanks, Ron!) - Fix pos_bool & code_width interaction (Thanks, Ron!) - Fix cmt_width, which was going one word over the limit. (Thanks, Ron!) - Major rework of the aligning code to better handle the gap options - Indent comments before 'case' at the same level as 'case' - mod_add_long_*_closebrace_comment adds the right comment type. (Thanks, Ron!) - Relax number parsing even further to accept stuff like "3A" - Add sp_after_oc_colon (Thanks, Kevin!) - Add better detection and labeling of Objective C messages - Add sp_after_send_oc_colon and sp_before_send_oc_colon (Thanks, Kevin!) - Fix detection of '*' in "return n * f();" - Add the 'set' config option which lets you create arbitrary keywords - Add sp_func_call_user_paren and the 'func_call_user' keyword type Changes in uncrustify-0.48 (18-Jul-2008) ------------------------------------------------------------------------------- - Fix classification of '(' in '#if defined (FOO)' - Add sp_defined_paren - Fix handling of negative in '#if X < -1' - Revert a change that broke indent continuation in an assignment - Fix interaction between nl_squeeze_ifdef and nl_after_{if,for,while,switch,do} - Preprocessor indents are indents, so indent_with_tabs=1 should do tabs - Add pp_indent_count - Handle C++ style casts, such as 'int(42.0)' a bit better - Another rework of template detection - Add sp_before_nl_cont, defaults to 'add' - If a statement starts with 'operator', it is a function call - Change sp_angle_word to be more generic - Add sp_after_operator_sym for "operator ++(" vs "operator ++ (" - Add sp_template_angle for "template<" vs "template <" - Add support for " *INDENT-OFF* " and " *INDENT-ON* " - Shuffle around spacing priorities - Add handling for '...' in variadic templates - Extend nl_template_class to handle anything after 'template <...>' - Treat the template '<' the same as '(' for indenting - Add indent_template_param - Split internal CT_CAST into CT_C_CAST, CT_CPP_CAST and CT_D_CAST - Swap priority of sp_after_angle and sp_before_ptr_star - Change cmt_multi_indent=false to disable all reformatting (needs more work) - Fix align_var_def_span - it wasn't counting newlines when it recursed - Add nl_else_if - mod_full_brace_if: Don't remove braces around certain 'else' statements - Tweak template detection a bit more - Rework and simplify multi-line comment indenting - Add indent_else_if - Improve right-comment aligning - Fix detection of functions with a 'const' return type - Add sp_cond_colon and sp_cond_question - Fine-tune the right comment align stuff - Add cmt_multi_check_last - Add align_right_cmt_gap - Add nl_return_expr - Indent FPAREN_OPEN if after a newline but not before a newline - Give sp_after_operator_sym priority over sp_func_call_paren - Add align_same_func_call_params Changes in uncrustify-0.47 (06-Jun-2008) ------------------------------------------------------------------------------- - Fix inifinite loop bug in reindent_line - Fix prototype detection with template parameter types - Fix off-by-1 error on positive values for indent_access_spec and indent_label - Add indent_extern to control indent extern-type namespaces - Add initial support for Objective C++ (extension '.mm') - Add nl_before_throw and indent 'throw' if after a prototype - Extend line numbers to 32 bits (used for logging) - Remove alternate token support for '<%', '%>', '<:', ':>', '%:', and '%:%:' - Fix recently-broken mixing of right-comment aligning (PP_ENDIF/PP_ELSE issue) - Indent a 'break' that follows a fully-braced 'case' at the level of the close brace - Add mod_move_case_break - Fix '&' and '*' after 'delete' - Escape opening '/*' when converting C++ comments to C comments - Add sp_inside_braces_empty - Fix cmt_sp_after_star_cont - Fix cmt_sp_before_star_cont - Explicitly disallow a tab after a space - Improve multi-line comment indenting a bit - Add sp_before_unnamed_byref and sp_before_unnamed_ptr_star Changes in uncrustify-0.46 (22-Apr-2008) ------------------------------------------------------------------------------- - Load the config file, if available, before handling '--universalindent' - Add align_var_def_gap, align_var_def_colon_gap, align_var_struct_gap, align_func_proto_gap, align_mix_var_proto, align_single_line_brace_gap - (internal) Eliminate the 'trailer' stuff, simplify aligning Changes in uncrustify-0.45 (7-Mar-2008) ------------------------------------------------------------------------------- - Fix buffer overflow in logger code - Add sp_enum_assign - For elipses handling in the GCC extension "case 1 ... 5:" - Add sp_after_class_colon, sp_before_class_colon, and sp_after_type - Send usage text to stdout instead of stderr - Fix mod_add_long_function_closebrace_comment if the file doesn't end in a newline - Redo alignments after splitting long lines - Add indent_relative_single_line_comments - Add indent_access_spec_body - Fix indent_func_proto_param to work on constructors - Add cmt_indent_multi - Add align_single_line_brace and align_single_line_func - Fix interaction of virtual braces and #pragma - Fix indenting problem with an assignment the last part of a for() - Fix the order of opening files so that '-f' and '-o' can be used together - Added a man file - Many improvements thanks to Stas Grabois - Fix a D problem due the lack of semicolons after struct/enum definitions - Improve the way aligning is done Changes in uncrustify-0.44 (12-Feb-2008) ------------------------------------------------------------------------------- - Fix issue with #else and unmatched braces (issue 1868493) - Update UnivarsalIndentGUI config output - Add the version to generated config files - Add nl_multi_line_define - Minimize distance between code and the backslash-newline in macros - Properly handle stuff like '#define MYHEADER ' - Fix detection of 'int foo(int);' in C++ (func proto, not class variable) - Improve handling of multi-line comments in a macro - Fix crash bug with some ctype implementations - Fix incorrect indenting of nested #endif with pp_if_indent_code - Fix problem with nl_after_if and nl_before_if w/ trailing comments Changes in uncrustify-0.43 (08-Jan-2008) ------------------------------------------------------------------------------- - Add align_right_cmt_mix to control aligning of comments after '}' and '#endif' - Allow a line split after an assignment - Fix infinite loop bug - Add sp_sign and sp_incdec - Fix vbrace conversion where some are converted and some aren't - Add a vbrace before a #pragma instead of after - Improve Objective C support - Add sp_before_oc_colon, sp_after_oc_scope, and sp_after_oc_type for ObjC - Add align_oc_msg_spec_span for ObjC - Add sp_member for spacing around '->' and '.' - More template handling improvements - Fix a NULL dereference related to __attribute__ Changes in uncrustify-0.42 (30-Nov-2007) ------------------------------------------------------------------------------- - Fix bug that would remove a newline after a C++ comment - Add "--mtime" command line option to preserve the mtime - Remove extra semicolons before inserting newlines after semicolons - Fix broken struct initializer alignment - Fix problem with pos_class_comma in a #define - Fix problem with an incomplete statement in a #define and virtual braces - Add indent_func_proto_param and indent_func_def_param - Add nl_func_proto_type_name, split from nl_func_type_name - Add mod_add_long_switch_closebrace_comment, mod_add_long_function_closebrace_comment - Add mod_sort_import to sort import statements (Java/D) - Add mod_sort_using to sort using statements (C#) - Add mod_sort_include to sort #include (C/C++) and #import (ObjC) statements - Add indent_func_class_param, indent_func_ctor_var_param, and indent_func_param_double - Fix inserting a newline before a preprocessor - Don't split empty function parens for code_width stuff Changes in uncrustify-0.41 (07-Nov-2007) ------------------------------------------------------------------------------- - Add cmt_insert_func_header, cmt_insert_file_header, and cmt_insert_class_header - Fix detection of prototypes without named parameters - sp_after_byref and sp_after_ptr_star only are applied if before a word - internal rework - Add pp_define_at_level - Fix detection of deref in "sizeof *x" - Fix broken output of backslash-newline in certain situations - Fix pp_indent_if stuff - Add nl_after_brace_open_cmt - Properly handle anonymous namespaces - Add pp_space_count Changes in uncrustify-0.40 (12-Oct-2007) ------------------------------------------------------------------------------- - Simplify preprocessor indenting - Add pp_indent_region and pp_region_indent_code - Add pp_indent_at_level - Add pp_indent_if and pp_if_indent_code - Add initial VALA support - Fix a problem with mod_full_paren_if_bool and functions - Add nl_func_paren - Fix function type parameter marking (broken in the last few releases) - Don't remove newline chunks before/after a preprocessor Changes in uncrustify-0.39 (25-Sep-2007) ------------------------------------------------------------------------------- - Improve conversion operators - Prevent undesired chunk combining ("~ ~" vs "~~" in D) - Add nl_after_multiline_comment - Fix handling of try/catch/finally blocks in virtual braces - Add sp_inv, sp_not, sp_addr, sp_deref (default to remove) - Fix nl_class_brace - Fix indent_func_call_param - Add nl_create_if_one_liner, nl_create_for_one_liner, nl_create_while_one_liner - Add indent_preserve_sql - Fix one-liner detection with multiple statements on one line - Add nl_func_leave_one_liners and nl_if_leave_one_liners - More template improvements Changes in uncrustify-0.38 (04-Sep-2007) ------------------------------------------------------------------------------- - Fix line splitting WRT the CT_SPACE token - Improve function call/prototype/definition detection - Fix some spacing issues - More template improvements - Allow for a C++ struct constructor - Add nl_before_access_spec and nl_after_access_spec - Add cmt_width, cmt_c_group, cmt_c_nl_start, cmt_c_nl_end - Handle conversion operators Changes in uncrustify-0.37 (16-Aug-2007) ------------------------------------------------------------------------------- - A bunch of D language improvements - Add sp_d_array_colon, nl_assign_square, nl_after_square_assign - Fix static keyword sort order - Improve typedef detection and aligning - Split nl_ds_struct_enum_close_brace out of nl_ds_struct_enum_cmt - Add indent_paren_close - Add indent_comma_paren and indent_bool_paren Changes in uncrustify-0.36 (04-Aug-2007) ------------------------------------------------------------------------------- - Add nl_after_vbrace_open - Improve option descriptions - Fix seg faults (check for NULL) - Fix spacing for operators () and [] - Add sp_before_dc and sp_after_dc to control spacing around '::' - Split pos_class_comma from pos_comma - Improve line splitting a little - no longer break at '::' or '->' or '.' - Add nl_enum_leave_one_liners and nl_getset_leave_one_liners - Add mod_remove_extra_semicolon - Fix handling of macro-open and macro-close - Add align_var_struct_thresh - Improve handling of comments after braces - Add support for Qt slots and signals - Add align_typedef_amp_style and align_var_def_amp_style - Add sp_attribute_paren and handling of the '__attribute__' macro - Add align_typedef_func, improve aligning of typedefs - Add sp_after_semi_for_empty Changes in uncrustify-0.35 (14-Jul-2007) ------------------------------------------------------------------------------- - Fix bug with nl_func_type_name and empty param list: int foo() { ... } - Don't parse pragma bodies - Properly indent multiline #error and #warning - Change nl_after_func_body to force the newline count (was a minimum) - Fix handling of CT_PTR_STAR when all options are AV_IGNORE - Fix problem when the first token in the file isn't in column 1 - Properly mark catch clauses that contain parameters, ie catch (Exception *e) - Add a newline after the open brace for nl_catch_brace, nl_do_brace, nl_else_brace, nl_try_brace, nl_getset_brace, nl_finally_brace - Add nl_multi_line_cond - Fix a bug with mod_full_paren_if_bool - Fix handling of templated variables: Buffer* buf - Fix handling of dynamic_cast(obj) stuff - Fix detection of templates in for() statements: for (std::map::iterator it = map.begin(); ... - Add --no-backup command-line option to replace w/o a backup file - Fix nl_class_leave_one_liners when set to false - Add nl_class_colon, which split the functionality of nl_class_init_args - Improve detection of reference variable declarations (A& B) Changes in uncrustify-0.34 (11-May-2007) ------------------------------------------------------------------------------- - Add sp_angle_paren and sp_angle_word - Properly handle multi-line CPP comments - Add sp_inside_paren_cast - improve indent_class_colon - fix indenting on open parens - Add sp_before_semi_for_empty - Fix detection of while if the do is in a preprocessor chunk (1675673) - (pawn) Don't add vsemi after case/switch brace close (1684840) - Add nl_assign_leave_one_liners to allow "foo_t foo = { 0, 1 };" - Change handling of #region stuff so that it is indented at brace level - Fix handling of missing semicolon after while-of-do. - Fix crash-bug in handling bad code: "if (a && );" - Add pos_comma Changes in uncrustify-0.33 (05-Mar-2007) ------------------------------------------------------------------------------- - Fix converting C++ comments with embedded C comments - Fix nl_func_var_def_blk with class variables - Fix some output issues with the 1st line and C++ comments - Eliminate indent_case_body, which wasn't used - Change rules for indenting case braces and the use of indent_case_brace - Fix variable declaration detection at the start of a code block - Add support for custom open/close indenting macros MACRO_OPEN, MACRO_ELSE, MACRO_CLOSE - Fix the config updating routines to NOT lose custom types and stuff - Add nl_after_func_body_one_liner - Fix nl_class_init_args - Add --universalindent option to output an ini file for UniversalIndentGUI Changes in uncrustify-0.32 (20-Feb-2007) ------------------------------------------------------------------------------- - Enable align_proto_var_def for constructors - Fix while-of-do handling inside virtual braces - Fix problem with comments between a close brace and else - Add sp_before_comma - Change align_var_def_star to align_var_def_star_style - Change align_proto_var_def to align_func_params - Add ls_func_split_full and ls_for_split_full - Rework code width code a bit - Start Objective C support - Add cmt_sp_before_star_cont and cmt_sp_after_star_cont - Fix spacing between (( and )) - Add nl_try_brace, nl_catch_brace, nl_finally_brace, nl_brace_catch, nl_brace_finally, sp_catch_brace, sp_brace_catch, sp_finally_brace, sp_brace_finally, sp_try_brace - Treat typedef functions the same as other function for param aligning - Turn any word after a enum/struct/union into a type - Add sp_getset_brace and nl_getset_brace - Add mod_full_paren_if_bool - Add nl_before_c_comment and nl_before_cpp_comment - Fix nl_class_leave_one_liners - Add nl_ds_struct_enum_cmt - Add sp_balance_nested_parens Changes in uncrustify-0.31 (24-Jan-2007) ------------------------------------------------------------------------------- - Improve mixed tab indent / space align - Try to fix spacing around embedded comments - Add indent_access_spec - Add __func__ and __FUNCTION__ detection for non-C99 compilers - General code cleanup (Thanks Tom!) - Add indent_xml_string - Add align_proto_var_def to align variables in prototypes Changes in uncrustify-0.30 (24-Nov-2006) ------------------------------------------------------------------------------- - Use environment variable UNCRUSTIFY_CONFIG if no '-c' option (non-WIN32) - Default to ~/.uncrustify.cfg if no '-c' option and no env var (non-WIN32) - Add '-q' option to the usage info - Added initial embedded SQL support - Many bug fixes - New options: indent_braces_no_func, indent_sing_line_comments, nl_before_if, nl_before_for, nl_after_for, nl_before_while, nl_after_while, nl_before_switch, nl_after_switch, nl_before_do, nl_after_do Changes in uncrustify-0.29 (26-Oct-2006) ------------------------------------------------------------------------------- - Add support for the 'Klaus' style - Fix a bunch of c++ template bugs - Add option nl_class_leave_one_liners Changes in uncrustify-0.28 (06-Oct-2006) ------------------------------------------------------------------------------- - Fix D range array detection a[1..4] => a[1 .. 4] - Fix D delegate variable aligning - More documentation updates (thanks Dirk!) - New options: nl_after_semicolon and nl_after_open_brace Changes in uncrustify-0.27 (23-Sep-2006) ------------------------------------------------------------------------------- - Improve template detection again (allow CT_TYPE in a template) - Fix bad formatting in "[ABC * 123]" and "[0xf & *val]" - Add --replace option to convert files in-place - Use a map for the options - Major configuration/option cleanup - add -o option to write to a file instead of stdout Changes in uncrustify-0.26 (09-Sep-2006) (removed a number from the version) ------------------------------------------------------------------------------- - Fix preprocessor labeling WRT comments - Fix an indenting problem - Add sp_after_byref - Fix alignment of global variable definitions - Fix detection of deref inside squares: a[*p] - Fix a weird indenting bug - Fix D template ! spacing - Add sp_after_operator - Add nl_template_class - Add start to detailed docs inside the program - Add --prefix and --suffix command line args - Add align_enum_equ_thresh and fix align_enum_equ_span - Fix formatting of function typedefs - Add indent_member - Simplify the indenting code a bit - Improve type_cast stuff (ie, dynamic_cast<> or static_cast<>) and templates Changes in uncrustify-0.0.25 (26-Aug-2006) ------------------------------------------------------------------------------- - Add sp_after_ptr_star, sp_before_ptr_star, sp_between_ptr_star - Fix D tokenizing for numbers and strings - Fix a bug with cast detection and with nl_after_func_proto - Improve template detection - Rename nl_bool_pos to pos_bool - Add pos_class_colon - Add indent_class_colon - Add nl_class_init_args - Add nl_collapse_empty_body - Add indent_square_nl Changes in uncrustify-0.0.24 (05-Aug-2006) ------------------------------------------------------------------------------- - Add initial PAWN support (thanks to Derek Evan Mart for testing and motivation!) - Fix parsing of numbers like 10.0 - Fix double negative (- -x) vs (--x) - Add ability to convert C++ (//) comments into C (/* */) comments - Fix usage of indent_columns; output_tab_size is only needed if using tabs - Add first small step in code width handling - New options: sp_fparen_brace, sp_macro, sp_marco_func, nl_elseif_brace, mod_pawn_semicolon, cmt_cpp_to_c, cmt_cpp_group, cmt_cpp_nl_start, cmt_cpp_nl_end, sp_after_tag Changes in uncrustify-0.0.23 (22-Jul-2006) ------------------------------------------------------------------------------- - Fix some crash bugs and some formatting problems - Fix Windows CRLF issues (binary vs text mode) - Add indent_class and indent_namespace - Add nl_class_brace and nl_namespace_brace - Add handling of operator stuff in CPP - Improve the test script a bit - Add sp_inside_fparens - Add ability to define types in the config file - Started work on improving #ifdef handling by evaluating the preprocessor Changes in uncrustify-0.0.22 (15-Jul-2006) ------------------------------------------------------------------------------- - Implement nl_max, nl_before_block_comment, nl_after_func_body, nl_after_func_proto, nl_after_func_proto_group - Improve detection of function prototypes - Improve marking of function prototype-related tokens - Improve variable definition aligning - fix align_var_def threshold - Improve handling of "private:" style stuff - Handle types with "::" in them - Add preprocessor spacing and indenting - Fix tab indenting style 1 (tab indent, space align) - Improve multi-line comment formatting Changes in uncrustify-0.0.21 (01-Jul-2006) ------------------------------------------------------------------------------- - Clean up some memory leaks & uninitialized variables - Add option to process multiple files at once - Change the newlines values from [UNIX, DOS, MAC] to [LF, CRLF, CR] - Properly mark the parens for functions - Implement control over the format of the function prototypes and definitions - Update configuration.txt Changes in uncrustify-0.0.20 (10-Jun-2006) ------------------------------------------------------------------------------- - Fix cast on a sizeof: (INT32)sizeof(x) - Fix this: "#define SOME_JUNK /*lint -e123 */(const mytype_t *)-1" - Don't align function typedefs (fixed again) - Finally fix the DOS and MAC line-ending support - Add line-ending autodetection - Add Windows build support Changes in uncrustify-0.0.19 (27-May-2006) ------------------------------------------------------------------------------- - Fix C/C++/C# casts - Improve D casts Changes in uncrustify-0.0.18 (12-May-2006) ------------------------------------------------------------------------------- - Add nl_bool_pos to move boolean ops between eol and sol - Improve C99 array initializer aligning/formatting - Replace nl_eat_start, nl_eat_end, and nl_eof_min with nl_start_of_file, nl_start_of_file_min, nl_end_of_file, and nl_end_of_file_min Changes in uncrustify-0.0.17 (03-May-2006) ------------------------------------------------------------------------------- - Add nl_eat_start to remove newlines at the start of the file - Add nl_eat_end to remove newlines at the end of the file - Add nl_eof_min to set the minimum number of newlines at the end of file - Add newlines setting to configure the newline output - Add '-q' command line option to turn off logging - Fix bug in nl_func_var_def_blk handling Changes in uncrustify-0.0.16 (21-Apr-2006) ------------------------------------------------------------------------------- - Add a stack alignment helper class - Improve typedef formatting - Add aligning thresholds for typedefs and assignments - update the automake/autoconf stuff Changes in uncrustify-0.0.15 (14-Apr-2006) ------------------------------------------------------------------------------- - Switch to C++ - Improve C++ template formatting - Improve C++ class handling Changes in uncrustify-0.0.14 (09-Apr-2006) ------------------------------------------------------------------------------- - Read from stdin if no file is specified - Build on OS X Changes in uncrustify-0.0.13 (07-Apr-2006) ------------------------------------------------------------------------------- - Rewrite the indent code - Fix a bunch of small problems with C casts - Rename a few files - Add more tests Changes in uncrustify-0.0.12 (30-Mar-2006) ------------------------------------------------------------------------------- - Add support for D template format "Foo!(int,char)" - Fix a format bug in a log - Fix elipsis spacing (remove space before elipsis) - Don't use getopt as it isn't all that portable (at least for QNX) - Rename some files - Bugfix: don't add virtual braces on the same line as a preprocessor - Bugfix: clean up indexed array aligning Changes in uncrustify-0.0.11 (27-Mar-2006) ------------------------------------------------------------------------------- - fix brace analysis on else statement - allow options to depend on other options - set the parent for case braces - handle/indent the C++ class colon thingy - handle C++ constructors and function defs - special handling for '::' operator - implement case indenting - handle cout '<<' indenting - handle DOS and MAC line endings in multiline comments - rename some indent options - fix ifndef handling - fix volatile handling - fix private/public/protected 'label' handling - alternate punctuators are also part of C++ - handle C++ wide L"strings" - improve C# get/set handling - fix spacing bug "a++;" vs "a ++;" due to statement start misdetect - add nl_assign_brace - fix parent of vbrace close - more test enhancements Changes in uncrustify-0.0.10 (22-Mar-2006) ------------------------------------------------------------------------------- - Complete rewrite of tokenizer and brace parser - Added support for D nested comments - Fixed some virtual brace bugs - Added some documentation for the brace parsing stuff - Add more tests to improve coverage (still lacking) Changes in uncrustify-0.0.9 (18-Mar-2006) ------------------------------------------------------------------------------- - Major enhancements for D - Add handling for special "[]" sequence for C#/D - add some more tests Changes in uncrustify-0.0.8 (13-Mar-2006) ------------------------------------------------------------------------------- - update TODO list - add a threshold for brace removal - improve brace removal - keep track of whether a token follows a tab - add option to preserve non-indenting tabs - major keyword and operator cleanup for C++, C#, D, and Java - add 'string' variants for ARITH, COMPARE, etc - add C# get/set detection - add template detection - add colon handling for class stuff and anonymous bitfields - pop the whole indent stack when leaving a preprocessor - fix embedded return handling in C#, ie: [ this should return negative ] - fix a problem with the ifdef frame stack (still a problem lurking...) - handle literal strings (C#) - handle non-keyword words (C#) -- example: @if @switch - set the parent on 'do' braces - handle C# #region preprocessor stuff - partially implement align on tabstop - fix virtual brace spacing (no more "else return;" => "elsereturn;") - add some more tests uncrustify-uncrustify-0.76.0/Comments.txt000066400000000000000000000021131434072136500205600ustar00rootroot000000000000002016-04-25 While a line is indented, the comment at the end of the line stays at the original column. If we have: else if ((pc->GetType() == CT_FUNC_CLASS_DEF) || (pc->GetType() == CT_FUNC_DEF) || (pc->GetType() == CT_FUNC_CLASS_PROTO) || (pc->GetType() == CT_FUNC_PROTO)) { // guy 2016-04-16 where the brace { is at new line with a comment. The option nl_elseif_brace = remove gives: else if ((pc->GetType() == CT_FUNC_CLASS_DEF) || (pc->GetType() == CT_FUNC_DEF) || (pc->GetType() == CT_FUNC_CLASS_PROTO) || (pc->GetType() == CT_FUNC_PROTO)) { // guy 2016-04-16 If using at new the same option again with a new value nl_elseif_brace = add is not able to reconstruct the original source. The comment has changed the line: else if ((pc->GetType() == CT_FUNC_CLASS_DEF) || (pc->GetType() == CT_FUNC_DEF) || (pc->GetType() == CT_FUNC_CLASS_PROTO) || (pc->GetType() == CT_FUNC_PROTO)) // guy 2016-04-16 { uncrustify-uncrustify-0.76.0/HELP000066400000000000000000000035021434072136500167100ustar00rootroot00000000000000------------------------------------------------------------------------------- HELP: Are you looking to help with uncrustify development? Great! Here are some tasks that need to be done: 1. New features Look at the feature requests on the GitHub project site. https://github.com/uncrustify/uncrustify Do any interest you? Most are easily done, but I haven't had the 'itch' to implement them. 2. Test Coverage The test coverage right now is hardly adequate. I would appreciate it if someone could make sure that every option is tested and add tests as needed. Automated testing is good. Without it, we can't detect regressions. Any option that doesn't have an associated test isn't really supported. 3. Code cleanup I don't have much time to work on uncrustify. When I do, it is usually a short span - only an hour or two. This leads to unreachable code and doing the same thing in multiple places. Trace through the code and find these "problems". I found one the other day in do_space(). A new feature didn't work because several lines of code were not reachable. 4. Code redesign Code gets ugly over time when new features are added willy-nilly. The problem is that the requirements are not known before the design is done. There are a few areas in particular that could benefit from a redesign. 4a. brace_cleanup The code in brace_cleanup is ugly. It works, but it is ugly. It was written with the assumption that there is no 'next' chunk. I had planned to merge that code in with the tokenizer. That didn't happen. So we are left with code that is more complicated than it needs to be. I haven't had the time or energy to revisit that code; I probably never will. If you'd like to take a stab at it... the would be wonderful. 4b. indent_text I think this function could be reworked to better take advantage of the paren stack. uncrustify-uncrustify-0.76.0/LIMITATIONS.txt000066400000000000000000000001141434072136500205660ustar00rootroot00000000000000Limitations in uncrustify are describe at the file src/uncrustify_limits.h uncrustify-uncrustify-0.76.0/NEWS000066400000000000000000000000271434072136500167330ustar00rootroot00000000000000No news is good news! uncrustify-uncrustify-0.76.0/README.md000066400000000000000000000353451434072136500175260ustar00rootroot00000000000000[![AppVeyor](https://img.shields.io/appveyor/ci/uncrustify/uncrustify/master.svg?style=flat-square&label=Windows)](https://ci.appveyor.com/project/uncrustify/uncrustify) [![Coverage Status](https://coveralls.io/repos/github/uncrustify/uncrustify/badge.svg?branch=master)](https://coveralls.io/github/uncrustify/uncrustify?branch=master) --------------------------- # Uncrustify A source code beautifier for C, C++, C#, Objective-C, D, Java, Pawn and Vala. ## Features * Highly configurable - 828 configurable options as of version 0.76.0 -
add/remove spaces - `sp_before_sparen`: _Add or remove space before '(' of 'if', 'for', 'switch', 'while', etc._ - `sp_compare`: _Add or remove space around compare operator '<', '>', '==', etc_
-
add/remove newlines - `nl_if_brace`: _Add or remove newline between 'if' and '{'_ - `nl_brace_while`: _Add or remove newline between '}' and 'while' of 'do' statement_
-
add/remove blanklines - `eat_blanks_before_close_brace`: _Whether to remove blank lines before '}'_ - `nl_max`: _The maximum consecutive newlines (3 = 2 blank lines)_
-
indent code - `indent_switch_case`: _indent_switch_case: Spaces to indent 'case' from 'switch'_ - `indent_class_colon`: _Whether to indent the stuff after a leading base class colon_
-
align code - `align_func_params`: _Align variable definitions in prototypes and functions_ - `align_struct_init_span`: _The span for aligning struct initializer values (0=don't align)_
-
modify code - `mod_full_brace_for`: _Add or remove braces on single-line 'for' statement_ - `mod_paren_on_return`: _Add or remove unnecessary paren on 'return' statement_
Here is an example [configuration file](https://raw.githubusercontent.com/uncrustify/uncrustify/master/documentation/htdocs/ben.cfg.txt), and here is a [before](https://raw.githubusercontent.com/uncrustify/uncrustify/master/documentation/htdocs/examples/c-1.in.c) and [after](https://raw.githubusercontent.com/uncrustify/uncrustify/master/documentation/htdocs/examples/c-1.out.c) C source example. That should give you a pretty good idea of what Uncrustify can do. --------------------------------------------------------------------------- ## Binaries Pre compiled binaries for Windows can be downloaded [here](https://sourceforge.net/projects/uncrustify/files/). ## Build [Python](https://www.python.org/) is an "interpreted high-level programming language for general-purpose programming", for this project it is needed to extend the capabilities of CMake. [CMake](https://cmake.org/) is a tool that generates build systems (Makefiles, Visual Studio project files, Xcode project files and others). To generate a build system for Uncrustify using CMake on UNIX-like systems, create a build folder and run CMake from it, making sure to specify Release mode: ```bash $ mkdir build $ cd build $ cmake -DCMAKE_BUILD_TYPE=Release .. ``` Other systems may require other flags (e.g. `cmake -G Xcode ..` for Xcode). Then use the build tools of your build system (in many cases this will simply be `make`, but on Windows it could be MSBuild or Visual Studio). Or use CMake to invoke it: ```bash $ cmake --build . --config Release ``` If testing is enabled, CMake generates a `test` target, which you can _build_ using your build system tools (usually `make test`). This can also be invoked using CTest: ```bash $ ctest -V -C Debug ``` There is also an `install` target, which can be used to install the Uncrustify executable (typically `make install`). ### A note on CMake configurations Some build systems are single-configuration, which means you specify the build type when running CMake (by setting the `CMAKE_BUILD_TYPE` variable), and the generated files then build that configuration. An example of a single-configuration build system are Makefiles. You can build the Release or Debug configurations of Uncrustify (from the build folder) with: ```bash $ cmake -DCMAKE_BUILD_TYPE=Release .. $ make ``` or ```bash $ cmake -DCMAKE_BUILD_TYPE=Debug .. $ make ``` Other build systems are multi-configuration, which means you specify the build type when building. An example of a multi-configuration build system are Visual Studios project files. When you open the project in Visual Studio, you can select which configuration to build. You can also do this while building from the command line with `cmake --build . --config Debug`. ## Bugs Post any bugs to the issue tracker found on the projects GitHub page: https://github.com/uncrustify/uncrustify/issues Please include the following with your issue: - a description of what is not working right - input code sufficient to demonstrate the issue - expected output code - configuration options used to generate the output More about this is in the [ISSUE_TEMPLATE](https://github.com/uncrustify/uncrustify/blob/master/.github/ISSUE_TEMPLATE) ### Known problems [Look at the Wiki](https://github.com/uncrustify/uncrustify/wiki/Known-Problems) ## Which repositories have uncrustify? [Look here](https://repology.org/metapackage/uncrustify/versions) ## Contribute If you want to add a feature, fix a bug, or implement missing functionality, feel free to do so! Patches are welcome! Here are some areas that need attention: - __Patches for Objective-C support__. We really need someone who knows this language as it has more than plenty open issues. A good starting point would be to integrate changes made in the [Unity fork](https://github.com/Unity-Technologies/uncrustify/tree/fixes/c-oc-java) - Test Java support and provide feedback (or patches!) - Test Embedded SQL to see what works - A logo of some sort - Anything else that you want to do to make it better? ### A note about pull requests Firstly take a look at the [CONTRIBUTING.md](https://github.com/uncrustify/uncrustify/blob/master/CONTRIBUTING.md) Currently we have two continuous integration systems that test your PRs, TravisCI and Appveyor. Tested are the test cases, the formatting of the code base and the output of the command line options. Test cases can be found in the `tests/` directory. Every file ending with `.test` is a test set. Inside each line with these components is a single test: `testNr[!] testConfigFileName testInputFileName [lang]` The configuration file `testConfigFileName` has to be located inside `tests/config`, the input file `testInputFileName` inside `tests/input//`, and expected results file inside the `tests/expected//` directory. Expected results have the following naming convention: `testNr-testInputFileName`. Optionally a `!` can follow the `testNr` to enable a custom rerun configuration. Rerun configurations need to be named like this: `testConfigFileName`(without extension)+`.rerun`+`.extension` Also, optionally a language for the input can be provided with `lang`. The codebase has to be formatted by the options set up in `forUncrustifySources.cfg`. Failing to format the sources correctly will cause TravisCI build failures. The Command line interface (CLI) output is tested by the `test_cli_options.sh` script. It is located inside of `tests/cli/` and operates on the subdirectories of that folder. If a PR is altering the CLI output, files inside those directories might need to be manually updated. This often happens when options are added, removed or altered. Keep in mind that the version string line (example: `# Uncrustify-0.69.0_f`) of outputs from commands like `--show-config` should be replaced with a blank line. ### Debugging The first method is to use uncrustify itself to get debug informations. Using: ```.txt uncrustify -c myExample.cfg -f myExample.cpp -p myExample.p -L A 2>myExample.A ``` you get two files for the first informations. The p-file gives you details of the parsing process and indentation. ```.txt # Line Tag Parent Columns Br/Lvl/pp Flag Nl Text # 1> CLASS[ NONE][ 1/ 1/ 6/ 0][0/0/0][ 10070000][0-0] class # 1> TYPE[ CLASS][ 7/ 7/ 14/ 1][0/0/0][ 10000000][0-0] Capteur # 1> BRACE_OPEN[ CLASS][ 15/ 15/ 16/ 1][0/0/0][ 100000400][0-0] { ``` The A-file gives you many details about the run itself, where the process is running thru, which values have the most important variables. ```.txt tokenize(2351): orig line is 1, orig col is 1, Text() 'class', type is CLASS, orig col_end is 6 tokenize(2351): orig line is 1, orig col is 7, Text() 'Capteur', type is WORD, orig col_end is 14 tokenize(2351): orig line is 1, orig col is 15, Text() '{', type is BRACE_OPEN, orig col_end is 16 ``` You can also dump the parsing information of each formatting step using the 'dump steps' option. ```.txt uncrustify -c myExample.cfg -f myExample.cpp -ds dump ``` This will create a series of 'dump_nnn.log' files, each containing the parsing information at specific points of the formatting process ('dump_000.log' will list the formatting options in use). You can combine this option with -p and -L to get a lot of detailed debugging information. ```.txt uncrustify -c myExample.cfg -f myExample.cpp -p myExample.p -L A 2>myExample.A -ds dump ``` It might be useful to add some code lines to see where something is happening. Use the package `unc_tools`. Remove the comment at line: ```.cpp #define DEVELOP_ONLY ``` Import the package: ```.cpp #include "unc_tools.h" ``` Add at some places the line: ```.cpp prot_the_line(__LINE__, 6, 0); ``` Compile again with DEBUG option. ### How to add an option If you need a new option, there are a few steps to follow. Take as example the option `sp_trailing_ret_t` First define the option: - Insert the code below to the file src/options.h _NOTE: This file is processed by make_options.py, and must conform to a particular format. Option groups are marked by '//begin ' (in upper case; this example is lower case to prevent being considered a region marker for code folding) followed by the group description. Options consist of two lines of declaration preceded by one or more lines of C++ comments. The comments form the option description and are taken verbatim, aside from stripping the leading '// '. Only comments immediately preceding an option declaration, with no blank lines, are taken as part of the description, so a blank line may be used to separate notations from a description. An option declaration is 'extern TYPE\nNAME;', optionally followed by ' // = VALUE' if the option has a default value that is different from the default-constructed value type of the option. The 'VALUE' must be valid C++ code, and is taken verbatim as an argument when creating the option's instantiation. Note also that the line break, as shown, is required. _ ```.cpp // Add or remove space around trailing return operator '->'. extern Option sp_trailing_ret_t; ``` - Insert the code below to the file src/space.cpp ```.cpp if (first->Is(CT_TRAILING_RET_T)) { // Add or remove space around trailing return operator '->'. log_rule("sp_trailing_ret_t"); return(options::sp_trailing_ret_t()); } ``` ### Portability We are pretty sure that nothing OS-specific is used in the code base. The software has been previously tested on the following operating systems: - Linux - QNX - OS X - FreeBSD, NetBSD, OpenBSD - Sun Solaris 9 - Windows (binary available) --------------------------------------------------------------------------- ## Running the program __NOTE__ This application works reasonably well but it has bugs. Do __not__ apply it on your whole codebase without checking the results! Here are ways to run it: ``` $ uncrustify -c mystyle.cfg -f somefile.c -o somefile.c.unc $ uncrustify -c mystyle.cfg -f somefile.c > somefile.c.unc $ uncrustify -c mystyle.cfg somefile.c $ uncrustify -c mystyle.cfg --no-backup somefile.c $ uncrustify -c mystyle.cfg *.c $ uncrustify -c mystyle.cfg --no-backup *.c ``` The `-c` flag selects the configuration file. The `-f` flag specifies the input file. The `-o` flag specifies the output file. If flag `-f` is used without flag `-o` the output will be send to `stdout`. Alternatively multiple or single files that should be processed can be specified at the command end without flags. If the flag `--no-backup` is missing, every file is saved with the initial name and an additional suffix (can be changed with --suffix). For more options descriptions call: ```bash $ uncrustify -h ``` ## Configuring the program Uncrustify usually reads configuration files that are passed via the `-c` flag. If the flag is not provided Uncrustify will try to find a configuration file via the `UNCRUSTIFY_CONFIG` environment variable or a file with the name `.uncrustify.cfg` or `uncrustify.cfg` in your home folder. To get a list of: - all available options use: ```bash uncrustify --show-config ``` - all available options in a usable configuration file format use: ```bash uncrustify --update-config ``` or ```bash uncrustify --update-config-with-doc ``` As the names suggest both options can produce output that adds newly introduced options to your old configuration file. For this your old configuration file has to be passed via the `-c` flag: ```bash uncrustify --update-config-with-doc -c path/to/your.cfg ``` Example configuration files that can be used as a starting point can be found in the `etc/` directory (such as [ben.cfg](./etc/ben.cfg)). Modify to your liking. Use a quality side-by-side diff tool to determine if the program did what you wanted. Repeat until your style is refined. To ease the process a bit, some 3rd party tools are available: - [Universal Indent GUI](http://universalindent.sourceforge.net/) - A cross-platform graphical configuration file editor for many code beautifiers, including Uncrustify. - [uncrustify_config](https://github.com/CDanU/uncrustify_config) - A web configuration tool based on Uncrustify's emscripten interface. - [UncrustifyX](https://github.com/ryanmaxwell/UncrustifyX) - Uncrustify utility and documentation browser for Mac OS X Under Windows: Uncrustify is a command-line tool, if you run it by double-clicking the executable, it will open a command prompt run the executable (which prints the help message), and then immediately close the window as uncrustify exits. You can open the command prompt (which is an interactive terminal window that allows you to run commands without it closing as soon as they exit) and run uncrustify.exe there. ## Using uncrustify with vim Have a look [here](https://github.com/cofyc/vim-uncrustify) ## Using uncrustify with IntelliJ Have a look at https://plugins.jetbrains.com/plugin/17528-uncrustify uncrustify-uncrustify-0.76.0/TESTING000066400000000000000000000070471434072136500173050ustar00rootroot00000000000000Running the tests ----------------- - All tests reside in the tests/ directory tree. - Running the tests is as simple as: $ ctest - Alternatively, the test scripts can be run directly: $ cd tests $ ./run_format_tests.py - To run the only the tests associated with language X ("cpp", "java", etc.): $ cd tests $ ./run_format_tests.py X Adding new tests ---------------- - A test is defined by adding a line in one of the tests/*.test files: you must pick the .test file for the proper programming language, i.e. pick the X.test file which defines tests which use inputs in language X. - A test has a (unique) number (a.k.a. test name) -- it does not have to be a sequential number, but it might be handy to treat it like that. - The X.test entry (line) has this format: where the fields are separated by an arbitrary non-zero amount of whitespace. - As each test references a config file and an input file (the latter written in programming language X), these are assumed to exist in the paths tests/config/ and tests/ respectively. It is _strongly_ advised to put input files in their own subdirectory, so a 'C' source formatting test entry might look like this (in 'c.test'): 99902 ger-full-cmt-reflow.cfg c/cmt-not-a-boxed-cmt.c where 'ger-full-cmt-reflow.cfg' is stored at tests/config/ger-full-cmt-reflow.cfg and 'c/cmt-not-a-boxed-cmt.c' will be fetched from tests/c/cmt-not-a-boxed-cmt.c when you run the tests. Features -------- - You can re-use config files and input files for multiple tests. So one might observe test sets like these: # clark's style - blank lines before and after flow control, indented comments: 20100 clark.cfg c/i2c-core.c 20101 clark.cfg c/comment-indent.c 20102 clark.cfg c/indent.cpp 20103 clark.cfg c/output.cpp and 21051 return-1.cfg c/nl_return_expr.c 21052 return-2.cfg c/nl_return_expr.c 21053 return-3.cfg c/nl_return_expr.c 21054 return-4.cfg c/nl_return_expr.c - Reference output files (the reference against which the uncrustify test run output is compared) are to be stored in the path tests/expected// where is the 'language directory' part of the input file, e.g. 'c' for input file 'c/nl_return_expr.c', is the test name (number), e.g. '21051', and is the file name part of the input test filespec, e.g. 'nl_return_expr.c' for input file spec 'c/nl_return_expr.c'. This means that for test 21051 return-1.cfg c/nl_return_expr.c the accompanying reference output is: tests/expected/c/21051-nl_return_expr.c - When starting out with a new test, you don't need to have a 'reference output' yet: the test will simply be reported as a 'fail'ed test until you do. - Tip: the easiest way to produce 'reference output' is to copy the test output (from tests/results/...etc... ) to tests/expected/...etc... once you've ascertained that those tests produce the desired (correct) output. The helper script tests/fixtest.sh will copy the results file to the output folder: $ fixtest.sh 30014 00110 # copy tests 30014 and 00110 - Tip: the helper script tests/difftest.sh runs 'diff' on the result and output versions to point out what changed. - Tip: There are also a few options to run_format_tests.py that can help. Most interesting is '-d' will run 'diff' if the test fails. - Tip: If some errors occur with Windows, set the macro variable NO_MACRO_VARARG to 1 to test some more pointer under Linux. uncrustify-uncrustify-0.76.0/appveyor.yml000066400000000000000000000020221434072136500206210ustar00rootroot00000000000000version: "{build}" platform: x64 environment: matrix: # MSVC - GENERATOR: Visual Studio 15 2017 Win64 APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 configuration: - Debug - Release clone_folder: C:\projects\uncrustify branches: only: - master clone_depth: 10 skip_tags: true #init: # - echo This is for test only # - ps: iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1')) install: - "SET PATH=C:/Python35-x64;C:/Python35-x64/Scripts;%PATH%" before_build: - cd c:\projects\uncrustify - mkdir build - cd build - cmake -DUNCRUSTIFY_SEPARATE_TESTS=ON -G "%GENERATOR%" .. build_script: - cmake --build . --config %CONFIGURATION% test_script: # - echo This is for test only # - C:/projects/uncrustify/build/Debug/uncrustify.exe -c C:/projects/uncrustify/tests/config/mono.cfg -f C:/projects/uncrustify/tests/input/cs/simple.cs -L 66 - set PYTHONIOENCODING=utf-8 - python ../scripts/run_ctest.py -- -C %CONFIGURATION% deploy: off uncrustify-uncrustify-0.76.0/cmake/000077500000000000000000000000001434072136500173155ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/cmake/CodeCoverage.cmake000066400000000000000000000031011434072136500226400ustar00rootroot00000000000000# # Code Coverage # if ( NOT CMAKE_BUILD_TYPE STREQUAL "Debug" ) message( WARNING "Code coverage results with an optimised (non-Debug) build may be misleading" ) endif ( NOT CMAKE_BUILD_TYPE STREQUAL "Debug" ) if ( NOT DEFINED CODECOV_OUTPUTFILE ) set( CODECOV_OUTPUTFILE cmake_coverage.output ) endif ( NOT DEFINED CODECOV_OUTPUTFILE ) if ( NOT DEFINED CODECOV_HTMLOUTPUTDIR ) set( CODECOV_HTMLOUTPUTDIR coverage_results ) endif ( NOT DEFINED CODECOV_HTMLOUTPUTDIR ) if ( CMAKE_COMPILER_IS_GNUCXX ) find_program( CODECOV_LCOV lcov ) find_program( CODECOV_GENHTML genhtml ) set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -Wall -W -Wshadow \ -Wunused-variable -Wunused-parameter -Wunused-function -Wunused \ -Wno-system-headers -Wno-deprecated -Woverloaded-virtual -Wwrite-strings \ -fprofile-arcs -ftest-coverage" ) link_libraries( gcov ) set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage" ) add_custom_target( coverage_init ALL ${CODECOV_LCOV} --base-directory ${PROJECT_SOURCE_DIR}/src --directory ${CMAKE_BINARY_DIR} --output-file ${CODECOV_OUTPUTFILE} --no-external --capture --initial DEPENDS ${CODECOVERAGE_DEPENDS}) add_custom_target( coverage ${CODECOV_LCOV} --base-directory ${PROJECT_SOURCE_DIR}/src --directory ${CMAKE_BINARY_DIR} --output-file ${CODECOV_OUTPUTFILE} --no-external --capture) add_custom_target( coverage_html ${CODECOV_GENHTML} -o ${CODECOV_HTMLOUTPUTDIR} ${CODECOV_OUTPUTFILE} DEPENDS coverage ) endif ( CMAKE_COMPILER_IS_GNUCXX ) uncrustify-uncrustify-0.76.0/cmake/GenerateTokenNames.cmake000066400000000000000000000017031434072136500240370ustar00rootroot00000000000000# # Generate token_names.h from token_enum.h # # This script is meant to be executed with `cmake -P` from a custom command, # and expects the variables `src_file` and `dst_file` to be set. # function(generate_token_names src_file dst_file) set(tokens "") file(READ "${src_file}" token_lines) string(REGEX REPLACE ";|\\[|\\]" " " token_lines "${token_lines}") string(REPLACE "\n" ";" token_lines "${token_lines}") foreach(token_line ${token_lines}) if(${token_line} MATCHES "^[ \t]*CT_([A-Z0-9_]+),.*$") list(APPEND tokens " \"${CMAKE_MATCH_1}\",\n") endif() endforeach() file(WRITE "${dst_file}" "/*\n" " * Generated by CMake\n" " */\n" "#ifndef TOKEN_NAMES_H_INCLUDED\n" "#define TOKEN_NAMES_H_INCLUDED\n" "\n" "const char *token_names[] =\n" "{\n" ${tokens} "};\n" "\n" "#endif /* TOKEN_NAMES_H_INCLUDED */\n" ) endfunction() generate_token_names("${src_file}" "${dst_file}") uncrustify-uncrustify-0.76.0/cmake/GenerateVersionHeader.cmake000066400000000000000000000025411434072136500245320ustar00rootroot00000000000000# # Generate uncrustify_version.h from uncrustify_version.h.in # # This script is meant to be executed with `cmake -P` from a custom target, # and expects the variables `PYTHON_EXECUTABLE`, `SOURCE_DIR`, `INPUT`, # `OUTPUT` and `UNCRUSTIFY_VERSION` to be set. # execute_process( COMMAND ${PYTHON_EXECUTABLE} ${SOURCE_DIR}/scripts/make_version.py WORKING_DIRECTORY ${SOURCE_DIR} RESULT_VARIABLE make_version_error OUTPUT_VARIABLE make_version_output ) if (make_version_error) # It's normal for make_version.py to fail when building from a tarball, so we # want to avoid anything that looks too much like a scary error. Thus, report # the error in an innocuous-looking fashion. # # If make_version.py is failing unexpectedly and needs to be debugged, # uncomment the next few lines. # string(STRIP "${make_version_output}" make_version_output) # message(STATUS # "scripts/make_version.py exited with code ${make_version_error}: " # "${make_version_output}") message(STATUS "Unable to determine version from source tree; " "fallback version '${UNCRUSTIFY_VERSION}' will be used") message(STATUS "(This is normal if you are building from a zip / tarball)") else() string(STRIP ${make_version_output} UNCRUSTIFY_VERSION) message(STATUS "Version: '${UNCRUSTIFY_VERSION}'") endif() configure_file("${INPUT}" "${OUTPUT}" @ONLY) uncrustify-uncrustify-0.76.0/cmake/Toolchain-mingw32.cmake000066400000000000000000000007731434072136500235320ustar00rootroot00000000000000# # Toolchain file for cross-compiling from Linux to Win32 using MinGW # set(CMAKE_SYSTEM_NAME Windows) if(NOT COMPILER_PREFIX) if(EXISTS /usr/i586-mingw32msvc) # mingw set(COMPILER_PREFIX "i586-mingw32msvc") else() # default to mingw-w64 set(COMPILER_PREFIX "i686-w64-mingw32") endif() endif() find_program(CMAKE_C_COMPILER NAMES ${COMPILER_PREFIX}-gcc) find_program(CMAKE_CXX_COMPILER NAMES ${COMPILER_PREFIX}-g++) find_program(CMAKE_RC_COMPILER NAMES ${COMPILER_PREFIX}-windres) uncrustify-uncrustify-0.76.0/cmake/Toolchain-mingw64.cmake000066400000000000000000000010071434072136500235260ustar00rootroot00000000000000# # Toolchain file for cross-compiling from Linux to Win64 using MinGW # set(CMAKE_SYSTEM_NAME Windows) if(NOT COMPILER_PREFIX) if(EXISTS /usr/amd64-mingw32msvc-gcc) # mingw set(COMPILER_PREFIX "amd64-mingw32msvc-gcc") else() # default to mingw-w64 set(COMPILER_PREFIX "x86_64-w64-mingw32") endif() endif() find_program(CMAKE_C_COMPILER NAMES ${COMPILER_PREFIX}-gcc) find_program(CMAKE_CXX_COMPILER NAMES ${COMPILER_PREFIX}-g++) find_program(CMAKE_RC_COMPILER NAMES ${COMPILER_PREFIX}-windres) uncrustify-uncrustify-0.76.0/cmake/uninstall.cmake000066400000000000000000000013371434072136500223340ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.0.2) set(MANIFEST "${CMAKE_CURRENT_BINARY_DIR}/install_manifest.txt") if(NOT EXISTS ${MANIFEST}) message(FATAL_ERROR "Cannot find install manifest: ${MANIFEST}") endif() file(STRINGS ${MANIFEST} files) foreach(file ${files}) if(EXISTS ${file} OR IS_SYMLINK ${file}) message(STATUS "Removing: ${file}") execute_process(COMMAND rm -f ${file} RESULT_VARIABLE result OUTPUT_QUIET ERROR_VARIABLE stderr ERROR_STRIP_TRAILING_WHITESPACE ) if(NOT ${result} EQUAL 0) message(FATAL_ERROR "${stderr}") endif() else() message(STATUS "Does-not-exist: ${file}") endif() endforeach(file) uncrustify-uncrustify-0.76.0/commit.log000066400000000000000000007263031434072136500202430ustar00rootroot00000000000000commit 6aeb46f1cd34104e6c9134f079469b3385274f4c Author: Ben Gardner Date: Tue Feb 2 20:16:57 2016 -0600 Rework make_win32.sh to build outside of the source tree. commit b08b81937aa0ff9438d6479ddb83419356877b30 Author: Ben Gardner Date: Tue Feb 2 20:16:31 2016 -0600 Update version, config files, run update-defaults.sh, etc commit 34a104aa67cb26c2c3273b769412a403dd6674db Author: Ben Gardner Date: Mon Feb 1 20:54:41 2016 -0600 Update release steps commit a8f4771b2e4ad48d91f14d2c2ceba228c5f93c9d Author: bengardner Date: Sun Jan 31 19:23:17 2016 -0600 PAWN: Cannot modify the #define PATTERN at all So keep it as a single chunk. Go with CT_MACRO for the type for now. commit 41d1e76ccf3ce9d5c968422f2ffe11b1782adc4c Author: bengardner Date: Sun Jan 31 18:24:41 2016 -0600 Correctly parse PAWN #define args Parses the following with %1=>WORD #define xx(%1, %2) foo(%1, %2) commit 10478309dca1c5c5928a9851a4b5916a007969b0 Author: bengardner Date: Sun Jan 31 18:12:58 2016 -0600 Revert "Correctly parse VALA #define args" This reverts commit 602b49c1f98eb51ec9589aa9edf1ac6c1ac1e4c9. commit 602b49c1f98eb51ec9589aa9edf1ac6c1ac1e4c9 Author: bengardner Date: Sun Jan 31 13:38:48 2016 -0600 Correctly parse VALA #define args Parses the following with %1=WORD #define xx(%1, %2) foo(%1, %2) commit 0ce3c3d1107f3fee593c374b87d31e31be74db9e Merge: 244c9de 4c69239 Author: Ben Gardner Date: Sun Jan 31 12:53:26 2016 -0600 Merge pull request #427 from benwaffle/master Add some missing vala keywords commit 4c692395e54183409f31f86e12b51859a6bbc645 Author: Ben Iofel Date: Fri Jan 29 18:13:42 2016 -0500 Add some missing vala keywords commit 244c9de670ccfa47f63dffa7ce43643000d6d352 Merge: 62a2ad9 97fab82 Author: Ben Gardner Date: Thu Jan 28 17:12:06 2016 -0600 Merge pull request #423 from Lykurg/assume2 Automatic language detection for stdin (--assume) commit 97fab8240389a9bc829588ed24c2b295c6ec3bec Author: Lorenz Haas Date: Mon Jan 18 21:00:41 2016 +0100 Automatic language detection for stdin (--assume) While -f uses the simple automatic language detection with stdin one is out of luck. With the new argument --assume one can specify the filename Uncrustify should use to perform the automatic language detection even for content pushed to stdin. commit 62a2ad9977f189bb4f6efb44ebfe07deffdd1e42 Merge: 9a46c56 672fd1c Author: Ben Gardner Date: Wed Dec 9 17:32:30 2015 -0600 Merge pull request #413 from jlee975/patch-1 Address issue #373. Checks the chunk prior to the '::' and forces a space if it is a known keyword. commit 672fd1c0143c535be37bf2bca4ea276a9ba352d3 Author: jlee975 Date: Wed Dec 9 11:54:03 2015 -0600 Address issue #373 sp_before_dc should not apply to global scope operator. commit 9a46c565e315d3eae16085e759febc9c5e809591 Merge: 15ee014 eef47c5 Author: Ben Gardner Date: Tue Nov 24 21:33:10 2015 -0600 Merge pull request #372 from ravethetadpole/while_one_liners add nl_while_leave_one_liners commit 15ee014c5261a26d46d3479f0f7330db719f183a Author: Lorenz Haas Date: Fri Apr 24 14:01:11 2015 +0200 Doxygen comments in CPP style like '//:', '//=', '//~' where not handled properly when spaces were to be added with option sp_cmt_cpp_start. The new option sp_cmt_cpp_qttr treats those comment leadings as a unity, if set to TRUE. Before sp_cmt_cpp_start=add converted '//:foo' to '// :foo'. Now it will correctly be converted to '//: foo'. commit efe1adb92ec09073778247412bba38a8f5dd4e64 Merge: 97ac4c9 7d0f864 Author: Ben Gardner Date: Tue Nov 24 21:23:28 2015 -0600 Merge branch 'npnth-master' commit 7d0f864a52c0f58703ea1bc07cad592d3db10697 Merge: 97ac4c9 55581c4 Author: Ben Gardner Date: Tue Nov 24 21:22:26 2015 -0600 Merge branch 'master' of https://github.com/npnth/uncrustify into npnth-master commit 97ac4c96b24ab428a4325e05347cabe19cfdab93 Merge: 4d68949 c2c2ac0 Author: Ben Gardner Date: Tue Oct 27 16:26:25 2015 -0500 Merge pull request #392 from icyflame/patch-1 Add file links to the readme commit 4d6894996b26fd0ba26275b59ece063a5082bdb2 Author: Ben Gardner Date: Wed Oct 21 10:16:58 2015 -0500 Expand digraphs test a bit. commit 485eb91664716ffac58a49394e628e5e5db13af5 Author: Ben Gardner Date: Wed Oct 21 10:15:51 2015 -0500 Add option: enable_digraphs and disable digraphs by default commit c2c2ac07fc60efd80631c325e113963c1a605815 Author: Siddharth Kannan Date: Mon Aug 10 17:42:20 2015 +0530 Add file links to the readme - Instead of just referencing a file, add a link to it. - This makes the configuration file location much more prominent. commit fc5228ecd9f579f366919e5d13f26ae5149f80f1 Merge: b3f3e21 abf3bef Author: Ben Gardner Date: Thu Jul 30 15:28:13 2015 -0500 Merge pull request #385 from tpltnt/md-readme Readme markdown commit b3f3e216af06574e465fe315ef19927caff21ebc Merge: b6593c1 420c240 Author: Ben Gardner Date: Thu Jul 30 12:35:59 2015 -0500 Merge pull request #387 from dirk-thomas/fix_windows_warnings fix warnings on Windows commit 420c240949aacf87d1924e488f65e80e8923c171 Author: Dirk Thomas Date: Wed Jul 29 18:15:41 2015 -0700 fix warnings on Windows commit abf3bef2940b8e5450cc4fde46d3ddc6c92148a8 Author: tpltnt Date: Tue Jul 21 21:37:02 2015 +0200 added markdown to README, closes #383 * marked shell commands * separated list of steps commit 55581c4e060763aa5984194aa3f948baa870ba99 Author: Gilles Date: Thu Jul 9 21:35:10 2015 -0400 Handle Java's `synchronized(foo){ ... }` construction Add a new CT for `synchronized` for java, which behaves like a vanilla if/for/while/switch construction if a parenthesis follows the keyword (otherwise, tokenize_cleanup reverts it to being a qualifier). This adds options `nl_synchronized_brace`, `nl_before_synchronized`, and `nl_after_synchronized`, which work in the obvious way. Since `synchronized` requires braces, no special handling of braceless code is necessary. Also update defaults.cfg by update-default-cfg.sh to appropriately handle these new options and add tests 80060 and 80061. commit eef47c5b357912fe1c0136e338a895f580dc256e Author: RaveTheTadpole Date: Mon May 4 10:50:19 2015 -0500 add nl_while_leave_one_liners Preserve one-line while statements. It is a straightforward extension of other leave_one_liners options. commit b6593c1bd9f2d5f2980c7e219df9109bef49e845 Merge: 2f8c55d 27bbbfc Author: Ben Gardner Date: Fri Apr 3 16:58:54 2015 -0500 Merge branch 'Unity-Technologies-features/msref-support' commit 27bbbfc407aa11ecc3ee4f5d2597bce280be6ddf Merge: 2f8c55d c8b80c8 Author: Ben Gardner Date: Fri Apr 3 16:58:18 2015 -0500 Merge branch 'features/msref-support' of https://github.com/Unity-Technologies/uncrustify into Unity-Technologies-features/msref-support Conflicts: tests/cpp.test commit 2f8c55d3c41e6caeb71f8d9775ebefc60c43d511 Author: Ben Gardner Date: Fri Apr 3 16:31:05 2015 -0500 run_tests.py needs Python 2. commit 9ac5184a3c7ceceedbe2777eb992565e39264091 Author: Guy Maurel Date: Fri Mar 27 14:32:52 2015 +0100 correct the function keywords_are_sorted commit c0ee10411e8095c93c5baa845d168862f4ec2df1 Author: Guy Maurel Date: Mon Mar 30 17:12:54 2015 +0200 Typo commit c8b80c898214f3c572532e6acf39238031079632 Author: Scott Bilas Date: Wed Mar 25 08:15:38 2015 +0100 Fixing issues as per Ben's review comments on https://github.com/bengardner/uncrustify/pull/350 commit db37e6d0d01f050a530c7a1596099ea6a8ea249c Merge: f23de29 faa87cd Author: Ben Gardner Date: Tue Mar 24 22:10:13 2015 -0500 Merge pull request #346 from 4picht/master allow indent_ctor_init to be negative commit f23de290bd80cedc4b2544c2e6243abc0b2dc57f Merge: 40a6abd a940421 Author: Ben Gardner Date: Tue Mar 24 22:07:25 2015 -0500 Merge pull request #347 from clbr/issue314 Add a new option for indenting continued shift expressions commit 40a6abd8008c7156b64c23b3e49258206da54479 Merge: e4cd86e 12c1768 Author: Ben Gardner Date: Tue Mar 24 21:52:16 2015 -0500 Merge pull request #349 from Unity-Technologies/fixes/bit-colon-class Fix: C++ bitfields were being detected in structs, but not in classes commit e4cd86ecbd32e6bc56337a4f2ee11af28759b590 Merge: cd1c861 a0086de Author: Ben Gardner Date: Tue Mar 24 21:48:21 2015 -0500 Merge pull request #356 from iv-mexx/feature/fixObjCTernaryMethodCall Fix ObjC 'Methodcall in ternary expression' commit a0086de8b5e65c828c4a45058ea040e6d9836634 Author: MeXx Date: Wed Mar 25 00:47:19 2015 +0100 Added a more complicated testcase for ternary operator in ObjC commit 55c91fb34857184d6e5cd97b3899eca36cd07537 Merge: fa11a5e 2216026 Author: MeXx Date: Wed Mar 25 00:44:31 2015 +0100 Merge branch 'fixes/objective-c-ternary' into feature/fixObjCTernaryMethodCall commit 2216026a78ccd0904b4f1a23fc2cf735601c142e Author: MeXx Date: Mon Mar 23 22:33:45 2015 +0100 ObjC: Add testcase to reproduce ObjC methodcall-in-ternary-expression issue #355 commit 4da23e911865870cd2e7a1e3d2b6a5d79d7e3156 Author: Scott Bilas Date: Thu Mar 19 15:39:48 2015 +0100 Ok that last hard coded fix wasn't the best idea. Too many cases. What we really need is a stack of question counts that is associated with the OC messages. I also updated the unit test for the case that was failing. Note that this has to be interpreted as OC+ to pick up the '::' in the sample. commit 2f9fb388111d644bf23b2a610b8c19d14084c8be Author: Scott Bilas Date: Thu Mar 19 14:18:52 2015 +0100 Fixed issue 635. Just a new case that needed to be handled surrounding ternary and OC messages. commit fa11a5e0e7ecfbbed7e712bfe92a6496ba675ef6 Author: MeXx Date: Mon Mar 23 22:38:23 2015 +0100 ObjC/combine_labels: dont reduce question_count if the colon is inside a ObjC message call, fixes #355 commit ead319cab7b2012ccb0e8d7880fe7a18f5d73505 Author: MeXx Date: Mon Mar 23 22:33:45 2015 +0100 ObjC: Add testcase to reproduce ObjC methodcall-in-ternary-expression issue #355 commit 8f3027c635041fdcf90c263b35cfda3bbeeed291 Author: Scott Bilas Date: Thu Feb 26 11:46:15 2015 +0100 Pick a better number to base this on commit 083e919cdaaf3056bc3419b9ce659752bfa67296 Author: Scott Bilas Date: Wed Feb 25 16:04:59 2015 +0100 Implementing support for MS's C++ extensions for C++/CLI and WinRT on the ^ character acting as markup for a reference (similar to * for pointers). Conflicts: tests/cpp.test commit 12c1768e10bf5423b77dc97a9f6382eec5197144 Author: Scott Bilas Date: Wed Feb 25 15:00:17 2015 +0100 Fix: C++ bitfields were being detected in structs, but not in classes commit a94042179131b1f7da04c137243c74c22eabb4d5 Author: Lauri Kasanen Date: Fri Feb 13 21:04:57 2015 +0200 Add a new option for indenting continued shift expressions Fixes #314. Including both a new more extensive test case as well as an adapted existing test case. This project has been sponsored by The Measurement Factory. Signed-off-by: Lauri Kasanen commit faa87cda17b896abb6b0893ae85bed57730c1ff9 Author: Julian Picht Date: Mon Feb 23 10:51:28 2015 +0100 allow indent_ctor_init to be negative commit cd1c8619321efc96afc1ab1e7d09e924f008acaa Author: Ben Gardner Date: Thu Feb 19 20:49:42 2015 -0600 Allow casting of this in "(Foo)this" commit e13ae46d98fcb28448db8941ef65ffda47d4bd9c Author: Ben Gardner Date: Thu Feb 19 20:23:30 2015 -0600 run_tests.py: Don't add .test if it already has it commit bfdcd34d7d64dd030df10bd7e3bb0467934d4f33 Author: Ben Gardner Date: Thu Feb 19 20:23:08 2015 -0600 Add another semicolon removal test commit 85af83abab2f63cc9ef1ca9d4d0d6dba082ad479 Author: Ben Gardner Date: Thu Feb 19 20:22:46 2015 -0600 Prevent semicolon removal after 'new' statements by marking braces commit fd743dec0631d76100cf21c4875a55af5cc062ad Author: Ben Gardner Date: Thu Feb 19 20:08:50 2015 -0600 Add test for sp_between_new_paren commit 88ade49e56e7b081c4a468623251d6c535ea9f46 Author: Ben Gardner Date: Thu Feb 19 20:08:09 2015 -0600 Add new option sp_between_new_paren commit 8a23fdf630d24decce329c3663d7d73d3eb0a964 Author: Ben Gardner Date: Thu Feb 19 19:53:48 2015 -0600 Add a test for not splitting "} while" commit ec88fea43c2ac1dbd85e5cf07423bb4e872e34ac Author: Ben Gardner Date: Thu Feb 19 19:53:02 2015 -0600 Don't insert a newline in "do {} while()" via nl_after_brace_close commit 3801c8e4755a59f92b0ff3668470b37c5dd8103e Author: Ben Gardner Date: Thu Feb 19 19:46:08 2015 -0600 Add logging for adding newlines commit 288df3e25977ea8ead8ce19d31438240a29ab46c Author: Ben Gardner Date: Thu Feb 19 19:32:18 2015 -0600 Update test results for nl_squeeze_ifdef fix commit 2176b8bf65f93257a4e86b5f63db97b7192a193c Author: Ben Gardner Date: Thu Feb 19 19:30:37 2015 -0600 nl_squeeze_ifdef should not remove blanks before whole-file #endif. This was messing up my style. commit 32bd357e9beefb5e72469c78208861e3f57985a5 Merge: 3ea72e3 6155faf Author: Ben Gardner Date: Wed Feb 18 22:08:04 2015 -0600 Merge pull request #345 from shazron/npm-package Added package.json for npm commit 3ea72e33125db3f854f6285f8efd69bc42e05d4f Author: Ben Gardner Date: Wed Feb 18 22:07:39 2015 -0600 Run uncrustify on itself using etc/ben.cfg, with a few manual fixes. commit 1369245fbb8d1cbed4957a97d9dd6cce2a5ac6d7 Merge: 094e094 698dfcd Author: Ben Gardner Date: Wed Feb 18 21:53:04 2015 -0600 Merge pull request #341 from nicodecker/vbr_indent New options for indenting at virtual brace open commit 094e0947415d5228ede9ccc2ab00f7f93adefbfa Merge: 58a76e6 c6aca7b Author: Ben Gardner Date: Wed Feb 18 21:52:37 2015 -0600 Merge pull request #342 from nicodecker/doxygen_comments Option for space handling in doxygen comments commit 58a76e6131f6d23af8faa09401ff562552208041 Merge: f62fda6 b44f525 Author: Ben Gardner Date: Wed Feb 18 21:51:19 2015 -0600 Merge pull request #340 from nicodecker/frag_at_col Fixed wrong position of comment in case of --frag commit f62fda639756684d964d2b60c7549c6a9d176182 Merge: 5d839c3 40b536a Author: Ben Gardner Date: Wed Feb 18 21:50:42 2015 -0600 Merge pull request #343 from nicodecker/fix_cmd_processing Bugfix: Undesired effect of disable_processing_cmt commit 6155faf25f8a02578cf99b2b4fdbae7cfdea26d7 Author: Shazron Abdullah Date: Wed Feb 18 15:08:22 2015 -0700 Added package.json for npm commit 40b536ae657a7f3d6c7ec4df051ad172516a5af7 Author: Nico Decker Date: Wed Feb 18 13:05:23 2015 +0100 Bugfix: Undesired effect of enable_processing_cmt The same bug as existed for disable_processing_cmt exists for enable_processing_cmt as well. Fixed in the same way by treating NULL and "" equally. commit f68d75d9dba517a9217cc5dd0cd4e5ae1fe7ca50 Author: Nico Decker Date: Wed Feb 18 08:45:32 2015 +0100 Bugfix: Undesired effect of disable_processing_cmt The new option disable_processing_cmt that has been added recently had an undesired side effect. Unfortunatly, due to its nature, it was not revealed by the test facility. Configuration created before the option was introduced works fine even with versions containing the new option. But in the configuration created with those new versions the option was automatically set to "". In the code this lead to unformatted text after the first comment! Fixed by treating NULL and "" equally. commit c6aca7b2c95079ef51d573c2538bd3067255012f Author: Nico Decker Date: Wed Feb 18 08:27:56 2015 +0100 Option for space handling in doxygen comments Doxygen comments in CPP style like '//!', '//!<', '///' and '///<' where not handled properly when spaces were to be added with option sp_cmt_cpp_start. The new option sp_cmt_cpp_doxygen treats those comment leadins as a unity, if set to TRUE. Before sp_cmt_cpp_start=add converted '//!x' to '// !x'. No it will correctly be converted to '//! x'. commit 698dfcd40824635ba41d543abaec08b98d0abce0 Author: Nico Decker Date: Sat Feb 14 18:35:38 2015 +0100 Added test for indenting after vbrace-open commit b44f5259de9d834d4aaf863720b204ae138d413b Author: Nico Decker Date: Sat Feb 14 17:54:39 2015 +0100 Fixed wrong position of comment in case of --frag In case of command line option --frag the position configured in align_right_cmt_at_col was not correct anymore. commit 5d839c344385bec76d5cf029c3bdb1576e4ca0d3 Merge: 3105b16 fa34bee Author: Ben Gardner Date: Sat Feb 14 10:35:42 2015 -0600 Merge pull request #337 from nicodecker/frag_tabstop Fixed wrong tabstop behaviour in case --frag is used. commit 3105b166dc7fd7b25d550d9cd1fd28c44c222bb6 Merge: f0f17a1 73d1466 Author: Ben Gardner Date: Sat Feb 14 10:35:25 2015 -0600 Merge pull request #339 from nicodecker/frag_eof No eof/bof newline modifications for --frag commit 73d1466b974809a42e960b490ec80fe2b2a476fd Author: Nico Decker Date: Sat Feb 14 14:14:41 2015 +0100 No eof/bof newline modifications for --frag When command line option --frag is used there is no real end-of-file or begin-of-file; therefore do not perform any modifications concerning options - nl_end_of_file_min - nl_end_of_file - nl_start_of_file_min - nl_start_of_file commit 343cfd27900724643762613fec811fd1c2d1b785 Author: Nico Decker Date: Sat Feb 14 13:53:40 2015 +0100 Introduced new options indent_min_vbrace_open and indent_vbrace_open_on_tabstop. The new options allow to applay special indent after virtual braces and newline. commit fa34bee5a08abff08a71dddf019f1ffaf352afa9 Author: Nico Decker Date: Sat Feb 14 13:24:55 2015 +0100 Fixed wrong tabstop behaviour in case --frag is used. calc_next_tab_column() did not take indent of first line into accout when command line option --frag was used. commit f0f17a1599f8a775942f2796761c80b06abee1b7 Merge: 7757d42 ef37f0a Author: Ben Gardner Date: Fri Feb 13 09:26:38 2015 -0600 Merge pull request #333 from Unity-Technologies/fixes/encoding-ignore Fixed bug with my 'ignore' change that broke non-ASCII encodings. commit ef37f0a104f06e94caa74cad9f1f13ab8c9cebd4 Author: Scott Bilas Date: Thu Feb 12 16:46:23 2015 +0100 Fixed bug with my 'ignore' change that broke non-ASCII encodings. Added tests to keep it from coming back. commit 7757d42c2c5124e00ef0a346d3f5e8ea7bb79d29 Merge: 36cb55c ffaf3fb Author: Ben Gardner Date: Thu Feb 12 07:53:49 2015 -0600 Merge branch 'Unity-Technologies-features/string-replace-tab-chars' commit ffaf3fbdac70bd7befc47b415b0cc58a520cad40 Merge: 36cb55c 3a27deb Author: Ben Gardner Date: Thu Feb 12 07:53:17 2015 -0600 Merge branch 'features/string-replace-tab-chars' of https://github.com/Unity-Technologies/uncrustify into Unity-Technologies-features/string-replace-tab-chars commit 36cb55cbb585da4ecba2706a9b2e39bde4d4d2d3 Merge: 3c1b714 a97b482 Author: Ben Gardner Date: Thu Feb 12 07:47:12 2015 -0600 Merge pull request #332 from Unity-Technologies/fixes/indent-off-for-realz Made *INDENT-OFF* truly disable all reformatting commit 3c1b714f44ede1f9badd88f9dc8db2a739fe168a Merge: 0f4fdaa 1933349 Author: Ben Gardner Date: Thu Feb 12 07:46:12 2015 -0600 Merge pull request #330 from Unity-Technologies/fixes/windows-config-relative-paths Implementing code on Windows to deal with relative file paths from an 'include' in a config file commit 3a27debe358b9f3b092a2a016822e014411bdbf4 Author: Scott Bilas Date: Thu Feb 12 11:54:53 2015 +0100 New option 'string_replace_tab_chars' that will convert tab chars found in ordinary literal C style strings to '\t' instead. It's very difficult to have tab chars in strings participate in reformatting of the outer code in a consistent way. For example, unit tests that compare code in strings against files on disk will suddenly fail if the contents of the strings change in any way. Switching to \t chars is one way to avoid this problem, plus make the code more readable. Conflicts: src/options.h commit a97b4827d7d6d94206e63227dbe80b8c124ad9c4 Author: Scott Bilas Date: Thu Feb 12 11:52:08 2015 +0100 Made *INDENT-OFF* truly disable all reformatting. Previously was still reformatting tab chars found in the ignored chunks. commit e2e0f40a852bc0480a781a66141b81a9c0d1d67d Author: Scott Bilas Date: Thu Feb 12 11:29:57 2015 +0100 minor spelling fix commit 193334979f55229daabcdcd520eeeafdc108e399 Author: Scott Bilas Date: Thu Feb 12 10:59:27 2015 +0100 Implementing code on Windows to deal with relative file paths from an 'include' in a config file commit 0f4fdaa2468624c100723841e1796fa9eb2e8e51 Merge: b3f4c00 90e0d3a Author: Ben Gardner Date: Wed Feb 11 21:54:54 2015 -0600 Merge branch 'Unity-Technologies-staging' commit 90e0d3aa2c8c3695333752d8790ef304f92eb1a1 Merge: b3f4c00 5bb6bc4 Author: Ben Gardner Date: Wed Feb 11 21:54:31 2015 -0600 Merge branch 'staging' of https://github.com/Unity-Technologies/uncrustify into Unity-Technologies-staging Conflicts: tests/c-sharp.test commit b3f4c005638e476b2e653b44b558111efbfc1b23 Merge: 66812c4 5824499 Author: Ben Gardner Date: Wed Feb 11 21:51:55 2015 -0600 Merge pull request #325 from MarekFort/master Add support for indent_class_on_colon commit 66812c4cf8228ea6ef91fef16399b90c18ff49bf Merge: 2286fad 3f4406d Author: Ben Gardner Date: Wed Feb 11 21:50:43 2015 -0600 Merge pull request #327 from Unity-Technologies/fixes/delegate-semicolon-removal Fixed another case for bug #628 (older C# 'delegate' syntax) commit 2286fad0c73d83d0f477f386077dcf5b813d6d3e Merge: e3469f0 3a1e3bb Author: Ben Gardner Date: Wed Feb 11 21:48:49 2015 -0600 Merge pull request #321 from Ditti4/master Fix some mistakes in the documentation commit e3469f0eec27845c7237462bc3e31b53c7e11cd5 Merge: b5e20df 575453f Author: Ben Gardner Date: Wed Feb 11 21:46:29 2015 -0600 Merge pull request #328 from Unity-Technologies/features/option-processing-cmt New options and tests for enable_processing_cmt/disable_processing_cmt t... commit b5e20dfeea723bc9fd7f8f9384dbafe3688e778a Merge: 261cfdb 77dbf12 Author: Ben Gardner Date: Wed Feb 11 21:44:05 2015 -0600 Merge pull request #329 from mikekov/master Keep trailing space in C++ comments if it follows backslash to prevent '\' from turning into line continuation commit 77dbf12633753fa2377db8c10354bbad84e89e6d Author: Mike Date: Wed Feb 11 11:18:12 2015 -0800 Keep trailing space in C++ comments if it follows backslash to prevent '\' from becoming line continuation commit 575453f1144d79c9c47d1e30dfc8e47fb3cfb746 Author: Scott Bilas Date: Tue Feb 10 15:51:11 2015 +0100 New options and tests for enable_processing_cmt/disable_processing_cmt that permits overriding the default UNCRUSTIFY_ON_TEXT/UNCRUSTIFY_OFF_TEXT. commit 3f4406ddf9f73d3ebacd2a385ae84fd21303379c Author: Scott Bilas Date: Wed Feb 11 11:13:36 2015 +0100 Fixed another case for bug #628 (older C# 'delegate' syntax) commit 261cfdb0f19afa785fcab54d93e3522058c0645f Author: Ben Gardner Date: Tue Feb 10 22:08:02 2015 -0600 Add test for SF#628 commit 2e7f4d9660096e30d6c25e53e9e7bd068008561e Author: Ben Gardner Date: Tue Feb 10 22:07:29 2015 -0600 Fix marking of "=> { }" lambda expressions in C#. Prevents semicolon removal. commit e0706629876026a937bf36d2cafa9f7a990954c5 Author: Ben Gardner Date: Tue Feb 10 21:45:37 2015 -0600 Add C++ digraph test from SF#629 commit 8182cd2658a8fc53911ea169b93d34bea2a07524 Author: Ben Gardner Date: Tue Feb 10 21:44:31 2015 -0600 Add partial support for digraphs. Uncrustify may still choke on them in the input, but it won't create them. commit 5bb6bc4eaa184f973f74e4aaf04232b5eedf3ad9 Author: Scott Bilas Date: Tue Feb 10 00:10:17 2015 +0100 Fixed bug with backslash at end of comment affecting the next line in C#. C# has no preprocessor, and backslashes at EOL don't mean anything special. Also added tests for C# to verify fix, and to C++ to make sure normal behavior maintained. commit 9bad4d26b408b401a523687dbc6a55bba1ec7ef2 Author: Ben Gardner Date: Sun Feb 8 17:00:26 2015 -0600 Add tests for the new options. commit fa792758e12688aac95944204cb6430f4ad83d75 Author: Ben Gardner Date: Sun Feb 8 16:59:38 2015 -0600 Add options to control spacing in C# array types: "int [,,] x;" sp_before_mdatype_commas sp_between_mdatype_commas sp_after_mdatype_commas commit 5bfa2736a73d2ad6d6e91a33299bf2433a74c7b0 Author: Ben Gardner Date: Sun Feb 8 16:15:26 2015 -0600 Don't crash if the input ends with a VBRACE_CLOSE. Fixes SF#616. commit 5824499fad6bbfa87e2066a38ae2e4d50b044eb9 Author: Marek Fort Date: Sun Feb 8 15:20:07 2015 +0100 Add support for indent_class_on_colon commit 3a1e3bb0d06bcc4dc0f3ba235dea9aa227ea7df7 Author: Dittrich, Rico Date: Thu Feb 5 11:01:47 2015 +0100 Fix some mistakes in the documentation commit 4e20f20fbeabae560f3471a99a9191ea7718875b Merge: 3319eef 2b82c2b Author: Ben Gardner Date: Tue Jan 6 20:40:10 2015 -0600 Merge pull request #316 from npnth/nl_after_label_colon Add nl_after_label_colon option commit 2b82c2b06abd30ef7de2829b4fee7af3e068ceaf Author: Gilles Date: Tue Jan 6 18:22:37 2015 -0500 Add tests for nl_after_label_colon Ensure that nl_after_label_colon does not adversely affect colons in switch statements or bitfields. commit 3561d7d4dedfa125d1d0b212f8ce2fb1397f18e4 Author: Gilles Date: Tue Jan 6 18:07:00 2015 -0500 Remove newline dependence in CT_LABEL_COLON detection Make combine_labels default to viewing a WORD + COLON combination as a label, not a bitfield definition. Colons that are inside structs or typedefs are considered bitfields. This allows labels to be tagged as such even if they are not preceded by a newline. commit b4cbf3cd44ae1f2895617ba68c784deec2159e92 Author: Gilles Date: Tue Jan 6 17:15:28 2015 -0500 Add default value for nl_after_label_colon This option defaults to false commit 083c2cb3f6caeae6b570a22242a19b6d4c482d35 Author: Gilles Date: Tue Jan 6 16:42:29 2015 -0500 Add support for nl_after_label_colon Add as a boolean option nl_after_label_colon. If this is set to true, a newline is appended to any LABEL COLON token sequence. commit 3319eefebdd947da8da84272e67fdf392c00790b Merge: f65394e 083a4fc Author: Ben Gardner Date: Sat Jan 3 12:07:24 2015 -0600 Merge pull request #315 from npnth/master Unify handling of newlines following { among if/else commit 083a4fc7b517343e8790f22b418afd08fc209890 Author: Gilles Date: Thu Jan 1 22:50:56 2015 -0500 Add test for nl_remove_extra_newlines=2, nl_after_brace_open=false In this situation, ensure that both if and else treat their immediately-following open braces similarly. commit 12a955e769169d696eb9787451916568cfc84ac1 Author: Gilles Date: Thu Jan 1 22:34:52 2015 -0500 Make newlines_do_else handle braces like newlines_if_for_while_switch Remove option-checking in the handling of newlines directly after CT_BRACE_OPEN in newlines_do_else. This matches the way newlines_if_for_while_switch handles the same situation, preventing awkward mismatches visually between if/else blocks when nl_after_brace_open is false. commit f65394e32925d3978bf2838f76bf19fa9791a7e0 Author: Ben Gardner Date: Mon Dec 22 21:37:33 2014 -0600 Extract the commit log commit b82c7cbf7c8028fb91faa3767321e9e1c0f0e34b Author: Ben Gardner Date: Mon Dec 22 21:37:17 2014 -0600 Update changelog commit 2b76d7a8f4d0c80f3917064b2f4e8309ec55cb3a Author: Ben Gardner Date: Mon Dec 22 21:26:42 2014 -0600 Documentation and script updates for version 0.61. commit df5fe150195d38e63a173727bed8a60a296db4c5 Author: Ben Gardner Date: Mon Dec 22 21:16:19 2014 -0600 Bump version to 0.61 commit 15d8f44c4efac3323b991a6db91b4fcb88ace694 Author: Ben Gardner Date: Mon Dec 22 21:13:21 2014 -0600 Attempt to get cygwin builds working. Not tested. commit c6a251f4329dc6911ba48a4b9cae88a62acb2c45 Author: Ben Gardner Date: Mon Dec 22 14:02:50 2014 -0600 Add test for SF#607. commit d330fda6ab18f77bfe6cb57b6cc64aae4a38b48f Author: Ben Gardner Date: Mon Dec 22 14:02:08 2014 -0600 Do not mark the parent of the brace that contains a CS_PROPERTY as GETSET. Fixes SF#607 commit 7909e742826539ec3d075df82439c72a6e93ddd6 Author: Ben Gardner Date: Mon Dec 22 13:41:33 2014 -0600 C++11 supports the "final" keyword in class declarations. commit 64439c58dbd8f6f2ce29eac53080823d49880d7d Merge: ffa7ea0 5814e8d Author: Ben Gardner Date: Thu Dec 18 20:28:08 2014 -0600 Merge pull request #312 from lgauthier/master Added fix for issue #124 commit 5814e8db5033408759d4f2785ed440a7f364d60d Author: logan.gauthier@metova.com Date: Thu Dec 18 19:29:21 2014 -0600 Added fix for issue #124: https://github.com/bengardner/uncrustify/issues/124 commit ffa7ea0fdc2dcdd26042fb814455fa03b58d1a00 Author: Ben Gardner Date: Wed Dec 10 20:41:49 2014 -0600 C#: mark a property in "new List { 1, 2, 3 }" commit af87b4751cf5aabac349152e1307dd8767d0df0e Merge: 95ba72b e27e624 Author: Ben Gardner Date: Sat Nov 22 15:05:32 2014 -0600 Merge branch 'Twigz-feature/add-const-qualifier-rule' commit e27e624416ba523330879613bcebc410a3ad6232 Author: Ben Gardner Date: Sat Nov 22 15:04:39 2014 -0600 Whitespace cleanup commit 6364871846d53862fa8492217821e11fc838fdd8 Author: Twigz Date: Fri Nov 21 11:12:21 2014 -0500 Adds a new test commit 566d2afdd178477948347e8bafbf91198b236ba6 Author: Twigz Date: Fri Nov 21 11:12:04 2014 -0500 Adds a new test commit b460d25dd6e99b9132631f4bbb9af4fbde49cf81 Author: Twigz Date: Fri Nov 21 10:21:08 2014 -0500 Adds qualifier rule for spacing commit 95ba72baf7f0833edfaaca0b8f29f6b48ef077e6 Author: Ben Gardner Date: Wed Nov 12 22:27:05 2014 -0600 D: Treat [ ] like { } as far as indenting content with tabs. commit 2046245afc355162c1dfecad59f076545c52d9dd Author: Ben Gardner Date: Tue Oct 14 14:50:37 2014 -0500 Update the year in the man page commit 86079866990368c0f18819f5fcf5cc689d3335ee Author: Ben Gardner Date: Tue Oct 14 14:49:56 2014 -0500 Rework make_win32.sh to build with the latest mingw32. Add a few more files. commit 531332f38876a189f849b20f47612958093c0924 Author: Ben Gardner Date: Tue Oct 14 14:46:33 2014 -0500 Update BUGS a bit commit ddbf42b6952a21a067991e716ab88cac974401bc Author: Ben Gardner Date: Tue Oct 14 14:20:07 2014 -0500 Rename variable "interface", as that makes mingw unhappy commit 51e931879a9844194e15197646be03268bdaa05a Author: Ben Gardner Date: Tue Oct 14 14:17:12 2014 -0500 Fix includes for Windows/mingw build commit 48001de690daf92d6d272f8ef5c8e71c8f627333 Author: Ben Gardner Date: Tue Oct 14 09:33:55 2014 -0500 Add include path to pick up windows_compat.h commit 03eb1c70fd36c6a0a23a53ad47198cf8335c7ad3 Author: Ben Gardner Date: Mon Oct 6 21:56:45 2014 -0500 Update multi-line string test commit 573fd546db2ec2e5171fb538e95f282fdb75337e Author: Ben Gardner Date: Mon Oct 6 21:44:40 2014 -0500 Handle multi-line string spacing better. Fixes SF#602 commit 76ab215694fd733877f544635760658c1e021541 Author: Ben Gardner Date: Mon Oct 6 21:28:14 2014 -0500 unc_text: Encode NL and CR as unicode for logs commit da1ab3de1363959adc2d82c0fa17ac008f93aae7 Merge: 0cdc975 b28e364 Author: Ben Gardner Date: Mon Oct 6 20:46:59 2014 -0500 Merge pull request #298 from Unity-Technologies/staging Fix for bug #600 commit b28e364b3778a9ae2ca912302fdb2ab6a24987c3 Author: Scott Bilas Date: Mon Oct 6 11:52:03 2014 +0200 Fix for bug #600 (https://sourceforge.net/p/uncrustify/bugs/600/). The nullable type was consuming the CT_QUESTION and appending it to itself, but wasn't also adjusting its end column. commit 0cdc9750dea4cea8a7db43287707b7c9f264b967 Author: Ben Gardner Date: Wed Sep 10 21:25:26 2014 -0500 Update semicolon removal test to cover new case. commit 757e2ad22a820d111758b4e8d0c864295f26ed87 Author: Ben Gardner Date: Wed Sep 10 21:24:09 2014 -0500 Do not remove the semicolon in '...) {...};' commit a60da588119327d6888230b1c47267ede3645242 Author: Ben Gardner Date: Wed Sep 10 21:22:47 2014 -0500 Log which path removed the semicolon commit 85614066efd65591305f75ad93f47b607209ee61 Author: Ben Gardner Date: Wed Sep 10 21:22:09 2014 -0500 Add a LOG_FUNC_CALL() to update the line number of the top entry. commit 72348985ddd768053ed685e503cff5f66734d1cf Author: Ben Gardner Date: Wed Sep 10 21:06:59 2014 -0500 Fixed cast detection in "(int *[])value" commit f11229b716a88f072f6d84d5b1f68cf5a415fcfe Author: Ben Gardner Date: Wed Sep 10 17:17:50 2014 -0500 Skip the top function name in log_func_stack_inline() commit d9f939d3f9aa941f372df26cdb8c554d2c7fbb2f Author: Ben Gardner Date: Wed Sep 10 17:15:11 2014 -0500 Add test for multi-line C# @"" strings commit d236601bd10be25db3d3b52b0dfa147cbeae8b9e Author: Ben Gardner Date: Wed Sep 10 17:10:45 2014 -0500 Properly detect multi-line C# @"" strings commit e97370fc83980b385d961e8a4c27d3c3eb9d9515 Author: Ben Gardner Date: Wed Sep 10 17:09:59 2014 -0500 Use log_func_stack() instead of passing around the func name/line commit 5f99e44de4265402f38e989f2f86663fbbb09730 Author: Ben Gardner Date: Wed Sep 10 17:07:52 2014 -0500 Modify log_func_stack() a bit commit 94c189d6a50f6609b2c80c6da8d98998398e17ee Author: Ben Gardner Date: Wed Sep 10 17:03:53 2014 -0500 Add a bunch of calls to LOG_FUNC_ENTRY(); commit 6b888a6186d38b06196a4ea69482a75fa5654222 Author: Ben Gardner Date: Wed Sep 10 16:06:00 2014 -0500 Add a utility functions to track and log certain function calls commit 419b2a47a8c342226eb6a99b284d8e0ace401b4c Author: Ben Gardner Date: Sun Sep 7 14:49:18 2014 -0500 Add a "file_ext" config option to specify custom file extensions. commit 172ff959f226e687b3ebb51c1c0fd0a7e90e1079 Author: Ben Gardner Date: Sat Sep 6 16:50:51 2014 -0500 Update man page for --check option commit f4a02cb29a863657c83d9f04946e8a9bc3f56866 Author: Ben Gardner Date: Sat Sep 6 16:28:22 2014 -0500 Fix odd whitespace issue commit 6f815360cf8003c74078f17e65f398afbe770508 Author: Ben Gardner Date: Sat Sep 6 16:28:10 2014 -0500 Change log that indicates the detected encoding commit 7fe2a24d34ef992ab78516d6e55f0edd5221be9a Author: Ben Gardner Date: Sat Sep 6 16:27:46 2014 -0500 Add --check option to see if a file changes when uncrustified commit b9bb1655b24911bc4629126d6121fe559e8b7a02 Author: Ben Gardner Date: Sat Sep 6 15:51:21 2014 -0500 Add missing fclose() before exit. commit c9ccb161739bb0db9b61f4aabcaba09d48ac49f4 Author: Ben Gardner Date: Sat Sep 6 15:45:14 2014 -0500 Rename variable 'dq' to 'vv', as it is for a vector, not a deque commit 888e7ce045feed34d7633386cae050096312a435 Author: Ben Gardner Date: Sat Sep 6 15:44:42 2014 -0500 Add a hook to output the file to a byte deque. commit ff03971ad08da030ca850f5d9cf0916724909bcc Author: Ben Gardner Date: Sat Sep 6 15:41:13 2014 -0500 write_byte: protect against negative ch commit b3d0212545c278a9a5c8e6dcfb256f5d4ba49c18 Author: Ben Gardner Date: Sat Sep 6 15:40:45 2014 -0500 unicode.c: make exactly one place that writes to the output file commit 9432f7cad9e85cc3001fc933ab8920e373018662 Author: Ben Gardner Date: Sat Sep 6 15:34:39 2014 -0500 Don't pass the FILE or encoding to write_char(). Preparing for multiple output paths. commit 77473c4d192a18bb507f2db8daeeb97feb00c329 Author: Ben Gardner Date: Sat Sep 6 15:23:02 2014 -0500 unicode.c: Make all functions static that can be commit 16160b6ac5bc76a9e4caa39e8de4715b5f9446f6 Author: Ben Gardner Date: Sat Sep 6 15:20:20 2014 -0500 Remove unused code: write_string() commit 54aee73007f4c9141a4fbc2892393d9aa673756b Author: Ben Gardner Date: Wed Sep 3 11:27:26 2014 -0500 Add option sp_fparen_dbrace commit c0a12ac85f3110aaa6c010b2ef2e25075b8c1623 Author: Ben Gardner Date: Wed Sep 3 11:20:03 2014 -0500 Fix nl_paren_dbrace_open in ')\n{{' commit 4120cd976bacfe11189795138138030acf65d03d Author: Ben Gardner Date: Wed Sep 3 11:14:37 2014 -0500 Add tests for nl_paren_dbrace_open commit 608543dec51e4ccfd64d5e80116fcf440e89d7a1 Author: Ben Gardner Date: Wed Sep 3 11:14:04 2014 -0500 Add option nl_paren_dbrace_open commit 69f926e4797a1f514bc91c878b77b99737dbbb8b Author: Ben Gardner Date: Wed Sep 3 11:00:21 2014 -0500 Pass through func/line in set_paren_parent2() and flags_parens2() commit ae4f4449170dfbcac96db1b9eb695489230cfe53 Author: Ben Gardner Date: Wed Sep 3 10:59:23 2014 -0500 Mark the double-brace open/close with parent_type=CT_DOUBLE_BRACE commit 1d723646eaa1069de41dd0649def9a598bc14fca Author: Ben Gardner Date: Wed Sep 3 10:52:28 2014 -0500 Clean up the log text for set_chunk_type() and set_chunk_parent() commit 0e78cafcdfadc0698b2ceb9c11474473e8823505 Author: Ben Gardner Date: Wed Sep 3 10:39:41 2014 -0500 Use set_chunk_type() instead of direct chunk_t->type assignments commit 7cdd71589f8c420588228c7ceef5bb31207a1ded Author: Ben Gardner Date: Wed Sep 3 10:09:52 2014 -0500 Add function set_chunk_type() to log assignments to chunk_t.type commit 9f9e1c9944680d5fc064fe3d1f691dcb6d0a1056 Author: Ben Gardner Date: Wed Sep 3 10:01:36 2014 -0500 Add a log in set_paren_parent() commit 5d0d28a2eb61ef7eb20f1199dafe10e737db24d1 Author: Ben Gardner Date: Wed Sep 3 09:47:01 2014 -0500 Refactor parent_type assignments to use set_chunk_parent() for logging commit b002966cfc90c6ecd835ea6a1e0241bd8928b563 Author: Ben Gardner Date: Tue Sep 2 17:39:08 2014 -0500 Add special handling for Java double brace initializers commit 2f53e1681fa5d33e3a3a4052671c3d49d464d5ee Author: Ben Gardner Date: Tue Sep 2 17:04:31 2014 -0500 Update namespace indent test results commit d2f28752fbe980a7e100a6c720308ea46a80c865 Author: Ben Gardner Date: Tue Sep 2 17:03:11 2014 -0500 Rework indent_namespace_single_indent, don't indent the namespace commit adefc45c0f18078c9273607abe20aa2f156f212d Author: Ben Gardner Date: Tue Sep 2 16:46:31 2014 -0500 Add the token parent to the LINDPC log commit da1a8b2de08c9f7768eb5af7f2ed57ddf171c453 Author: Ben Gardner Date: Mon Sep 1 22:13:16 2014 -0500 Fix C-Sharp '#property' parsing commit 12d00abd4c33a04b1a1ddce40cc174a014b3ce84 Author: Ben Gardner Date: Mon Sep 1 21:53:09 2014 -0500 Add D language "static if" test commit ec025e4f1e993333b3c3ae4564b972c618115b3c Author: Ben Gardner Date: Mon Sep 1 21:49:33 2014 -0500 Add support for D language "static if" by merging the tokens commit 6218d70859db853bda2ccc0172b6f30dfef35eb3 Author: Ben Gardner Date: Mon Sep 1 21:21:56 2014 -0500 Update test results for new '( {' indent rule commit 19b781e661b78dbd88c35e2da549c146ec2d7c90 Author: Ben Gardner Date: Mon Sep 1 21:20:30 2014 -0500 Change default to have the '{' indent override the '(' indent. Example: gtkwidget.enabled.connect((widdget) => { message("Clicked"); }); The old way would have the brace indent relative to the open paren: gtkwidget.enabled.connect((widdget) => { message("Clicked"); }); commit da37c3a85fc898081004d19e3198f6ac3052341e Author: Ben Gardner Date: Mon Sep 1 21:07:31 2014 -0500 VALA also has preprocessors (#if/#else/#endif) commit d814973783c01b047c2911912459ee313f04ff59 Author: Ben Gardner Date: Mon Sep 1 20:59:06 2014 -0500 Change order of '--update-config' and config file required checks. commit e7ff01b89b69f47317f02db4c94e3bf5d45f718b Author: Ben Gardner Date: Mon Sep 1 20:56:24 2014 -0500 Add a TODO about complaining if --update-config is used with -f, etc commit ea04e51fdd98c1af67ad3372ca840fa4971571c2 Author: Ben Gardner Date: Mon Sep 1 20:55:47 2014 -0500 Do not require a config file if generating one commit 441b3acc1ffef8d02567707d4917529c9aff558b Author: Ben Gardner Date: Mon Sep 1 20:34:39 2014 -0500 Fix variable def continuation indent for pointer vars. Example: SomeType *a, *b; commit da75afc55f5221e1407181c6c84c54c362677539 Author: Ben Gardner Date: Mon Sep 1 19:26:35 2014 -0500 Update cmt_width test commit 040cf4036206278db5472cea2d061c9f616bdc81 Author: Ben Gardner Date: Mon Sep 1 19:22:59 2014 -0500 Do not wrap a comment word if nothing has been written on the line yet commit e8bf4cd13433216bb61a5f815a30b3bda7724486 Author: Ben Gardner Date: Mon Sep 1 16:25:00 2014 -0500 Add option sp_enum_paren commit 0de157e20f7306375fc7eb4da4fd4f9b0e3e5a25 Author: Ben Gardner Date: Mon Sep 1 15:37:54 2014 -0500 Add test for option indent_namespace_single_indent commit b536f4268d28f31fe45a03bcd78589f2029d11f0 Author: Ben Gardner Date: Mon Sep 1 15:37:20 2014 -0500 Add option indent_namespace_single_indent Thanks to gnoorlanderwork for the idea. commit 7f3296723c6f97adc7164c1fd3c922b1bd18a35c Author: Ben Gardner Date: Mon Sep 1 15:07:23 2014 -0500 Update tests for new align_same_func_call_params functionality commit 5513771a22ea83c56ddae18839e44c33a6bfa4de Author: Ben Gardner Date: Mon Sep 1 15:03:44 2014 -0500 Let align_same_func_call_params() handle "class.func()" commit 17671d126a7d0285dc10b0db595694cdf611af1c Author: Ben Gardner Date: Mon Sep 1 14:30:47 2014 -0500 Don't align stuff after the last comma in align_init_brace() commit 21e7af10b5ddf3a1f48f4f56ba7edfb457dc462f Author: Ben Gardner Date: Mon Sep 1 14:29:30 2014 -0500 Enhance reindent_line() log commit df323401e80fcd7c86d277820f7c2fd42738d54c Author: Ben Gardner Date: Mon Sep 1 14:28:48 2014 -0500 Add more SPACE logs commit 7b966dc0b4502f4a1943e258668449837446cbc5 Author: Ben Gardner Date: Sun Aug 31 23:36:31 2014 -0500 Update tests and results for latest code changes commit 2007ed17b1336406b81460d2381b8601a67ae0f1 Author: Ben Gardner Date: Sun Aug 31 23:34:18 2014 -0500 Move the 'force one space before a END comment' from output to space commit e4e368890b86bda15e1ec230479aefc8363293ed Author: Ben Gardner Date: Sun Aug 31 23:33:17 2014 -0500 space: drop vbrace tokens back to the previous and skip them commit ca1abde6b817dbccadbd81502aa1c2ecbdf9d163 Author: Ben Gardner Date: Sun Aug 31 23:32:10 2014 -0500 Force a space before a comment if there was a space in the input Otherwise try to keep them in the same column as the input. commit bc5e0894f37b0b76d7cc87eef7a60c8dc1b4c683 Author: Ben Gardner Date: Sun Aug 31 23:30:23 2014 -0500 Enhance the space log a bit (show final column) commit 8a6b5b51b2da83e9b107ffcba14b3c1e944f7f1a Author: Ben Gardner Date: Sun Aug 31 23:06:39 2014 -0500 Fix duplicate rule log for sp_before_semi/sp_special_semi commit be9ea6a4ac3cfbca60a8e4c09144d74fca3381fc Author: Ben Gardner Date: Sun Aug 31 22:21:24 2014 -0500 Keep track of the original whitespace (columns) before a token commit 6ce863d5a6b2c10d4e2a1580db1b4addb4358deb Author: Ben Gardner Date: Sun Aug 31 16:57:09 2014 -0500 Fix off-by-one error for indent_relative_single_line_comments commit 7d8e560bd8a67512bb8e17a867e01f3872b727d1 Author: Ben Gardner Date: Sat Aug 30 22:33:09 2014 -0500 Run update-default-cfg.sh again commit e1728472645c0dace8f6995e2c3ca0bf5fb5d2ef Author: Ben Gardner Date: Sat Aug 30 22:32:17 2014 -0500 Fix typo in indent_paren_open_brace description commit 02237e57fe852c2a179796777e5a269b50ef8442 Author: Ben Gardner Date: Sat Aug 30 22:30:55 2014 -0500 Run update-default-cfg.sh commit 5b1183a3f0af3ef8679698b105bc85561931ebf5 Author: Ben Gardner Date: Sat Aug 30 22:25:09 2014 -0500 Add test for option cmt_convert_tab_to_spaces commit 8b04b2cc8943fb2688fa118c413d8b93492f941b Author: Ben Gardner Date: Sat Aug 30 22:22:00 2014 -0500 Add option cmt_convert_tabs_to_spaces commit a76f64c867700babbdecb07e20614a97172072b0 Author: Ben Gardner Date: Sat Aug 30 22:20:07 2014 -0500 Revert logsev of whole file ifdef log commit 38c6c324e7cebc04c0831bddcbe80a1b15687120 Merge: 6209e9d 540e0b3 Author: Ben Gardner Date: Sat Aug 30 21:46:51 2014 -0500 Merge branch 'master' of git@github.com:bengardner/uncrustify.git commit 6209e9d288a97fbc46c8ea1cd772c906249dfdd0 Author: Ben Gardner Date: Sat Aug 30 21:46:05 2014 -0500 Update test for latest comment change commit f02f57730dff061975dfd3339357b0f01c1b780d Author: Ben Gardner Date: Sat Aug 30 21:37:11 2014 -0500 The comment continue should be " * " if not combining C++ comments commit 540e0b37abd802e3c2a92248063583a839d2983f Merge: 2b81408 3e00ee5 Author: Ben Gardner Date: Sat Aug 30 16:41:12 2014 -0500 Merge pull request #283 from Speedy37/master Fix parsing issue with Objective-C message send. commit 2b81408f08af6be29fa32adea9538759047378dc Author: Ben Gardner Date: Sat Aug 30 16:38:43 2014 -0500 Update test results based on other changes commit a15e4158741a69c51644d2695e68a0ea23f4b89c Author: Ben Gardner Date: Sat Aug 30 16:36:59 2014 -0500 Clean up ifdef_over_whole_file() usage a bit. commit c732f43af8def231f23beb6d523cd52f76504c8c Author: Ben Gardner Date: Sat Aug 30 16:30:13 2014 -0500 Cache the results of ifdef_over_whole_file() commit 6a3d100bdda9075394d09a89ae19d9573c6840ca Merge: 620747e 86ca62b Author: Ben Gardner Date: Sat Aug 30 16:00:01 2014 -0500 Merge branch 'no_include_guard_indent' of https://github.com/rdan/uncrustify into rdan-no_include_guard_indent commit 620747ec48e8e8aff87c0de68910b9fe15cd59b2 Author: Ben Gardner Date: Thu Aug 28 23:01:32 2014 -0500 Add tests for new '({\n' functionality commit 1a16cfc6e2d6d40d2b4862ac391e9ebe7c73d409 Author: Ben Gardner Date: Thu Aug 28 23:00:33 2014 -0500 Indent by brace in '({\n', add option indent_paren_open_brace to revert This is mainly for objective C code. commit c5e9583136dc576805dae5ea1ca2490622d56051 Author: Ben Gardner Date: Thu Aug 28 22:50:19 2014 -0500 Make the LINDPC logs much more verbose and easier to read commit 0f6dbafe9f79c4aad2d5c879ccb19c1a1e31edd1 Author: Ben Gardner Date: Fri Aug 22 20:00:21 2014 -0500 Add missing config for test 562 commit e85bc5a6eb32106f3d3d05d70d726be5c0492e5c Author: Ben Gardner Date: Fri Aug 22 15:20:33 2014 -0500 Update test results based on new comment substitution code commit 8e1742f64b8d14648d48ddce9126c866b26f0215 Author: Ben Gardner Date: Fri Aug 22 15:20:08 2014 -0500 Do comment keyword substitution before processing the comment. commit a91f95312e2b372f40ebca53021c666f15dadd38 Author: Ben Gardner Date: Fri Aug 22 12:54:43 2014 -0500 Add more tests commit 96a655df62e6d6ea92533de2906f8ea0367bb91b Author: Ben Gardner Date: Fri Aug 22 12:54:30 2014 -0500 Do comment keyword replacement earlier and directly on the comment text. commit b8d8b0202e31dac687b892f8c9a41fb687ec2024 Author: Ben Gardner Date: Fri Aug 22 12:53:36 2014 -0500 Enhance unc_text with insert(), erase(), rfind(), and replace(). commit 68c76717b183c4e80fee468e3d317c5be6c02d4a Author: Ben Gardner Date: Fri Aug 22 10:57:50 2014 -0500 Fix comment keyword substitution of 'fclass' inside a class commit 43edc60aa6d58a767193b5e8d43457d9708ec65f Author: Ben Gardner Date: Fri Aug 22 10:27:56 2014 -0500 Clean up index.html a bit commit 622a0cbe0db7257cfd32f882d88a34e35de5cdc7 Author: Ben Gardner Date: Thu Aug 21 23:11:26 2014 -0500 Add test for SF#562 commit 0ffb183bd3f6c55a393d1fcf37581d5913a836ec Author: Ben Gardner Date: Thu Aug 21 23:10:56 2014 -0500 Fix operator call detection in "baz(&operator[](bar));" commit a6ac4f0fedd98efe23fdd4f94087361b3eb522a5 Author: Ben Gardner Date: Thu Aug 21 21:57:21 2014 -0500 make_version.py: no need to split lines of uncrustify_version.h.in commit f4af8773e815af8f3feae6251f19ac4a7f211cda Author: Ben Gardner Date: Thu Aug 21 21:54:36 2014 -0500 Update make_version.py after the configure.ac rename commit e8e4c21a116fdea29def40aceaa0f4320f6b0d94 Author: Ben Gardner Date: Thu Aug 21 21:50:27 2014 -0500 Re-run autogen.sh on Ubuntu 14.04 commit f199bd478471e7db1477ac15c5da3af5451d20d9 Author: Ben Gardner Date: Thu Aug 21 21:45:37 2014 -0500 Rename configure.in to configure.ac commit 8b3f1083fe074cc14ea2e43ad18374ea1df09f3e Author: Ben Gardner Date: Thu Aug 21 21:44:25 2014 -0500 Add a script to update the version commit 1751709f4026da603f5ac5420669c4dcb50a48f8 Author: Ben Gardner Date: Thu Aug 21 21:01:32 2014 -0500 Do not remove semicolon in "return {a, b};" commit f815d6b3964295c5d9864df14988aff6f55d7a5e Author: Ben Gardner Date: Thu Aug 21 20:48:44 2014 -0500 Remove incorrect warning about unmatched VBRACE_OPEN at the EOF commit 94a2eabf307fc7534c3be3de36a8670ce2623e05 Author: Ben Gardner Date: Wed Aug 20 20:47:15 2014 -0500 Add test for GH#287 commit 39914d4e1e593f66f23505ce14cbfd4e5a69adf8 Author: Ben Gardner Date: Wed Aug 20 10:32:24 2014 -0500 Add test for SF#588 commit 7234f48a60ac0ec1a1798e1d9e535f4f104eea69 Author: Ben Gardner Date: Wed Aug 20 10:29:23 2014 -0500 Add support for VALA numeric identifiers: '@4' is a WORD, not a NUMBER commit 6f41f0ce00522f0bc3ccb1d475adfb8beb1eef72 Author: Ben Gardner Date: Wed Aug 20 10:28:36 2014 -0500 A change in preproc level should reset '<<' aligning. It probably should reset other aligning, too, but no one has complained. commit 71417801533cb5e0c7c112fafcd0bdd520c7edfc Merge: 80b7109 d33176e Author: Ben Gardner Date: Tue Aug 19 22:37:28 2014 -0500 Merge pull request #285 from PerfectCarl/patch-1 Mention VALA in -l option in the help message commit d33176e1afa755c1a9299fa5893c7179369e4339 Author: PerfectCarl Date: Tue Aug 19 11:08:36 2014 +0200 Mention VALA in -l option in the help message commit 80b7109e9465914721884681bcf7f8aa5d9a5ea4 Author: Ben Gardner Date: Mon Aug 18 14:56:47 2014 -0500 Add test for SF#594 commit 18393d0345ecff19da0c4e15c718b1656263b27c Author: Ben Gardner Date: Mon Aug 18 14:56:19 2014 -0500 Do not call tokenize_cleanup for the C language (and a few others). commit 3e00ee5dcb90f07056a02a995b9052f54fe6c8cb Author: Vincent Rouillé Date: Mon Aug 18 16:29:30 2014 +0200 Fix parsing issue with Objective-C message send. Parsing message like [(id)obj msg:var] was failing. commit add39bf18ae0f76f53d9d8703805c7543d61db15 Author: Ben Gardner Date: Sat Aug 16 20:30:01 2014 -0500 Add a test for SF#593 commit 1ac4301a450fc238ac4ff4f0a59579dbecb55e27 Author: Ben Gardner Date: Sat Aug 16 20:29:04 2014 -0500 indent_continue should also apply to class constructor calls. Not sure why that was explicitly disabled, but no tests failed after removing that check. commit 5d1bfcc1b2512283c1b72a79fd0abcc1a88543f4 Author: Ben Gardner Date: Fri Aug 15 16:09:45 2014 -0500 Split FUNC_CLASS into FUNC_CLASS_DEV, FUNC_CLASS_PROTO commit 05a5d5bcc6d524d3290fbc10deacbf623360adab Author: Ben Gardner Date: Fri Aug 15 15:22:02 2014 -0500 Remove invalid 'namespace' from C test commit ff21c4ff8dd77444143ce860f34620f71d82c2a6 Author: Ben Gardner Date: Fri Aug 15 15:19:58 2014 -0500 "namespace" is not a keyword in the C language. commit 173e61aa02b98499474b694291d6cb7be70a7434 Author: Ben Gardner Date: Fri Aug 15 15:08:07 2014 -0500 Fix null deref if file starts with a newline commit 8ca5edfa5b30fa55ef72fe5c5cc8d8e268f3edb9 Author: Ben Gardner Date: Wed Aug 13 09:39:32 2014 -0500 Missed a ctx.restore() in parse_code_placeholder() commit 53725db37577296299c3e5df961402cf6d24190b Author: Ben Gardner Date: Fri Aug 8 17:54:36 2014 -0500 Protect trailing space inside a multi-line string commit 397b2f95193c2ee04a8e9b6d1dbb73e244bfe0c0 Author: Ben Gardner Date: Fri Aug 8 17:44:17 2014 -0500 VALA verbatim string: missing setting nl_count commit 12eb6a6ababa2dab992fe73475c6f8ec34117036 Author: Ben Gardner Date: Fri Aug 8 17:34:34 2014 -0500 Rework parse_code_placeholder() commit 420b06637bb19be1f9dba5a285f07521772cf5e6 Author: Ben Gardner Date: Fri Aug 8 17:33:34 2014 -0500 Drop new option dont_protect_xcode_code_placeholders I don't see how anyone would not want this. commit a442258c580a71066b7b64cfe6fd033a7decb11c Merge: c55f777 6059686 Author: Ben Gardner Date: Fri Aug 8 17:24:03 2014 -0500 Merge branch 'jgross-xcode-placeholders' of https://github.com/JoshuaGross/uncrustify into JoshuaGross-jgross-xcode-placeholders Conflicts: tests/objective-c.test commit c55f777dda2be74ed7d264f4ec298d7393d0e241 Merge: f28d310 3214eac Author: Ben Gardner Date: Fri Aug 8 17:19:29 2014 -0500 Merge pull request #263 from mys007/master Fix Issue 262 commit f28d310ae56840e50b22c51d9da5a9e4027b061d Merge: ade7245 3111f77 Author: Ben Gardner Date: Fri Aug 8 17:16:50 2014 -0500 Merge branch 'master' of https://github.com/orudge/uncrustify into orudge-master Conflicts: src/punctuators.cpp commit ade7245cc6b1fda9239d5965bc47e2dfc8f1a369 Author: Ben Gardner Date: Fri Aug 8 17:07:14 2014 -0500 Clean up whitespace from merge commit 4d20bcaeef08eff40d60d389bea9e6e360d84a18 Merge: dbc35fe faa3a8e Author: Ben Gardner Date: Fri Aug 8 17:04:56 2014 -0500 Merge branch 'java-try' of https://github.com/Keepun/uncrustify into Keepun-java-try commit dbc35fee81a99dc1dcda4e92aa991313c2d5a2fa Merge: 034f7e2 fad09d7 Author: Ben Gardner Date: Fri Aug 8 16:58:16 2014 -0500 Merge pull request #277 from tintou/master Added missing vala punctuators. commit 034f7e218e3140b2261ae5a0b2b2b7513d9ffc26 Author: Ben Gardner Date: Mon Aug 4 22:53:47 2014 -0500 Add basic support for VALA verbatim strings. It looks like it is stripping trailing spaces in the string, but that is a separate issue. commit fad09d7ff1342a4f3bf3a27a7acb9bb32413a609 Author: Corentin Noël Date: Tue Jul 29 02:37:35 2014 +0200 Added :: as it might be used in some projects. commit 1839b061d7af045abbf1433dd89e3a53f44588d6 Author: Corentin Noël Date: Tue Jul 29 02:19:24 2014 +0200 Fixed missing vala ponctuators. commit 3111f775de155e7981aed56b6618a081e2db4767 Author: Owen Rudge Date: Fri Jul 18 15:12:41 2014 +0100 Fix right shift (">>") turning into "> >" in C# commit 3214eacea005b4ba73efdf7fe44d69b45518b327 Author: Martin Simonovsky Date: Sun Jun 1 13:21:16 2014 +0200 fixed operator priorities in line splittings commit faa3a8e407ad0b0c395b0b2c1b0f89c010d8164e Author: Keepun Date: Sat May 24 02:53:46 2014 +0400 Fix try-with-resources statement in Java 7 commit 36a0f44c54ee6301a5a208a12c08f97e59fcaa42 Author: Ben Gardner Date: Thu Apr 3 23:03:42 2014 -0500 Fix wrong test result. commit 1022db6785f99f26f944eb9d21690369a2eecde3 Author: Ben Gardner Date: Thu Apr 3 23:00:34 2014 -0500 Fix indent error if an open paren is the first thing on a line We cannot use the column of the paren until it has been indented, so indent it right away. Fixes SF#572 commit c883fb79794806105f01b02d45e8da69d288d9b5 Author: Ben Gardner Date: Thu Apr 3 22:58:42 2014 -0500 Enhance indent detailed logs - show the whole stack commit 4ddf2df6dbc480568f3d3a307eb29c5ae2361643 Author: Ben Gardner Date: Thu Apr 3 22:00:26 2014 -0500 Add test case for SF#574 commit 1bbac3f0021c44d9e2ff7b8a14bb1cda008b3b1a Author: Ben Gardner Date: Thu Apr 3 21:57:22 2014 -0500 Do not remove a newline before a function if preceded by a Vbrace close Fixes SF#574 commit f4b55060cb678f5ab86af43f37ca1da88dbcbb1c Author: Ben Gardner Date: Thu Apr 3 21:56:22 2014 -0500 Wrap newline_iarf() and newline_iarf_pair() in macros to trace calls commit 04a29f322b87d895b57792547f2fd1044b1403b9 Author: Ben Gardner Date: Thu Apr 3 21:37:44 2014 -0500 Work around labeling mix-up with ?: and OC messages commit 6059686712cacc0417ca652c291cdecaec577f26 Author: Joshua Gross Date: Sat Jan 25 21:44:42 2014 -0800 Handle Xcode code placeholders. commit 20cd06a17c4ac6e1ceffe59028cc80657a877d6d Author: Ben Gardner Date: Thu Jan 23 21:37:59 2014 -0600 Whitespace and style clean up commit 2c27e1c95bb205d02662d3095eae24a435d6d856 Author: Ben Gardner Date: Thu Jan 23 21:23:14 2014 -0600 Fix compile warning about uninitialized variable. The condition "can't happen", but may as well make the compiler happy. commit b4c8b3610166b580f557e0f90f9c091b63830e25 Author: Joshua Gross Date: Wed Oct 23 17:19:07 2013 -0700 * Fix a segfault parsing Objective-C blocks * More indenting options for Objective-C blocks, and passing blocks as method invocation parameters. * Fix `for...in` for Objective-C. * Allow methods to be invoked on Objective-C primitives, like NSStrings. * Unit tests for the above. Fix case of block literal being mistaken for block signature. Adding another test case for situations where extra space is added around a block passed in as the first argument of a C method invocation. Adding the cfg file for our new tests. Fix case where a block is passed as the first argument of a C-style method invocation; the parser marked the whole thing as a block type definition. Add another test for short ternary expressions and make sure it takes precedence over question mark spacing. Strengthening tests to make sure that short ternary doesn't break regular ternary expressions. Test showing how Uncrustify fails to treat messages on string literals properly. Allow messages to be sent to NSStrings. Add tests that show that casting to (id) breaks parsing (meaningless operation but syntactically valid). Allow `(id)[obj args]` as a valid Objective-C casting statement. Fix test case expected output. Fix for (x in y) for objective-c Improving indentation support of blocks being passed into message invocations. New options for indenting blocks in message invocations in different ways. Fix the block indentation options for Objective-C; it was very aggressively indenting more than was necessary. Mimic Objective-C style inline-block indentation. Prioritize aligning everything with the first message in a message invocation, if possible (as long as it doesn't force us to go below the current indentation level, we're fine). Xcode-style block-in-message indenting. Fix segfault Put parens around bitwise op Fix indentation Move check for for...in loops in Objective-C to a helper function in chunk_list.h Adding small test-case for for...in loops with id type declarations. Adding small test-case for for...in loops with id type declarations. commit 59aef5ceaba9e7dfa8f0e7a5d31cbe1d21cb2d53 Merge: b519818 b1ccf9d Author: Ben Gardner Date: Mon Jan 13 14:17:17 2014 -0800 Merge pull request #231 from Lykurg/fixspelling Fix typo in documentation commit b1ccf9dbbd34a0a8533423e25412e418e2a9af33 Author: Lykurg Date: Sun Jan 12 13:15:32 2014 +0100 Fix typo in documentation commit b519818ff9cc4225b4bcd905cc15b472c35f367d Author: Ben Gardner Date: Sun Jan 5 21:57:01 2014 -0600 Clean up formatting. commit f15390ebacb54c3c2a2780e26ba0259ca9d63bc6 Author: Joshua Gross Date: Mon Oct 28 16:26:50 2013 -0700 Differentiate between normal ternary (a ? b : c) and short ternary, (b ?: c) with option sp_cond_ternary_short commit 4b83d06c86ab949d1bc71d8eaa2cee9e9c7332bb Author: Tim Hütz Date: Sun Dec 29 12:35:48 2013 +0100 Fix build on Windows Added the missing include statements to build uncrustify on Windows (using Visual Studio Express 2013). commit 3dfe4933a0cf53cb966fb4312d4203911e66748e Author: Ben Gardner Date: Sat Jan 4 13:31:45 2014 -0600 Fix UniversalIndentGUI comment for newline options commit 8039738f68530f36a4edbaa254b2bdc0824ae594 Author: Ben Gardner Date: Mon Dec 16 20:50:01 2013 -0600 Update test 30750 for new option nl_brace_fparen commit 3ccea5e2702454f9da206f5b5f31c3cc13b33079 Author: Ben Gardner Date: Mon Dec 16 20:49:05 2013 -0600 Add option nl_brace_fparen to make test 30752 pass again commit fac76ee437b3e0a4adea2c6869f01aa3ff68d3ee Author: Ben Gardner Date: Mon Dec 16 20:48:31 2013 -0600 Fix option name: nl_brace_fparen commit 277e83780bc1f9f141b2ff3d8adf6dc38ec9133e Author: Ben Gardner Date: Mon Dec 16 20:45:23 2013 -0600 Whitespace cleanup. commit 4e1ce1982a698d6e36b90b59447179b9b004b9f5 Merge: 465c4cb 7c85198 Author: Ben Gardner Date: Mon Dec 16 20:37:49 2013 -0600 Merge branch 'alanf/space-between-block-and-square-brace' of https://github.com/alanf/uncrustify into alanf-alanf/space-between-block-and-square-brace commit 465c4cb4f770cf685bf7cc7611d4a85de0ccc97e Merge: f066915 a98ff1a Author: Ben Gardner Date: Mon Dec 16 17:37:02 2013 -0800 Merge pull request #205 from loudnate/patch-1 Correcting issues in default objc.cfg commit 7c85198f51d813884447bd2c8f2f9823aabc5252 Author: Alan Fineberg Date: Mon Dec 9 14:22:01 2013 -0800 Allow removal or addition of newlines after blocks. commit f066915cb48fff599321268e2bdc72d4a411ae9f Merge: 72fc222 b8ed112 Author: Ben Gardner Date: Tue Oct 15 20:37:57 2013 -0700 Merge pull request #207 from idpaterson/pull-requests/oc-ns-enum-alt Added support for NS_ENUM and NS_OPTIONS modern Obj-C enums commit b8ed112d479a23f7576e38f5e899eab4e38b9bea Author: ipaterson Date: Mon Oct 14 19:38:38 2013 -0400 Added basic support for NS_ENUM and NS_OPTIONS syntax using enum formatting rules. Fixes #143 and fixes #201. commit a98ff1aed753af485e855d2faab2c918258936f5 Author: Nate Date: Sun Oct 13 19:39:17 2013 -0700 Correcting issues in default objc.cfg commit 72fc222641ef6c592f70c5de5b92f04936bc6306 Author: Ben Gardner Date: Mon Oct 7 22:01:02 2013 -0500 Do a little code-style clean up commit 62d836458b8ef3efb2cd7f24ded256967511ee8d Merge: 5c571d4 e4d50b7 Author: Ben Gardner Date: Mon Oct 7 21:53:13 2013 -0500 Merge branch 'java-class-names-with-brackets' of https://github.com/npnth/uncrustify into npnth-java-class-names-with-brackets commit 5c571d415182a668bf053ba31130575079b8bd22 Author: ipaterson Date: Mon Oct 7 16:10:54 2013 -0400 Fixed handling of multiline arrays to match disctionaries. Previously the closing bracket was being aligned with the opening bracket, producing a very odd indentation. commit de982885cb09c2d91f1086e6473faaffab645029 Author: ipaterson Date: Mon Oct 7 16:05:56 2013 -0400 Fixed invalid Objective-C array literal syntax in tests. Arrays use square brackets, not braces. commit e4d50b74db2f21eda5505069cab7e639cb4f7137 Author: S. Gilles Date: Sat Sep 7 01:41:48 2013 -0400 Less fragile array-as-type handling Handle [], [N]-skipping in a better section of the code, which fixes some restrictions on the number of type tokens before an array for recognition (i.e. `final int[] a;' would be recognized, but `int a[];' would not). Test 80030 is updated to reflect this. commit 612c4aa8eea099e26f7abb80a5d14adb5b4bee45 Author: Ben Gardner Date: Thu Sep 5 20:49:12 2013 -0500 Update the README file to indicate that bugs should go on the sf.net site That info is also in the BUGS file, but github.com doesn't show that. commit e84a5811953b5fe95edb74e8268dd504a5d540e5 Author: Ben Gardner Date: Sat Aug 31 01:17:56 2013 -0500 Add another class colon test commit 058eac81bcb46c2804a30e684687b274e2a62eec Author: Ben Gardner Date: Sat Aug 31 01:17:15 2013 -0500 There cannot be variables to align in a class base list commit 25031c042320bbbd51a64dfc857f37371a361fbe Author: Ben Gardner Date: Sat Aug 31 01:14:15 2013 -0500 Mark stuff between a class base ':' and the '{' as IN_CLASS_BASE commit d2345631e2d49ada2c877eb0ad266c6d53c46373 Author: Ben Gardner Date: Sat Aug 31 00:38:35 2013 -0500 Update config files for the CLASS_COLON/CONSTR_COLON split commit 3dcffc22a4ec69afa82d4e35a3bab7943a62018e Author: Ben Gardner Date: Sat Aug 31 00:37:56 2013 -0500 New options: indent_constr_colon, nl_constr_colon, nl_constr_init_args, pos_constr_comma, pos_constr_colon This should finish the split between the class initializer list and base class list. commit cdadf3b0127a3c7ce37efa9525bcbbf45f0789e3 Author: Ben Gardner Date: Fri Aug 30 23:56:02 2013 -0500 Add options sp_after_constr_colon and sp_before_constr_colon Assuming that indent_ctor_init_leading was only meant to apply to the constructor colon, not the class declaration. No tests fail, but that may be because there is no test coverage. commit 0404165b13e37bdbcaed38cd1feb5d7c783795cd Author: Ben Gardner Date: Fri Aug 30 23:48:13 2013 -0500 Split the constructor initializer use CLASS_COLON into CONSTR_COLON. Keep all the options the same, so there is no change in test output. commit 25dd1fdc9923250ee0f1da92a8ceb3053ef0fa23 Author: Ben Gardner Date: Sat Aug 24 21:24:50 2013 -0500 Fix crash due to incorrect NULL check. commit 6d2b4980468c2f0c1d386fbe7d0625799463839b Author: Stephen Gilles Date: Wed Aug 21 17:02:10 2013 +0000 Simplify chunk_get_next_nisq commit ffb0d2693ea8d5d8c2e18c3e667e878d2f1bef03 Author: S. Gilles Date: Sat Aug 17 19:06:44 2013 -0400 Treat class names with array indicators as CT_TYPE in Java Extends the 'word followed by word is type' check to skip past intermediary (nested and stacked) sets of bracket. commit dd1dc2d81323bebdae2b85b2df49f6cddaaf2f2a Author: Ben Gardner Date: Thu Aug 15 00:48:18 2013 -0500 Use tok_ctx.expect() in a few more places. commit 28d53f6263d5ac24cc57f035a37fe898971ae84d Author: Ben Gardner Date: Thu Aug 15 00:28:46 2013 -0500 Remove unused local variable. commit 44cce3c3998233dc83c32d345e3db2e7bedbc1ca Merge: 5a2faae b2fbac9 Author: Ben Gardner Date: Thu Aug 15 00:26:01 2013 -0500 Merge branch 'master' of https://github.com/npnth/uncrustify into npnth-master commit 5a2faae9790991f0d8879e785e8d12606525c393 Merge: e11229f d8a4ec8 Author: Ben Gardner Date: Wed Aug 14 22:16:55 2013 -0700 Merge pull request #196 from villytiger/decltype Fix applying sp_before_dc rule with decltype commit d8a4ec8182c77f56b4389197c580d704bba0f706 Author: Ilya Lyubimov Date: Thu Aug 8 22:07:46 2013 +0400 Fix applying sp_before_dc rule with decltype Rule wasn't applied and one space was forcely added in the following example: std::vector v; decltype(v)::const_iterator it; commit b2fbac97eaf58220a60713ac939b9f6518cc9c8c Author: S. Gilles Date: Sun Aug 4 15:41:04 2013 -0400 Explicitly recognize '@interface' as class-like keyword In Java, treat '@interface' like the keyword 'class', including all implied indentation. This changes the results of 80010, and as such is a distinct commit. commit 9c208322522772aa0483dbf0a318e0e99a502f95 Author: S. Gilles Date: Sun Aug 4 04:10:13 2013 -0400 Better handling of Java interfaces Handle Java interfaces without relying on untracked newlines so that nl_remove_extra_newlines can be nonzero. Also handle the keyword @interface during tokenization so that it is not mishandled. Tests 80011-80014 are added as well. commit e11229f1d86ad0acbfa84f5863d0fd094817fc4b Author: Ben Gardner Date: Sat Jul 13 13:09:39 2013 -0500 Add tests for fix for SF#557 commit 860378c4ba6aa482711513e44ad90b1d59ee8c69 Author: Huang-Ming Huang Date: Sat Jul 13 13:07:06 2013 -0500 Fix function parameter classification bug commit b4a057cfd17618f459a80a589b46fdf696d5a4ec Author: Ben Gardner Date: Sat Jul 13 12:33:31 2013 -0500 Add test for github issue 137 - objc indent issue commit 2b268a241f7244fa2b24a6c30caa25df41796524 Author: Ben Gardner Date: Sat Jul 13 12:32:44 2013 -0500 Fix whitespace around '+' in last commit commit 0326d0594f48e8c771d524d18778dc2975690f04 Merge: 936558e 06c8ecb Author: Ben Gardner Date: Sat Jul 13 10:31:03 2013 -0700 Merge pull request #185 from mmcdole/master Fix nested block indentation in Objective-C commit 936558e04a1a234cfb3c5eee34ee68b06b418f1b Author: Ben Gardner Date: Sat Jul 13 12:15:44 2013 -0500 Trailing whitespace fix commit cde6fea68d1f593c8ed3972c70669cdaebc4188b Author: Ben Gardner Date: Sat Jul 13 12:15:27 2013 -0500 Add a test for the new sp_cond_xx_xx options commit 58a2138e587576ad27c469053df625bf80bc41be Author: Ben Gardner Date: Sat Jul 13 12:07:47 2013 -0500 Add sp_cond_colon_before/after and sp_cond_question_before/after. Thanks to Daniel Burr. commit 67ce0bfe08b4b5f9282c1eaf508a67009bfae4c2 Author: Ben Gardner Date: Sun Jun 30 22:00:55 2013 -0500 A stray colon in a 'for' statement is likely a FOR_COLON. Thanks to github user shhccie for finding the issue. commit 06c8ecb30abd418c7e6297f43449ce24cc91f6b3 Author: Matthew McDole Date: Wed Jun 26 15:48:07 2013 -0500 Fix issue with nested blocks in OC commit 41f04c88dfdf3aa1769add9fbcbe195d20a72457 Author: Ben Gardner Date: Wed Jun 12 22:19:41 2013 -0500 Add a test for the long brace comment options. commit 49f5cd579166085a5fc42e4d5850973126f8a0b3 Author: Ben Gardner Date: Wed Jun 12 22:19:02 2013 -0500 Grab the full namespace or function name. commit c0073178d2d4340e6a0fedf0c62b8907a0730eb1 Author: Ben Gardner Date: Wed Jun 12 21:53:27 2013 -0500 Don't use standard lib name for a variable. commit 9117dc60e1e5aa7b230541dfad90f72480af99bf Author: Ben Gardner Date: Wed Jun 12 21:53:00 2013 -0500 Fix crash bug when running test 10010 due to NULL pointer (ns_pc). commit 29e33a35adf05ba75d46ceb2df5f04c45000e5cc Author: Marius Zwicker Date: Tue Jun 11 17:05:46 2013 +0200 Added the option to add a comment after closing braces of namespaces, similar to functions commit 06fd7cd290136fe31c7687181599916fa8ff70c5 Author: Ben Gardner Date: Sat Jun 8 12:10:12 2013 -0500 Add test for SF#538. commit 1478a195ea804a501d6354d7b5fdbbca6c86e70b Author: Ben Gardner Date: Sat Jun 8 12:07:02 2013 -0500 Allow types (var defs) inside for(), if(), while() loops. commit 12b722905b2b53de37d74309d32756afdd3a03fc Author: Ben Gardner Date: Sat Jun 8 12:05:57 2013 -0500 Remove unused label. commit c6af5594221da60e725a3466f83178f2e956efc2 Author: Ben Gardner Date: Sat Jun 8 12:05:41 2013 -0500 Mark LVALUE in the first pass. commit acf6ae6abc4ffa096c93ff69acaa7006642043bc Author: Ben Gardner Date: Thu Jun 6 21:50:20 2013 -0500 Extend/add test case for SF#537 commit aacacc7c443315320108d03e3d292c448f964de3 Author: Ben Gardner Date: Thu Jun 6 21:43:09 2013 -0500 Extend the list of tokens that shouldn't be before a proto/def commit 485d7682a4cb5949c833c3260c950416d3d258bb Author: Ben Gardner Date: Thu Jun 6 21:18:40 2013 -0500 Try doing a class continuation indent. commit 20653f4ee86f0d44a95b756c5b1404a6ce2790ab Author: Ben Gardner Date: Thu Jun 6 20:51:30 2013 -0500 Add something to a test to cover "(*x)();" commit 395b0fc45ae23b1fa1d7d34c57a7bb86d2be3fe1 Author: Ben Gardner Date: Thu Jun 6 20:50:54 2013 -0500 Require *something* for a function type definition. commit a9bde78443c5da89ea5761e6a33ffe914ab6514e Author: Ben Gardner Date: Wed Jun 5 23:44:04 2013 -0500 Do a better job of skipping B:: in "A(B::*C)();" commit fd3cd8775ba6b940cec494a1d467049e69a6bf91 Author: Ben Gardner Date: Wed Jun 5 23:26:53 2013 -0500 Check the 'return' type for a function type. commit a5ecb4772c95dd818c474c1e38fa2dcc5087eff7 Author: Ben Gardner Date: Wed Jun 5 22:55:07 2013 -0500 Require '{', ';', or '=' after a function type. Fixes part of SF#532. commit 6bc77231195f6ca75472a428c8d5bc26629c4637 Author: Ben Gardner Date: Wed Jun 5 22:29:49 2013 -0500 Update test for C comment fix commit 6ad733743f5db519cd3edc84e7a300672361f0bf Author: Ben Gardner Date: Wed Jun 5 22:28:56 2013 -0500 Add some protection against adding a '*/' inside a C comment commit ed0b66aacd88b7e6c565c6feea20b216e977560d Author: Ben Gardner Date: Wed Jun 5 22:00:42 2013 -0500 No return type for constructor/destructor Affects nl_func_proto_type_name and nl_func_type_name. Fixes SF#530 commit 77681bfd703af2de55c2550317400b012c89ac8b Merge: a290e0c bdfe301 Author: Ben Gardner Date: Tue Jun 4 21:32:15 2013 -0700 Merge pull request #180 from berenm/cpp-lambdas Better support for C++11 lambdas formatting. commit a290e0c455383748f2e436671611dae758c711a9 Merge: 1e38539 61f8b86 Author: Ben Gardner Date: Tue Jun 4 21:29:13 2013 -0700 Merge pull request #181 from berenm/cpp-braced-init Support C++11 braced initializer lists. commit 61f8b869c18502375afacb8a325fd569ec4f500b Author: Beren Minor Date: Tue Jun 4 20:17:47 2013 +0200 Support C++11 braced initializer lists. commit bdfe301d4f21ee4be6940b200692f0fcf77bab0a Author: Beren Minor Date: Tue Jun 4 18:25:51 2013 +0200 Update etc/defaults.cfg with missing options, from --update-config-with-doc. commit faf210181cf57c5ecb895de1e83f710a6952772c Author: Beren Minor Date: Tue Jun 4 12:02:36 2013 +0200 Support newline addition/removal before opening brace for C++11 lambda. Add new nl_cpp_ldef_brace option to add/remove/force newline before C++11 lambda opening brace. commit 05ba0c5e7ab7cfcdcc5bdf3fa053ccd7f7705e6f Author: Beren Minor Date: Tue Jun 4 11:04:27 2013 +0200 Support one-liner C++11 lambdas. (Closes #162) Add new nl_cpp_lambda_leave_one_liners option to leave one-liner C++11 lambdas. commit 1e38539c662c662cf2b4d690be5addbb0b30c18f Merge: 2fc8bee 7ba2041 Author: Ben Gardner Date: Sat Jun 1 10:26:14 2013 -0500 Merge branch 'master' of github.com:bengardner/uncrustify commit 2fc8beea2586b931e22c80f03e18bbb138f324d8 Author: Ben Gardner Date: Sat Jun 1 10:24:31 2013 -0500 Fix code indent commit fa8987ebb27f89f66f0c9b13c9c8033aec393cdc Author: Ben Gardner Date: Sat Jun 1 10:20:24 2013 -0500 Use parens in 'if' statement commit f4f1d6dfec4ba24a0f32f8af7a2239e2ea8bc7dc Author: Ben Gardner Date: Sat Jun 1 10:20:59 2013 -0500 Undo change that breaks the @return comment in java comments commit 9c7ff6f05360f0bfc8bd992eeab23aa6a1095c85 Author: Florin Pop Date: Mon May 27 19:37:42 2013 +0200 Output Objective-C parameter names where $(javaparam) is used in a comment block. commit 7ba2041fb62f8f32969813ee59b4468df4cd83ad Merge: 6f840f2 7689235 Author: Ben Gardner Date: Sat Jun 1 08:09:09 2013 -0700 Merge pull request #173 from nightdelphin/fix_keyword Fix "finally" keyword in keywords.cpp commit 6f840f2da5f316a67146fe7a366b412593cd189c Author: Ben Gardner Date: Sun May 26 22:31:20 2013 -0500 Enhance test for align_same_func_call_params to cover brace levels. commit b338372bb6fd32c8faa7bac059ea6b3e7adbd879 Author: Ben Gardner Date: Sun May 26 22:30:25 2013 -0500 Fix align_same_func_call_params with different brace levels. commit a2741b1208eafeb3c12446c98008d1bcf4f088e3 Author: Ben Gardner Date: Sun May 26 22:03:08 2013 -0500 Add test for options sp_word_brace and sp_word_brace_ns commit 569d2cd0fa74376eef4ebb1b72c01ed65f86140f Author: Ben Gardner Date: Sun May 26 22:02:50 2013 -0500 Set defaults to new options to not change current behavior commit 7496a1d2b40b6c46ccf46e42698a04f4ced370a9 Author: Ben Gardner Date: Sun May 26 22:02:27 2013 -0500 Set the parent for the braces around get/set pairs. commit cdc3e28d68c9fd07287289fbb2dae8aa3e35dc08 Author: Ben Gardner Date: Sun May 26 22:00:11 2013 -0500 Add sp_word_brace_ns and sp_word_brace to control space in 'word {' Addresses SF#545 commit 1b5bdb93aa143de4ad50d2446b73ac390fd62c1d Author: Ben Gardner Date: Sun May 26 21:22:14 2013 -0500 Update test to cover SF#547 commit 3526839296295de7a5fa1f718e28a05656b5a0b2 Author: Ben Gardner Date: Sun May 26 21:21:50 2013 -0500 typename also indicates a function param type. commit 2158000a3652c4246051cab381308a1bf25faec2 Author: Ben Gardner Date: Sun May 26 21:08:22 2013 -0500 Add some logs that were useful in fixing SF#546 commit 77c2a484f64ebf50319bb5edf45bf06fb6915d4d Author: Ben Gardner Date: Sun May 26 21:07:53 2013 -0500 Add two other function template patterns to the nl_func_type_name test. commit 5c33a3175bd1f1b319bc84054ca6b4e9063840d6 Author: Ben Gardner Date: Sun May 26 21:06:26 2013 -0500 Fix nl_func_type_name for template functions. Fixes SF#546 commit 0288131faf20267b174f44ecf87c0ea426940d3c Author: Ben Gardner Date: Sat May 25 17:24:21 2013 -0500 Add test case for SF#548 commit 3716f7f6605e0d1689220a953e3baf0e910de191 Author: Ben Gardner Date: Sat May 25 17:19:27 2013 -0500 Add a new token for the 'class' in 'enum class'. May fix SF#548 commit 9936f1b7d5de8b72a0f2d7f768e62403f6196589 Author: Ben Gardner Date: Sat May 25 17:01:52 2013 -0500 Add test coverage for SF#549 commit cb9853b4cb653fccb8dee0321e3117bad9692b41 Author: Ben Gardner Date: Sat May 25 16:57:21 2013 -0500 Add test for SF#550 commit 4c3e74457e31e69e95a99fd7622644a5dbc45b18 Author: Ben Gardner Date: Sat May 25 16:52:46 2013 -0500 Don't remove braces if it contains a switch statement and other stuff. Fixes SF#549 commit c658f44a26fe827577866585b0c359323e1a2e01 Author: Ben Gardner Date: Sat May 25 12:08:46 2013 -0500 Don't try to align '<<' in enums. Fixes SF#550 commit 7689235fda8d378ea09825ab049c8df7d465cbaa Author: Ivan Nazarenko Date: Thu May 23 18:54:07 2013 +0300 Fix "finally" keyword in keywords.cpp commit 265ca86b5d94e67443dd960832acdf7db85e113a Author: Ben Gardner Date: Tue Apr 9 07:13:58 2013 -0500 Fix off-by-one in enc_text::find() commit 52076100951f58927502f84cbbf8c90643c67adf Author: Ben Gardner Date: Tue Apr 9 06:56:01 2013 -0500 create_one_liner: Bail if there is more than one newline This used to bail if there were any newlines, which prevented creating one liners. commit 7a0c75e5ca74bcf23de2fad92072d7bf030c738d Author: Ben Gardner Date: Tue Apr 9 06:54:02 2013 -0500 FORCE a space after a VBRACE OPEN instead of ADD commit be86509d80831f82c10fb38a12cb037798f69921 Author: Ben Gardner Date: Tue Apr 9 06:41:59 2013 -0500 Update test results for new option commit 43cdd73953b55107f12c5547e3d73f7c7f13600f Author: Ben Gardner Date: Tue Apr 9 06:41:24 2013 -0500 Move sp_cparen_oparen so it doesn't conflict with other options commit 3c8fe04e45d779a3b9d1838152bb953bdd9c643a Author: Ben Gardner Date: Tue Apr 9 06:04:59 2013 -0500 Add option sp_cparen_oparen Controls the spacing between a close paren and open paren. commit 20a311344bd331ac9bff4872582225111f1ff75f Merge: 816cbb9 620ff3c Author: Ben Gardner Date: Mon Mar 25 19:06:06 2013 -0700 Merge pull request #158 from madscientist/ms/wrap C++ comments with long first words were wrapped, leaving an empty comment line. commit 816cbb971be2a0ee6f2a2b8f898d3fbc228d2997 Merge: 84dde5e 37076b2 Author: Ben Gardner Date: Mon Mar 25 19:04:48 2013 -0700 Merge pull request #157 from madscientist/ms/stdin Allow "-" to mean read filenames from stdin with -F/--files. commit 620ff3ca8559f69381482336dd5b73872cf50f97 Author: Paul Smith Date: Sat Mar 16 19:10:26 2013 -0400 C++ comments with long first words were wrapped, leaving an empty comment line. commit 37076b29113a2f5ee40858e897cdef0c5a365400 Author: Paul Smith Date: Sat Mar 16 12:21:30 2013 -0400 Allow "-" to mean read filenames from stdin with -F/--files. commit 84dde5e2f8722dcfb511a1d264b0834b95f6f294 Author: Ben Gardner Date: Wed Jan 16 21:18:25 2013 -0600 Fix detection of '[xx] =' when aligning initializers. commit cc67666318862116caa3b6c1682926c333e20dbb Merge: 847c1f0 299f2b4 Author: Ben Gardner Date: Tue Jan 15 18:46:53 2013 -0800 Merge pull request #130 from rolandschulz/master Add option to disable tightening when aligning commit 847c1f08134c717bdf813e0d82f1ce1001ee23fc Author: Ben Gardner Date: Tue Jan 15 20:44:32 2013 -0600 Update semicolon removal test for typedefs. This addresses NS_ENUM & NS_OPTIONS declarations (OC). From: Jim Frisby commit 24d820b1db375efb142019eba47e5bb6e5b864dd Author: Ben Gardner Date: Tue Jan 15 20:34:52 2013 -0600 Do not remove semicolons if the parent is CT_TYPEDEF commit 299f2b4356a28764188ea55b239e8917748d3b99 Author: Roland Schulz Date: Tue Jan 1 16:05:28 2013 -0500 Add option to disable tightening when aligning Fixes #122 commit 15dc4bb3a821b823ce96e7cd288b48d274b0900c Merge: be4dc5d 6983fea Author: Ben Gardner Date: Mon Jan 14 06:05:44 2013 -0800 Merge pull request #128 from ryanmaxwell/master Correction for issue #127 commit be4dc5d7a229ea5280ef525876c27144dc747624 Author: Ben Gardner Date: Mon Jan 14 07:54:31 2013 -0600 Fix the version in the ChangeLog commit 6983fea0e95e21300ea3c2ed0fbc21605dd98291 Author: Ryan Maxwell Date: Tue Jan 8 16:16:07 2013 +1300 correct @finally keyword type commit 432aa0b373cb82928dcc359cc9246daa5d1a4f2e Author: Ben Gardner Date: Tue Jan 1 16:00:04 2013 -0600 Update commit.log commit 20f85c688334859635b21b95951b1e115540c69d Author: Ben Gardner Date: Tue Jan 1 15:59:23 2013 -0600 Run scripts/update-defaults.sh commit d85e6222393b36fde7aa8275abdea0c86ffe7f8d Author: Ben Gardner Date: Tue Jan 1 15:57:34 2013 -0600 Run autogen.sh on Ubuntu 12.10. commit f9282e34b98da6733c502448bbb88dd4ae28048a Author: Ben Gardner Date: Tue Jan 1 15:56:51 2013 -0600 Update the ChangeLog commit 5d1398028feaf5181a5e41e8893392bdac602afb Author: Ben Gardner Date: Tue Jan 1 15:25:38 2013 -0600 Add a few files to the workspace commit cae8a0b9c1b913e428e219865bb46fa58d4539fc Author: Ben Gardner Date: Tue Jan 1 15:25:13 2013 -0600 Update version number to 0.60 commit edfb4f0bd76c11af4d5bb7cd709c0857ab084042 Author: Ben Gardner Date: Sun Dec 30 14:56:49 2012 -0600 Fix labeling of OC @property statements commit 4154cb656fd3344b72c10b757087344adb1fa190 Author: Ben Gardner Date: Sun Dec 30 10:57:48 2012 -0600 Properly label 'using namespace XXX;' commit b3744a85a9273d05b80d05086cfc42024e1813c9 Author: Ben Gardner Date: Sat Dec 29 23:39:23 2012 -0600 Split 'prev' code in chunk_skip_to_match() to chunk_skip_to_match_rev() commit 182a0cae4cf0d2db4e41249043fd9ef9191ba54e Author: Ben Gardner Date: Sat Dec 29 23:25:32 2012 -0600 Fix the pawn-only keyword 'sleep', which is like return or sizeof. commit d625ef6006159aa9272cf9be7c497b802b4c7e65 Author: Ben Gardner Date: Sat Dec 29 23:24:46 2012 -0600 Update test results (missed a file in the last commit) commit 51fe304d6dbb1d4ddf2e30a9e4e6c04f62aa903c Author: Ben Gardner Date: Sat Dec 29 22:42:13 2012 -0600 Update config and test for indent_oc_block_msg commit 67d055ccfbcf7c3e9b2078b791e991c813eb847e Author: Ben Gardner Date: Sat Dec 29 22:38:53 2012 -0600 Add option: indent_oc_block_msg Indents blocks relative to the tag name inside messages. Really hacky, but it seems to work. commit 0edf827adcb8b509b58607faacecec906ed0980b Author: Ben Gardner Date: Sat Dec 29 15:51:59 2012 -0600 And and update tests for new ObjC options commit fa87f91938e520251d1380e0ebd2d69f7d11e1d7 Author: Ben Gardner Date: Sat Dec 29 15:47:04 2012 -0600 New option: indent_oc_msg_colon Insert a CT_SPACE in front of the longest arg to make it work. commit f3aa1441a79f5968436e4b607ed8d3c8b8209c0f Author: Ben Gardner Date: Sat Dec 29 15:43:09 2012 -0600 Finish option nl_oc_msg_leave_one_liner commit e2f941ab0c8f1f1d48cf88d4718efcb8e8b525bd Author: Ben Gardner Date: Sat Dec 29 15:42:18 2012 -0600 Extend flag_series to both set and clear flags. commit bc7a55d957419cb4c01fa7a3a0cbad6cbf2573c1 Author: Ben Gardner Date: Sat Dec 29 15:41:05 2012 -0600 Add m_skip_first to AlignStack to anchor the first line. commit 626c3e5de763176d3b6d148a958786b712fd2b55 Author: Ben Gardner Date: Sat Dec 29 10:52:39 2012 -0600 Add a comment for undo_one_liner() commit e6248d0b55c066e76bc18c64245ebb0d6975f9da Author: Ben Gardner Date: Sat Dec 29 10:52:16 2012 -0600 Add option: align_oc_msg_colon_first Controls whether the first OC message arg is aligned with the rest if it is short. commit d1fc8a0bdb2c04d057716be024063e4778b03799 Author: Ben Gardner Date: Sat Dec 29 10:50:40 2012 -0600 Add ChunkStack::Pop_Front() commit 493f3ed0bb1e3c21485ceaac1c6d7351ee5abe25 Author: Ben Gardner Date: Sat Dec 29 10:50:16 2012 -0600 Add options: nl_oc_msg_leave_one_liner and nl_oc_msg_args Splits OC message arguments to one-per-line. commit a317d7df902664efdcff5797685e9587a92b7bd7 Author: Ben Gardner Date: Sat Dec 29 10:43:02 2012 -0600 Rename ChunkStack::Push() to ChunkStack::Push_Back() commit 79a889b0e4847a39c2543a940214ab3e4be515a0 Author: Ben Gardner Date: Sat Dec 29 10:03:08 2012 -0600 Copy the level, pp_level and brace_level when inserting a newline. commit e1befa297644f4e53e79bd341cb68d3399203c31 Author: Ben Gardner Date: Fri Dec 28 14:58:06 2012 -0600 Do a better job of labeling 'extern (C)' stuff in D commit 3e92b23534e7e96e57f360fc24082eff6b06025d Author: Ben Gardner Date: Fri Dec 28 14:57:16 2012 -0600 Add option sp_extern_paren to control space in 'extern (C)' (D) commit c5916e04bc9f75d873660fa8e46baeb12ed1abd8 Author: Ben Gardner Date: Fri Dec 28 14:28:42 2012 -0600 Add test for the Java for-each construct. commit 9d193c556f240a168ec679aa1d4c7e478f82a87b Author: Ben Gardner Date: Fri Dec 28 14:26:40 2012 -0600 Allow splitting after a Java for-each colon. commit 3c3db622f1eb8bd5496d542ea2d80c88c0cd59a9 Author: Ben Gardner Date: Fri Dec 28 14:22:12 2012 -0600 Add options: sp_before_for_colon and sp_after_for_colon commit 7cbfd663b38859451612d7ad1b649359f6b808db Author: Ben Gardner Date: Fri Dec 28 14:03:57 2012 -0600 Label the ':' in the Java foreach: "for (TYPE VAR: EXPR) { }" commit ec14dea186351cf021e41bb7a7e7952a46734575 Author: Ben Gardner Date: Fri Dec 28 14:02:50 2012 -0600 Remove the date from token_names.h/make_token_names.sh commit 4f37cdf81942be97894ec467bada3f7c5f917590 Author: Ben Gardner Date: Thu Dec 27 19:50:20 2012 -0600 Skip the 'mutable' keyword in C++ lambda expressions Thanks to Jorge Amado commit 126a8b4474e9c260775a571804725316073a5db0 Author: Ben Gardner Date: Tue Dec 4 23:01:44 2012 -0600 Add option sp_after_oc_property commit dfff12d84896faa23e5832e0d28f8ffe78686935 Author: Ben Gardner Date: Tue Dec 4 22:53:05 2012 -0600 Update test for indent_oc_block option commit 697236aaf0b4b5979287e176f3a1773f25fe16db Author: Ben Gardner Date: Tue Dec 4 22:50:02 2012 -0600 Add option indent_oc_block to drop back the brace indent of OC blocks commit ba2faf474b574d85a570f145c8c65693490f9ec0 Author: Ben Gardner Date: Tue Dec 4 22:08:37 2012 -0600 Add a basic test for the '&&' C++ move operator commit 1ced8f481245a154a575d47acae6e286bffd8f95 Author: Ben Gardner Date: Tue Dec 4 22:08:16 2012 -0600 Allow the '&&' operator to be interpreted as CT_BYREF commit 3bb91cc5cdf5c914e59b630b0d1153c2aef8cc34 Author: Ben Gardner Date: Tue Dec 4 21:51:20 2012 -0600 Add option sp_before_pp_stringify and default sp_pp_stringify to ignore. commit 0b34f6412ad9c3fa45cc00edcae2f86710bc3db0 Author: Ben Gardner Date: Tue Dec 4 21:30:25 2012 -0600 Add test for sp_cmt_cpp_start fix commit 44e0253a1648e9ba8c905e9aa7877d07268645e1 Author: Ben Gardner Date: Tue Dec 4 21:26:43 2012 -0600 Fix C++ comment continuation on wrapped lines. commit a5b7aad662e80a56db10e990ec35b48d032e6223 Author: Ben Gardner Date: Tue Dec 4 21:20:15 2012 -0600 Add support for Objective C @throw and option sp_after_throw commit f91f1aa05b1f0f935fccebe50def5136a052f805 Author: Ben Gardner Date: Fri Nov 30 22:11:28 2012 -0600 Make a log less ambiguous, as there was the same text a few lines up. commit 9c3cf58acb6a45479147f4ccd849a83f3a0b9384 Author: Ben Gardner Date: Fri Nov 30 22:10:51 2012 -0600 Only flag parens after a function. This code may be redundant. commit a18e0a8c33e426cb04ca28e93165a46e9103e35c Author: Ben Gardner Date: Fri Nov 30 22:09:08 2012 -0600 Set the paren parent when marking a function call commit ce990e6d35316958c4f8a596c5c1efc1ef5e60e2 Author: Ben Gardner Date: Fri Nov 30 22:08:40 2012 -0600 Improve the flag_parens() log commit 53a19b1dbb088a468c50e6760785078503044126 Author: Ben Gardner Date: Fri Nov 30 20:32:23 2012 -0600 Add test case for SF#340 commit e9cf4852e0783dadfb8a1d98edaa78512371ef1b Author: Ben Gardner Date: Fri Nov 30 20:31:50 2012 -0600 Mark the parameter label with DONT_INDENT when aligning on the colon. Fixes SF#340 commit d5fabd4e79aabbc8cb0bb8f103c6a0a8c3776143 Author: Ben Gardner Date: Fri Nov 30 20:17:01 2012 -0600 Change template detection a little and enable for for Java commit 7556452ec8277f9b487b51b3682acec2d58536eb Author: Ben Gardner Date: Fri Nov 30 20:02:51 2012 -0600 Add missing ANGLE_OPEN/ANGLE_CLOSE to chunk_skip_to_match() commit 55d4795178842bdafcff18b3e510528ecd5a79bb Author: Ben Gardner Date: Tue Nov 27 22:40:17 2012 -0600 Rework test results based on recent changes. commit 93d0cc53ddaf5cc7e83b8515019c7700ec4183c4 Author: Ben Gardner Date: Tue Nov 27 22:38:07 2012 -0600 Add sp_after_tparen_close=remove to a few test config files commit 81d782116d6bce157c79609054d7419f0982cc06 Author: Ben Gardner Date: Tue Nov 27 22:31:14 2012 -0600 Rework ObjC block type, literal, and message marking commit f1152bde2a61f863730b5ef9d7377b7505abbcbd Author: Ben Gardner Date: Tue Nov 27 22:28:57 2012 -0600 Allow ObjC '^' to be used as a function pointer commit 31d47719c594f3f8c5a59c498f66702e94ef46ac Author: Ben Gardner Date: Tue Nov 27 22:27:15 2012 -0600 Use TPAREN_OPEN for aligning function defs commit 7a029ce0ea6e3489531ab28a84e4e4b335eeb2bf Author: Ben Gardner Date: Tue Nov 27 22:25:59 2012 -0600 Add sp_after_tparen_close and sp_ptr_star_paren commit 1e6cf7a2a3b568b33e8fc39c65a356b1069039dd Author: Ben Gardner Date: Tue Nov 27 22:05:57 2012 -0600 Make flag_parens() log who called it. commit 474fe3a8bec8f5f860598ca061859022b24b8a15 Author: Ben Gardner Date: Tue Nov 27 22:04:22 2012 -0600 Fix up fix_typedef() commit 2c5353d982c35ffa624fa369bdbbbd4741acb8dc Author: Ben Gardner Date: Tue Nov 27 22:01:54 2012 -0600 Clean up mark_function_type() and make it handle more cases. commit bfd9a034944c29c8566ceadcea39812fd6f8b2ee Author: Ben Gardner Date: Tue Nov 27 21:53:41 2012 -0600 Move log in align_typedefs and remove obsolete comment commit 4abb818058010d13478e924e443699e0c68b9565 Author: Ben Gardner Date: Mon Nov 26 23:04:43 2012 -0600 FUNC_WRAP and TYPE_WRAP need to be handled before the main loop. commit 6470b895835a897cfc0d195343c927525a277ea6 Author: Ben Gardner Date: Mon Nov 26 21:53:20 2012 -0600 Add an include statement to the config files to base of another config. commit e055dbc87cfae1b552dfa1512d87d04afd74dcc8 Author: Ben Gardner Date: Sun Nov 25 18:52:29 2012 -0600 Add TPAREN_OPEN and TPAREN_CLOSE for future function type stuff. commit 9c86d2f9f2ef023c48f709bbc7d1ae8a30241a77 Author: Ben Gardner Date: Sun Nov 25 18:49:24 2012 -0600 Change --decode to process all remaining args instead of just one. commit afc1f2aa1b1d3b765b3143613b718555fb0ddbd5 Author: Ben Gardner Date: Sun Nov 25 12:15:44 2012 -0600 Add a log sev for flag_parens() commit 3f528f93a2fd8a16aba5daed7a02a857e5afebda Author: Ben Gardner Date: Sun Nov 25 10:02:13 2012 -0600 Add '__thread' (C/C++) keyword commit 146b50958d9f9a58d9690fe778c14d4f758abb04 Author: Ben Gardner Date: Sun Nov 25 10:01:48 2012 -0600 Add '__block' (ObjC) keyword commit cf8c379422c360d6f87da219b817b0e8ba53fad8 Author: Ben Gardner Date: Sat Nov 24 15:04:44 2012 -0600 Try to clean up the objective C block code a little commit 2cb28330f9b0e4fd78d5d07364338ea1eda5667d Author: Ben Gardner Date: Sat Nov 24 15:04:11 2012 -0600 Make chunk_skip_to_match() go both ways. commit d5b3d1c4ebf793947a0f47a9a81d53f1dd2f3620 Author: Ben Gardner Date: Sat Nov 24 13:56:37 2012 -0600 Split out return type marking logic into mark_function_return_type() commit 877fc7f2bb65c3735a7c767d50d9f54e12ec3b36 Author: Ben Gardner Date: Sat Nov 24 13:25:47 2012 -0600 Objective C: @end marks the end of a statement commit 23cd8b3faf4f009ef68ec26df1095cdf4b5f5d4d Author: Ben Gardner Date: Sat Nov 24 13:25:20 2012 -0600 Objective C has the typedef keyword. commit dae38559646a0b4186e6464d9e40b1ed4c5d1213 Author: Ben Gardner Date: Fri Nov 23 15:21:30 2012 -0600 Split CT_CARET (^) from CT_ARITH commit 9fe010cbbca11f04ac31ca8a2f31f978ae805e38 Author: Ben Gardner Date: Fri Nov 23 13:38:02 2012 -0600 Patch over segfault in GH#107. commit 36c4414aa46b4d8378179bfc2630c363a10872ec Author: Ben Gardner Date: Thu Nov 22 11:03:10 2012 -0600 Update test results for nl_squeeze_ifdef change commit 114c2ac0f5e6be54fbefeeae050e12b46df09569 Author: Ben Gardner Date: Thu Nov 22 11:02:49 2012 -0600 Make nl_squeeze_ifdef work before #else and #endif commit a18cd338149d97938e28e07f64809949ea16e5a9 Author: Ben Gardner Date: Thu Nov 22 10:38:06 2012 -0600 Fix cmt_sp_after_star_cont when wrapping long comment lines. commit 83f2e0a7e832341485f6d37b980eefb9c77f489c Author: Ben Gardner Date: Wed Nov 21 20:20:48 2012 -0600 Add a test for bug SF#485 commit 07f1938707162f95209772de8821fdfe707ee282 Author: Ben Gardner Date: Wed Nov 21 20:18:28 2012 -0600 A colon starts a statement on the next token. Fixed SF#485 commit b2bd23da3c103b5d3a0877bce31991b6e62b45fd Author: Ben Gardner Date: Wed Nov 21 16:52:16 2012 -0600 Add test for variable aligning change for bug 495 commit cc503cb277767988e7f9c4aefbf3f8e51a396db5 Author: Ben Gardner Date: Wed Nov 21 16:47:48 2012 -0600 Align FUNC_CTOR_VAR with regular variables Patch from SF#495, thanks to Jean-Marc Bourguet commit 571d39af2e2ca5cec7d1665d25e2e2b640275b3a Author: Ben Gardner Date: Wed Nov 21 16:42:09 2012 -0600 Add a test for bug 484 commit 577f10774afd2a086c112fbc855db5f37876a635 Author: Ben Gardner Date: Wed Nov 21 16:41:35 2012 -0600 Do a better job of marking the C++ constructor initialization functions. Fixes SF#484. commit a8b1eb768712d0e0dd5efd00e0ff88027160b787 Author: Ben Gardner Date: Wed Nov 21 15:52:37 2012 -0600 Expand tests to cover new functionality commit 2305faab70e6df3096305a419bddeb3c49312959 Author: Ben Gardner Date: Wed Nov 21 15:52:14 2012 -0600 sp_cmt_cpp_start: Do not insert a space in '////' Thanks to sf.net user stsi commit 374c12df306f5d3f36c2026d734f758d87dc2e18 Author: Ben Gardner Date: Wed Nov 21 15:45:46 2012 -0600 Add a test for bug 481 commit 570a17c1f6b20ab0d2db31d4f62816bef257f865 Author: Ben Gardner Date: Wed Nov 21 15:45:28 2012 -0600 Always allow '[]' in prototypes. Fixes SF#481. commit 2654520e936bc91fbc18d4501b89965ee053c4b1 Author: Ben Gardner Date: Wed Nov 21 15:35:56 2012 -0600 Add a test for bug 472 commit 316bbcf34494b2dd2a1565d664ffaee6019bd79c Author: Ben Gardner Date: Wed Nov 21 15:35:11 2012 -0600 Handle old-school C function pointers as a prototype parameters. void foo(int, (void)); commit c2261b80c37d89ee56f7dcdd4cea00669e19e384 Author: Ben Gardner Date: Wed Nov 21 15:33:33 2012 -0600 C/C++ casts cannot be followed by a comma, close paren or semicolon. commit ebff0b4e9299711d3237e92e21099af3d7eb4da3 Author: Ben Gardner Date: Tue Nov 20 22:44:32 2012 -0600 nl_before_return and nl_after_return should also check for vbrace. commit dd9adc5775e7a56cd2c0c39220f246fbe449fa14 Author: Ben Gardner Date: Tue Nov 20 22:36:44 2012 -0600 Add a test for negative values of indent_continue commit bfb6771bea22b12447f0f670332f344cfe9dcde2 Author: Ben Gardner Date: Tue Nov 20 22:36:13 2012 -0600 Fix negative values for indent_continue. commit 86f2e99a784ea5c6c04b91c463db4f4ed7b355ff Author: Ben Gardner Date: Tue Nov 20 22:03:05 2012 -0600 Add a test to catch the tab-backslash-newline problem. commit 2faf4e699a49a0ca1c087bb135159afaa107bd93 Author: Ben Gardner Date: Tue Nov 20 22:02:25 2012 -0600 Do not allow a tab before a backslash-newline except if it was aligned. commit 102996568c1d3d53853b8142f27fe204cb30b772 Author: Ben Gardner Date: Tue Nov 20 21:43:44 2012 -0600 Expand the typedef aligning tests a bit. commit bf2a69a6e1ec7911e4b03da5fe944aa9570e796c Author: Ben Gardner Date: Tue Nov 20 21:37:09 2012 -0600 Rework typedef processing to handle 'typedef void foo(int);' commit 286d3d38c852d76808ac079cdb8852084a90e2e1 Author: Ben Gardner Date: Tue Nov 20 15:27:51 2012 -0600 Update tests for latest fixes. commit 71409716a860cef542e08d680574dea8f46670dc Author: Ben Gardner Date: Tue Nov 20 15:27:28 2012 -0600 Ignore vbraces when determining the comment position. commit b56f56b581a95c0cf86096c6162c7cb44749ddbb Author: Ben Gardner Date: Tue Nov 20 15:13:31 2012 -0600 Do not allow the removal of braces if it contains any preprocessors. commit 78438169b21759238252faf917231d4b9422e529 Author: Ben Gardner Date: Tue Nov 20 14:57:56 2012 -0600 Handle mod_full_brace_if_chain first so that braces are not toggled. Keep a flag to prevent a brace being virtualized. commit 70dfbd2d44ca1f7ff1c823bfbf9cdd2224b3c213 Author: Ben Gardner Date: Tue Nov 20 14:23:22 2012 -0600 Make nl_after_class force a newline after a semicolon for a class. commit 396480606490e9a22dc4e14d23e4ee3fd31d9e22 Author: Ben Gardner Date: Tue Nov 20 11:01:16 2012 -0600 Reuse the config file output code in the parsed output code. commit 55b5a029109a684851f77f05e8727bf6c53168b1 Author: Ben Gardner Date: Tue Nov 20 10:58:26 2012 -0600 Revert the test result 'fix'. The results are ugly, but correct. commit d93b3e57927ae6287d3d5aa336eb45e925213a1d Author: Ben Gardner Date: Tue Nov 20 10:57:50 2012 -0600 Fix prototype parameter marking when TYPE_WRAP is used. commit c7ba8cc65f8aa2995a241ff9145d967df2039aee Author: Ben Gardner Date: Tue Nov 20 10:23:52 2012 -0600 Add version to the 'parsed' output and make it usable as a config file. commit 00fa127f3e0192db96e089d754b95bc3ebb71f9f Author: Ben Gardner Date: Tue Nov 20 10:23:16 2012 -0600 Update test that had broken results, which were fixed by the last commit. commit 391b2919584ce149750d5ffe175fab0377f31a5a Author: Ben Gardner Date: Tue Nov 20 10:13:27 2012 -0600 Fix marking of unnamed parameters in prototypes. commit 235be8d12a7d16e1fcd7d7b6effd68e99727dc53 Author: Ben Gardner Date: Mon Nov 19 21:32:55 2012 -0600 Also handle: '[ func(a,b,c) selector ]' commit 0375f45fca8fef84ea1b4f764a2fff246aef707f Author: Ben Gardner Date: Mon Nov 19 21:32:19 2012 -0600 Update obj-c.cfg with new option: sp_after_oc_msg_receiver Add a test that uses it. commit 69523163bf7cd2aefebfd911551bf00e0a2ad1eb Author: Ben Gardner Date: Mon Nov 19 21:29:36 2012 -0600 Add Obj-C option: sp_after_oc_msg_receiver commit 24fe8b792003e513213f6c1d293063d61337afdc Author: Ben Gardner Date: Mon Nov 19 20:26:03 2012 -0600 nl_after_func_body should control the newline after a ObjC block expression. commit 9c131cea93862c88b8bb403ffe0e61620301026a Author: Ben Gardner Date: Mon Nov 19 14:29:04 2012 -0600 Update test results. I had changed the input but didn't update the results. commit 45519f9fe1b2e287760ebfce874277b40286db76 Author: Ben Gardner Date: Mon Nov 19 14:28:26 2012 -0600 Objective C messages: allow nested [] and protocols <> [ class self method ] ; [ [NSMutableString alloc] initWithString: @"" ]; commit 43e36321bc80deceb31c2b46a27bf865ea6feec4 Author: Ben Gardner Date: Sun Nov 18 22:37:43 2012 -0600 Add some more Objective C literal tests commit 90828710bab8306971767f0372abc8676e53c2ee Author: Ben Gardner Date: Sun Nov 18 22:35:33 2012 -0600 Do not do a space safety check on literal strings. commit cf4562d3ece8716d5bfa7257331369691b7a3401 Author: Ben Gardner Date: Sun Nov 18 22:11:25 2012 -0600 Parse Objective C literals: @2 or @"hello" commit 254c53bb55f51392ea6bbea73f9dad52ce6e3b02 Author: Ben Gardner Date: Sun Nov 18 21:48:49 2012 -0600 Clean up GCC compile warning about strict aliasing rules. commit 4e95ba9bb36c92f6807e322df2c15de3c79321a6 Author: Ben Gardner Date: Sun Nov 18 21:47:39 2012 -0600 Add a simple test for Java annotations commit b332a27a8f5fcd253bc736df4ed1d06b5882049a Author: Ben Gardner Date: Sun Nov 18 21:45:45 2012 -0600 Add basic support for Java annotations. New options: sp_annotation_paren nl_after_annotation nl_between_annotation Thanks to skarekar. commit 5421d10fca9a51e1311e3c791cbb8e2ab649eecd Author: Ben Gardner Date: Sun Nov 18 21:36:10 2012 -0600 Fix the 'package' keyword for Java, D, and ECMA. The Java 'package' keyword is nothing like 'namespace'. The D keyword is like 'private'. ECMA just has it as a reserved word. commit 5f403057e4bc4cfe0adf5e10a9702d1c68af257d Author: Ben Gardner Date: Sat Nov 10 11:53:50 2012 -0600 Add option sp_inside_sparen_open to mirror sp_inside_sparen_close commit 6407100375f6369bd2170d8d586af7742d4325c3 Author: Ben Gardner Date: Wed Oct 17 22:47:52 2012 -0500 Fix spelling errors in comments Thanks to Ger Hobbelt commit 97bae9f6766596f45ae1a6f3b960aeff468b7bf6 Author: Ben Gardner Date: Wed Oct 17 22:28:51 2012 -0500 Remove unused parameter to print_options() Thanks to Ger Hobbelt commit 46b78ef42a3ad960cee0eeb2c9b69f4cd6208e15 Author: Ben Gardner Date: Wed Oct 17 22:27:39 2012 -0500 Use the cross-platform 'safe' isalpha() wrapper. Thanks to Ger Hobbelt commit eb7ce00527e1f9fb7e1b9748a9458fdea4a0cf87 Author: Ben Gardner Date: Wed Oct 17 22:23:53 2012 -0500 Use the log_sev_t enum instead of int where it makes sense Thanks to Ger Hobbelt commit 4976ecf46bf5c99070442ed61d2c4d61d2313078 Author: Ben Gardner Date: Wed Oct 17 22:12:52 2012 -0500 Remove unused variable. Thanks to Ger Hobbelt commit 8177f573f0c6e5915b82fc785ac4314408933290 Author: Ben Gardner Date: Wed Oct 17 21:41:49 2012 -0500 Use EXIT_SUCCESS and EXIT_FAILURE instead of 0 and 1 for portability Thanks to Ger Hobbelt commit 9a96fd27e29d64ad813e9d99a135ef0e3079567b Author: Ben Gardner Date: Wed Oct 17 21:38:25 2012 -0500 Add some enum value comments Thanks to Ger Hobbelt commit 3653536c281c6bcc982da4bfe71a56536d734298 Author: Ben Gardner Date: Wed Oct 17 21:36:30 2012 -0500 Use GetEnvironmentVariableA() instead of GetEnvironmentVariable() Thanks to Ger Hobbelt commit db25fd2c9345eb506d57db33a501a81e68121976 Author: Ben Gardner Date: Wed Oct 17 21:35:15 2012 -0500 Whitespace cleanup a bit Thanks to Ger Hobbelt commit 6c430a023695451d5eb17027a098cc0d4e816aa6 Author: Ben Gardner Date: Wed Oct 17 21:13:02 2012 -0500 Uncrustify combined.cpp commit d35dc97ff2868e439cba3b5c331f442cc9391d13 Author: Ben Gardner Date: Wed Oct 17 21:09:16 2012 -0500 Update my preferred style and change mod_paren_on_return to ignore. commit 6bfecba0b345006c560793012d073db3b02bf585 Author: David Schaefgen Date: Tue Oct 16 09:38:47 2012 -0500 Finish FIX | Issue #99 Found an additional case, anonymous block arguments to Objective-C messages, i.e.: - (void)resetCells:(void (^)(UIView *view, NSUInteger idx))handler {...} or this in an @interface - (void)resetCells:(void (^)(UIView *view, NSUInteger idx))handler; commit 4eaee0e7f8b7621eb24a0fe24b7959047e74b011 Author: Ben Gardner Date: Mon Oct 15 20:46:09 2012 -0500 Fix the '>' + '>' => '>>' detection logic The memcmp() was incorrect since the token string storage was changed. The extra else if () logic added recently was not needed. At least, it didn't make any difference in the tests once tif was fixed. commit 3f06a2cd5f98fc9b2e32b4da99681df664677402 Author: Ben Gardner Date: Mon Oct 15 20:40:03 2012 -0500 Save off current template test results. Apparently, this "bool X = j<3>>1;" is now the template 'j' passed a value of 3 compared against 1. commit ab0cb3517a07482cd38e6857cdd5aa9cfdd2ac0f Author: Ben Gardner Date: Mon Oct 15 20:32:19 2012 -0500 Update test results for recent Objective C improvements. commit aea8b1b2a2eaac3f46bcb7afdeb92144187ce677 Merge: be15b03 e91557f Author: Ben Gardner Date: Fri Oct 12 10:39:47 2012 -0700 Merge pull request #89 from jasonfharris/master Request for fix to make ObjC handle method one liners (nl_func_leave_one_liners) commit be15b031d9aa3ca652184bc4fc9d602e4e54688e Merge: ccd991f 4be6c27 Author: Ben Gardner Date: Fri Oct 12 10:38:17 2012 -0700 Merge pull request #90 from aniec07/master Bug 3555610, bugs of >> worked on version 0.57 commit ccd991fc2e0a2865a79f11c82a92a863303b6788 Merge: bc39f8b 0befe17 Author: Ben Gardner Date: Fri Oct 12 10:36:18 2012 -0700 Merge pull request #100 from daschae/master FIX | issue 99 -> Type pointers in Objective-C block argument definitions and literal blocks star is arith rather than ptr_type commit 0befe17a9705c9a1849dc8fd44f60a131f0a45b0 Author: David Schaefgen Date: Thu Oct 11 18:24:01 2012 -0500 FIX | issue #99 Type pointers in Objective-C block argument definitions and literal blocks star is arith rather than ptr_type. Pass everything starting with the open paren through fix_fcn_def_params(chunk_t *) to process the arguments like function parameters. commit bc39f8b5dfc50037593247e6b290be802b479d72 Author: Ben Gardner Date: Wed Sep 26 21:45:23 2012 -0500 Fix tokenizing of comments such as '/*// ... */' commit 4be6c270cc1bd01164ab75a6a8e066b8de95e64a Author: Anirban Pramanick Date: Wed Aug 22 12:22:44 2012 +0530 Update src/tokenize_cleanup.cpp Changes pertaining to bugs of >> - ID: 3555610 Resolve conflict between template and comparator followed by shift operator The function handle_double_angle_close is called when then second '>' of '>>' is reached. pc is then '>' which is of comparator type. pc->prev is also of comparator type. We delete pc and make prev as CT_ARITH. We also make the next field of prev point to pc->next. prev now behaves has the current pc. This invokes a case of angle mismatch because earlier a '<' was opened and detected as ANGLE_OPEN, which should now be CT_COMPARE. Thus the while loop helps us detect this '<' and make it CT_COMPARE. commit 96a59eb2493c5fd7754baad18433817d3655d791 Author: Anirban Pramanick Date: Wed Aug 22 12:09:27 2012 +0530 Update tests/output/cpp/30103-templates.cpp bugs of >> - ID: 3555610 Resolve conflict between template and comparator followed by shift operator commit 648b2c2863a76eb5a830439467e73a510e15698b Author: Anirban Pramanick Date: Wed Aug 22 12:07:54 2012 +0530 Update tests/output/cpp/30102-templates.cpp Did not remove the syntax error line that was similar to bugs ID: 3555610 commit 7d47d1624ae6affa797d75cfcb4462d4bbaa7542 Author: Anirban Pramanick Date: Wed Aug 22 12:07:05 2012 +0530 Update tests/output/cpp/30102-templates.cpp bugs of >> - ID: 3555610 Resolve conflict between template and comparator followed by shift operator commit f6cfd7b9c394df1d18a984331e75f1fe94b2845d Author: Anirban Pramanick Date: Wed Aug 22 12:05:56 2012 +0530 Update tests/output/cpp/30101-templates.cpp bugs of >> - ID: 3555610 Resolve conflict between template and comparator followed by shift operator commit 92a4088e4d3725e82d637b50d1b9edbdddd653b4 Author: Anirban Pramanick Date: Wed Aug 22 12:04:10 2012 +0530 Update tests/output/cpp/30100-templates.cpp bugs of >> - ID: 3555610 Resolve conflict between template and comparator followed by shift operator commit 110fabb014714dbacb838efedd24e38e65eb92ea Author: Anirban Pramanick Date: Wed Aug 22 12:00:51 2012 +0530 Update tests/output/cpp/30023-templates.cpp bugs of >> - ID: 3555610 Test case to resolve conflict between template and comparator followed by shift operator. commit b99e585ddc4e22f0b26e991048c2b47a1da96737 Author: Anirban Pramanick Date: Wed Aug 22 11:53:16 2012 +0530 Update tests/input/cpp/templates.cpp Y>1>> x4 is detected as a syntax error in C++. However a condition like: if ( j<3>>1 ) is not a syntax error. But Uncrustify detects the latter as a template and forces a space making it as: if ( j<3> >1 ) which is a syntax error in C++. Therefore the required test condition should be: bool X = j<3>>1; where 3>>1 does not need to be specified explicitly inside brackets commit e91557f0682b2d046b764613c30831d5a1724a96 Author: Jason Date: Mon Aug 20 03:28:51 2012 +0200 fix leave function one liners alone for objective C methods commit acf6059a97e72b1b8fa596309accfc4c34d374c5 Merge: 65dd559 234a1e9 Author: Ben Gardner Date: Wed Jul 18 09:49:41 2012 -0700 Merge pull request #85 from kastiglione/fix-blocks-spacing Mark functions inside block expressions commit 65dd5597686d1772d951fc6698578afbf8ebf3ac Merge: 1712cbe 4c8a034 Author: Ben Gardner Date: Wed Jul 18 09:47:32 2012 -0700 Merge pull request #86 from Hackerpilot/master Add support for D's new lambda operator commit 4c8a0340cbb9c551e58618e5b485e304167a57fd Author: Hackerpilot Date: Sat Jul 14 22:42:20 2012 +0000 Added lambda operator to D commit 234a1e932de5b8bfd18ffa688ceb30d10cf30acb Author: Dave Lee Date: Mon Jul 2 22:39:23 2012 -0600 Mark functions inside block expressions commit 1712cbe29a4afd2b00ec4f4a5b1698a080be8215 Author: Ben Gardner Date: Tue Jun 26 22:02:03 2012 -0500 Expand the ObjC boxed test commit b48b7c8ca701a2f281d527f8bf63b8e48873255b Author: Ben Gardner Date: Tue Jun 26 22:01:43 2012 -0500 Treat ObjC boxed strings the same as other boxed types. commit d466c318dec17f37a3a6e85d3f273a409422dcea Merge: f450527 16fdfdf Author: Ben Gardner Date: Sun Jun 24 15:27:57 2012 -0700 Merge pull request #84 from GerHobbelt/issue-084 bugfix: wrong offset passed to peek() --> CRLF not recognized correctly commit f4505271868e251e694f2aff5da8804342b55505 Author: Ben Gardner Date: Sun Jun 24 16:44:29 2012 -0500 Add a test for Objective C boxed literals commit b875c33fe318810b0a69317c0800e46b25f32685 Author: Ben Gardner Date: Sun Jun 24 16:41:50 2012 -0500 Add new option: nl_brace_struct_var commit 16fdfdfcc8df54c5b4082f786b81995f8b80cc03 Author: Ger Hobbelt Date: Sun Jun 24 19:11:15 2012 +0200 wrong offset passed to peek() --> CRLF not recognized correctly (as peek(1) points 1 PAST the LF!) in D /+...+/ comments. commit f91bb5a01c76caef5ba035f73c20b5ff3424161a Author: Ben Gardner Date: Sun Jun 24 02:00:34 2012 -0500 Add options: sp_before_oc_dict_colon and sp_after_oc_dict_colon commit c0db5d7584ef6103abe7a820c5f28cd4bb2ef2eb Author: Ben Gardner Date: Sun Jun 24 01:59:14 2012 -0500 Add basic support for Objective-C boxed expressions. commit 2e5f32e87834ca1239dc1481091c85db134c5f92 Merge: cc65530 1b6c857 Author: Ben Gardner Date: Tue Jun 5 15:25:02 2012 -0700 Merge pull request #79 from pwaller/remove_ns_close_semicolon Remove semicolons after namespace close brace commit 1b6c857876e78b46d1a2c6d0c7ae8dbba1504fb7 Author: Peter Waller Date: Thu May 31 13:20:34 2012 +0100 Remove semicolons after namespace close brace commit 86ca62b2918a801ee4b1f2d1509439d313453cbb Merge: 7df80a1 cc65530 Author: rdan Date: Sat May 12 14:14:43 2012 +0200 Merge branch 'master' of git://github.com/bengardner/uncrustify into no_include_guard_indent commit 7df80a132e1176c5830ba307d26df19a7bafd12c Author: rdan Date: Sat May 12 14:05:29 2012 +0200 Tests updated to validate the modifications in this branch commit a4b6730f26ba978a2614ca754466a43ac3e510af Author: rdan Date: Mon May 7 20:15:03 2012 +0200 - Update of the management of the #include guard Specific actions were taken for preprocessor directives. It is now extended to all code: - code inside the "#include guard" is not indented - optimization of "ifdef_over_whole_file" to be able to call it several times - Update of the comment of some options to clarify their actions commit cc65530fb55a9b24fda73f46474bf26589b43020 Author: Ben Gardner Date: Fri May 4 22:44:42 2012 -0500 Remove incorrect labeling of CT_CLASS_COLON in mark_function(). The proper place is in combine_labels(). commit eb9bf3beda26457e3ff74d2359a16c14e8439a72 Author: Ben Gardner Date: Fri May 4 22:25:27 2012 -0500 nl_func_type_name[_class] should not affect template stuff Fixes SF#3523347 commit 3539361342da04a3286f0cf808d827ede1aba217 Author: Ben Gardner Date: Fri May 4 22:07:32 2012 -0500 Don't allow a definition or prototype after CT_ARITH. This is a hack that fixed SF#3522432. commit dfa082ded986d024b4c429b27d86851467e94473 Author: Ben Gardner Date: Fri May 4 22:06:32 2012 -0500 Don't start a statement on a ')' or ']'. commit 11fa9162d6ffec46eb3dd9ceb92ed5acfde360e0 Author: Ben Gardner Date: Fri May 4 22:03:18 2012 -0500 Improve logs for statement start detection commit 159921c86fb85bb44b9b8d18b5e44dfa56a459cc Merge: 088e4e1 a3a56c1 Author: Ben Gardner Date: Sat Apr 28 14:26:40 2012 -0700 Merge pull request #65 from JanX2/master Updated Xcode project with recent changes commit a3a56c1fad9d23afecc691723a622a3d9c678890 Author: Jan Weiß Date: Thu Apr 26 15:24:37 2012 +0200 Updating Xcode project with recent file changes. commit 2bff457c9f0255a9a753ab5fd314eabcf5e6d920 Author: Jan Weiß Date: Thu Apr 26 15:23:48 2012 +0200 Updating “.gitignore” for Xcode 4. commit 088e4e10adeee341e60d444b0a2bd07bdc960111 Author: Ben Gardner Date: Sat Apr 14 15:39:57 2012 -0500 Add test commit 62746441ccc52dee9b87e9ef133e8f7c6fab0831 Author: Oleg Smolsky Date: Sat Apr 14 15:36:30 2012 -0500 Fixed a small alignment bug in complex calls commit 7e40fd41ba6f99d43b2931deaec66534f52e637d Author: Ben Gardner Date: Sat Apr 7 15:43:29 2012 -0500 Fix detection of a cast in "(uint32)std::distance(a,b)" commit df0a2c1b661766f7581b9d47a1250abef7230633 Author: Ben Gardner Date: Fri Apr 6 11:54:08 2012 -0500 Add another C++ test case commit f420f11b6966f33382390366e7ecd216b2fd99b8 Author: Oleg Smolsky Date: Thu Apr 5 21:05:06 2012 -0700 Fixed multi-line indentation in the 'return' case commit 06d1642da17fb9407577943d51d93a2442f45747 Author: Ben Gardner Date: Fri Apr 6 11:35:40 2012 -0500 Update test results for latest fix to C++ lambda stuff commit 65867c045c4833d6d8034bbc6394d872c33c2b45 Author: Oleg Smolsky Date: Thu Apr 5 18:56:43 2012 -0700 Additional lambda/indent fix commit a54dfa1aa36561c025ed2ba56861f19436fb50af Author: Oleg Smolsky Date: Sun Apr 1 11:33:14 2012 -0700 Moved a hard-coded constant out into an option indent_ctor_init_leading = 4 # virtual indent from the ':' for member # initializers. Default is 2. # (applies to the leading colon case) this is needed for handling member initializer lists: Thread::Thread() : m_bStarted(false), m_log(/Thread) { .... } commit 9d3ab48b138ecdfbee4ddbd0e35fce31ae785b92 Author: Ben Gardner Date: Fri Apr 6 11:23:19 2012 -0500 Add an expanded test for '<<' alignment. The results may not be correct based on pending patches. commit 7a9f6a9b9fa75dd143a9b4fd91c1a2dee1eb46c6 Author: Ben Gardner Date: Thu Mar 29 19:36:18 2012 -0500 Update test for lambda return type commit 19dff2aea0dec7910fdae1065370e23ba2e7be1b Author: Ben Gardner Date: Thu Mar 29 19:35:58 2012 -0500 Handle C++ lambda return type commit bc1ea727dff5b73b86fc1a5f6f94690c5173e370 Author: Ben Gardner Date: Thu Mar 29 18:55:49 2012 -0500 Fix a few problems with the new options commit bd32896fd7f0fd73aa338b1a1340086097cbe649 Author: Ben Gardner Date: Thu Mar 29 18:55:19 2012 -0500 Add some tests for the new sp_cpp_lambda_xx options commit 7e2db96aa6cdba4e012e8adfa266a67e7cf2adda Author: Ben Gardner Date: Thu Mar 29 18:34:44 2012 -0500 Add sp_cpp_lambda_assign and sp_cpp_lambda_paren commit c12a4c5ce4929eaff377486b36da690037d58345 Author: Ben Gardner Date: Thu Mar 29 17:53:12 2012 -0500 Label C++11 lambda expressions commit 9e92b900e5766dc2e95f611c5627625f17a9262b Author: Ben Gardner Date: Thu Mar 29 17:18:42 2012 -0500 Correct input file. commit d28e0fd97037eb548e62f177435bb675de5521a8 Author: Ben Gardner Date: Thu Mar 29 11:16:53 2012 -0500 Add VS2011 project files (Oleg Smolsky) commit b5d0a2c5edba524f49f984078f8740b7743af30c Author: Ben Gardner Date: Tue Mar 27 21:24:23 2012 -0500 Add test cases for new '<<' aligning functionality commit 5ff36433c85ca55a3b4f6d972dbbb5d7e9082b62 Author: Ben Gardner Date: Tue Mar 27 21:23:52 2012 -0500 Fix aligning of '<<' in C++ From: Oleg Smolsky commit 9fa0183f6a2f08e4b5c0a5f433481277fce0cb52 Author: Ben Gardner Date: Tue Mar 27 21:10:25 2012 -0500 Add sp_permit_cpp11_shift From: Oleg Smolsky commit 5a930a5dc1e285513b52088f98a5dacd5fea4ea3 Merge: c6e500a 868501f Author: Ben Gardner Date: Tue Mar 20 21:23:55 2012 -0500 Merge branch 'master' of github.com:bengardner/uncrustify commit c6e500aaaba0abba230311471a52f8b34776cdde Merge: d519bfa bbbee52 Author: Ben Gardner Date: Tue Mar 20 21:21:32 2012 -0500 Merge branch 'rdan-20120129' of https://github.com/rdan/uncrustify into rdan-rdan-20120129 Conflicts: src/indent.cpp commit 868501f35dead19b3731eefb5a1435105665dbdf Merge: d519bfa 5542d0b Author: Ben Gardner Date: Tue Mar 20 19:16:30 2012 -0700 Merge pull request #57 from mkonig/mos_extensions Added a script that generates uncrustify_version.h on windows. commit d519bfa85552cebc5388b979668ea7c5d1c53853 Merge: 82f70d3 e2e0756 Author: Ben Gardner Date: Tue Mar 20 19:13:46 2012 -0700 Merge pull request #63 from bitserf/objc-method-spec-colons Tweak align_oc_decl_colon to also align colons of Objective-C method prototypes commit e2e075683a576be33afdab4eac922c3afd52bb2b Author: Leon Breedt Date: Wed Mar 21 03:10:34 2012 +1300 Tweak align_oc_decl_colon to also align colons of Obj-C method prototypes. commit 5542d0b29f741f0fb97b9c9a617a99a04f03d3a7 Author: Mirko König Date: Sat Feb 25 19:56:23 2012 +0100 Added a script that generates uncrustify_version.h on windows. Added this script to vs2008 solution to run as pre-build event. Added compat_win32.cpp to vs2008 solution file. commit bbbee52fd41dc240f3312d06cf4744e3337bf70e Author: rdan Date: Mon Feb 13 01:41:36 2012 +0100 Update of test file to try to avoid an "UNSTABLE" result (for 00617). It's still unstable because of "nl_max" which is applied everywhere even if another option specifies a different value (ex: nl_max is set to 2 to have a maximum of 1 consecutive blank line everywhere in the code. But we also want to have 2 blank lines after the declaration of local variables in a function). commit af232a0b7adc6ab1340f84c7fbc827a67f38887f Author: rdan Date: Mon Feb 13 00:50:12 2012 +0100 - Correction of my previous commit (bug detected with file "pp-if-indent.c", file added to tests). The bug is present only when the option added is active. - Correction of a bug that was already in uncrustify detected with file "pp-if-indent.c". It generated the following output: pp-if-indent.c:19 Unmatched PP_IF_INDENT pp-if-indent.c:21 Unmatched BRACE_OPEN pp-if-indent.c:30 Unmatched PP_IF_INDENT pp-if-indent.c:33 Unmatched BRACE_OPEN commit 82f70d3261904ac11caf7ca125a852ce10d0f6e2 Merge: e5d2eff bc43061 Author: Ben Gardner Date: Sun Feb 12 17:34:21 2012 -0600 Merge branch 'rdan-20120129' of https://github.com/rdan/uncrustify commit e5d2eff99f6f1042057d64dbbdaab817a7914606 Author: Ben Gardner Date: Sun Feb 12 17:27:10 2012 -0600 Don't include src/config.h, as that is generated by configure. commit b7cf7809161b5d47d0786e051a779cb1c9002eb7 Author: Ben Gardner Date: Sun Feb 12 17:23:09 2012 -0600 Add missing file to MS VC++ 2010 project file commit bc43061e83f77d726c5891a4ded770a787207dc9 Author: rdan Date: Sun Feb 12 13:31:44 2012 +0100 New option to force the indentation of function definition to start on the first column even if this function is defined inside a #if/#endif directive. commit d8c5e80b1463282cee7a9fea7d8852804a4dd2b0 Author: rdan Date: Sun Feb 12 13:07:29 2012 +0100 Correction of an issue: In the following code #if A void function(void) { } #endif A is qualified as Tag=CT_TYPE/Parent=FUNC_DEF instead of Tag=WORD/Parent=NONE. commit 95eb26256066b608063f42d8ca7ade73e8fb2922 Author: rdan Date: Sun Feb 12 13:02:48 2012 +0100 Updates to be able to generate the software with Visual C++ 2010 commit dc89e72f61320fc95a15638ddd03663e937620e4 Author: Ben Gardner Date: Tue Feb 7 08:06:41 2012 -0600 Add include of windows_compat.h to compat_win32.cpp commit 6358b4865f18a0a8f75f6a534447524682cdb4bc Author: Ben Gardner Date: Sat Jan 14 16:06:13 2012 -0600 Debugging: also log the column_indent commit 948ec99cfdc6acbb1d13b489d7d2bbe39059fba9 Author: Ben Gardner Date: Sat Jan 14 16:04:13 2012 -0600 Update tests to reflect the change in the last commit. commit c0b125fdfe6e6f5d02b466220961ac6731b4c728 Author: Ben Gardner Date: Sat Jan 14 16:02:26 2012 -0600 A #define body indent should have 1 level of tabs in mixed mode. commit 490986c7607c772cb76eb7bbf4eb62d3ccfc2bfa Author: Ben Gardner Date: Sat Jan 14 11:02:27 2012 -0600 Add custom type PROTO_WRAP for old-style prototype wrapper macros. commit 3359082eff68278e7d3b2cf0ebbdf0f914857852 Author: Ben Gardner Date: Sat Jan 14 10:22:38 2012 -0600 Rework the default config file check to avoid C99 constructs. Fixes a compile error on MS VC++ 2010. commit 7aba80646c66fc45dcb9e8fdc9542b7d1794cc5a Author: Ben Gardner Date: Sat Jan 14 10:13:42 2012 -0600 Fix compile issue on MS VC++ 2010 commit 2a220107fd1e0e9139c5bbe312b14b3b12e2cee7 Author: Ben Gardner Date: Sat Jan 7 21:48:41 2012 -0600 Add option: nl_version_brace Affects D commit 72c9645f0b57017063ed83f5db7e3d845eab56a7 Author: Ben Gardner Date: Sat Jan 7 21:48:15 2012 -0600 Add option: nl_scope_brace Affects D commit c4bdf597a32525548c43f80c4b36a9dabdb7475f Author: Ben Gardner Date: Sat Jan 7 21:10:15 2012 -0600 Fix crash if unittest is the first token in the file. commit 91701a4e5ec5de9cb4f71847da44e7f1ed3d8c26 Author: Ben Gardner Date: Sat Jan 7 21:09:48 2012 -0600 Add option: nl_unittest_brace commit 1691e461067922002c1dd5d3f42519715cce9001 Author: Ben Gardner Date: Sat Jan 7 16:59:35 2012 -0600 Add a few other C++ extensions. Fixes SF#3470255 commit 4dccc7487e0baaffb8f6a25a10adc8841514dcce Author: Ben Gardner Date: Sat Jan 7 16:40:14 2012 -0600 Add test for sp_before_template_paren commit bdf2c6671c5b97c3120749499685f9458f0bdd5c Author: Ben Gardner Date: Sat Jan 7 16:39:25 2012 -0600 Add option: sp_before_template_paren Controls the space for D in "class Foo(" and "template Foo(". commit 2501784474c6493bbfff3b7ede29ec8222a42b5c Author: Ben Gardner Date: Sat Jan 7 16:25:40 2012 -0600 Improve labeling of D templates. commit 3ffbfd5c7c0b6f618394ae6dfb4c1e88cc8a0b2c Author: Ben Gardner Date: Thu Jan 5 22:37:30 2012 -0600 Do a better job of marking types in a class commit e047b3d380003e3f6355dc8c88ef62b7ac063051 Author: Ben Gardner Date: Thu Jan 5 22:36:49 2012 -0600 Do a better job handling class forward declarations commit c321930e9ef4d989d596bdc068b17aaec0d8dad8 Author: Ben Gardner Date: Thu Jan 5 22:34:23 2012 -0600 Fix incorrect test commit c0c4354016756ddb02984341a3b79295c1f1ba57 Author: Ben Gardner Date: Thu Jan 5 21:34:02 2012 -0600 Use unc_text::equals() instead of memcmp() commit 044ebe1c4ad8e11f99d2d49a1134fae86b490e79 Author: Ben Gardner Date: Thu Dec 29 16:47:09 2011 -0600 Add ability to get config from UNCRUSTIFY_CONFIG env var to win32 commit d7b57f9fd59ff39e24503ffa8a822a1a46b48e29 Author: Ben Gardner Date: Thu Dec 29 15:27:10 2011 -0600 Update tests for nl_before_newline commit 3040f3887634b0f4331bee7b25f9f34f5f97adc7 Author: Ben Gardner Date: Thu Dec 29 15:26:02 2011 -0600 Add option: nl_before_return Move nl_after_return to the blankline group. commit 4e39f15b183b6e92531aa0bd88168515c4d8cbc3 Author: Ben Gardner Date: Wed Dec 28 00:54:34 2011 -0600 Save off working notes about #if/#else/#endif code threads commit 47fa9b294210f07ecabedbf75ee30ffa5603be12 Author: Ben Gardner Date: Wed Dec 28 00:50:15 2011 -0600 Handle function pointers with complex return types (ie, unsigned char). Fixes SF #3152653 commit 6226fdb03c02b8e3ecbea1bbda2ea5d945322457 Author: Ben Gardner Date: Wed Dec 28 00:25:49 2011 -0600 Change newline_iarf_pair() to handle 'force' as 'add' + newline limit. Fixed SF #3169766 commit 3ee41a21c7a8c76e1db7d208d4f8eab6dfaf7065 Author: Ben Gardner Date: Wed Dec 28 00:05:46 2011 -0600 Get nl_class_init_args=force to work Fixed SF #3444921 commit 4775d8990fc8552b4384a833386b2aea0fb665aa Author: Ben Gardner Date: Tue Dec 27 23:25:26 2011 -0600 The '*' in "*," is always likely to be a pointer in the following: FUNCDEF_MACRO( func, (arg1 *,arg2 *, arg3*)); Fixes SF #3464371 commit 37ebfd815d1ed8b5ba33b69d76da980c7ec6644c Author: Ben Gardner Date: Sat Nov 26 12:03:15 2011 -0600 From: Jim Meyering include for open, close, unlink Otherwise, I get errors like these on Fedora 16: uncrustify.cpp: In function 'bool file_content_matches(const string&,\ const string&)': uncrustify.cpp:903:16: error: 'close' was not declared in this scope uncrustify.cpp:915:45: error: 'read' was not declared in this scope ... uncrustify.cpp: In function 'void do_source_file(const char*,\ const char*, const char*, bool, bool)': uncrustify.cpp:1046:46: error: 'unlink' was not declared in this scope commit 1c8aedbd1e845196f2a46491b8479596e7404856 Merge: 34d4143 fbf046e Author: Ben Gardner Date: Sat Nov 26 09:56:03 2011 -0800 Merge pull request #47 from meyering/multi-line-comment--do-not-elide-utf8-characters do not elide UTF-8 characters from multi-line comments commit fbf046e03e41fb8c137c2ed49c120bf389cbbc75 Author: Jim Meyering Date: Fri Nov 25 19:47:25 2011 +0100 do not elide UTF-8 characters from multi-line comments Before this change, uncrustify would remove UTF-8 characters from multi-line comments. E.g., here, uncrustify would remove an a-acute from a 2-line comment: $ printf '/*\303\241\n*/\n' > utf8.c $ src/uncrustify -q utf8.c; wc -c utf8.c utf8.c.unc* 8 utf8.c 6 utf8.c.uncrustify This fixes it and adds a test to exercise the fix. * src/output.cpp (output_comment_multi_simple): Correct the type of "ch": use "int", not char, to avoid sign-extension with signed char. * tests/c.test: New file. * tests/input/c/cmt_multi_utf8.c: New file. * tests/output/c/02423-cmt_multi_utf8.c: New file. commit 34d41436cfc900c23edb55c161ae2086766ce56e Author: Ben Gardner Date: Tue Nov 15 21:23:18 2011 -0600 Update tests based on latest patch commit 2d0e192c23b3a24aa16566ca1aafaf0f470f5580 Author: Ben Gardner Date: Tue Nov 15 21:22:54 2011 -0600 From: Todd Richmond Rework function parameter line splitting. commit 6df0bc53655d8bb590f028166fb17c6796d408b9 Author: Ben Gardner Date: Tue Nov 15 21:15:43 2011 -0600 Whitespace cleanup commit e4f447789a2f6f4a1c1f0cb8e9e6c8871e67ee79 Author: Ben Gardner Date: Tue Nov 15 21:15:29 2011 -0600 From: Todd Richmond Don't split '>>' into '> >' for C++ templates. Fixes SF#3203335 commit 4d2960bf02e840fd2c9bf80b7a2cb9122770b3ea Author: Ben Gardner Date: Tue Nov 15 20:49:48 2011 -0600 From: Todd Richmond Add support for __try, __except, and __finally. commit ceb60d60580cbdfc8cf72daf7244df5847759ce1 Author: Ben Gardner Date: Tue Nov 15 20:44:36 2011 -0600 From: Todd Richmond Add copy constructor to AlignStack. commit a920c2b08afeac1e4312daeb768871e4600972f4 Author: Ben Gardner Date: Tue Nov 15 20:43:57 2011 -0600 From Todd Richmond Fix off-by-one error in align_same_func_call_params() commit 2d9f50feaef2b80854bed2ce64e4d6eec9c5bbcc Author: Ben Gardner Date: Tue Nov 15 20:38:59 2011 -0600 Run uncrustify against some of its source. commit 867f0f7dad29a9ab08e2394140e43749f3e4c3fb Author: Ben Gardner Date: Tue Nov 15 20:38:29 2011 -0600 From: Todd Richmond Update sun.cfg and update test results from the latest patch. commit 2e95b3c8bf4bf9d7ec688c769803ffaf3ca4be29 Author: Ben Gardner Date: Tue Nov 15 20:37:22 2011 -0600 From: Todd Richmond Add a slew of new options: nl_typedef_blk_start, nl_typedef_blk_end, nl_typedef_blk_in nl_var_def_blk_start, nl_var_def_blk_end, nl_var_def_blk_in nl_remove_extra_newlines From SF #3426576 commit b24579c1e5b68f8ce9757964c81686ce8a7a5b84 Author: Ben Gardner Date: Tue Nov 15 20:23:37 2011 -0600 Fix null dereferences commit 31265d3337be44b4499d3a673ff4a3622e27af53 Author: Ben Gardner Date: Tue Nov 15 20:18:57 2011 -0600 Fix spelling recommed => recommend commit 122b7e7b3f44d3c0ae72f703874d123ef6d5d053 Author: Ben Gardner Date: Thu Nov 10 05:58:31 2011 -0600 Fix aligning on '<<' in the presence of 'operator <<'. commit d723b22b89b3a460fa8a7e6975b89d3059b45ad3 Author: Ben Gardner Date: Thu Nov 10 05:52:17 2011 -0600 Increase the span of '<<' slignment so that 'q' and 'xyz' align in the following code snippet: void bar() { out << "q" // << "abc" // << "def" << "xyz"; } commit 158cc8abe5e3ce1c3b53b161dd1c5d5fcd2e847c Author: Ben Gardner Date: Thu Nov 10 05:38:37 2011 -0600 Update test results to reflect virtual brace comment spacing fix. commit 491b8927f2305b4ed7d727e7de2e77970ffc526c Author: Ben Gardner Date: Thu Nov 10 05:37:07 2011 -0600 From: Jim Meyering Fix handling of virtual braces when calculating the comment column. foo () { if (1) a = b; /* c */ } commit 7021e495105caffa5d2f47be65984c75254ac692 Author: Ben Gardner Date: Thu Nov 10 05:29:04 2011 -0600 Fix handling of templates in constructors: TOTO::~TOTO () { } commit 88bb98e5e8b0a03fdcf8522cb62bf7c5ba175f56 Author: Ben Gardner Date: Thu Nov 10 05:18:30 2011 -0600 From: Todd Richmond do_code_width() must be followed by newlines_cleanup_braces because breaking lines might also break one-liners such as enum x = { 1, var_too_long_for_code_width }; which reformats to enum x = { 1, var_too_long_for_code_width }; instead of putting the newline after the { commit 004a21be1b633306c6e655719a06d09bf7e3ee95 Author: Ben Gardner Date: Thu Nov 10 05:13:25 2011 -0600 From: Todd Richmond Allow a line split between two strings. commit 10c35ad427c9ab08f255f98ed60c1ffb57a668ec Author: Ben Gardner Date: Thu Nov 10 05:08:34 2011 -0600 Java also uses the ellipsis commit e6ccc2551d533b75c435dd34ea030ed9ed02b783 Author: Ben Gardner Date: Wed Nov 9 07:18:30 2011 -0600 Change '-F' handling to match what the usage info says, one file per line. More work is needed to support a prefix on windows, as drive letters aren't handled. commit 8c2cc60bbe4fedf012331d8641fec5dce27d97df Author: Ben Gardner Date: Wed Nov 9 07:01:53 2011 -0600 From: Todd Richmond Create new option ls_code_width to better control line width splitting. commit e1ebb8b1592832dbcd6b5664fa05f2c4e2208243 Author: Ben Gardner Date: Thu Nov 3 21:11:26 2011 -0500 From: Todd Richmond struct/enum/class variable definitions are using nl_after_struct/ nl_after_class newlines which were designed for the actual struct definition, not instances of the struct. This adds an extra newline within a var def block int x() { struct b c; struct d e; } formats to int x() { struct b c; struct d e; } commit 4bdae67aa0cbb5858aae1065eea23c4a5dde89f3 Author: Ben Gardner Date: Thu Nov 3 21:04:26 2011 -0500 From: Todd Richmond Two wide strings concatenated together without a space causes the second L to trail the first string instead of lead the 2nd string. #define x L"a"L"b" formats to L"a"L "b" instead of L"a" L"b" commit 1db8aaf384e2c74f98974df0d6a6ffa27903615b Author: Ben Gardner Date: Tue Oct 25 18:47:42 2011 -0500 From: Todd Richmond Rework long line splitting code. This patch does the following 1) makes indenting for indent_continue != 0 consistent except that >0 is old behavior of grouping constructs like ?: or functions 2) fixes a bug found with the fix for 3426636 (long typedefs). The old code never indented properly because it added indent_size to 0 instead of the previous indent. In test cases that showed up as a 3 char indent instead of 4 3) fix test cases for the long typedef lines. Note that your final typedef change caused typedefed functions to tread the arguments as a function which causes the lines to indent to the fparen. I think your change is correct behavior and only the test case needed an update commit 4a0e1d63861d883ddacfcd6b9bf4ddab6c5adb7b Author: Ben Gardner Date: Tue Oct 25 18:40:05 2011 -0500 Rework 'class' detection to allow 'class' as a member name. commit 53d716f543709bb0b6f1e524bc910c64ecebaf21 Merge: 716df3c d57307d Author: Ben Gardner Date: Tue Oct 25 18:29:42 2011 -0500 Merge branch 'master' of github.com:bengardner/uncrustify commit 716df3cfdad8f49daf4841c5b58593345ebbac6a Author: Ben Gardner Date: Tue Oct 25 18:27:31 2011 -0500 From: Todd Richmond If mod_full_brace_if = add and mod_full_brace_if_chain = true, it will eat a required line break after the closing if statement, regardless of having { } or not. if (a) b(); c(); reformats to if (a) b(); c(); commit d57307ddfec43dd3a9967b56b6b3e8cf935a2825 Merge: 0650864 c9768db Author: Ben Gardner Date: Mon Oct 24 10:29:55 2011 -0700 Merge pull request #45 from Uncommon/master Add missing files to Xcode project commit c9768db3e058dd2b63303f3f09d0a6a2ab479be6 Author: David Catmull Date: Mon Oct 24 11:19:46 2011 -0600 Add unc_text.cpp and unicode.cpp to the Xcode project commit 06508646f3cc0fbccb7ad6eeb0c50d42b847ff29 Author: Ben Gardner Date: Sat Oct 22 15:50:15 2011 -0500 Add a log when the comment cont_text is set. commit c9fce40717e12c2feaec7f7a469baa351c213426 Author: Ben Gardner Date: Sat Oct 22 15:49:33 2011 -0500 Detect a comment lead without requiring a space after a single '*'. commit e02dd8a41e466876bc39aa8eaf55c1d6aee6b596 Author: Ben Gardner Date: Sat Oct 22 15:48:05 2011 -0500 Insert a space between '*' and text in a comment line start. commit 0461e187859eb2b227073edd6b74ccc39359b1ca Author: Ben Gardner Date: Sat Oct 22 15:46:39 2011 -0500 Add unc_text::insert() commit cfa96cbe6c840ac11845cda0e55424cda764cd79 Author: Ben Gardner Date: Sat Oct 22 14:51:24 2011 -0500 Add a test for align_func_proto_span with align_on_operator commit abd74db2c35b9bfcf95d706d58ce3ab1e5d96562 Author: Ben Gardner Date: Sat Oct 22 14:37:03 2011 -0500 Set the gap on all aligned chunks commit 187f33f098806d9bd1cc4df618cd5e337381e0d4 Author: Ben Gardner Date: Sat Oct 22 14:34:49 2011 -0500 Set the start and amp style for align_func_proto commit 95cac2cff979de9391f983f1de4fcb5d90aec525 Author: Ben Gardner Date: Fri Oct 21 21:53:21 2011 -0500 Also need to end a typedef indent on an open paren commit ab66cf91f5b788ecd1a9f704f3f18ee5e1ac595f Author: Ben Gardner Date: Fri Oct 21 21:52:55 2011 -0500 Update code-width.c test with long typedefs commit fbd5ad351a12808679ed029eaa4e14b115ab3a12 Author: Ben Gardner Date: Fri Oct 21 21:44:27 2011 -0500 Use a continuation indent for typedefs that span two lines. Fixes SF 3426636 commit 0c8f3cc968820db79b04883a862f42355f3effdd Author: Ben Gardner Date: Thu Oct 20 22:21:20 2011 -0500 Allow '&' in a C-style cast. Ie, (Foo &). Fixes SF#3266678 commit ad9f2b11ec58e7d2458d07276263bb683bc87f19 Author: Ben Gardner Date: Thu Oct 20 21:54:03 2011 -0500 Remove unused variables that g++ 4.6 found. Signed-off-by: Ben Gardner commit db9c795e9d756ed3eff50510311b62436f51ac20 Author: Ben Gardner Date: Thu Oct 20 21:44:17 2011 -0500 From: Todd Richmond New option: align_pp_define_together Align #define functions and variables together commit f3f6ac39f834e31fa703109e1ccdccd76c64066c Author: Ben Gardner Date: Sat Oct 15 21:48:03 2011 -0500 Change the 'class' check to require a 'word' after to be value. Should now handle variables named 'interface' or members named 'class'. commit e5246380c0a64c878d070ff322b101509dc3813e Author: Ben Gardner Date: Sat Oct 15 21:37:27 2011 -0500 Back out absolute indent_continue check in split_line(), as it caused ls_func_split_full to fail. commit 0f22bda9daa368017a46bd66994fa206194c99be Author: Ben Gardner Date: Thu Oct 13 22:28:42 2011 -0500 Fix wording of the utf8_byte option commit 02342d6f0a241dfd52666334d0c363f7b5121bd4 Author: Ben Gardner Date: Thu Oct 13 22:28:20 2011 -0500 From: Todd Richmond Update sub.cfg commit 2720231d94a927f6ee9e83e9fecedef7e7b75e52 Author: Ben Gardner Date: Thu Oct 13 22:24:24 2011 -0500 Fix regression caused by labeling 'interface' as a keyword. commit 005fefb6fe223b45684d3f2f166cc6d1ad26450d Author: Ben Gardner Date: Thu Oct 13 22:06:04 2011 -0500 From: Todd Richmond Rework long line splitting commit e00f3545a4430f89d627d92f0bdaf63b6f18cbfc Author: Ben Gardner Date: Thu Oct 13 21:58:05 2011 -0500 From: Todd Richmond Add support for negative indent_continue values. commit 6aeed7a617bb0058092c36dc1cf5cbc6232b1831 Author: Ben Gardner Date: Thu Oct 13 21:55:05 2011 -0500 From: Todd Richmond Add project name to VS2010 project file commit d3a972aaf7ea9ef20c0f7c5436ae4d598aa381c4 Author: Ben Gardner Date: Thu Oct 13 21:49:16 2011 -0500 From: Todd Richmond uncrustify needs a "join" option to go with the other lead/trail options. The requirement is to remove extraneous newlines and merge them into the same format they would have if newlines were not found in the original. This is critical for function calls/deffs where arguments are not brought back together to maximize line length The attached diff is quite simple and resolves the test cases I tried so far. It also undoes the splits that were added by the over-aggressive splitting that I resolved in my previous large diff commit 345560f7d0c27e65725a91664e89ca544155df84 Author: Ben Gardner Date: Thu Oct 13 21:41:30 2011 -0500 From: Todd Richmond If mod_remove_extra_semicolon=true, extra semicolons will be removed from within a macro such as #define ENDSTRUCT }; There might be other modifying options as well that should not take effect within macros commit a36b09750273c9d3306e85684028d2cac0f32770 Author: Ben Gardner Date: Thu Oct 13 21:38:51 2011 -0500 From: Todd Richmond To denote that a string is unicode, L"string" is used, but uncustify will insert a space in the # cpp operator for common macros such as #define KEYWORD(_keyword_) L#_keyword_ which reformats to #define KEYWORD(_keyword_) L # _keyword_ sp_pp_stringify will remove the trailing space but not the leading space which is an invalid construct commit befe3c513e69a08a3e90dc759da01b338687f5a5 Author: Ben Gardner Date: Thu Oct 13 21:35:38 2011 -0500 From: Todd Richmond In Visual Studio in C/C++, the "interface" keyword should be treated like "class" as it allows derivations like ": public foo" commit 965c01bad535aa807e25f4b79a9a6495a3b18280 Author: Jim Meyering Date: Sun Oct 2 12:59:57 2011 +0200 handle a backslash followed by a literal newline Without this change, uncrustify's lexer would get confused for any C code containing a string like this: f ("\ Some text\n"); That led to a diagnostic like "Garbage in col 8: 5c" typically followed by a cascade of unwarranted diagnostics. The fix is to reset "escaped" also when handling a literal newline or a carriage return. Also included: a test case to exercise the bug/fix: tests/c.test tests/input/c/backslash-newline-lex.c tests/output/c/01060-backslash-newline-lex.c Signed-off-by: Ben Gardner commit c404574dd88dba6520ca545ed1b388d678049c21 Author: Ben Gardner Date: Sat Oct 8 21:34:42 2011 -0500 Update SlickEdit project files commit 68c59727a92ee887c110175258dacd27b589fcf8 Author: Ben Gardner Date: Sat Oct 8 20:57:13 2011 -0500 Add OpenPorts.se link commit 8efb7ea7ff46a7b6196f9233541bb63a1a9d3142 Author: Ben Gardner Date: Tue Oct 4 21:37:04 2011 -0500 Save off changes for version 0.59 commit ee20cffd27cafd99aac17c06e80ba954554fb76f Author: Ben Gardner Date: Tue Oct 4 21:06:02 2011 -0500 Update two tests to reflect recent change to mod_full_paren_if_bool commit 3dfc51bf551358630722b7e931588f7c5b01b20e Author: Ben Gardner Date: Tue Sep 27 21:01:18 2011 -0500 Fix comma and boolean op precedence with mod_full_paren_if_bool commit dfbd1a86c0490e0a016ab1a40b125e42ec291c29 Author: Ben Gardner Date: Tue Sep 27 20:55:32 2011 -0500 Change cast to fix warning: assuming signed overflow does not occur when assuming that (X - c) <= X is always true commit f30b92aac7008d942b36547e421c72d69ddbcc62 Author: Ben Gardner Date: Tue Sep 27 20:49:15 2011 -0500 Fix the log level in mark_change() commit e8f850c79ed93e16fca9e1902175419f05e95774 Author: Ben Gardner Date: Tue Sep 27 20:42:46 2011 -0500 Properly handle an empty source file commit 235ae27fa2dccfee5e44c7fb03bbf178b32d3260 Author: Ben Gardner Date: Tue Sep 27 20:40:44 2011 -0500 Don't add parens around BOOL comparisons if there is a preproc present commit cda1e865876bf577f74efac9fd4a720ff78b2a00 Merge: 3de9050 26804b5 Author: Ben Gardner Date: Mon Sep 19 21:21:24 2011 -0500 Merge branch 'master' of https://github.com/jott/uncrustify into jott-master commit 3de90503fc5b360c11ceb861bde3acc138d87ef4 Merge: 51ee3f4 74f6836 Author: Ben Gardner Date: Mon Sep 19 21:17:56 2011 -0500 Merge branch 'jott-aa107f1' commit 74f6836d4aef70a9b4c9ef46810fcefdc6caa798 Author: Ben Gardner Date: Mon Sep 19 21:17:43 2011 -0500 From: Jott Fixed a crash in indent_text. When a closing paren is missing at the end of a file, the next token is NULL. To reproduce, create a file with just x( in it and without a newline. commit 51ee3f4c7c39c4a337476c51ac576474cb3fac5d Merge: 0fa8fd4 6827f9f Author: Ben Gardner Date: Mon Sep 19 19:13:57 2011 -0700 Merge pull request #38 from jott/6827f9ff03920b7b2f178474292176c6078edc11 Fixed an infinite loop in parse_word. commit 26804b5098a0b1d7e288186caeadbd412e2297f6 Author: Jonas Hurrelmann Date: Mon Sep 19 21:39:10 2011 +0200 Added new files to the VS2008 project file. commit aa107f1bc6926def0152b182541650cdb43d3744 Author: Jonas Hurrelmann Date: Mon Sep 19 21:26:04 2011 +0200 Fixed a crash in indent_text. When a closing paren is missing at the end of a file, the next token is NULL. To reproduce, create a file with just x( in it and without a newline. commit 6827f9ff03920b7b2f178474292176c6078edc11 Author: Jonas Hurrelmann Date: Mon Sep 19 21:18:58 2011 +0200 Fixed an infinite loop in parse_word. When there are no more characters in the context, the parsing fails. Create a file with just #x in it and without a new line to reproduce. commit 0fa8fd44c6a4ebffbe9378c932c604dd814ad2af Author: Ben Gardner Date: Mon Sep 12 20:58:12 2011 -0500 Update the Win32 VS2010 project file (Todd Richmond) commit 2be051a1e0e155a96710bec43ab16c4eaffa79e2 Author: Ben Gardner Date: Mon Sep 12 20:56:53 2011 -0500 Fix some build issues under Win32 commit 60f3681da60462eda539b78e0c6c3eea823481e5 Author: Ben Gardner Date: Thu Sep 8 21:38:27 2011 -0500 Set the parent of '{' in cast '(foo){1,2,3}' Fixes SF #3406144 commit 2b6a3105f5bfeaef74821ffb714799871376ad62 Author: Ben Gardner Date: Wed Sep 7 21:34:18 2011 -0500 Add option nl_case_colon_brace commit ed129ba0f37055b4be02200e2bb644a51c29aa02 Merge: eb394d1 b144060 Author: Ben Gardner Date: Tue Sep 6 22:25:52 2011 -0500 Merge branch 'master' of https://github.com/hschmidt/uncrustify into hschmidt-master Conflicts: src/token_names.h Assuming that the change in test 50007 was intentional commit eb394d1ad6001cebf6ef2ef3572e1ae13a200e86 Merge: 9789753 caecd7c Author: Ben Gardner Date: Tue Sep 6 22:17:45 2011 -0500 Merge branch 'indent_ctor_init' of https://github.com/patnotz/uncrustify into patnotz-indent_ctor_init Conflicts: tests/cpp.test commit 978975355fa1e8280400df3d742b48498d6af1b3 Author: Ben Gardner Date: Tue Sep 6 22:10:31 2011 -0500 Rework the sp_before_tr_emb_cmt and sp_num_before_tr_emb_cmt options commit eaa5aef38a15b3c5aabb06943f8a2d0cea53dd04 Merge: 235adfd 6dcaa68 Author: Ben Gardner Date: Tue Sep 6 21:47:20 2011 -0500 Merge branch 'sp_before_tr_emb_cmt' of https://github.com/patnotz/uncrustify into patnotz-sp_before_tr_emb_cmt Conflicts: src/tokenize_cleanup.cpp commit 235adfd18147f35a196686efa2ddd084010ba505 Author: Ben Gardner Date: Tue Sep 6 21:22:00 2011 -0500 Remove commented out memset's commit 727d23421b17a960e5fb8fe80e331739be278724 Author: Ben Gardner Date: Mon Sep 5 20:26:07 2011 -0500 Remove some unused functions commit b18c4ee9b7a3240cfee3330559c8c4b64f1fc823 Author: Ben Gardner Date: Sun Sep 4 22:36:24 2011 -0500 Need to check the real previous when looking for the start of the file commit 00f7f5d2a50e3ee504772387e7071fcf0111d684 Author: Ben Gardner Date: Sun Sep 4 22:22:58 2011 -0500 Update some tests that had incorrect output due to newline issues commit c08cf0da0f2a8970848a6d601494beea49aff866 Author: Ben Gardner Date: Sun Sep 4 22:22:24 2011 -0500 Fix some output stability issues by running the newline code twice commit 9160e075dcb81d895cac3fd8aee9164ea8cd637b Author: Ben Gardner Date: Sat Sep 3 16:21:13 2011 -0500 Don't nest complex statements when creating an 'if' one-liner commit 6b4cdc6ddd259ea6b7c210a7fdf8064a4080c6bd Author: Ben Gardner Date: Sat Sep 3 16:12:48 2011 -0500 Fix some test output commit 5230fbb00bd0cc3e28dba2645139378b21212a3b Author: Ben Gardner Date: Sat Sep 3 16:12:10 2011 -0500 Improve blank line handling commit 2f05596f4f7423c8b06eb28dac3d9d629dd7d1a3 Author: Ben Gardner Date: Sat Sep 3 15:43:00 2011 -0500 Update test config to reflect new option name commit 8c57f4556d2ce43f3a6f41368f09b24db40aa6ab Author: Ben Gardner Date: Sat Sep 3 15:40:11 2011 -0500 Add test of UTF-16 input files w/o a BOM (output contains the BOM) commit 9e45777e294ce778a46e43ae0e0c75d9027e7948 Author: Ben Gardner Date: Sat Sep 3 15:37:45 2011 -0500 Force the BOM on UTF-16, detect UTF-16 encoding without a BOM commit a44d84381db4f0882a5fa2a47f49f4ecc73a12fa Author: Ben Gardner Date: Sat Sep 3 15:07:34 2011 -0500 Rework the Byte Order Mark stuff (more options) commit c16a2f1ea6f001a6b12a51ade1befb7a38662f16 Merge: ab8a73f 7ba9a91 Author: Ben Gardner Date: Sat Sep 3 12:06:05 2011 -0500 Merge branch 'unicode' commit ab8a73f782e1859bdb304189a2e2b098ad680d5a Author: Ben Gardner Date: Sat Sep 3 12:05:56 2011 -0500 Update vpj file commit bf40639ae0ab7b49e4dca7c5af0dddf5c173e63c Author: Ben Gardner Date: Sat Sep 3 12:05:37 2011 -0500 Fix error in comment commit 7ba9a91cd3a7f2ea5815ee61d7b838b7cb2bb36d Author: Ben Gardner Date: Sat Sep 3 12:02:16 2011 -0500 Save fixed test commit 1067a8b382521b62eadb099e23c80c3e649c81c6 Author: Ben Gardner Date: Sat Sep 3 12:01:21 2011 -0500 Fix 1-liner splitting in "{ get; set; }" commit b16542872982674f8896fa68a22c28a0a383c945 Author: Ben Gardner Date: Sat Sep 3 11:11:40 2011 -0500 Add tests for UTF-16 handling commit 1dac0422c9d52d0cb84d25d3eb8ed20569cdc9a6 Author: Ben Gardner Date: Sat Sep 3 11:08:08 2011 -0500 Fix UTF-16 handling and the BOM commit d6c084a4f7f25ae05a43364ef52a7fc5c89df6fa Author: Ben Gardner Date: Fri Sep 2 02:29:02 2011 -0500 Add test for force_utf8 commit d95d1fe639882fbe85e78403fbd871407ea14145 Author: Ben Gardner Date: Fri Sep 2 02:26:11 2011 -0500 Add force_utf8 commit 10d5b16f6f207bd51d05ef232a328fa67165e262 Author: Ben Gardner Date: Fri Sep 2 02:13:57 2011 -0500 fix test - no idea why it was broken previously commit 8742ac03b5a7670938440eb9ab8eff1f7517a40c Author: Ben Gardner Date: Fri Sep 2 02:13:35 2011 -0500 Fix a few UTF-8 bugs commit 85a24120bd4b693024b9d6428ca260a2426ec176 Author: Ben Gardner Date: Fri Sep 2 01:47:16 2011 -0500 get output_comment_multi() working commit 9d3e02ed8091f86f00d095613b40d826f68ac7d8 Author: Ben Gardner Date: Fri Sep 2 01:35:29 2011 -0500 save everything except output_comment_multi commit 090841b780f60c3ee9ff3c530f5693ea194196e1 Author: Ben Gardner Date: Fri Sep 2 01:13:02 2011 -0500 rework output_comment_multi_simple to use unc_text commit b895188f6b093010125c2b26c6802233f56f1f10 Author: Ben Gardner Date: Fri Sep 2 01:12:10 2011 -0500 More unc_text usage and cleanup commit f9736a041e65b92c6040776c73027c289b463e76 Author: Ben Gardner Date: Tue Aug 30 22:32:23 2011 -0500 Fix combining of C comments commit 911d7c9d316235275094a539341fe7e192b41fb2 Author: Ben Gardner Date: Tue Aug 30 22:28:17 2011 -0500 Fix more string-related issues commit 95ee11320e9bf26c6715d73b1fdcb4301207497a Merge: 5f4855d a0f6fbc Author: Ben Gardner Date: Fri Aug 26 19:21:23 2011 -0700 Merge pull request #32 from patnotz/testing-howto Tweaks to the TESTING how-to commit 878becb3b0f205974efe86fef36616326c706487 Author: Ben Gardner Date: Fri Aug 26 21:19:46 2011 -0500 Save off work commit 6dcaa6850aa475e76a83d77e7322c67cc1aee3ed Author: Pat Notz Date: Tue Aug 2 22:29:59 2011 -0600 Add option for controlling space before trailing/embedded comments Two new options: # Controls the spaces before a trailing or embedded comment sp_before_tr_emb_cmt = ignore # Number of spaces before a trailing or embedded comment sp_num_before_tr_emb_cmt = 0 commit a0f6fbcc77cd45c867514b24d0d3e499f2e00fe3 Author: Pat Notz Date: Fri Aug 26 11:36:38 2011 -0600 Tweaks to the TESTING how-to - correct "run-tests.py" to "run_tests.py" - add tip about 'run_tests.py LANG' - can do "cd tests; ./run_tests.py", not "./tests/run_tests.py" commit caecd7c26b58926fe00e9d3c110906d9f7e7050e Author: Pat Notz Date: Fri Aug 26 15:54:21 2011 -0600 Add indent_ctor_init option for extra indenting of ctor initializers if indent_ctor_init > 0 then that many extra spaces are added to the indetation of the constructor initializer list. commit 63b1c684256183f773eca6740564395631857674 Author: Ben Gardner Date: Thu Aug 25 20:42:09 2011 -0500 Save off Unicode work commit 5f4855d5a9165fc083c2ed2d65a988e2786054c1 Merge: 69486ca 9f6bdb7 Author: Ben Gardner Date: Thu Aug 25 18:41:04 2011 -0700 Merge pull request #29 from JanX2/master Fixed Xcode build settings commit 69486ca2d0187c8a3e0fe08da1ea1196f2d53237 Merge: 3437cff c44ee6d Author: Ben Gardner Date: Thu Aug 25 18:32:21 2011 -0700 Merge pull request #31 from patnotz/testing-howto Add TESTING file to document running and adding tests commit c44ee6dfb5b60e32725f8df25c9dc93f58177452 Author: Pat Notz Date: Tue Aug 23 10:16:34 2011 -0600 Add TESTING file to document running and adding tests The content of this file is from messages from Ger Hobbelt and Ben Gardner. commit fe42c67ae018c7ee44f276d0d4ab543710062678 Author: Ben Gardner Date: Thu Aug 18 22:31:37 2011 -0500 Add a completely untested unc_text class commit 97996a0b51d916d4f25f5b61aecbb4c367f5f19f Author: Ben Gardner Date: Wed Aug 17 22:28:55 2011 -0500 Add a start to UTF-8 and UTF-16 support commit 9f6bdb7f3880cf90eea86381a1ac7c96ea54f96a Author: Jan Weiß Date: Tue Aug 16 17:54:57 2011 +0200 Cleaning Xcode build settings. commit b4687cd969dba1ca92b51b6268aae109622ba5aa Author: Jan Weiß Date: Tue Aug 16 17:54:22 2011 +0200 Xcode project file touched by more recent Xcode version (3.2.5). commit a0639c2b9047e91e585bfbc009fc3eda961d137c Author: Ben Gardner Date: Sat Aug 13 22:56:16 2011 -0500 Fix comment commit 3437cffac02717c37c4f7b3d23adc7c73d2a2543 Author: Ben Gardner Date: Sat Aug 13 21:37:25 2011 -0500 Update test results for new sp_after_new option commit e7e09ab2b2b67341451bacc11472a6f5330c642d Author: Ben Gardner Date: Sat Aug 13 21:09:21 2011 -0500 Make do_space() static and don't log spacing if the 2nd chunk is a newline commit e0e50e81b0ba2c04242b7799d71dd2b6d77dcc01 Author: Ben Gardner Date: Sat Aug 13 21:08:49 2011 -0500 Add option sp_after_new commit 3bbe8521f46956d7d879505452b4c7b5273dfd88 Author: Ben Gardner Date: Sat Aug 13 21:07:52 2011 -0500 Mark the parent of '[]' in 'delete[] x' commit 7501cad6f93119ae3862a3b84d3934d6c9bd9df0 Author: Ben Gardner Date: Sat Aug 13 14:14:10 2011 -0500 Add new options: nl_after_class and nl_after_struct commit 46718ae6f0873340e19dde925837ac657274ef7b Author: Ben Gardner Date: Sat Aug 13 14:13:05 2011 -0500 Set the parent type of the semicolon after a class/struct/enum/union commit 97bba2218fc491ed48bac794a6c2f093a9628dbc Author: Ben Gardner Date: Wed Aug 10 22:02:20 2011 -0500 Add nl_property_brace to handle "public foo bar { get; set; }" commit 1b30ae951777f26fbbb463bb2cc8e19b222be459 Author: Ben Gardner Date: Wed Aug 10 21:44:11 2011 -0500 Fix the new option nl_after_func_body_class (too much cut-and-paste) Improve logging so see what changes blank lines. commit 20b21c2f7cd9c3b635b0fc124541e17074fdf941 Author: Ben Gardner Date: Sat Aug 6 22:56:10 2011 -0500 Yell if a macro function ending with a semicolon is detected. Using those in code confuses Uncrustify. commit 26a283192627880f598f857cf8892338098d038c Author: Ben Gardner Date: Sat Aug 6 22:55:15 2011 -0500 Update test for recent namespace/property fix commit 5f547a4988eab08f04d1d22c2c67a6a175fbd4bb Author: Ben Gardner Date: Sat Aug 6 22:50:42 2011 -0500 Fix detection of "void f(::a::b v);" commit 238d22c69c8a9bfc67bf029c1b6642f00fafc642 Author: Ben Gardner Date: Sat Aug 6 22:26:13 2011 -0500 Set the parent of everything between 'namespace' and '{' to fix false property detection in C#. commit ef8350ecdbcf65988f708f8d072513deb85bfd5a Author: Ben Gardner Date: Sat Aug 6 22:11:49 2011 -0500 Add option nl_after_func_body_class commit a746876a46f9c0437be10248760cef9ea11a3d8e Author: Ben Gardner Date: Sat Aug 6 21:51:19 2011 -0500 Check for embedded 0's in the input file. This causes undesired operation. commit bcee5c52f5922102e57c805141480bc5a41e14d1 Author: Ben Gardner Date: Sat Aug 6 21:38:30 2011 -0500 Keywords 'and' and 'or' may be in C/C++ '#if' statements commit 057d9e4188d182147d5bd459530b4785811fe117 Author: Ben Gardner Date: Sat Aug 6 21:28:34 2011 -0500 Add some additional null checks in newline_add_after() commit 25b916cee118fa9ec92d96a45bd1bfed5bfb95b5 Author: Ben Gardner Date: Sat Aug 6 21:00:50 2011 -0500 nl_before_throw only applies to after a ')'. commit e9d48e186b3969511d24a85c0c5def9ce278d757 Author: Ben Gardner Date: Thu Jul 28 21:50:10 2011 -0500 Use std::bitset for the log mask commit cb1dbd354b339ae81c03865ccf0e6fb60a4e03ca Author: Ben Gardner Date: Sat Jul 16 15:38:11 2011 -0500 Add missing test results commit 0ab0127350eccdaf085c2b5a4e082679746acad5 Author: Ben Gardner Date: Sat Jul 16 15:02:48 2011 -0500 Add config file for the 'sun' C++ format (Todd Richmond) commit 9519de3a7e44f903ce5fbc56b6182579fad8a1c4 Author: Ben Gardner Date: Sat Jul 16 14:57:41 2011 -0500 Add Visual Studio 2010 project file. commit f4c5357612d26e94a5951336d58c5b351dab3c65 Author: Ben Gardner Date: Thu Jul 7 22:19:54 2011 -0500 Clarify the description for nl_func_var_def_blk commit 6cbeb6fba003f19fc4a56261072accd34900cbd2 Author: Ben Gardner Date: Thu Jul 7 22:15:59 2011 -0500 The continuation indent applies to the next line, not the current Fixes SF#3348571 commit abb5ed155825b5756328d226881e041882a4e96b Author: Ben Gardner Date: Wed Jul 6 21:31:19 2011 -0500 Make the nl_func_var_def_blk option take priority over nl_before_if, etc Fixes SF#3348594 commit e7990ff73274f4d4ed6fe89853148c9a58d23efa Author: Ben Gardner Date: Wed Jul 6 20:37:57 2011 -0500 Remove arbitrary limits in align_same_func_call_params() commit 0fd87aad1bc102221d45d75caee772ea370e36fe Author: Ben Gardner Date: Wed Jul 6 20:30:12 2011 -0500 Fix align_same_func_call_params() Fixes SF#3354409 commit f6ab1b08e9327f22c4077a212c793b14c55b08cb Author: Ben Gardner Date: Tue Jul 5 22:07:29 2011 -0500 Use feof() to detect the end of the stdin stream. commit 5ddffe8ca744cbe8cfbff11632460b59769f4939 Author: Ben Gardner Date: Mon Jul 4 22:49:35 2011 -0500 Remove std:: prefix, now that we are "using namespace std". commit c3224461bfdda91c8414095b31aa87ece0817434 Author: Ben Gardner Date: Mon Jul 4 22:49:09 2011 -0500 Re-run update-default-cfg.sh commit 313c87ae4403b76c31a7302c6d6374f0fbae6f39 Author: Ben Gardner Date: Mon Jul 4 22:48:46 2011 -0500 Remove newline at the end of the option text. commit 7d627682a0b5aeed41abf467d5f3253641ea75fb Author: Ben Gardner Date: Mon Jul 4 22:46:29 2011 -0500 No longer need malloc() or realloc() commit f7d16638d056a2e1a2df0e6f298b786153f02e6b Author: Ben Gardner Date: Mon Jul 4 22:40:45 2011 -0500 Use std namespace and use std::vector for file data. commit 067d13ae43eaca6c67036d459f51617b53bc17c8 Author: Ben Gardner Date: Mon Jul 4 21:49:42 2011 -0500 Use std::map for custom keywords. commit 29371a4b44cb5af4375dcf2364af607c4c6952b7 Author: Ben Gardner Date: Mon Jul 4 21:48:17 2011 -0500 Use a std::map for the custom defines. commit 4c7c49574de4360bd233b67622f62dba1bb4d413 Author: Ben Gardner Date: Mon Jul 4 15:25:28 2011 -0500 Move add_long_preprocessor_conditional_block_comment() out of defines.cpp commit 183a3ab83f52c14d91fa71f6b9a845a4ff3ec55b Author: Ben Gardner Date: Sat Jul 2 17:32:11 2011 -0500 Remove unused typedefs and types. commit acc0a1488f581f1a5d3a0f389a29d645db24a13a Author: Ben Gardner Date: Sat Jul 2 17:24:14 2011 -0500 Rework ChunkStack to use std::deque and not manually manage memory commit c45d8a349f8964c6f36bece12c5fcfcbffd0a6bf Author: Ben Gardner Date: Sat Jul 2 16:15:23 2011 -0500 Replace C99 construct with new/delete. commit 7d2f25f76cd051e58d4599c07820778bbf6d543d Author: Ben Gardner Date: Fri Jun 17 14:47:50 2011 -0500 Add more to the C++ operator test commit adb08f32bc3b8f77dc5efb86bd3f33be3da82b2b Author: Ben Gardner Date: Fri Jun 17 14:45:58 2011 -0500 Clarify the description of sp_inside_square commit dd537926695d380f6aec1e4bd8ce551dd2f37219 Author: Ben Gardner Date: Fri Jun 17 14:44:35 2011 -0500 Properly handle 'operator []', 'operator new[]' and 'operator delete[]'. Fixes SF #3317841 commit 314cf189824f261afd6673f5b90cdb9f3ac92778 Author: Ben Gardner Date: Fri Jun 17 10:55:07 2011 -0500 Use the comment size as a guide for how large a line can be. Fixes SF #3317781 commit 2b9adf5b10bc501d4256bc77130c243d8bcd78e0 Author: Ben Gardner Date: Sat Jun 11 17:25:54 2011 -0500 Remove obsolete subversion $Id$ tags commit 59e7dd641a525f3eb6086fc2a3774ccaaed4c30f Author: Ben Gardner Date: Sat Jun 11 17:18:13 2011 -0500 Redo the options to tests/run_tests.py commit 4cfad57e4785c0989a9192a2a0f8baf9d7ac8ee1 Author: Ben Gardner Date: Sat Jun 11 17:06:27 2011 -0500 Extend the test script to check for stability. If a test passes, it runs uncrustify on the output and checks to see if it changes. commit 9073b78f0fb4219e229c4a161669eadc17a4e26b Author: Ben Gardner Date: Sat Jun 11 16:50:52 2011 -0500 Do not remove braces if set to AV_FORCE Fixes SF #3289119 commit 9db88d5c5831b599323fbd00290beaa64485e900 Author: Ben Gardner Date: Sat Jun 11 16:39:39 2011 -0500 Fix indent_cmt_with_tabs for comments in the first column. Fixes SF #3310758 commit 4cf28b5c5eafec045424084f69b21c1189e01ad7 Author: Ben Gardner Date: Sat Jun 11 16:34:30 2011 -0500 Sort the keyword table. @synthesize and @selector were out of order. commit 317b7f0e04f575dd3de1dd50bf863cbf7c9562a6 Author: Ben Gardner Date: Sat Jun 11 16:21:11 2011 -0500 Add handling for the Java assert statement Fixes SF #3304061 commit 4efe8c86ce16fc9fbfb00ab18725c3063e75dcfc Author: Ben Gardner Date: Sat Jun 11 16:18:37 2011 -0500 Add a test for the Java assert statement. commit b69eadfbc8f1b51b09fbb948373c486b2b7ef106 Author: Ben Gardner Date: Sat Jun 11 16:16:52 2011 -0500 Add a specific keyword for the Java 'assert' commit 28f342227228f6bed4fa65e92bf161ef6a898dca Author: Ben Gardner Date: Sat Jun 11 16:15:58 2011 -0500 Add test number ranges to each language test file commit 9e911263e5d1055ad28fcec4745d592421025efd Author: Ben Gardner Date: Sat Jun 11 16:12:27 2011 -0500 Renumber the C tests commit 6175a01d970d9bad6138fea083ecce3b283d6747 Author: Ben Gardner Date: Sat Jun 11 15:37:50 2011 -0500 Fix some NULL-derefs in add_long_preprocessor_conditional_block_comment() Closes SF #3306280 commit 116e2e6d87bc741a47b3dcbdefadc0323c3000ee Author: Ben Gardner Date: Sat Jun 11 15:29:07 2011 -0500 Try to do a better job at handling user-defined literal suffixes. Fixes the second issue in SF #3306237. commit d42b30e474ffd4aabe262b748520ff05ca1f9159 Author: Ben Gardner Date: Sat Jun 11 14:54:53 2011 -0500 Recognize the C++0x 'constexpr' keyword commit 983dd90b2a03525955c0faa854ddc953c8a18cb8 Author: Ben Gardner Date: Sat Jun 11 14:39:44 2011 -0500 Change parse_number() to allow decimal numbers starting with a 0, as in 08. Fixed the first issue in SF# 3306237. commit 92a6a6b2ccb7916d56aa6d3956b2e773bd9f82c8 Author: Ben Gardner Date: Tue Jun 7 20:50:38 2011 -0500 Remove diagnostic code about unexpect chunk in struct/enum/union commit 2cc9f6d51ba0d091c6e4e1b3f876528a6d2648b2 Author: Ben Gardner Date: Thu May 26 21:21:27 2011 -0500 Suppress log on expected chunk Fix SF #3307476 commit 586f958edf0d2303fe6411370958fe15a6465ae2 Author: Ben Gardner Date: Sun May 22 10:20:21 2011 -0500 Update tests for SF bug #3305534 commit df55dc01c7f5358f8572ea23df46374d0752458f Author: Ben Gardner Date: Sun May 22 10:10:26 2011 -0500 Fix detection of operator() function calls. Fixes SF #3305534 commit 7bf25d620c3fd11f2edaad43ba71139deae6ca9f Author: Ben Gardner Date: Thu May 19 22:13:45 2011 -0500 Uncrustify 0.58 commit 6ed81d30cf926218d873ea644fdfe016343cb1bf Author: Ben Gardner Date: Wed May 4 21:09:14 2011 -0500 Do not corrupt files that contain non-ASCII UTF-8 characters commit f4c1969ad44a8ae7c79dcb616aed2e70d81989a8 Author: Ben Gardner Date: Wed Apr 20 22:07:39 2011 -0500 Add missing test file commit 5b8cf13145ed0e104d6add03a338b8c80b1f6c1c Author: Ben Gardner Date: Wed Apr 20 21:50:19 2011 -0500 Add a test for aligning static class variables commit c581c009194be58024a1eaf53d9c753ffdde06f0 Author: Ben Gardner Date: Wed Apr 20 21:49:28 2011 -0500 Skip over member stuff 'foo::bar' when aligning variables. commit c6266ba06538ebda17cc3bcd8b9ba5a218dda324 Author: Ben Gardner Date: Wed Apr 20 21:37:47 2011 -0500 Back up past and class specifiers when aligning function prototypes and single-line functions. commit edaa77817e796fbd54c55106da068aa8789f4b36 Author: Ben Gardner Date: Sat Apr 16 23:40:34 2011 -0500 Fix '*' detection in "BYTE** c = new BYTE*[12];" commit 7925530f1e5405d738729607d9761c7e8f1ead98 Author: Ben Gardner Date: Sat Apr 16 23:20:24 2011 -0500 Label the '&' in 'TYPE &' as BYREF. commit 4b8f3fb5ace5d2286315dcc815a4e6c0d6bf700f Author: Ben Gardner Date: Sat Apr 16 22:57:07 2011 -0500 Handle MS extension: 'for each ( xx in yy )' commit 5885e05beac1496cb9ad5688f28edd9d63c198b0 Author: Ben Gardner Date: Sat Apr 16 22:42:58 2011 -0500 Fix the description for mod_add_long_ifdef_else_comment and mod_add_long_ifdef_endif_comment commit 837ccbf4713428383857453fcd1ef1831dfb2036 Author: Ben Gardner Date: Sat Apr 16 22:38:18 2011 -0500 Add test for D sized enums commit f9263ccd64d06fb2a9425ff55e8caaf522936645 Author: Ben Gardner Date: Sat Apr 16 22:35:43 2011 -0500 Correctly handle D sized enums in "enum x : int { ... }" commit 8438283ffd1ce36116c2b252362c835a7f4f7326 Author: Ben Gardner Date: Fri Apr 8 18:24:55 2011 -0500 Fix cut and paste error in description for cmt_insert_before_preproc commit bc33025cb4fa8772fe036cdc6f6cf1a665525f64 Author: Ben Gardner Date: Sat Mar 19 09:11:55 2011 -0500 Add inserted comment substitution for "$(message)". From: Kevin Hardman commit d633b408c604babcaf349b7418d519e3f8f0bd20 Author: Ben Gardner Date: Sat Mar 19 09:10:42 2011 -0500 Add new option cmt_insert_oc_msg_header. From: Kevin Hardman commit ce5edfe22ae1d6b0c3d27e516a8f2dff6b777fdc Author: Ben Gardner Date: Sat Mar 5 15:33:11 2011 -0600 The default for tok_split_gte is now false, so it needs to be set. commit 4a011f3b8d44762adadcef4f071bc04ab6c982ef Author: Ben Gardner Date: Sat Mar 5 15:29:17 2011 -0600 Fix detection of this: d[i].e * f(); Was detecting 'f()' as a function prototype, should be a function call. commit e02cea59246cd98e2e4682a126a15a83d8f9a2fa Author: Ben Gardner Date: Sat Mar 5 15:28:10 2011 -0600 Fix segfault introduced in the last commit. commit ee31f327f5b1faf197bb86c7942fb2e35a685c89 Author: Ben Gardner Date: Sat Mar 5 15:14:26 2011 -0600 Mark the parent of braces if an open brace follows a function call. Fixed SF issue 3171797. commit 01c2d27e0f8f4a4fccd037c4aabe00b7dd25eec2 Author: Ben Gardner Date: Sat Mar 5 14:48:01 2011 -0600 Change the default to NOT split '>=' if it could be the closing part of a template. commit 8a6089244856829128c3f0d2a7fe0b65010c765e Author: Ben Gardner Date: Fri Jan 21 22:25:13 2011 -0600 Add a hack to allow a something named 'class' that isn't part of a class definition. As in: "MyClass.class.getCanonicalName()" commit d57a1a30683db491fa00879509dfe506e3dad6c6 Author: Ben Gardner Date: Fri Jan 21 21:58:56 2011 -0600 Add some special handling to allow ObjC to use some keywords as identifiers commit 03b4a31c63a15b75d3c8759a6d92610e450c5ad6 Author: Ben Gardner Date: Thu Jan 6 10:23:33 2011 -0600 Add a test for detecting function parameters commit 3e4c826e4cacd760c3b7860a4366549be917b445 Author: Ben Gardner Date: Thu Jan 6 10:05:50 2011 -0600 Function parameters may be arrays. commit b1b19b9ddd9411f99ccd642308856d071f157440 Author: Ben Gardner Date: Thu Jan 6 10:04:38 2011 -0600 Use chunk_skip_to_match() instead of chunk_get_next_type() where appropriate commit af7ee0f748283ff39e20eae928fd6eab630c54dc Author: Ben Gardner Date: Sat Jan 1 13:42:12 2011 -0600 Change logic so that align_keep_tabs doesn't break align_with_tabs. commit 2ad8fc4030d34aebd55ff1a138a3208f558680d7 Author: Ben Gardner Date: Sat Jan 1 13:18:55 2011 -0600 Change some keywords to CT_WORD between '@interface' and '@end' (ObjC) commit a726617e74b739a54f6fda3487d17180de3e9ba1 Author: Ben Gardner Date: Sat Jan 1 12:46:44 2011 -0600 Allow function types inside function parameters in a prototype. commit a6f728ec83a5798f65566cf70f67b0eea44e2050 Author: Ben Gardner Date: Fri Dec 31 14:52:23 2010 -0600 Add tests for sp_catch_paren, sp_throw_paren, sp_version_paren and sp_scope_paren. commit 135d677b97e3dea11600ea0adce9228563a0e583 Author: Ben Gardner Date: Fri Dec 31 14:49:28 2010 -0600 Add new options for D: sp_scope_paren and sp_version_paren commit c6a66430edfc6d2e0705b396a0877511aa7d6042 Author: Ben Gardner Date: Fri Dec 31 14:28:23 2010 -0600 Add option sp_catch_paren commit 27df8f102b8848b347a5788206795b175bdd4c9d Author: ben Date: Fri Dec 31 13:51:16 2010 -0600 Only mark a colon as a CT_CLASS_COLON if at the same level as the parens. commit 6840f94af18dcc30f252bf0c45642673f7ba901b Author: ben Date: Fri Dec 31 12:15:00 2010 -0600 Add option tok_split_gte to disable splitting '>>=' and '>=' in template detection. commit e6528e71b685a73ee30da0eabe3521ce03c3d8a9 Author: ben Date: Fri Dec 31 11:33:11 2010 -0600 Don't right-align if align_on_tabstop is set. commit 5c2a8b36760bf64059a5b60bf6f827b190cdb2cd Author: ben Date: Fri Dec 31 11:31:00 2010 -0600 Remove some duplicate tab-calculating code. commit b144060febe17aea8a38ee758f125452281d454c Author: Hannes Schmidt Date: Sat Dec 4 16:06:49 2010 -0800 Fix detection of whether inside Obj-C msg send Fixes sp_before_send_oc_colon and sp_after_send_oc_colon that were probabably broken by 42b1ed31999d4926188acf881912b49958282dac. Also revives the intent of cb9c866934ff2937e59eebab7dfeb937de73f792 broken by the same commit. Signed-off-by: Hannes Schmidt commit a22f48121a9eeb207230c0063d0c51f38ce8fa82 Author: Ben Gardner Date: Thu Nov 25 10:46:38 2010 -0600 Add note about how to push a tag commit 0247755e1496b876c4fa5759eafb6ebc1b47a459 Author: Ben Gardner Date: Thu Nov 25 10:20:27 2010 -0600 Prep uncrustify 0.57 release commit cbb8025fd6ba45664ed49e7f4d4c4e215fc77b01 Author: Ben Gardner Date: Wed Nov 24 10:51:39 2010 -0600 Bail on template detection if we back up into a return and there is a boolean op in the angles. commit ef6ccbacb8583b22c9d3df8a2b3c9bf808628cf7 Author: Ben Gardner Date: Wed Nov 24 10:09:09 2010 -0600 Fix detection of anonymous bit fields in a structure commit bda365fd6805565584ab02237862cc961eb99723 Author: Ben Gardner Date: Sat Nov 20 10:25:09 2010 -0600 Fix incorrect removal of braces of an 'if' statement that is followed by and 'else' and have a nested 'if' before the 'else'. commit 2d1498c30ae7aa985fbde3d882ab2d35092b4adf Author: Ben Gardner Date: Mon Nov 15 17:22:08 2010 -0600 Don't change the '*' in the following to a ptr_type: struct { int a; } b[2 * SZ]; commit 233256cc6a661ff8ff56f31172602b11be9c4149 Author: Ben Gardner Date: Mon Nov 15 17:12:34 2010 -0600 Improve labeling of the angled brackets in protocol lists as in: @protocol Shape commit 5276460b2449fe3f4410a44c47ff29ff3ada3773 Author: Ben Gardner Date: Sat Nov 6 14:18:41 2010 -0500 Do not indent ignored text. commit 196b1e23fe67070290285ee9e180f2c3a1ff1949 Author: Ben Gardner Date: Thu Nov 4 10:09:44 2010 -0500 Add support for Q_SLOTS and Q_SIGNALS. (John Volpe) commit e936d42ed978b8e1497ec4b65171f52262795ff5 Author: Ben Gardner Date: Thu Nov 4 09:55:04 2010 -0500 Update test to cover classes declared with scope. commit a690b7bcce5371935c569c0d9564da23e125070f Author: Ben Gardner Date: Thu Nov 4 09:52:14 2010 -0500 Skip over '::' when looking for the class name. commit cf154549c630206d22e4fca3b27e1672cc6ed26a Author: Ben Gardner Date: Thu Nov 4 09:44:08 2010 -0500 Fix indent of ObjC class if there are no messages declared. commit 2382da103bd64ff866d0ce4a875436a5e8fd7740 Author: Ben Gardner Date: Thu Nov 4 09:16:23 2010 -0500 Check for indent-on on the current line before parsing off whitespace. commit 91808ad839f2aeb6566192beeac2f10f55027259 Author: Ben Gardner Date: Wed Nov 3 22:13:04 2010 -0500 Add D support for 'unittest' as a plain old symbol instead of a keyword. commit 49ddde72b5c528633c37341123a2a09da12db431 Author: Ben Gardner Date: Wed Nov 3 22:04:35 2010 -0500 Fix detection of " *INDENT-ON*" when the comment isn't in column 1. commit f7c0b6f5edf89f72cf9a01405d4611b8da1c5223 Author: Ben Gardner Date: Wed Nov 3 21:48:06 2010 -0500 Fix handling of multi-line CPP comments. These are '//' comments with escaped newlines. commit 4dffd493412a5811e0b1cbfe1b31470511c75e34 Author: Ben Gardner Date: Wed Nov 3 21:03:25 2010 -0500 Add support for the D template format that doesn't use parens. Example: "to!string(1.2)" or "TFoo!int.t x;" Fixed bug #3091128 commit 2b2ceb78c6db5e1b1a099c11a1932b740ebb075a Author: Ben Gardner Date: Thu Oct 7 21:52:27 2010 -0500 Treat 'try' followed by a colon as a qualifier to handle this format: A::A(int) try : B() { } catch (...) { } Otherwise, a virtual brace is inserted after 'try'. commit 4c5d7b7377efcda9e2c1573e2178ebe5a5386b55 Author: Ben Gardner Date: Thu Oct 7 21:40:14 2010 -0500 Fix detection of the language of files passed on the command line. commit 11fb326964e5096b75f2a3edb171851794163bb5 Author: Ben Gardner Date: Thu Oct 7 21:26:31 2010 -0500 Zero cpd.frame_count before scanning the file. Force the preproc parent type to the correct value in pf_check(). commit a0c308b86bff8f29609b3dbc866317293317de2f Author: Ben Gardner Date: Thu Oct 7 20:17:24 2010 -0500 Add minimal support for C++0x rvalue references commit 67365501baa5df7b617a97ede8597809f102b727 Author: Ben Gardner Date: Thu Oct 7 19:26:58 2010 -0500 Add support for the MS-specific '#@' charizing preprocessor operator commit 52a3525fed0b407a01dace8f959b22e369f84fc1 Author: Ben Gardner Date: Wed Sep 1 20:12:49 2010 -0500 Comment out mark_struct_union_body log statement. commit 247a8053952291032b134b8ef2d35f94e4707d8c Author: Ben Gardner Date: Sat Aug 28 17:58:14 2010 -0500 Update test for C++0x R strings with embedded newlines. commit a20c582e003cccb1fa2f8f0f696c71ea3799dac2 Author: Ben Gardner Date: Sat Aug 28 17:57:50 2010 -0500 Newlines may appear inside the C++0x R"(xxx)" strings commit d1db1dd3ffa9983f9c07ecd824fba68785b55f9d Author: Ben Gardner Date: Thu Aug 26 20:51:22 2010 -0500 Update the tests for the newly added C++0x literals. commit 5af337c38f0dd8025ae46e2ccbf290d2b43a2638 Author: Ben Gardner Date: Thu Aug 26 20:49:10 2010 -0500 Add support for C++0x string literals and the user-defined literals commit e63fe8b359ac2efa1e015c87ae4eb079de7071fa Author: Ben Gardner Date: Fri Aug 13 09:00:40 2010 -0500 'foreach' isn't a C++ keyword commit f543e31a8c6fe5b9b31fead5caafd970277319d8 Author: Ben Gardner Date: Wed Jul 28 21:41:59 2010 -0500 Fix incorrect log text commit 525014a12e3e5427e61f6f607d985fae87ab9657 Author: Ben Gardner Date: Wed Jul 28 21:41:47 2010 -0500 Improve support for D casts and const(type) qualifier. commit 0c9675a86e8225fe65bdaaf9a3138f6efe7c4d12 Author: Ben Gardner Date: Sun Jul 25 19:15:06 2010 -0500 Rework tests for new nl_func_def_xxx options commit fece00a87048a3e2631356c8d10ddd947498c6ad Author: Ben Gardner Date: Sun Jul 25 19:10:09 2010 -0500 Adjust config to pass with new options commit 2d1e4acc633a1ddf65d1f6a19c0c25ca29b8bbe8 Author: Ben Gardner Date: Sun Jul 25 19:09:41 2010 -0500 Add nl_func_def_paren, nl_func_def_start, nl_func_def_start_single, nl_func_def_end, nl_func_def_end_single, nl_func_def_empty commit 494715379a4b277fa72ff029ae9593f063125730 Author: Ben Gardner Date: Sun Jul 25 18:46:34 2010 -0500 Enhance tests for nl_func_def_args commit 462b272579de97a1140fd7a8fc7f3f3bb21ee198 Author: Ben Gardner Date: Sun Jul 25 18:45:35 2010 -0500 Add option nl_func_def_args, which is nl_func_decl_args for function defs. commit 022a9f957da6f907a07f492af2cdcbf9e3d7883b Author: Ben Gardner Date: Sun Jul 25 18:22:40 2010 -0500 Fix interaction between mod_case_brace and mod_move_case_brace commit 74b73e29483c52fba4b34decde389a837373fbc9 Author: Ben Gardner Date: Sun Jul 25 18:17:44 2010 -0500 Add more logging for inserting blank lines. commit 7449c779ffa8944adae43d4579515d1f1540de18 Author: Ben Gardner Date: Sun Jul 25 17:48:59 2010 -0500 Add option sp_func_call_paren_empty commit 033a4ff4fab8954f6f66e79245e550ef623dfe10 Author: Ben Gardner Date: Sun Jul 25 17:46:37 2010 -0500 Update tests for operator byref fix. SF bug #3023966 commit 54a60a6b912bfbd2fbe0366fe1907f4651d8c79f Author: Ben Gardner Date: Sun Jul 25 17:27:46 2010 -0500 Use column_indent for checking to see if a comment is off to the right. Fixed detection inside of switch statements. SF bug #3032787 commit e54a3e147d4e7f44a5f54a82e7c8469c819bf0c1 Author: Ben Gardner Date: Sun Jul 25 16:59:22 2010 -0500 Change operator tokens into a type before merging into CT_OPERATOR_VAL. Fixed SF bug #3023966. commit 508abd9c8fc41e14f0f498df27afa1234d8ec79b Author: Ben Gardner Date: Sun Jul 25 16:45:18 2010 -0500 Try to do a better job of handling struct/union bodies, reusing code. Fixes bug-3029014 commit 7425e9e102cc81381b366a814176e8914bede5f1 Author: Ben Gardner Date: Sun Jul 25 16:40:56 2010 -0500 Update test for bug 3029014 commit e2166d7634e28f44352bdab4e5d0e70cc8dd1606 Author: Ben Gardner Date: Sat Jul 24 11:45:31 2010 -0500 Add missing ChoicesReadable for lead_break, lead_force, etc. commit 931d0b7e5d381c9849695f1f56c3dd19fdea1e93 Author: Ben Gardner Date: Wed Jul 21 21:54:33 2010 -0500 Add a test for templates. Illustrates SF bug #3019852 commit d5f09b310e3ac6acb7cee023a16a8fe8d98f75d2 Author: Ben Gardner Date: Wed Jul 21 21:51:19 2010 -0500 Mark token after '+' as starting an expression Fixes SF bug 3032782 commit 07fc9a7e6179d77d0170ecadf66c285896f12542 Author: Ben Gardner Date: Fri Jul 16 17:16:24 2010 -0500 Add --frag option for indenting a code fragment. commit 5777fe7d9a354b074e579a18630f5e30b90bbea7 Author: Ben Gardner Date: Thu Jul 15 20:43:23 2010 -0500 Templates: Only split a '>?' if the '<' is at the top of the stack commit 9b77f5bfe4dd4593e3b5e0a9da64c252704b7b2c Author: Ben Gardner Date: Wed Jul 14 21:51:02 2010 -0500 Improve throw() handling. It is either like return or const. commit 73a33f4b4952992351d9e2c6ab05660b03a76c0f Author: Ben Gardner Date: Wed Jul 14 20:09:27 2010 -0500 Fix removal of braces when the body contains a braced statement + extra stuff commit 877bf9e44a20e8381ccd342d5f763789e12d10d9 Author: Ben Gardner Date: Tue Jun 8 07:53:44 2010 -0500 Increase the hard-coded template depth from 16 to 1024. commit aefb0814b43b59ca3abfbfc5366653efe065075c Author: Ben Gardner Date: Fri May 28 17:05:16 2010 -0500 Rebuild automake stuff after applying the last silent build patch. commit d2c438a56776a04c945972961a4cd11c96b9630b Author: Ben Gardner Date: Fri May 28 17:03:52 2010 -0500 Use silent rules instead of nostdinc A nice feature of automake is that it allows a VPATH build. That is, a build from outside the source tree. This is disabled in uncrustify via nostdinc in /src/Makefile.am. If the purpose of using nostdinc is to clean up the output of the build, I recommend using silent rules instead. commit 10ef222f462174a92d727f2afd669f346d0deb4c Author: Ben Gardner Date: Fri May 28 16:54:58 2010 -0500 Skip over CT_SPACE when looking for the chunk to align the open paren. commit 4b246dd11309323b446e31f4b75835f1289d471b Author: Ben Gardner Date: Fri May 28 16:18:22 2010 -0500 Close out the assign on a level drop inside a preprocessor. commit b120022d230e7c3e623269128ab27ea0838b8e11 Author: Ben Gardner Date: Fri May 28 15:41:20 2010 -0500 Clean up some minor (?) code issues. Tests still pass, so I doubt the code in question mattered too much. I'm sure someone will let me know if this change breaks something. commit 211a7366ea612ae18153b660a847f34ecd75ccf6 Author: Ben Gardner Date: Fri May 28 15:11:17 2010 -0500 Properly mark the return type of an operator function def/proto. commit f446787e4de9add6467646d3b17dcc9c50b2a157 Author: Ben Gardner Date: Fri May 28 14:44:28 2010 -0500 Update test to cover a class declaration with a macro before the class name. commit 56de0a62647e9fe5970e6ce5c5242af81be36006 Author: Ben Gardner Date: Fri May 28 14:43:24 2010 -0500 Handle macros in the class name, detecting the last word/type as the class. class MACRO foo { }; commit 84162ab363cb62b1e355d055aaaad23cf9b6429a Author: Ben Gardner Date: Fri May 28 14:24:05 2010 -0500 Reset the column after outputting the BOM. commit 5be5734967ad787c22d5e3a30d5c15d7646e8b6b Author: Ben Gardner Date: Mon May 17 18:23:44 2010 -0500 Clean up build and project files. Rebuild the makefiles. commit 3fce21b5dd8f61adf4aab3a8c71209e22d957452 Author: Ben Gardner Date: Mon May 17 18:21:09 2010 -0500 Reduce the number of places where the version needs to be manually entered. Automatically generate the man and version files. From: Ger Hobbelt commit efb84c2491d76b5f32e22b54561c69afb11796bf Author: Ben Gardner Date: Thu May 6 08:25:53 2010 -0500 Check for NULL to prevent a segmentation fault. Fixes Debian bug #580195. commit 9a25a81a035dd7c1fe3d25213be14b482d48465d Author: Ben Gardner Date: Sun Apr 25 16:49:26 2010 -0500 Fix newline handling between 'private:' and a constructor. Fixes bug 2983317 commit e635598c2ccf3a8d017bd2d88df59e3aa18326e4 Author: Ben Gardner Date: Wed Apr 21 07:56:03 2010 -0500 Fix spelling (paramter -> parameter) and regenerate the default configs. commit d256f0dfb9ec59b74d145da2b02bcbfc969980fa Author: Ben Gardner Date: Sun Apr 11 08:36:24 2010 -0500 Fix sp_paren_comma (was hard-coded to FORCE) commit a82bdbf9fa8b2f43340338329162ea61fde7496f Author: Ben Gardner Date: Tue Mar 30 19:03:11 2010 -0500 Do a better job of resolving '>>', '>=', '>>=' vs '> >' for templates. Affects C++ and C#. C# parses '>>' as two ANGLE_CLOSE and the logic must combine them when it is supposed to be a right shift. C++ parses '>>' as right shift and must peel off the leading '>' as needed. commit 7d5ef5c2d156b979ed1508ac1ad87ad4b40c39e6 Author: Ben Gardner Date: Tue Mar 30 18:59:57 2010 -0500 Add sp_angle_shift to control the space between two ANGLE_CLOSE. '>>' vs '> >' commit 48542c381460f20d5e5e4316e46c3a97d9d8fc35 Author: Ben Gardner Date: Tue Mar 30 18:07:47 2010 -0500 Make sp_cpp_cast_paren affect TYPE_WRAP. Example (assuming SLIST_HEAD is set as TYPE_WRAP): typedef SLIST_HEAD( , foo) foo_list_t; commit 495501c3a2e6e6450b4654b7524e4b87aee99775 Author: Ben Gardner Date: Tue Mar 30 18:00:46 2010 -0500 Add sp_paren_comma to handle the super-rare missing first argument in a macro. "typedef SLIST_HEAD( , foo) foo_list_t;" commit 2f37327eab974d6faa2148af43347eea9be653bd Author: Ben Gardner Date: Tue Mar 30 17:56:45 2010 -0500 For mod_full_brace_xxx, 'remove' must be done before 'add' to make 'force' work right. commit 174fc88607a0d4f0eb43bb66ccd7e5878bf33ebd Author: Ben Gardner Date: Tue Mar 30 17:55:34 2010 -0500 Label colons inside a function call as CT_LABEL_COLON commit 044aa182b0cc8ea2699345fc713dd672ec4c48c3 Author: Ben Gardner Date: Sat Mar 27 16:40:16 2010 -0500 Prep for version 0.56 commit bf91a0e8452d67043c1f173d4c3891ee5e28ac44 Author: Ben Gardner Date: Sat Mar 27 16:10:56 2010 -0500 Add sp_assign_default to control spacing around '=' in a prototype. commit 6a2668606926b8c5e11317438e5b5264578bed91 Author: Ben Gardner Date: Sat Mar 27 15:52:28 2010 -0500 Improve test for nl_func_type_name commit f85b85ca8d5eb24316dbab512bbbf6467b5ed280 Author: Ben Gardner Date: Sat Mar 27 15:46:53 2010 -0500 Improve align_oc_msg_colon_span with nested messages. commit 1eebba4b93bdb9e76ee0beff1c5c710b52025215 Author: Ben Gardner Date: Sat Mar 27 15:24:56 2010 -0500 sp_after_oc_at_sel_parens should not change space if followed by a square close. commit 18d8d2bba441dc81cf8f494bf3e6b689edebbe52 Author: Ben Gardner Date: Sat Mar 27 15:10:49 2010 -0500 Do a better job of labeling ObjC message statements. Examples: [class func: val name1: val1 name2: val2]; [class func: val : val1 : val2]; commit f099fadff2e38c28d2e0ad3d9b897dee19dc76f4 Author: Ben Gardner Date: Sat Mar 27 14:07:39 2010 -0500 Insert function comment after the access specifier. commit e2fd5395a37392dd0ec26a0acc402aee2fe28794 Author: Ben Gardner Date: Fri Mar 26 17:43:10 2010 -0500 Detect the C# using statement - using (xx) { } Add mod_full_brace_using and nl_using_brace commit 62a453f2c01f3a4938025c5750c485e4271c3310 Author: Emmanuel Christophe Date: Tue Mar 23 22:52:37 2010 +0800 Add test for indent_braces_no... options commit bd5f91f005dca20403680000b89b3fcbf5cb14d0 Author: Emmanuel Christophe Date: Mon Mar 22 22:18:09 2010 +0800 Add indent_braces_no_struct option commit feec2a8fd4572f81b5a2f38ce91a1237255885d4 Author: Emmanuel Christophe Date: Sat Mar 20 23:44:28 2010 +0800 Add indent_braces_no_class option commit b2354a0a0980bb827745372310b476b6c46afa45 Author: Ben Gardner Date: Mon Mar 8 19:29:00 2010 -0600 Add a script to build a win32 release zip on linux commit faec052dcf9bfbed8788a63e283917ef7901eadf Author: Ben Gardner Date: Mon Mar 8 17:52:20 2010 -0600 Use PRIx64 to show the flags, like is done everywhere else. commit 42b1ed31999d4926188acf881912b49958282dac Author: Ben Gardner Date: Fri Feb 19 21:55:58 2010 -0600 Add sp_inside_oc_at_sel_parens and sp_after_oc_at_sel_parens. Make some @selector options also apply to @protocol(). Set the PCF_IN_OC_MSG flag instead of changing the parent of everything inside a OC msg. commit b2bc11feb5717f553e16a074dee90195b3752bfb Author: Ben Gardner Date: Fri Feb 19 21:21:01 2010 -0600 Step back to a non-inserted token to get the backslash position. Fixes issue 2935688. commit 58d7dbd5d9a88ecaf47e9f6d17e7988f26a6491d Author: Ben Gardner Date: Fri Feb 19 20:59:29 2010 -0600 Fix mod_full_paren_if_bool interactions with ternary conditional (a?b:c) Fixes issue #2943323. commit 8909c9fc0c8f9f308c1ccef1bfc4cef5ce889d5d Author: Ben Gardner Date: Sun Jan 24 21:02:19 2010 -0600 Spelling: statment -> statement commit 5b4be42d368a2d8c049cd3361b1901649ec57c63 Author: Ben Gardner Date: Sat Jan 16 12:30:24 2010 -0600 Fix incorrect indenting inside enums. Bug 2930752. commit 10b633d6d50af6faf979953fd07f2aec5e0b7f6f Author: Ben Gardner Date: Sat Jan 9 11:09:56 2010 -0600 From: Mathieu Lacage Force uncrustify to respect the nl_func_leave_one_liners configuration option for constructors and destructors. i.e., if nl_func_leave_one_liners=True: Foo::Foo() {} is left as-is. Without this patch, it is transformed into: Foo::Foo() { } commit ba2bdf90a110bda22d5e865fadfd9db9afd2f74c Author: Ben Gardner Date: Tue Jan 5 21:16:19 2010 -0600 Don't mess with the position of a backslash-newline in a comment, unless in a preprocessor. commit 0578f7c5b5202481756c16bbd480ab4787f80961 Author: Ben Gardner Date: Thu Dec 31 13:33:18 2009 -0600 Change 'newline' to 'blank line' in some descriptions. Clarify an option description. -- Thanks Ronan (rdan) commit 921c1ca41e18772b1e70d90dc822508e2993221c Author: Ben Gardner Date: Thu Dec 31 13:31:35 2009 -0600 Add indent_first_bool_expr - Thanks to Ronan (rdan) commit e042712e0a623dd7db2df136fca4c391aa0fd9a2 Author: Ben Gardner Date: Thu Dec 31 13:15:55 2009 -0600 Update the vpj file commit 0796009c9f506159d19d12440595e6c9786b5d65 Author: Ben Gardner Date: Thu Dec 31 13:15:42 2009 -0600 Extend the pos_xxx options to have xx_break and xx_force options. xx_break adds a line break is one wasn't present and xx_force removes extra newlines so that there is either one before or one after. commit 49f7ce6dbdcf48aea20c114aaadc24afa4aca45a Author: Ben Gardner Date: Wed Dec 30 16:51:01 2009 -0600 Update template test for the latest fix. commit a9df57a0d1d2849d01121e04ecd7ffa104ebaac7 Author: Ben Gardner Date: Wed Dec 30 16:43:29 2009 -0600 Allow a function prototype to be wrapped in a function call at the top level. #define MACRO(a) a MACRO(void foo(void)); commit 38870ae909a97a4e6cc065437c23da70f977a678 Author: Ben Gardner Date: Wed Dec 30 14:15:48 2009 -0600 Indent ObjC msg declarations that span more than one line. commit 6a360a75b81c6e5e821d4711b0e2e8d375e7afa7 Author: Ben Gardner Date: Wed Dec 30 13:30:47 2009 -0600 Add option: align_oc_decl_colon commit d29556fc7ae373ed860842edee8d99163dbcf084 Author: Ben Gardner Date: Wed Dec 30 09:15:01 2009 -0600 Add a freebsd style test commit 096e5c1ce1cbf7df35146012ccce41e1f176e89d Author: Ben Gardner Date: Wed Dec 30 09:07:11 2009 -0600 Add indent_continue support to variable definition indenting. commit 09b97918833807fc7be2bc737d21ff4e98466ff6 Author: Ben Gardner Date: Wed Dec 30 08:50:33 2009 -0600 Update test results for recent change in nl_else_brace with regards to virtual braces. commit 74a1427b4c48c8cebeb192b635a184a5b7be941b Author: Ben Gardner Date: Wed Dec 30 08:47:59 2009 -0600 In if/for/while/switch/do/else statements, if a newline was added around the vbrace open, also add one around the vbrace close. commit 098fc1598fac6ea19b2328502dcdc919223352a6 Author: Ben Gardner Date: Wed Dec 30 08:46:52 2009 -0600 newline_add_before() and newline_add_after() should ignore virtual braces when checking to see if there is already a newline present. commit 541ca14b9226aad5184ebffba9ee463857ce0afc Author: Ben Gardner Date: Wed Dec 30 08:45:58 2009 -0600 New option: nl_after_vbrace_close commit cf53884b8a5b066aba1f5d82995eb7b2162337d6 Author: Ben Gardner Date: Wed Dec 30 08:03:10 2009 -0600 align_same_func_call_params: only align function calls that are right after a newline. commit 7e0dd190729658e3db8a64c408d83c7cac3fbe1d Author: Ben Gardner Date: Wed Dec 30 07:52:12 2009 -0600 If an exact option name match doesn't work, try comparing only alphanumeric characters. This will accept options that were copied from SF's broken web interface that have the underscore characters stripped. commit d66f78b95905e2680e378fe4dab5e68e1771fc30 Author: Ben Gardner Date: Tue Dec 29 15:00:01 2009 -0600 Enhance one-liner tests commit 3b8acea8a478238db3b27290efbace5fd9b19a86 Author: Ben Gardner Date: Tue Dec 29 14:46:38 2009 -0600 Make nl_if_brace, nl_else_brace, etc, able to insert a newline between the close paren and the "a++" in "if (foo) a++;". Will not do that if leave_xx_one_liners is true. commit bec510f9ce24a89c25df786266fdfce75f8abec9 Author: Ben Gardner Date: Tue Dec 29 14:29:16 2009 -0600 Mark virtual brace one-liners commit 1e86a51400bd99f94b120726f403f10e0f9996e8 Author: Ben Gardner Date: Tue Dec 29 13:58:51 2009 -0600 Mention that cmt_indent_multi disables keyword substitution in multi-line comments. commit e63d84a58f7f4f7e13553e5c49d011a5e2866d6f Author: Ben Gardner Date: Tue Dec 29 13:42:17 2009 -0600 Add tests for indent_var_def_cont commit 399530476d7280b7d5888dbae5a8a6a8979fa784 Author: Ben Gardner Date: Tue Dec 29 13:35:10 2009 -0600 Use an empty config instead of /dev/null commit aa5a2135aded6a19e7995b5072db6a18097dde73 Author: Ben Gardner Date: Tue Dec 29 13:27:24 2009 -0600 Add indent_var_def_cont and indent 'a' by one tabstop in 'int \n a, b, c;' commit e0cae88fb3559e4a60a7e22fee9d9ff67e03ac99 Author: Ben Gardner Date: Mon Dec 28 13:31:00 2009 -0600 Add option indent_var_def_cont commit f7891ea8ec39151cc23f52a22de6322c0e370daa Author: Ben Gardner Date: Tue Dec 29 13:24:02 2009 -0600 Variable definitions cannot appear in an enum commit 8d72d2210ef3c9fd080cffcb26f080e55b32d6a5 Author: Ben Gardner Date: Tue Dec 29 13:23:13 2009 -0600 Split the flag PCF_IN_ENUM, creating PCF_IN_STRUCT commit d55e99d732915ef38b2709b95dd7d00235bd3611 Author: Ben Gardner Date: Tue Dec 29 13:22:03 2009 -0600 Extend the flags variable to 64 bits commit 5c81851d01649f53ded1353d4471a5df27e4090d Author: Ben Gardner Date: Tue Dec 29 12:46:03 2009 -0600 Fix language check for PAWN and D enums. commit 992447afb354e34cd5b3cd3224c927fde113d6d9 Author: Ben Gardner Date: Mon Dec 28 11:31:03 2009 -0600 Expand test to cover nl_func_type_name with constructor variables. commit 7a3fe5a03884e7928d1cd5d3452d81f18b61490a Author: Ben Gardner Date: Mon Dec 28 11:29:54 2009 -0600 The fparen parent was being set too early, breaking proper handling of 'constructor' variables. commit 4d1c3f01cc6f056c8e4860145c8380ebf83ecc73 Author: Ben Gardner Date: Thu Dec 24 11:27:48 2009 -0600 Add LANG_CPP to 'foreach' commit 82b1ec3b5a705552b175fc80ee8d6c56e0edbd8c Author: Ben Gardner Date: Wed Dec 23 21:10:27 2009 -0600 Fix aligning '<<'. The code was too clever. commit 70363eb72ce236de774a89af0ca54195167078c4 Author: Ben Gardner Date: Wed Dec 23 20:42:10 2009 -0600 Make sp_before_dc handle any keyword before '::'. commit b18e56af0cdb1c312c30b7c84b449a3f9ea94d04 Author: Ben Gardner Date: Wed Dec 23 20:29:05 2009 -0600 Fix off-by-one problem with align_right_cmt_gap. Clarify what the option does. commit 3103fc2ff6163ba3c1b6bea0fe3c1f996d5946cc Author: Ben Gardner Date: Tue Dec 22 22:04:06 2009 -0600 Fix marking of a destructor commit bae94e27a383b7dfcc35147cdb7815608dad4121 Author: Ben Gardner Date: Tue Dec 22 20:17:45 2009 -0600 Split out and handle the Objective C '@protocol' commit a856c5fd63c1fb946cfbea2ac07199efdd7aa812 Author: Ben Gardner Date: Tue Dec 22 19:01:19 2009 -0600 Don't change PAREN_CLOSE to OC_CLASS_EXT commit df905852d2661f230151da2e55c15282115537a6 Author: Ben Gardner Date: Tue Dec 8 20:57:38 2009 -0600 Makefile.in is required to build with MinGW. commit c65e73ddc886f296e106e976df4dd800d9aefef2 Author: Ben Gardner Date: Tue Dec 8 19:10:07 2009 -0600 Change include of windows_compat.h so that it builds under MinGW/MinSys on Windows commit 714500275add5b811d4bc0604f1748b394f59cef Author: Ben Gardner Date: Sat Dec 5 22:20:42 2009 -0600 Finish removal of d.tokenize.cpp commit d99335251ac8974585c4e4763c1b724bc1b408d6 Merge: 3d40b0f 78d5e7c Author: Ben Gardner Date: Sat Dec 5 22:18:20 2009 -0600 Merge branch 'freebsd' commit 3d40b0f3ebe93eb333ca4ac6bb2f3dde03d37d93 Author: Ben Gardner Date: Sat Dec 5 22:10:34 2009 -0600 Update tests to reflect comment output improvements. commit b427544b4662856ffc0625a34e9e4690e4fe0077 Author: Ben Gardner Date: Sat Dec 5 22:15:54 2009 -0600 Add indent_cmt_with_tabs and rework the comment output code. commit 514d70eb81e80bc92f227a589a1e180437b73fdb Author: Ben Gardner Date: Sat Dec 5 21:59:54 2009 -0600 Clean up some aligning commit 6cb7a7ed7b759ff69846a34958213a212404c93d Author: Ben Gardner Date: Sat Dec 5 20:26:21 2009 -0600 Fix bug in align_tab_column() commit 8c63eb3ccb7b811bbfa3854d369407c2f15de511 Author: Ben Gardner Date: Sat Dec 5 18:25:43 2009 -0600 Filter out trailing spaces commit 78d5e7cbbdaef7aa3945885ccc69bc5bf8378323 Author: Ben Gardner Date: Sat Dec 5 22:10:34 2009 -0600 Update tests to reflect comment output improvements. commit 51c1f51f86cc4f79f8b0f050122035ec5599ddfd Author: Ben Gardner Date: Sat Dec 5 22:09:35 2009 -0600 Add indent_cmt_with_tabs and rework the comment output code. commit fe7e8204856a591cb89939619badf93489d4be2a Author: Ben Gardner Date: Sat Dec 5 21:59:54 2009 -0600 Clean up some aligning commit a5b683c4f644a9ba2ba5e9cf367903fd87eafb54 Author: Ben Gardner Date: Sat Dec 5 20:26:21 2009 -0600 Fix bug in align_tab_column() commit 622bb1cf4531bff6028e78de83ff367176cb9688 Author: Ben Gardner Date: Sat Dec 5 18:25:43 2009 -0600 Filter out trailing spaces commit 5e60ea5aa84dc60a3221026538d14995d8fb3b58 Merge: 837f579 72754d8 Author: Ben Gardner Date: Sat Dec 5 12:29:03 2009 -0600 Merge branch 'master' into freebsd commit 72754d8ce612b1f2e79a301bacd84456a410112a Author: Ben Gardner Date: Sat Dec 5 09:43:57 2009 -0600 Spelling corrections, thanks to Bill Cox commit 41086eb04d33d9c0589bdb9bf4d0c4b3e62692f7 Author: Ben Gardner Date: Sat Dec 5 09:40:12 2009 -0600 Add more patterns to .gitignore commit 837f579390c814f5969cc7fb539d14ead000a72b Author: Ben Gardner Date: Sat Dec 5 09:38:44 2009 -0600 save off work in the freebsd branch commit 2d39c44b4f8600600586213ae65584808c16ad14 Author: Ben Gardner Date: Sat Nov 28 20:31:37 2009 -0600 Add a start to the FreeBSD style (not yet perfect) commit c28ffcaeec772f85770e61c4ad09e4c994393272 Author: Ben Gardner Date: Sat Nov 28 20:18:03 2009 -0600 Add a note that the old K&R function declarations are not handled. commit 0bbae411beec75b78d368727aea2bdc61002d9be Author: Ben Gardner Date: Sat Nov 28 20:17:25 2009 -0600 Add option indent_continue commit ae7a414ff4f153d3aea6149b01dcfc412c3f4a4a Author: Ben Gardner Date: Fri Nov 27 21:54:47 2009 -0600 Update release step. commit 709abc9d725d5b95a031057f2ad143325b99220a Author: Ben Gardner Date: Fri Nov 27 21:46:26 2009 -0600 Save off auto-generated files. commit c842cf4d9515f6d52a7f1cf8e72a9269517585c3 Author: Ben Gardner Date: Fri Nov 27 21:46:07 2009 -0600 Missed some support files for Win32 and OSX commit f0e41e2ff8b0ba6782ee520f74748cb38a01f44f Author: Ben Gardner Date: Fri Nov 27 21:30:18 2009 -0600 Update the release steps. commit 22f60eb9e70b7162f879d3d5b4685b1692a516b5 Author: Ben Gardner Date: Fri Nov 27 21:29:50 2009 -0600 Update the default config files. commit fa38a4d0b356130780f2aafae4fa089dae7b0ea2 Author: Ben Gardner Date: Fri Nov 27 21:17:48 2009 -0600 Move changelog to the root so 'make dist' can pick it up. commit 3fec51af2bac389ec34e9817ae3b22c2b196e48a Author: Ben Gardner Date: Fri Nov 27 20:59:52 2009 -0600 Update vpj file commit 7a426d5c03d9ef6fd721bc4474b647ce01ff1540 Author: Ben Gardner Date: Fri Nov 27 20:59:27 2009 -0600 Makefile.in doesn't need to be checked in. commit ea1432b6691ad678e23b470eae7473ad6e3d9646 Author: Ben Gardner Date: Fri Nov 27 20:57:41 2009 -0600 Fix operator-related breakage in pawn. commit 2ca1ce44ccc6da68f254ef7d2f88c01c856050ae Author: Ben Gardner Date: Fri Nov 27 18:10:24 2009 -0600 Update makefile to get 'make dist' to work right. commit cdc226c38c2a0d87603f24cb72b61a4d40850b8a Author: Ben Gardner Date: Fri Nov 27 17:59:07 2009 -0600 Add the homepage URL commit 42ca2151714ef394392f929607b18e59a59707a9 Author: Ben Gardner Date: Fri Nov 27 15:32:29 2009 -0600 Run 'autogen.sh' on Ubuntu 9.10 commit 163dfc47d406c4d709271a75380575d16afae923 Author: Ben Gardner Date: Fri Nov 27 15:31:47 2009 -0600 Updates for release 0.55 commit 2daa03ce4df9479178d4c84c5965af895eb4d41d Author: Ben Gardner Date: Fri Nov 27 11:27:26 2009 -0600 Add nl_func_decl_start_single and nl_func_decl_end_single commit 18dba54313c8aea3e59593fdab2a7beeb01fe5e2 Author: Ben Gardner Date: Fri Nov 27 11:06:41 2009 -0600 Add new option: nl_after_vbrace_open_empty commit 285dd9175bab26d9f44538131852210a24de20ea Author: Ben Gardner Date: Fri Nov 27 10:30:49 2009 -0600 Fix possible out-of-bounds array access. commit 71daf98217f8ee4ade168f9cf786b99c119124f3 Author: Ben Gardner Date: Thu Nov 19 20:17:47 2009 -0600 'mutable' is a qualifier, just like const. Except different. commit 9855ec9cfd5b39daa35f389892cebcd48dd48452 Author: Ben Gardner Date: Thu Nov 19 20:08:54 2009 -0600 Update test commit 19463629dedebd2ac84d001ef6dbb4f419856654 Author: Ben Gardner Date: Thu Nov 19 20:05:15 2009 -0600 Don't insert a newline between a brace and comment for the else. commit d4270ec55aac03ad76b8816b07f2fcd7cc1ef15e Author: Ben Gardner Date: Thu Nov 19 19:42:51 2009 -0600 Fix test to reflect nl_struct_brace fix. commit 93be59cf4e1d56df7798a247a640edac14eecdb6 Author: Ben Gardner Date: Thu Nov 19 19:42:09 2009 -0600 pos_assign should not affect '=' followed by '{'. commit 3cda54e81789ccaf198ce498ed49d50c15464e56 Author: Ben Gardner Date: Thu Nov 19 19:30:47 2009 -0600 nl_struct_brace should not apply outside of a 'struct' declaration. // applies struct foo { int x; int y; }; // does not apply struct foo bar = { 5, 6 }; commit b209fe1639061db4a2f59b5bb1656ce64697dfbd Author: Ben Gardner Date: Thu Nov 19 18:55:53 2009 -0600 Change nl_create_if_one_liner to also work for 'else if' and 'else'. commit c20507f47e3d9db50e1d99eb91de9a4673955a17 Author: Ben Gardner Date: Sat Nov 14 18:13:33 2009 -0600 Fix align_on_tabstop commit e9c387ba3dd0f0d584156f12540d2668faafa635 Author: Ben Gardner Date: Sat Nov 14 18:13:21 2009 -0600 Fix align_with_tabs commit 90ca35b66e07ee5b9d695fde168eca016ee656c7 Author: Ben Gardner Date: Sat Nov 14 17:59:49 2009 -0600 Set PCF_WAS_ALIGNED when aligning chunks. commit 5c459ba07a32a2474522e31dd9873667fbd9ecde Author: Ben Gardner Date: Sat Nov 14 17:44:42 2009 -0600 Improve template test commit 405eb7bbd3c53b6b8daa48a2d79259e94d9b5941 Author: Ben Gardner Date: Sat Nov 14 17:44:21 2009 -0600 Add support for templates inside a #define Fixes SF bug #2887001 commit 619b83477d37796f591477c35bb2c70ca96a779f Author: Ben Gardner Date: Sat Nov 14 17:02:59 2009 -0600 Improve operator tests after recent bugfix. commit ef02353e0c7d20082bad9e2c9f5228f64a17c2d1 Author: Ben Gardner Date: Sat Nov 14 16:58:19 2009 -0600 Rework operator handling. Everything after the 'operator' keyword that is part of the operator type is put in one chunk. Fixes SF bug #2889468 commit f2941dd0dfa70431989d2d9f994532b3ac5aa019 Author: Ben Gardner Date: Sat Nov 14 13:32:23 2009 -0600 Improve test for nl_func_type_name commit b9f6aba423e6e08620ee83b7fe39d83f7b5bb823 Author: Ben Gardner Date: Sat Nov 14 13:31:58 2009 -0600 nl_func_type_name: Don't remove a newline after a brace open. Fixed SF bug #2889292 commit dc920c761a001e99305daf6d0531db50f0d47826 Author: Ben Gardner Date: Sat Nov 14 13:11:42 2009 -0600 Expand a test to include a destructor. commit 72846d01c88d2ab8a2843dffc97a3c04275e9608 Author: Ben Gardner Date: Sat Nov 14 13:11:01 2009 -0600 The destructor is part of the function name definition, not the type. Fixes SF bug #2892606. commit ce39ae62f6b69aaa86e4a6365bddb50b09083cad Author: Ben Gardner Date: Wed Nov 11 22:42:00 2009 -0600 Minor whitespace and comment changes Signed-off-by: Ben Gardner commit e28fc35ab98e7efe5449bbae1f9ae5a92ec1808a Author: rdan Date: Thu Nov 12 05:35:49 2009 +0800 Code updates to be able to run tests script in python under windoze with uncrustify compiled in debug mode with Visual C++ 2005 Signed-off-by: rdan commit b38dfb52efef5c703316bb9bcb33d64e1283b5ee Author: Ben Gardner Date: Sat Nov 7 13:36:36 2009 -0600 Clarify and rework sp_before_ellipsis. It only applies when after a non-punctuator. Fixes SF issue #2886991. commit ff4780d68465eb8b480a096c89310f85c5664f73 Author: Ben Gardner Date: Fri Nov 6 09:27:04 2009 -0600 Add new option sp_endif_cmt commit 0fb8f11ec1302854e408db82b9fa6aaebfab19aa Author: Ben Gardner Date: Fri Nov 6 07:49:24 2009 -0600 Update test to cover the bug where a close paren is added inside a preproc. commit 328aca7a107bdd9859079d431d71cabf2d52c037 Author: Ben Gardner Date: Fri Nov 6 07:48:25 2009 -0600 Fix SF issue #2892803. The close paren was being added inside a preprocessor line. commit ad62ea13b11112f478c5b8f9c974ae8a98820768 Author: Ben Gardner Date: Fri Nov 6 07:47:29 2009 -0600 Update SlickEdit project due to recent file deletions commit fc97bf3fb1396f7f2928ff59c0e74aabcfc91db2 Author: Ben Gardner Date: Thu Nov 5 17:46:27 2009 -0600 Do a little whitspace cleanup in make_token_names.sh commit 30297231a5cffd865db53ec007295163bf2b15ca Author: Ben Gardner Date: Thu Nov 5 17:44:52 2009 -0600 Add test for align_left_shift commit c8bba4c31bcc6e1956ee7519bcb037cbc07144ea Author: Ben Gardner Date: Thu Nov 5 17:44:29 2009 -0600 Fix align_left_shift with array indexes. Fixes #2887031 commit 0eef7440ba20893e8b895bacda426dd756fa2fdc Author: Ben Gardner Date: Thu Nov 5 17:42:01 2009 -0600 Remove unused files commit 011a65079177126b9e3c1d7c82e9c90594441e57 Merge: 80db493 d8e30f3 Author: Ben Gardner Date: Tue Oct 27 19:12:38 2009 -0500 Merge branch 'objc' Conflicts: src/align.cpp tests/run_tests.py commit 80db493b7f78d7ea9123c3a7a0b35a17597cc9c2 Author: Ben Gardner Date: Sun Oct 25 10:26:08 2009 -0500 Change exit value based on test results commit d8e30f3c3f11f867d52fe4c6b5e4fbeae5c05f7e Author: Ben Gardner Date: Sun Oct 25 10:22:30 2009 -0500 Add back in token_names.h - needed for Windows build, which cannot recreated it. commit 6ac52866038bb3000b4e0e825aaddf8587770d71 Author: Ben Gardner Date: Sun Oct 25 10:20:37 2009 -0500 Run uncrustify on its own code commit 264967863eaab7cd77dad767ffd2faf2bbc07724 Author: Ben Gardner Date: Sun Oct 25 10:10:16 2009 -0500 Run uncrustify on itself commit 5e696d6554fcec27f09ed244f1119cadcef52d89 Author: André Berg Date: Sun Oct 25 03:07:45 2009 +0800 Spelling fix. suprisingly -> surprisingly. Minor grammar tweaks. commit 809b47f672ee55915e203986a52633a26a762c30 Author: André Berg Date: Sun Oct 25 02:59:05 2009 +0800 Add OSX Xcode build & install instructions to README. commit d11d2dfbc83aa85ee9a6a06e7f86ac1f3a6f6221 Author: André Berg Date: Sat Oct 24 16:43:07 2009 +0800 Remove some unneeded left-overs. Shorten the more info url. commit adab7441278cf2f54712894fd2b1c0dce008dcfa Author: André Berg Date: Sat Oct 24 14:27:15 2009 +0800 Replace those pesky tabs in some config files with spaces. commit 305e94a0ced1ea2deb1169aa9322802b89c73b8b Author: André Berg Date: Sat Oct 24 14:26:27 2009 +0800 Update existing block tests to better demonstrate that spacing options work as intended. commit bdf8181f1a2a2251e465e646ec516a3ee22c8c72 Author: André Berg Date: Sat Oct 24 14:24:47 2009 +0800 Update existing test case which already was using blocks. commit dc82fcc501bbc75f00949d760c5a61da4a82acf3 Author: André Berg Date: Sat Oct 24 14:24:11 2009 +0800 Add and register more test cases for block caret spacing. commit 08678af3a74ef7e55949ecf358ae2fde99f17bcd Author: André Berg Date: Sat Oct 24 14:22:00 2009 +0800 Update objc.cfg file. commit 5e39d01fe8b4e7c63133c3853047843b3b40341a Author: André Berg Date: Sat Oct 24 14:19:50 2009 +0800 Add new options for space before and after a block pointer caret. commit 511bc74d7cb4cf17d7dccfaa8c953f7b73b281ed Author: André Berg Date: Sat Oct 24 13:06:29 2009 +0800 Add test cases for blocks. commit 2d7013d9290a7e60e18ed786d63a72e6931dcb98 Author: André Berg Date: Sat Oct 24 13:03:31 2009 +0800 Bug fix: Fix for detecting class category and extension parens. Was confusing type with parent_type earlier. commit b92b77b739d9b652071dbf8067f0cb19f6f9eb96 Author: André Berg Date: Sat Oct 24 12:49:32 2009 +0800 First (devel) version of changes for OC blocks support. - Register new chunk types in token_enum.h - Add early detection of block pointer caret to tokenize_cleanup.cpp - Do the marking in combine.cpp commit cb9c866934ff2937e59eebab7dfeb937de73f792 Author: André Berg Date: Thu Oct 22 00:24:41 2009 +0800 Bug fix: OC msg sends like [self class] are no longer marked as CT_CLASS. commit 1080cbdd00ee8b1535145d962265d16bb1bc85b2 Author: André Berg Date: Thu Oct 22 00:08:38 2009 +0800 Improvement: Change oc_msg_colon_align from boolean to span with number. Makes just much more sense that way. The align feature works great but a bit too aggressively since it would just go and align method calls happening at the very top of an enclosing method with method calls all the way at the bottom of the enclosing method. I think a span of 1 will fit what most Objective-C programmers use. Uptaded a lot of the oc test cases to test for this behaviour. Xcode project update: Add missing oc test cases. commit 0d8540ee1ab4f923e63474b31a355f467f47d1ae Author: André Berg Date: Wed Oct 21 19:33:19 2009 +0800 Update tests with real_world_file.m output. Make sure tests run cleanly. commit 257e93e999c2f8560160ebc4e42378665600bb6b Author: André Berg Date: Wed Oct 21 15:39:56 2009 +0800 Tests: Add a sample of real world objective-c code to the tests. This sample also includes blocks which currently are not marked in uncrustify. Will change that later. commit 8b97e6b3899da59c91e6ad4922da3d77cc63cbe7 Author: André Berg Date: Wed Oct 21 15:36:19 2009 +0800 Bug fix: line_len can become 0 here which subsequently causes a segmentation fault. This is a workaround because larger issues seem to be at stake as I have seen line to contain garbage value at some point half into the sentence. commit 7c44cc65fa378610d7f05230a3f128cd94504672 Author: André Berg Date: Tue Oct 20 00:47:31 2009 +0800 Fix for (Type **) problems in msg decls/specs. Fix for missing parent type inside msg decl/spec type parens: now correctly is OC_MSG_DECL/OC_MSG_SPEC. commit 80c7a10b4abca4e8fb583f49e9001fa1be002c8c Author: André Berg Date: Tue Oct 20 00:41:10 2009 +0800 Xcode project update: Rearranged some build scripts. Replaced some absolute group references with project relative ones. commit fe224a9c2ad6f11925539c0933f1cbcd63b74d33 Author: André Berg Date: Tue Oct 20 00:32:08 2009 +0800 Make run_tests.py return 0 on all success or 1 on failure. This plays better with shell script incorporating build systems. commit 441fa512bb0ef38217467ac4dd4b766345f485bb Author: André Berg Date: Tue Oct 20 00:24:17 2009 +0800 Add missing osx directory. commit 9884f5057576248f6014bb889b740f736ed25f6d Author: André Berg Date: Tue Oct 20 00:23:08 2009 +0800 obj.cfg again... dunno how that change got lost in the commit commit 4ac16b0c705a0a56c83be0fdcf47bbf4cbc9a30d Author: André Berg Date: Tue Oct 20 00:21:20 2009 +0800 Update objc.cfg. Add a few extra Xcode project specific entries to .gitignore. commit 344cf3524a5e6152668a168493339834a58ea946 Author: André Berg Date: Tue Oct 20 00:29:46 2009 +0800 Add new Objective-C test for a more complex method. Details follow... The complex_method.m test was showing a problem with method argument types in the form of (typeName **) where the first star would get parsed as ARITH and the the second star would get parsed as DEREF. I have a fix available, coming in one of the next commits. commit 67a83fb1248674908de7c8e14b82ac63a1032e9b Author: Ben Gardner Date: Sat Oct 17 14:33:18 2009 -0500 Clean up the home page. - add mention of Git - add FreeBSD ports link commit 23632dae52e5a30a8ff595d9bd9d6c6d2eede07a Author: Ben Gardner Date: Sat Oct 17 14:02:39 2009 -0500 Spelling fix: preceeded -> preceded commit fe25b6d06401b0a523e15a896831720c488bd5ce Author: Ben Gardner Date: Sat Oct 17 13:13:55 2009 -0500 Import r1644 from subversion uncrustify-uncrustify-0.76.0/coverity.sh000077500000000000000000000027071434072136500204460ustar00rootroot00000000000000#!/bin/sh # # ARGS: 1:remote # BRANCH=coverity_scan if [ -z "$1" ] ; then cat < .travis.yml git add .travis.yml git commit -m 'Copy coverity.travis.yml -> .travis.yml for coverity build.' git push -f $REMOTE $BRANCH git checkout master echo 'Finished.' uncrustify-uncrustify-0.76.0/coverity.travis.yml000066400000000000000000000031031434072136500221300ustar00rootroot00000000000000language: cpp sudo: required branches: only: - coverity_scan # Coverity stuff env: global: # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created # via the "travis encrypt" command using the project repo's public key - secure: "rHg6I3iGS/u7+sWDD0misaVVrmVy6sjTuTGp1NK5nxuoDBjZgJkXC61yIzhbbDywwt5lCTYhC1J08ljrfVl4OSblrQIy9ihSrOs2mA/SrPiKh5sB1B661Pd20GDK+hkLByrSyWR2UusgHxYly9KPykbo0wX7R0qdLJouv86Irx09SS+YggkQTiAxVD7dvxHagiZa609zau5sZvDDtmFs73nS+JAjRwj5iweSPO00ApHZSgIrhWMDCSoWXPEnOn8+Ruw02Eza0ArvceipuMtY5ju6kejQvgZ7l7y7nu4LwXUFxWE2z4C7lSTIjIk9cKGcEoSHAvTCAJor75AQY7NcMWq0MYNXj55e+CPzELBT5XCcR14CKirgOHaG7L9H7McvFdMTsmujkd61Qbxs9p2lro8nliFAvpG7yduuaF/XTCugzS8JwrPfq98mWgqhVO0ysowEsesOn0Bjo9XmjBUtjVJxg8hdq50XoVyWHnXLoEXgXLcRv4JFFfquvM5+nvd2pNxopTboO//KPsGIz1A1qCQ0g9ktaVM+be7wZzB6Lb3L2hnOdmTiNNirJXnNupwQF64ZUxmajyh3QF+SIcYEnoug+2X1bftC+qLKf2DkR4DwjCvWWVXAk0/Nn3ndfuKyGy8ZzUkHGw+BGjq5Z/SVC0l+AJ+y5UWtu8PNj+Bdtsw=" before_install: - mkdir $TRAVIS_BUILD_DIR/build - echo -n | openssl s_client -connect scan.coverity.com:443 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' | sudo tee -a /etc/ssl/certs/ca- script: true addons: coverity_scan: project: name: "uncrustify/uncrustify" description: "Build submitted via Travis CI" notification_email: {NOTIFICATION_EMAIL} build_command_prepend: "(rm -rf $TRAVIS_BUILD_DIR/build ; mkdir $TRAVIS_BUILD_DIR/build ; cd $TRAVIS_BUILD_DIR/build ; cmake -DCMAKE_BUILD_TYPE=Release $TRAVIS_BUILD_DIR)" build_command: "make -C $TRAVIS_BUILD_DIR/build" branch_pattern: coverity_scan uncrustify-uncrustify-0.76.0/documentation/000077500000000000000000000000001434072136500211065ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/documentation/Track.jpg000066400000000000000000000556661434072136500226760ustar00rootroot00000000000000JFIFExifII* Vo  d1ni|digiKam-6.4.0Track.pngdigiKam-6.4.0ohttp://ns.adobe.com/xap/1.0/ ICC_PROFILE lcms0mntrRGB XYZ  acspMSFTlcms-lcms h-2H۩] dmndjdeschdmddhwtptPrXYZdbXYZxgXYZrTRC gTRC  bTRC chrm$cprt!desclcms generated descsRGBdescsRGBXYZ =XYZ o8XYZ $XYZ bcurv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Kmcurv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Kmcurv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmchrmT{L&f\textno copyright, use freely 2Photoshop 3.08BIMAdigiKamF6.4.0C     #!)!$%'('+.+&.#&'&C   &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&o! }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?Ty6]\ILZI"RO`>u5:W-?fʻN@OGN@OKSU ='Je_'Je_SU,{N@OGN@OGX++eOW:W-?:W-?ʟ9c?tZ߅ ?tZ߅ =?_prǰd_ d_ {*ʾ`ҿi~(ҿi~(T}2/Q2/Q*='Je_'Je_SU,{N@OGN@OGX++eOW:W-?:W-?ʟ9cǸ֧Cm +*J$D^|i/6yVnqq3R ( ( (<4an_znn-෸6 rynWz|PHĽWfYҼI[J]l9-v3!*zK .[]K9`JRAg#El-,0/CMr+eߔKcZ %v sQI _@Zov揦Mc'W?t%YF.WoFwMufEucS%+xvY` )V^nlu5n4ʷX&"Xe`3';~n#[kajPSiGg7u嶞fO8uF$<mO~RJ[{UĨ42@ia%Z/1vͣf9oŕJ3 4k{UΞYa2FW2tCl/EG,O^bGfu(6 ϵZ7h,O; pX@w$ 4^r-r[i+!//@M5EHFg![ӛѽ6v-wٵ{xte4v|V=ou/|Wiv`)oongVs'1qɫj.⛋m.-uHhgDb bdJO v_GQjރ9.a+4hљA}NAT!}vO: [6;W6[iV%ym#h3;rߦ u]t?Xh~,[La$JtEbgVf'kc#Sh^7[ %ӯ)ݫ$,௔á `x'O$fndYIQ̻N6G@ m/U,KݮD.ŋHy=OZ~f2ɺH(]>OK5B딘9@ׇ|[{N`V6DNK̘?@n+P-gkZ]\'e 8Ep\Oovs;gֻRԴ7?`Ôaq? ( ( ( (d9j1%u)"2 ; {HKXr-<fڤw\jkXF T|޽sZ ݵ,򘍏7ni_at$fEޏ.i X@ p cDRo.ny767 :F:hQYiek'v9#gv0m8Ͻ$>YeӒDIbtfd`z0;p ORſ,-絙&-k=˃$ccNMg$T=ޞY[KuEc. 6w FFhll7we :$@3s/cI%ot-Bne8;nP?zC1gw̏df1[TQ@Q@Q@Q@q%2¦*PG{EPEPEPEPEPEPEP=ZCãD &FTQh{r4}ϵ>׿/@^Mh{r4}ϵ>׿/@^Mh{r4}ϵ>׿/@^Mh{r4}ϵ>׿/@^Mh{r4߱ Sr+eEό*V=Hn36} @jG!K:ч%8l+$p!?Q@Q@Q@Q@G<ː[ :NDgȷsԿ獷o"#R6#=%e^=A2\d㟡9jZ*-{ ;{ErVmD5U<8']OjWc[Λ[.rrx}P3cynoJ^x?>~[g_-ݓ}?׶~tPE^?/'u_=TyN%d/yal.A|De Vu}jͥ [˸aq5ZCgWdKݙH}߉JԵSn$YV"H%*K aցfOi0[j72Lʺ-8uC |MidhbLY%+pzg8ⶨZ[Sdt6F 3I]+C[deʕܬ2qV*iْ iv_M@IaHg8.Khjᐺy  gWU<1(eܥN 掗˘l&}AI#`I砢Xn|3ƲF#rpyh@5~|%f3_F^>-ת9/izf IӭtsY ' ( 5MO61&]>s |wwjVviZ~"<8vhpSMb>m"YU#BAZo+m$m[$;|O>/kK8s|izOiOw <%egP?LIfe~̾ɯ)/ny_ٟؗ?_eϕ|VosU ӳ)~w(^~u N*ݽ[&(?[Rkm"m2 !fgy܊讧7MFFx𮫧híCcoj[ZV~3'uTI/Lw#f2-J5csa}&햚v,7R?h-;l# ?W/o2o]O@A$=}SM Nʞ-]MDknt 768m]y _844}6ZմˏmM඀l;2?zb+d|bhlڊ򂭱G8К%^nѷ8'嬮yuMWAYXzz];Ju?{8Af=O5{i !qۧkB2.IGuWG~zՊ*Kh-"Ihj(#мCGW_?hlVa.YĒ:ע8|:A_Oj|Vcf6R8=hív+"wp87qU 1h (פIր45K ]SO?2 k.qXGOv5t-FY3\\p̒L aZQ@Z[Ygw o:6zMVOF$ ~T6Y°[0ASEť %!f*TG@~ k,em$^T֏rY ) *qZֶZkmPG/EP0Bՙ R ˻U[Xv$ʖ*ȫ %!  …OEPUu >Q87ޫ 34ӳMtIS?e|41M-Ƨ$]Xf(\ ҽ}2Bu*r&A1|G8c-5"mbtNO@yFwVȊ0dP}-oG4}-oG4}-oG4}-oG4/4۲ 2 .T^l(Um[ͲkTy_o o*6PQ5wZ]HtOŮeAmosmGIyrE6Ohq3RXIȜl2zuNU#]_<"No{~fE4sqױ*ŵ#ف4 u.?{JbpEΜnvrct_hz՞y]K$:s|Ybh  X@9w=GA^K wxci2Ȭ YPm?#žnC%<!92 ~ i8'x$` g8=9}WoGOk{_}~mz ޽_i7;{3}*oH/`joxt^ZY-v]F-4BB3}:#R3*zL%jTh鮝v,?e}M$ 2X.|x UIOql29އR1ꂆ"7u3n(((((oKWL~X5 uH^@Q@G[³ Krw;B4G;'~u$i>gp3CIe G /'r3'qwk*Q,u} ƶMg)e ]Eo&Ȃ0-'8nF{Y<1j:7!2+,p%ޱDd1s*|c~OO>M;~SfdI-MKihka# kd,f%x=gukl6܍EȵfsІj'M.? QUե%ץ^=KO'uM]Mc&*1)L[˂0w8mυ/f ,$r@pKg.TkAVo̓O_Lvo:=+,Im dx[r >cE G5Ɲ[.ϣ]FE$EhrG,;]Q?Ò3nqkúit쥽/-֛4B$NxpzO\t{?=NoO?TNg{ 4i>OG09?hӛ}S&:=a$sϪ7?Mt{?H?TNoO?i>OG4ia ӛ}S&9?hӣA7?MsϪG?=NoO?TNg{ 4i>OG0=Ïnrg8ZUBkǚ&S +r0+~ger=30Ǖ ( ( ( ( C<.#XfcX~ExPQ@Q@Q@Q@Q@/G(P<2>jHAfeGRrEHQ@Q@Q@?ɿj3_?S<G}q‘ɋ]VH Ja_䎝뵑VٕdeYP$g A6N1k㻹x>9buai2Hћ= $vXrZڍU([mX+jW1v'7p^Mim$,jOߗ|OۛOf >zv(Y.jX1L,W[`=˿<<9ڽ M7UfԮ.۽xw7'USjQ+[LO[Hl`8 tx Q<{yxh~x=5`-!v8Ymw.:]~Mj:ffKlbH }(8if@w_TЅo׫¿Ws-O#8&+*Y8 *PEPEPEPx\&F~:LM[ñjMSQ6sͱITB1wq b;fG?#@>ZjltrP|5=sSO5d`c`c;TX.mRI9,Jy9nd*ġnw>3kBWܶ˖C< DͦEe,+D%a~MEZ_2Wn^[=9i&,8=8'm1mZR]M0 px}hEu+\Gp@9ު7z)೽HZW@$pX;Lj[u{/ q\A}q&1qz}Al)GRAM+ u-*w.ԒI9VV9|ƝBlKgLXT n+pȴ]BJW"fR('GOZ^-փ̏ aH粒ӭ&fF9ag>߱Gج(A~bH?ؠV}} bYϤQ+?>g>߱Gج(A~bH?ؠV}} bYϤQ+?>g>߱Gج(A~bH?ؠK[hA.txt Tracking puts a red "M" in the source to show where the options are working. A tracking number is used and written in the Track.html file and the output file A.txt to make possible to link the changes together. An example: tracking.cpp { a = b + 111-55; } The config file: indent_with_tabs = 0 sp_arith = force sp_assign = force The tracking file is: Uncrustify: where do the Spaces options work 

{
        aM=M<
/a>bM+M<
/font>111M-M55M;
}
Use it with a browser and you can see the red "M"s. Let put the cursor on the "M"s, and you see the tracking number and the option used. (look at the picture track.jpg) uncrustify-uncrustify-0.76.0/documentation/align-thresholds.txt000066400000000000000000000133661434072136500251270ustar00rootroot00000000000000------------------------------------------------------------------------------- Alignment thresholds: Alignment threshold are used to prevent aligning of certain text. Consider this example when aligning assignments: a = 2; gld.settings[somevariable] = 5; Without thresholds, this would result in: a = 2; gld.settings[somevariable] = 5; However, this is likely not desired. So to handle this, we set a limit on the number of columns that a alignment may move a token. If we set the threshold to, say, 3 characters, then the two would not be aligned together because 'a = 2' would have to be moved by 25 columns. Here's a more complicated case: a = 1; bb = 2; ccc = 3; dddd = 4; eeeee = 5; ffffff = 6; In this case, we may want this output: a = 1; bb = 2; ccc = 3; dddd = 4; eeeee = 5; ffffff = 6; But, with a threshold of 3, 'a' and 'ffffff' cannot be aligned together. So how should these thresholds be implemented? One approach is to use the threshold as the maximum difference between the current maximum and the new maximum. Using this approach, all 6 lines above are aligned, because the change for each is 1 column. Consider this with a line-span of 3 and a column-threshold of 3. Note that we'll now need to keep track of the last line processed. (line and column numbers added for clarity) 111111 123456789012345 --------------- 1 | a = 1; 2 | eeeee = 5; 3 | ffffff = 6; On line 1, the maxcol is set to 3. On line 2, the maxcol would be set to 7, except that exceeds the threshold. On line 3, the maxcol would be set to 8, except that exceeds the threshold. So, it ends up with one item in the align stack - line 1. Then we pick up from where we left off - on line 2. On line 2, the maxcol is set to 7. On line 3, the maxcol is set to 8. End result: 111111 123456789012345 --------------- 1 | a = 1; 2 | eeeee = 5; 3 | ffffff = 6; Now lets get tricky. 111111 123456789012345 --------------- 1 | a = 1; 2 | eeeee = 5; 3 | ccc = 3; 4 | ffffff = 6; How should this be aligned? I think we need to add another list - a 'skipped' list, that runs in parallel with the 'aligned' list. On line 1, the maxcol is set to 3, added to the aligned list. On line 2, col exceeds the threshold, so it is added to the skipped list. On line 3, the maxcol is set to 5, added to the aligned list. Now, after an item is added to the aligned list, the skipped list must be re-scanned. We now see that line 2 is only 2 columns different, so it is added and maxcol = 7. The skipped list is now empty. On line 4, the maxcol is set to 8, added to the aligned list. So the output is: 111111 123456789012345 --------------- 1 | a = 1; 2 | eeeee = 5; 3 | ccc = 3; 4 | ffffff = 6; Now for a case where the skipped list is not absorbed: 111111 123456789012345 --------------- 1 | a = 1; 2 | iiiiiiiiiiiiieeeee = 5; 3 | ccc = 3; 4 | ffffff = 6; On line 1, the maxcol is set to 3, added to the aligned list. On line 2, col exceeds the threshold, so it is added to the skipped list. On line 3, the maxcol is set to 5, added to the aligned list. Skipped list is scanned, nothing moved from the skipped list to the aligned list. On line 4, the maxcol is set to 8, added to the aligned list. So the output is: 111111 123456789012345 --------------- 1 | a = 1; 2 | iiiiiiiiiiiiieeeee = 5; 3 | ccc = 3; 4 | ffffff = 6; As a reminder, the old system would have produced: 1 | a = 1; 2 | iiiiiiiiiiiiieeeee = 5; 3 | ccc = 3; 4 | ffffff = 6; Which is probably not wanted. --===---===---===---===-- Absolute thresholds To get a better grip on what thresholds do the absolute thresholds were introduced. An absolute threshold means that the item, in this case the assign statement, is never moved more than the threshold value. See the below example: Relative threshold = 10 000000000111111111122222222223 123456789012345678901234567890 1| a = 1 2| aaaaa = 1 3| bbbbbbbbbbb = 2 4| ccccccccccccccccccccc = 3 Absolute threshold: 000000000111111111122222222223 123456789012345678901234567890 1| a = 1 2| aaaaa = 1 3| bbbbbbbbbbb = 2 4| cccccccccccccccccccc = 3 --===---===---===---===-- How to do this generically in the code... Easy case - one item per line. An AlignStack is used to manage alignment. Here are the functions and what each of them do: AlignStack::Start(line_span, col_thresh) AlignStack::Add(pc) AlignStack::Flush() AlignStack::Newline(count) AlignStack::End() For each entry, a sequence number is kept. AlignStack::Start(line_span, col_thresh) - initializes the align and skipped lists - zero max_column - zero cur_seqnum - zero nl_count AlignStack::Add(start, seqnum) - update cur_seqnum, assign to item - if item column is within threshold - zero nl_count - add to the aligned list - if item column is > max_col - update max_col - re-adds all items on the skipped list - if item column is not within threshold, add to skipped list AlignStack::NewLines(count) - adds count to nl_count - if nl_count > line_span, call AlignStack::Flush() AlignStack::Flush() - step through all the items in aligned list and align the items to max_column - keep the seq_num of the last aligned item - zero max_column - remove all items with a seq_num < last aligned seq_num - call AlignStack::Add on all remaining items in the skipped list AlignStack::End() - call AlignStack::Flush - clear the lists - free resources, etc Example usage: see align_assign function in align_assign.cpp Chunk *align_assign(Chunk *first, size_t span, size_t thresh, size_t *p_nl_count); uncrustify-uncrustify-0.76.0/documentation/control_the_spaces.txt000066400000000000000000000016131434072136500255260ustar00rootroot000000000000002021-01-23 Guy Maurel The do_space function within the file space.cpp controls the space between every two tokens. There are three categories of actions. The first one is the most important. Options control what is to do with the interval between the two token: * "Ignore" means do not change it. * "Add" in the context of spaces means make sure there is at least 1. * "Add" elsewhere means make sure one is present. * "Remove" mean remove the space/brace/newline/etc. * "Force" in the context of spaces means ensure that there is exactly 1. * "Force" in other contexts means the same as "add". For example the option "sp_before_assign": Add or remove space before assignment operator '=', '+=', etc. in such a statement: a =5; The second categorie is used for all positions where no option is coded. The third categorie is a debug for the developer, who still have something to do. uncrustify-uncrustify-0.76.0/documentation/dump-steps.txt000066400000000000000000000046711434072136500237600ustar00rootroot00000000000000 This file describes the purpose of the 'dump steps' command line option. OVERVIEW -------- The '-ds/--dump-steps' option instructs uncrustify to log a lot of debug information throughout the formatting process, which can be very useful when trying to understand why something is being formatted in the way it is. This is usually the case when the expected results do not match with the actual ones. COMPARISON WITH '-p' OPTION --------------------------- While the '-p' option only prints the parsing information at the end of the process, the '-ds' option will print the same information at many points in time, providing extra depth to users and developers when troubleshooting an issue. GENERATED FILES --------------- Add '-ds FILE' to the command line options to enable the functionality. This will create a number of files as follow: - FILE_000.log: this file contains the list of the options used by uncrustify - FILE_001.log: this file lists the parsing status after uncrustify has read the input file and before starting the formatting process. - FILE_002.log: this file lists the parsing status before uncrustify enters its first internal while loop - FILE_AAA.log - FILE_BBB.log: a variable number of files, depending on the progress of the formatting process. Each file is printed at the end of one iteration of the first internal while loop. - FILE_BBB+1.log: this file lists the parsing status before uncrustify enters its second internal while loop - FILE_BBB+2.log - FILE_CCC.log: a variable number of files, depending on the progress of the formatting process. Each file is printed at the end of one iteration of the second internal while loop. - FILE_CCC+1.log: this file lists the parsing status at the end of the process. NOTE: by combining FILE_000.log and FILE_CCC+1.log, you will get the same content of the parsing file obtained with the '-p' option. USAGE ----- Comparing each file with the previous one will help understanding why something is being formatted the way it is. When debugging a formatting issue, this provides a quick way to restrict the section of the code that should be investigated. The first line of each file contains a brief descriptive string which can be used to quickly find the point in the code where the file was created. Look for 'dump_step(dump_file, )' in src/uncrustify.cpp. uncrustify-uncrustify-0.76.0/documentation/example.c000066400000000000000000000033631434072136500227120ustar00rootroot00000000000000 const char *token_names[] = { [CT_POUND] = "POUND", [CT_PREPROC] = "PREPROC", [CT_PREPROC_BODY] = "PREPROC_BODY", [CT_PP] = "PP", }; int main(int argc, char *argv[]) { struct junk a[] = { { "version", 0, 0, 0 }, { "file", 1, 150, 'f' }, { "config", 1, 0, 'c' }, { "parsed", 25, 0, 'p' }, { NULL, 0, 0, 0 } }; } color_t colors[] = { { "red", { 255, 0, 0 } }, { "blue", { 0, 255, 0 } }, { "green", { 0, 0, 255 } }, { "purple", { 255, 255, 0 } }, }; struct foo_t bar = { .name = "bar", .age = 21 }; struct foo_t bars[] = { [0] = { .name = "bar", .age = 21 }, [1] = { .name = "barley", .age = 55 }, }; void foo(void) { int i; char *name; i = 5; name = "bob"; } /** * This is your typical header comment */ int foo(int bar) { int idx; int res = 0; // trailing comment // that spans two lines for (idx = 1; idx < bar; idx++) /* comment in virtual braces */ res += idx; res *= idx; // some comment // almost continued, but a NL in between // col1 comment in level 1 return(res); } // col1 comment in level 0 #define foobar(x) \ { \ for (i = 0; i < x; i++) \ { \ junk(i, x); \ } \ } void foo(void) { switch(ch) { case 'a': { handle_a(); break; } case 'b': handle_b(); break; case 'c': case 'd': handle_cd(); break; case 'e': { handle_a(); } break; default: handle_default(); break; } } uncrustify-uncrustify-0.76.0/documentation/goals.txt000066400000000000000000000013141434072136500227530ustar00rootroot00000000000000------------------------------------------------------------------------------- Goal: Do as little or as much reformatting as desired - everything should be configurable Features: Whitespace modifications + Indent code (tabs, tabs + spaces, spaces) - brace indenting - paren continuation - '=' continuation - broken string continuation - comment indenting + Add/Remove spaces before/after/between symbols + position braces (same line, cuddle else/while, etc) Non-whitespace modifications + Put a '*' on the left in multi-line C comments + Add/Remove outter-most parens on return expressions + Add braces for 'fully braced' format (TODO: update the list to include more available features) uncrustify-uncrustify-0.76.0/documentation/how_to_configure_options.txt000066400000000000000000000020601434072136500267600ustar00rootroot00000000000000Here are some suggestions on how to familiarize yourself with the various options that uncrustify offers. 1. Read through default.cfg config file. This lists all the available options and a brief description of what they do. 2. Create an empty config file or make a copy of the default.cfg file 3. Looking at the file default.cfg, add or change one or more options in the config file created in 2. and test the result. 4. Iterate step 3. over and over changing just a few options at a time till the required output is reached. Working on one option at a time will give the best results. It is recommended to use a backup-update-compare cycle to ease your testing. 1. save a copy of the last configuration and the last output 2. modify the config file 3. run uncrustify again on the original unmodified files with the new configuration 4. compare the new output with the saved one to see the effects of the changed configuration. If you discover an issue or you need some extra functionality, please report an issue at https://github.com/uncrustify/uncrustify/issues uncrustify-uncrustify-0.76.0/documentation/how_to_format_cpp_lambda_functions.rst000066400000000000000000000043441434072136500307460ustar00rootroot00000000000000################################# Formatting C++ Lambda Expressions ################################# Uncrustify supports some formatting of c++ lambda expressions, although the support is incomplete. The parts of c++ lambda expressions that are currently recognized by Uncrusitify are: .. code-block:: c++ [ captures ] execution_context ( params ) specifiers -> ret { body } Explanations for all the tokens in the above lambda expression (except for ``execution_context``), as well as a complete description of c++ lambda expressions, are found `here `_. The ``execution_context`` token is a non-standard addition to allow for specification of the execution space (e.g. host or device in CUDA). The native specifiers for the `execution_context` for lambda expression in CUDA are ``__device__`` and ``__host__ __device__``. However, it is common for code to use a preprocessor variable in place of the native specifiers. The Uncrustify options for formatting of c++ lambda expressions are: .. code-block:: sp_cpp_lambda_assign sp_cpp_lambda_square_paren sp_cpp_lambda_square_brace sp_cpp_lambda_paren_brace sp_cpp_lambda_fparen nl_cpp_lambda_leave_one_liners nl_cpp_ldef_brace indent_cpp_lambda_body indent_cpp_lambda_only_once Please refer to the example configuration file at `uncrustify/documentation/htdocs/default.cfg `_ for an explanation of the options. Additionally, a multiple number of ``execution_context`` tokens may be set in the configuration file: .. code-block:: set EXECUTION_CONTEXT __host__ __device__ set EXECUTION_CONTEXT DEVICE_LAMBDA_CONTEXT HOST_DEVICE_LAMBDA_CONTEXT The effect of these lines in the configuration file is that any of the strings (``__host__``, ``__device__``, ``DEVICE_LAMBDA_CONTEXT``, ``HOST_DEVICE_LAMBDA_CONTEXT``) will be recognized by uncrusitfy and will allow the lambda to be properly identified. Note that each word after the token name (``EXECUTION_CONTEXT`` in this instance) is a separate token. This means that uncrustify will parse ``__host__`` and ``__device__`` as separate tokens, and there is no need to specify ``__device__`` twice. uncrustify-uncrustify-0.76.0/documentation/htdocs/000077500000000000000000000000001434072136500223725ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/documentation/htdocs/align_typedef.html000066400000000000000000000070041434072136500260730ustar00rootroot00000000000000 Uncrustify: The align typedef options

align_typedef

align_typedef_span

The span for aligning single-line typedefs (0=don't align)
original
align_typedef_span=0		 align_typedef_span=1 align_typedef_span=2 
typedef int MY_INT;
int a;
typedef int      *MY_INTP;
typedef float  My_Float;
no alignment 
typedef int MY_INT;
int a;
typedef int   *MY_INTP;
typedef float My_Float;
The third line is not catch in the span 
typedef int   MY_INT;
int a;
typedef int   *MY_INTP;
typedef float My_Float;
all the lines are catched

align_typedef_gap

The minimum space between the type and the synonym of a typedef
Can be only used if align_typedef_span >= 1
original
align_typedef_span=2		 align_typedef_gap=1 align_typedef_gap=3 
typedef int   MY_INT;
int a;
typedef int   *MY_INTP;
typedef float My_Float;
as above 
typedef int   MY_INT;
int a;
typedef int   *MY_INTP;
typedef float My_Float;
no change 
typedef int     MY_INT;
int a;
typedef int     *MY_INTP;
typedef float   My_Float;
the gap has 3 spaces

align_typedef_star_style

Controls the positioning of the '*' in typedefs.
0: Align on typedef type, ignore '*'
1: The '*' is part of type name
2: The '*' is part of the type, but dangling
original align_typedef_gap=3
align_typedef_star_style=0		 align_typedef_gap=3
align_typedef_star_style=1		 align_typedef_gap=3
align_typedef_star_style=2		 
typedef int MY_INT;
int a;
typedef int  *    MY_INTP;
typedef float  My_Float;
no alignment 
typedef int     MY_INT;
int a;
typedef int *   MY_INTP;
typedef float   My_Float;
the star is ignored 
typedef int     MY_INT;
int a;
typedef int     *MY_INTP;
typedef float   My_Float;
the star is part of type name 
typedef int     MY_INT;
int a;
typedef int    *MY_INTP;
typedef float   My_Float;
the star is part of type name, but dangling

align_typedef_func

How to align typedef'd functions with other typedefs
0: Don't mix them at all
1: align the open paren with the types
original align_typedef_gap=3
align_typedef_star_style=1
align_typedef_func=1		 
typedef int MY_INT;
int a;
typedef int  *    MY_INTP;
typedef float  My_Float;
typedef int      (*foo_t)(void *bar);
typedef int          (*somefunc_t)(void *barstool);
no alignment 
typedef int     MY_INT;
int a;
typedef int     *MY_INTP;
typedef float   My_Float;
typedef int     (*foo_t)(void *bar);
typedef int     (*somefunc_t)(void *barstool);
uncrustify-uncrustify-0.76.0/documentation/htdocs/ben.cfg.txt000066400000000000000000000070761434072136500244470ustar00rootroot00000000000000# # My favorite format # newlines = LF # AUTO (default), CRLF, CR, or LF indent_with_tabs = 0 # 1=indent to level only, 2=indent with tabs input_tab_size = 8 # original tab size output_tab_size = 3 # new tab size indent_columns = output_tab_size # indent_label = 0 # pos: absolute col, neg: relative column indent_align_string = False # align broken strings indent_brace = 0 indent_class = true nl_start_of_file = remove # nl_start_of_file_min = 0 nl_end_of_file = force nl_end_of_file_min = 1 nl_max = 4 nl_before_block_comment = 2 nl_after_func_body = 2 nl_after_func_proto_group = 2 nl_assign_brace = add # "= {" vs "= \n {" nl_enum_brace = add # "enum {" vs "enum \n {" nl_union_brace = add # "union {" vs "union \n {" nl_struct_brace = add # "struct {" vs "struct \n {" nl_do_brace = add # "do {" vs "do \n {" nl_if_brace = add # "if () {" vs "if () \n {" nl_for_brace = add # "for () {" vs "for () \n {" nl_else_brace = add # "else {" vs "else \n {" nl_while_brace = add # "while () {" vs "while () \n {" nl_switch_brace = add # "switch () {" vs "switch () \n {" nl_var_def_blk_end_func_top = 1 nl_before_case = 1 nl_fcall_brace = add # "foo() {" vs "foo()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" nl_after_return = TRUE nl_brace_while = remove nl_brace_else = add nl_squeeze_ifdef = TRUE pos_bool = trail # BOOL ops on trailing end eat_blanks_before_close_brace = TRUE eat_blanks_after_open_brace = TRUE mod_paren_on_return = add # "return 1;" vs "return (1);" mod_full_brace_if = add # "if (a) a--;" vs "if (a) { a--; }" mod_full_brace_for = add # "for () a--;" vs "for () { a--; }" mod_full_brace_do = add # "do a--; while ();" vs "do { a--; } while ();" mod_full_brace_while = add # "while (a) a--;" vs "while (a) { a--; }" sp_before_byref = remove sp_before_semi = remove sp_paren_paren = remove # space between (( and )) sp_return_paren = remove # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = force # "{ 1 }" vs "{1}" sp_inside_braces_struct = force # "{ 1 }" vs "{1}" sp_inside_braces_enum = force # "{ 1 }" vs "{1}" sp_inside_paren = remove sp_inside_fparen = remove sp_inside_sparen = remove sp_inside_for = remove sp_inside_square = remove #sp_type_func = ignore sp_assign = force sp_arith = force sp_bool = force sp_compare = force sp_assign = force sp_after_comma = force sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" sp_func_class_paren = remove sp_before_angle = force sp_after_angle = force sp_inside_angle = remove sp_sparen_brace = add sp_fparen_brace = add sp_after_ptr_star = remove sp_before_ptr_star = force sp_between_ptr_star = remove align_with_tabs = FALSE # use tabs to align align_on_tabstop = FALSE # align on tabstops align_enum_equ_span = 4 align_nl_cont = TRUE align_var_def_span = 1 align_var_def_thresh = 12 align_var_def_inline = TRUE align_var_def_star = TRUE align_var_def_colon = TRUE align_assign_span = 1 align_assign_thresh = 12 align_struct_init_span = 3 align_var_struct_span = 99 align_right_cmt_span = 3 align_pp_define_span = 3 align_pp_define_gap = 4 align_number_right = TRUE align_typedef_span = 5 align_typedef_gap = 3 cmt_star_cont = TRUE uncrustify-uncrustify-0.76.0/documentation/htdocs/config.txt000066400000000000000000004404511434072136500244100ustar00rootroot00000000000000# Uncrustify-0.76.0 # # General options # # The type of line endings. # # Default: auto newlines = auto # lf/crlf/cr/auto # The original size of tabs in the input. # # Default: 8 input_tab_size = 8 # unsigned number # The size of tabs in the output (only used if align_with_tabs=true). # # Default: 8 output_tab_size = 8 # unsigned number # The ASCII value of the string escape char, usually 92 (\) or (Pawn) 94 (^). # # Default: 92 string_escape_char = 92 # unsigned number # Alternate string escape char (usually only used for Pawn). # Only works right before the quote char. string_escape_char2 = 0 # unsigned number # Replace tab characters found in string literals with the escape sequence \t # instead. string_replace_tab_chars = false # true/false # Allow interpreting '>=' and '>>=' as part of a template in code like # 'void f(list>=val);'. If true, 'assert(x<0 && y>=3)' will be broken. # Improvements to template detection may make this option obsolete. tok_split_gte = false # true/false # Disable formatting of NL_CONT ('\\n') ended lines (e.g. multi-line macros). disable_processing_nl_cont = false # true/false # Specify the marker used in comments to disable processing of part of the # file. # # Default: *INDENT-OFF* disable_processing_cmt = " *INDENT-OFF*" # string # Specify the marker used in comments to (re)enable processing in a file. # # Default: *INDENT-ON* enable_processing_cmt = " *INDENT-ON*" # string # Enable parsing of digraphs. enable_digraphs = false # true/false # Option to allow both disable_processing_cmt and enable_processing_cmt # strings, if specified, to be interpreted as ECMAScript regular expressions. # If true, a regex search will be performed within comments according to the # specified patterns in order to disable/enable processing. processing_cmt_as_regex = false # true/false # Add or remove the UTF-8 BOM (recommend 'remove'). utf8_bom = ignore # ignore/add/remove/force/not_defined # If the file contains bytes with values between 128 and 255, but is not # UTF-8, then output as UTF-8. utf8_byte = false # true/false # Force the output encoding to UTF-8. utf8_force = false # true/false # # Spacing options # # Add or remove space around non-assignment symbolic operators ('+', '/', '%', # '<<', and so forth). sp_arith = ignore # ignore/add/remove/force/not_defined # Add or remove space around arithmetic operators '+' and '-'. # # Overrides sp_arith. sp_arith_additive = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment operator '=', '+=', etc. sp_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space around '=' in C++11 lambda capture specifications. # # Overrides sp_assign. sp_cpp_lambda_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after the capture specification of a C++11 lambda when # an argument list is present, as in '[] (int x){ ... }'. sp_cpp_lambda_square_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the capture specification of a C++11 lambda with # no argument list is present, as in '[] { ... }'. sp_cpp_lambda_square_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space after the opening parenthesis and before the closing # parenthesis of a argument list of a C++11 lambda, as in # '[]( int x ){ ... }'. sp_cpp_lambda_argument_list = ignore # ignore/add/remove/force/not_defined # Add or remove space after the argument list of a C++11 lambda, as in # '[](int x) { ... }'. sp_cpp_lambda_paren_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between a lambda body and its call operator of an # immediately invoked lambda, as in '[]( ... ){ ... } ( ... )'. sp_cpp_lambda_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment operator '=' in a prototype. # # If set to ignore, use sp_assign. sp_assign_default = ignore # ignore/add/remove/force/not_defined # Add or remove space before assignment operator '=', '+=', etc. # # Overrides sp_assign. sp_before_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after assignment operator '=', '+=', etc. # # Overrides sp_assign. sp_after_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space in 'enum {'. # # Default: add sp_enum_brace = add # ignore/add/remove/force/not_defined # Add or remove space in 'NS_ENUM ('. sp_enum_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment '=' in enum. sp_enum_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space before assignment '=' in enum. # # Overrides sp_enum_assign. sp_enum_before_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after assignment '=' in enum. # # Overrides sp_enum_assign. sp_enum_after_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment ':' in enum. sp_enum_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space around preprocessor '##' concatenation operator. # # Default: add sp_pp_concat = add # ignore/add/remove/force/not_defined # Add or remove space after preprocessor '#' stringify operator. # Also affects the '#@' charizing operator. sp_pp_stringify = ignore # ignore/add/remove/force/not_defined # Add or remove space before preprocessor '#' stringify operator # as in '#define x(y) L#y'. sp_before_pp_stringify = ignore # ignore/add/remove/force/not_defined # Add or remove space around boolean operators '&&' and '||'. sp_bool = ignore # ignore/add/remove/force/not_defined # Add or remove space around compare operator '<', '>', '==', etc. sp_compare = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')'. sp_inside_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested parentheses, i.e. '((' vs. ') )'. sp_paren_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('. sp_cparen_oparen = ignore # ignore/add/remove/force/not_defined # Whether to balance spaces inside nested parentheses. sp_balance_nested_parens = false # true/false # Add or remove space between ')' and '{'. sp_paren_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested braces, i.e. '{{' vs. '{ {'. sp_brace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space before pointer star '*'. sp_before_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space before pointer star '*' that isn't followed by a # variable name. If set to ignore, sp_before_ptr_star is used instead. sp_before_unnamed_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space between pointer stars '*', as in 'int ***a;'. sp_between_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer star '*', if followed by a word. # # Overrides sp_type_func. sp_after_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer caret '^', if followed by a word. sp_after_ptr_block_caret = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer star '*', if followed by a qualifier. sp_after_ptr_star_qualifier = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*', if followed by a function # prototype or function definition. # # Overrides sp_after_ptr_star and sp_type_func. sp_after_ptr_star_func = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*' in the trailing return of a # function prototype or function definition. sp_after_ptr_star_trailing = ignore # ignore/add/remove/force/not_defined # Add or remove space between the pointer star '*' and the name of the variable # in a function pointer definition. sp_ptr_star_func_var = ignore # ignore/add/remove/force/not_defined # Add or remove space between the pointer star '*' and the name of the type # in a function pointer type definition. sp_ptr_star_func_type = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*', if followed by an open # parenthesis, as in 'void* (*)()'. sp_ptr_star_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space before a pointer star '*', if followed by a function # prototype or function definition. sp_before_ptr_star_func = ignore # ignore/add/remove/force/not_defined # Add or remove space before a pointer star '*' in the trailing return of a # function prototype or function definition. sp_before_ptr_star_trailing = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&'. sp_before_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&' that isn't followed by a # variable name. If set to ignore, sp_before_byref is used instead. sp_before_unnamed_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space after reference sign '&', if followed by a word. # # Overrides sp_type_func. sp_after_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space after a reference sign '&', if followed by a function # prototype or function definition. # # Overrides sp_after_byref and sp_type_func. sp_after_byref_func = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&', if followed by a function # prototype or function definition. sp_before_byref_func = ignore # ignore/add/remove/force/not_defined # Add or remove space after a reference sign '&', if followed by an open # parenthesis, as in 'char& (*)()'. sp_byref_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between type and word. In cases where total removal of # whitespace would be a syntax error, a value of 'remove' is treated the same # as 'force'. # # This also affects some other instances of space following a type that are # not covered by other options; for example, between the return type and # parenthesis of a function type template argument, between the type and # parenthesis of an array parameter, or between 'decltype(...)' and the # following word. # # Default: force sp_after_type = force # ignore/add/remove/force/not_defined # Add or remove space between 'decltype(...)' and word, # brace or function call. sp_after_decltype = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space before the parenthesis in the D constructs # 'template Foo(' and 'class Foo('. sp_before_template_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'template' and '<'. # If set to ignore, sp_before_angle is used. sp_template_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space before '<'. sp_before_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '<' and '>'. sp_inside_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '<>'. sp_inside_angle_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and ':'. sp_angle_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after '>'. sp_after_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '(' as found in 'new List(foo);'. sp_angle_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '()' as found in 'new List();'. sp_angle_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and a word as in 'List m;' or # 'template static ...'. sp_angle_word = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '>' in '>>' (template stuff). # # Default: add sp_angle_shift = add # ignore/add/remove/force/not_defined # (C++11) Permit removal of the space between '>>' in 'foo >'. Note # that sp_angle_shift cannot remove the space without this option. sp_permit_cpp11_shift = false # true/false # Add or remove space before '(' of control statements ('if', 'for', 'switch', # 'while', etc.). sp_before_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')' of control statements other than # 'for'. sp_inside_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space after '(' of control statements other than 'for'. # # Overrides sp_inside_sparen. sp_inside_sparen_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before ')' of control statements other than 'for'. # # Overrides sp_inside_sparen. sp_inside_sparen_close = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')' of 'for' statements. sp_inside_for = ignore # ignore/add/remove/force/not_defined # Add or remove space after '(' of 'for' statements. # # Overrides sp_inside_for. sp_inside_for_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before ')' of 'for' statements. # # Overrides sp_inside_for. sp_inside_for_close = ignore # ignore/add/remove/force/not_defined # Add or remove space between '((' or '))' of control statements. sp_sparen_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after ')' of control statements. sp_after_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of control statements. sp_sparen_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'do' and '{'. sp_do_brace_open = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'while'. sp_brace_close_while = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'while' and '('. Overrides sp_before_sparen. sp_while_paren_open = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'invariant' and '('. sp_invariant_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space after the ')' in 'invariant (C) c'. sp_after_invariant_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space before empty statement ';' on 'if', 'for' and 'while'. sp_special_semi = ignore # ignore/add/remove/force/not_defined # Add or remove space before ';'. # # Default: remove sp_before_semi = remove # ignore/add/remove/force/not_defined # Add or remove space before ';' in non-empty 'for' statements. sp_before_semi_for = ignore # ignore/add/remove/force/not_defined # Add or remove space before a semicolon of an empty left part of a for # statement, as in 'for ( ; ; )'. sp_before_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between the semicolons of an empty middle part of a for # statement, as in 'for ( ; ; )'. sp_between_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after ';', except when followed by a comment. # # Default: add sp_after_semi = add # ignore/add/remove/force/not_defined # Add or remove space after ';' in non-empty 'for' statements. # # Default: force sp_after_semi_for = force # ignore/add/remove/force/not_defined # Add or remove space after the final semicolon of an empty part of a for # statement, as in 'for ( ; ; )'. sp_after_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[' (except '[]'). sp_before_square = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[' for a variable definition. # # Default: remove sp_before_vardef_square = remove # ignore/add/remove/force/not_defined # Add or remove space before '[' for asm block. sp_before_square_asm_block = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[]'. sp_before_squares = ignore # ignore/add/remove/force/not_defined # Add or remove space before C++17 structured bindings. sp_cpp_before_struct_binding = ignore # ignore/add/remove/force/not_defined # Add or remove space inside a non-empty '[' and ']'. sp_inside_square = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '[]'. sp_inside_square_empty = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside a non-empty Objective-C boxed array '@[' and # ']'. If set to ignore, sp_inside_square is used. sp_inside_square_oc_array = ignore # ignore/add/remove/force/not_defined # Add or remove space after ',', i.e. 'a,b' vs. 'a, b'. sp_after_comma = ignore # ignore/add/remove/force/not_defined # Add or remove space before ',', i.e. 'a,b' vs. 'a ,b'. # # Default: remove sp_before_comma = remove # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between ',' and ']' in multidimensional array type # like 'int[,,]'. sp_after_mdatype_commas = ignore # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between '[' and ',' in multidimensional array type # like 'int[,,]'. sp_before_mdatype_commas = ignore # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between ',' in multidimensional array type # like 'int[,,]'. sp_between_mdatype_commas = ignore # ignore/add/remove/force/not_defined # Add or remove space between an open parenthesis and comma, # i.e. '(,' vs. '( ,'. # # Default: force sp_paren_comma = force # ignore/add/remove/force/not_defined # Add or remove space between a type and ':'. sp_type_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after the variadic '...' when preceded by a # non-punctuator. # The value REMOVE will be overridden with FORCE sp_after_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space before the variadic '...' when preceded by a # non-punctuator. # The value REMOVE will be overridden with FORCE sp_before_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between a type and '...'. sp_type_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between a '*' and '...'. sp_ptr_type_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '...'. sp_paren_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between '&&' and '...'. sp_byref_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and a qualifier such as 'const'. sp_paren_qualifier = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and 'noexcept'. sp_paren_noexcept = ignore # ignore/add/remove/force/not_defined # Add or remove space after class ':'. sp_after_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before class ':'. sp_before_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after class constructor ':'. # # Default: add sp_after_constr_colon = add # ignore/add/remove/force/not_defined # Add or remove space before class constructor ':'. # # Default: add sp_before_constr_colon = add # ignore/add/remove/force/not_defined # Add or remove space before case ':'. # # Default: remove sp_before_case_colon = remove # ignore/add/remove/force/not_defined # Add or remove space between 'operator' and operator sign. sp_after_operator = ignore # ignore/add/remove/force/not_defined # Add or remove space between the operator symbol and the open parenthesis, as # in 'operator ++('. sp_after_operator_sym = ignore # ignore/add/remove/force/not_defined # Overrides sp_after_operator_sym when the operator has no arguments, as in # 'operator *()'. sp_after_operator_sym_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after C/D cast, i.e. 'cast(int)a' vs. 'cast(int) a' or # '(int)a' vs. '(int) a'. sp_after_cast = ignore # ignore/add/remove/force/not_defined # Add or remove spaces inside cast parentheses. sp_inside_paren_cast = ignore # ignore/add/remove/force/not_defined # Add or remove space between the type and open parenthesis in a C++ cast, # i.e. 'int(exp)' vs. 'int (exp)'. sp_cpp_cast_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof' and '('. sp_sizeof_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof' and '...'. sp_sizeof_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof...' and '('. sp_sizeof_ellipsis_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between '...' and a parameter pack. sp_ellipsis_parameter_pack = ignore # ignore/add/remove/force/not_defined # Add or remove space between a parameter pack and '...'. sp_parameter_pack_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'decltype' and '('. sp_decltype_paren = ignore # ignore/add/remove/force/not_defined # (Pawn) Add or remove space after the tag keyword. sp_after_tag = ignore # ignore/add/remove/force/not_defined # Add or remove space inside enum '{' and '}'. sp_inside_braces_enum = ignore # ignore/add/remove/force/not_defined # Add or remove space inside struct/union '{' and '}'. sp_inside_braces_struct = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}' sp_inside_braces_oc_dict = ignore # ignore/add/remove/force/not_defined # Add or remove space after open brace in an unnamed temporary # direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore. sp_after_type_brace_init_lst_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before close brace in an unnamed temporary # direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore. sp_before_type_brace_init_lst_close = ignore # ignore/add/remove/force/not_defined # Add or remove space inside an unnamed temporary direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore # works only if sp_before_type_brace_init_lst_close is set to ignore. sp_inside_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '{' and '}'. sp_inside_braces = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '{}'. sp_inside_braces_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space around trailing return operator '->'. sp_trailing_return = ignore # ignore/add/remove/force/not_defined # Add or remove space between return type and function name. A minimum of 1 # is forced except for pointer return types. sp_type_func = ignore # ignore/add/remove/force/not_defined # Add or remove space between type and open brace of an unnamed temporary # direct-list-initialization. sp_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' on function declaration. sp_func_proto_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function declaration # without parameters. sp_func_proto_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' with a typedef specifier. sp_func_type_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between alias name and '(' of a non-pointer function type typedef. sp_func_def_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function definition # without parameters. sp_func_def_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space inside empty function '()'. # Overrides sp_after_angle unless use_sp_after_angle_always is set to true. sp_inside_fparens = ignore # ignore/add/remove/force/not_defined # Add or remove space inside function '(' and ')'. sp_inside_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space inside the first parentheses in a function type, as in # 'void (*x)(...)'. sp_inside_tparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between the ')' and '(' in a function type, as in # 'void (*x)(...)'. sp_after_tparen_close = ignore # ignore/add/remove/force/not_defined # Add or remove space between ']' and '(' when part of a function call. sp_square_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of function. sp_fparen_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of a function call in object # initialization. # # Overrides sp_fparen_brace. sp_fparen_brace_initializer = ignore # ignore/add/remove/force/not_defined # (Java) Add or remove space between ')' and '{{' of double brace initializer. sp_fparen_dbrace = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' on function calls. sp_func_call_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function calls without # parameters. If set to ignore (the default), sp_func_call_paren is used. sp_func_call_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between the user function name and '(' on function # calls. You need to set a keyword to be a user function in the config file, # like: # set func_call_user tr _ i18n sp_func_call_user_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space inside user function '(' and ')'. sp_func_call_user_inside_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested parentheses with user functions, # i.e. '((' vs. '( ('. sp_func_call_user_paren_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between a constructor/destructor and the open # parenthesis. sp_func_class_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between a constructor without parameters or destructor # and '()'. sp_func_class_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after 'return'. # # Default: force sp_return = force # ignore/add/remove/force/not_defined # Add or remove space between 'return' and '('. sp_return_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'return' and '{'. sp_return_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '__attribute__' and '('. sp_attribute_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'defined' and '(' in '#if defined (FOO)'. sp_defined_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'throw' and '(' in 'throw (something)'. sp_throw_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'throw' and anything other than '(' as in # '@throw [...];'. sp_after_throw = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'catch' and '(' in 'catch (something) { }'. # If set to ignore, sp_before_sparen is used. sp_catch_paren = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@catch' and '(' # in '@catch (something) { }'. If set to ignore, sp_catch_paren is used. sp_oc_catch_paren = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before Objective-C protocol list # as in '@protocol Protocol' or '@interface MyClass : NSObject'. sp_before_oc_proto_list = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between class name and '(' # in '@interface className(categoryName):BaseClass' sp_oc_classname_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'version' and '(' # in 'version (something) { }'. If set to ignore, sp_before_sparen is used. sp_version_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'scope' and '(' # in 'scope (something) { }'. If set to ignore, sp_before_sparen is used. sp_scope_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'super' and '(' in 'super (something)'. # # Default: remove sp_super_paren = remove # ignore/add/remove/force/not_defined # Add or remove space between 'this' and '(' in 'this (something)'. # # Default: remove sp_this_paren = remove # ignore/add/remove/force/not_defined # Add or remove space between a macro name and its definition. sp_macro = ignore # ignore/add/remove/force/not_defined # Add or remove space between a macro function ')' and its definition. sp_macro_func = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'else' and '{' if on the same line. sp_else_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'else' if on the same line. sp_brace_else = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and the name of a typedef on the same line. sp_brace_typedef = ignore # ignore/add/remove/force/not_defined # Add or remove space before the '{' of a 'catch' statement, if the '{' and # 'catch' are on the same line, as in 'catch (decl) {'. sp_catch_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the '{' of a '@catch' statement, if the '{' # and '@catch' are on the same line, as in '@catch (decl) {'. # If set to ignore, sp_catch_brace is used. sp_oc_catch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'catch' if on the same line. sp_brace_catch = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '}' and '@catch' if on the same line. # If set to ignore, sp_brace_catch is used. sp_oc_brace_catch = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'finally' and '{' if on the same line. sp_finally_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'finally' if on the same line. sp_brace_finally = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'try' and '{' if on the same line. sp_try_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between get/set and '{' if on the same line. sp_getset_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between a variable and '{' for C++ uniform # initialization. sp_word_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space between a variable and '{' for a namespace. # # Default: add sp_word_brace_ns = add # ignore/add/remove/force/not_defined # Add or remove space before the '::' operator. sp_before_dc = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '::' operator. sp_after_dc = ignore # ignore/add/remove/force/not_defined # (D) Add or remove around the D named array initializer ':' operator. sp_d_array_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '!' (not) unary operator. # # Default: remove sp_not = remove # ignore/add/remove/force/not_defined # Add or remove space between two '!' (not) unary operators. # If set to ignore, sp_not will be used. sp_not_not = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '~' (invert) unary operator. # # Default: remove sp_inv = remove # ignore/add/remove/force/not_defined # Add or remove space after the '&' (address-of) unary operator. This does not # affect the spacing after a '&' that is part of a type. # # Default: remove sp_addr = remove # ignore/add/remove/force/not_defined # Add or remove space around the '.' or '->' operators. # # Default: remove sp_member = remove # ignore/add/remove/force/not_defined # Add or remove space after the '*' (dereference) unary operator. This does # not affect the spacing after a '*' that is part of a type. # # Default: remove sp_deref = remove # ignore/add/remove/force/not_defined # Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. # # Default: remove sp_sign = remove # ignore/add/remove/force/not_defined # Add or remove space between '++' and '--' the word to which it is being # applied, as in '(--x)' or 'y++;'. # # Default: remove sp_incdec = remove # ignore/add/remove/force/not_defined # Add or remove space before a backslash-newline at the end of a line. # # Default: add sp_before_nl_cont = add # ignore/add/remove/force/not_defined # (OC) Add or remove space after the scope '+' or '-', as in '-(void) foo;' # or '+(int) bar;'. sp_after_oc_scope = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in message specs, # i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'. sp_after_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in message specs, # i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'. sp_before_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in immutable dictionary expression # 'NSDictionary *test = @{@"foo" :@"bar"};'. sp_after_oc_dict_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in immutable dictionary expression # 'NSDictionary *test = @{@"foo" :@"bar"};'. sp_before_oc_dict_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in message specs, # i.e. '[object setValue:1];' vs. '[object setValue: 1];'. sp_after_send_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in message specs, # i.e. '[object setValue:1];' vs. '[object setValue :1];'. sp_before_send_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the (type) in message specs, # i.e. '-(int)f: (int) x;' vs. '-(int)f: (int)x;'. sp_after_oc_type = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the first (type) in message specs, # i.e. '-(int) f:(int)x;' vs. '-(int)f:(int)x;'. sp_after_oc_return_type = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@selector' and '(', # i.e. '@selector(msgName)' vs. '@selector (msgName)'. # Also applies to '@protocol()' constructs. sp_after_oc_at_sel = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@selector(x)' and the following word, # i.e. '@selector(foo) a:' vs. '@selector(foo)a:'. sp_after_oc_at_sel_parens = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside '@selector' parentheses, # i.e. '@selector(foo)' vs. '@selector( foo )'. # Also applies to '@protocol()' constructs. sp_inside_oc_at_sel_parens = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before a block pointer caret, # i.e. '^int (int arg){...}' vs. ' ^int (int arg){...}'. sp_before_oc_block_caret = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after a block pointer caret, # i.e. '^int (int arg){...}' vs. '^ int (int arg){...}'. sp_after_oc_block_caret = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between the receiver and selector in a message, # as in '[receiver selector ...]'. sp_after_oc_msg_receiver = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after '@property'. sp_after_oc_property = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@synchronized' and the open parenthesis, # i.e. '@synchronized(foo)' vs. '@synchronized (foo)'. sp_after_oc_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove space around the ':' in 'b ? t : f'. sp_cond_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before the ':' in 'b ? t : f'. # # Overrides sp_cond_colon. sp_cond_colon_before = ignore # ignore/add/remove/force/not_defined # Add or remove space after the ':' in 'b ? t : f'. # # Overrides sp_cond_colon. sp_cond_colon_after = ignore # ignore/add/remove/force/not_defined # Add or remove space around the '?' in 'b ? t : f'. sp_cond_question = ignore # ignore/add/remove/force/not_defined # Add or remove space before the '?' in 'b ? t : f'. # # Overrides sp_cond_question. sp_cond_question_before = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '?' in 'b ? t : f'. # # Overrides sp_cond_question. sp_cond_question_after = ignore # ignore/add/remove/force/not_defined # In the abbreviated ternary form '(a ?: b)', add or remove space between '?' # and ':'. # # Overrides all other sp_cond_* options. sp_cond_ternary_short = ignore # ignore/add/remove/force/not_defined # Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make # sense here. sp_case_label = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space around the D '..' operator. sp_range = ignore # ignore/add/remove/force/not_defined # Add or remove space after ':' in a Java/C++11 range-based 'for', # as in 'for (Type var : expr)'. sp_after_for_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before ':' in a Java/C++11 range-based 'for', # as in 'for (Type var : expr)'. sp_before_for_colon = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'extern' and '(' as in 'extern (C)'. sp_extern_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the opening of a C++ comment, as in '// A'. sp_cmt_cpp_start = ignore # ignore/add/remove/force/not_defined # Add or remove space in a C++ region marker comment, as in '// BEGIN'. # A region marker is defined as a comment which is not preceded by other text # (i.e. the comment is the first non-whitespace on the line), and which starts # with either 'BEGIN' or 'END'. # # Overrides sp_cmt_cpp_start. sp_cmt_cpp_region = ignore # ignore/add/remove/force/not_defined # If true, space added with sp_cmt_cpp_start will be added after Doxygen # sequences like '///', '///<', '//!' and '//!<'. sp_cmt_cpp_doxygen = false # true/false # If true, space added with sp_cmt_cpp_start will be added after Qt translator # or meta-data comments like '//:', '//=', and '//~'. sp_cmt_cpp_qttr = false # true/false # Add or remove space between #else or #endif and a trailing comment. sp_endif_cmt = ignore # ignore/add/remove/force/not_defined # Add or remove space after 'new', 'delete' and 'delete[]'. sp_after_new = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'new' and '(' in 'new()'. sp_between_new_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and type in 'new(foo) BAR'. sp_after_newop_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space inside parentheses of the new operator # as in 'new(foo) BAR'. sp_inside_newop_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the open parenthesis of the new operator, # as in 'new(foo) BAR'. # # Overrides sp_inside_newop_paren. sp_inside_newop_paren_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before the close parenthesis of the new operator, # as in 'new(foo) BAR'. # # Overrides sp_inside_newop_paren. sp_inside_newop_paren_close = ignore # ignore/add/remove/force/not_defined # Add or remove space before a trailing comment. sp_before_tr_cmt = ignore # ignore/add/remove/force/not_defined # Number of spaces before a trailing comment. sp_num_before_tr_cmt = 0 # unsigned number # Add or remove space before an embedded comment. # # Default: force sp_before_emb_cmt = force # ignore/add/remove/force/not_defined # Number of spaces before an embedded comment. # # Default: 1 sp_num_before_emb_cmt = 1 # unsigned number # Add or remove space after an embedded comment. # # Default: force sp_after_emb_cmt = force # ignore/add/remove/force/not_defined # Number of spaces after an embedded comment. # # Default: 1 sp_num_after_emb_cmt = 1 # unsigned number # (Java) Add or remove space between an annotation and the open parenthesis. sp_annotation_paren = ignore # ignore/add/remove/force/not_defined # If true, vbrace tokens are dropped to the previous token and skipped. sp_skip_vbrace_tokens = false # true/false # Add or remove space after 'noexcept'. sp_after_noexcept = ignore # ignore/add/remove/force/not_defined # Add or remove space after '_'. sp_vala_after_translation = ignore # ignore/add/remove/force/not_defined # If true, a is inserted after #define. force_tab_after_define = false # true/false # # Indenting options # # The number of columns to indent per level. Usually 2, 3, 4, or 8. # # Default: 8 indent_columns = 8 # unsigned number # Whether to ignore indent for the first continuation line. Subsequent # continuation lines will still be indented to match the first. indent_ignore_first_continue = false # true/false # The continuation indent. If non-zero, this overrides the indent of '(', '[' # and '=' continuation indents. Negative values are OK; negative value is # absolute and not increased for each '(' or '[' level. # # For FreeBSD, this is set to 4. # Requires indent_ignore_first_continue=false. indent_continue = 0 # number # The continuation indent, only for class header line(s). If non-zero, this # overrides the indent of 'class' continuation indents. # Requires indent_ignore_first_continue=false. indent_continue_class_head = 0 # unsigned number # Whether to indent empty lines (i.e. lines which contain only spaces before # the newline character). indent_single_newlines = false # true/false # The continuation indent for func_*_param if they are true. If non-zero, this # overrides the indent. indent_param = 0 # unsigned number # How to use tabs when indenting code. # # 0: Spaces only # 1: Indent with tabs to brace level, align with spaces (default) # 2: Indent and align with tabs, using spaces when not on a tabstop # # Default: 1 indent_with_tabs = 1 # unsigned number # Whether to indent comments that are not at a brace level with tabs on a # tabstop. Requires indent_with_tabs=2. If false, will use spaces. indent_cmt_with_tabs = false # true/false # Whether to indent strings broken by '\' so that they line up. indent_align_string = false # true/false # The number of spaces to indent multi-line XML strings. # Requires indent_align_string=true. indent_xml_string = 0 # unsigned number # Spaces to indent '{' from level. indent_brace = 0 # unsigned number # Whether braces are indented to the body level. indent_braces = false # true/false # Whether to disable indenting function braces if indent_braces=true. indent_braces_no_func = false # true/false # Whether to disable indenting class braces if indent_braces=true. indent_braces_no_class = false # true/false # Whether to disable indenting struct braces if indent_braces=true. indent_braces_no_struct = false # true/false # Whether to indent based on the size of the brace parent, # i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc. indent_brace_parent = false # true/false # Whether to indent based on the open parenthesis instead of the open brace # in '({\n'. indent_paren_open_brace = false # true/false # (C#) Whether to indent the brace of a C# delegate by another level. indent_cs_delegate_brace = false # true/false # (C#) Whether to indent a C# delegate (to handle delegates with no brace) by # another level. indent_cs_delegate_body = false # true/false # Whether to indent the body of a 'namespace'. indent_namespace = false # true/false # Whether to indent only the first namespace, and not any nested namespaces. # Requires indent_namespace=true. indent_namespace_single_indent = false # true/false # The number of spaces to indent a namespace block. # If set to zero, use the value indent_columns indent_namespace_level = 0 # unsigned number # If the body of the namespace is longer than this number, it won't be # indented. Requires indent_namespace=true. 0 means no limit. indent_namespace_limit = 0 # unsigned number # Whether to indent only in inner namespaces (nested in other namespaces). # Requires indent_namespace=true. indent_namespace_inner_only = false # true/false # Whether the 'extern "C"' body is indented. indent_extern = false # true/false # Whether the 'class' body is indented. indent_class = false # true/false # Whether to ignore indent for the leading base class colon. indent_ignore_before_class_colon = false # true/false # Additional indent before the leading base class colon. # Negative values decrease indent down to the first column. # Requires indent_ignore_before_class_colon=false and a newline break before # the colon (see pos_class_colon and nl_class_colon) indent_before_class_colon = 0 # number # Whether to indent the stuff after a leading base class colon. indent_class_colon = false # true/false # Whether to indent based on a class colon instead of the stuff after the # colon. Requires indent_class_colon=true. indent_class_on_colon = false # true/false # Whether to ignore indent for a leading class initializer colon. indent_ignore_before_constr_colon = false # true/false # Whether to indent the stuff after a leading class initializer colon. indent_constr_colon = false # true/false # Virtual indent from the ':' for leading member initializers. # # Default: 2 indent_ctor_init_leading = 2 # unsigned number # Virtual indent from the ':' for following member initializers. # # Default: 2 indent_ctor_init_following = 2 # unsigned number # Additional indent for constructor initializer list. # Negative values decrease indent down to the first column. indent_ctor_init = 0 # number # Whether to indent 'if' following 'else' as a new block under the 'else'. # If false, 'else\nif' is treated as 'else if' for indenting purposes. indent_else_if = false # true/false # Amount to indent variable declarations after a open brace. # # <0: Relative # >=0: Absolute indent_var_def_blk = 0 # number # Whether to indent continued variable declarations instead of aligning. indent_var_def_cont = false # true/false # How to indent continued shift expressions ('<<' and '>>'). # Set align_left_shift=false when using this. # 0: Align shift operators instead of indenting them (default) # 1: Indent by one level # -1: Preserve original indentation indent_shift = 0 # number # Whether to force indentation of function definitions to start in column 1. indent_func_def_force_col1 = false # true/false # Whether to indent continued function call parameters one indent level, # rather than aligning parameters under the open parenthesis. indent_func_call_param = false # true/false # Whether to indent continued function definition parameters one indent level, # rather than aligning parameters under the open parenthesis. indent_func_def_param = false # true/false # for function definitions, only if indent_func_def_param is false # Allows to align params when appropriate and indent them when not # behave as if it was true if paren position is more than this value # if paren position is more than the option value indent_func_def_param_paren_pos_threshold = 0 # unsigned number # Whether to indent continued function call prototype one indent level, # rather than aligning parameters under the open parenthesis. indent_func_proto_param = false # true/false # Whether to indent continued function call declaration one indent level, # rather than aligning parameters under the open parenthesis. indent_func_class_param = false # true/false # Whether to indent continued class variable constructors one indent level, # rather than aligning parameters under the open parenthesis. indent_func_ctor_var_param = false # true/false # Whether to indent continued template parameter list one indent level, # rather than aligning parameters under the open parenthesis. indent_template_param = false # true/false # Double the indent for indent_func_xxx_param options. # Use both values of the options indent_columns and indent_param. indent_func_param_double = false # true/false # Indentation column for standalone 'const' qualifier on a function # prototype. indent_func_const = 0 # unsigned number # Indentation column for standalone 'throw' qualifier on a function # prototype. indent_func_throw = 0 # unsigned number # How to indent within a macro followed by a brace on the same line # This allows reducing the indent in macros that have (for example) # `do { ... } while (0)` blocks bracketing them. # # true: add an indent for the brace on the same line as the macro # false: do not add an indent for the brace on the same line as the macro # # Default: true indent_macro_brace = true # true/false # The number of spaces to indent a continued '->' or '.'. # Usually set to 0, 1, or indent_columns. indent_member = 0 # unsigned number # Whether lines broken at '.' or '->' should be indented by a single indent. # The indent_member option will not be effective if this is set to true. indent_member_single = false # true/false # Spaces to indent single line ('//') comments on lines before code. indent_single_line_comments_before = 0 # unsigned number # Spaces to indent single line ('//') comments on lines after code. indent_single_line_comments_after = 0 # unsigned number # When opening a paren for a control statement (if, for, while, etc), increase # the indent level by this value. Negative values decrease the indent level. indent_sparen_extra = 0 # number # Whether to indent trailing single line ('//') comments relative to the code # instead of trying to keep the same absolute column. indent_relative_single_line_comments = false # true/false # Spaces to indent 'case' from 'switch'. Usually 0 or indent_columns. # It might be wise to choose the same value for the option indent_case_brace. indent_switch_case = 0 # unsigned number # Spaces to indent the body of a 'switch' before any 'case'. # Usually the same as indent_columns or indent_switch_case. indent_switch_body = 0 # unsigned number # Whether to ignore indent for '{' following 'case'. indent_ignore_case_brace = false # true/false # Spaces to indent '{' from 'case'. By default, the brace will appear under # the 'c' in case. Usually set to 0 or indent_columns. Negative values are OK. # It might be wise to choose the same value for the option indent_switch_case. indent_case_brace = 0 # number # indent 'break' with 'case' from 'switch'. indent_switch_break_with_case = false # true/false # Whether to indent preprocessor statements inside of switch statements. # # Default: true indent_switch_pp = true # true/false # Spaces to shift the 'case' line, without affecting any other lines. # Usually 0. indent_case_shift = 0 # unsigned number # Whether to align comments before 'case' with the 'case'. # # Default: true indent_case_comment = true # true/false # Whether to indent comments not found in first column. # # Default: true indent_comment = true # true/false # Whether to indent comments found in first column. indent_col1_comment = false # true/false # Whether to indent multi string literal in first column. indent_col1_multi_string_literal = false # true/false # Align comments on adjacent lines that are this many columns apart or less. # # Default: 3 indent_comment_align_thresh = 3 # unsigned number # Whether to ignore indent for goto labels. indent_ignore_label = false # true/false # How to indent goto labels. Requires indent_ignore_label=false. # # >0: Absolute column where 1 is the leftmost column # <=0: Subtract from brace indent # # Default: 1 indent_label = 1 # number # How to indent access specifiers that are followed by a # colon. # # >0: Absolute column where 1 is the leftmost column # <=0: Subtract from brace indent # # Default: 1 indent_access_spec = 1 # number # Whether to indent the code after an access specifier by one level. # If true, this option forces 'indent_access_spec=0'. indent_access_spec_body = false # true/false # If an open parenthesis is followed by a newline, whether to indent the next # line so that it lines up after the open parenthesis (not recommended). indent_paren_nl = false # true/false # How to indent a close parenthesis after a newline. # # 0: Indent to body level (default) # 1: Align under the open parenthesis # 2: Indent to the brace level # -1: Preserve original indentation indent_paren_close = 0 # number # Whether to indent the open parenthesis of a function definition, # if the parenthesis is on its own line. indent_paren_after_func_def = false # true/false # Whether to indent the open parenthesis of a function declaration, # if the parenthesis is on its own line. indent_paren_after_func_decl = false # true/false # Whether to indent the open parenthesis of a function call, # if the parenthesis is on its own line. indent_paren_after_func_call = false # true/false # How to indent a comma when inside braces. # 0: Indent by one level (default) # 1: Align under the open brace # -1: Preserve original indentation indent_comma_brace = 0 # number # How to indent a comma when inside parentheses. # 0: Indent by one level (default) # 1: Align under the open parenthesis # -1: Preserve original indentation indent_comma_paren = 0 # number # How to indent a Boolean operator when inside parentheses. # 0: Indent by one level (default) # 1: Align under the open parenthesis # -1: Preserve original indentation indent_bool_paren = 0 # number # Whether to ignore the indentation of a Boolean operator when outside # parentheses. indent_ignore_bool = false # true/false # Whether to ignore the indentation of an arithmetic operator. indent_ignore_arith = false # true/false # Whether to indent a semicolon when inside a for parenthesis. # If true, aligns under the open for parenthesis. indent_semicolon_for_paren = false # true/false # Whether to ignore the indentation of a semicolon outside of a 'for' # statement. indent_ignore_semicolon = false # true/false # Whether to align the first expression to following ones # if indent_bool_paren=1. indent_first_bool_expr = false # true/false # Whether to align the first expression to following ones # if indent_semicolon_for_paren=true. indent_first_for_expr = false # true/false # If an open square is followed by a newline, whether to indent the next line # so that it lines up after the open square (not recommended). indent_square_nl = false # true/false # (ESQL/C) Whether to preserve the relative indent of 'EXEC SQL' bodies. indent_preserve_sql = false # true/false # Whether to ignore the indentation of an assignment operator. indent_ignore_assign = false # true/false # Whether to align continued statements at the '='. If false or if the '=' is # followed by a newline, the next line is indent one tab. # # Default: true indent_align_assign = true # true/false # If true, the indentation of the chunks after a '=' sequence will be set at # LHS token indentation column before '='. indent_off_after_assign = false # true/false # Whether to align continued statements at the '('. If false or the '(' is # followed by a newline, the next line indent is one tab. # # Default: true indent_align_paren = true # true/false # (OC) Whether to indent Objective-C code inside message selectors. indent_oc_inside_msg_sel = false # true/false # (OC) Whether to indent Objective-C blocks at brace level instead of usual # rules. indent_oc_block = false # true/false # (OC) Indent for Objective-C blocks in a message relative to the parameter # name. # # =0: Use indent_oc_block rules # >0: Use specified number of spaces to indent indent_oc_block_msg = 0 # unsigned number # (OC) Minimum indent for subsequent parameters indent_oc_msg_colon = 0 # unsigned number # (OC) Whether to prioritize aligning with initial colon (and stripping spaces # from lines, if necessary). # # Default: true indent_oc_msg_prioritize_first_colon = true # true/false # (OC) Whether to indent blocks the way that Xcode does by default # (from the keyword if the parameter is on its own line; otherwise, from the # previous indentation level). Requires indent_oc_block_msg=true. indent_oc_block_msg_xcode_style = false # true/false # (OC) Whether to indent blocks from where the brace is, relative to a # message keyword. Requires indent_oc_block_msg=true. indent_oc_block_msg_from_keyword = false # true/false # (OC) Whether to indent blocks from where the brace is, relative to a message # colon. Requires indent_oc_block_msg=true. indent_oc_block_msg_from_colon = false # true/false # (OC) Whether to indent blocks from where the block caret is. # Requires indent_oc_block_msg=true. indent_oc_block_msg_from_caret = false # true/false # (OC) Whether to indent blocks from where the brace caret is. # Requires indent_oc_block_msg=true. indent_oc_block_msg_from_brace = false # true/false # When indenting after virtual brace open and newline add further spaces to # reach this minimum indent. indent_min_vbrace_open = 0 # unsigned number # Whether to add further spaces after regular indent to reach next tabstop # when indenting after virtual brace open and newline. indent_vbrace_open_on_tabstop = false # true/false # How to indent after a brace followed by another token (not a newline). # true: indent all contained lines to match the token # false: indent all contained lines to match the brace # # Default: true indent_token_after_brace = true # true/false # Whether to indent the body of a C++11 lambda. indent_cpp_lambda_body = false # true/false # How to indent compound literals that are being returned. # true: add both the indent from return & the compound literal open brace # (i.e. 2 indent levels) # false: only indent 1 level, don't add the indent for the open brace, only # add the indent for the return. # # Default: true indent_compound_literal_return = true # true/false # (C#) Whether to indent a 'using' block if no braces are used. # # Default: true indent_using_block = true # true/false # How to indent the continuation of ternary operator. # # 0: Off (default) # 1: When the `if_false` is a continuation, indent it under the `if_true` branch # 2: When the `:` is a continuation, indent it under `?` indent_ternary_operator = 0 # unsigned number # Whether to indent the statements inside ternary operator. indent_inside_ternary_operator = false # true/false # If true, the indentation of the chunks after a `return` sequence will be set at return indentation column. indent_off_after_return = false # true/false # If true, the indentation of the chunks after a `return new` sequence will be set at return indentation column. indent_off_after_return_new = false # true/false # If true, the tokens after return are indented with regular single indentation. By default (false) the indentation is after the return token. indent_single_after_return = false # true/false # Whether to ignore indent and alignment for 'asm' blocks (i.e. assume they # have their own indentation). indent_ignore_asm_block = false # true/false # Don't indent the close parenthesis of a function definition, # if the parenthesis is on its own line. donot_indent_func_def_close_paren = false # true/false # # Newline adding and removing options # # Whether to collapse empty blocks between '{' and '}' except for functions. # Use nl_collapse_empty_body_functions to specify how empty function braces # should be formatted. nl_collapse_empty_body = false # true/false # Whether to collapse empty blocks between '{' and '}' for functions only. # If true, overrides nl_inside_empty_func. nl_collapse_empty_body_functions = false # true/false # Don't split one-line braced assignments, as in 'foo_t f = { 1, 2 };'. nl_assign_leave_one_liners = false # true/false # Don't split one-line braced statements inside a 'class xx { }' body. nl_class_leave_one_liners = false # true/false # Don't split one-line enums, as in 'enum foo { BAR = 15 };' nl_enum_leave_one_liners = false # true/false # Don't split one-line get or set functions. nl_getset_leave_one_liners = false # true/false # (C#) Don't split one-line property get or set functions. nl_cs_property_leave_one_liners = false # true/false # Don't split one-line function definitions, as in 'int foo() { return 0; }'. # might modify nl_func_type_name nl_func_leave_one_liners = false # true/false # Don't split one-line C++11 lambdas, as in '[]() { return 0; }'. nl_cpp_lambda_leave_one_liners = false # true/false # Don't split one-line if/else statements, as in 'if(...) b++;'. nl_if_leave_one_liners = false # true/false # Don't split one-line while statements, as in 'while(...) b++;'. nl_while_leave_one_liners = false # true/false # Don't split one-line do statements, as in 'do { b++; } while(...);'. nl_do_leave_one_liners = false # true/false # Don't split one-line for statements, as in 'for(...) b++;'. nl_for_leave_one_liners = false # true/false # (OC) Don't split one-line Objective-C messages. nl_oc_msg_leave_one_liner = false # true/false # (OC) Add or remove newline between method declaration and '{'. nl_oc_mdef_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between Objective-C block signature and '{'. nl_oc_block_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@interface' statement. nl_oc_before_interface = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@implementation' statement. nl_oc_before_implementation = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@end' statement. nl_oc_before_end = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '@interface' and '{'. nl_oc_interface_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '@implementation' and '{'. nl_oc_implementation_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newlines at the start of the file. nl_start_of_file = ignore # ignore/add/remove/force/not_defined # The minimum number of newlines at the start of the file (only used if # nl_start_of_file is 'add' or 'force'). nl_start_of_file_min = 0 # unsigned number # Add or remove newline at the end of the file. nl_end_of_file = ignore # ignore/add/remove/force/not_defined # The minimum number of newlines at the end of the file (only used if # nl_end_of_file is 'add' or 'force'). nl_end_of_file_min = 0 # unsigned number # Add or remove newline between '=' and '{'. nl_assign_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between '=' and '['. nl_assign_square = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '[]' and '{'. nl_tsquare_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline after '= ['. Will also affect the newline before # the ']'. nl_after_square_assign = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function call's ')' and '{', as in # 'list_for_each(item, &list) { }'. nl_fcall_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum' and '{'. nl_enum_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum' and 'class'. nl_enum_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class' and the identifier. nl_enum_class_identifier = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class' type and ':'. nl_enum_identifier_colon = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class identifier :' and type. nl_enum_colon_type = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'struct and '{'. nl_struct_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'union' and '{'. nl_union_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'if' and '{'. nl_if_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'else'. nl_brace_else = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else if' and '{'. If set to ignore, # nl_if_brace is used instead. nl_elseif_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else' and '{'. nl_else_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else' and 'if'. nl_else_if = ignore # ignore/add/remove/force/not_defined # Add or remove newline before '{' opening brace nl_before_opening_brace_func_class_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline before 'if'/'else if' closing parenthesis. nl_before_if_closing_paren = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'finally'. nl_brace_finally = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'finally' and '{'. nl_finally_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'try' and '{'. nl_try_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between get/set and '{'. nl_getset_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'for' and '{'. nl_for_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline before the '{' of a 'catch' statement, as in # 'catch (decl) {'. nl_catch_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline before the '{' of a '@catch' statement, as in # '@catch (decl) {'. If set to ignore, nl_catch_brace is used. nl_oc_catch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'catch'. nl_brace_catch = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '}' and '@catch'. If set to ignore, # nl_brace_catch is used. nl_oc_brace_catch = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and ']'. nl_brace_square = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and ')' in a function invocation. nl_brace_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'while' and '{'. nl_while_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'scope (x)' and '{'. nl_scope_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'unittest' and '{'. nl_unittest_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'version (x)' and '{'. nl_version_brace = ignore # ignore/add/remove/force/not_defined # (C#) Add or remove newline between 'using' and '{'. nl_using_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between two open or close braces. Due to general # newline/brace handling, REMOVE may not work. nl_brace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'do' and '{'. nl_do_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'while' of 'do' statement. nl_brace_while = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'switch' and '{'. nl_switch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'synchronized' and '{'. nl_synchronized_brace = ignore # ignore/add/remove/force/not_defined # Add a newline between ')' and '{' if the ')' is on a different line than the # if/for/etc. # # Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch and # nl_catch_brace. nl_multi_line_cond = false # true/false # Add a newline after '(' if an if/for/while/switch condition spans multiple # lines nl_multi_line_sparen_open = ignore # ignore/add/remove/force/not_defined # Add a newline before ')' if an if/for/while/switch condition spans multiple # lines. Overrides nl_before_if_closing_paren if both are specified. nl_multi_line_sparen_close = ignore # ignore/add/remove/force/not_defined # Force a newline in a define after the macro name for multi-line defines. nl_multi_line_define = false # true/false # Whether to add a newline before 'case', and a blank line before a 'case' # statement that follows a ';' or '}'. nl_before_case = false # true/false # Whether to add a newline after a 'case' statement. nl_after_case = false # true/false # Add or remove newline between a case ':' and '{'. # # Overrides nl_after_case. nl_case_colon_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between ')' and 'throw'. nl_before_throw = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'namespace' and '{'. nl_namespace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class. nl_template_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class declaration. # # Overrides nl_template_class. nl_template_class_decl = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized class declaration. # # Overrides nl_template_class_decl. nl_template_class_decl_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class definition. # # Overrides nl_template_class. nl_template_class_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized class definition. # # Overrides nl_template_class_def. nl_template_class_def_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function. nl_template_func = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function # declaration. # # Overrides nl_template_func. nl_template_func_decl = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized function # declaration. # # Overrides nl_template_func_decl. nl_template_func_decl_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function # definition. # # Overrides nl_template_func. nl_template_func_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized function # definition. # # Overrides nl_template_func_def. nl_template_func_def_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template variable. nl_template_var = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'template<...>' and 'using' of a templated # type alias. nl_template_using = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'class' and '{'. nl_class_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline before or after (depending on pos_class_comma, # may not be IGNORE) each',' in the base class list. nl_class_init_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in the constructor member # initialization. Related to nl_constr_colon, pos_constr_colon and # pos_constr_comma. nl_constr_init_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline before first element, after comma, and after last # element, in 'enum'. nl_enum_own_lines = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name in a function # definition. # might be modified by nl_func_leave_one_liners nl_func_type_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name inside a class # definition. If set to ignore, nl_func_type_name or nl_func_proto_type_name # is used instead. nl_func_type_name_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline between class specification and '::' # in 'void A::f() { }'. Only appears in separate member implementation (does # not appear with in-line implementation). nl_func_class_scope = ignore # ignore/add/remove/force/not_defined # Add or remove newline between function scope and name, as in # 'void A :: f() { }'. nl_func_scope_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name in a prototype. nl_func_proto_type_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # declaration. nl_func_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_paren for functions with no parameters. nl_func_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # definition. nl_func_def_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_paren for functions with no parameters. nl_func_def_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # call. nl_func_call_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_call_paren for functions with no parameters. nl_func_call_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline after '(' in a function declaration. nl_func_decl_start = ignore # ignore/add/remove/force/not_defined # Add or remove newline after '(' in a function definition. nl_func_def_start = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_decl_start when there is only one parameter. nl_func_decl_start_single = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_start when there is only one parameter. nl_func_def_start_single = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function declaration if '(' and ')' # are in different lines. If false, nl_func_decl_start is used instead. nl_func_decl_start_multi_line = false # true/false # Whether to add a newline after '(' in a function definition if '(' and ')' # are in different lines. If false, nl_func_def_start is used instead. nl_func_def_start_multi_line = false # true/false # Add or remove newline after each ',' in a function declaration. nl_func_decl_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in a function definition. nl_func_def_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in a function call. nl_func_call_args = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after each ',' in a function declaration if '(' # and ')' are in different lines. If false, nl_func_decl_args is used instead. nl_func_decl_args_multi_line = false # true/false # Whether to add a newline after each ',' in a function definition if '(' # and ')' are in different lines. If false, nl_func_def_args is used instead. nl_func_def_args_multi_line = false # true/false # Add or remove newline before the ')' in a function declaration. nl_func_decl_end = ignore # ignore/add/remove/force/not_defined # Add or remove newline before the ')' in a function definition. nl_func_def_end = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_decl_end when there is only one parameter. nl_func_decl_end_single = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_end when there is only one parameter. nl_func_def_end_single = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before ')' in a function declaration if '(' and ')' # are in different lines. If false, nl_func_decl_end is used instead. nl_func_decl_end_multi_line = false # true/false # Whether to add a newline before ')' in a function definition if '(' and ')' # are in different lines. If false, nl_func_def_end is used instead. nl_func_def_end_multi_line = false # true/false # Add or remove newline between '()' in a function declaration. nl_func_decl_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '()' in a function definition. nl_func_def_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '()' in a function call. nl_func_call_empty = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function call, # has preference over nl_func_call_start_multi_line. nl_func_call_start = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before ')' in a function call. nl_func_call_end = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function call if '(' and ')' are in # different lines. nl_func_call_start_multi_line = false # true/false # Whether to add a newline after each ',' in a function call if '(' and ')' # are in different lines. nl_func_call_args_multi_line = false # true/false # Whether to add a newline before ')' in a function call if '(' and ')' are in # different lines. nl_func_call_end_multi_line = false # true/false # Whether to respect nl_func_call_XXX option in case of closure args. nl_func_call_args_multi_line_ignore_closures = false # true/false # Whether to add a newline after '<' of a template parameter list. nl_template_start = false # true/false # Whether to add a newline after each ',' in a template parameter list. nl_template_args = false # true/false # Whether to add a newline before '>' of a template parameter list. nl_template_end = false # true/false # (OC) Whether to put each Objective-C message parameter on a separate line. # See nl_oc_msg_leave_one_liner. nl_oc_msg_args = false # true/false # (OC) Minimum number of Objective-C message parameters before applying nl_oc_msg_args. nl_oc_msg_args_min_params = 0 # unsigned number # (OC) Max code width of Objective-C message before applying nl_oc_msg_args. nl_oc_msg_args_max_code_width = 0 # unsigned number # Add or remove newline between function signature and '{'. nl_fdef_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between function signature and '{', # if signature ends with ')'. Overrides nl_fdef_brace. nl_fdef_brace_cond = ignore # ignore/add/remove/force/not_defined # Add or remove newline between C++11 lambda signature and '{'. nl_cpp_ldef_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'return' and the return expression. nl_return_expr = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'throw' and the throw expression. nl_throw_expr = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after semicolons, except in 'for' statements. nl_after_semicolon = false # true/false # (Java) Add or remove newline between the ')' and '{{' of the double brace # initializer. nl_paren_dbrace_open = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after the type in an unnamed temporary # direct-list-initialization, better: # before a direct-list-initialization. nl_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after the open brace in an unnamed temporary # direct-list-initialization. nl_type_brace_init_lst_open = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before the close brace in an unnamed temporary # direct-list-initialization. nl_type_brace_init_lst_close = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before '{'. nl_before_brace_open = false # true/false # Whether to add a newline after '{'. nl_after_brace_open = false # true/false # Whether to add a newline between the open brace and a trailing single-line # comment. Requires nl_after_brace_open=true. nl_after_brace_open_cmt = false # true/false # Whether to add a newline after a virtual brace open with a non-empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open = false # true/false # Whether to add a newline after a virtual brace open with an empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open_empty = false # true/false # Whether to add a newline after '}'. Does not apply if followed by a # necessary ';'. nl_after_brace_close = false # true/false # Whether to add a newline after a virtual brace close, # as in 'if (foo) a++; return;'. nl_after_vbrace_close = false # true/false # Add or remove newline between the close brace and identifier, # as in 'struct { int a; } b;'. Affects enumerations, unions and # structures. If set to ignore, uses nl_after_brace_close. nl_brace_struct_var = ignore # ignore/add/remove/force/not_defined # Whether to alter newlines in '#define' macros. nl_define_macro = false # true/false # Whether to alter newlines between consecutive parenthesis closes. The number # of closing parentheses in a line will depend on respective open parenthesis # lines. nl_squeeze_paren_close = false # true/false # Whether to remove blanks after '#ifxx' and '#elxx', or before '#elxx' and # '#endif'. Does not affect top-level #ifdefs. nl_squeeze_ifdef = false # true/false # Makes the nl_squeeze_ifdef option affect the top-level #ifdefs as well. nl_squeeze_ifdef_top_level = false # true/false # Add or remove blank line before 'if'. nl_before_if = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'if' statement. Add/Force work only if the # next token is not a closing brace. nl_after_if = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'for'. nl_before_for = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'for' statement. nl_after_for = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'while'. nl_before_while = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'while' statement. nl_after_while = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'switch'. nl_before_switch = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'switch' statement. nl_after_switch = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'synchronized'. nl_before_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'synchronized' statement. nl_after_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'do'. nl_before_do = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'do/while' statement. nl_after_do = ignore # ignore/add/remove/force/not_defined # Ignore nl_before_{if,for,switch,do,synchronized} if the control # statement is immediately after a case statement. # if nl_before_{if,for,switch,do} is set to remove, this option # does nothing. nl_before_ignore_after_case = false # true/false # Whether to put a blank line before 'return' statements, unless after an open # brace. nl_before_return = false # true/false # Whether to put a blank line after 'return' statements, unless followed by a # close brace. nl_after_return = false # true/false # Whether to put a blank line before a member '.' or '->' operators. nl_before_member = ignore # ignore/add/remove/force/not_defined # (Java) Whether to put a blank line after a member '.' or '->' operators. nl_after_member = ignore # ignore/add/remove/force/not_defined # Whether to double-space commented-entries in 'struct'/'union'/'enum'. nl_ds_struct_enum_cmt = false # true/false # Whether to force a newline before '}' of a 'struct'/'union'/'enum'. # (Lower priority than eat_blanks_before_close_brace.) nl_ds_struct_enum_close_brace = false # true/false # Add or remove newline before or after (depending on pos_class_colon) a class # colon, as in 'class Foo : public Bar'. nl_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove newline around a class constructor colon. The exact position # depends on nl_constr_init_args, pos_constr_colon and pos_constr_comma. nl_constr_colon = ignore # ignore/add/remove/force/not_defined # Whether to collapse a two-line namespace, like 'namespace foo\n{ decl; }' # into a single line. If true, prevents other brace newline rules from turning # such code into four lines. If true, it also preserves one-liner namespaces. nl_namespace_two_to_one_liner = false # true/false # Whether to remove a newline in simple unbraced if statements, turning them # into one-liners, as in 'if(b)\n i++;' => 'if(b) i++;'. nl_create_if_one_liner = false # true/false # Whether to remove a newline in simple unbraced for statements, turning them # into one-liners, as in 'for (...)\n stmt;' => 'for (...) stmt;'. nl_create_for_one_liner = false # true/false # Whether to remove a newline in simple unbraced while statements, turning # them into one-liners, as in 'while (expr)\n stmt;' => 'while (expr) stmt;'. nl_create_while_one_liner = false # true/false # Whether to collapse a function definition whose body (not counting braces) # is only one line so that the entire definition (prototype, braces, body) is # a single line. nl_create_func_def_one_liner = false # true/false # Whether to split one-line simple list definitions into three lines by # adding newlines, as in 'int a[12] = { 0 };'. nl_create_list_one_liner = false # true/false # Whether to split one-line simple unbraced if statements into two lines by # adding a newline, as in 'if(b) i++;'. nl_split_if_one_liner = false # true/false # Whether to split one-line simple unbraced for statements into two lines by # adding a newline, as in 'for (...) stmt;'. nl_split_for_one_liner = false # true/false # Whether to split one-line simple unbraced while statements into two lines by # adding a newline, as in 'while (expr) stmt;'. nl_split_while_one_liner = false # true/false # Don't add a newline before a cpp-comment in a parameter list of a function # call. donot_add_nl_before_cpp_comment = false # true/false # # Blank line options # # The maximum number of consecutive newlines (3 = 2 blank lines). nl_max = 0 # unsigned number # The maximum number of consecutive newlines in a function. nl_max_blank_in_func = 0 # unsigned number # The number of newlines inside an empty function body. # This option overrides eat_blanks_after_open_brace and # eat_blanks_before_close_brace, but is ignored when # nl_collapse_empty_body_functions=true nl_inside_empty_func = 0 # unsigned number # The number of newlines before a function prototype. nl_before_func_body_proto = 0 # unsigned number # The number of newlines before a multi-line function definition. Where # applicable, this option is overridden with eat_blanks_after_open_brace=true nl_before_func_body_def = 0 # unsigned number # The number of newlines before a class constructor/destructor prototype. nl_before_func_class_proto = 0 # unsigned number # The number of newlines before a class constructor/destructor definition. nl_before_func_class_def = 0 # unsigned number # The number of newlines after a function prototype. nl_after_func_proto = 0 # unsigned number # The number of newlines after a function prototype, if not followed by # another function prototype. nl_after_func_proto_group = 0 # unsigned number # The number of newlines after a class constructor/destructor prototype. nl_after_func_class_proto = 0 # unsigned number # The number of newlines after a class constructor/destructor prototype, # if not followed by another constructor/destructor prototype. nl_after_func_class_proto_group = 0 # unsigned number # Whether one-line method definitions inside a class body should be treated # as if they were prototypes for the purposes of adding newlines. # # Requires nl_class_leave_one_liners=true. Overrides nl_before_func_body_def # and nl_before_func_class_def for one-liners. nl_class_leave_one_liner_groups = false # true/false # The number of newlines after '}' of a multi-line function body. nl_after_func_body = 0 # unsigned number # The number of newlines after '}' of a multi-line function body in a class # declaration. Also affects class constructors/destructors. # # Overrides nl_after_func_body. nl_after_func_body_class = 0 # unsigned number # The number of newlines after '}' of a single line function body. Also # affects class constructors/destructors. # # Overrides nl_after_func_body and nl_after_func_body_class. nl_after_func_body_one_liner = 0 # unsigned number # The number of newlines before a block of typedefs. If nl_after_access_spec # is non-zero, that option takes precedence. # # 0: No change (default). nl_typedef_blk_start = 0 # unsigned number # The number of newlines after a block of typedefs. # # 0: No change (default). nl_typedef_blk_end = 0 # unsigned number # The maximum number of consecutive newlines within a block of typedefs. # # 0: No change (default). nl_typedef_blk_in = 0 # unsigned number # The minimum number of blank lines after a block of variable definitions # at the top of a function body. If any preprocessor directives appear # between the opening brace of the function and the variable block, then # it is considered as not at the top of the function.Newlines are added # before trailing preprocessor directives, if any exist. # # 0: No change (default). nl_var_def_blk_end_func_top = 0 # unsigned number # The minimum number of empty newlines before a block of variable definitions # not at the top of a function body. If nl_after_access_spec is non-zero, # that option takes precedence. Newlines are not added at the top of the # file or just after an opening brace. Newlines are added above any # preprocessor directives before the block. # # 0: No change (default). nl_var_def_blk_start = 0 # unsigned number # The minimum number of empty newlines after a block of variable definitions # not at the top of a function body. Newlines are not added if the block # is at the bottom of the file or just before a preprocessor directive. # # 0: No change (default). nl_var_def_blk_end = 0 # unsigned number # The maximum number of consecutive newlines within a block of variable # definitions. # # 0: No change (default). nl_var_def_blk_in = 0 # unsigned number # The minimum number of newlines before a multi-line comment. # Doesn't apply if after a brace open or another multi-line comment. nl_before_block_comment = 0 # unsigned number # The minimum number of newlines before a single-line C comment. # Doesn't apply if after a brace open or other single-line C comments. nl_before_c_comment = 0 # unsigned number # The minimum number of newlines before a CPP comment. # Doesn't apply if after a brace open or other CPP comments. nl_before_cpp_comment = 0 # unsigned number # Whether to force a newline after a multi-line comment. nl_after_multiline_comment = false # true/false # Whether to force a newline after a label's colon. nl_after_label_colon = false # true/false # The number of newlines before a struct definition. nl_before_struct = 0 # unsigned number # The number of newlines after '}' or ';' of a struct/enum/union definition. nl_after_struct = 0 # unsigned number # The number of newlines before a class definition. nl_before_class = 0 # unsigned number # The number of newlines after '}' or ';' of a class definition. nl_after_class = 0 # unsigned number # The number of newlines before a namespace. nl_before_namespace = 0 # unsigned number # The number of newlines after '{' of a namespace. This also adds newlines # before the matching '}'. # # 0: Apply eat_blanks_after_open_brace or eat_blanks_before_close_brace if # applicable, otherwise no change. # # Overrides eat_blanks_after_open_brace and eat_blanks_before_close_brace. nl_inside_namespace = 0 # unsigned number # The number of newlines after '}' of a namespace. nl_after_namespace = 0 # unsigned number # The number of newlines before an access specifier label. This also includes # the Qt-specific 'signals:' and 'slots:'. Will not change the newline count # if after a brace open. # # 0: No change (default). nl_before_access_spec = 0 # unsigned number # The number of newlines after an access specifier label. This also includes # the Qt-specific 'signals:' and 'slots:'. Will not change the newline count # if after a brace open. # # 0: No change (default). # # Overrides nl_typedef_blk_start and nl_var_def_blk_start. nl_after_access_spec = 0 # unsigned number # The number of newlines between a function definition and the function # comment, as in '// comment\n void foo() {...}'. # # 0: No change (default). nl_comment_func_def = 0 # unsigned number # The number of newlines after a try-catch-finally block that isn't followed # by a brace close. # # 0: No change (default). nl_after_try_catch_finally = 0 # unsigned number # (C#) The number of newlines before and after a property, indexer or event # declaration. # # 0: No change (default). nl_around_cs_property = 0 # unsigned number # (C#) The number of newlines between the get/set/add/remove handlers. # # 0: No change (default). nl_between_get_set = 0 # unsigned number # (C#) Add or remove newline between property and the '{'. nl_property_brace = ignore # ignore/add/remove/force/not_defined # Whether to remove blank lines after '{'. eat_blanks_after_open_brace = false # true/false # Whether to remove blank lines before '}'. eat_blanks_before_close_brace = false # true/false # How aggressively to remove extra newlines not in preprocessor. # # 0: No change (default) # 1: Remove most newlines not handled by other config # 2: Remove all newlines and reformat completely by config nl_remove_extra_newlines = 0 # unsigned number # (Java) Add or remove newline after an annotation statement. Only affects # annotations that are after a newline. nl_after_annotation = ignore # ignore/add/remove/force/not_defined # (Java) Add or remove newline between two annotations. nl_between_annotation = ignore # ignore/add/remove/force/not_defined # The number of newlines before a whole-file #ifdef. # # 0: No change (default). nl_before_whole_file_ifdef = 0 # unsigned number # The number of newlines after a whole-file #ifdef. # # 0: No change (default). nl_after_whole_file_ifdef = 0 # unsigned number # The number of newlines before a whole-file #endif. # # 0: No change (default). nl_before_whole_file_endif = 0 # unsigned number # The number of newlines after a whole-file #endif. # # 0: No change (default). nl_after_whole_file_endif = 0 # unsigned number # # Positioning options # # The position of arithmetic operators in wrapped expressions. pos_arith = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of assignment in wrapped expressions. Do not affect '=' # followed by '{'. pos_assign = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of Boolean operators in wrapped expressions. pos_bool = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of comparison operators in wrapped expressions. pos_compare = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of conditional operators, as in the '?' and ':' of # 'expr ? stmt : stmt', in wrapped expressions. pos_conditional = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in wrapped expressions. pos_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in enum entries. pos_enum_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in the base class list if there is more than one # line. Affects nl_class_init_args. pos_class_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in the constructor initialization list. # Related to nl_constr_colon, nl_constr_init_args and pos_constr_colon. pos_constr_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of trailing/leading class colon, between class and base class # list. Affects nl_class_colon. pos_class_colon = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of colons between constructor and member initialization. # Related to nl_constr_colon, nl_constr_init_args and pos_constr_comma. pos_constr_colon = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of shift operators in wrapped expressions. pos_shift = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # # Line splitting options # # Try to limit code width to N columns. code_width = 0 # unsigned number # Whether to fully split long 'for' statements at semi-colons. ls_for_split_full = false # true/false # Whether to fully split long function prototypes/calls at commas. # The option ls_code_width has priority over the option ls_func_split_full. ls_func_split_full = false # true/false # Whether to split lines as close to code_width as possible and ignore some # groupings. # The option ls_code_width has priority over the option ls_func_split_full. ls_code_width = false # true/false # # Code alignment options (not left column spaces/tabs) # # Whether to keep non-indenting tabs. align_keep_tabs = false # true/false # Whether to use tabs for aligning. align_with_tabs = false # true/false # Whether to bump out to the next tab when aligning. align_on_tabstop = false # true/false # Whether to right-align numbers. align_number_right = false # true/false # Whether to keep whitespace not required for alignment. align_keep_extra_space = false # true/false # Whether to align variable definitions in prototypes and functions. align_func_params = false # true/false # The span for aligning parameter definitions in function on parameter name. # # 0: Don't align (default). align_func_params_span = 0 # unsigned number # The threshold for aligning function parameter definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_func_params_thresh = 0 # number # The gap for aligning function parameter definitions. align_func_params_gap = 0 # unsigned number # The span for aligning constructor value. # # 0: Don't align (default). align_constr_value_span = 0 # unsigned number # The threshold for aligning constructor value. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_constr_value_thresh = 0 # number # The gap for aligning constructor value. align_constr_value_gap = 0 # unsigned number # Whether to align parameters in single-line functions that have the same # name. The function names must already be aligned with each other. align_same_func_call_params = false # true/false # The span for aligning function-call parameters for single line functions. # # 0: Don't align (default). align_same_func_call_params_span = 0 # unsigned number # The threshold for aligning function-call parameters for single line # functions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_same_func_call_params_thresh = 0 # number # The span for aligning variable definitions. # # 0: Don't align (default). align_var_def_span = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of variable definitions. # # 0: Part of the type 'void * foo;' (default) # 1: Part of the variable 'void *foo;' # 2: Dangling 'void *foo;' # Dangling: the '*' will not be taken into account when aligning. align_var_def_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of variable definitions. # # 0: Part of the type 'long & foo;' (default) # 1: Part of the variable 'long &foo;' # 2: Dangling 'long &foo;' # Dangling: the '&' will not be taken into account when aligning. align_var_def_amp_style = 0 # unsigned number # The threshold for aligning variable definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_def_thresh = 0 # number # The gap for aligning variable definitions. align_var_def_gap = 0 # unsigned number # Whether to align the colon in struct bit fields. align_var_def_colon = false # true/false # The gap for aligning the colon in struct bit fields. align_var_def_colon_gap = 0 # unsigned number # Whether to align any attribute after the variable name. align_var_def_attribute = false # true/false # Whether to align inline struct/enum/union variable definitions. align_var_def_inline = false # true/false # The span for aligning on '=' in assignments. # # 0: Don't align (default). align_assign_span = 0 # unsigned number # The span for aligning on '=' in function prototype modifier. # # 0: Don't align (default). align_assign_func_proto_span = 0 # unsigned number # The threshold for aligning on '=' in assignments. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_assign_thresh = 0 # number # Whether to align on the left most assignment when multiple # definitions are found on the same line. # Depends on 'align_assign_span' and 'align_assign_thresh' settings. align_assign_on_multi_var_defs = false # true/false # The span for aligning on '{' in braced init list. # # 0: Don't align (default). align_braced_init_list_span = 0 # unsigned number # The threshold for aligning on '{' in braced init list. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_braced_init_list_thresh = 0 # number # How to apply align_assign_span to function declaration "assignments", i.e. # 'virtual void foo() = 0' or '~foo() = {default|delete}'. # # 0: Align with other assignments (default) # 1: Align with each other, ignoring regular assignments # 2: Don't align align_assign_decl_func = 0 # unsigned number # The span for aligning on '=' in enums. # # 0: Don't align (default). align_enum_equ_span = 0 # unsigned number # The threshold for aligning on '=' in enums. # Use a negative number for absolute thresholds. # # 0: no limit (default). align_enum_equ_thresh = 0 # number # The span for aligning class member definitions. # # 0: Don't align (default). align_var_class_span = 0 # unsigned number # The threshold for aligning class member definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_class_thresh = 0 # number # The gap for aligning class member definitions. align_var_class_gap = 0 # unsigned number # The span for aligning struct/union member definitions. # # 0: Don't align (default). align_var_struct_span = 0 # unsigned number # The threshold for aligning struct/union member definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_struct_thresh = 0 # number # The gap for aligning struct/union member definitions. align_var_struct_gap = 0 # unsigned number # The span for aligning struct initializer values. # # 0: Don't align (default). align_struct_init_span = 0 # unsigned number # The span for aligning single-line typedefs. # # 0: Don't align (default). align_typedef_span = 0 # unsigned number # The minimum space between the type and the synonym of a typedef. align_typedef_gap = 0 # unsigned number # How to align typedef'd functions with other typedefs. # # 0: Don't mix them at all (default) # 1: Align the open parenthesis with the types # 2: Align the function type name with the other type names align_typedef_func = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of typedefs. # # 0: Part of the typedef type, 'typedef int * pint;' (default) # 1: Part of type name: 'typedef int *pint;' # 2: Dangling: 'typedef int *pint;' # Dangling: the '*' will not be taken into account when aligning. align_typedef_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of typedefs. # # 0: Part of the typedef type, 'typedef int & intref;' (default) # 1: Part of type name: 'typedef int &intref;' # 2: Dangling: 'typedef int &intref;' # Dangling: the '&' will not be taken into account when aligning. align_typedef_amp_style = 0 # unsigned number # The span for aligning comments that end lines. # # 0: Don't align (default). align_right_cmt_span = 0 # unsigned number # Minimum number of columns between preceding text and a trailing comment in # order for the comment to qualify for being aligned. Must be non-zero to have # an effect. align_right_cmt_gap = 0 # unsigned number # If aligning comments, whether to mix with comments after '}' and #endif with # less than three spaces before the comment. align_right_cmt_mix = false # true/false # Whether to only align trailing comments that are at the same brace level. align_right_cmt_same_level = false # true/false # Minimum column at which to align trailing comments. Comments which are # aligned beyond this column, but which can be aligned in a lesser column, # may be "pulled in". # # 0: Ignore (default). align_right_cmt_at_col = 0 # unsigned number # The span for aligning function prototypes. # # 0: Don't align (default). align_func_proto_span = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of function prototypes. # # 0: Part of the type 'void * foo();' (default) # 1: Part of the function 'void *foo();' # 2: Dangling 'void *foo();' # Dangling: the '*' will not be taken into account when aligning. align_func_proto_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of function prototypes. # # 0: Part of the type 'long & foo();' (default) # 1: Part of the function 'long &foo();' # 2: Dangling 'long &foo();' # Dangling: the '&' will not be taken into account when aligning. align_func_proto_amp_style = 0 # unsigned number # The threshold for aligning function prototypes. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_func_proto_thresh = 0 # number # Minimum gap between the return type and the function name. align_func_proto_gap = 0 # unsigned number # Whether to align function prototypes on the 'operator' keyword instead of # what follows. align_on_operator = false # true/false # Whether to mix aligning prototype and variable declarations. If true, # align_var_def_XXX options are used instead of align_func_proto_XXX options. align_mix_var_proto = false # true/false # Whether to align single-line functions with function prototypes. # Uses align_func_proto_span. align_single_line_func = false # true/false # Whether to align the open brace of single-line functions. # Requires align_single_line_func=true. Uses align_func_proto_span. align_single_line_brace = false # true/false # Gap for align_single_line_brace. align_single_line_brace_gap = 0 # unsigned number # (OC) The span for aligning Objective-C message specifications. # # 0: Don't align (default). align_oc_msg_spec_span = 0 # unsigned number # Whether to align macros wrapped with a backslash and a newline. This will # not work right if the macro contains a multi-line comment. align_nl_cont = false # true/false # Whether to align macro functions and variables together. align_pp_define_together = false # true/false # The span for aligning on '#define' bodies. # # =0: Don't align (default) # >0: Number of lines (including comments) between blocks align_pp_define_span = 0 # unsigned number # The minimum space between label and value of a preprocessor define. align_pp_define_gap = 0 # unsigned number # Whether to align lines that start with '<<' with previous '<<'. # # Default: true align_left_shift = true # true/false # Whether to align comma-separated statements following '<<' (as used to # initialize Eigen matrices). align_eigen_comma_init = false # true/false # Whether to align text after 'asm volatile ()' colons. align_asm_colon = false # true/false # (OC) Span for aligning parameters in an Objective-C message call # on the ':'. # # 0: Don't align. align_oc_msg_colon_span = 0 # unsigned number # (OC) Whether to always align with the first parameter, even if it is too # short. align_oc_msg_colon_first = false # true/false # (OC) Whether to align parameters in an Objective-C '+' or '-' declaration # on the ':'. align_oc_decl_colon = false # true/false # (OC) Whether to not align parameters in an Objectve-C message call if first # colon is not on next line of the message call (the same way Xcode does # alignment) align_oc_msg_colon_xcode_like = false # true/false # # Comment modification options # # Try to wrap comments at N columns. cmt_width = 0 # unsigned number # How to reflow comments. # # 0: No reflowing (apart from the line wrapping due to cmt_width) (default) # 1: No touching at all # 2: Full reflow (enable cmt_indent_multi for indent with line wrapping due to cmt_width) cmt_reflow_mode = 0 # unsigned number # Path to a file that contains regular expressions describing patterns for # which the end of one line and the beginning of the next will be folded into # the same sentence or paragraph during full comment reflow. The regular # expressions are described using ECMAScript syntax. The syntax for this # specification is as follows, where "..." indicates the custom regular # expression and "n" indicates the nth end_of_prev_line_regex and # beg_of_next_line_regex regular expression pair: # # end_of_prev_line_regex[1] = "...$" # beg_of_next_line_regex[1] = "^..." # end_of_prev_line_regex[2] = "...$" # beg_of_next_line_regex[2] = "^..." # . # . # . # end_of_prev_line_regex[n] = "...$" # beg_of_next_line_regex[n] = "^..." # # Note that use of this option overrides the default reflow fold regular # expressions, which are internally defined as follows: # # end_of_prev_line_regex[1] = "[\w,\]\)]$" # beg_of_next_line_regex[1] = "^[\w,\[\(]" # end_of_prev_line_regex[2] = "\.$" # beg_of_next_line_regex[2] = "^[A-Z]" cmt_reflow_fold_regex_file = "" # string # Whether to indent wrapped lines to the start of the encompassing paragraph # during full comment reflow (cmt_reflow_mode = 2). Overrides the value # specified by cmt_sp_after_star_cont. # # Note that cmt_align_doxygen_javadoc_tags overrides this option for # paragraphs associated with javadoc tags cmt_reflow_indent_to_paragraph_start = false # true/false # Whether to convert all tabs to spaces in comments. If false, tabs in # comments are left alone, unless used for indenting. cmt_convert_tab_to_spaces = false # true/false # Whether to apply changes to multi-line comments, including cmt_width, # keyword substitution and leading chars. # # Default: true cmt_indent_multi = true # true/false # Whether to align doxygen javadoc-style tags ('@param', '@return', etc.) # and corresponding fields such that groups of consecutive block tags, # parameter names, and descriptions align with one another. Overrides that # which is specified by the cmt_sp_after_star_cont. If cmt_width > 0, it may # be necessary to enable cmt_indent_multi and set cmt_reflow_mode = 2 # in order to achieve the desired alignment for line-wrapping. cmt_align_doxygen_javadoc_tags = false # true/false # The number of spaces to insert after the star and before doxygen # javadoc-style tags (@param, @return, etc). Requires enabling # cmt_align_doxygen_javadoc_tags. Overrides that which is specified by the # cmt_sp_after_star_cont. # # Default: 1 cmt_sp_before_doxygen_javadoc_tags = 1 # unsigned number # Whether to change trailing, single-line c-comments into cpp-comments. cmt_trailing_single_line_c_to_cpp = false # true/false # Whether to group c-comments that look like they are in a block. cmt_c_group = false # true/false # Whether to put an empty '/*' on the first line of the combined c-comment. cmt_c_nl_start = false # true/false # Whether to add a newline before the closing '*/' of the combined c-comment. cmt_c_nl_end = false # true/false # Whether to change cpp-comments into c-comments. cmt_cpp_to_c = false # true/false # Whether to group cpp-comments that look like they are in a block. Only # meaningful if cmt_cpp_to_c=true. cmt_cpp_group = false # true/false # Whether to put an empty '/*' on the first line of the combined cpp-comment # when converting to a c-comment. # # Requires cmt_cpp_to_c=true and cmt_cpp_group=true. cmt_cpp_nl_start = false # true/false # Whether to add a newline before the closing '*/' of the combined cpp-comment # when converting to a c-comment. # # Requires cmt_cpp_to_c=true and cmt_cpp_group=true. cmt_cpp_nl_end = false # true/false # Whether to put a star on subsequent comment lines. cmt_star_cont = false # true/false # The number of spaces to insert at the start of subsequent comment lines. cmt_sp_before_star_cont = 0 # unsigned number # The number of spaces to insert after the star on subsequent comment lines. cmt_sp_after_star_cont = 0 # unsigned number # For multi-line comments with a '*' lead, remove leading spaces if the first # and last lines of the comment are the same length. # # Default: true cmt_multi_check_last = true # true/false # For multi-line comments with a '*' lead, remove leading spaces if the first # and last lines of the comment are the same length AND if the length is # bigger as the first_len minimum. # # Default: 4 cmt_multi_first_len_minimum = 4 # unsigned number # Path to a file that contains text to insert at the beginning of a file if # the file doesn't start with a C/C++ comment. If the inserted text contains # '$(filename)', that will be replaced with the current file's name. cmt_insert_file_header = "" # string # Path to a file that contains text to insert at the end of a file if the # file doesn't end with a C/C++ comment. If the inserted text contains # '$(filename)', that will be replaced with the current file's name. cmt_insert_file_footer = "" # string # Path to a file that contains text to insert before a function definition if # the function isn't preceded by a C/C++ comment. If the inserted text # contains '$(function)', '$(javaparam)' or '$(fclass)', these will be # replaced with, respectively, the name of the function, the javadoc '@param' # and '@return' stuff, or the name of the class to which the member function # belongs. cmt_insert_func_header = "" # string # Path to a file that contains text to insert before a class if the class # isn't preceded by a C/C++ comment. If the inserted text contains '$(class)', # that will be replaced with the class name. cmt_insert_class_header = "" # string # Path to a file that contains text to insert before an Objective-C message # specification, if the method isn't preceded by a C/C++ comment. If the # inserted text contains '$(message)' or '$(javaparam)', these will be # replaced with, respectively, the name of the function, or the javadoc # '@param' and '@return' stuff. cmt_insert_oc_msg_header = "" # string # Whether a comment should be inserted if a preprocessor is encountered when # stepping backwards from a function name. # # Applies to cmt_insert_oc_msg_header, cmt_insert_func_header and # cmt_insert_class_header. cmt_insert_before_preproc = false # true/false # Whether a comment should be inserted if a function is declared inline to a # class definition. # # Applies to cmt_insert_func_header. # # Default: true cmt_insert_before_inlines = true # true/false # Whether a comment should be inserted if the function is a class constructor # or destructor. # # Applies to cmt_insert_func_header. cmt_insert_before_ctor_dtor = false # true/false # # Code modifying options (non-whitespace) # # Add or remove braces on a single-line 'do' statement. mod_full_brace_do = ignore # ignore/add/remove/force/not_defined # Add or remove braces on a single-line 'for' statement. mod_full_brace_for = ignore # ignore/add/remove/force/not_defined # (Pawn) Add or remove braces on a single-line function definition. mod_full_brace_function = ignore # ignore/add/remove/force/not_defined # Add or remove braces on a single-line 'if' statement. Braces will not be # removed if the braced statement contains an 'else'. mod_full_brace_if = ignore # ignore/add/remove/force/not_defined # Whether to enforce that all blocks of an 'if'/'else if'/'else' chain either # have, or do not have, braces. Overrides mod_full_brace_if. # # 0: Don't override mod_full_brace_if # 1: Add braces to all blocks if any block needs braces and remove braces if # they can be removed from all blocks # 2: Add braces to all blocks if any block already has braces, regardless of # whether it needs them # 3: Add braces to all blocks if any block needs braces and remove braces if # they can be removed from all blocks, except if all blocks have braces # despite none needing them mod_full_brace_if_chain = 0 # unsigned number # Whether to add braces to all blocks of an 'if'/'else if'/'else' chain. # If true, mod_full_brace_if_chain will only remove braces from an 'if' that # does not have an 'else if' or 'else'. mod_full_brace_if_chain_only = false # true/false # Add or remove braces on single-line 'while' statement. mod_full_brace_while = ignore # ignore/add/remove/force/not_defined # Add or remove braces on single-line 'using ()' statement. mod_full_brace_using = ignore # ignore/add/remove/force/not_defined # Don't remove braces around statements that span N newlines mod_full_brace_nl = 0 # unsigned number # Whether to prevent removal of braces from 'if'/'for'/'while'/etc. blocks # which span multiple lines. # # Affects: # mod_full_brace_for # mod_full_brace_if # mod_full_brace_if_chain # mod_full_brace_if_chain_only # mod_full_brace_while # mod_full_brace_using # # Does not affect: # mod_full_brace_do # mod_full_brace_function mod_full_brace_nl_block_rem_mlcond = false # true/false # Add or remove unnecessary parentheses on 'return' statement. mod_paren_on_return = ignore # ignore/add/remove/force/not_defined # Add or remove unnecessary parentheses on 'throw' statement. mod_paren_on_throw = ignore # ignore/add/remove/force/not_defined # (Pawn) Whether to change optional semicolons to real semicolons. mod_pawn_semicolon = false # true/false # Whether to fully parenthesize Boolean expressions in 'while' and 'if' # statement, as in 'if (a && b > c)' => 'if (a && (b > c))'. mod_full_paren_if_bool = false # true/false # Whether to fully parenthesize Boolean expressions after '=' # statement, as in 'x = a && b > c;' => 'x = (a && (b > c));'. mod_full_paren_assign_bool = false # true/false # Whether to fully parenthesize Boolean expressions after '=' # statement, as in 'return a && b > c;' => 'return (a && (b > c));'. mod_full_paren_return_bool = false # true/false # Whether to remove superfluous semicolons. mod_remove_extra_semicolon = false # true/false # Whether to remove duplicate include. mod_remove_duplicate_include = false # true/false # If a function body exceeds the specified number of newlines and doesn't have # a comment after the close brace, a comment will be added. mod_add_long_function_closebrace_comment = 0 # unsigned number # If a namespace body exceeds the specified number of newlines and doesn't # have a comment after the close brace, a comment will be added. mod_add_long_namespace_closebrace_comment = 0 # unsigned number # If a class body exceeds the specified number of newlines and doesn't have a # comment after the close brace, a comment will be added. mod_add_long_class_closebrace_comment = 0 # unsigned number # If a switch body exceeds the specified number of newlines and doesn't have a # comment after the close brace, a comment will be added. mod_add_long_switch_closebrace_comment = 0 # unsigned number # If an #ifdef body exceeds the specified number of newlines and doesn't have # a comment after the #endif, a comment will be added. mod_add_long_ifdef_endif_comment = 0 # unsigned number # If an #ifdef or #else body exceeds the specified number of newlines and # doesn't have a comment after the #else, a comment will be added. mod_add_long_ifdef_else_comment = 0 # unsigned number # Whether to take care of the case by the mod_sort_xx options. mod_sort_case_sensitive = false # true/false # Whether to sort consecutive single-line 'import' statements. mod_sort_import = false # true/false # (C#) Whether to sort consecutive single-line 'using' statements. mod_sort_using = false # true/false # Whether to sort consecutive single-line '#include' statements (C/C++) and # '#import' statements (Objective-C). Be aware that this has the potential to # break your code if your includes/imports have ordering dependencies. mod_sort_include = false # true/false # Whether to prioritize '#include' and '#import' statements that contain # filename without extension when sorting is enabled. mod_sort_incl_import_prioritize_filename = false # true/false # Whether to prioritize '#include' and '#import' statements that does not # contain extensions when sorting is enabled. mod_sort_incl_import_prioritize_extensionless = false # true/false # Whether to prioritize '#include' and '#import' statements that contain # angle over quotes when sorting is enabled. mod_sort_incl_import_prioritize_angle_over_quotes = false # true/false # Whether to ignore file extension in '#include' and '#import' statements # for sorting comparison. mod_sort_incl_import_ignore_extension = false # true/false # Whether to group '#include' and '#import' statements when sorting is enabled. mod_sort_incl_import_grouping_enabled = false # true/false # Whether to move a 'break' that appears after a fully braced 'case' before # the close brace, as in 'case X: { ... } break;' => 'case X: { ... break; }'. mod_move_case_break = false # true/false # Whether to move a 'return' that appears after a fully braced 'case' before # the close brace, as in 'case X: { ... } return;' => 'case X: { ... return; }'. mod_move_case_return = false # true/false # Add or remove braces around a fully braced case statement. Will only remove # braces if there are no variable declarations in the block. mod_case_brace = ignore # ignore/add/remove/force/not_defined # Whether to remove a void 'return;' that appears as the last statement in a # function. mod_remove_empty_return = false # true/false # Add or remove the comma after the last value of an enumeration. mod_enum_last_comma = ignore # ignore/add/remove/force/not_defined # Syntax to use for infinite loops. # # 0: Leave syntax alone (default) # 1: Rewrite as `for(;;)` # 2: Rewrite as `while(true)` # 3: Rewrite as `do`...`while(true);` # 4: Rewrite as `while(1)` # 5: Rewrite as `do`...`while(1);` # # Infinite loops that do not already match one of these syntaxes are ignored. # Other options that affect loop formatting will be applied after transforming # the syntax. mod_infinite_loop = 0 # unsigned number # Add or remove the 'int' keyword in 'int short'. mod_int_short = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'short int'. mod_short_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int long'. mod_int_long = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'long int'. mod_long_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int signed'. mod_int_signed = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'signed int'. mod_signed_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int unsigned'. mod_int_unsigned = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'unsigned int'. mod_unsigned_int = ignore # ignore/add/remove/force/not_defined # If there is a situation where mod_int_* and mod_*_int would result in # multiple int keywords, whether to keep the rightmost int (the default) or the # leftmost int. mod_int_prefer_int_on_left = false # true/false # (OC) Whether to organize the properties. If true, properties will be # rearranged according to the mod_sort_oc_property_*_weight factors. mod_sort_oc_properties = false # true/false # (OC) Weight of a class property modifier. mod_sort_oc_property_class_weight = 0 # number # (OC) Weight of 'atomic' and 'nonatomic'. mod_sort_oc_property_thread_safe_weight = 0 # number # (OC) Weight of 'readwrite' when organizing properties. mod_sort_oc_property_readwrite_weight = 0 # number # (OC) Weight of a reference type specifier ('retain', 'copy', 'assign', # 'weak', 'strong') when organizing properties. mod_sort_oc_property_reference_weight = 0 # number # (OC) Weight of getter type ('getter=') when organizing properties. mod_sort_oc_property_getter_weight = 0 # number # (OC) Weight of setter type ('setter=') when organizing properties. mod_sort_oc_property_setter_weight = 0 # number # (OC) Weight of nullability type ('nullable', 'nonnull', 'null_unspecified', # 'null_resettable') when organizing properties. mod_sort_oc_property_nullability_weight = 0 # number # # Preprocessor options # # How to use tabs when indenting preprocessor code. # # -1: Use 'indent_with_tabs' setting (default) # 0: Spaces only # 1: Indent with tabs to brace level, align with spaces # 2: Indent and align with tabs, using spaces when not on a tabstop # # Default: -1 pp_indent_with_tabs = -1 # number # Add or remove indentation of preprocessor directives inside #if blocks # at brace level 0 (file-level). pp_indent = ignore # ignore/add/remove/force/not_defined # Whether to indent #if/#else/#endif at the brace level. If false, these are # indented from column 1. pp_indent_at_level = false # true/false # Whether to indent #if/#else/#endif at the parenthesis level if the brace # level is 0. If false, these are indented from column 1. pp_indent_at_level0 = false # true/false # Specifies the number of columns to indent preprocessors per level # at brace level 0 (file-level). If pp_indent_at_level=false, also specifies # the number of columns to indent preprocessors per level # at brace level > 0 (function-level). # # Default: 1 pp_indent_count = 1 # unsigned number # Add or remove space after # based on pp level of #if blocks. pp_space_after = ignore # ignore/add/remove/force/not_defined # Sets the number of spaces per level added with pp_space_after. pp_space_count = 0 # unsigned number # The indent for '#region' and '#endregion' in C# and '#pragma region' in # C/C++. Negative values decrease indent down to the first column. pp_indent_region = 0 # number # Whether to indent the code between #region and #endregion. pp_region_indent_code = false # true/false # If pp_indent_at_level=true, sets the indent for #if, #else and #endif when # not at file-level. Negative values decrease indent down to the first column. # # =0: Indent preprocessors using output_tab_size # >0: Column at which all preprocessors will be indented pp_indent_if = 0 # number # Whether to indent the code between #if, #else and #endif. pp_if_indent_code = false # true/false # Whether to indent the body of an #if that encompasses all the code in the file. pp_indent_in_guard = false # true/false # Whether to indent '#define' at the brace level. If false, these are # indented from column 1. pp_define_at_level = false # true/false # Whether to indent '#include' at the brace level. pp_include_at_level = false # true/false # Whether to ignore the '#define' body while formatting. pp_ignore_define_body = false # true/false # An offset value that controls the indentation of the body of a multiline #define. # 'body' refers to all the lines of a multiline #define except the first line. # Requires 'pp_ignore_define_body = false'. # # <0: Absolute column: the body indentation starts off at the specified column # (ex. -3 ==> the body is indented starting from column 3) # >=0: Relative to the column of the '#' of '#define' # (ex. 3 ==> the body is indented starting 3 columns at the right of '#') # # Default: 8 pp_multiline_define_body_indent = 8 # number # Whether to indent case statements between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the case statements # directly inside of. # # Default: true pp_indent_case = true # true/false # Whether to indent whole function definitions between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the function definition # is directly inside of. # # Default: true pp_indent_func_def = true # true/false # Whether to indent extern C blocks between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the extern block is # directly inside of. # # Default: true pp_indent_extern = true # true/false # How to indent braces directly inside #if, #else, and #endif. # Requires pp_if_indent_code=true and only applies to the indent of the # preprocessor that the braces are directly inside of. # 0: No extra indent # 1: Indent by one level # -1: Preserve original indentation # # Default: 1 pp_indent_brace = 1 # number # Whether to print warning messages for unbalanced #if and #else blocks. # This will print a message in the following cases: # - if an #ifdef block ends on a different indent level than # where it started from. Example: # # #ifdef TEST # int i; # { # int j; # #endif # # - an #elif/#else block ends on a different indent level than # the corresponding #ifdef block. Example: # # #ifdef TEST # int i; # #else # } # int j; # #endif pp_warn_unbalanced_if = false # true/false # # Sort includes options # # The regex for include category with priority 0. include_category_0 = "" # string # The regex for include category with priority 1. include_category_1 = "" # string # The regex for include category with priority 2. include_category_2 = "" # string # # Use or Do not Use options # # true: indent_func_call_param will be used (default) # false: indent_func_call_param will NOT be used # # Default: true use_indent_func_call_param = true # true/false # The value of the indentation for a continuation line is calculated # differently if the statement is: # - a declaration: your case with QString fileName ... # - an assignment: your case with pSettings = new QSettings( ... # # At the second case the indentation value might be used twice: # - at the assignment # - at the function call (if present) # # To prevent the double use of the indentation value, use this option with the # value 'true'. # # true: indent_continue will be used only once # false: indent_continue will be used every time (default) # # Requires indent_ignore_first_continue=false. use_indent_continue_only_once = false # true/false # The indentation can be: # - after the assignment, at the '[' character # - at the beginning of the lambda body # # true: indentation will be at the beginning of the lambda body # false: indentation will be after the assignment (default) indent_cpp_lambda_only_once = false # true/false # Whether sp_after_angle takes precedence over sp_inside_fparen. This was the # historic behavior, but is probably not the desired behavior, so this is off # by default. use_sp_after_angle_always = false # true/false # Whether to apply special formatting for Qt SIGNAL/SLOT macros. Essentially, # this tries to format these so that they match Qt's normalized form (i.e. the # result of QMetaObject::normalizedSignature), which can slightly improve the # performance of the QObject::connect call, rather than how they would # otherwise be formatted. # # See options_for_QT.cpp for details. # # Default: true use_options_overriding_for_qt_macros = true # true/false # If true: the form feed character is removed from the list of whitespace # characters. See https://en.cppreference.com/w/cpp/string/byte/isspace. use_form_feed_no_more_as_whitespace_character = false # true/false # # Warn levels - 1: error, 2: warning (default), 3: note # # (C#) Warning is given if doing tab-to-\t replacement and we have found one # in a C# verbatim string literal. # # Default: 2 warn_level_tabs_found_in_verbatim_string_literals = 2 # unsigned number # Limit the number of loops. # Used by uncrustify.cpp to exit from infinite loop. # 0: no limit. debug_max_number_of_loops = 0 # number # Set the number of the line to protocol; # Used in the function prot_the_line if the 2. parameter is zero. # 0: nothing protocol. debug_line_number_to_protocol = 0 # number # Set the number of second(s) before terminating formatting the current file, # 0: no timeout. # only for linux debug_timeout = 0 # number # Set the number of characters to be printed if the text is too long, # 0: do not truncate. debug_truncate = 0 # unsigned number # sort (or not) the tracking info. # # Default: true debug_sort_the_tracks = true # true/false # decode (or not) the flags as a new line. # only if the -p option is set. debug_decode_the_flags = false # true/false # insert the number of the line at the beginning of each line set_numbering_for_html_output = false # true/false # Meaning of the settings: # Ignore - do not do any changes # Add - makes sure there is 1 or more space/brace/newline/etc # Force - makes sure there is exactly 1 space/brace/newline/etc, # behaves like Add in some contexts # Remove - removes space/brace/newline/etc # # # - Token(s) can be treated as specific type(s) with the 'set' option: # `set tokenType tokenString [tokenString...]` # # Example: # `set BOOL __AND__ __OR__` # # tokenTypes are defined in src/token_enum.h, use them without the # 'CT_' prefix: 'CT_BOOL' => 'BOOL' # # # - Token(s) can be treated as type(s) with the 'type' option. # `type tokenString [tokenString...]` # # Example: # `type int c_uint_8 Rectangle` # # This can also be achieved with `set TYPE int c_uint_8 Rectangle` # # # To embed whitespace in tokenStrings use the '\' escape character, or quote # the tokenStrings. These quotes are supported: "'` # # # - Support for the auto detection of languages through the file ending can be # added using the 'file_ext' command. # `file_ext langType langString [langString..]` # # Example: # `file_ext CPP .ch .cxx .cpp.in` # # langTypes are defined in uncrusify_types.h in the lang_flag_e enum, use # them without the 'LANG_' prefix: 'LANG_CPP' => 'CPP' # # # - Custom macro-based indentation can be set up using 'macro-open', # 'macro-else' and 'macro-close'. # `(macro-open | macro-else | macro-close) tokenString` # # Example: # `macro-open BEGIN_TEMPLATE_MESSAGE_MAP` # `macro-open BEGIN_MESSAGE_MAP` # `macro-close END_MESSAGE_MAP` # # # option(s) with 'not default' value: 0 # uncrustify-uncrustify-0.76.0/documentation/htdocs/configuration.txt000066400000000000000000000043731434072136500260110ustar00rootroot00000000000000Quick documentation (probably out of date - see options.h) There are five type of arguments: - boolean (true/false) - numeric - ignore/add/remove/force - LF/CRLF/CR/AUTO - ignore/lead/trail "Ignore" means do not change it. "Add" in the context of spaces means make sure there is at least 1. "Add" elsewhere means make sure one is present. "Remove" mean remove the space/brace/newline/etc. "Force" in the context of spaces means ensure that there is exactly 1. "Force" in other contexts means the same as "add". Configuration items may reference previously defined configuration items. Numeric items may be prefixed with a '-' to invert the number. Boolean items may be prefixed with a '-' or '~' to invert the value. For example, the following is valid: output_tab_size = 4 indent_columns = output_tab_size All items default to false/0/ignore except: - newlines = auto - input_tab_size = 8 - output_tab_size = 8 - indent_columns = 8 - indent_with_tabs = 1 - indent_label = 1 - indent_access_spec = 1 - sp_before_comma = remove - string_escape_char = 92 # '\' Refer to set_option_defaults() Terminology: There are three types of parenthesis: sparen, fparen, paren. sparen are found with if/for/switch/while statements. fparen are found with function prototypes, calls and implementations. paren are everything else, such as those found with arithmetic ops. A 'span' is the maximum number of lines that a aligning feature will be considered. This is done to limit the scope of the aligning. So, if a span is set to 3 and more than 3 lines do not contain the item that is to be aligned, then the aligning set is closed. A 'gap' is the minimum spacing for aligned items. So, if it is set to 3 for typedefs, then there are a minimum of three spaces between the type and the typedef name. A 'threshold' is the maximum number of columns that a aligning feature will be considered. This is done to limit the scope of the aligning. This prevents really longs lines from being aligned with short lines. A list of all the options with documentation can be acquired by running uncrustify with the following options: $ uncrustify --show-config To get a valid configuration file with all defaults, run this: $ uncrustify -c /dev/null --update-config-with-doc uncrustify-uncrustify-0.76.0/documentation/htdocs/default.cfg000066400000000000000000004404511434072136500245070ustar00rootroot00000000000000# Uncrustify-0.76.0 # # General options # # The type of line endings. # # Default: auto newlines = auto # lf/crlf/cr/auto # The original size of tabs in the input. # # Default: 8 input_tab_size = 8 # unsigned number # The size of tabs in the output (only used if align_with_tabs=true). # # Default: 8 output_tab_size = 8 # unsigned number # The ASCII value of the string escape char, usually 92 (\) or (Pawn) 94 (^). # # Default: 92 string_escape_char = 92 # unsigned number # Alternate string escape char (usually only used for Pawn). # Only works right before the quote char. string_escape_char2 = 0 # unsigned number # Replace tab characters found in string literals with the escape sequence \t # instead. string_replace_tab_chars = false # true/false # Allow interpreting '>=' and '>>=' as part of a template in code like # 'void f(list>=val);'. If true, 'assert(x<0 && y>=3)' will be broken. # Improvements to template detection may make this option obsolete. tok_split_gte = false # true/false # Disable formatting of NL_CONT ('\\n') ended lines (e.g. multi-line macros). disable_processing_nl_cont = false # true/false # Specify the marker used in comments to disable processing of part of the # file. # # Default: *INDENT-OFF* disable_processing_cmt = " *INDENT-OFF*" # string # Specify the marker used in comments to (re)enable processing in a file. # # Default: *INDENT-ON* enable_processing_cmt = " *INDENT-ON*" # string # Enable parsing of digraphs. enable_digraphs = false # true/false # Option to allow both disable_processing_cmt and enable_processing_cmt # strings, if specified, to be interpreted as ECMAScript regular expressions. # If true, a regex search will be performed within comments according to the # specified patterns in order to disable/enable processing. processing_cmt_as_regex = false # true/false # Add or remove the UTF-8 BOM (recommend 'remove'). utf8_bom = ignore # ignore/add/remove/force/not_defined # If the file contains bytes with values between 128 and 255, but is not # UTF-8, then output as UTF-8. utf8_byte = false # true/false # Force the output encoding to UTF-8. utf8_force = false # true/false # # Spacing options # # Add or remove space around non-assignment symbolic operators ('+', '/', '%', # '<<', and so forth). sp_arith = ignore # ignore/add/remove/force/not_defined # Add or remove space around arithmetic operators '+' and '-'. # # Overrides sp_arith. sp_arith_additive = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment operator '=', '+=', etc. sp_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space around '=' in C++11 lambda capture specifications. # # Overrides sp_assign. sp_cpp_lambda_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after the capture specification of a C++11 lambda when # an argument list is present, as in '[] (int x){ ... }'. sp_cpp_lambda_square_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the capture specification of a C++11 lambda with # no argument list is present, as in '[] { ... }'. sp_cpp_lambda_square_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space after the opening parenthesis and before the closing # parenthesis of a argument list of a C++11 lambda, as in # '[]( int x ){ ... }'. sp_cpp_lambda_argument_list = ignore # ignore/add/remove/force/not_defined # Add or remove space after the argument list of a C++11 lambda, as in # '[](int x) { ... }'. sp_cpp_lambda_paren_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between a lambda body and its call operator of an # immediately invoked lambda, as in '[]( ... ){ ... } ( ... )'. sp_cpp_lambda_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment operator '=' in a prototype. # # If set to ignore, use sp_assign. sp_assign_default = ignore # ignore/add/remove/force/not_defined # Add or remove space before assignment operator '=', '+=', etc. # # Overrides sp_assign. sp_before_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after assignment operator '=', '+=', etc. # # Overrides sp_assign. sp_after_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space in 'enum {'. # # Default: add sp_enum_brace = add # ignore/add/remove/force/not_defined # Add or remove space in 'NS_ENUM ('. sp_enum_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment '=' in enum. sp_enum_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space before assignment '=' in enum. # # Overrides sp_enum_assign. sp_enum_before_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after assignment '=' in enum. # # Overrides sp_enum_assign. sp_enum_after_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment ':' in enum. sp_enum_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space around preprocessor '##' concatenation operator. # # Default: add sp_pp_concat = add # ignore/add/remove/force/not_defined # Add or remove space after preprocessor '#' stringify operator. # Also affects the '#@' charizing operator. sp_pp_stringify = ignore # ignore/add/remove/force/not_defined # Add or remove space before preprocessor '#' stringify operator # as in '#define x(y) L#y'. sp_before_pp_stringify = ignore # ignore/add/remove/force/not_defined # Add or remove space around boolean operators '&&' and '||'. sp_bool = ignore # ignore/add/remove/force/not_defined # Add or remove space around compare operator '<', '>', '==', etc. sp_compare = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')'. sp_inside_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested parentheses, i.e. '((' vs. ') )'. sp_paren_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('. sp_cparen_oparen = ignore # ignore/add/remove/force/not_defined # Whether to balance spaces inside nested parentheses. sp_balance_nested_parens = false # true/false # Add or remove space between ')' and '{'. sp_paren_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested braces, i.e. '{{' vs. '{ {'. sp_brace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space before pointer star '*'. sp_before_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space before pointer star '*' that isn't followed by a # variable name. If set to ignore, sp_before_ptr_star is used instead. sp_before_unnamed_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space between pointer stars '*', as in 'int ***a;'. sp_between_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer star '*', if followed by a word. # # Overrides sp_type_func. sp_after_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer caret '^', if followed by a word. sp_after_ptr_block_caret = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer star '*', if followed by a qualifier. sp_after_ptr_star_qualifier = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*', if followed by a function # prototype or function definition. # # Overrides sp_after_ptr_star and sp_type_func. sp_after_ptr_star_func = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*' in the trailing return of a # function prototype or function definition. sp_after_ptr_star_trailing = ignore # ignore/add/remove/force/not_defined # Add or remove space between the pointer star '*' and the name of the variable # in a function pointer definition. sp_ptr_star_func_var = ignore # ignore/add/remove/force/not_defined # Add or remove space between the pointer star '*' and the name of the type # in a function pointer type definition. sp_ptr_star_func_type = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*', if followed by an open # parenthesis, as in 'void* (*)()'. sp_ptr_star_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space before a pointer star '*', if followed by a function # prototype or function definition. sp_before_ptr_star_func = ignore # ignore/add/remove/force/not_defined # Add or remove space before a pointer star '*' in the trailing return of a # function prototype or function definition. sp_before_ptr_star_trailing = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&'. sp_before_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&' that isn't followed by a # variable name. If set to ignore, sp_before_byref is used instead. sp_before_unnamed_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space after reference sign '&', if followed by a word. # # Overrides sp_type_func. sp_after_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space after a reference sign '&', if followed by a function # prototype or function definition. # # Overrides sp_after_byref and sp_type_func. sp_after_byref_func = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&', if followed by a function # prototype or function definition. sp_before_byref_func = ignore # ignore/add/remove/force/not_defined # Add or remove space after a reference sign '&', if followed by an open # parenthesis, as in 'char& (*)()'. sp_byref_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between type and word. In cases where total removal of # whitespace would be a syntax error, a value of 'remove' is treated the same # as 'force'. # # This also affects some other instances of space following a type that are # not covered by other options; for example, between the return type and # parenthesis of a function type template argument, between the type and # parenthesis of an array parameter, or between 'decltype(...)' and the # following word. # # Default: force sp_after_type = force # ignore/add/remove/force/not_defined # Add or remove space between 'decltype(...)' and word, # brace or function call. sp_after_decltype = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space before the parenthesis in the D constructs # 'template Foo(' and 'class Foo('. sp_before_template_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'template' and '<'. # If set to ignore, sp_before_angle is used. sp_template_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space before '<'. sp_before_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '<' and '>'. sp_inside_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '<>'. sp_inside_angle_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and ':'. sp_angle_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after '>'. sp_after_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '(' as found in 'new List(foo);'. sp_angle_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '()' as found in 'new List();'. sp_angle_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and a word as in 'List m;' or # 'template static ...'. sp_angle_word = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '>' in '>>' (template stuff). # # Default: add sp_angle_shift = add # ignore/add/remove/force/not_defined # (C++11) Permit removal of the space between '>>' in 'foo >'. Note # that sp_angle_shift cannot remove the space without this option. sp_permit_cpp11_shift = false # true/false # Add or remove space before '(' of control statements ('if', 'for', 'switch', # 'while', etc.). sp_before_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')' of control statements other than # 'for'. sp_inside_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space after '(' of control statements other than 'for'. # # Overrides sp_inside_sparen. sp_inside_sparen_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before ')' of control statements other than 'for'. # # Overrides sp_inside_sparen. sp_inside_sparen_close = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')' of 'for' statements. sp_inside_for = ignore # ignore/add/remove/force/not_defined # Add or remove space after '(' of 'for' statements. # # Overrides sp_inside_for. sp_inside_for_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before ')' of 'for' statements. # # Overrides sp_inside_for. sp_inside_for_close = ignore # ignore/add/remove/force/not_defined # Add or remove space between '((' or '))' of control statements. sp_sparen_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after ')' of control statements. sp_after_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of control statements. sp_sparen_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'do' and '{'. sp_do_brace_open = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'while'. sp_brace_close_while = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'while' and '('. Overrides sp_before_sparen. sp_while_paren_open = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'invariant' and '('. sp_invariant_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space after the ')' in 'invariant (C) c'. sp_after_invariant_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space before empty statement ';' on 'if', 'for' and 'while'. sp_special_semi = ignore # ignore/add/remove/force/not_defined # Add or remove space before ';'. # # Default: remove sp_before_semi = remove # ignore/add/remove/force/not_defined # Add or remove space before ';' in non-empty 'for' statements. sp_before_semi_for = ignore # ignore/add/remove/force/not_defined # Add or remove space before a semicolon of an empty left part of a for # statement, as in 'for ( ; ; )'. sp_before_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between the semicolons of an empty middle part of a for # statement, as in 'for ( ; ; )'. sp_between_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after ';', except when followed by a comment. # # Default: add sp_after_semi = add # ignore/add/remove/force/not_defined # Add or remove space after ';' in non-empty 'for' statements. # # Default: force sp_after_semi_for = force # ignore/add/remove/force/not_defined # Add or remove space after the final semicolon of an empty part of a for # statement, as in 'for ( ; ; )'. sp_after_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[' (except '[]'). sp_before_square = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[' for a variable definition. # # Default: remove sp_before_vardef_square = remove # ignore/add/remove/force/not_defined # Add or remove space before '[' for asm block. sp_before_square_asm_block = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[]'. sp_before_squares = ignore # ignore/add/remove/force/not_defined # Add or remove space before C++17 structured bindings. sp_cpp_before_struct_binding = ignore # ignore/add/remove/force/not_defined # Add or remove space inside a non-empty '[' and ']'. sp_inside_square = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '[]'. sp_inside_square_empty = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside a non-empty Objective-C boxed array '@[' and # ']'. If set to ignore, sp_inside_square is used. sp_inside_square_oc_array = ignore # ignore/add/remove/force/not_defined # Add or remove space after ',', i.e. 'a,b' vs. 'a, b'. sp_after_comma = ignore # ignore/add/remove/force/not_defined # Add or remove space before ',', i.e. 'a,b' vs. 'a ,b'. # # Default: remove sp_before_comma = remove # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between ',' and ']' in multidimensional array type # like 'int[,,]'. sp_after_mdatype_commas = ignore # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between '[' and ',' in multidimensional array type # like 'int[,,]'. sp_before_mdatype_commas = ignore # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between ',' in multidimensional array type # like 'int[,,]'. sp_between_mdatype_commas = ignore # ignore/add/remove/force/not_defined # Add or remove space between an open parenthesis and comma, # i.e. '(,' vs. '( ,'. # # Default: force sp_paren_comma = force # ignore/add/remove/force/not_defined # Add or remove space between a type and ':'. sp_type_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after the variadic '...' when preceded by a # non-punctuator. # The value REMOVE will be overridden with FORCE sp_after_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space before the variadic '...' when preceded by a # non-punctuator. # The value REMOVE will be overridden with FORCE sp_before_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between a type and '...'. sp_type_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between a '*' and '...'. sp_ptr_type_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '...'. sp_paren_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between '&&' and '...'. sp_byref_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and a qualifier such as 'const'. sp_paren_qualifier = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and 'noexcept'. sp_paren_noexcept = ignore # ignore/add/remove/force/not_defined # Add or remove space after class ':'. sp_after_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before class ':'. sp_before_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after class constructor ':'. # # Default: add sp_after_constr_colon = add # ignore/add/remove/force/not_defined # Add or remove space before class constructor ':'. # # Default: add sp_before_constr_colon = add # ignore/add/remove/force/not_defined # Add or remove space before case ':'. # # Default: remove sp_before_case_colon = remove # ignore/add/remove/force/not_defined # Add or remove space between 'operator' and operator sign. sp_after_operator = ignore # ignore/add/remove/force/not_defined # Add or remove space between the operator symbol and the open parenthesis, as # in 'operator ++('. sp_after_operator_sym = ignore # ignore/add/remove/force/not_defined # Overrides sp_after_operator_sym when the operator has no arguments, as in # 'operator *()'. sp_after_operator_sym_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after C/D cast, i.e. 'cast(int)a' vs. 'cast(int) a' or # '(int)a' vs. '(int) a'. sp_after_cast = ignore # ignore/add/remove/force/not_defined # Add or remove spaces inside cast parentheses. sp_inside_paren_cast = ignore # ignore/add/remove/force/not_defined # Add or remove space between the type and open parenthesis in a C++ cast, # i.e. 'int(exp)' vs. 'int (exp)'. sp_cpp_cast_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof' and '('. sp_sizeof_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof' and '...'. sp_sizeof_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof...' and '('. sp_sizeof_ellipsis_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between '...' and a parameter pack. sp_ellipsis_parameter_pack = ignore # ignore/add/remove/force/not_defined # Add or remove space between a parameter pack and '...'. sp_parameter_pack_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'decltype' and '('. sp_decltype_paren = ignore # ignore/add/remove/force/not_defined # (Pawn) Add or remove space after the tag keyword. sp_after_tag = ignore # ignore/add/remove/force/not_defined # Add or remove space inside enum '{' and '}'. sp_inside_braces_enum = ignore # ignore/add/remove/force/not_defined # Add or remove space inside struct/union '{' and '}'. sp_inside_braces_struct = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}' sp_inside_braces_oc_dict = ignore # ignore/add/remove/force/not_defined # Add or remove space after open brace in an unnamed temporary # direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore. sp_after_type_brace_init_lst_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before close brace in an unnamed temporary # direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore. sp_before_type_brace_init_lst_close = ignore # ignore/add/remove/force/not_defined # Add or remove space inside an unnamed temporary direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore # works only if sp_before_type_brace_init_lst_close is set to ignore. sp_inside_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '{' and '}'. sp_inside_braces = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '{}'. sp_inside_braces_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space around trailing return operator '->'. sp_trailing_return = ignore # ignore/add/remove/force/not_defined # Add or remove space between return type and function name. A minimum of 1 # is forced except for pointer return types. sp_type_func = ignore # ignore/add/remove/force/not_defined # Add or remove space between type and open brace of an unnamed temporary # direct-list-initialization. sp_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' on function declaration. sp_func_proto_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function declaration # without parameters. sp_func_proto_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' with a typedef specifier. sp_func_type_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between alias name and '(' of a non-pointer function type typedef. sp_func_def_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function definition # without parameters. sp_func_def_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space inside empty function '()'. # Overrides sp_after_angle unless use_sp_after_angle_always is set to true. sp_inside_fparens = ignore # ignore/add/remove/force/not_defined # Add or remove space inside function '(' and ')'. sp_inside_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space inside the first parentheses in a function type, as in # 'void (*x)(...)'. sp_inside_tparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between the ')' and '(' in a function type, as in # 'void (*x)(...)'. sp_after_tparen_close = ignore # ignore/add/remove/force/not_defined # Add or remove space between ']' and '(' when part of a function call. sp_square_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of function. sp_fparen_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of a function call in object # initialization. # # Overrides sp_fparen_brace. sp_fparen_brace_initializer = ignore # ignore/add/remove/force/not_defined # (Java) Add or remove space between ')' and '{{' of double brace initializer. sp_fparen_dbrace = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' on function calls. sp_func_call_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function calls without # parameters. If set to ignore (the default), sp_func_call_paren is used. sp_func_call_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between the user function name and '(' on function # calls. You need to set a keyword to be a user function in the config file, # like: # set func_call_user tr _ i18n sp_func_call_user_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space inside user function '(' and ')'. sp_func_call_user_inside_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested parentheses with user functions, # i.e. '((' vs. '( ('. sp_func_call_user_paren_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between a constructor/destructor and the open # parenthesis. sp_func_class_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between a constructor without parameters or destructor # and '()'. sp_func_class_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after 'return'. # # Default: force sp_return = force # ignore/add/remove/force/not_defined # Add or remove space between 'return' and '('. sp_return_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'return' and '{'. sp_return_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '__attribute__' and '('. sp_attribute_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'defined' and '(' in '#if defined (FOO)'. sp_defined_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'throw' and '(' in 'throw (something)'. sp_throw_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'throw' and anything other than '(' as in # '@throw [...];'. sp_after_throw = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'catch' and '(' in 'catch (something) { }'. # If set to ignore, sp_before_sparen is used. sp_catch_paren = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@catch' and '(' # in '@catch (something) { }'. If set to ignore, sp_catch_paren is used. sp_oc_catch_paren = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before Objective-C protocol list # as in '@protocol Protocol' or '@interface MyClass : NSObject'. sp_before_oc_proto_list = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between class name and '(' # in '@interface className(categoryName):BaseClass' sp_oc_classname_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'version' and '(' # in 'version (something) { }'. If set to ignore, sp_before_sparen is used. sp_version_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'scope' and '(' # in 'scope (something) { }'. If set to ignore, sp_before_sparen is used. sp_scope_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'super' and '(' in 'super (something)'. # # Default: remove sp_super_paren = remove # ignore/add/remove/force/not_defined # Add or remove space between 'this' and '(' in 'this (something)'. # # Default: remove sp_this_paren = remove # ignore/add/remove/force/not_defined # Add or remove space between a macro name and its definition. sp_macro = ignore # ignore/add/remove/force/not_defined # Add or remove space between a macro function ')' and its definition. sp_macro_func = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'else' and '{' if on the same line. sp_else_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'else' if on the same line. sp_brace_else = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and the name of a typedef on the same line. sp_brace_typedef = ignore # ignore/add/remove/force/not_defined # Add or remove space before the '{' of a 'catch' statement, if the '{' and # 'catch' are on the same line, as in 'catch (decl) {'. sp_catch_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the '{' of a '@catch' statement, if the '{' # and '@catch' are on the same line, as in '@catch (decl) {'. # If set to ignore, sp_catch_brace is used. sp_oc_catch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'catch' if on the same line. sp_brace_catch = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '}' and '@catch' if on the same line. # If set to ignore, sp_brace_catch is used. sp_oc_brace_catch = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'finally' and '{' if on the same line. sp_finally_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'finally' if on the same line. sp_brace_finally = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'try' and '{' if on the same line. sp_try_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between get/set and '{' if on the same line. sp_getset_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between a variable and '{' for C++ uniform # initialization. sp_word_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space between a variable and '{' for a namespace. # # Default: add sp_word_brace_ns = add # ignore/add/remove/force/not_defined # Add or remove space before the '::' operator. sp_before_dc = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '::' operator. sp_after_dc = ignore # ignore/add/remove/force/not_defined # (D) Add or remove around the D named array initializer ':' operator. sp_d_array_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '!' (not) unary operator. # # Default: remove sp_not = remove # ignore/add/remove/force/not_defined # Add or remove space between two '!' (not) unary operators. # If set to ignore, sp_not will be used. sp_not_not = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '~' (invert) unary operator. # # Default: remove sp_inv = remove # ignore/add/remove/force/not_defined # Add or remove space after the '&' (address-of) unary operator. This does not # affect the spacing after a '&' that is part of a type. # # Default: remove sp_addr = remove # ignore/add/remove/force/not_defined # Add or remove space around the '.' or '->' operators. # # Default: remove sp_member = remove # ignore/add/remove/force/not_defined # Add or remove space after the '*' (dereference) unary operator. This does # not affect the spacing after a '*' that is part of a type. # # Default: remove sp_deref = remove # ignore/add/remove/force/not_defined # Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. # # Default: remove sp_sign = remove # ignore/add/remove/force/not_defined # Add or remove space between '++' and '--' the word to which it is being # applied, as in '(--x)' or 'y++;'. # # Default: remove sp_incdec = remove # ignore/add/remove/force/not_defined # Add or remove space before a backslash-newline at the end of a line. # # Default: add sp_before_nl_cont = add # ignore/add/remove/force/not_defined # (OC) Add or remove space after the scope '+' or '-', as in '-(void) foo;' # or '+(int) bar;'. sp_after_oc_scope = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in message specs, # i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'. sp_after_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in message specs, # i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'. sp_before_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in immutable dictionary expression # 'NSDictionary *test = @{@"foo" :@"bar"};'. sp_after_oc_dict_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in immutable dictionary expression # 'NSDictionary *test = @{@"foo" :@"bar"};'. sp_before_oc_dict_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in message specs, # i.e. '[object setValue:1];' vs. '[object setValue: 1];'. sp_after_send_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in message specs, # i.e. '[object setValue:1];' vs. '[object setValue :1];'. sp_before_send_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the (type) in message specs, # i.e. '-(int)f: (int) x;' vs. '-(int)f: (int)x;'. sp_after_oc_type = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the first (type) in message specs, # i.e. '-(int) f:(int)x;' vs. '-(int)f:(int)x;'. sp_after_oc_return_type = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@selector' and '(', # i.e. '@selector(msgName)' vs. '@selector (msgName)'. # Also applies to '@protocol()' constructs. sp_after_oc_at_sel = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@selector(x)' and the following word, # i.e. '@selector(foo) a:' vs. '@selector(foo)a:'. sp_after_oc_at_sel_parens = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside '@selector' parentheses, # i.e. '@selector(foo)' vs. '@selector( foo )'. # Also applies to '@protocol()' constructs. sp_inside_oc_at_sel_parens = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before a block pointer caret, # i.e. '^int (int arg){...}' vs. ' ^int (int arg){...}'. sp_before_oc_block_caret = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after a block pointer caret, # i.e. '^int (int arg){...}' vs. '^ int (int arg){...}'. sp_after_oc_block_caret = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between the receiver and selector in a message, # as in '[receiver selector ...]'. sp_after_oc_msg_receiver = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after '@property'. sp_after_oc_property = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@synchronized' and the open parenthesis, # i.e. '@synchronized(foo)' vs. '@synchronized (foo)'. sp_after_oc_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove space around the ':' in 'b ? t : f'. sp_cond_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before the ':' in 'b ? t : f'. # # Overrides sp_cond_colon. sp_cond_colon_before = ignore # ignore/add/remove/force/not_defined # Add or remove space after the ':' in 'b ? t : f'. # # Overrides sp_cond_colon. sp_cond_colon_after = ignore # ignore/add/remove/force/not_defined # Add or remove space around the '?' in 'b ? t : f'. sp_cond_question = ignore # ignore/add/remove/force/not_defined # Add or remove space before the '?' in 'b ? t : f'. # # Overrides sp_cond_question. sp_cond_question_before = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '?' in 'b ? t : f'. # # Overrides sp_cond_question. sp_cond_question_after = ignore # ignore/add/remove/force/not_defined # In the abbreviated ternary form '(a ?: b)', add or remove space between '?' # and ':'. # # Overrides all other sp_cond_* options. sp_cond_ternary_short = ignore # ignore/add/remove/force/not_defined # Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make # sense here. sp_case_label = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space around the D '..' operator. sp_range = ignore # ignore/add/remove/force/not_defined # Add or remove space after ':' in a Java/C++11 range-based 'for', # as in 'for (Type var : expr)'. sp_after_for_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before ':' in a Java/C++11 range-based 'for', # as in 'for (Type var : expr)'. sp_before_for_colon = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'extern' and '(' as in 'extern (C)'. sp_extern_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the opening of a C++ comment, as in '// A'. sp_cmt_cpp_start = ignore # ignore/add/remove/force/not_defined # Add or remove space in a C++ region marker comment, as in '// BEGIN'. # A region marker is defined as a comment which is not preceded by other text # (i.e. the comment is the first non-whitespace on the line), and which starts # with either 'BEGIN' or 'END'. # # Overrides sp_cmt_cpp_start. sp_cmt_cpp_region = ignore # ignore/add/remove/force/not_defined # If true, space added with sp_cmt_cpp_start will be added after Doxygen # sequences like '///', '///<', '//!' and '//!<'. sp_cmt_cpp_doxygen = false # true/false # If true, space added with sp_cmt_cpp_start will be added after Qt translator # or meta-data comments like '//:', '//=', and '//~'. sp_cmt_cpp_qttr = false # true/false # Add or remove space between #else or #endif and a trailing comment. sp_endif_cmt = ignore # ignore/add/remove/force/not_defined # Add or remove space after 'new', 'delete' and 'delete[]'. sp_after_new = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'new' and '(' in 'new()'. sp_between_new_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and type in 'new(foo) BAR'. sp_after_newop_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space inside parentheses of the new operator # as in 'new(foo) BAR'. sp_inside_newop_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the open parenthesis of the new operator, # as in 'new(foo) BAR'. # # Overrides sp_inside_newop_paren. sp_inside_newop_paren_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before the close parenthesis of the new operator, # as in 'new(foo) BAR'. # # Overrides sp_inside_newop_paren. sp_inside_newop_paren_close = ignore # ignore/add/remove/force/not_defined # Add or remove space before a trailing comment. sp_before_tr_cmt = ignore # ignore/add/remove/force/not_defined # Number of spaces before a trailing comment. sp_num_before_tr_cmt = 0 # unsigned number # Add or remove space before an embedded comment. # # Default: force sp_before_emb_cmt = force # ignore/add/remove/force/not_defined # Number of spaces before an embedded comment. # # Default: 1 sp_num_before_emb_cmt = 1 # unsigned number # Add or remove space after an embedded comment. # # Default: force sp_after_emb_cmt = force # ignore/add/remove/force/not_defined # Number of spaces after an embedded comment. # # Default: 1 sp_num_after_emb_cmt = 1 # unsigned number # (Java) Add or remove space between an annotation and the open parenthesis. sp_annotation_paren = ignore # ignore/add/remove/force/not_defined # If true, vbrace tokens are dropped to the previous token and skipped. sp_skip_vbrace_tokens = false # true/false # Add or remove space after 'noexcept'. sp_after_noexcept = ignore # ignore/add/remove/force/not_defined # Add or remove space after '_'. sp_vala_after_translation = ignore # ignore/add/remove/force/not_defined # If true, a is inserted after #define. force_tab_after_define = false # true/false # # Indenting options # # The number of columns to indent per level. Usually 2, 3, 4, or 8. # # Default: 8 indent_columns = 8 # unsigned number # Whether to ignore indent for the first continuation line. Subsequent # continuation lines will still be indented to match the first. indent_ignore_first_continue = false # true/false # The continuation indent. If non-zero, this overrides the indent of '(', '[' # and '=' continuation indents. Negative values are OK; negative value is # absolute and not increased for each '(' or '[' level. # # For FreeBSD, this is set to 4. # Requires indent_ignore_first_continue=false. indent_continue = 0 # number # The continuation indent, only for class header line(s). If non-zero, this # overrides the indent of 'class' continuation indents. # Requires indent_ignore_first_continue=false. indent_continue_class_head = 0 # unsigned number # Whether to indent empty lines (i.e. lines which contain only spaces before # the newline character). indent_single_newlines = false # true/false # The continuation indent for func_*_param if they are true. If non-zero, this # overrides the indent. indent_param = 0 # unsigned number # How to use tabs when indenting code. # # 0: Spaces only # 1: Indent with tabs to brace level, align with spaces (default) # 2: Indent and align with tabs, using spaces when not on a tabstop # # Default: 1 indent_with_tabs = 1 # unsigned number # Whether to indent comments that are not at a brace level with tabs on a # tabstop. Requires indent_with_tabs=2. If false, will use spaces. indent_cmt_with_tabs = false # true/false # Whether to indent strings broken by '\' so that they line up. indent_align_string = false # true/false # The number of spaces to indent multi-line XML strings. # Requires indent_align_string=true. indent_xml_string = 0 # unsigned number # Spaces to indent '{' from level. indent_brace = 0 # unsigned number # Whether braces are indented to the body level. indent_braces = false # true/false # Whether to disable indenting function braces if indent_braces=true. indent_braces_no_func = false # true/false # Whether to disable indenting class braces if indent_braces=true. indent_braces_no_class = false # true/false # Whether to disable indenting struct braces if indent_braces=true. indent_braces_no_struct = false # true/false # Whether to indent based on the size of the brace parent, # i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc. indent_brace_parent = false # true/false # Whether to indent based on the open parenthesis instead of the open brace # in '({\n'. indent_paren_open_brace = false # true/false # (C#) Whether to indent the brace of a C# delegate by another level. indent_cs_delegate_brace = false # true/false # (C#) Whether to indent a C# delegate (to handle delegates with no brace) by # another level. indent_cs_delegate_body = false # true/false # Whether to indent the body of a 'namespace'. indent_namespace = false # true/false # Whether to indent only the first namespace, and not any nested namespaces. # Requires indent_namespace=true. indent_namespace_single_indent = false # true/false # The number of spaces to indent a namespace block. # If set to zero, use the value indent_columns indent_namespace_level = 0 # unsigned number # If the body of the namespace is longer than this number, it won't be # indented. Requires indent_namespace=true. 0 means no limit. indent_namespace_limit = 0 # unsigned number # Whether to indent only in inner namespaces (nested in other namespaces). # Requires indent_namespace=true. indent_namespace_inner_only = false # true/false # Whether the 'extern "C"' body is indented. indent_extern = false # true/false # Whether the 'class' body is indented. indent_class = false # true/false # Whether to ignore indent for the leading base class colon. indent_ignore_before_class_colon = false # true/false # Additional indent before the leading base class colon. # Negative values decrease indent down to the first column. # Requires indent_ignore_before_class_colon=false and a newline break before # the colon (see pos_class_colon and nl_class_colon) indent_before_class_colon = 0 # number # Whether to indent the stuff after a leading base class colon. indent_class_colon = false # true/false # Whether to indent based on a class colon instead of the stuff after the # colon. Requires indent_class_colon=true. indent_class_on_colon = false # true/false # Whether to ignore indent for a leading class initializer colon. indent_ignore_before_constr_colon = false # true/false # Whether to indent the stuff after a leading class initializer colon. indent_constr_colon = false # true/false # Virtual indent from the ':' for leading member initializers. # # Default: 2 indent_ctor_init_leading = 2 # unsigned number # Virtual indent from the ':' for following member initializers. # # Default: 2 indent_ctor_init_following = 2 # unsigned number # Additional indent for constructor initializer list. # Negative values decrease indent down to the first column. indent_ctor_init = 0 # number # Whether to indent 'if' following 'else' as a new block under the 'else'. # If false, 'else\nif' is treated as 'else if' for indenting purposes. indent_else_if = false # true/false # Amount to indent variable declarations after a open brace. # # <0: Relative # >=0: Absolute indent_var_def_blk = 0 # number # Whether to indent continued variable declarations instead of aligning. indent_var_def_cont = false # true/false # How to indent continued shift expressions ('<<' and '>>'). # Set align_left_shift=false when using this. # 0: Align shift operators instead of indenting them (default) # 1: Indent by one level # -1: Preserve original indentation indent_shift = 0 # number # Whether to force indentation of function definitions to start in column 1. indent_func_def_force_col1 = false # true/false # Whether to indent continued function call parameters one indent level, # rather than aligning parameters under the open parenthesis. indent_func_call_param = false # true/false # Whether to indent continued function definition parameters one indent level, # rather than aligning parameters under the open parenthesis. indent_func_def_param = false # true/false # for function definitions, only if indent_func_def_param is false # Allows to align params when appropriate and indent them when not # behave as if it was true if paren position is more than this value # if paren position is more than the option value indent_func_def_param_paren_pos_threshold = 0 # unsigned number # Whether to indent continued function call prototype one indent level, # rather than aligning parameters under the open parenthesis. indent_func_proto_param = false # true/false # Whether to indent continued function call declaration one indent level, # rather than aligning parameters under the open parenthesis. indent_func_class_param = false # true/false # Whether to indent continued class variable constructors one indent level, # rather than aligning parameters under the open parenthesis. indent_func_ctor_var_param = false # true/false # Whether to indent continued template parameter list one indent level, # rather than aligning parameters under the open parenthesis. indent_template_param = false # true/false # Double the indent for indent_func_xxx_param options. # Use both values of the options indent_columns and indent_param. indent_func_param_double = false # true/false # Indentation column for standalone 'const' qualifier on a function # prototype. indent_func_const = 0 # unsigned number # Indentation column for standalone 'throw' qualifier on a function # prototype. indent_func_throw = 0 # unsigned number # How to indent within a macro followed by a brace on the same line # This allows reducing the indent in macros that have (for example) # `do { ... } while (0)` blocks bracketing them. # # true: add an indent for the brace on the same line as the macro # false: do not add an indent for the brace on the same line as the macro # # Default: true indent_macro_brace = true # true/false # The number of spaces to indent a continued '->' or '.'. # Usually set to 0, 1, or indent_columns. indent_member = 0 # unsigned number # Whether lines broken at '.' or '->' should be indented by a single indent. # The indent_member option will not be effective if this is set to true. indent_member_single = false # true/false # Spaces to indent single line ('//') comments on lines before code. indent_single_line_comments_before = 0 # unsigned number # Spaces to indent single line ('//') comments on lines after code. indent_single_line_comments_after = 0 # unsigned number # When opening a paren for a control statement (if, for, while, etc), increase # the indent level by this value. Negative values decrease the indent level. indent_sparen_extra = 0 # number # Whether to indent trailing single line ('//') comments relative to the code # instead of trying to keep the same absolute column. indent_relative_single_line_comments = false # true/false # Spaces to indent 'case' from 'switch'. Usually 0 or indent_columns. # It might be wise to choose the same value for the option indent_case_brace. indent_switch_case = 0 # unsigned number # Spaces to indent the body of a 'switch' before any 'case'. # Usually the same as indent_columns or indent_switch_case. indent_switch_body = 0 # unsigned number # Whether to ignore indent for '{' following 'case'. indent_ignore_case_brace = false # true/false # Spaces to indent '{' from 'case'. By default, the brace will appear under # the 'c' in case. Usually set to 0 or indent_columns. Negative values are OK. # It might be wise to choose the same value for the option indent_switch_case. indent_case_brace = 0 # number # indent 'break' with 'case' from 'switch'. indent_switch_break_with_case = false # true/false # Whether to indent preprocessor statements inside of switch statements. # # Default: true indent_switch_pp = true # true/false # Spaces to shift the 'case' line, without affecting any other lines. # Usually 0. indent_case_shift = 0 # unsigned number # Whether to align comments before 'case' with the 'case'. # # Default: true indent_case_comment = true # true/false # Whether to indent comments not found in first column. # # Default: true indent_comment = true # true/false # Whether to indent comments found in first column. indent_col1_comment = false # true/false # Whether to indent multi string literal in first column. indent_col1_multi_string_literal = false # true/false # Align comments on adjacent lines that are this many columns apart or less. # # Default: 3 indent_comment_align_thresh = 3 # unsigned number # Whether to ignore indent for goto labels. indent_ignore_label = false # true/false # How to indent goto labels. Requires indent_ignore_label=false. # # >0: Absolute column where 1 is the leftmost column # <=0: Subtract from brace indent # # Default: 1 indent_label = 1 # number # How to indent access specifiers that are followed by a # colon. # # >0: Absolute column where 1 is the leftmost column # <=0: Subtract from brace indent # # Default: 1 indent_access_spec = 1 # number # Whether to indent the code after an access specifier by one level. # If true, this option forces 'indent_access_spec=0'. indent_access_spec_body = false # true/false # If an open parenthesis is followed by a newline, whether to indent the next # line so that it lines up after the open parenthesis (not recommended). indent_paren_nl = false # true/false # How to indent a close parenthesis after a newline. # # 0: Indent to body level (default) # 1: Align under the open parenthesis # 2: Indent to the brace level # -1: Preserve original indentation indent_paren_close = 0 # number # Whether to indent the open parenthesis of a function definition, # if the parenthesis is on its own line. indent_paren_after_func_def = false # true/false # Whether to indent the open parenthesis of a function declaration, # if the parenthesis is on its own line. indent_paren_after_func_decl = false # true/false # Whether to indent the open parenthesis of a function call, # if the parenthesis is on its own line. indent_paren_after_func_call = false # true/false # How to indent a comma when inside braces. # 0: Indent by one level (default) # 1: Align under the open brace # -1: Preserve original indentation indent_comma_brace = 0 # number # How to indent a comma when inside parentheses. # 0: Indent by one level (default) # 1: Align under the open parenthesis # -1: Preserve original indentation indent_comma_paren = 0 # number # How to indent a Boolean operator when inside parentheses. # 0: Indent by one level (default) # 1: Align under the open parenthesis # -1: Preserve original indentation indent_bool_paren = 0 # number # Whether to ignore the indentation of a Boolean operator when outside # parentheses. indent_ignore_bool = false # true/false # Whether to ignore the indentation of an arithmetic operator. indent_ignore_arith = false # true/false # Whether to indent a semicolon when inside a for parenthesis. # If true, aligns under the open for parenthesis. indent_semicolon_for_paren = false # true/false # Whether to ignore the indentation of a semicolon outside of a 'for' # statement. indent_ignore_semicolon = false # true/false # Whether to align the first expression to following ones # if indent_bool_paren=1. indent_first_bool_expr = false # true/false # Whether to align the first expression to following ones # if indent_semicolon_for_paren=true. indent_first_for_expr = false # true/false # If an open square is followed by a newline, whether to indent the next line # so that it lines up after the open square (not recommended). indent_square_nl = false # true/false # (ESQL/C) Whether to preserve the relative indent of 'EXEC SQL' bodies. indent_preserve_sql = false # true/false # Whether to ignore the indentation of an assignment operator. indent_ignore_assign = false # true/false # Whether to align continued statements at the '='. If false or if the '=' is # followed by a newline, the next line is indent one tab. # # Default: true indent_align_assign = true # true/false # If true, the indentation of the chunks after a '=' sequence will be set at # LHS token indentation column before '='. indent_off_after_assign = false # true/false # Whether to align continued statements at the '('. If false or the '(' is # followed by a newline, the next line indent is one tab. # # Default: true indent_align_paren = true # true/false # (OC) Whether to indent Objective-C code inside message selectors. indent_oc_inside_msg_sel = false # true/false # (OC) Whether to indent Objective-C blocks at brace level instead of usual # rules. indent_oc_block = false # true/false # (OC) Indent for Objective-C blocks in a message relative to the parameter # name. # # =0: Use indent_oc_block rules # >0: Use specified number of spaces to indent indent_oc_block_msg = 0 # unsigned number # (OC) Minimum indent for subsequent parameters indent_oc_msg_colon = 0 # unsigned number # (OC) Whether to prioritize aligning with initial colon (and stripping spaces # from lines, if necessary). # # Default: true indent_oc_msg_prioritize_first_colon = true # true/false # (OC) Whether to indent blocks the way that Xcode does by default # (from the keyword if the parameter is on its own line; otherwise, from the # previous indentation level). Requires indent_oc_block_msg=true. indent_oc_block_msg_xcode_style = false # true/false # (OC) Whether to indent blocks from where the brace is, relative to a # message keyword. Requires indent_oc_block_msg=true. indent_oc_block_msg_from_keyword = false # true/false # (OC) Whether to indent blocks from where the brace is, relative to a message # colon. Requires indent_oc_block_msg=true. indent_oc_block_msg_from_colon = false # true/false # (OC) Whether to indent blocks from where the block caret is. # Requires indent_oc_block_msg=true. indent_oc_block_msg_from_caret = false # true/false # (OC) Whether to indent blocks from where the brace caret is. # Requires indent_oc_block_msg=true. indent_oc_block_msg_from_brace = false # true/false # When indenting after virtual brace open and newline add further spaces to # reach this minimum indent. indent_min_vbrace_open = 0 # unsigned number # Whether to add further spaces after regular indent to reach next tabstop # when indenting after virtual brace open and newline. indent_vbrace_open_on_tabstop = false # true/false # How to indent after a brace followed by another token (not a newline). # true: indent all contained lines to match the token # false: indent all contained lines to match the brace # # Default: true indent_token_after_brace = true # true/false # Whether to indent the body of a C++11 lambda. indent_cpp_lambda_body = false # true/false # How to indent compound literals that are being returned. # true: add both the indent from return & the compound literal open brace # (i.e. 2 indent levels) # false: only indent 1 level, don't add the indent for the open brace, only # add the indent for the return. # # Default: true indent_compound_literal_return = true # true/false # (C#) Whether to indent a 'using' block if no braces are used. # # Default: true indent_using_block = true # true/false # How to indent the continuation of ternary operator. # # 0: Off (default) # 1: When the `if_false` is a continuation, indent it under the `if_true` branch # 2: When the `:` is a continuation, indent it under `?` indent_ternary_operator = 0 # unsigned number # Whether to indent the statements inside ternary operator. indent_inside_ternary_operator = false # true/false # If true, the indentation of the chunks after a `return` sequence will be set at return indentation column. indent_off_after_return = false # true/false # If true, the indentation of the chunks after a `return new` sequence will be set at return indentation column. indent_off_after_return_new = false # true/false # If true, the tokens after return are indented with regular single indentation. By default (false) the indentation is after the return token. indent_single_after_return = false # true/false # Whether to ignore indent and alignment for 'asm' blocks (i.e. assume they # have their own indentation). indent_ignore_asm_block = false # true/false # Don't indent the close parenthesis of a function definition, # if the parenthesis is on its own line. donot_indent_func_def_close_paren = false # true/false # # Newline adding and removing options # # Whether to collapse empty blocks between '{' and '}' except for functions. # Use nl_collapse_empty_body_functions to specify how empty function braces # should be formatted. nl_collapse_empty_body = false # true/false # Whether to collapse empty blocks between '{' and '}' for functions only. # If true, overrides nl_inside_empty_func. nl_collapse_empty_body_functions = false # true/false # Don't split one-line braced assignments, as in 'foo_t f = { 1, 2 };'. nl_assign_leave_one_liners = false # true/false # Don't split one-line braced statements inside a 'class xx { }' body. nl_class_leave_one_liners = false # true/false # Don't split one-line enums, as in 'enum foo { BAR = 15 };' nl_enum_leave_one_liners = false # true/false # Don't split one-line get or set functions. nl_getset_leave_one_liners = false # true/false # (C#) Don't split one-line property get or set functions. nl_cs_property_leave_one_liners = false # true/false # Don't split one-line function definitions, as in 'int foo() { return 0; }'. # might modify nl_func_type_name nl_func_leave_one_liners = false # true/false # Don't split one-line C++11 lambdas, as in '[]() { return 0; }'. nl_cpp_lambda_leave_one_liners = false # true/false # Don't split one-line if/else statements, as in 'if(...) b++;'. nl_if_leave_one_liners = false # true/false # Don't split one-line while statements, as in 'while(...) b++;'. nl_while_leave_one_liners = false # true/false # Don't split one-line do statements, as in 'do { b++; } while(...);'. nl_do_leave_one_liners = false # true/false # Don't split one-line for statements, as in 'for(...) b++;'. nl_for_leave_one_liners = false # true/false # (OC) Don't split one-line Objective-C messages. nl_oc_msg_leave_one_liner = false # true/false # (OC) Add or remove newline between method declaration and '{'. nl_oc_mdef_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between Objective-C block signature and '{'. nl_oc_block_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@interface' statement. nl_oc_before_interface = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@implementation' statement. nl_oc_before_implementation = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@end' statement. nl_oc_before_end = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '@interface' and '{'. nl_oc_interface_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '@implementation' and '{'. nl_oc_implementation_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newlines at the start of the file. nl_start_of_file = ignore # ignore/add/remove/force/not_defined # The minimum number of newlines at the start of the file (only used if # nl_start_of_file is 'add' or 'force'). nl_start_of_file_min = 0 # unsigned number # Add or remove newline at the end of the file. nl_end_of_file = ignore # ignore/add/remove/force/not_defined # The minimum number of newlines at the end of the file (only used if # nl_end_of_file is 'add' or 'force'). nl_end_of_file_min = 0 # unsigned number # Add or remove newline between '=' and '{'. nl_assign_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between '=' and '['. nl_assign_square = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '[]' and '{'. nl_tsquare_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline after '= ['. Will also affect the newline before # the ']'. nl_after_square_assign = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function call's ')' and '{', as in # 'list_for_each(item, &list) { }'. nl_fcall_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum' and '{'. nl_enum_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum' and 'class'. nl_enum_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class' and the identifier. nl_enum_class_identifier = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class' type and ':'. nl_enum_identifier_colon = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class identifier :' and type. nl_enum_colon_type = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'struct and '{'. nl_struct_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'union' and '{'. nl_union_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'if' and '{'. nl_if_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'else'. nl_brace_else = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else if' and '{'. If set to ignore, # nl_if_brace is used instead. nl_elseif_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else' and '{'. nl_else_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else' and 'if'. nl_else_if = ignore # ignore/add/remove/force/not_defined # Add or remove newline before '{' opening brace nl_before_opening_brace_func_class_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline before 'if'/'else if' closing parenthesis. nl_before_if_closing_paren = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'finally'. nl_brace_finally = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'finally' and '{'. nl_finally_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'try' and '{'. nl_try_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between get/set and '{'. nl_getset_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'for' and '{'. nl_for_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline before the '{' of a 'catch' statement, as in # 'catch (decl) {'. nl_catch_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline before the '{' of a '@catch' statement, as in # '@catch (decl) {'. If set to ignore, nl_catch_brace is used. nl_oc_catch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'catch'. nl_brace_catch = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '}' and '@catch'. If set to ignore, # nl_brace_catch is used. nl_oc_brace_catch = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and ']'. nl_brace_square = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and ')' in a function invocation. nl_brace_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'while' and '{'. nl_while_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'scope (x)' and '{'. nl_scope_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'unittest' and '{'. nl_unittest_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'version (x)' and '{'. nl_version_brace = ignore # ignore/add/remove/force/not_defined # (C#) Add or remove newline between 'using' and '{'. nl_using_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between two open or close braces. Due to general # newline/brace handling, REMOVE may not work. nl_brace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'do' and '{'. nl_do_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'while' of 'do' statement. nl_brace_while = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'switch' and '{'. nl_switch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'synchronized' and '{'. nl_synchronized_brace = ignore # ignore/add/remove/force/not_defined # Add a newline between ')' and '{' if the ')' is on a different line than the # if/for/etc. # # Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch and # nl_catch_brace. nl_multi_line_cond = false # true/false # Add a newline after '(' if an if/for/while/switch condition spans multiple # lines nl_multi_line_sparen_open = ignore # ignore/add/remove/force/not_defined # Add a newline before ')' if an if/for/while/switch condition spans multiple # lines. Overrides nl_before_if_closing_paren if both are specified. nl_multi_line_sparen_close = ignore # ignore/add/remove/force/not_defined # Force a newline in a define after the macro name for multi-line defines. nl_multi_line_define = false # true/false # Whether to add a newline before 'case', and a blank line before a 'case' # statement that follows a ';' or '}'. nl_before_case = false # true/false # Whether to add a newline after a 'case' statement. nl_after_case = false # true/false # Add or remove newline between a case ':' and '{'. # # Overrides nl_after_case. nl_case_colon_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between ')' and 'throw'. nl_before_throw = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'namespace' and '{'. nl_namespace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class. nl_template_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class declaration. # # Overrides nl_template_class. nl_template_class_decl = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized class declaration. # # Overrides nl_template_class_decl. nl_template_class_decl_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class definition. # # Overrides nl_template_class. nl_template_class_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized class definition. # # Overrides nl_template_class_def. nl_template_class_def_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function. nl_template_func = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function # declaration. # # Overrides nl_template_func. nl_template_func_decl = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized function # declaration. # # Overrides nl_template_func_decl. nl_template_func_decl_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function # definition. # # Overrides nl_template_func. nl_template_func_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized function # definition. # # Overrides nl_template_func_def. nl_template_func_def_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template variable. nl_template_var = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'template<...>' and 'using' of a templated # type alias. nl_template_using = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'class' and '{'. nl_class_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline before or after (depending on pos_class_comma, # may not be IGNORE) each',' in the base class list. nl_class_init_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in the constructor member # initialization. Related to nl_constr_colon, pos_constr_colon and # pos_constr_comma. nl_constr_init_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline before first element, after comma, and after last # element, in 'enum'. nl_enum_own_lines = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name in a function # definition. # might be modified by nl_func_leave_one_liners nl_func_type_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name inside a class # definition. If set to ignore, nl_func_type_name or nl_func_proto_type_name # is used instead. nl_func_type_name_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline between class specification and '::' # in 'void A::f() { }'. Only appears in separate member implementation (does # not appear with in-line implementation). nl_func_class_scope = ignore # ignore/add/remove/force/not_defined # Add or remove newline between function scope and name, as in # 'void A :: f() { }'. nl_func_scope_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name in a prototype. nl_func_proto_type_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # declaration. nl_func_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_paren for functions with no parameters. nl_func_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # definition. nl_func_def_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_paren for functions with no parameters. nl_func_def_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # call. nl_func_call_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_call_paren for functions with no parameters. nl_func_call_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline after '(' in a function declaration. nl_func_decl_start = ignore # ignore/add/remove/force/not_defined # Add or remove newline after '(' in a function definition. nl_func_def_start = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_decl_start when there is only one parameter. nl_func_decl_start_single = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_start when there is only one parameter. nl_func_def_start_single = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function declaration if '(' and ')' # are in different lines. If false, nl_func_decl_start is used instead. nl_func_decl_start_multi_line = false # true/false # Whether to add a newline after '(' in a function definition if '(' and ')' # are in different lines. If false, nl_func_def_start is used instead. nl_func_def_start_multi_line = false # true/false # Add or remove newline after each ',' in a function declaration. nl_func_decl_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in a function definition. nl_func_def_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in a function call. nl_func_call_args = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after each ',' in a function declaration if '(' # and ')' are in different lines. If false, nl_func_decl_args is used instead. nl_func_decl_args_multi_line = false # true/false # Whether to add a newline after each ',' in a function definition if '(' # and ')' are in different lines. If false, nl_func_def_args is used instead. nl_func_def_args_multi_line = false # true/false # Add or remove newline before the ')' in a function declaration. nl_func_decl_end = ignore # ignore/add/remove/force/not_defined # Add or remove newline before the ')' in a function definition. nl_func_def_end = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_decl_end when there is only one parameter. nl_func_decl_end_single = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_end when there is only one parameter. nl_func_def_end_single = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before ')' in a function declaration if '(' and ')' # are in different lines. If false, nl_func_decl_end is used instead. nl_func_decl_end_multi_line = false # true/false # Whether to add a newline before ')' in a function definition if '(' and ')' # are in different lines. If false, nl_func_def_end is used instead. nl_func_def_end_multi_line = false # true/false # Add or remove newline between '()' in a function declaration. nl_func_decl_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '()' in a function definition. nl_func_def_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '()' in a function call. nl_func_call_empty = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function call, # has preference over nl_func_call_start_multi_line. nl_func_call_start = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before ')' in a function call. nl_func_call_end = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function call if '(' and ')' are in # different lines. nl_func_call_start_multi_line = false # true/false # Whether to add a newline after each ',' in a function call if '(' and ')' # are in different lines. nl_func_call_args_multi_line = false # true/false # Whether to add a newline before ')' in a function call if '(' and ')' are in # different lines. nl_func_call_end_multi_line = false # true/false # Whether to respect nl_func_call_XXX option in case of closure args. nl_func_call_args_multi_line_ignore_closures = false # true/false # Whether to add a newline after '<' of a template parameter list. nl_template_start = false # true/false # Whether to add a newline after each ',' in a template parameter list. nl_template_args = false # true/false # Whether to add a newline before '>' of a template parameter list. nl_template_end = false # true/false # (OC) Whether to put each Objective-C message parameter on a separate line. # See nl_oc_msg_leave_one_liner. nl_oc_msg_args = false # true/false # (OC) Minimum number of Objective-C message parameters before applying nl_oc_msg_args. nl_oc_msg_args_min_params = 0 # unsigned number # (OC) Max code width of Objective-C message before applying nl_oc_msg_args. nl_oc_msg_args_max_code_width = 0 # unsigned number # Add or remove newline between function signature and '{'. nl_fdef_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between function signature and '{', # if signature ends with ')'. Overrides nl_fdef_brace. nl_fdef_brace_cond = ignore # ignore/add/remove/force/not_defined # Add or remove newline between C++11 lambda signature and '{'. nl_cpp_ldef_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'return' and the return expression. nl_return_expr = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'throw' and the throw expression. nl_throw_expr = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after semicolons, except in 'for' statements. nl_after_semicolon = false # true/false # (Java) Add or remove newline between the ')' and '{{' of the double brace # initializer. nl_paren_dbrace_open = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after the type in an unnamed temporary # direct-list-initialization, better: # before a direct-list-initialization. nl_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after the open brace in an unnamed temporary # direct-list-initialization. nl_type_brace_init_lst_open = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before the close brace in an unnamed temporary # direct-list-initialization. nl_type_brace_init_lst_close = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before '{'. nl_before_brace_open = false # true/false # Whether to add a newline after '{'. nl_after_brace_open = false # true/false # Whether to add a newline between the open brace and a trailing single-line # comment. Requires nl_after_brace_open=true. nl_after_brace_open_cmt = false # true/false # Whether to add a newline after a virtual brace open with a non-empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open = false # true/false # Whether to add a newline after a virtual brace open with an empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open_empty = false # true/false # Whether to add a newline after '}'. Does not apply if followed by a # necessary ';'. nl_after_brace_close = false # true/false # Whether to add a newline after a virtual brace close, # as in 'if (foo) a++; return;'. nl_after_vbrace_close = false # true/false # Add or remove newline between the close brace and identifier, # as in 'struct { int a; } b;'. Affects enumerations, unions and # structures. If set to ignore, uses nl_after_brace_close. nl_brace_struct_var = ignore # ignore/add/remove/force/not_defined # Whether to alter newlines in '#define' macros. nl_define_macro = false # true/false # Whether to alter newlines between consecutive parenthesis closes. The number # of closing parentheses in a line will depend on respective open parenthesis # lines. nl_squeeze_paren_close = false # true/false # Whether to remove blanks after '#ifxx' and '#elxx', or before '#elxx' and # '#endif'. Does not affect top-level #ifdefs. nl_squeeze_ifdef = false # true/false # Makes the nl_squeeze_ifdef option affect the top-level #ifdefs as well. nl_squeeze_ifdef_top_level = false # true/false # Add or remove blank line before 'if'. nl_before_if = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'if' statement. Add/Force work only if the # next token is not a closing brace. nl_after_if = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'for'. nl_before_for = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'for' statement. nl_after_for = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'while'. nl_before_while = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'while' statement. nl_after_while = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'switch'. nl_before_switch = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'switch' statement. nl_after_switch = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'synchronized'. nl_before_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'synchronized' statement. nl_after_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'do'. nl_before_do = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'do/while' statement. nl_after_do = ignore # ignore/add/remove/force/not_defined # Ignore nl_before_{if,for,switch,do,synchronized} if the control # statement is immediately after a case statement. # if nl_before_{if,for,switch,do} is set to remove, this option # does nothing. nl_before_ignore_after_case = false # true/false # Whether to put a blank line before 'return' statements, unless after an open # brace. nl_before_return = false # true/false # Whether to put a blank line after 'return' statements, unless followed by a # close brace. nl_after_return = false # true/false # Whether to put a blank line before a member '.' or '->' operators. nl_before_member = ignore # ignore/add/remove/force/not_defined # (Java) Whether to put a blank line after a member '.' or '->' operators. nl_after_member = ignore # ignore/add/remove/force/not_defined # Whether to double-space commented-entries in 'struct'/'union'/'enum'. nl_ds_struct_enum_cmt = false # true/false # Whether to force a newline before '}' of a 'struct'/'union'/'enum'. # (Lower priority than eat_blanks_before_close_brace.) nl_ds_struct_enum_close_brace = false # true/false # Add or remove newline before or after (depending on pos_class_colon) a class # colon, as in 'class Foo : public Bar'. nl_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove newline around a class constructor colon. The exact position # depends on nl_constr_init_args, pos_constr_colon and pos_constr_comma. nl_constr_colon = ignore # ignore/add/remove/force/not_defined # Whether to collapse a two-line namespace, like 'namespace foo\n{ decl; }' # into a single line. If true, prevents other brace newline rules from turning # such code into four lines. If true, it also preserves one-liner namespaces. nl_namespace_two_to_one_liner = false # true/false # Whether to remove a newline in simple unbraced if statements, turning them # into one-liners, as in 'if(b)\n i++;' => 'if(b) i++;'. nl_create_if_one_liner = false # true/false # Whether to remove a newline in simple unbraced for statements, turning them # into one-liners, as in 'for (...)\n stmt;' => 'for (...) stmt;'. nl_create_for_one_liner = false # true/false # Whether to remove a newline in simple unbraced while statements, turning # them into one-liners, as in 'while (expr)\n stmt;' => 'while (expr) stmt;'. nl_create_while_one_liner = false # true/false # Whether to collapse a function definition whose body (not counting braces) # is only one line so that the entire definition (prototype, braces, body) is # a single line. nl_create_func_def_one_liner = false # true/false # Whether to split one-line simple list definitions into three lines by # adding newlines, as in 'int a[12] = { 0 };'. nl_create_list_one_liner = false # true/false # Whether to split one-line simple unbraced if statements into two lines by # adding a newline, as in 'if(b) i++;'. nl_split_if_one_liner = false # true/false # Whether to split one-line simple unbraced for statements into two lines by # adding a newline, as in 'for (...) stmt;'. nl_split_for_one_liner = false # true/false # Whether to split one-line simple unbraced while statements into two lines by # adding a newline, as in 'while (expr) stmt;'. nl_split_while_one_liner = false # true/false # Don't add a newline before a cpp-comment in a parameter list of a function # call. donot_add_nl_before_cpp_comment = false # true/false # # Blank line options # # The maximum number of consecutive newlines (3 = 2 blank lines). nl_max = 0 # unsigned number # The maximum number of consecutive newlines in a function. nl_max_blank_in_func = 0 # unsigned number # The number of newlines inside an empty function body. # This option overrides eat_blanks_after_open_brace and # eat_blanks_before_close_brace, but is ignored when # nl_collapse_empty_body_functions=true nl_inside_empty_func = 0 # unsigned number # The number of newlines before a function prototype. nl_before_func_body_proto = 0 # unsigned number # The number of newlines before a multi-line function definition. Where # applicable, this option is overridden with eat_blanks_after_open_brace=true nl_before_func_body_def = 0 # unsigned number # The number of newlines before a class constructor/destructor prototype. nl_before_func_class_proto = 0 # unsigned number # The number of newlines before a class constructor/destructor definition. nl_before_func_class_def = 0 # unsigned number # The number of newlines after a function prototype. nl_after_func_proto = 0 # unsigned number # The number of newlines after a function prototype, if not followed by # another function prototype. nl_after_func_proto_group = 0 # unsigned number # The number of newlines after a class constructor/destructor prototype. nl_after_func_class_proto = 0 # unsigned number # The number of newlines after a class constructor/destructor prototype, # if not followed by another constructor/destructor prototype. nl_after_func_class_proto_group = 0 # unsigned number # Whether one-line method definitions inside a class body should be treated # as if they were prototypes for the purposes of adding newlines. # # Requires nl_class_leave_one_liners=true. Overrides nl_before_func_body_def # and nl_before_func_class_def for one-liners. nl_class_leave_one_liner_groups = false # true/false # The number of newlines after '}' of a multi-line function body. nl_after_func_body = 0 # unsigned number # The number of newlines after '}' of a multi-line function body in a class # declaration. Also affects class constructors/destructors. # # Overrides nl_after_func_body. nl_after_func_body_class = 0 # unsigned number # The number of newlines after '}' of a single line function body. Also # affects class constructors/destructors. # # Overrides nl_after_func_body and nl_after_func_body_class. nl_after_func_body_one_liner = 0 # unsigned number # The number of newlines before a block of typedefs. If nl_after_access_spec # is non-zero, that option takes precedence. # # 0: No change (default). nl_typedef_blk_start = 0 # unsigned number # The number of newlines after a block of typedefs. # # 0: No change (default). nl_typedef_blk_end = 0 # unsigned number # The maximum number of consecutive newlines within a block of typedefs. # # 0: No change (default). nl_typedef_blk_in = 0 # unsigned number # The minimum number of blank lines after a block of variable definitions # at the top of a function body. If any preprocessor directives appear # between the opening brace of the function and the variable block, then # it is considered as not at the top of the function.Newlines are added # before trailing preprocessor directives, if any exist. # # 0: No change (default). nl_var_def_blk_end_func_top = 0 # unsigned number # The minimum number of empty newlines before a block of variable definitions # not at the top of a function body. If nl_after_access_spec is non-zero, # that option takes precedence. Newlines are not added at the top of the # file or just after an opening brace. Newlines are added above any # preprocessor directives before the block. # # 0: No change (default). nl_var_def_blk_start = 0 # unsigned number # The minimum number of empty newlines after a block of variable definitions # not at the top of a function body. Newlines are not added if the block # is at the bottom of the file or just before a preprocessor directive. # # 0: No change (default). nl_var_def_blk_end = 0 # unsigned number # The maximum number of consecutive newlines within a block of variable # definitions. # # 0: No change (default). nl_var_def_blk_in = 0 # unsigned number # The minimum number of newlines before a multi-line comment. # Doesn't apply if after a brace open or another multi-line comment. nl_before_block_comment = 0 # unsigned number # The minimum number of newlines before a single-line C comment. # Doesn't apply if after a brace open or other single-line C comments. nl_before_c_comment = 0 # unsigned number # The minimum number of newlines before a CPP comment. # Doesn't apply if after a brace open or other CPP comments. nl_before_cpp_comment = 0 # unsigned number # Whether to force a newline after a multi-line comment. nl_after_multiline_comment = false # true/false # Whether to force a newline after a label's colon. nl_after_label_colon = false # true/false # The number of newlines before a struct definition. nl_before_struct = 0 # unsigned number # The number of newlines after '}' or ';' of a struct/enum/union definition. nl_after_struct = 0 # unsigned number # The number of newlines before a class definition. nl_before_class = 0 # unsigned number # The number of newlines after '}' or ';' of a class definition. nl_after_class = 0 # unsigned number # The number of newlines before a namespace. nl_before_namespace = 0 # unsigned number # The number of newlines after '{' of a namespace. This also adds newlines # before the matching '}'. # # 0: Apply eat_blanks_after_open_brace or eat_blanks_before_close_brace if # applicable, otherwise no change. # # Overrides eat_blanks_after_open_brace and eat_blanks_before_close_brace. nl_inside_namespace = 0 # unsigned number # The number of newlines after '}' of a namespace. nl_after_namespace = 0 # unsigned number # The number of newlines before an access specifier label. This also includes # the Qt-specific 'signals:' and 'slots:'. Will not change the newline count # if after a brace open. # # 0: No change (default). nl_before_access_spec = 0 # unsigned number # The number of newlines after an access specifier label. This also includes # the Qt-specific 'signals:' and 'slots:'. Will not change the newline count # if after a brace open. # # 0: No change (default). # # Overrides nl_typedef_blk_start and nl_var_def_blk_start. nl_after_access_spec = 0 # unsigned number # The number of newlines between a function definition and the function # comment, as in '// comment\n void foo() {...}'. # # 0: No change (default). nl_comment_func_def = 0 # unsigned number # The number of newlines after a try-catch-finally block that isn't followed # by a brace close. # # 0: No change (default). nl_after_try_catch_finally = 0 # unsigned number # (C#) The number of newlines before and after a property, indexer or event # declaration. # # 0: No change (default). nl_around_cs_property = 0 # unsigned number # (C#) The number of newlines between the get/set/add/remove handlers. # # 0: No change (default). nl_between_get_set = 0 # unsigned number # (C#) Add or remove newline between property and the '{'. nl_property_brace = ignore # ignore/add/remove/force/not_defined # Whether to remove blank lines after '{'. eat_blanks_after_open_brace = false # true/false # Whether to remove blank lines before '}'. eat_blanks_before_close_brace = false # true/false # How aggressively to remove extra newlines not in preprocessor. # # 0: No change (default) # 1: Remove most newlines not handled by other config # 2: Remove all newlines and reformat completely by config nl_remove_extra_newlines = 0 # unsigned number # (Java) Add or remove newline after an annotation statement. Only affects # annotations that are after a newline. nl_after_annotation = ignore # ignore/add/remove/force/not_defined # (Java) Add or remove newline between two annotations. nl_between_annotation = ignore # ignore/add/remove/force/not_defined # The number of newlines before a whole-file #ifdef. # # 0: No change (default). nl_before_whole_file_ifdef = 0 # unsigned number # The number of newlines after a whole-file #ifdef. # # 0: No change (default). nl_after_whole_file_ifdef = 0 # unsigned number # The number of newlines before a whole-file #endif. # # 0: No change (default). nl_before_whole_file_endif = 0 # unsigned number # The number of newlines after a whole-file #endif. # # 0: No change (default). nl_after_whole_file_endif = 0 # unsigned number # # Positioning options # # The position of arithmetic operators in wrapped expressions. pos_arith = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of assignment in wrapped expressions. Do not affect '=' # followed by '{'. pos_assign = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of Boolean operators in wrapped expressions. pos_bool = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of comparison operators in wrapped expressions. pos_compare = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of conditional operators, as in the '?' and ':' of # 'expr ? stmt : stmt', in wrapped expressions. pos_conditional = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in wrapped expressions. pos_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in enum entries. pos_enum_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in the base class list if there is more than one # line. Affects nl_class_init_args. pos_class_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in the constructor initialization list. # Related to nl_constr_colon, nl_constr_init_args and pos_constr_colon. pos_constr_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of trailing/leading class colon, between class and base class # list. Affects nl_class_colon. pos_class_colon = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of colons between constructor and member initialization. # Related to nl_constr_colon, nl_constr_init_args and pos_constr_comma. pos_constr_colon = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of shift operators in wrapped expressions. pos_shift = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # # Line splitting options # # Try to limit code width to N columns. code_width = 0 # unsigned number # Whether to fully split long 'for' statements at semi-colons. ls_for_split_full = false # true/false # Whether to fully split long function prototypes/calls at commas. # The option ls_code_width has priority over the option ls_func_split_full. ls_func_split_full = false # true/false # Whether to split lines as close to code_width as possible and ignore some # groupings. # The option ls_code_width has priority over the option ls_func_split_full. ls_code_width = false # true/false # # Code alignment options (not left column spaces/tabs) # # Whether to keep non-indenting tabs. align_keep_tabs = false # true/false # Whether to use tabs for aligning. align_with_tabs = false # true/false # Whether to bump out to the next tab when aligning. align_on_tabstop = false # true/false # Whether to right-align numbers. align_number_right = false # true/false # Whether to keep whitespace not required for alignment. align_keep_extra_space = false # true/false # Whether to align variable definitions in prototypes and functions. align_func_params = false # true/false # The span for aligning parameter definitions in function on parameter name. # # 0: Don't align (default). align_func_params_span = 0 # unsigned number # The threshold for aligning function parameter definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_func_params_thresh = 0 # number # The gap for aligning function parameter definitions. align_func_params_gap = 0 # unsigned number # The span for aligning constructor value. # # 0: Don't align (default). align_constr_value_span = 0 # unsigned number # The threshold for aligning constructor value. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_constr_value_thresh = 0 # number # The gap for aligning constructor value. align_constr_value_gap = 0 # unsigned number # Whether to align parameters in single-line functions that have the same # name. The function names must already be aligned with each other. align_same_func_call_params = false # true/false # The span for aligning function-call parameters for single line functions. # # 0: Don't align (default). align_same_func_call_params_span = 0 # unsigned number # The threshold for aligning function-call parameters for single line # functions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_same_func_call_params_thresh = 0 # number # The span for aligning variable definitions. # # 0: Don't align (default). align_var_def_span = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of variable definitions. # # 0: Part of the type 'void * foo;' (default) # 1: Part of the variable 'void *foo;' # 2: Dangling 'void *foo;' # Dangling: the '*' will not be taken into account when aligning. align_var_def_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of variable definitions. # # 0: Part of the type 'long & foo;' (default) # 1: Part of the variable 'long &foo;' # 2: Dangling 'long &foo;' # Dangling: the '&' will not be taken into account when aligning. align_var_def_amp_style = 0 # unsigned number # The threshold for aligning variable definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_def_thresh = 0 # number # The gap for aligning variable definitions. align_var_def_gap = 0 # unsigned number # Whether to align the colon in struct bit fields. align_var_def_colon = false # true/false # The gap for aligning the colon in struct bit fields. align_var_def_colon_gap = 0 # unsigned number # Whether to align any attribute after the variable name. align_var_def_attribute = false # true/false # Whether to align inline struct/enum/union variable definitions. align_var_def_inline = false # true/false # The span for aligning on '=' in assignments. # # 0: Don't align (default). align_assign_span = 0 # unsigned number # The span for aligning on '=' in function prototype modifier. # # 0: Don't align (default). align_assign_func_proto_span = 0 # unsigned number # The threshold for aligning on '=' in assignments. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_assign_thresh = 0 # number # Whether to align on the left most assignment when multiple # definitions are found on the same line. # Depends on 'align_assign_span' and 'align_assign_thresh' settings. align_assign_on_multi_var_defs = false # true/false # The span for aligning on '{' in braced init list. # # 0: Don't align (default). align_braced_init_list_span = 0 # unsigned number # The threshold for aligning on '{' in braced init list. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_braced_init_list_thresh = 0 # number # How to apply align_assign_span to function declaration "assignments", i.e. # 'virtual void foo() = 0' or '~foo() = {default|delete}'. # # 0: Align with other assignments (default) # 1: Align with each other, ignoring regular assignments # 2: Don't align align_assign_decl_func = 0 # unsigned number # The span for aligning on '=' in enums. # # 0: Don't align (default). align_enum_equ_span = 0 # unsigned number # The threshold for aligning on '=' in enums. # Use a negative number for absolute thresholds. # # 0: no limit (default). align_enum_equ_thresh = 0 # number # The span for aligning class member definitions. # # 0: Don't align (default). align_var_class_span = 0 # unsigned number # The threshold for aligning class member definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_class_thresh = 0 # number # The gap for aligning class member definitions. align_var_class_gap = 0 # unsigned number # The span for aligning struct/union member definitions. # # 0: Don't align (default). align_var_struct_span = 0 # unsigned number # The threshold for aligning struct/union member definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_struct_thresh = 0 # number # The gap for aligning struct/union member definitions. align_var_struct_gap = 0 # unsigned number # The span for aligning struct initializer values. # # 0: Don't align (default). align_struct_init_span = 0 # unsigned number # The span for aligning single-line typedefs. # # 0: Don't align (default). align_typedef_span = 0 # unsigned number # The minimum space between the type and the synonym of a typedef. align_typedef_gap = 0 # unsigned number # How to align typedef'd functions with other typedefs. # # 0: Don't mix them at all (default) # 1: Align the open parenthesis with the types # 2: Align the function type name with the other type names align_typedef_func = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of typedefs. # # 0: Part of the typedef type, 'typedef int * pint;' (default) # 1: Part of type name: 'typedef int *pint;' # 2: Dangling: 'typedef int *pint;' # Dangling: the '*' will not be taken into account when aligning. align_typedef_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of typedefs. # # 0: Part of the typedef type, 'typedef int & intref;' (default) # 1: Part of type name: 'typedef int &intref;' # 2: Dangling: 'typedef int &intref;' # Dangling: the '&' will not be taken into account when aligning. align_typedef_amp_style = 0 # unsigned number # The span for aligning comments that end lines. # # 0: Don't align (default). align_right_cmt_span = 0 # unsigned number # Minimum number of columns between preceding text and a trailing comment in # order for the comment to qualify for being aligned. Must be non-zero to have # an effect. align_right_cmt_gap = 0 # unsigned number # If aligning comments, whether to mix with comments after '}' and #endif with # less than three spaces before the comment. align_right_cmt_mix = false # true/false # Whether to only align trailing comments that are at the same brace level. align_right_cmt_same_level = false # true/false # Minimum column at which to align trailing comments. Comments which are # aligned beyond this column, but which can be aligned in a lesser column, # may be "pulled in". # # 0: Ignore (default). align_right_cmt_at_col = 0 # unsigned number # The span for aligning function prototypes. # # 0: Don't align (default). align_func_proto_span = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of function prototypes. # # 0: Part of the type 'void * foo();' (default) # 1: Part of the function 'void *foo();' # 2: Dangling 'void *foo();' # Dangling: the '*' will not be taken into account when aligning. align_func_proto_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of function prototypes. # # 0: Part of the type 'long & foo();' (default) # 1: Part of the function 'long &foo();' # 2: Dangling 'long &foo();' # Dangling: the '&' will not be taken into account when aligning. align_func_proto_amp_style = 0 # unsigned number # The threshold for aligning function prototypes. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_func_proto_thresh = 0 # number # Minimum gap between the return type and the function name. align_func_proto_gap = 0 # unsigned number # Whether to align function prototypes on the 'operator' keyword instead of # what follows. align_on_operator = false # true/false # Whether to mix aligning prototype and variable declarations. If true, # align_var_def_XXX options are used instead of align_func_proto_XXX options. align_mix_var_proto = false # true/false # Whether to align single-line functions with function prototypes. # Uses align_func_proto_span. align_single_line_func = false # true/false # Whether to align the open brace of single-line functions. # Requires align_single_line_func=true. Uses align_func_proto_span. align_single_line_brace = false # true/false # Gap for align_single_line_brace. align_single_line_brace_gap = 0 # unsigned number # (OC) The span for aligning Objective-C message specifications. # # 0: Don't align (default). align_oc_msg_spec_span = 0 # unsigned number # Whether to align macros wrapped with a backslash and a newline. This will # not work right if the macro contains a multi-line comment. align_nl_cont = false # true/false # Whether to align macro functions and variables together. align_pp_define_together = false # true/false # The span for aligning on '#define' bodies. # # =0: Don't align (default) # >0: Number of lines (including comments) between blocks align_pp_define_span = 0 # unsigned number # The minimum space between label and value of a preprocessor define. align_pp_define_gap = 0 # unsigned number # Whether to align lines that start with '<<' with previous '<<'. # # Default: true align_left_shift = true # true/false # Whether to align comma-separated statements following '<<' (as used to # initialize Eigen matrices). align_eigen_comma_init = false # true/false # Whether to align text after 'asm volatile ()' colons. align_asm_colon = false # true/false # (OC) Span for aligning parameters in an Objective-C message call # on the ':'. # # 0: Don't align. align_oc_msg_colon_span = 0 # unsigned number # (OC) Whether to always align with the first parameter, even if it is too # short. align_oc_msg_colon_first = false # true/false # (OC) Whether to align parameters in an Objective-C '+' or '-' declaration # on the ':'. align_oc_decl_colon = false # true/false # (OC) Whether to not align parameters in an Objectve-C message call if first # colon is not on next line of the message call (the same way Xcode does # alignment) align_oc_msg_colon_xcode_like = false # true/false # # Comment modification options # # Try to wrap comments at N columns. cmt_width = 0 # unsigned number # How to reflow comments. # # 0: No reflowing (apart from the line wrapping due to cmt_width) (default) # 1: No touching at all # 2: Full reflow (enable cmt_indent_multi for indent with line wrapping due to cmt_width) cmt_reflow_mode = 0 # unsigned number # Path to a file that contains regular expressions describing patterns for # which the end of one line and the beginning of the next will be folded into # the same sentence or paragraph during full comment reflow. The regular # expressions are described using ECMAScript syntax. The syntax for this # specification is as follows, where "..." indicates the custom regular # expression and "n" indicates the nth end_of_prev_line_regex and # beg_of_next_line_regex regular expression pair: # # end_of_prev_line_regex[1] = "...$" # beg_of_next_line_regex[1] = "^..." # end_of_prev_line_regex[2] = "...$" # beg_of_next_line_regex[2] = "^..." # . # . # . # end_of_prev_line_regex[n] = "...$" # beg_of_next_line_regex[n] = "^..." # # Note that use of this option overrides the default reflow fold regular # expressions, which are internally defined as follows: # # end_of_prev_line_regex[1] = "[\w,\]\)]$" # beg_of_next_line_regex[1] = "^[\w,\[\(]" # end_of_prev_line_regex[2] = "\.$" # beg_of_next_line_regex[2] = "^[A-Z]" cmt_reflow_fold_regex_file = "" # string # Whether to indent wrapped lines to the start of the encompassing paragraph # during full comment reflow (cmt_reflow_mode = 2). Overrides the value # specified by cmt_sp_after_star_cont. # # Note that cmt_align_doxygen_javadoc_tags overrides this option for # paragraphs associated with javadoc tags cmt_reflow_indent_to_paragraph_start = false # true/false # Whether to convert all tabs to spaces in comments. If false, tabs in # comments are left alone, unless used for indenting. cmt_convert_tab_to_spaces = false # true/false # Whether to apply changes to multi-line comments, including cmt_width, # keyword substitution and leading chars. # # Default: true cmt_indent_multi = true # true/false # Whether to align doxygen javadoc-style tags ('@param', '@return', etc.) # and corresponding fields such that groups of consecutive block tags, # parameter names, and descriptions align with one another. Overrides that # which is specified by the cmt_sp_after_star_cont. If cmt_width > 0, it may # be necessary to enable cmt_indent_multi and set cmt_reflow_mode = 2 # in order to achieve the desired alignment for line-wrapping. cmt_align_doxygen_javadoc_tags = false # true/false # The number of spaces to insert after the star and before doxygen # javadoc-style tags (@param, @return, etc). Requires enabling # cmt_align_doxygen_javadoc_tags. Overrides that which is specified by the # cmt_sp_after_star_cont. # # Default: 1 cmt_sp_before_doxygen_javadoc_tags = 1 # unsigned number # Whether to change trailing, single-line c-comments into cpp-comments. cmt_trailing_single_line_c_to_cpp = false # true/false # Whether to group c-comments that look like they are in a block. cmt_c_group = false # true/false # Whether to put an empty '/*' on the first line of the combined c-comment. cmt_c_nl_start = false # true/false # Whether to add a newline before the closing '*/' of the combined c-comment. cmt_c_nl_end = false # true/false # Whether to change cpp-comments into c-comments. cmt_cpp_to_c = false # true/false # Whether to group cpp-comments that look like they are in a block. Only # meaningful if cmt_cpp_to_c=true. cmt_cpp_group = false # true/false # Whether to put an empty '/*' on the first line of the combined cpp-comment # when converting to a c-comment. # # Requires cmt_cpp_to_c=true and cmt_cpp_group=true. cmt_cpp_nl_start = false # true/false # Whether to add a newline before the closing '*/' of the combined cpp-comment # when converting to a c-comment. # # Requires cmt_cpp_to_c=true and cmt_cpp_group=true. cmt_cpp_nl_end = false # true/false # Whether to put a star on subsequent comment lines. cmt_star_cont = false # true/false # The number of spaces to insert at the start of subsequent comment lines. cmt_sp_before_star_cont = 0 # unsigned number # The number of spaces to insert after the star on subsequent comment lines. cmt_sp_after_star_cont = 0 # unsigned number # For multi-line comments with a '*' lead, remove leading spaces if the first # and last lines of the comment are the same length. # # Default: true cmt_multi_check_last = true # true/false # For multi-line comments with a '*' lead, remove leading spaces if the first # and last lines of the comment are the same length AND if the length is # bigger as the first_len minimum. # # Default: 4 cmt_multi_first_len_minimum = 4 # unsigned number # Path to a file that contains text to insert at the beginning of a file if # the file doesn't start with a C/C++ comment. If the inserted text contains # '$(filename)', that will be replaced with the current file's name. cmt_insert_file_header = "" # string # Path to a file that contains text to insert at the end of a file if the # file doesn't end with a C/C++ comment. If the inserted text contains # '$(filename)', that will be replaced with the current file's name. cmt_insert_file_footer = "" # string # Path to a file that contains text to insert before a function definition if # the function isn't preceded by a C/C++ comment. If the inserted text # contains '$(function)', '$(javaparam)' or '$(fclass)', these will be # replaced with, respectively, the name of the function, the javadoc '@param' # and '@return' stuff, or the name of the class to which the member function # belongs. cmt_insert_func_header = "" # string # Path to a file that contains text to insert before a class if the class # isn't preceded by a C/C++ comment. If the inserted text contains '$(class)', # that will be replaced with the class name. cmt_insert_class_header = "" # string # Path to a file that contains text to insert before an Objective-C message # specification, if the method isn't preceded by a C/C++ comment. If the # inserted text contains '$(message)' or '$(javaparam)', these will be # replaced with, respectively, the name of the function, or the javadoc # '@param' and '@return' stuff. cmt_insert_oc_msg_header = "" # string # Whether a comment should be inserted if a preprocessor is encountered when # stepping backwards from a function name. # # Applies to cmt_insert_oc_msg_header, cmt_insert_func_header and # cmt_insert_class_header. cmt_insert_before_preproc = false # true/false # Whether a comment should be inserted if a function is declared inline to a # class definition. # # Applies to cmt_insert_func_header. # # Default: true cmt_insert_before_inlines = true # true/false # Whether a comment should be inserted if the function is a class constructor # or destructor. # # Applies to cmt_insert_func_header. cmt_insert_before_ctor_dtor = false # true/false # # Code modifying options (non-whitespace) # # Add or remove braces on a single-line 'do' statement. mod_full_brace_do = ignore # ignore/add/remove/force/not_defined # Add or remove braces on a single-line 'for' statement. mod_full_brace_for = ignore # ignore/add/remove/force/not_defined # (Pawn) Add or remove braces on a single-line function definition. mod_full_brace_function = ignore # ignore/add/remove/force/not_defined # Add or remove braces on a single-line 'if' statement. Braces will not be # removed if the braced statement contains an 'else'. mod_full_brace_if = ignore # ignore/add/remove/force/not_defined # Whether to enforce that all blocks of an 'if'/'else if'/'else' chain either # have, or do not have, braces. Overrides mod_full_brace_if. # # 0: Don't override mod_full_brace_if # 1: Add braces to all blocks if any block needs braces and remove braces if # they can be removed from all blocks # 2: Add braces to all blocks if any block already has braces, regardless of # whether it needs them # 3: Add braces to all blocks if any block needs braces and remove braces if # they can be removed from all blocks, except if all blocks have braces # despite none needing them mod_full_brace_if_chain = 0 # unsigned number # Whether to add braces to all blocks of an 'if'/'else if'/'else' chain. # If true, mod_full_brace_if_chain will only remove braces from an 'if' that # does not have an 'else if' or 'else'. mod_full_brace_if_chain_only = false # true/false # Add or remove braces on single-line 'while' statement. mod_full_brace_while = ignore # ignore/add/remove/force/not_defined # Add or remove braces on single-line 'using ()' statement. mod_full_brace_using = ignore # ignore/add/remove/force/not_defined # Don't remove braces around statements that span N newlines mod_full_brace_nl = 0 # unsigned number # Whether to prevent removal of braces from 'if'/'for'/'while'/etc. blocks # which span multiple lines. # # Affects: # mod_full_brace_for # mod_full_brace_if # mod_full_brace_if_chain # mod_full_brace_if_chain_only # mod_full_brace_while # mod_full_brace_using # # Does not affect: # mod_full_brace_do # mod_full_brace_function mod_full_brace_nl_block_rem_mlcond = false # true/false # Add or remove unnecessary parentheses on 'return' statement. mod_paren_on_return = ignore # ignore/add/remove/force/not_defined # Add or remove unnecessary parentheses on 'throw' statement. mod_paren_on_throw = ignore # ignore/add/remove/force/not_defined # (Pawn) Whether to change optional semicolons to real semicolons. mod_pawn_semicolon = false # true/false # Whether to fully parenthesize Boolean expressions in 'while' and 'if' # statement, as in 'if (a && b > c)' => 'if (a && (b > c))'. mod_full_paren_if_bool = false # true/false # Whether to fully parenthesize Boolean expressions after '=' # statement, as in 'x = a && b > c;' => 'x = (a && (b > c));'. mod_full_paren_assign_bool = false # true/false # Whether to fully parenthesize Boolean expressions after '=' # statement, as in 'return a && b > c;' => 'return (a && (b > c));'. mod_full_paren_return_bool = false # true/false # Whether to remove superfluous semicolons. mod_remove_extra_semicolon = false # true/false # Whether to remove duplicate include. mod_remove_duplicate_include = false # true/false # If a function body exceeds the specified number of newlines and doesn't have # a comment after the close brace, a comment will be added. mod_add_long_function_closebrace_comment = 0 # unsigned number # If a namespace body exceeds the specified number of newlines and doesn't # have a comment after the close brace, a comment will be added. mod_add_long_namespace_closebrace_comment = 0 # unsigned number # If a class body exceeds the specified number of newlines and doesn't have a # comment after the close brace, a comment will be added. mod_add_long_class_closebrace_comment = 0 # unsigned number # If a switch body exceeds the specified number of newlines and doesn't have a # comment after the close brace, a comment will be added. mod_add_long_switch_closebrace_comment = 0 # unsigned number # If an #ifdef body exceeds the specified number of newlines and doesn't have # a comment after the #endif, a comment will be added. mod_add_long_ifdef_endif_comment = 0 # unsigned number # If an #ifdef or #else body exceeds the specified number of newlines and # doesn't have a comment after the #else, a comment will be added. mod_add_long_ifdef_else_comment = 0 # unsigned number # Whether to take care of the case by the mod_sort_xx options. mod_sort_case_sensitive = false # true/false # Whether to sort consecutive single-line 'import' statements. mod_sort_import = false # true/false # (C#) Whether to sort consecutive single-line 'using' statements. mod_sort_using = false # true/false # Whether to sort consecutive single-line '#include' statements (C/C++) and # '#import' statements (Objective-C). Be aware that this has the potential to # break your code if your includes/imports have ordering dependencies. mod_sort_include = false # true/false # Whether to prioritize '#include' and '#import' statements that contain # filename without extension when sorting is enabled. mod_sort_incl_import_prioritize_filename = false # true/false # Whether to prioritize '#include' and '#import' statements that does not # contain extensions when sorting is enabled. mod_sort_incl_import_prioritize_extensionless = false # true/false # Whether to prioritize '#include' and '#import' statements that contain # angle over quotes when sorting is enabled. mod_sort_incl_import_prioritize_angle_over_quotes = false # true/false # Whether to ignore file extension in '#include' and '#import' statements # for sorting comparison. mod_sort_incl_import_ignore_extension = false # true/false # Whether to group '#include' and '#import' statements when sorting is enabled. mod_sort_incl_import_grouping_enabled = false # true/false # Whether to move a 'break' that appears after a fully braced 'case' before # the close brace, as in 'case X: { ... } break;' => 'case X: { ... break; }'. mod_move_case_break = false # true/false # Whether to move a 'return' that appears after a fully braced 'case' before # the close brace, as in 'case X: { ... } return;' => 'case X: { ... return; }'. mod_move_case_return = false # true/false # Add or remove braces around a fully braced case statement. Will only remove # braces if there are no variable declarations in the block. mod_case_brace = ignore # ignore/add/remove/force/not_defined # Whether to remove a void 'return;' that appears as the last statement in a # function. mod_remove_empty_return = false # true/false # Add or remove the comma after the last value of an enumeration. mod_enum_last_comma = ignore # ignore/add/remove/force/not_defined # Syntax to use for infinite loops. # # 0: Leave syntax alone (default) # 1: Rewrite as `for(;;)` # 2: Rewrite as `while(true)` # 3: Rewrite as `do`...`while(true);` # 4: Rewrite as `while(1)` # 5: Rewrite as `do`...`while(1);` # # Infinite loops that do not already match one of these syntaxes are ignored. # Other options that affect loop formatting will be applied after transforming # the syntax. mod_infinite_loop = 0 # unsigned number # Add or remove the 'int' keyword in 'int short'. mod_int_short = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'short int'. mod_short_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int long'. mod_int_long = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'long int'. mod_long_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int signed'. mod_int_signed = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'signed int'. mod_signed_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int unsigned'. mod_int_unsigned = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'unsigned int'. mod_unsigned_int = ignore # ignore/add/remove/force/not_defined # If there is a situation where mod_int_* and mod_*_int would result in # multiple int keywords, whether to keep the rightmost int (the default) or the # leftmost int. mod_int_prefer_int_on_left = false # true/false # (OC) Whether to organize the properties. If true, properties will be # rearranged according to the mod_sort_oc_property_*_weight factors. mod_sort_oc_properties = false # true/false # (OC) Weight of a class property modifier. mod_sort_oc_property_class_weight = 0 # number # (OC) Weight of 'atomic' and 'nonatomic'. mod_sort_oc_property_thread_safe_weight = 0 # number # (OC) Weight of 'readwrite' when organizing properties. mod_sort_oc_property_readwrite_weight = 0 # number # (OC) Weight of a reference type specifier ('retain', 'copy', 'assign', # 'weak', 'strong') when organizing properties. mod_sort_oc_property_reference_weight = 0 # number # (OC) Weight of getter type ('getter=') when organizing properties. mod_sort_oc_property_getter_weight = 0 # number # (OC) Weight of setter type ('setter=') when organizing properties. mod_sort_oc_property_setter_weight = 0 # number # (OC) Weight of nullability type ('nullable', 'nonnull', 'null_unspecified', # 'null_resettable') when organizing properties. mod_sort_oc_property_nullability_weight = 0 # number # # Preprocessor options # # How to use tabs when indenting preprocessor code. # # -1: Use 'indent_with_tabs' setting (default) # 0: Spaces only # 1: Indent with tabs to brace level, align with spaces # 2: Indent and align with tabs, using spaces when not on a tabstop # # Default: -1 pp_indent_with_tabs = -1 # number # Add or remove indentation of preprocessor directives inside #if blocks # at brace level 0 (file-level). pp_indent = ignore # ignore/add/remove/force/not_defined # Whether to indent #if/#else/#endif at the brace level. If false, these are # indented from column 1. pp_indent_at_level = false # true/false # Whether to indent #if/#else/#endif at the parenthesis level if the brace # level is 0. If false, these are indented from column 1. pp_indent_at_level0 = false # true/false # Specifies the number of columns to indent preprocessors per level # at brace level 0 (file-level). If pp_indent_at_level=false, also specifies # the number of columns to indent preprocessors per level # at brace level > 0 (function-level). # # Default: 1 pp_indent_count = 1 # unsigned number # Add or remove space after # based on pp level of #if blocks. pp_space_after = ignore # ignore/add/remove/force/not_defined # Sets the number of spaces per level added with pp_space_after. pp_space_count = 0 # unsigned number # The indent for '#region' and '#endregion' in C# and '#pragma region' in # C/C++. Negative values decrease indent down to the first column. pp_indent_region = 0 # number # Whether to indent the code between #region and #endregion. pp_region_indent_code = false # true/false # If pp_indent_at_level=true, sets the indent for #if, #else and #endif when # not at file-level. Negative values decrease indent down to the first column. # # =0: Indent preprocessors using output_tab_size # >0: Column at which all preprocessors will be indented pp_indent_if = 0 # number # Whether to indent the code between #if, #else and #endif. pp_if_indent_code = false # true/false # Whether to indent the body of an #if that encompasses all the code in the file. pp_indent_in_guard = false # true/false # Whether to indent '#define' at the brace level. If false, these are # indented from column 1. pp_define_at_level = false # true/false # Whether to indent '#include' at the brace level. pp_include_at_level = false # true/false # Whether to ignore the '#define' body while formatting. pp_ignore_define_body = false # true/false # An offset value that controls the indentation of the body of a multiline #define. # 'body' refers to all the lines of a multiline #define except the first line. # Requires 'pp_ignore_define_body = false'. # # <0: Absolute column: the body indentation starts off at the specified column # (ex. -3 ==> the body is indented starting from column 3) # >=0: Relative to the column of the '#' of '#define' # (ex. 3 ==> the body is indented starting 3 columns at the right of '#') # # Default: 8 pp_multiline_define_body_indent = 8 # number # Whether to indent case statements between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the case statements # directly inside of. # # Default: true pp_indent_case = true # true/false # Whether to indent whole function definitions between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the function definition # is directly inside of. # # Default: true pp_indent_func_def = true # true/false # Whether to indent extern C blocks between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the extern block is # directly inside of. # # Default: true pp_indent_extern = true # true/false # How to indent braces directly inside #if, #else, and #endif. # Requires pp_if_indent_code=true and only applies to the indent of the # preprocessor that the braces are directly inside of. # 0: No extra indent # 1: Indent by one level # -1: Preserve original indentation # # Default: 1 pp_indent_brace = 1 # number # Whether to print warning messages for unbalanced #if and #else blocks. # This will print a message in the following cases: # - if an #ifdef block ends on a different indent level than # where it started from. Example: # # #ifdef TEST # int i; # { # int j; # #endif # # - an #elif/#else block ends on a different indent level than # the corresponding #ifdef block. Example: # # #ifdef TEST # int i; # #else # } # int j; # #endif pp_warn_unbalanced_if = false # true/false # # Sort includes options # # The regex for include category with priority 0. include_category_0 = "" # string # The regex for include category with priority 1. include_category_1 = "" # string # The regex for include category with priority 2. include_category_2 = "" # string # # Use or Do not Use options # # true: indent_func_call_param will be used (default) # false: indent_func_call_param will NOT be used # # Default: true use_indent_func_call_param = true # true/false # The value of the indentation for a continuation line is calculated # differently if the statement is: # - a declaration: your case with QString fileName ... # - an assignment: your case with pSettings = new QSettings( ... # # At the second case the indentation value might be used twice: # - at the assignment # - at the function call (if present) # # To prevent the double use of the indentation value, use this option with the # value 'true'. # # true: indent_continue will be used only once # false: indent_continue will be used every time (default) # # Requires indent_ignore_first_continue=false. use_indent_continue_only_once = false # true/false # The indentation can be: # - after the assignment, at the '[' character # - at the beginning of the lambda body # # true: indentation will be at the beginning of the lambda body # false: indentation will be after the assignment (default) indent_cpp_lambda_only_once = false # true/false # Whether sp_after_angle takes precedence over sp_inside_fparen. This was the # historic behavior, but is probably not the desired behavior, so this is off # by default. use_sp_after_angle_always = false # true/false # Whether to apply special formatting for Qt SIGNAL/SLOT macros. Essentially, # this tries to format these so that they match Qt's normalized form (i.e. the # result of QMetaObject::normalizedSignature), which can slightly improve the # performance of the QObject::connect call, rather than how they would # otherwise be formatted. # # See options_for_QT.cpp for details. # # Default: true use_options_overriding_for_qt_macros = true # true/false # If true: the form feed character is removed from the list of whitespace # characters. See https://en.cppreference.com/w/cpp/string/byte/isspace. use_form_feed_no_more_as_whitespace_character = false # true/false # # Warn levels - 1: error, 2: warning (default), 3: note # # (C#) Warning is given if doing tab-to-\t replacement and we have found one # in a C# verbatim string literal. # # Default: 2 warn_level_tabs_found_in_verbatim_string_literals = 2 # unsigned number # Limit the number of loops. # Used by uncrustify.cpp to exit from infinite loop. # 0: no limit. debug_max_number_of_loops = 0 # number # Set the number of the line to protocol; # Used in the function prot_the_line if the 2. parameter is zero. # 0: nothing protocol. debug_line_number_to_protocol = 0 # number # Set the number of second(s) before terminating formatting the current file, # 0: no timeout. # only for linux debug_timeout = 0 # number # Set the number of characters to be printed if the text is too long, # 0: do not truncate. debug_truncate = 0 # unsigned number # sort (or not) the tracking info. # # Default: true debug_sort_the_tracks = true # true/false # decode (or not) the flags as a new line. # only if the -p option is set. debug_decode_the_flags = false # true/false # insert the number of the line at the beginning of each line set_numbering_for_html_output = false # true/false # Meaning of the settings: # Ignore - do not do any changes # Add - makes sure there is 1 or more space/brace/newline/etc # Force - makes sure there is exactly 1 space/brace/newline/etc, # behaves like Add in some contexts # Remove - removes space/brace/newline/etc # # # - Token(s) can be treated as specific type(s) with the 'set' option: # `set tokenType tokenString [tokenString...]` # # Example: # `set BOOL __AND__ __OR__` # # tokenTypes are defined in src/token_enum.h, use them without the # 'CT_' prefix: 'CT_BOOL' => 'BOOL' # # # - Token(s) can be treated as type(s) with the 'type' option. # `type tokenString [tokenString...]` # # Example: # `type int c_uint_8 Rectangle` # # This can also be achieved with `set TYPE int c_uint_8 Rectangle` # # # To embed whitespace in tokenStrings use the '\' escape character, or quote # the tokenStrings. These quotes are supported: "'` # # # - Support for the auto detection of languages through the file ending can be # added using the 'file_ext' command. # `file_ext langType langString [langString..]` # # Example: # `file_ext CPP .ch .cxx .cpp.in` # # langTypes are defined in uncrusify_types.h in the lang_flag_e enum, use # them without the 'LANG_' prefix: 'LANG_CPP' => 'CPP' # # # - Custom macro-based indentation can be set up using 'macro-open', # 'macro-else' and 'macro-close'. # `(macro-open | macro-else | macro-close) tokenString` # # Example: # `macro-open BEGIN_TEMPLATE_MESSAGE_MAP` # `macro-open BEGIN_MESSAGE_MAP` # `macro-close END_MESSAGE_MAP` # # # option(s) with 'not default' value: 0 # uncrustify-uncrustify-0.76.0/documentation/htdocs/examples/000077500000000000000000000000001434072136500242105ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/documentation/htdocs/examples/c-1.in.c000066400000000000000000000776641434072136500253650ustar00rootroot00000000000000/* i2c-core.c - a device driver for the iic-bus interface */ /* ------------------------------------------------------------------------- */ /* Copyright (C) 1995-99 Simon G. Vogl This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* ------------------------------------------------------------------------- */ /* With some changes from Kysti Mlkki . All SMBus-related things are written by Frodo Looijaard SMBus 2.0 support by Mark Studebaker */ #include #include #include #include #include #include #include #include #include static LIST_HEAD(adapters); static LIST_HEAD(drivers); static DECLARE_MUTEX(core_lists); static DEFINE_IDR(i2c_adapter_idr); static int i2c_device_match(struct device *dev, struct device_driver *drv) { return 1; } static int i2c_bus_suspend(struct device * dev, pm_message_t state) { int rc = 0; if (dev->driver && dev->driver->suspend) rc = dev->driver->suspend(dev,state,0); return rc; } static int i2c_bus_resume(struct device * dev) { int rc = 0; if (dev->driver && dev->driver->resume) rc = dev->driver->resume(dev,0); return rc; } struct bus_type i2c_bus_type = { .name = "i2c", .match = i2c_device_match, .suspend = i2c_bus_suspend, .resume = i2c_bus_resume, }; static int i2c_device_probe(struct device *dev) { return -ENODEV; } static int i2c_device_remove(struct device *dev) { return 0; } void i2c_adapter_dev_release(struct device *dev) { struct i2c_adapter *adap = dev_to_i2c_adapter(dev); complete(&adap->dev_released); } struct device_driver i2c_adapter_driver = { .name = "i2c_adapter", .bus = &i2c_bus_type, .probe = i2c_device_probe, .remove = i2c_device_remove, }; static void i2c_adapter_class_dev_release(struct class_device *dev) { struct i2c_adapter *adap = class_dev_to_i2c_adapter(dev); complete(&adap->class_dev_released); } struct class i2c_adapter_class = { .name = "i2c-adapter", .release =&i2c_adapter_class_dev_release, }; static ssize_t show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf) { struct i2c_adapter *adap = dev_to_i2c_adapter(dev); return sprintf(buf, "%s\n", adap->name); } static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL); static void i2c_client_release(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); complete(&client->released); } static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf) { struct i2c_client *client = to_i2c_client(dev); return sprintf(buf, "%s\n", client->name); } /* * We can't use the DEVICE_ATTR() macro here as we want the same filename for a * different type of a device. So beware if the DEVICE_ATTR() macro ever * changes, this definition will also have to change. */ static struct device_attribute dev_attr_client_name = { .attr = {.name = "name", .mode = S_IRUGO, .owner = THIS_MODULE }, .show = &show_client_name, }; /* --------------------------------------------------- * registering functions * --------------------------------------------------- */ /* ----- * i2c_add_adapter is called from within the algorithm layer, * when a new hw adapter registers. A new device is register to be * available for clients. */ int i2c_add_adapter(struct i2c_adapter *adap) { int id, res = 0; struct list_head *item; struct i2c_driver *driver; down(&core_lists); if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) { res = -ENOMEM; goto out_unlock; } res = idr_get_new(&i2c_adapter_idr, adap, &id); if (res < 0) { if (res == -EAGAIN) res = -ENOMEM; goto out_unlock; } adap->nr = id & MAX_ID_MASK; init_MUTEX(&adap->bus_lock); init_MUTEX(&adap->clist_lock); list_add_tail(&adap->list,&adapters); INIT_LIST_HEAD(&adap->clients); /* Add the adapter to the driver core. * If the parent pointer is not set up, * we add this adapter to the host bus. */ if (adap->dev.parent == NULL) adap->dev.parent = &platform_bus; sprintf(adap->dev.bus_id, "i2c-%d", adap->nr); adap->dev.driver = &i2c_adapter_driver; adap->dev.release = &i2c_adapter_dev_release; device_register(&adap->dev); device_create_file(&adap->dev, &dev_attr_name); /* Add this adapter to the i2c_adapter class */ memset(&adap->class_dev, 0x00, sizeof(struct class_device)); adap->class_dev.dev = &adap->dev; adap->class_dev.class = &i2c_adapter_class; strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE); class_device_register(&adap->class_dev); dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name); /* inform drivers of new adapters */ list_for_each(item,&drivers) { driver = list_entry(item, struct i2c_driver, list); if (driver->flags & I2C_DF_NOTIFY) /* We ignore the return code; if it fails, too bad */ driver->attach_adapter(adap); } out_unlock: up(&core_lists); return res; } int i2c_del_adapter(struct i2c_adapter *adap) { struct list_head *item, *_n; struct i2c_adapter *adap_from_list; struct i2c_driver *driver; struct i2c_client *client; int res = 0; down(&core_lists); /* First make sure that this adapter was ever added */ list_for_each_entry(adap_from_list, &adapters, list) { if (adap_from_list == adap) break; } if (adap_from_list != adap) { pr_debug("i2c-core: attempting to delete unregistered " "adapter [%s]\n", adap->name); res = -EINVAL; goto out_unlock; } list_for_each(item,&drivers) { driver = list_entry(item, struct i2c_driver, list); if (driver->detach_adapter) if ((res = driver->detach_adapter(adap))) { dev_err(&adap->dev, "detach_adapter failed " "for driver [%s]\n", driver->name); goto out_unlock; } } /* detach any active clients. This must be done first, because * it can fail; in which case we give up. */ list_for_each_safe(item, _n, &adap->clients) { client = list_entry(item, struct i2c_client, list); /* detaching devices is unconditional of the set notify * flag, as _all_ clients that reside on the adapter * must be deleted, as this would cause invalid states. */ if ((res=client->driver->detach_client(client))) { dev_err(&adap->dev, "detach_client failed for client " "[%s] at address 0x%02x\n", client->name, client->addr); goto out_unlock; } } /* clean up the sysfs representation */ init_completion(&adap->dev_released); init_completion(&adap->class_dev_released); class_device_unregister(&adap->class_dev); device_remove_file(&adap->dev, &dev_attr_name); device_unregister(&adap->dev); list_del(&adap->list); /* wait for sysfs to drop all references */ wait_for_completion(&adap->dev_released); wait_for_completion(&adap->class_dev_released); /* free dynamically allocated bus id */ idr_remove(&i2c_adapter_idr, adap->nr); dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name); out_unlock: up(&core_lists); return res; } /* ----- * What follows is the "upwards" interface: commands for talking to clients, * which implement the functions to access the physical information of the * chips. */ int i2c_add_driver(struct i2c_driver *driver) { struct list_head *item; struct i2c_adapter *adapter; int res = 0; down(&core_lists); /* add the driver to the list of i2c drivers in the driver core */ driver->driver.name = driver->name; driver->driver.bus = &i2c_bus_type; driver->driver.probe = i2c_device_probe; driver->driver.remove = i2c_device_remove; res = driver_register(&driver->driver); if (res) goto out_unlock; list_add_tail(&driver->list,&drivers); pr_debug("i2c-core: driver [%s] registered\n", driver->name); /* now look for instances of driver on our adapters */ if (driver->flags & I2C_DF_NOTIFY) { list_for_each(item,&adapters) { adapter = list_entry(item, struct i2c_adapter, list); driver->attach_adapter(adapter); } } out_unlock: up(&core_lists); return res; } int i2c_del_driver(struct i2c_driver *driver) { struct list_head *item1, *item2, *_n; struct i2c_client *client; struct i2c_adapter *adap; int res = 0; down(&core_lists); /* Have a look at each adapter, if clients of this driver are still * attached. If so, detach them to be able to kill the driver * afterwards. * * Removing clients does not depend on the notify flag, else * invalid operation might (will!) result, when using stale client * pointers. */ list_for_each(item1,&adapters) { adap = list_entry(item1, struct i2c_adapter, list); if (driver->detach_adapter) { if ((res = driver->detach_adapter(adap))) { dev_err(&adap->dev, "detach_adapter failed " "for driver [%s]\n", driver->name); goto out_unlock; } } else { list_for_each_safe(item2, _n, &adap->clients) { client = list_entry(item2, struct i2c_client, list); if (client->driver != driver) continue; dev_dbg(&adap->dev, "detaching client [%s] " "at 0x%02x\n", client->name, client->addr); if ((res = driver->detach_client(client))) { dev_err(&adap->dev, "detach_client " "failed for client [%s] at " "0x%02x\n", client->name, client->addr); goto out_unlock; } } } } driver_unregister(&driver->driver); list_del(&driver->list); pr_debug("i2c-core: driver [%s] unregistered\n", driver->name); out_unlock: up(&core_lists); return 0; } static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr) { struct list_head *item; struct i2c_client *client; list_for_each(item,&adapter->clients) { client = list_entry(item, struct i2c_client, list); if (client->addr == addr) return -EBUSY; } return 0; } int i2c_check_addr(struct i2c_adapter *adapter, int addr) { int rval; down(&adapter->clist_lock); rval = __i2c_check_addr(adapter, addr); up(&adapter->clist_lock); return rval; } int i2c_attach_client(struct i2c_client *client) { struct i2c_adapter *adapter = client->adapter; down(&adapter->clist_lock); if (__i2c_check_addr(client->adapter, client->addr)) { up(&adapter->clist_lock); return -EBUSY; } list_add_tail(&client->list,&adapter->clients); up(&adapter->clist_lock); if (adapter->client_register) { if (adapter->client_register(client)) { dev_dbg(&adapter->dev, "client_register " "failed for client [%s] at 0x%02x\n", client->name, client->addr); } } if (client->flags & I2C_CLIENT_ALLOW_USE) client->usage_count = 0; client->dev.parent = &client->adapter->dev; client->dev.driver = &client->driver->driver; client->dev.bus = &i2c_bus_type; client->dev.release = &i2c_client_release; snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id), "%d-%04x", i2c_adapter_id(adapter), client->addr); dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n", client->name, client->dev.bus_id); device_register(&client->dev); device_create_file(&client->dev, &dev_attr_client_name); return 0; } int i2c_detach_client(struct i2c_client *client) { struct i2c_adapter *adapter = client->adapter; int res = 0; if ((client->flags & I2C_CLIENT_ALLOW_USE) && (client->usage_count > 0)) { dev_warn(&client->dev, "Client [%s] still busy, " "can't detach\n", client->name); return -EBUSY; } if (adapter->client_unregister) { res = adapter->client_unregister(client); if (res) { dev_err(&client->dev, "client_unregister [%s] failed, " "client not detached\n", client->name); goto out; } } down(&adapter->clist_lock); list_del(&client->list); init_completion(&client->released); device_remove_file(&client->dev, &dev_attr_client_name); device_unregister(&client->dev); up(&adapter->clist_lock); wait_for_completion(&client->released); out: return res; } static int i2c_inc_use_client(struct i2c_client *client) { if (!try_module_get(client->driver->owner)) return -ENODEV; if (!try_module_get(client->adapter->owner)) { module_put(client->driver->owner); return -ENODEV; } return 0; } static void i2c_dec_use_client(struct i2c_client *client) { module_put(client->driver->owner); module_put(client->adapter->owner); } int i2c_use_client(struct i2c_client *client) { int ret; ret = i2c_inc_use_client(client); if (ret) return ret; if (client->flags & I2C_CLIENT_ALLOW_USE) { if (client->flags & I2C_CLIENT_ALLOW_MULTIPLE_USE) client->usage_count++; else if (client->usage_count > 0) goto busy; else client->usage_count++; } return 0; busy: i2c_dec_use_client(client); return -EBUSY; } int i2c_release_client(struct i2c_client *client) { if(client->flags & I2C_CLIENT_ALLOW_USE) { if(client->usage_count>0) client->usage_count--; else { pr_debug("i2c-core: %s used one too many times\n", __FUNCTION__); return -EPERM; } } i2c_dec_use_client(client); return 0; } void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg) { struct list_head *item; struct i2c_client *client; down(&adap->clist_lock); list_for_each(item,&adap->clients) { client = list_entry(item, struct i2c_client, list); if (!try_module_get(client->driver->owner)) continue; if (NULL != client->driver->command) { up(&adap->clist_lock); client->driver->command(client,cmd,arg); down(&adap->clist_lock); } module_put(client->driver->owner); } up(&adap->clist_lock); } static int __init i2c_init(void) { int retval; retval = bus_register(&i2c_bus_type); if (retval) return retval; retval = driver_register(&i2c_adapter_driver); if (retval) return retval; return class_register(&i2c_adapter_class); } static void __exit i2c_exit(void) { class_unregister(&i2c_adapter_class); driver_unregister(&i2c_adapter_driver); bus_unregister(&i2c_bus_type); } subsys_initcall(i2c_init); module_exit(i2c_exit); /* ---------------------------------------------------- * the functional interface to the i2c busses. * ---------------------------------------------------- */ int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num) { int ret; if (adap->algo->master_xfer) { #ifdef DEBUG for (ret = 0; ret < num; ret++) { dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, " "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ? 'R' : 'W', msgs[ret].addr, msgs[ret].len); } #endif down(&adap->bus_lock); ret = adap->algo->master_xfer(adap,msgs,num); up(&adap->bus_lock); return ret; } else { dev_dbg(&adap->dev, "I2C level transfers not supported\n"); return -ENOSYS; } } int i2c_master_send(struct i2c_client *client,const char *buf ,int count) { int ret; struct i2c_adapter *adap=client->adapter; struct i2c_msg msg; msg.addr = client->addr; msg.flags = client->flags & I2C_M_TEN; msg.len = count; msg.buf = (char *)buf; ret = i2c_transfer(adap, &msg, 1); /* If everything went ok (i.e. 1 msg transmitted), return #bytes transmitted, else error code. */ return (ret == 1) ? count : ret; } int i2c_master_recv(struct i2c_client *client, char *buf ,int count) { struct i2c_adapter *adap=client->adapter; struct i2c_msg msg; int ret; msg.addr = client->addr; msg.flags = client->flags & I2C_M_TEN; msg.flags |= I2C_M_RD; msg.len = count; msg.buf = buf; ret = i2c_transfer(adap, &msg, 1); /* If everything went ok (i.e. 1 msg transmitted), return #bytes transmitted, else error code. */ return (ret == 1) ? count : ret; } int i2c_control(struct i2c_client *client, unsigned int cmd, unsigned long arg) { int ret = 0; struct i2c_adapter *adap = client->adapter; dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg); switch (cmd) { case I2C_RETRIES: adap->retries = arg; break; case I2C_TIMEOUT: adap->timeout = arg; break; default: if (adap->algo->algo_control!=NULL) ret = adap->algo->algo_control(adap,cmd,arg); } return ret; } /* ---------------------------------------------------- * the i2c address scanning function * Will not work for 10-bit addresses! * ---------------------------------------------------- */ static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind, int (*found_proc) (struct i2c_adapter *, int, int)) { int err; /* Make sure the address is valid */ if (addr < 0x03 || addr > 0x77) { dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n", addr); return -EINVAL; } /* Skip if already in use */ if (i2c_check_addr(adapter, addr)) return 0; /* Make sure there is something at this address, unless forced */ if (kind < 0) { if (i2c_smbus_xfer(adapter, addr, 0, 0, 0, I2C_SMBUS_QUICK, NULL) < 0) return 0; /* prevent 24RF08 corruption */ if ((addr & ~0x0f) == 0x50) i2c_smbus_xfer(adapter, addr, 0, 0, 0, I2C_SMBUS_QUICK, NULL); } /* Finally call the custom detection function */ err = found_proc(adapter, addr, kind); /* -ENODEV can be returned if there is a chip at the given address but it isn't supported by this chip driver. We catch it here as this isn't an error. */ return (err == -ENODEV) ? 0 : err; } int i2c_probe(struct i2c_adapter *adapter, struct i2c_client_address_data *address_data, int (*found_proc) (struct i2c_adapter *, int, int)) { int i, err; int adap_id = i2c_adapter_id(adapter); /* Forget it if we can't probe using SMBUS_QUICK */ if (! i2c_check_functionality(adapter,I2C_FUNC_SMBUS_QUICK)) return -1; /* Force entries are done first, and are not affected by ignore entries */ if (address_data->forces) { unsigned short **forces = address_data->forces; int kind; for (kind = 0; forces[kind]; kind++) { for (i = 0; forces[kind][i] != I2C_CLIENT_END; i += 2) { if (forces[kind][i] == adap_id || forces[kind][i] == ANY_I2C_BUS) { dev_dbg(&adapter->dev, "found force " "parameter for adapter %d, " "addr 0x%02x, kind %d\n", adap_id, forces[kind][i + 1], kind); err = i2c_probe_address(adapter, forces[kind][i + 1], kind, found_proc); if (err) return err; } } } } /* Probe entries are done second, and are not affected by ignore entries either */ for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) { if (address_data->probe[i] == adap_id || address_data->probe[i] == ANY_I2C_BUS) { dev_dbg(&adapter->dev, "found probe parameter for " "adapter %d, addr 0x%02x\n", adap_id, address_data->probe[i + 1]); err = i2c_probe_address(adapter, address_data->probe[i + 1], -1, found_proc); if (err) return err; } } /* Normal entries are done last, unless shadowed by an ignore entry */ for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) { int j, ignore; ignore = 0; for (j = 0; address_data->ignore[j] != I2C_CLIENT_END; j += 2) { if ((address_data->ignore[j] == adap_id || address_data->ignore[j] == ANY_I2C_BUS) && address_data->ignore[j + 1] == address_data->normal_i2c[i]) { dev_dbg(&adapter->dev, "found ignore " "parameter for adapter %d, " "addr 0x%02x\n", adap_id, address_data->ignore[j + 1]); } ignore = 1; break; } if (ignore) continue; dev_dbg(&adapter->dev, "found normal entry for adapter %d, " "addr 0x%02x\n", adap_id, address_data->normal_i2c[i]); err = i2c_probe_address(adapter, address_data->normal_i2c[i], -1, found_proc); if (err) return err; } return 0; } struct i2c_adapter* i2c_get_adapter(int id) { struct i2c_adapter *adapter; down(&core_lists); adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id); if (adapter && !try_module_get(adapter->owner)) adapter = NULL; up(&core_lists); return adapter; } void i2c_put_adapter(struct i2c_adapter *adap) { module_put(adap->owner); } /* The SMBus parts */ #define POLY (0x1070U << 3) static u8 crc8(u16 data) { int i; for(i = 0; i < 8; i++) { if (data & 0x8000) data = data ^ POLY; data = data << 1; } return (u8)(data >> 8); } /* CRC over count bytes in the first array plus the bytes in the rest array if it is non-null. rest[0] is the (length of rest) - 1 and is included. */ static u8 i2c_smbus_partial_pec(u8 crc, int count, u8 *first, u8 *rest) { int i; for(i = 0; i < count; i++) crc = crc8((crc ^ first[i]) << 8); if(rest != NULL) for(i = 0; i <= rest[0]; i++) crc = crc8((crc ^ rest[i]) << 8); return crc; } static u8 i2c_smbus_pec(int count, u8 *first, u8 *rest) { return i2c_smbus_partial_pec(0, count, first, rest); } /* Returns new "size" (transaction type) Note that we convert byte to byte_data and byte_data to word_data rather than invent new xxx_PEC transactions. */ static int i2c_smbus_add_pec(u16 addr, u8 command, int size, union i2c_smbus_data *data) { u8 buf[3]; buf[0] = addr << 1; buf[1] = command; switch(size) { case I2C_SMBUS_BYTE: data->byte = i2c_smbus_pec(2, buf, NULL); size = I2C_SMBUS_BYTE_DATA; break; case I2C_SMBUS_BYTE_DATA: buf[2] = data->byte; data->word = buf[2] || (i2c_smbus_pec(3, buf, NULL) << 8); size = I2C_SMBUS_WORD_DATA; break; case I2C_SMBUS_WORD_DATA: /* unsupported */ break; case I2C_SMBUS_BLOCK_DATA: data->block[data->block[0] + 1] = i2c_smbus_pec(2, buf, data->block); size = I2C_SMBUS_BLOCK_DATA_PEC; break; } return size; } static int i2c_smbus_check_pec(u16 addr, u8 command, int size, u8 partial, union i2c_smbus_data *data) { u8 buf[3], rpec, cpec; buf[1] = command; switch(size) { case I2C_SMBUS_BYTE_DATA: buf[0] = (addr << 1) | 1; cpec = i2c_smbus_pec(2, buf, NULL); rpec = data->byte; break; case I2C_SMBUS_WORD_DATA: buf[0] = (addr << 1) | 1; buf[2] = data->word & 0xff; cpec = i2c_smbus_pec(3, buf, NULL); rpec = data->word >> 8; break; case I2C_SMBUS_WORD_DATA_PEC: /* unsupported */ cpec = rpec = 0; break; case I2C_SMBUS_PROC_CALL_PEC: /* unsupported */ cpec = rpec = 0; break; case I2C_SMBUS_BLOCK_DATA_PEC: buf[0] = (addr << 1); buf[2] = (addr << 1) | 1; cpec = i2c_smbus_pec(3, buf, data->block); rpec = data->block[data->block[0] + 1]; break; case I2C_SMBUS_BLOCK_PROC_CALL_PEC: buf[0] = (addr << 1) | 1; rpec = i2c_smbus_partial_pec(partial, 1, buf, data->block); cpec = data->block[data->block[0] + 1]; break; default: cpec = rpec = 0; break; } if (rpec != cpec) { pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n", rpec, cpec); return -1; } return 0; } s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value) { return i2c_smbus_xfer(client->adapter,client->addr,client->flags, value,0,I2C_SMBUS_QUICK,NULL); } s32 i2c_smbus_read_byte(struct i2c_client *client) { union i2c_smbus_data data; if (i2c_smbus_xfer(client->adapter,client->addr,client->flags, I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data)) return -1; else return 0x0FF & data.byte; } s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value) { union i2c_smbus_data data; /* only for PEC */ return i2c_smbus_xfer(client->adapter,client->addr,client->flags, I2C_SMBUS_WRITE,value, I2C_SMBUS_BYTE,&data); } s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command) { union i2c_smbus_data data; if (i2c_smbus_xfer(client->adapter,client->addr,client->flags, I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data)) return -1; else return 0x0FF & data.byte; } s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value) { union i2c_smbus_data data; data.byte = value; return i2c_smbus_xfer(client->adapter,client->addr,client->flags, I2C_SMBUS_WRITE,command, I2C_SMBUS_BYTE_DATA,&data); } s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command) { union i2c_smbus_data data; if (i2c_smbus_xfer(client->adapter,client->addr,client->flags, I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data)) return -1; else return 0x0FFFF & data.word; } s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value) { union i2c_smbus_data data; data.word = value; return i2c_smbus_xfer(client->adapter,client->addr,client->flags, I2C_SMBUS_WRITE,command, I2C_SMBUS_WORD_DATA,&data); } s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command, u8 length, u8 *values) { union i2c_smbus_data data; int i; if (length > I2C_SMBUS_BLOCK_MAX) length = I2C_SMBUS_BLOCK_MAX; for (i = 1; i <= length; i++) data.block[i] = values[i-1]; data.block[0] = length; return i2c_smbus_xfer(client->adapter,client->addr,client->flags, I2C_SMBUS_WRITE,command, I2C_SMBUS_BLOCK_DATA,&data); } /* Returns the number of read bytes */ s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values) { union i2c_smbus_data data; int i; if (i2c_smbus_xfer(client->adapter,client->addr,client->flags, I2C_SMBUS_READ,command, I2C_SMBUS_I2C_BLOCK_DATA,&data)) return -1; else { for (i = 1; i <= data.block[0]; i++) values[i-1] = data.block[i]; return data.block[0]; } } /* Simulate a SMBus command using the i2c protocol No checking of parameters is done! */ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr, unsigned short flags, char read_write, u8 command, int size, union i2c_smbus_data * data) { /* So we need to generate a series of msgs. In the case of writing, we need to use only one message; when reading, we need two. We initialize most things with sane defaults, to keep the code below somewhat simpler. */ unsigned char msgbuf0[34]; unsigned char msgbuf1[34]; int num = read_write == I2C_SMBUS_READ?2:1; struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 }, { addr, flags | I2C_M_RD, 0, msgbuf1 } }; int i; msgbuf0[0] = command; switch(size) { case I2C_SMBUS_QUICK: msg[0].len = 0; /* Special case: The read/write field is used as data */ msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0; num = 1; break; case I2C_SMBUS_BYTE: if (read_write == I2C_SMBUS_READ) { /* Special case: only a read! */ msg[0].flags = I2C_M_RD | flags; num = 1; } break; case I2C_SMBUS_BYTE_DATA: if (read_write == I2C_SMBUS_READ) msg[1].len = 1; else { msg[0].len = 2; msgbuf0[1] = data->byte; } break; case I2C_SMBUS_WORD_DATA: if (read_write == I2C_SMBUS_READ) msg[1].len = 2; else { msg[0].len=3; msgbuf0[1] = data->word & 0xff; msgbuf0[2] = (data->word >> 8) & 0xff; } break; case I2C_SMBUS_PROC_CALL: num = 2; /* Special case */ read_write = I2C_SMBUS_READ; msg[0].len = 3; msg[1].len = 2; msgbuf0[1] = data->word & 0xff; msgbuf0[2] = (data->word >> 8) & 0xff; break; case I2C_SMBUS_BLOCK_DATA: case I2C_SMBUS_BLOCK_DATA_PEC: if (read_write == I2C_SMBUS_READ) { dev_err(&adapter->dev, "Block read not supported " "under I2C emulation!\n"); return -1; } else { msg[0].len = data->block[0] + 2; if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) { dev_err(&adapter->dev, "smbus_access called with " "invalid block write size (%d)\n", data->block[0]); return -1; } if(size == I2C_SMBUS_BLOCK_DATA_PEC) (msg[0].len)++; for (i = 1; i <= msg[0].len; i++) msgbuf0[i] = data->block[i-1]; } break; case I2C_SMBUS_BLOCK_PROC_CALL: case I2C_SMBUS_BLOCK_PROC_CALL_PEC: dev_dbg(&adapter->dev, "Block process call not supported " "under I2C emulation!\n"); return -1; case I2C_SMBUS_I2C_BLOCK_DATA: if (read_write == I2C_SMBUS_READ) { msg[1].len = I2C_SMBUS_I2C_BLOCK_MAX; } else { msg[0].len = data->block[0] + 1; if (msg[0].len > I2C_SMBUS_I2C_BLOCK_MAX + 1) { dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with " "invalid block write size (%d)\n", data->block[0]); return -1; } for (i = 1; i <= data->block[0]; i++) msgbuf0[i] = data->block[i]; } break; default: dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n", size); return -1; } if (i2c_transfer(adapter, msg, num) < 0) return -1; if (read_write == I2C_SMBUS_READ) switch(size) { case I2C_SMBUS_BYTE: data->byte = msgbuf0[0]; break; case I2C_SMBUS_BYTE_DATA: data->byte = msgbuf1[0]; break; case I2C_SMBUS_WORD_DATA: case I2C_SMBUS_PROC_CALL: data->word = msgbuf1[0] | (msgbuf1[1] << 8); break; case I2C_SMBUS_I2C_BLOCK_DATA: /* fixed at 32 for now */ data->block[0] = I2C_SMBUS_I2C_BLOCK_MAX; for (i = 0; i < I2C_SMBUS_I2C_BLOCK_MAX; i++) data->block[i+1] = msgbuf1[i]; break; } return 0; } s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags, char read_write, u8 command, int size, union i2c_smbus_data * data) { s32 res; int swpec = 0; u8 partial = 0; flags &= I2C_M_TEN | I2C_CLIENT_PEC; if((flags & I2C_CLIENT_PEC) && !(i2c_check_functionality(adapter, I2C_FUNC_SMBUS_HWPEC_CALC))) { swpec = 1; if(read_write == I2C_SMBUS_READ && size == I2C_SMBUS_BLOCK_DATA) size = I2C_SMBUS_BLOCK_DATA_PEC; else if(size == I2C_SMBUS_PROC_CALL) size = I2C_SMBUS_PROC_CALL_PEC; else if(size == I2C_SMBUS_BLOCK_PROC_CALL) { i2c_smbus_add_pec(addr, command, I2C_SMBUS_BLOCK_DATA, data); partial = data->block[data->block[0] + 1]; size = I2C_SMBUS_BLOCK_PROC_CALL_PEC; } else if(read_write == I2C_SMBUS_WRITE && size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA) size = i2c_smbus_add_pec(addr, command, size, data); } if (adapter->algo->smbus_xfer) { down(&adapter->bus_lock); res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write, command,size,data); up(&adapter->bus_lock); } else res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write, command,size,data); if(res >= 0 && swpec && size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA && (read_write == I2C_SMBUS_READ || size == I2C_SMBUS_PROC_CALL_PEC || size == I2C_SMBUS_BLOCK_PROC_CALL_PEC)) { if(i2c_smbus_check_pec(addr, command, size, partial, data)) return -1; } return res; } /* Next four are needed by i2c-isa */ EXPORT_SYMBOL_GPL(i2c_adapter_dev_release); EXPORT_SYMBOL_GPL(i2c_adapter_driver); EXPORT_SYMBOL_GPL(i2c_adapter_class); EXPORT_SYMBOL_GPL(i2c_bus_type); EXPORT_SYMBOL(i2c_add_adapter); EXPORT_SYMBOL(i2c_del_adapter); EXPORT_SYMBOL(i2c_add_driver); EXPORT_SYMBOL(i2c_del_driver); EXPORT_SYMBOL(i2c_attach_client); EXPORT_SYMBOL(i2c_detach_client); EXPORT_SYMBOL(i2c_use_client); EXPORT_SYMBOL(i2c_release_client); EXPORT_SYMBOL(i2c_clients_command); EXPORT_SYMBOL(i2c_check_addr); EXPORT_SYMBOL(i2c_master_send); EXPORT_SYMBOL(i2c_master_recv); EXPORT_SYMBOL(i2c_control); EXPORT_SYMBOL(i2c_transfer); EXPORT_SYMBOL(i2c_get_adapter); EXPORT_SYMBOL(i2c_put_adapter); EXPORT_SYMBOL(i2c_probe); EXPORT_SYMBOL(i2c_smbus_xfer); EXPORT_SYMBOL(i2c_smbus_write_quick); EXPORT_SYMBOL(i2c_smbus_read_byte); EXPORT_SYMBOL(i2c_smbus_write_byte); EXPORT_SYMBOL(i2c_smbus_read_byte_data); EXPORT_SYMBOL(i2c_smbus_write_byte_data); EXPORT_SYMBOL(i2c_smbus_read_word_data); EXPORT_SYMBOL(i2c_smbus_write_word_data); EXPORT_SYMBOL(i2c_smbus_write_block_data); EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data); MODULE_AUTHOR("Simon G. Vogl "); MODULE_DESCRIPTION("I2C-Bus main module"); MODULE_LICENSE("GPL"); uncrustify-uncrustify-0.76.0/documentation/htdocs/examples/c-1.out.c000066400000000000000000000767651434072136500255670ustar00rootroot00000000000000/* i2c-core.c - a device driver for the iic-bus interface */ /* ------------------------------------------------------------------------- */ /* Copyright (C) 1995-99 Simon G. Vogl This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* ------------------------------------------------------------------------- */ /* With some changes from Kysti Mlkki . All SMBus-related things are written by Frodo Looijaard SMBus 2.0 support by Mark Studebaker */ #include #include #include #include #include #include #include #include #include static LIST_HEAD(adapters); static LIST_HEAD(drivers); static DECLARE_MUTEX(core_lists); static DEFINE_IDR(i2c_adapter_idr); static int i2c_device_match(struct device *dev, struct device_driver *drv) { return 1; } static int i2c_bus_suspend(struct device *dev, pm_message_t state) { int rc = 0; if (dev->driver && dev->driver->suspend) rc = dev->driver->suspend(dev, state, 0); return rc; } static int i2c_bus_resume(struct device *dev) { int rc = 0; if (dev->driver && dev->driver->resume) rc = dev->driver->resume(dev, 0); return rc; } struct bus_type i2c_bus_type = { .name = "i2c", .match = i2c_device_match, .suspend = i2c_bus_suspend, .resume = i2c_bus_resume, }; static int i2c_device_probe(struct device *dev) { return -ENODEV; } static int i2c_device_remove(struct device *dev) { return 0; } void i2c_adapter_dev_release(struct device *dev) { struct i2c_adapter *adap = dev_to_i2c_adapter(dev); complete(&adap->dev_released); } struct device_driver i2c_adapter_driver = { .name = "i2c_adapter", .bus = &i2c_bus_type, .probe = i2c_device_probe, .remove = i2c_device_remove, }; static void i2c_adapter_class_dev_release(struct class_device *dev) { struct i2c_adapter *adap = class_dev_to_i2c_adapter(dev); complete(&adap->class_dev_released); } struct class i2c_adapter_class = { .name = "i2c-adapter", .release = &i2c_adapter_class_dev_release, }; static ssize_t show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf) { struct i2c_adapter *adap = dev_to_i2c_adapter(dev); return sprintf(buf, "%s\n", adap->name); } static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL); static void i2c_client_release(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); complete(&client->released); } static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf) { struct i2c_client *client = to_i2c_client(dev); return sprintf(buf, "%s\n", client->name); } /* * We can't use the DEVICE_ATTR() macro here as we want the same filename for a * different type of a device. So beware if the DEVICE_ATTR() macro ever * changes, this definition will also have to change. */ static struct device_attribute dev_attr_client_name = { .attr = { .name = "name", .mode = S_IRUGO, .owner = THIS_MODULE }, .show = &show_client_name, }; /* --------------------------------------------------- * registering functions * --------------------------------------------------- */ /* ----- * i2c_add_adapter is called from within the algorithm layer, * when a new hw adapter registers. A new device is register to be * available for clients. */ int i2c_add_adapter(struct i2c_adapter *adap) { int id, res = 0; struct list_head *item; struct i2c_driver *driver; down(&core_lists); if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) { res = -ENOMEM; goto out_unlock; } res = idr_get_new(&i2c_adapter_idr, adap, &id); if (res < 0) { if (res == -EAGAIN) res = -ENOMEM; goto out_unlock; } adap->nr = id & MAX_ID_MASK; init_MUTEX(&adap->bus_lock); init_MUTEX(&adap->clist_lock); list_add_tail(&adap->list, &adapters); INIT_LIST_HEAD(&adap->clients); /* Add the adapter to the driver core. * If the parent pointer is not set up, * we add this adapter to the host bus. */ if (adap->dev.parent == NULL) adap->dev.parent = &platform_bus; sprintf(adap->dev.bus_id, "i2c-%d", adap->nr); adap->dev.driver = &i2c_adapter_driver; adap->dev.release = &i2c_adapter_dev_release; device_register(&adap->dev); device_create_file(&adap->dev, &dev_attr_name); /* Add this adapter to the i2c_adapter class */ memset(&adap->class_dev, 0x00, sizeof(struct class_device)); adap->class_dev.dev = &adap->dev; adap->class_dev.class = &i2c_adapter_class; strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE); class_device_register(&adap->class_dev); dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name); /* inform drivers of new adapters */ list_for_each(item, &drivers) { driver = list_entry(item, struct i2c_driver, list); if (driver->flags & I2C_DF_NOTIFY) /* We ignore the return code; if it fails, too bad */ driver->attach_adapter(adap); } out_unlock: up(&core_lists); return res; } int i2c_del_adapter(struct i2c_adapter *adap) { struct list_head *item, *_n; struct i2c_adapter *adap_from_list; struct i2c_driver *driver; struct i2c_client *client; int res = 0; down(&core_lists); /* First make sure that this adapter was ever added */ list_for_each_entry(adap_from_list, &adapters, list) { if (adap_from_list == adap) break; } if (adap_from_list != adap) { pr_debug("i2c-core: attempting to delete unregistered " "adapter [%s]\n", adap->name); res = -EINVAL; goto out_unlock; } list_for_each(item, &drivers) { driver = list_entry(item, struct i2c_driver, list); if (driver->detach_adapter) if ((res = driver->detach_adapter(adap))) { dev_err(&adap->dev, "detach_adapter failed " "for driver [%s]\n", driver->name); goto out_unlock; } } /* detach any active clients. This must be done first, because * it can fail; in which case we give up. */ list_for_each_safe(item, _n, &adap->clients) { client = list_entry(item, struct i2c_client, list); /* detaching devices is unconditional of the set notify * flag, as _all_ clients that reside on the adapter * must be deleted, as this would cause invalid states. */ if ((res = client->driver->detach_client(client))) { dev_err(&adap->dev, "detach_client failed for client " "[%s] at address 0x%02x\n", client->name, client->addr); goto out_unlock; } } /* clean up the sysfs representation */ init_completion(&adap->dev_released); init_completion(&adap->class_dev_released); class_device_unregister(&adap->class_dev); device_remove_file(&adap->dev, &dev_attr_name); device_unregister(&adap->dev); list_del(&adap->list); /* wait for sysfs to drop all references */ wait_for_completion(&adap->dev_released); wait_for_completion(&adap->class_dev_released); /* free dynamically allocated bus id */ idr_remove(&i2c_adapter_idr, adap->nr); dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name); out_unlock: up(&core_lists); return res; } /* ----- * What follows is the "upwards" interface: commands for talking to clients, * which implement the functions to access the physical information of the * chips. */ int i2c_add_driver(struct i2c_driver *driver) { struct list_head *item; struct i2c_adapter *adapter; int res = 0; down(&core_lists); /* add the driver to the list of i2c drivers in the driver core */ driver->driver.name = driver->name; driver->driver.bus = &i2c_bus_type; driver->driver.probe = i2c_device_probe; driver->driver.remove = i2c_device_remove; res = driver_register(&driver->driver); if (res) goto out_unlock; list_add_tail(&driver->list, &drivers); pr_debug("i2c-core: driver [%s] registered\n", driver->name); /* now look for instances of driver on our adapters */ if (driver->flags & I2C_DF_NOTIFY) { list_for_each(item, &adapters) { adapter = list_entry(item, struct i2c_adapter, list); driver->attach_adapter(adapter); } } out_unlock: up(&core_lists); return res; } int i2c_del_driver(struct i2c_driver *driver) { struct list_head *item1, *item2, *_n; struct i2c_client *client; struct i2c_adapter *adap; int res = 0; down(&core_lists); /* Have a look at each adapter, if clients of this driver are still * attached. If so, detach them to be able to kill the driver * afterwards. * * Removing clients does not depend on the notify flag, else * invalid operation might (will!) result, when using stale client * pointers. */ list_for_each(item1, &adapters) { adap = list_entry(item1, struct i2c_adapter, list); if (driver->detach_adapter) { if ((res = driver->detach_adapter(adap))) { dev_err(&adap->dev, "detach_adapter failed " "for driver [%s]\n", driver->name); goto out_unlock; } } else { list_for_each_safe(item2, _n, &adap->clients) { client = list_entry(item2, struct i2c_client, list); if (client->driver != driver) continue; dev_dbg(&adap->dev, "detaching client [%s] " "at 0x%02x\n", client->name, client->addr); if ((res = driver->detach_client(client))) { dev_err(&adap->dev, "detach_client " "failed for client [%s] at " "0x%02x\n", client->name, client->addr); goto out_unlock; } } } } driver_unregister(&driver->driver); list_del(&driver->list); pr_debug("i2c-core: driver [%s] unregistered\n", driver->name); out_unlock: up(&core_lists); return 0; } static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr) { struct list_head *item; struct i2c_client *client; list_for_each(item, &adapter->clients) { client = list_entry(item, struct i2c_client, list); if (client->addr == addr) return -EBUSY; } return 0; } int i2c_check_addr(struct i2c_adapter *adapter, int addr) { int rval; down(&adapter->clist_lock); rval = __i2c_check_addr(adapter, addr); up(&adapter->clist_lock); return rval; } int i2c_attach_client(struct i2c_client *client) { struct i2c_adapter *adapter = client->adapter; down(&adapter->clist_lock); if (__i2c_check_addr(client->adapter, client->addr)) { up(&adapter->clist_lock); return -EBUSY; } list_add_tail(&client->list, &adapter->clients); up(&adapter->clist_lock); if (adapter->client_register) { if (adapter->client_register(client)) { dev_dbg(&adapter->dev, "client_register " "failed for client [%s] at 0x%02x\n", client->name, client->addr); } } if (client->flags & I2C_CLIENT_ALLOW_USE) client->usage_count = 0; client->dev.parent = &client->adapter->dev; client->dev.driver = &client->driver->driver; client->dev.bus = &i2c_bus_type; client->dev.release = &i2c_client_release; snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id), "%d-%04x", i2c_adapter_id(adapter), client->addr); dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n", client->name, client->dev.bus_id); device_register(&client->dev); device_create_file(&client->dev, &dev_attr_client_name); return 0; } int i2c_detach_client(struct i2c_client *client) { struct i2c_adapter *adapter = client->adapter; int res = 0; if ((client->flags & I2C_CLIENT_ALLOW_USE) && (client->usage_count > 0)) { dev_warn(&client->dev, "Client [%s] still busy, " "can't detach\n", client->name); return -EBUSY; } if (adapter->client_unregister) { res = adapter->client_unregister(client); if (res) { dev_err(&client->dev, "client_unregister [%s] failed, " "client not detached\n", client->name); goto out; } } down(&adapter->clist_lock); list_del(&client->list); init_completion(&client->released); device_remove_file(&client->dev, &dev_attr_client_name); device_unregister(&client->dev); up(&adapter->clist_lock); wait_for_completion(&client->released); out: return res; } static int i2c_inc_use_client(struct i2c_client *client) { if (!try_module_get(client->driver->owner)) return -ENODEV; if (!try_module_get(client->adapter->owner)) { module_put(client->driver->owner); return -ENODEV; } return 0; } static void i2c_dec_use_client(struct i2c_client *client) { module_put(client->driver->owner); module_put(client->adapter->owner); } int i2c_use_client(struct i2c_client *client) { int ret; ret = i2c_inc_use_client(client); if (ret) return ret; if (client->flags & I2C_CLIENT_ALLOW_USE) { if (client->flags & I2C_CLIENT_ALLOW_MULTIPLE_USE) client->usage_count++; else if (client->usage_count > 0) goto busy; else client->usage_count++; } return 0; busy: i2c_dec_use_client(client); return -EBUSY; } int i2c_release_client(struct i2c_client *client) { if (client->flags & I2C_CLIENT_ALLOW_USE) { if (client->usage_count > 0) client->usage_count--; else { pr_debug("i2c-core: %s used one too many times\n", __FUNCTION__); return -EPERM; } } i2c_dec_use_client(client); return 0; } void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg) { struct list_head *item; struct i2c_client *client; down(&adap->clist_lock); list_for_each(item, &adap->clients) { client = list_entry(item, struct i2c_client, list); if (!try_module_get(client->driver->owner)) continue; if (NULL != client->driver->command) { up(&adap->clist_lock); client->driver->command(client, cmd, arg); down(&adap->clist_lock); } module_put(client->driver->owner); } up(&adap->clist_lock); } static int __init i2c_init(void) { int retval; retval = bus_register(&i2c_bus_type); if (retval) return retval; retval = driver_register(&i2c_adapter_driver); if (retval) return retval; return class_register(&i2c_adapter_class); } static void __exit i2c_exit(void) { class_unregister(&i2c_adapter_class); driver_unregister(&i2c_adapter_driver); bus_unregister(&i2c_bus_type); } subsys_initcall(i2c_init); module_exit(i2c_exit); /* ---------------------------------------------------- * the functional interface to the i2c busses. * ---------------------------------------------------- */ int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) { int ret; if (adap->algo->master_xfer) { #ifdef DEBUG for (ret = 0; ret < num; ret++) { dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, " "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ? 'R' : 'W', msgs[ret].addr, msgs[ret].len); } #endif down(&adap->bus_lock); ret = adap->algo->master_xfer(adap, msgs, num); up(&adap->bus_lock); return ret; } else { dev_dbg(&adap->dev, "I2C level transfers not supported\n"); return -ENOSYS; } } int i2c_master_send(struct i2c_client *client, const char *buf, int count) { int ret; struct i2c_adapter *adap = client->adapter; struct i2c_msg msg; msg.addr = client->addr; msg.flags = client->flags & I2C_M_TEN; msg.len = count; msg.buf = (char *)buf; ret = i2c_transfer(adap, &msg, 1); /* If everything went ok (i.e. 1 msg transmitted), return #bytes transmitted, else error code. */ return (ret == 1) ? count : ret; } int i2c_master_recv(struct i2c_client *client, char *buf, int count) { struct i2c_adapter *adap = client->adapter; struct i2c_msg msg; int ret; msg.addr = client->addr; msg.flags = client->flags & I2C_M_TEN; msg.flags |= I2C_M_RD; msg.len = count; msg.buf = buf; ret = i2c_transfer(adap, &msg, 1); /* If everything went ok (i.e. 1 msg transmitted), return #bytes transmitted, else error code. */ return (ret == 1) ? count : ret; } int i2c_control(struct i2c_client *client, unsigned int cmd, unsigned long arg) { int ret = 0; struct i2c_adapter *adap = client->adapter; dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg); switch (cmd) { case I2C_RETRIES: adap->retries = arg; break; case I2C_TIMEOUT: adap->timeout = arg; break; default: if (adap->algo->algo_control != NULL) ret = adap->algo->algo_control(adap, cmd, arg); } return ret; } /* ---------------------------------------------------- * the i2c address scanning function * Will not work for 10-bit addresses! * ---------------------------------------------------- */ static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind, int (*found_proc)(struct i2c_adapter *, int, int)) { int err; /* Make sure the address is valid */ if (addr < 0x03 || addr > 0x77) { dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n", addr); return -EINVAL; } /* Skip if already in use */ if (i2c_check_addr(adapter, addr)) return 0; /* Make sure there is something at this address, unless forced */ if (kind < 0) { if (i2c_smbus_xfer(adapter, addr, 0, 0, 0, I2C_SMBUS_QUICK, NULL) < 0) return 0; /* prevent 24RF08 corruption */ if ((addr & ~0x0f) == 0x50) i2c_smbus_xfer(adapter, addr, 0, 0, 0, I2C_SMBUS_QUICK, NULL); } /* Finally call the custom detection function */ err = found_proc(adapter, addr, kind); /* -ENODEV can be returned if there is a chip at the given address but it isn't supported by this chip driver. We catch it here as this isn't an error. */ return (err == -ENODEV) ? 0 : err; } int i2c_probe(struct i2c_adapter *adapter, struct i2c_client_address_data *address_data, int (*found_proc)(struct i2c_adapter *, int, int)) { int i, err; int adap_id = i2c_adapter_id(adapter); /* Forget it if we can't probe using SMBUS_QUICK */ if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) return -1; /* Force entries are done first, and are not affected by ignore entries */ if (address_data->forces) { unsigned short **forces = address_data->forces; int kind; for (kind = 0; forces[kind]; kind++) { for (i = 0; forces[kind][i] != I2C_CLIENT_END; i += 2) { if (forces[kind][i] == adap_id || forces[kind][i] == ANY_I2C_BUS) { dev_dbg(&adapter->dev, "found force " "parameter for adapter %d, " "addr 0x%02x, kind %d\n", adap_id, forces[kind][i + 1], kind); err = i2c_probe_address(adapter, forces[kind][i + 1], kind, found_proc); if (err) return err; } } } } /* Probe entries are done second, and are not affected by ignore entries either */ for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) { if (address_data->probe[i] == adap_id || address_data->probe[i] == ANY_I2C_BUS) { dev_dbg(&adapter->dev, "found probe parameter for " "adapter %d, addr 0x%02x\n", adap_id, address_data->probe[i + 1]); err = i2c_probe_address(adapter, address_data->probe[i + 1], -1, found_proc); if (err) return err; } } /* Normal entries are done last, unless shadowed by an ignore entry */ for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) { int j, ignore; ignore = 0; for (j = 0; address_data->ignore[j] != I2C_CLIENT_END; j += 2) { if ((address_data->ignore[j] == adap_id || address_data->ignore[j] == ANY_I2C_BUS) && address_data->ignore[j + 1] == address_data->normal_i2c[i]) { dev_dbg(&adapter->dev, "found ignore " "parameter for adapter %d, " "addr 0x%02x\n", adap_id, address_data->ignore[j + 1]); } ignore = 1; break; } if (ignore) continue; dev_dbg(&adapter->dev, "found normal entry for adapter %d, " "addr 0x%02x\n", adap_id, address_data->normal_i2c[i]); err = i2c_probe_address(adapter, address_data->normal_i2c[i], -1, found_proc); if (err) return err; } return 0; } struct i2c_adapter * i2c_get_adapter(int id) { struct i2c_adapter *adapter; down(&core_lists); adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id); if (adapter && !try_module_get(adapter->owner)) adapter = NULL; up(&core_lists); return adapter; } void i2c_put_adapter(struct i2c_adapter *adap) { module_put(adap->owner); } /* The SMBus parts */ #define POLY (0x1070U << 3) static u8 crc8(u16 data) { int i; for (i = 0; i < 8; i++) { if (data & 0x8000) data = data ^ POLY; data = data << 1; } return (u8)(data >> 8); } /* CRC over count bytes in the first array plus the bytes in the rest array if it is non-null. rest[0] is the (length of rest) - 1 and is included. */ static u8 i2c_smbus_partial_pec(u8 crc, int count, u8 *first, u8 *rest) { int i; for (i = 0; i < count; i++) crc = crc8((crc ^ first[i]) << 8); if (rest != NULL) for (i = 0; i <= rest[0]; i++) crc = crc8((crc ^ rest[i]) << 8); return crc; } static u8 i2c_smbus_pec(int count, u8 *first, u8 *rest) { return i2c_smbus_partial_pec(0, count, first, rest); } /* Returns new "size" (transaction type) Note that we convert byte to byte_data and byte_data to word_data rather than invent new xxx_PEC transactions. */ static int i2c_smbus_add_pec(u16 addr, u8 command, int size, union i2c_smbus_data *data) { u8 buf[3]; buf[0] = addr << 1; buf[1] = command; switch (size) { case I2C_SMBUS_BYTE: data->byte = i2c_smbus_pec(2, buf, NULL); size = I2C_SMBUS_BYTE_DATA; break; case I2C_SMBUS_BYTE_DATA: buf[2] = data->byte; data->word = buf[2] || (i2c_smbus_pec(3, buf, NULL) << 8); size = I2C_SMBUS_WORD_DATA; break; case I2C_SMBUS_WORD_DATA: /* unsupported */ break; case I2C_SMBUS_BLOCK_DATA: data->block[data->block[0] + 1] = i2c_smbus_pec(2, buf, data->block); size = I2C_SMBUS_BLOCK_DATA_PEC; break; } return size; } static int i2c_smbus_check_pec(u16 addr, u8 command, int size, u8 partial, union i2c_smbus_data *data) { u8 buf[3], rpec, cpec; buf[1] = command; switch (size) { case I2C_SMBUS_BYTE_DATA: buf[0] = (addr << 1) | 1; cpec = i2c_smbus_pec(2, buf, NULL); rpec = data->byte; break; case I2C_SMBUS_WORD_DATA: buf[0] = (addr << 1) | 1; buf[2] = data->word & 0xff; cpec = i2c_smbus_pec(3, buf, NULL); rpec = data->word >> 8; break; case I2C_SMBUS_WORD_DATA_PEC: /* unsupported */ cpec = rpec = 0; break; case I2C_SMBUS_PROC_CALL_PEC: /* unsupported */ cpec = rpec = 0; break; case I2C_SMBUS_BLOCK_DATA_PEC: buf[0] = (addr << 1); buf[2] = (addr << 1) | 1; cpec = i2c_smbus_pec(3, buf, data->block); rpec = data->block[data->block[0] + 1]; break; case I2C_SMBUS_BLOCK_PROC_CALL_PEC: buf[0] = (addr << 1) | 1; rpec = i2c_smbus_partial_pec(partial, 1, buf, data->block); cpec = data->block[data->block[0] + 1]; break; default: cpec = rpec = 0; break; } if (rpec != cpec) { pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n", rpec, cpec); return -1; } return 0; } s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value) { return i2c_smbus_xfer(client->adapter, client->addr, client->flags, value, 0, I2C_SMBUS_QUICK, NULL); } s32 i2c_smbus_read_byte(struct i2c_client *client) { union i2c_smbus_data data; if (i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &data)) return -1; else return 0x0FF & data.byte; } s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value) { union i2c_smbus_data data; /* only for PEC */ return i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, &data); } s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command) { union i2c_smbus_data data; if (i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, command, I2C_SMBUS_BYTE_DATA, &data)) return -1; else return 0x0FF & data.byte; } s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value) { union i2c_smbus_data data; data.byte = value; return i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, command, I2C_SMBUS_BYTE_DATA, &data); } s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command) { union i2c_smbus_data data; if (i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, command, I2C_SMBUS_WORD_DATA, &data)) return -1; else return 0x0FFFF & data.word; } s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value) { union i2c_smbus_data data; data.word = value; return i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, command, I2C_SMBUS_WORD_DATA, &data); } s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command, u8 length, u8 *values) { union i2c_smbus_data data; int i; if (length > I2C_SMBUS_BLOCK_MAX) length = I2C_SMBUS_BLOCK_MAX; for (i = 1; i <= length; i++) data.block[i] = values[i - 1]; data.block[0] = length; return i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, command, I2C_SMBUS_BLOCK_DATA, &data); } /* Returns the number of read bytes */ s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values) { union i2c_smbus_data data; int i; if (i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, command, I2C_SMBUS_I2C_BLOCK_DATA, &data)) return -1; else { for (i = 1; i <= data.block[0]; i++) values[i - 1] = data.block[i]; return data.block[0]; } } /* Simulate a SMBus command using the i2c protocol No checking of parameters is done! */ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr, unsigned short flags, char read_write, u8 command, int size, union i2c_smbus_data *data) { /* So we need to generate a series of msgs. In the case of writing, we need to use only one message; when reading, we need two. We initialize most things with sane defaults, to keep the code below somewhat simpler. */ unsigned char msgbuf0[34]; unsigned char msgbuf1[34]; int num = read_write == I2C_SMBUS_READ ? 2 : 1; struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 }, { addr, flags | I2C_M_RD, 0, msgbuf1 } }; int i; msgbuf0[0] = command; switch (size) { case I2C_SMBUS_QUICK: msg[0].len = 0; /* Special case: The read/write field is used as data */ msg[0].flags = flags | (read_write == I2C_SMBUS_READ) ? I2C_M_RD : 0; num = 1; break; case I2C_SMBUS_BYTE: if (read_write == I2C_SMBUS_READ) { /* Special case: only a read! */ msg[0].flags = I2C_M_RD | flags; num = 1; } break; case I2C_SMBUS_BYTE_DATA: if (read_write == I2C_SMBUS_READ) msg[1].len = 1; else { msg[0].len = 2; msgbuf0[1] = data->byte; } break; case I2C_SMBUS_WORD_DATA: if (read_write == I2C_SMBUS_READ) msg[1].len = 2; else { msg[0].len = 3; msgbuf0[1] = data->word & 0xff; msgbuf0[2] = (data->word >> 8) & 0xff; } break; case I2C_SMBUS_PROC_CALL: num = 2; /* Special case */ read_write = I2C_SMBUS_READ; msg[0].len = 3; msg[1].len = 2; msgbuf0[1] = data->word & 0xff; msgbuf0[2] = (data->word >> 8) & 0xff; break; case I2C_SMBUS_BLOCK_DATA: case I2C_SMBUS_BLOCK_DATA_PEC: if (read_write == I2C_SMBUS_READ) { dev_err(&adapter->dev, "Block read not supported " "under I2C emulation!\n"); return -1; } else { msg[0].len = data->block[0] + 2; if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) { dev_err(&adapter->dev, "smbus_access called with " "invalid block write size (%d)\n", data->block[0]); return -1; } if (size == I2C_SMBUS_BLOCK_DATA_PEC) (msg[0].len)++; for (i = 1; i <= msg[0].len; i++) msgbuf0[i] = data->block[i - 1]; } break; case I2C_SMBUS_BLOCK_PROC_CALL: case I2C_SMBUS_BLOCK_PROC_CALL_PEC: dev_dbg(&adapter->dev, "Block process call not supported " "under I2C emulation!\n"); return -1; case I2C_SMBUS_I2C_BLOCK_DATA: if (read_write == I2C_SMBUS_READ) msg[1].len = I2C_SMBUS_I2C_BLOCK_MAX; else { msg[0].len = data->block[0] + 1; if (msg[0].len > I2C_SMBUS_I2C_BLOCK_MAX + 1) { dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with " "invalid block write size (%d)\n", data->block[0]); return -1; } for (i = 1; i <= data->block[0]; i++) msgbuf0[i] = data->block[i]; } break; default: dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n", size); return -1; } if (i2c_transfer(adapter, msg, num) < 0) return -1; if (read_write == I2C_SMBUS_READ) switch (size) { case I2C_SMBUS_BYTE: data->byte = msgbuf0[0]; break; case I2C_SMBUS_BYTE_DATA: data->byte = msgbuf1[0]; break; case I2C_SMBUS_WORD_DATA: case I2C_SMBUS_PROC_CALL: data->word = msgbuf1[0] | (msgbuf1[1] << 8); break; case I2C_SMBUS_I2C_BLOCK_DATA: /* fixed at 32 for now */ data->block[0] = I2C_SMBUS_I2C_BLOCK_MAX; for (i = 0; i < I2C_SMBUS_I2C_BLOCK_MAX; i++) data->block[i + 1] = msgbuf1[i]; break; } return 0; } s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags, char read_write, u8 command, int size, union i2c_smbus_data *data) { s32 res; int swpec = 0; u8 partial = 0; flags &= I2C_M_TEN | I2C_CLIENT_PEC; if ((flags & I2C_CLIENT_PEC) && !(i2c_check_functionality(adapter, I2C_FUNC_SMBUS_HWPEC_CALC))) { swpec = 1; if (read_write == I2C_SMBUS_READ && size == I2C_SMBUS_BLOCK_DATA) size = I2C_SMBUS_BLOCK_DATA_PEC; else if (size == I2C_SMBUS_PROC_CALL) size = I2C_SMBUS_PROC_CALL_PEC; else if (size == I2C_SMBUS_BLOCK_PROC_CALL) { i2c_smbus_add_pec(addr, command, I2C_SMBUS_BLOCK_DATA, data); partial = data->block[data->block[0] + 1]; size = I2C_SMBUS_BLOCK_PROC_CALL_PEC; } else if (read_write == I2C_SMBUS_WRITE && size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA) size = i2c_smbus_add_pec(addr, command, size, data); } if (adapter->algo->smbus_xfer) { down(&adapter->bus_lock); res = adapter->algo->smbus_xfer(adapter, addr, flags, read_write, command, size, data); up(&adapter->bus_lock); } else res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write, command, size, data); if (res >= 0 && swpec && size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA && (read_write == I2C_SMBUS_READ || size == I2C_SMBUS_PROC_CALL_PEC || size == I2C_SMBUS_BLOCK_PROC_CALL_PEC)) if (i2c_smbus_check_pec(addr, command, size, partial, data)) return -1; return res; } /* Next four are needed by i2c-isa */ EXPORT_SYMBOL_GPL(i2c_adapter_dev_release); EXPORT_SYMBOL_GPL(i2c_adapter_driver); EXPORT_SYMBOL_GPL(i2c_adapter_class); EXPORT_SYMBOL_GPL(i2c_bus_type); EXPORT_SYMBOL(i2c_add_adapter); EXPORT_SYMBOL(i2c_del_adapter); EXPORT_SYMBOL(i2c_add_driver); EXPORT_SYMBOL(i2c_del_driver); EXPORT_SYMBOL(i2c_attach_client); EXPORT_SYMBOL(i2c_detach_client); EXPORT_SYMBOL(i2c_use_client); EXPORT_SYMBOL(i2c_release_client); EXPORT_SYMBOL(i2c_clients_command); EXPORT_SYMBOL(i2c_check_addr); EXPORT_SYMBOL(i2c_master_send); EXPORT_SYMBOL(i2c_master_recv); EXPORT_SYMBOL(i2c_control); EXPORT_SYMBOL(i2c_transfer); EXPORT_SYMBOL(i2c_get_adapter); EXPORT_SYMBOL(i2c_put_adapter); EXPORT_SYMBOL(i2c_probe); EXPORT_SYMBOL(i2c_smbus_xfer); EXPORT_SYMBOL(i2c_smbus_write_quick); EXPORT_SYMBOL(i2c_smbus_read_byte); EXPORT_SYMBOL(i2c_smbus_write_byte); EXPORT_SYMBOL(i2c_smbus_read_byte_data); EXPORT_SYMBOL(i2c_smbus_write_byte_data); EXPORT_SYMBOL(i2c_smbus_read_word_data); EXPORT_SYMBOL(i2c_smbus_write_word_data); EXPORT_SYMBOL(i2c_smbus_write_block_data); EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data); MODULE_AUTHOR("Simon G. Vogl "); MODULE_DESCRIPTION("I2C-Bus main module"); MODULE_LICENSE("GPL"); uncrustify-uncrustify-0.76.0/documentation/htdocs/examples/example.c000066400000000000000000000033631434072136500260140ustar00rootroot00000000000000 const char *token_names[] = { [CT_POUND] = "POUND", [CT_PREPROC] = "PREPROC", [CT_PREPROC_BODY] = "PREPROC_BODY", [CT_PP] = "PP", }; int main(int argc, char *argv[]) { struct junk a[] = { { "version", 0, 0, 0 }, { "file", 1, 150, 'f' }, { "config", 1, 0, 'c' }, { "parsed", 25, 0, 'p' }, { NULL, 0, 0, 0 } }; } color_t colors[] = { { "red", { 255, 0, 0 } }, { "blue", { 0, 255, 0 } }, { "green", { 0, 0, 255 } }, { "purple", { 255, 255, 0 } }, }; struct foo_t bar = { .name = "bar", .age = 21 }; struct foo_t bars[] = { [0] = { .name = "bar", .age = 21 }, [1] = { .name = "barley", .age = 55 }, }; void foo(void) { int i; char *name; i = 5; name = "bob"; } /** * This is your typical header comment */ int foo(int bar) { int idx; int res = 0; // trailing comment // that spans two lines for (idx = 1; idx < bar; idx++) /* comment in virtual braces */ res += idx; res *= idx; // some comment // almost continued, but a NL in between // col1 comment in level 1 return(res); } // col1 comment in level 0 #define foobar(x) \ { \ for (i = 0; i < x; i++) \ { \ junk(i, x); \ } \ } void foo(void) { switch(ch) { case 'a': { handle_a(); break; } case 'b': handle_b(); break; case 'c': case 'd': handle_cd(); break; case 'e': { handle_a(); } break; default: handle_default(); break; } } uncrustify-uncrustify-0.76.0/documentation/htdocs/images/000077500000000000000000000000001434072136500236375ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/documentation/htdocs/images/linuxlinks.gif000066400000000000000000000007161434072136500265320ustar00rootroot00000000000000GIF89aVϿï׷ϫǟo_{Oo?f3WK@!,V dihlp,tmxIpH,{rl:ШtJm)"Q-!"C#h,Dehq"(@h{lnxv Y(_'"jwy" s`|#xv  \)^h&ȩ[#  $kmŷ" ܩh x%Yj"1K_hD QGIJ'΢9[Ң"nZըիXjʵk#`Ê 뵬ٳhJ ;uncrustify-uncrustify-0.76.0/documentation/htdocs/index.html000066400000000000000000000144111434072136500243700ustar00rootroot00000000000000 Uncrustify - Source Code Beautifier for C-like languages

Uncrustify

Source Code Beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and VALA

Travis CI Build Status Coverity Scan Build Status

Introduction

The goals of this project are simple: Create a highly configurable, easily modifiable source code beautifier.


Features

  • Indent code, aligning on parens, assignments, etc
  • Align on '=' and variable definitions
  • Align structure initializers
  • Align #define stuff
  • Align backslash-newline stuff
  • Reformat comments (a little bit)
  • Fix inter-character spacing
  • Add or remove parens on return statements
  • Add or remove braces on single-statement if/do/while/for statements
  • Supports embedded SQL 'EXEC SQL' stuff
  • Highly configurable - 828 configurable options as of version 0.76.0

See some example output.


Where to get Uncrustify

Project Websites

Sourceforge project web site
Release downloads
Freshmeat Project
Git Hub

Source Code

As of release 0.54, the source code is maintained in a Git repository.

The public Git URL for Sourceforge.net is
git://uncrustify.git.sourceforge.net/gitroot/uncrustify/uncrustify

The public Git URL for github.com is
git://github.com/uncrustify/uncrustify.git

Prebuilt binaries

Windows (i386) : Sourceforge

Universal Indent GUI

Universal Indent GUI is a cross-platform graphical configuration file editor for many code beautifiers, including Uncrustify.

Want to help?

The most helpful way is to try it out and give feedback. Documentation and examples are available in the source tree, so check it out.

You can find the output from 'uncrustify --show-config' here.
Here is the default config file. And one I set up for Linux.
And here is a before and after C source example.
That should give you a pretty good idea of what Uncrustify can do.

If you find a bug, please do the following:

  • Reduce the input source file to the minimum that still has the problem
  • Use the sourceforget.net bug tracker
  • Attach the input source file, the configuration file, and a file that contains the expected output

If you want to add a feature, fix a bug, or implement missing functionality, feel free to do so! Patches are welcome!
Here are some areas that need attention:

  • Test Java support and provide feedback (or patches!)
  • Test Objective C support and provide feedback (or patches!)
  • Test Embedded SQL to see what works
  • This web page need a (re)design
  • A logo of some sort
  • Examples that can be put on this website to show off what Uncrustify can do
  • Anything else that you want to do to make it better?

Project Mailing list

We don't have a mailing list for Uncrustify.
We are using github.
You may use Issues to publish an error report.
Or PR to make a bugfix proposal.

Portability

I'm pretty sure that I'm not using anything that is OS-specific.
The software has been tested on the following operating systems:

  • Linux
  • QNX
  • OS X
  • FreeBSD, NetBSD, OpenBSD
  • Sun Solaris 9
  • Windows XP (binary available)

Links

Distributions that package Uncrustify

"Support This Project"
uncrustify-uncrustify-0.76.0/documentation/htdocs/linux.cfg.txt000066400000000000000000000054661434072136500250430ustar00rootroot00000000000000# # uncrustify config file for the linux kernel # indent_with_tabs = 2 # 1=indent to level only, 2=indent with tabs input_tab_size = 8 # original tab size output_tab_size = 8 # new tab size indent_columns = output_tab_size indent_label = 1 # pos: absolute col, neg: relative column # # inter-symbol newlines # nl_enum_brace = remove # "enum {" vs "enum \n {" nl_union_brace = remove # "union {" vs "union \n {" nl_struct_brace = remove # "struct {" vs "struct \n {" nl_do_brace = remove # "do {" vs "do \n {" nl_if_brace = remove # "if () {" vs "if () \n {" nl_for_brace = remove # "for () {" vs "for () \n {" nl_else_brace = remove # "else {" vs "else \n {" nl_while_brace = remove # "while () {" vs "while () \n {" nl_switch_brace = remove # "switch () {" vs "switch () \n {" nl_brace_while = remove # "} while" vs "} \n while" - cuddle while nl_brace_else = remove # "} else" vs "} \n else" - cuddle else nl_var_def_blk_end_func_top = 1 nl_fcall_brace = remove # "list_for_each() {" vs "list_for_each()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" # nl_after_return = TRUE; # nl_before_case = 1 # # Source code modifications # mod_paren_on_return = remove # "return 1;" vs "return (1);" mod_full_brace_if = remove # "if (a) a--;" vs "if (a) { a--; }" mod_full_brace_for = remove # "for () a--;" vs "for () { a--; }" mod_full_brace_do = remove # "do a--; while ();" vs "do { a--; } while ();" mod_full_brace_while = remove # "while (a) a--;" vs "while (a) { a--; }" mod_full_brace_nl = 3 # don't remove if more than 3 newlines # # inter-character spacing options # # sp_return_paren = force # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = add # "{ 1 }" vs "{1}" sp_inside_braces_struct = add # "{ 1 }" vs "{1}" sp_inside_braces_enum = add # "{ 1 }" vs "{1}" sp_assign = add sp_arith = add sp_bool = add sp_compare = add sp_assign = add sp_after_comma = add sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" # # Aligning stuff # align_with_tabs = TRUE # use tabs to align align_on_tabstop = TRUE # align on tabstops # align_keep_tabs = true align_enum_equ_span = 4 # '=' in enum definition # align_nl_cont = TRUE # align_var_def_span = 2 # align_var_def_inline = TRUE # align_var_def_star = FALSE # align_var_def_colon = TRUE # align_assign_span = 1 align_struct_init_span = 3 # align stuff in a structure init '= { }' align_right_cmt_span = 3 # align_pp_define_span = 8; # align_pp_define_gap = 4; # cmt_star_cont = FALSE # indent_brace = 0 uncrustify-uncrustify-0.76.0/documentation/htdocs/options.html000066400000000000000000000017121434072136500247540ustar00rootroot00000000000000 Uncrustify: where do the options work

Uncrustify: Where do the options work?

Move the cursor to a caret to see which option operates at this part of the code.

New lines

You want to "add/ force/ ignore/ remove" a new line.

Namespace

You want to "add/ force/ ignore/ remove" a new line.

Positioning

You want to change a position.

Spaces

You want to "add/ force/ ignore/ remove" a space at some places.

Code modifying

You want to modify the code.

Indenting

You want to indent the code. uncrustify-uncrustify-0.76.0/documentation/htdocs/options_ASM.html000066400000000000000000000015201434072136500254510ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work-Java

Uncrustify: Where do the options work ASM ?

Spaces for ASM

void foo()
{
        int head, bar;
        __asm__ __volatile__
        (
                "movq %0,%%xmm0\n\t"    /* asm template */
        "0:\n\t"
                "bar    %0,█[%4]\n\t"   // in template
        "1:\n\t"
                : "=a", (bar)
                : "=&b", (&head), "+m", (bar)
                : "cc"
        );
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Align.html000066400000000000000000000024771434072136500260770ustar00rootroot00000000000000#define SUCCESS 0 █ align_pp_define_gap The minimum space between label and value of a preprocessor define #define SetType(tt) do { \ LOG_FUNC_CALL(); \ SetTypeReal((tt)); \ } while (false) align_nl_cont = true #define LOG_STR(sev, str, len) \ if (log_sev_on(sev)) { log_str(sev, str, len); } █ nl_after_brace_close extern struct cp_data cpd; extern bool QT_SIGNAL_SLOT_found; extern int QT_SIGNAL_SLOT_level; extern bool restoreValues; align_var_def_span █ enum argval_t { AV_IGNORE = 0, AV_ADD = 1, AV_REMOVE = 2, AV_FORCE = 3, /**< remove + add */ AV_NOT_DEFINED = 4 /* to be used with QT, SIGNAL SLOT macros */ }; █ align_var_struct_span UO_indent_var_def_blk, // indent a variable def block that appears at the top UO_indent_var_def_cont, UO_indent_shift, // if a shift expression spans multiple lines, indent UO_indent_min_vbrace_open, // min. indent after virtual brace open and newline UO_indent_vbrace_open_on_tabstop, // when identing after virtual brace open and newline add further spaces to reach next tabstop align_right_cmt_span uncrustify-uncrustify-0.76.0/documentation/htdocs/options_CLI_NET.html000066400000000000000000000010751434072136500261530ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work-Java

Uncrustify: Where do the options work CLI .NET ?

Spaces for CLI .NET


    Foo^ foo = dynamic_cast(bar);
        █
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_C_sharp.html000066400000000000000000000013441434072136500264140ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work-Java

Uncrustify: Where do the options work C-# ?

Spaces for C-#


    int[ , , ] testArray = new int[4, 2, 3];
        █ █ █
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_D.html000066400000000000000000000010351434072136500252150ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work-D

Uncrustify: Where do the options work-D?

Spaces-D


    invariant (C) c;
                 █
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Indenting.html000066400000000000000000000133071434072136500267560ustar00rootroot00000000000000 Uncrustify: where do the Indenting options work

Uncrustify: Where do the options work?

Indenting


// indent_with_tabs     = 0 spaces only
// indent_cmt_with_tabs = false
int foo::bar()
{
    int a;
████
    double a_very_long_variable = test (foobar1,
        foobar5);
    ████
}

class Test
{
 private:
█
   int a;
}

Register

indent_columns indent_continue indent_with_tabs indent_cmt_with_tabs indent_align_string indent_xml_string indent_brace indent_braces indent_braces_no_func indent_braces_no_class indent_braces_no_struct indent_brace_parent indent_paren_open_brace indent_namespace indent_namespace_single_indent indent_namespace_level indent_namespace_limit indent_extern indent_class indent_class_colon indent_class_on_colon indent_constr_colon indent_ctor_init_leading indent_ctor_init indent_else_if indent_var_def_blk indent_var_def_cont indent_shift indent_func_def_force_col1 indent_func_call_param indent_func_def_param indent_func_proto_param indent_func_class_param indent_func_ctor_var_param indent_template_param indent_func_param_double indent_func_const indent_func_throw indent_member indent_single_line_comments_before indent_single_line_comments_after indent_relative_single_line_comments indent_switch_case indent_case_shift indent_case_brace indent_col1_comment indent_label indent_access_spec indent_access_spec_body indent_paren_nl indent_paren_close indent_comma_paren indent_bool_paren indent_first_bool_expr indent_square_nl indent_preserve_sql indent_align_assign indent_off_after_assign indent_min_vbrace_open indent_vbrace_open_on_tabstop use_indent_continue_only_once

not yet shown

only for Pawn

only for Java

only for objective C

indent_oc_msg_colon
indent_oc_msg_prioritize_first_colon
indent_oc_block_msg_xcode_style
indent_oc_block_msg_from_keyword
indent_oc_block_msg_from_colon
indent_oc_block_msg_from_caret
indent_oc_block_msg_from_brace
indent_oc_inside_msg_sel
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Java.html000066400000000000000000000010471434072136500257160ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work-Java

Uncrustify: Where do the options work-Java?

Spaces-Java


    for (Type var : expr)
                   █
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_ModifyCode.html000066400000000000000000000143141434072136500270600ustar00rootroot00000000000000 Uncrustify: where do the Positioning options work

Uncrustify: Where do the options work?

Code modifying

namespace a::b
{
int foo::bar()
{
    switch(xx) {
    case 1: 
        do { ++i; } while (++cnt < 1000);
           █      █
        for (i = 0; i < 5; i++) { bar(i); }
                                █         █
        if (a != b) {
                    █
                    █
                    █
           x = a;
           if (c == d)
                      █
              y = 5;
        }
        █
        █
        █
        while (a == b)
                      █
            c++;
        █
        if (( a < b) && ( b > c)) {
            █      █    █      █
        return (nCount);
               █      █
        if (a) {
            foo();;
                  █
        };
         █
        break;
    case 2: {
            int b;
            b = 2;
        }
        █
        break;
        █
    default:
        handle_the_rest();
        break;
    } // switch
      █
} // foo::bar
  █
} // namespace a::b
  █

void a()
{
    return;
    █
}

Register

mod_add_long_function_closebrace_comment mod_add_long_ifdef_else_comment
mod_add_long_ifdef_endif_comment mod_add_long_namespace_closebrace_comment
mod_add_long_switch_closebrace_comment mod_case_brace
mod_full_brace_do mod_full_brace_for
mod_full_brace_function mod_full_brace_if_chain
mod_full_brace_if mod_full_brace_nl
mod_full_brace_using mod_full_brace_while
mod_full_paren_if_bool mod_move_case_break
mod_paren_on_return mod_pawn_semicolon
mod_remove_empty_return mod_remove_extra_semicolon
mod_sort_import mod_sort_include mod_sort_incl_import_prioritize_filename mod_sort_incl_import_prioritize_extensionless mod_sort_incl_import_prioritize_angle_over_quotes mod_sort_incl_import_ignore_extension mod_sort_incl_import_grouping_enabled
mod_sort_using

not yet shown

mod_full_brace_using
mod_add_long_ifdef_endif_comment
mod_add_long_ifdef_else_comment
mod_sort_include

only for Pawn

mod_full_brace_function
mod_pawn_semicolon

only for Java

mod_sort_import

only for C#

mod_sort_using
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Namespace.html000066400000000000000000000042641434072136500267350ustar00rootroot00000000000000 Uncrustify: where do the New Lines options work

Uncrustify: Where do the options work?

Spaces and New lines for Namespace

namespace fooA {
              █
  // use here nl_namespace_brace=false
     ...

namespace fooB {
              █
// sp_word_brace_ns=true
          █     █void a();
// indent_namespace=true"
// indent_namespace_level=5"
     ...

namespace foo1 {     █
  // indent_namespace_single_indent=true
namespace foo2 {
    █void a();
  // indent_namespace=true
     ...

namespace fooC {
     █
  // indent_namespace=true
  █
  // indent_namespace_limit=3
void a();
void b();
void c();
}

namespace dudeNamespace
█
{ class ForwardFooClass; }


namespace fooD {
  █
  // nl_inside_namespace=2
	void a();
	void b();
	void c();
  █
  // nl_inside_namespace=2
}

namespace fooD {
	void a();
	void b();
	void c();
}  █// namespace fooD
  // mod_add_long_namespace_closebrace_comment=2
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_NewLines.html000066400000000000000000000250251434072136500265630ustar00rootroot00000000000000 Uncrustify: where do the New Lines options work

Uncrustify: Where do the options work?

New lines

█
█
void bar_0();  // function definition
          ██
void bar_0()   // function declaration
          ██
void A::bar_1(int a);
        █    █     █
void bar_2(int a) █
    █     █     █
          █     █
{█
}
█
void bar_3(int x,
           int y)
          █    █
{
    int a = 5; █
    int b = 7;
        █
    a = 135;
    list_for_each(item, list) {
                             █
    }
    █
    /* c1
     * c2
     */
    █
    int x2;
    █
    /* single comment */
    █
    // cpp comment
    std::for_each(a, b, [] (int& b) -> foo {
                                            █
        b+=3;
    }
    A_function(parameter_for_A);
              █               █
}
█


class foo : public my_Class █
         █
{
    void bar_c(int t, int u) █
        █            █
        : t(222)
        , u(88)
        █
    {
        █
        typedef char CHAR;
        █ █
        CHAR c;
        int a;
        int b;
        █
        c = 'a';
        █
        switch (a) {
                  █
        case 0:
            b = 1;
            break;
        █
        case 1: b = 5; break;
               █
        case 13: {
                █
            b = 15;
            break;
        }
        }
        █ █
        do { █
           do_something();
        } while (!d.isEmpty());
        ██ █
        if (a) { █
            b = 1;
        } else if (c) {
         █    █      █
            b ;
        } else {
              █
            b = 3;
        }
        █ █
        for (a = 1; a < 5; a++) {
                              █
            b = b + a;
        }
        █
        for (int a = 1; a < 5;
             a++) {
                 █
            b = a + 4;
        }
        try {
        █
            b = 1;
            if (err) {
                █
                throw std::runtime_error(std::string("nextKey: ") + err.asString());
            }
        } catch (const std::exception &exc) {
         █                                 █
            b = 3;
        }
        █
        while (c) {
             █
            b ;
        }
        █
    }
    enum CaseOfOne {
                  █
        a1,
        b1,
        █
        // comment
        c1,
        █
    };
    struct indent_ptr_t █
   {
        Chunk *ref;
        █
        // comment
        int delta;
        █
    } ipt;
     █
    █
    union UnionOfOne {
                    █
        a1,
        b1,
        █
        // comment
        c1,
        █
    };
    █ █
    private: // same for protected:, signal: or slots: label
    █
        int ap;
};
█


namespace foo {
             █
int foo()
{
    if (foo) a++; return;
        █          █
    if (a)
        return;
    █
l123: █
    int a = 5;
    █
    if (a > b) {
        c = 7;
    █
        return a + b;
    }
    std::for_each(a, b, [] (int& b)->foo{ b+=3; return(b); });
                                                            █
    QUrl dxOffEagle("http://something/newpage.html?[{\"foo: bar\"}]", QUrl::TolerantMode);
                                                                  █
    █
    return 0;
    █


/* c1
 *
 */
█
void b();
█
void d();
#define LOG_CONTTEXT() \
                      █
    LOG_FMT(LCONTTEXT  \
            ,"%s:%d set cont_text to '%s'\n"  \
            ,__func__, __LINE__, cmt.cont_text.c_str())
template <class T>
█
ItemJob::ItemJob(PlatformDependent *internals, const QNetworkRequest &request)
    : GetJob(internals, request)
typedef int ia;
typedef int ib;
█
typedef int ic;
typedef int id;
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Objectiv-C.html000066400000000000000000000010731434072136500267610ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work-Objectiv-C

Uncrustify: Where do the options work-Objectiv-C?

Spaces-Objectiv-C

    @selector (methodNameWithArg:);
             █
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Positioning.html000066400000000000000000000045471434072136500273470ustar00rootroot00000000000000 Uncrustify: where do the Positioning options work

Uncrustify: Where do the options work?

Positioning

void Mode( TDistMode dm )
{
    a = b
	+ c;
	█
    ms_DistMode
        = dm;
	█
    if (   (count > 0)
        && (count < MAX_COUNT)) { ... }
        █
    b = ( GetDistanceMode()
	== dmKM ) ? "km" : "Miles";
	█
    b = ( GetDistanceMode() == dmKM ) 
        ? "km"
        : "Miles";
        █
}
{
	a = B(1
	      , 2
	      , 3);
	      █
}

class GLOX_API ClientBase
        : public Class
             ██
        , public OtherClass   // if many lines are wanted
        █
        , public ThridClass
        , public ForthClass
                   █

        // nl_class_colon=force
        // pos_class_colon=lead_force
        // nl_class_init_args=force
        // pos_class_comma=lead_force
{ }

class foo : public
{
    void bar_c(int t, int u)
        : t(222)
        █
        , u(88)
        █
    {}
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Preprocessor.html000066400000000000000000000013461434072136500275250ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work-Preprocessor

Uncrustify: Where do the options work-Preprocessor?

Spaces-Preprocessor

    #define x(y) L #y
                  █
    #define msg0(x) printf("%c: %d\n", ??=@ x, x)
                                           █
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Assign.html000066400000000000000000000025101434072136500273700ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for assign

int a = 5;
     █ █
     █ █
int decimal█=█1;
normal█+=█2;

int find(size_t idx█=█0);

enum FLAGS {
    FLAGS_decimal█=█1,

return [█=█](T* t) {  };
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Byref.html000066400000000000000000000015471434072136500272240ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for byref

   bool█&█foo(int█&█idx);

   MyType█&█MyClass::myMethode() {
      const MyType& t = getSomewhere();
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Case.html000066400000000000000000000014011434072136500270150ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for case

{
   switch (a)
   {
   case█████1█:
      b = 5;
   case 2█:
      b = 7;
   default█:
      b = 0;
   }
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Cast.html000066400000000000000000000011301434072136500270330ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for cast

   b = int█(█a█);
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Class.html000066400000000000000000000016451434072136500272210ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for class

{
   class my_class█:█baseclass1, baseclass2
{
public:
        my_class█(int b)█:█x(b);

        my_class█() : c(2)
        {
        }
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Comma.html000066400000000000000000000010531434072136500272010ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for comma

{
   int A(bool a█,█bool b);
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Enum.html000066400000000000000000000017021434072136500270520ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for enum

enum FLAGS {
    FLAGS_decimal█=█1
};

enum Status {█Unknown, Success, Error█};

enum class comment_align_e█:█unsigned int
{
   REGULAR, BRACE, ENDIF,
};
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_For.html000066400000000000000000000023211434072136500266720ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for for loop

{
        for (i = 0█;█i < 10█;█i++█)
        {
                b = i + 1;
        }

        for (█;█;█)
        {
                b = b + 1;
        }
        for(auto x█:█std::as_const(str)) {}
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_New.html000066400000000000000000000017161434072136500267040ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for new/ delete

{
    Foo* foo = new█Foo(a,v);
    // does'nt work at every place

    delete[]█m_used;

    Foo* foo = new█(█ptr,std::nothrow█)█Foo[];
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Operator.html000066400000000000000000000020561434072136500277440ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for operator

{
   bool operator█()█(T1 const t1, T2 const t2)
   {
      ...
   }
   unc_text operator =█()
   {
      ...
   }
   auto max(int a, int b)█->█int;
   auto max(int a, int b) const█->█int;
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Paren.html000066400000000000000000000044531434072136500272210ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for Parenthesis


{
    auto a =
    [=] (█int *a, Something b█)█{
        // ...
    };
}
void foo(█int key, int value█)
{
    a = (█b + c█);
    a = B(█(c) + (d)█);
    return A(█key, value█) + B(█);
}
}
class STDMETHOD
{
   STDMETHOD(GetValues)█(BSTR bsName, REFDATA** pData);
};
void (__attribute__(█(noreturn)█) ****f) (void);

char *__attribute__(█(aligned(8)█)█) *f;

(struct foo)█{...}

typedef const char *█(*somefunc_t)(void *barstool);





if█(█a█)█{ b = 13; }
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Space_Template.html000066400000000000000000000022311434072136500277170ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces for template

{
   template█<█bool a█>█void f();

   new List█(foo);

   new List(█);

   List<byte>█m;
   template <typename T>█static ...;

   template<typename T> class Foo<Bar<T>█> { };
}
uncrustify-uncrustify-0.76.0/documentation/htdocs/options_Spaces.html000066400000000000000000000534321434072136500262600ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work

Uncrustify: Where do the options work?

Spaces

You want to "add/ force/ ignore/ remove" a at some places.

Some more options... 

// Comments
  █
int a;            /* emb cmt */ int b;            // trailing cmt
      █..........█                    █..........█

    union {
        uint maxChars;
        uint maxBytes;
    } mLength;
    union { int m_size; int m_any; };
           █                      █
    return { -1, -1, -1 };
            █          █

class Parser :: ParserPrivate { };
            █  █               █
template <typename T> class to { };
                                █
my $all = { };
           █
enum FocusEffect { };
                  █
struct error { };
              █
};

#define LOG_FMT (sev, args ...) \
               █          █
   if (log_sev_on(sev)) { log_fmt(sev, ## args); }
                                           █  █
#endif
#define FS_NOCOW_FL 0x00800000
                   █
#define STRHACK(x) HACKSTR(x)
             █
#define wakeUpCaller(cond) \
                          █
    if (cond) { \
               █
        cond->release(); \
                        █
     }
typedef struct { int val; int sel; } DiceInfo;
                                    █
void * bar()
    █ █
{
    int a = 5;
         █ █
         █ █
    int * const i;
         █
    c = a + b;
         █ █
    a = ~ b;
         █
    x = - 5;
         █
    y = + 7;
         █
    (-- a);
       █
    i ++;
     █
    b = ( a == d ) ? 55 : 88;
                  █ █  █ █
                  █ █  █ █
    b = ( a == d ) ? : 88;
                    █
    if( ( a || b ) && c ) x = 1;
           █  █   █  █
         █      █      █
       █
    c = a > b;
         █ █
    int * i;
       █ █
       █
    int * * j;
         █
    throw (x);
         █
    try {
       █
    } catch (const Exception &e) { }
     █     █
    } catch (...) { }
     █     █
    } catch { }
     █     █
    auto x1 = decltype(x) {0};
                         █
    Foo() noexcept () {}
                  █
    void operator ++ ( );
                 █  █ █
    int a0[][] = { { 1 } };
                  █ █ █ █
    char m_array [256];
                █
    return { {crypt(_Nums, inSeed)} };
            █                      █
    do {
      █
        xxx = _error;
    } while(0)
     █
    bool CompareGenomeByFeatureResults::clickOnLink(std::string const& inLink) {
        auto const [sequence, type, firstPosition, lastPosition] = parseLink(inLink);
                  █
    decltype (x)  y;
            █
    using x_t = decltype (x);
                        █
    foo( ABC );
        █   █
    foo( ( ABC ) )
        █       █
    typedef void timer_cb (struct timer_node *n);
                         █
    if (n) ;
          █
    a( , 1);
      █
    foo() noexcept;
         █
    return {x};
          █
    void funcName() const;
                   █
    void ncName() override;
                 █
    template < int ... X > int bar2()
                  █
    {
            auto s = sizeof ... (  X  );
                           █   █
            chomp(  X  ) ...;
                            █
            return X  +  ...;
    }
    do amime3(); while (false);
                      █
    auto b0 = unknown_kw { 2 };
                        █
    if (data)   go = new ClassA();
              █
    else        go = new ClassB();
              █

    auto f0(int a, int b) -> int;
                         █  █


int main(int argc , char *argv [])
                 █ █          █
{
	int a [2];
	     █
	a[ n ] = 3;
	  █ █
	const char *names [] =
	                 █
	{
		"{ False , True }",
		        █ █
		"{ Ignore, Add, Remove, Force }",

	return (-1);
	      █


    int a ( );
         █ █
    int a (int b) {};
         █       █
    int foo () {};
           █
void ( int a ) ( int b );
      █     █ █ █     █
static void sockaddr_unmapped(
    struct sockaddr *sa __attribute__ ((unused)),
                                     █
    socklen_t *len __attribute__ ((unused)))
                                █

void (^ weak_recurseTreeNodes)(int a);
       █
template< >
struct Bar< false > : Foo { };
                   █


template < typename T > inline static bool remove(T column)
        █ █          █
        █              █

int & a(int & b);
   █ █     █ █
int c(int &)
   █     █
{
	d = aa (& y,& d) ;
	      █  █   █  █
        e = ee ();
              █
	if ( a == 5 ) ...
	  █
            █      █
            █      █
            ...
        if (b) ;
              █
	if ( a == 6 ) b = 66;        
                     █
	if ( a == 7 ) { b = 77; }        
                     █
        if (! a) {
             █
            b = 4;
        } else {
         █    █
            b = 5;
        }
        for(a = 1 ; a < b ; a++) {
                 █       █
           ...
	for( ; ; ) {
            █ █ █
           ...
	switch (whatIsToDo) ...
	      █
	while (start < end) ...
	     █



namespace Server {
                █
class Cache : public QObject
           █ █
Cache::StorageDebugger ()
                      █
    : mFile(0)
   █ █
{
        new service;
           █
        delete service;
              █
        delete[] buffer;
                █
        if (this == & other) return * this;
                     █               █
        switch (a) {
        case 1 :
              █
                b= 1;
                break;
        case 2 : {
                b = 2;
                break;
        }
        default :
                break;
        }
        bool operator () (Entity::Id lhs, Entity::Id rhs) const
        ...          █  █

        a = ( int ) 5.6;
             █   █ █
        cpp = int (7);
                 █
        len = sizeof (int);
                    █
        SomeStruct a = SomeStruct {1, 2, 3};
                                 █
	someFuncCall(SomeStruct {4, 5, 6});
	                       █
        log . foo . bar = 5;
           █ █   █ █
	other -> foo -> bar = 123;
	     █  █   █  █
}
/// doxygen sequence
   █
///< doxygen sequence
    █
//! doxygen sequence
   █
//!< doxygen sequence
    █
#if A
#else /* Comment A */
     █
#endif /* Comment B */
      █

void Initialize( BYTE nDelay = 100 );
                            █ █
void f1()
{
      auto a = [█=█]█(█int *a, Something & b█);

      parallel_for(0, 100, [█&█]█(█const int i█)█{
          const std::vector values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };

      list[idx] (param);
               █

double foo()
{
	return( foo(n) );
	       █      █


Vector2<double> ()
               █

{
        List<byte> bob = new List<byte> ();
                  █
        QVector<QPair<Condition, QString> > mWhenThen;
                                         █

template<int i, int ... Indexes, typename IdxHolder, typename ... Elements>
                   █                                         █
struct index_holder_impl<i, index_holder<Indexes ...>, IdxHolder, Elements ...>
                                                █                         █
{
	typedef typename index_holder_impl<i + 1, index_holder<Indexes ... i>,	Elements ...>::type type;
	                                                              █                 █
Java Sources 

    for (Type var : expr)
                   █
uncrustify-uncrustify-0.76.0/documentation/htdocs/project-support.jpg000066400000000000000000000073141434072136500262610ustar00rootroot00000000000000JFIF,,Created with The GIMPCC X"  + !"#&18, !"1#23ACQabq ?o %~Y]g#|OCk+kL؄~׌i -ks|*H̩5TL}9Kh?k^T:#4nc/7c\3jrrBWnM-m#v yfXG[FO.y9un/(5`8&Q tET_hϡϬK˩5qЩ^{zǤ0[/6 *Yq͞sM<݁ T%{tOގV'f2WoYUEf'>goydewƕD1TrNEq&'ݟwϫcFΫLF\5S_yqA #bVURߴ@ ̶LM4zP2^S(Y&ƨ_ǵpᙦ:#Kz}⺞~cWUg=Kh˝'ߝ\ x'_s?u ~iw1D;Ҥƃ((Pfu*|7vR]?eRTa#Ù«iX&tpTŪz҈b{d./<'Odw=z@K^?$as5I6Ƚtj;|Vsp̦50 Bgj#M ϶بM|!lI⡁㽲soI񎧭~bsQ֛>=}\rP96_ǚJ3&R8BLP+Qi6yN=~VxU䁪7j관YÍY- )t9/ 5;o}!/M{d3qS'ѱ?y?RE}ϺV:J )qvqj!"ᾉV?)za΄v sbt}\GM)/Έ CCTW hμ#*df=fF'?"YڌxY"YWCA嗝[ ԻbYfF M ŋG _Z }s_+A= y˲oir40w%nuGrD]fw<`,^;5S@vk|I 2{zUB 6j3)ʂS*5!tvC$}djB=O?v`^ƾRRFGe[5)' ;4$nyvF[qQ i ^3X'6p;R,} rp$v41J%L2ͳ* .=(,;zI:\eUbĘ0*Iy1s?{VFOl'>\)!Ę1_;# Ai#b7V| .`oYwC#ƔٚHμ6OUI?lM7d3fP2y21U%YPH;Q#|窟L40^ #Hf3Q3clT&e.jM}$ICJW5wW"`Euۓ&zW/NE&K1JHv,I@&wa'?\_E Sj7f4b!Ѵzp=}g%y (g&|f]U" BjQj=YQ"±";hWU3/, E~X\ I6[o3[.-gb>Bν]DFaS$9;;^q-$Ǵ ['F*$>1ɳ0 7ӼY *9|WgTJx)!@kY Ȯ;ژY "=Pg25#;է-H[]N =BP.?0ZGRכW(-U`e!$RŬK^7u%pih-Nn),#U8ۉ88s;ϗ˜O\W8ZxQչ#5e4l 2ZA ,!;JEHK5P C>R=²ZU|>8f>/X%%9k,uVӴUg‡G=fٕJܓ)L[jjL J&*.d~T'7kO6Y#LG0XREqˏ{7{U3t8.w{nqc[IE[O>:_PAgmIs✯A{VI0"'5UD6a͎! Qka1|EnwT\ZPۋ;ԹR}׻\|غe*RǍ<#_b^(I }u̜_Or)$"eτI]R0aڦw0oH a6"UܚV\eY@)wQBn7%oSW\Kq}KJx4jx5I}}]l@t˾DٚpUol8f|z8C$^.fc3,cЀO)=):} cw Ԣ] 灰wM?0V'nU+R:+q];hRL<:JL1v"JlgEmmHW:iĸT£u-Σ%m,6_t3s&#iַ;B9q]JRwOݿCM‘5gXզW|az߿Ӹxk]-Ep[`, k!ʝ}zSVA=A~禍xvH┾ssws[P rK;[kS2tpċ)ߓ)YmK~)Wy{e'pdr _kkLA`#:uncrustify-uncrustify-0.76.0/documentation/htdocs/uncrustify.css000066400000000000000000000014241434072136500253200ustar00rootroot00000000000000html, body { background-color: #5a5f52; color: #ffffff; } div.node1 { margin: 0em; width: 70%; } div.node2 { margin: 0em; width: 90%; } h1, h2, h3, h4 { font-family: Verdana, sans-serif; color: #d1c121; } h1 { font-size: 18pt; } h2 { font-size: 14pt; } h3 { font-size: 11pt; } h4 { font-size: 10pt; } pre { font-family: Verdana, sans-serif; font-size: 11pt; background-color: #6b6f63; } a { font-family: Verdana, sans-serif; font-size: 11pt; color: #d1c121; } p, small, li { font-family: Verdana, sans-serif; color: #ffffff; } p { font-size: 11pt; } small { font-size: 7pt; } li { list-style-type: disc; font-size: 11pt; font-style: italic; } uncrustify-uncrustify-0.76.0/documentation/htdocs/uncrustify.html000066400000000000000000000014151434072136500254740ustar00rootroot00000000000000

Uncrustify your C code

Project web site

Download Uncrustify 0.0.3

What it does:
  • Indent code
  • Align code on '=' and variable definitions
  • Align #define stuff
  • Align backslash-newline stuff
  • Reformat comments (a little bit)
  • Fix inter-character spacing
What it doesn't do (yet):
  • Split long lines
  • Handle format changing #if/#else stuff
uncrustify-uncrustify-0.76.0/documentation/not_a_compiler.txt000066400000000000000000000006541434072136500246460ustar00rootroot00000000000000uncrustify is not a compiler. Let have a look on: # if A int abc( int a, int b, int c) { // do something # else int abc( int a, int b) { // do something else # endif } It will produce an error, because uncrustify doesn't evaluate the value of A. uncrustify will read all the lines, a compiler only a part of it, depending on A. uncrustify encounter two opening braces but only one closing brace. uncrustify-uncrustify-0.76.0/documentation/overview.odt000066400000000000000000000404131434072136500234660ustar00rootroot00000000000000PK|4^2 ''mimetypeapplication/vnd.oasis.opendocument.textPK|4Configurations2/statusbar/PK|4'Configurations2/accelerator/current.xmlPKPK|4Configurations2/floater/PK|4Configurations2/popupmenu/PK|4Configurations2/progressbar/PK|4Configurations2/menubar/PK|4Configurations2/toolbar/PK|4Configurations2/images/Bitmaps/PK|4 layout-cachecd`d(g``d``Q1< PKE PK|4 content.xml]o񽿂P¹h-KX986@r94EP\]rZV}k_Z3$w+13w/NrŔR6 D(#..^_K[%IiYC W% TvxFչ)5%2yzϻ]P骸pBųFWK)KRq۠a}8|a2P;)Tg)nB0`)OeĔq5j^ytWTqb[1dJ.Q;ra$=ZFRkvXa`ᔺlN-AK|pR,- e8~GhLO:G0MZJ6%6B_,$Hb"8Oou*3G_ԧt1ׂ%,T%3F.;?> }ڗ*B O Z&<"쿚$vEFjw[݀T7yzXk,me! Rj*֣C/XͿ-͆E4`knE>v>gf?H?xhG&hYYUA! v&sa=H7"= R(sWзʫOˁHPGq92t&ZseIm72x3HnBz1o`܄O*R5-Bb i&Nd@fRaub;w`IU TS.'.yD3FOD@ :M^w;n򎶛&vl;nB_{OYiy03iתG|iGt?]]_6DӖO?VΰgAM3I/{_r:kf>.|~6u˦.lz|:|mz&=k7]3MO`}o3\sM2?B] $t?܅}o5v.t߅} w.thB]|څ}Bm.t߅}S{kU/qW.P)X.^Yi>'QySұ31`1+:K8I`i!RǏ7Ik)c좸I~P㽁r7Mkyȩfg߉PY=̡̓)_l-GUyiqv@_1u`XF=r!/e5P] ap}\Ԅ # %}0LD̐ 6?f4!!M.~"-D  I5ɤ z 2rnb |m\ Cjaiuq=oX nF( 궳]K)*6aV֥:d~Z!XgD!ZMֹqYd2V.`۳mW͚%۷[gv=.^%"|DzM5nRuVoё=`@28.]u-e :S/k{IAFE <8 `BQ!$`Cܖ. B4GRn wS;]Bנ"㇌fnW,9+4MA0#iC]""_JT 1mUԾgj$hV Jf 0ݖoOnIdi ^>Tny ^}=,7 ޏuCfĘr׉?o;Χ*SNlSFc>#;_FReZOAp@iyq*P;qA5ku/yd!$ǟܰp?YnMR?~uaog9MU+_|I-+!#3 s\^zXεCppY}mIѺy(\L*hgBVv@o!)lVz;N\q\+Ozԝ~XrPvIq|m[VB?a XK)M*=.$G^>7ѵ}va1`iB7OozMbLX\dPCXcPpdH(b)%1BK{2+ZPqJKCoC﬙]鄣Pa 6ul^ᚅ1r$I >%c2_N&n3Db j$$G˛aS.$Zd+ItU/[džfn&ޛĕ͐vd>D߇u,l^a|1 +*l:}lja{cƕY3E `TFz5j͠>QǩxzcbZFDX ,WFCX+Q"0| Co)FψFg_QomFL1'`ٌ%KNd &{-˃q 䎊i8ː炂^h6$#B4 rtY =kTeﵚK-[s9%^:RlQv!tE<1RBSp(rCG op趏E=P=i- qvDnC3'Q*pGV I񇨐Lm1B +J-h+`!RT!TT>)&Xg5O -F;,*baW i T912ВP  fk)m` SJQq%BAJ)Xe[ZGu}֊$֦kdѐԪl g{ȷh s( TG[yAcY; CsC>4aB d:]hg r|1Kk7n8a[1q S^mɠ@neJ&抴b\ž+$)ʅnrkm+,qJr *NmnXͅ4A< :u_x/uϳKV23O!9F.sKXT2%& ˵Rt~*Gm ĩS9 UeJT(ݡ8U0=Pbx[ kWEKi9?KQtI"(|g2;$(r\5/vl|%ݾ"HY_AtŠ/qҬIslna¬) 3}#sjU^[ޭBￇ-U*J75nFm9G-@?'J}|): tߡ\ \?,GiYl JYO[ݓO=7D?b"MNa~ّmFnw:9߸XL7Onx+)5Ϭ.a0 Y4|r `M{:l\L ڱɚBAGNzC)'P)6kvnuºNX :aͯ:aEIrR&.BdSpx8a9ҬwT- J \"̙ ROήtԛg?\ GiZ"56s^]w})fHZ4BcCCVToġ%sFpocɳ(yMّD|lozu[^lv93ˌ50Ӕn$ 0CtN\2[u4p>8v 0C hÄAɗBH}fC{ǡS/p lϵHⱢ:C$dHT:Ey\-ߣ= PKdR&PK|4U ""meta.xml OpenOffice.org/2.0$Linux OpenOffice.org_project/680$Build-90112006-03-27T19:37:112006-03-27T20:53:56en-US11PT1H16M49SPK|4Thumbnails/thumbnail.pngxeP-ŵ@ V(ZN((^\(Z(!HR$H{vfw?fwV9QOGHC]Ek!.6APQ|o\MOU_)GTK S|L)tw}yl,snccQ Gv`[ R.*ץɈ'%Y`)bSU(3sYu|,].Brh*q\'^LS;4mt! ,|1\e߽7b3[mZegӓ[ѫr]fd6=xh CTm ?ie݇]ʇ{vݷzv^4Z n)ȯE#\I2AD!Tc⋧h. *3TSSyvJ'&֬p+="mƖ?MVv, aSy,3@va 8 s7Jkp{ @;44}+w|B_F/ JQOuٳŚCΫ~?@-D/u2ۭ#~'w>@7yg(;JWm:KyU%2D[CDbLY =拎>Ҩ*QpjGf Uy#n ;W[LKCeQ.,p`k)Oґ Y;oV+HY4Gq0O'ɊzuJm#zcȁ%9'.Gf̢}gIEif)mК0vE\3263ItپXOl&ɒ0^(8j3D4U|$cSB,Mu6/JnD)3yEq[<%UʾVt^%ˇ?57]{?tPߟ'@DcN*ћk7fS~΀qs=-E(ny_b%$$ܴ'iRHK.Y 2 %7ßlW rp.YlɯVM=o!'8c-%1ZFk:- Bmݭ:Jytg K7Sh]~R=@@ #ԬmbPitNLJڎꬫq&C3Ҡ\'?7$VD\>DuIeWN&^X CT6"w,pw%^<ho,(tc3UAMCqӨ^_~*dj{k5Qҿ&j6v0_xuM)fWK;/OwsYN͑ _%?LplfrO@_+3&a kτ픞f Ly~L(.={c_6GD 2W` 8 bC\SjXQHɋ!GC6a3_ P5Q&cyWAO?:hNY3~i@-մjz76N{rЎ'NzIC9T:ubOn )~-\a@t_]&_-'!_%~~Fú$))AڳoAUދU-ZR, K+g-P8$)ePB> ^0ZT0.1T5/ldH u9IӖ>jWN n,q]6$i7|.Ҁ25 |$d%M- #2ִq`q,Ӧ*# <{SQ$Ƨe`{o^\146`˛!Wp piUT*|޼[9VmO э(i (Do솸o~B(߭xX4>FI ܐ@t{S7a>C~U7F~ra}%s6+G2bxٮ˞`$-q2mzDZG:GJ}<0:lIp5Ď7oqGÁ#c@ ̴r/%bsq02nsIW/(hL<~13_; 1k7ܠDc58ì-FHH"ynP0OKJ%haB글Ë?~rj&ϔo?#r>]i\q*fQSrgKG4`H-ܣ!N_9_9qҾ.jlB?Fm~Yny{H2I\^*W 0Jß?QjJEӨ6-!cx! YOx@{qs ]k}) v9hE3c 0spd)=NfzjK tɹOř:n0۬2B)c"uL&茣6c^Iגk|P7#lq!9 FUuo!y89#M+25{CmlwtV"gBSNo3!A1.yƕUުYH$ghx=Wnrikrּn hCP)dh79^'MwBc\p8 Å]Җ(^/4/}9XIڡ~W*CTjF^wθ^n r$#zcij)K*̪1#d =lBj?`^lrSg*3V黛Q\z~'jiNzxzGǛHuջ|dX@(OC}b\k]XqlWVNI؄&LOl͵jq+bk9d*F}=GY,و0:v,Ĩú ObX,El;.T r -V}mp Y ˸B=AaA&T%mn#v L~XK@sSK ecBz`9FS{D/FnNEoCyHW]MnLr)4tuL4o?, 11p8db5|lrcHv䆴\{yD ,Q8UmJ.J~ c߾4 oǰ-9F7xK@_B6ȣkQ>^Xh&ksB:i !}h4,Hs7/nqr=A[p\ݙZc<ߌL\EO{-;qpaOL%BN[ް4~S ;pwmL#'7L@-׹'6|j})Ծ E,B\6#r1xV;|*KJlZkYqYӈn'ՐK%GGyqNrX̒[oz#)L n{GžZ͞bS;TV\)E ;!4#8OYsqI&=rЄ 㭋E(O|fw# ۗޚs.l MH =+1ECUGF:PKH|QPK|4 settings.xmlY]s:};#m@H饥 7a/Y+2 ]qi (QE+1r-܇f~4e ]R7-/VLsݔ,4~#iͷZpDJeZ]./P-*FQI(|qt[SjNHW*o];״w~m}5~}ldk^ּs~6۽1piUrr:& Z f[WkŰXf.vx|1-\30C6*|6p;p }΄>ek}MdڜATmk[.1]VPM~;P4 8{$.:~8"kB]4L/_rbN ikKTlA7aks9b9|NJY>luDmi7VhHP`oi咩W9qɉ :XӉ ,r=txP玔h\u\Bs*Y,@)(qرr*0…5]219I͝(G v~.?a/#mG'Pekwۛ[΁Fќq,}'Aǂ/$wb03S@b[[V'c|ڄ*u![PSX'Ţ'OʦI *C6Wr4Ql>:f:fb(i[1 r;GjR[4٥N*AJ+W__KHB*A@Is]&d2j\*%5ֆ76l7LLtgaJZFK nrۃ;~U}.($eQvM78vw-X87%;Vɥ+Vdȣcn*jPK5kb_PK|4META-INF/manifest.xmlMn F9ަDj =$ ő6@X)H;ۈAhky+zX`uiP}F`k0 լjѶN-ןדi(.N,0J=67Z:޶U]+*.Sz]#wnS^tñzA)4.HCݕE'3RJgL6G/q'k^PSE]kj|-" TLa'8 NG\ ͎alⰵ I> +o6ӛ{nR~{rWPKOPK|4^2 ''mimetypePK|4MConfigurations2/statusbar/PK|4'Configurations2/accelerator/current.xmlPK|4Configurations2/floater/PK|4Configurations2/popupmenu/PK|4JConfigurations2/progressbar/PK|4Configurations2/menubar/PK|4Configurations2/toolbar/PK|4Configurations2/images/Bitmaps/PK|4E  -layout-cachePK|4ʚn |content.xmlPK|4dR& 9styles.xmlPK|4U ""meta.xmlPK|4H|Q Thumbnails/thumbnail.pngPK|45kb_ 6settings.xmlPK|4O;;META-INF/manifest.xmlPK(<uncrustify-uncrustify-0.76.0/documentation/paren_stack.txt000066400000000000000000000167231434072136500241520ustar00rootroot00000000000000 =-----------------------------------------------------------------------------= * * * Paren Stack * * * =-----------------------------------------------------------------------------= At the heart of this algorithm are two stacks. There is the Paren Stack (PS) and the Frame stack. The PS (pse in the code) keeps track of braces, parens, if/else/switch/do/while/etc items -- anything that is nestable. Complex statements go through some of these BS_ stages: BS_PAREN1 - paren on if/for/switch/while, etc BS_PAREN2 - paren on do{}while() BS_BRACE_DO - brace set on do{} BS_BRACE2 - brace on if/else/for/switch/while BS_ELSE - expecting 'else' after 'if' BS_ELSEIF - expecting 'if' after 'else' BS_WHILE - expecting 'while' after 'do' The file is processed one token at a time to support #if/#else/#endif preprocessors at any point. Take this simple if statement as an example: if ( x ) { x--; } The stack would look like so: The format is first the token processed and then the PSE stack as it appears AFTER the token is processed. 'if' [IF - PAREN1] '(' [IF - PAREN1] [SPAREN OPEN] 'x' [IF - PAREN1] [SPAREN OPEN] ')' [IF - BRACE2] <- note that the stage was changed on SPAREN_CLOSE '{' [IF - BRACE2] [BRACE OPEN] 'x' [IF - BRACE2] [BRACE OPEN] '--' [IF - BRACE2] [BRACE OPEN] ';' [IF - BRACE2] [BRACE OPEN] '}' [IF - ELSE] <- lack of else kills the ELSE, closes statement Virtual brace example: if ( x ) x--; else if (y) y--; else z++; 'if' [IF - PAREN1] '(' [IF - PAREN1] [SPAREN OPEN] 'x' [IF - PAREN1] [SPAREN OPEN] ')' [IF - BRACE2] 'x' [IF - BRACE2] [VBRACE OPEN] <- VBrace open inserted before because the token was not '{' '--' [IF - BRACE2] [VBRACE OPEN] ';' [IF - ELSE] <- Semicolon causes a VBrace close to be inserted after the semicolon 'else' [ELSE - ELSEIF] <- IF changed into ELSE, expect IF or BRACE 'x' [ELSE - BRACE2] [VBRACE OPEN] <- lack of '{' -> VBrace '++' [ELSE - BRACE2] [VBRACE OPEN] ';' <- VBrace close inserted after semicolon ELSE removed after statement close Nested virtual brace example: (EOF represents the end of the file) if ( x ) if (y) y--; else z++; EOF 'if' [IF - PAREN1] '(' [IF - PAREN1] [PAREN OPEN] 'x' [IF - PAREN1] [PAREN OPEN] ')' [IF - BRACE2] 'if' [IF - BRACE2] [VBRACE OPEN] [IF - PAREN1] <- VBrace on BRACE2, IF opened '(' [IF - BRACE2] [VBRACE OPEN] [IF - PAREN1] [SPAREN OPEN] 'y' [IF - BRACE2] [VBRACE OPEN] [IF - PAREN1] [SPAREN OPEN] ')' [IF - BRACE2] [VBRACE OPEN] [IF - BRACE2] 'y' [IF - BRACE2] [VBRACE OPEN] [IF - BRACE2] [VBRACE OPEN] '--' [IF - BRACE2] [VBRACE OPEN] [IF - BRACE2] [VBRACE OPEN] ';' [IF - BRACE2] [VBRACE OPEN] [IF - ELSE] 'else' [IF - BRACE2] [VBRACE OPEN] [ELSE - ELSEIF] 'z' [IF - BRACE2] [VBRACE OPEN] [ELSE - BRACE2] [VBRACE OPEN] '++' [IF - BRACE2] [VBRACE OPEN] [ELSE - BRACE2] [VBRACE OPEN] ';' [IF - BRACE2] [VBRACE OPEN] [ELSE - BRACE2] - step1 [IF - BRACE2] [VBRACE OPEN] - step2 [IF - ELSE] - step3 EOF -- this last semi is more complicated - first it terminates the VBRACE and then the else, which then, since it is the end of a statement, terminates the VBRACE. That bumps the IF stage to ELSE. The EOF kills that off (since it is not an else) Order of operation: 1) if TOS=VBRACE && PC=SEMI, insert VBRACE close, PC=>VBRACE close 2) if PC=VBRACE close or PC=BRACE close, and TOS is complex (if/else/etc) then advance complex stage. If statement ends, pop and advance Stages for each complex statement: if IF-PAREN1, IF-BRACE2, IF-ELSE if/else IF-PAREN1, IF-BRACE2, IF-ELSE, ELSE-ELSEIF, ELSE-BRACE2 if/else if/else IF-PAREN1, IF-BRACE2, IF-ELSE, ELSE-ELSEIF, IF-PAREN1, IF-BRACE2, IF-ELSE, ELSE-ELSEIF, ELSE-BRACE2 for FOR-PAREN1, FOR-BRACE2 while WHILE-PAREN1, WHILE-BRACE2 switch SWITCH-PAREN1, SWITCH-BRACE2 synchronized SYNCHRONIZED-PAREN1 do/while DO-BRACE_DO, DO-WHILE, WHILE-PAREN2 Another less-interesting example: { if (x) volatile { y++; } return y; } '{' [BRACE OPEN] 'if' [BRACE OPEN] [IF - PAREN1] '(' [BRACE OPEN] [IF - PAREN1] [PAREN OPEN] 'x' [BRACE OPEN] [IF - PAREN1] [PAREN OPEN] ')' [BRACE OPEN] [IF - BRACE2] 'volatile' [BRACE OPEN] [IF - BRACE2] [VBRACE OPEN] [VOLATILE - BRACE2] '{' [BRACE OPEN] [IF - BRACE2] [VBRACE OPEN] [VOLATILE - BRACE2] [BRACE OPEN] 'y' [BRACE OPEN] [IF - BRACE2] [VBRACE OPEN] [VOLATILE - BRACE2] [BRACE OPEN] '++' [BRACE OPEN] [IF - BRACE2] [VBRACE OPEN] [VOLATILE - BRACE2] [BRACE OPEN] ';' [BRACE OPEN] [IF - BRACE2] [VBRACE OPEN] [VOLATILE - BRACE2] [BRACE OPEN] '}' [BRACE OPEN] [IF - ELSE] <- the brace close ends brace-open, volatile-brace2 and vbrace-open 'return' [BRACE OPEN] <- not else 'y' [BRACE OPEN] ';' [BRACE OPEN] '}' <- empties the stack =-----------------------------------------------------------------------------= * * * Parse Frames * * * =-----------------------------------------------------------------------------= The pse stack is kept on a frame stack. The frame stack is need for languages that support preprocessors (C, C++, C#) that can arbitrarily change code flow. It also isolates #define macros so that they are indented independently and do not affect the rest of the program. When an #if is hit, a copy of the current frame is push on the frame stack. When an #else/#elif is hit, a copy of the current stack is pushed under the #if frame and the original (pre-#if) frame is copied to the current frame. When #endif is hit, the top frame is popped. This has the following effects: - a simple #if / #endif does not affect program flow - #if / #else /#endif - continues from the #if clause When a #define is entered, the current frame is pushed and cleared. When a #define is exited, the frame is popped. Take this example, which isn't very exciting, as both the #if and #else parts end up with the same paren stack. This is the usual case. { foo(param1, #ifdef DEBUG "debug"); #else "release"); #endif } Right before the #ifdef, we have this for the paren stack: Top> [BRACE OPEN] [PAREN OPEN] The #ifdef pushes a copy of the current stack, so we have this: Top> [BRACE OPEN] [PAREN OPEN] [BRACE OPEN] [PAREN OPEN] The close paren after "debug" closes out the PAREN-OPEN on the top of the stack. Top> [BRACE OPEN] [BRACE OPEN] [PAREN OPEN] The #else swaps the top two frames. Top> [BRACE OPEN] [PAREN OPEN] [BRACE OPEN] Right after the #else, we hit another close paren after the "release". Top> [BRACE OPEN] [BRACE OPEN] At the #endif, the top of stack is thrown out, which restores us to the #if path. Top> [BRACE OPEN] uncrustify-uncrustify-0.76.0/documentation/preprocessor_indentation.txt000066400000000000000000000257711434072136500270050ustar00rootroot00000000000000 Preprocessor blocks can arbitrarily alter the program flow and make indenting code a challenging task. This file covers the following topics: 1) Uncrustify approach to indentation of preprocessor blocks 2) Rationale for the chosen approach 3) Recommendations for the user --------------------------------------------------------- Uncrustify approach to indentation of preprocessor blocks --------------------------------------------------------- Uncrustify handles different preprocessor blocks in different ways. There are just three simple rules to remember. A. #ifdef/#endif block ---------------------- The contents of the block are indented starting at the same brace level of the code preceding the block. Once #endif is reached, any indentation change caused by the block is discarded and the following code continues at the same brace level of the code preceding the block. B. #ifdef/#elif/#else/#endif block ---------------------------------- The contents of the #ifdef part of the block are indented starting at the same brace level of the code preceding the block. Once an #elif/#else is reached, the indentation restarts at the brace level of the code preceding the #ifdef part of the block. This is repeated for each #else and #elif part. Once #endif is reached, the following code continues at the same brace level reached at the end of the #ifdef part. C. #define block ---------------- The contents of the block are indented starting anew, therefore not following the indentation of the code preceding the block. Once the #define ends, any indentation change caused by the block is discarded and the following code continues at the same brace level of the code preceding the block. --------------------------------- Rationale for the chosen approach --------------------------------- Preprocessor blocks can be very hard to handle and there is no definitive correct way that works in all situations. Therefore a compromise approach is required, coupled with warning to the user when tricky code is encountered. A. #ifdef/#endif block ---------------------- Let's start with the simplest case, a balanced #ifdef/#endif block. This is a block that starts and ends at the same brace level. For example: some code A #ifdef TEST some code B #endif some code C or some code A #ifdef TEST { some code B } #endif some code C These cases are very easy to handle, since the indentation before, through and after the preprocessor block is consistent. There is no alteration of the brace level from 'some code A' to 'some code C'. Rule A applies nicely to the above code. Let's now look at a more complex example. some code A #ifdef TEST { some code B #endif some code C #ifdef TEST some code D } #endif some code E This contains two unbalanced #ifdef blocks. Most likely the programmer intended to use them in pair, but that is not important when it comes to indentation. The code above could be indented as: some code A #ifdef TEST { some code B #endif some code C #ifdef TEST some code D } #endif some code E or as: some code A #ifdef TEST { some code B #endif some code C #ifdef TEST some code D } #endif some code E Note how 'some code C' is indented differently in the two cases: in the first, the indentation change caused by the first #ifdef block is discarded, while in the second it is taken into consideration. Depending on the options used at compile time, the code in the preprocessor blocks could be included or not included in the final code, therefore none of the two options is superior to the other. A better approach would be to avoid the use of unbalanced preprocessor blocks, so that indentation of the code could be uniquely defined. Uncrustify follows the first version, discarding indentation changes caused by the #ifdef block. Warning messages about unbalanced preprocessor blocks can optionally be printed by using the option 'pp_warn_unbalanced_if'. B. #ifdef/#elif/#else/#endif block ---------------------------------- Let's start with the simplest case, a balanced #ifdef/#else/#endif block. This is a block where each part starts and ends at the same brace level. For example: some code A #ifdef TEST some code B #else some code C #endif some code D or some code A #ifdef TEST { some code B } #else { some code C } #endif some code D or even: some code A #ifdef TEST { some code B } #else some code C #endif some code D These cases are very easy to handle, since the indentation before, through and after the preprocessor blocks is consistent. There is no alteration of the brace level from 'some code A' to 'some code D'. Rule B applies nicely to the above code. Let's now look at a more complex example. some code A #ifdef TEST { some code B #else some code C #endif some code D #ifdef TEST some code E } #else some code F #endif some code G This once again raises the question of where 'some code D' should be placed and there is no unique best choice. Uncrustify has chosen (for reasons explained further below) to: - indent each part of an #ifdef/#elif/#else/#endif block starting at the brace level of the code preceding #ifdef. - continue after #endif at the indentation level reached at the end of the #ifdef part. This would result in the following formatted code: some code A #ifdef TEST { some code B #else some code C #endif some code D #ifdef TEST some code E } #else some code F #endif some code G And yes, the indentation of 'some code F' may surprise you a bit. Here is an even trickier example: some code A #ifdef TEST some code B #else { some code C #endif some code D #ifndef TEST some code E } #else some code F #endif some code G which results in this bizarre output, where 'some code G' is no longer aligned with 'some code A': some code A #ifdef TEST some code B #else { some code C #endif some code D #ifndef TEST some code E } #else some code F #endif some code G So why not simply discard all the indentation changes created by an #ifdef/#elif/#else/#endif block? The answer is simple: to make sure things still work fine after the #endif line! Without going into too much detail here (see the overview.odt and theory.txt files for more info) in addition to the visible braces, there is a thing called 'virtual braces' which also affects indentation. A common use of #ifdef/#elif/#else/#endif blocks is to do some different things on the same set of variables. In this case, there may not be any visible brace, but virtual braces may get modified between the code before and after the preprocessor block. Throwing away the whole thing would result in the code after #endif being formatted in a completely wrong manner. As an example, consider this piece of code: some code A if (cond1) some var = value1; else some var = #ifdef TEST value2; #else value3; #endif some code B The formatted version looks exactly like the original. But if the complete #ifdef/#else/#endif block was thrown away, the result would be as if 'some code B' was being indented as part of the else (not #else) block, at a position just after the = symbol. By retaining the changes made in the #ifdef part, the 'else' block is correctly handled and 'some code B' is indented as per its original position. C. #define block ---------------- Here is an example showing how #define works. The following code: { { some code A #define TEST \ { \ some defs \ } some code B } } would be formatted as: { { some code A #define TEST \ { \ some defs \ } some code B } } Notice how 'some code B' and 'some code A' are indented in the same way, while the #define body starts from anew. ---------------------------- Recommendations for the user ---------------------------- The golden rule is to avoid unbalanced preprocessor blocks. This keeps things simple and indentation can be uniquely defined. Existing unbalanced blocks should be reworked so that all braces are properly balanced, either outside or inside the preprocessor blocks. If you have a huge code base, it may be difficult to quickly find offending blocks. If the option 'pp_warn_unbalanced_if' is set to true, Uncrustify will print warning messages at the end of each unbalanced preprocessor block part based on the following rules: 1) unbalanced #ifdef part This works for either an #ifdef/#endif block or the first part of an #ifdef/#elif/#else/#endif block. If the #ifdef ends at a brace level different from where it starts, a message will be displayed, highlighting both the starting and ending indentation levels. 2) unbalanced #elif or #else part If such part ends at a different brace level than the corresponding #ifdef part, a message will be displayed highlighting the ending indentation levels of both the part in question and the respective #ifdef part. 3) unbalanced #define If a #define ends at a brace level different from where it starts, a message will be displayed, highlighting the ending indentation level. Here is an example with a mix of balanced and unbalanced blocks, with line numbers in front for easier reference: 1 void Fun(int &data) 2 { 3 data = 1; 4 5 #ifdef MANUAL_LAYOUT 6 { 7 data = 2; 8 } 9 #endif 10 11 #ifdef MANUAL_LAYOUT 12 { 13 { 14 data = 2; 15 #elif TEST1 16 data = 21; 17 #elif TEST2 18 { 19 data = 22; 20 #elif TEST3 21 { 22 { 23 data = 22; 24 #else 25 { 26 { 27 data = 22; 28 #endif 29 30 data = 3; 31 32 #ifdef MANUAL_LAYOUT 33 { 34 data = 4; 35 #else 36 data = 5; 37 #endif 38 39 #ifdef MANUAL_LAYOUT 40 data = 6; 41 #else 42 data = 7; 43 #endif 44 45 #ifdef MANUAL_LAYOUT 46 } 47 } 48 #endif 49 50 #ifdef MANUAL_LAYOUT 51 } 52 #endif 53 54 data = 8; 55 56 data = 9; 57 } These are the warning messages related to unbalanced preprocessor blocks printed by Uncrustify when 'pp_warn_unbalanced_if' is true. fl_check(236): orig line is 15, unbalanced #if block braces (1), in-level is 1, out-level is 3 fl_check(248): orig line is 17, unbalanced #if-#else block braces (1), #else out-level is 1, #if out-level is 3 fl_check(248): orig line is 20, unbalanced #if-#else block braces (1), #else out-level is 2, #if out-level is 3 fl_check(236): orig line is 35, unbalanced #if block braces (1), in-level is 3, out-level is 4 fl_check(291): orig line is 37, unbalanced #if-#else block braces (2), #else out-level is 3, #if out-level is 4 fl_check(321): orig line is 48, unbalanced #if block braces (2), in-level is 4, out-level is 2 fl_check(321): orig line is 52, unbalanced #if block braces (2), in-level is 4, out-level is 3 uncrustify-uncrustify-0.76.0/documentation/theory.txt000066400000000000000000000100161434072136500231570ustar00rootroot00000000000000 ------------------------------------------------------------------------------- This document is too incomplete to be of much use. Patches are welcome! Theory of operation ------------------- Uncrustify goes through several steps to reformat code. The first step, parsing, is the most complex and important. Step 1 - Tokenize ----------------- C code must be understood to some degree to be able to be properly indented. The parsing step reads in a text buffer and breaks it into chunks and puts those chunks in a list. When a chunk is parsed, the original column and line are recorded. These are the chunks that are parsed: - punctuators - numbers - words (keywords, variables, etc) - comments - strings - whitespace - preprocessors See token_enum.h for a complete list. See punctuators.cpp and keywords.cpp for examples of how they are used. In the code, chunk types are prefixed with 'CT_'. The CT_WORD token is changed into a more specific token using the lookup table in keywords.cpp Step 2 - Tokenize Cleanup ------------------------- The second step is to change the token type for certain constructs that need to be adjusted early on. For example, the '<' token can be either a CT_COMPARE or CT_ANGLE_OPEN. Both are handled very differently. If a CT_WORD follows CT_ENUM/CT_STRUCT/CT_UNION, then it is marked as a CT_TYPE. Basically, anything that doesn't depend on the nesting level can be done at this stage. Step 3 - Brace Cleanup ------------------------- This is possibly the most difficult step. do/if/else/for/switch/while bodies are examined and virtual braces are added. Brace parent types are set. Statement start and expression starts are labeled. And #ifdef constructs are handled. This step determines the levels (m_braceLevel, level and m_ppLevel). REVISIT: The code in brace_cleanup.cpp needs to be reworked to take advantage of being able to scan forward and backward. The original code was going to be merged into tokenize.cpp, but that was WAY too complex. Step 4 - Fix Symbols (combine.cpp) ---------------------------------- This step is no longer properly named. In the original design, neighboring chunks were to be combined into longer chunks. This proved to be a silly idea. But the name of the file stuck. This is where most of the interesting identification stuff goes on. Colons type are detected, variables are marked, functions are labeled, etc. Also, all the punctuators are classified. Ie, CT_MINUS become CT_NEG or CT_ARITH. - Types are marked. - Functions are marked. - Parenthesis and braces are marked where appropriate. - finds and marks casts - finds and marks variable definitions (for aligning) - finds and marks assignments that may be aligned - changes CT_INCDEC_AFTER to CT_INCDEC_BEFORE - changes CT_STAR to either CT_PTR_TYPE, CT_DEREF or CT_ARITH - changes CT_MINUS to either CT_NEG or CT_ARITH - changes CT_PLUS and CT_ADDR to CT_ARITH, if needed - other stuff? Casts ----- Casts are detected as follows: - paren pair not part of if/for/etc nor part of a function - contains only CT_QUALIFIER, CT_TYPE, '*', and no more than one CT_WORD - is not followed by CT_ARITH Tough cases: (foo) * bar; If uncertain about a cast like this: (foo_t), some simple rules are applied. If the word ends in '_t', it is a cast, unless followed by '+'. If the word is all caps (FOO), it is a cast. If you use custom types (very likely) that aren't detected properly (unlikely), the add them to the config file like so: (example Using C-Sharp types) type UInt32 UInt16 UInt8 Byte type Int32 Int16 Int8 Step 6+ Everything else ------------------------- From this point on, many filters are run on the chunk list to change the token columns. indent.cpp sets the left-most column. align.cpp set the column for individual chunks. space.cpp sets the spacing between chunks. Others insert newlines, change token position, etc. Last Step - Output ------------------------- At the final step the list is printed to the output. Everything except comments are printed as-is. Comments are reformatted in the output stage. uncrustify-uncrustify-0.76.0/documentation/threads.txt000066400000000000000000000042621434072136500233050ustar00rootroot00000000000000 Notes on how to deal with the wicked corner case that is C/C++ preprocessor #if magic. None of this is actually implemented. Languages not affected: - D - Java - ECMA (Java Script) Langauges affected: - C - C++ - C# - Vala - Pawn - Objective C/C++ Threads of code are created for functions that navigate the tokens. There is the master list of the raw tokens parsed out. There is at least one thread, which, in the absense of any #if statements, is the same as the raw token list. In the threads, a BARRIER is placed where ever code cannot move past. This represents and #if or #else statement. Normally, the barriers are skipped when navigating code. Only when removing a newline does the code need to check for a barrier. For #if statements without an #else, there is an implicit #else added that contains nothing. // example 1 a #if X b #endif c Thread #if #endif V V 0 - a -+- b -+- c | | 1 +-----+ <- empty else path (ie, for '#if 0') Max depth = 2 // example 2 a #if X b #else c #endif d #if #endif V V 0 - a -+- b -+- d | | 1 +- c -+ <- else path Max depth = 2 // example 3 a #if X b #elif Y c #elif Z d #else e #endif f #if A g #endif h #if X #endif #if A V V V 0 - a -+- b -+- f -----------+- g -+- h | | | | 1 +- c -+ <- elif Y +-----+ <- empty else | | 2 +- d -+ <- elif Z | | 3 +- e -+ <- else Max depth = 4 The detection routines need to be executed once for each thread, up to the maximum thread depth. Note that the typical maximum thread depth is going to be 2-3. 0 - a - b - f - g - h 1 - a - c - f ----- h 2 - a - d - f - g - h 3 - a - e - f - g - h The general rule is that if the current thread exceed the max, thread 0 is used. Identification is the primary use for the threads. The secondary use is indentation. The indentation of each token at each thread level is recorded. The maximum indentation for the token is used, assuming the thread is without error. ('#if 0' commented out code that is bad may not be handled.) I won't know if this will work for sure until I try it. uncrustify-uncrustify-0.76.0/documentation/track.html000066400000000000000000000012701434072136500231000ustar00rootroot00000000000000 Uncrustify: where do the Spaces options work 

{
        aM=M<
/a>bM+M<
/font>111M-M55M;
}
uncrustify-uncrustify-0.76.0/emscripten/000077500000000000000000000000001434072136500204065ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/emscripten/CMakeLists.txt000066400000000000000000000163611434072136500231550ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.0.0) # ------------------------------------------------------------------------------ if(DEFINED ENV{EMSCRIPTEN}) SET(emscripten_root_path "$ENV{EMSCRIPTEN}") else() find_file(EMCC_EXECUTABLE emcc HINTS "/usr/lib/emscripten") if(EXISTS ${EMCC_EXECUTABLE}) get_filename_component(emscripten_root_path ${EMCC_EXECUTABLE} DIRECTORY) endif() endif() # Abort if not found. if ("${emscripten_root_path}" STREQUAL "") MESSAGE(FATAL_ERROR "Could not locate the Emscripten directory via the \ EMSCRIPTEN environment variable! Set it up or pass \ -Demscripten_root_path=xxx to CMake to specify the \ directory.") endif() SET(CMAKE_TOOLCHAIN_FILE "${emscripten_root_path}/cmake/Modules/Platform/Emscripten.cmake") SET(project_name "libUncrustify") PROJECT(${project_name}) set(CMAKE_INCLUDE_CURRENT_DIR ON) #get parent folder, add src GET_FILENAME_COMPONENT(unc_projdir ${CMAKE_CURRENT_LIST_DIR} DIRECTORY) # ------------------------------------------------------------------------------ include(CheckCXXCompilerFlag) include(CheckIncludeFileCXX) include(CheckSymbolExists) include(CheckCXXSymbolExists) include(CheckTypeSize) find_package(PythonInterp REQUIRED) # # Determine config # if(WIN32) # Windows builds use src/windows_compat.h instead of config.h else() # Generate config.h set(avail_headers "") set(headers inttypes.h memory.h stdint.h stdlib.h strings.h string.h sys/stat.h sys/types.h unistd.h utime.h ) foreach(header ${headers}) string(TOUPPER "${header}" header_uc) string(REGEX REPLACE "[^A-Z0-9_]" "_" include_var "HAVE_${header_uc}") check_include_file_cxx("${header}" ${include_var}) if(${include_var}) list(APPEND avail_headers ${header}) endif() unset(include_var) unset(header_uc) endforeach() unset(headers) check_include_file("stdbool.h" HAVE_STDBOOL_H) set(symbols memset strcasecmp strchr strdup strerror strtol strtoul ) foreach(symbol ${symbols}) string(TOUPPER "${symbol}" symbol_uc) string(REGEX REPLACE "[^A-Z0-9_]" "_" symbol_var "HAVE_${symbol_uc}") check_cxx_symbol_exists("${symbol}" "${avail_headers}" ${symbol_var}) unset(symbol_var) unset(symbol_uc) endforeach() unset(symbols) unset(avail_headers) check_type_size(_Bool _BOOL LANGUAGE C) configure_file("${unc_projdir}/src/config.h.in" config.h @ONLY) endif() # # Generate uncrustify_version.h # set(CURRENT_VERSION "Uncrustify-0.69.0_f") option(NoGitVersionString "Do not use make_version.py and git to build a version string" OFF) if(NoGitVersionString) configure_file("${unc_projdir}/src/uncrustify_version.h.in" "${PROJECT_BINARY_DIR}/uncrustify_version.h" @ONLY) else() # Add target to generate version header; # do this every build to ensure git SHA is up to date add_custom_target(generate_version_header ${CMAKE_COMMAND} -D PYTHON_EXECUTABLE:STRING=${PYTHON_EXECUTABLE} -D SOURCE_DIR:PATH="${unc_projdir}" -D INPUT:PATH="${unc_projdir}/src/uncrustify_version.h.in" -D OUTPUT:PATH="${PROJECT_BINARY_DIR}/uncrustify_version.h" -D CURRENT_VERSION:STRING="CURRENT_VERSION" -P ${unc_projdir}/cmake/GenerateVersionHeader.cmake COMMENT "Generating version header" ) set_source_files_properties( "${PROJECT_BINARY_DIR}/uncrustify_version.h" PROPERTIES GENERATED TRUE ) endif() # # Generate token_names.h # add_custom_command( OUTPUT "${PROJECT_BINARY_DIR}/token_names.h" COMMAND ${CMAKE_COMMAND} "-Dsrc_file=${unc_projdir}/src/token_enum.h" "-Ddst_file=${PROJECT_BINARY_DIR}/token_names.h" -P "${unc_projdir}/cmake/GenerateTokenNames.cmake" MAIN_DEPENDENCY "${unc_projdir}/src/token_enum.h" COMMENT "Generating token_names.h" ) # Set up commands for generated source files function(py_gen OUTPUT SCRIPT INPUT) set(out "${PROJECT_BINARY_DIR}/src/${OUTPUT}") set(deps "${unc_projdir}/src/${INPUT}") get_filename_component(outdir "${out}" DIRECTORY) foreach(arg IN LISTS ARGN) list(APPEND deps "${unc_projdir}/src/${arg}") endforeach() add_custom_command( OUTPUT "${out}" COMMAND ${CMAKE_COMMAND} -E make_directory "${outdir}" COMMAND ${PYTHON_EXECUTABLE} "${unc_projdir}/scripts/${SCRIPT}" "${out}" ${deps} DEPENDS ${deps} "${unc_projdir}/scripts/${SCRIPT}" MAIN_DEPENDENCY ${unc_projdir}/src/${INPUT} COMMENT "Generating ${OUTPUT}" ) endfunction() py_gen(punctuator_table.h make_punctuator_table.py symbols_table.h ) py_gen(options.cpp make_options.py options.h options.cpp.in ) py_gen(option_enum.h make_option_enum.py option.h option_enum.h.in ) py_gen(option_enum.cpp make_option_enum.py option.h option_enum.cpp.in ) # ------------------------------------------------------------------------------ FILE(GLOB unc_infiles "${unc_projdir}/src/*.cpp") ADD_EXECUTABLE(${project_name} ${unc_infiles} ${unc_projdir}/src/token_enum.h ${unc_projdir}/src/symbols_table.h ${unc_projdir}/src/options.h ${unc_projdir}/src/option.h ${PROJECT_BINARY_DIR}/src/options.cpp ${PROJECT_BINARY_DIR}/src/option_enum.cpp ${PROJECT_BINARY_DIR}/src/option_enum.h ${PROJECT_BINARY_DIR}/uncrustify_version.h ${unc_projdir}/src/option_enum.cpp.in ${unc_projdir}/src/option_enum.h.in ${unc_projdir}/src/options.cpp.in ) add_dependencies(${project_name} generate_version_header) include_directories( ${PROJECT_BINARY_DIR} ${PROJECT_BINARY_DIR}/src ${unc_projdir}/src ) SET(unc_compile_flags "--bind -O3") SET_TARGET_PROPERTIES(${project_name} PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED YES CXX_EXTENSIONS NO COMPILE_FLAGS "${unc_compile_flags}" LINK_FLAGS "${unc_compile_flags} \ -s TOTAL_MEMORY=67108864 \ -s ALLOW_MEMORY_GROWTH=1 \ -s VERBOSE=1 \ -s MODULARIZE=1 \ -s EXPORT_NAME=\"'${project_name}'\" \ -s ERROR_ON_UNDEFINED_SYMBOLS=1 \ -s 'EXTRA_EXPORTED_RUNTIME_METHODS=[\"UTF8ToString\",\"stringToUTF8\",\"lengthBytesUTF8\", \"writeAsciiToMemory\"]' \ -s WASM=0\ --memory-init-file 0\ --pre-js ${CMAKE_CURRENT_LIST_DIR}/prefix_module.js \ --post-js ${CMAKE_CURRENT_LIST_DIR}/postfix_module.js \ ") EM_LINK_PRE_JS(${project_name} ${CMAKE_CURRENT_LIST_DIR}/prefix_module.js) EM_LINK_POST_JS(${project_name} ${CMAKE_CURRENT_LIST_DIR}/postfix_module.js) # ------------------------------------------------------------------------------ # add file post/pre-fix add_custom_command(TARGET ${project_name} POST_BUILD COMMAND ${CMAKE_COMMAND} -Dunc_targetfile:FILEPATH=$ -P "${CMAKE_CURRENT_LIST_DIR}/CMake_catFiles.cmake" ) add_custom_target(emscripten_test COMMAND ${CMAKE_COMMAND} -Dunc_targetfile:FILEPATH=$ -Dunc_projdir:FILEPATH=${unc_projdir} -P "${CMAKE_CURRENT_LIST_DIR}/CMake_emscripten_test.cmake" COMMENT "Starting libUncrustify.js tests:" ) uncrustify-uncrustify-0.76.0/emscripten/CMake_catFiles.cmake000066400000000000000000000007741434072136500242120ustar00rootroot00000000000000if(NOT unc_targetfile) MESSAGE(FATAL_ERROR "unc_targetfile param not defined") endif() function(cat IN_FILE OUT_FILE) file(READ ${IN_FILE} CONTENTS) file(APPEND ${OUT_FILE} "${CONTENTS}") endfunction() SET(unc_tmpfile "${unc_targetfile}_.tmp") file(WRITE "${unc_tmpfile}" "") cat("${CMAKE_CURRENT_LIST_DIR}/prefix_file" "${unc_tmpfile}") cat("${unc_targetfile}" "${unc_tmpfile}") cat("${CMAKE_CURRENT_LIST_DIR}/postfix_file" "${unc_tmpfile}") file(RENAME "${unc_tmpfile}" "${unc_targetfile}") uncrustify-uncrustify-0.76.0/emscripten/CMake_emscripten_test.cmake000066400000000000000000000014761434072136500256700ustar00rootroot00000000000000if(NOT unc_targetfile) MESSAGE(FATAL_ERROR "unc_targetfile param not defined") endif() if(NOT unc_projdir ) MESSAGE(FATAL_ERROR "unc_projdir param not defined") endif() message(STATUS "unc_targetfile: ${unc_targetfile}") message(STATUS "test_dir: ${unc_projdir}/emscripten/test/") message(STATUS "-----------------------------------------------------------------------------") find_package(PythonInterp REQUIRED) execute_process( COMMAND ${PYTHON_EXECUTABLE} "${unc_projdir}/emscripten/test/run_tests.py" "${unc_targetfile}" "${unc_projdir}/emscripten/test/" WORKING_DIRECTORY ${unc_projdir} RESULT_VARIABLE make_version_error OUTPUT_VARIABLE make_version_output ) MESSAGE(STATUS ${make_version_output}) if(NOT ${make_version_error} EQUAL 0) message(FATAL_ERROR "errno: ${make_version_error}") endif() uncrustify-uncrustify-0.76.0/emscripten/README.md000066400000000000000000000022471434072136500216720ustar00rootroot00000000000000building -------------------------------------------------------------------------------- **dependencies**: cmake, python, clang, emscripten, node 1. create a `build` directory somewhere 2. inside this directory call `cmake ` and `make`
(the CMakeLists.txt file is located in /emscripten) Optionally the generated libUncrustify.js can be tested via `make emscripten_test` _libUncrustify.js_ example usage -------------------------------------------------------------------------------- 1. load module instance: ```js var uncrustify = libUncrustify(); ``` 2. set option settings either one at a time with: ```js uncrustify.set_option( "optionNameString", "newOptionValueString" ); ``` or a whole bunch via: ```js uncrustify.loadConfig( "configFileFormatString" ) ``` 3. set the language of the to be formated file string ```js uncrustify.set_language( languageInt ); ``` 4. format a file string: ```js var uncrustyFileString = uncrustify.uncrustify( "crustyFileString" ); ``` 5. delete initialized module instance: ```js uncrustify.destruct(); ``` uncrustify-uncrustify-0.76.0/emscripten/build.sh000077500000000000000000000040131434072136500220420ustar00rootroot00000000000000#!/bin/sh # script to build without cmake, # manually generate header files usually created by CMake, # past those inside Uncrustifys 'src' dir # run this script in the 'emscripten' dir sh_dir="$(dirname "$(readlink -f "$0")")" outTmp="temp.bak" out="libUncrustify.js" #https://github.com/kripken/emscripten/blob/master/src/settings.js em++ -O3 \ ${COMMENT# initialy increase memory for big input files } \ -s TOTAL_MEMORY=67108864 \ ${COMMENT# let the memory grow dynamically if even more is needed } \ -s ALLOW_MEMORY_GROWTH=1 \ -s VERBOSE=1 \ -s MODULARIZE=1 \ -s EXPORT_NAME="'libUncrustify'" \ -s ERROR_ON_UNDEFINED_SYMBOLS=1 \ -s ALLOW_MEMORY_GROWTH=1 \ -s "EXTRA_EXPORTED_RUNTIME_METHODS=['UTF8ToString', 'stringToUTF8', 'lengthBytesUTF8', 'writeAsciiToMemory']" \ --bind \ --pre-js prefix_module.js \ --post-js postfix_module.js \ ${COMMENT# TODO: handle async ajax load to enable this } \ --memory-init-file 0 \ -o $out \ ../src/*.cpp \ && cat "./prefix_file" "$out" "./postfix_file" > "$outTmp" \ && mv "$outTmp" "$out" \ && ./test/run_tests.py "$sh_dir/libUncrustify.js" "$sh_dir/test" uncrustify-uncrustify-0.76.0/emscripten/libUncrustify.d.ts000066400000000000000000000525531434072136500240540ustar00rootroot00000000000000/** * Emscriptens interface for bound std::vectors */ interface EmscriptenVector< T > { get( i : number ) : T push_back( elem : T ); resize( size : number, elem : T ); size() : number; get() : T; set( elem : T ); //TODO: // isAliasOf(); // clone(); // delete(); // isDeleted() : boolean; // deleteLater(); } /** * Emscriptens interface for bound enum types */ interface EmscriptenEnumType { //! returns list with value objects of an enum values() : EmscriptenVector; } /** * Emscriptens interface for bound enum type value objects */ interface EmscriptenEnumTypeObject { //! return value of an enum value object value : number; } declare namespace LibUncrustify { // // Example how to iterate below options : forin iterate Options, // skip 'values' key, [ s : Options_STRING ] : EmscriptenEnumTypeObject; // region enum bindings export interface OptionTypeValue extends EmscriptenEnumTypeObject {} export interface OptionType extends EmscriptenEnumType { BOOL : OptionTypeValue; IARF : OptionTypeValue; LINEEND : OptionTypeValue; TOKENPOS : OptionTypeValue; NUM : OptionTypeValue; UNUM : OptionTypeValue; STRING : OptionTypeValue; } export interface IARFValue extends EmscriptenEnumTypeObject {} export interface IARF extends EmscriptenEnumType { IGNORE : IARFValue; ADD : IARFValue; REMOVE : IARFValue; FORCE : IARFValue; } export interface LineEndValue extends EmscriptenEnumTypeObject {} export interface LineEnd extends EmscriptenEnumType { LF : LineEndValue; CRLF : LineEndValue; CR : LineEndValue; AUTO : LineEndValue; } export interface TokenPosValue extends EmscriptenEnumTypeObject {} export interface TokenPos extends EmscriptenEnumType { IGNORE : TokenPosValue; BREAK : TokenPosValue; FORCE : TokenPosValue; LEAD : TokenPosValue; TRAIL : TokenPosValue; JOIN : TokenPosValue; LEAD_BREAK : TokenPosValue; LEAD_FORCE : TokenPosValue; TRAIL_BREAK : TokenPosValue; TRAIL_FORCE : TokenPosValue; } export interface LogTypeValue extends EmscriptenEnumTypeObject {} export interface LogType extends EmscriptenEnumType { SYS : LogTypeValue; ERR : LogTypeValue; WARN : LogTypeValue; NOTE : LogTypeValue; INFO : LogTypeValue; DATA : LogTypeValue; FILELIST : LogTypeValue; LINEENDS : LogTypeValue; CASTS : LogTypeValue; ALBR : LogTypeValue; ALTD : LogTypeValue; ALPP : LogTypeValue; ALPROTO : LogTypeValue; ALNLC : LogTypeValue; ALTC : LogTypeValue; ALADD : LogTypeValue; ALASS : LogTypeValue; FVD : LogTypeValue; FVD2 : LogTypeValue; INDENT : LogTypeValue; INDENT2 : LogTypeValue; INDPSE : LogTypeValue; INDPC : LogTypeValue; NEWLINE : LogTypeValue; PF : LogTypeValue; STMT : LogTypeValue; TOK : LogTypeValue; ALRC : LogTypeValue; CMTIND : LogTypeValue; INDLINE : LogTypeValue; SIB : LogTypeValue; RETURN : LogTypeValue; BRDEL : LogTypeValue; FCN : LogTypeValue; FCNP : LogTypeValue; PCU : LogTypeValue; DYNKW : LogTypeValue; OUTIND : LogTypeValue; BCSAFTER : LogTypeValue; BCSPOP : LogTypeValue; BCSPUSH : LogTypeValue; BCSSWAP : LogTypeValue; FTOR : LogTypeValue; AS : LogTypeValue; PPIS : LogTypeValue; TYPEDEF : LogTypeValue; VARDEF : LogTypeValue; DEFVAL : LogTypeValue; PVSEMI : LogTypeValue; PFUNC : LogTypeValue; SPLIT : LogTypeValue; FTYPE : LogTypeValue; TEMPL : LogTypeValue; PARADD : LogTypeValue; PARADD2 : LogTypeValue; BLANKD : LogTypeValue; TEMPFUNC : LogTypeValue; SCANSEMI : LogTypeValue; DELSEMI : LogTypeValue; FPARAM : LogTypeValue; NL1LINE : LogTypeValue; PFCHK : LogTypeValue; AVDB : LogTypeValue; SORT : LogTypeValue; SPACE : LogTypeValue; ALIGN : LogTypeValue; ALAGAIN : LogTypeValue; OPERATOR : LogTypeValue; ASFCP : LogTypeValue; INDLINED : LogTypeValue; BCTRL : LogTypeValue; RMRETURN : LogTypeValue; PPIF : LogTypeValue; MCB : LogTypeValue; BRCH : LogTypeValue; FCNR : LogTypeValue; OCCLASS : LogTypeValue; OCMSG : LogTypeValue; BLANK : LogTypeValue; OBJCWORD : LogTypeValue; CHANGE : LogTypeValue; CONTTEXT : LogTypeValue; ANNOT : LogTypeValue; OCBLK : LogTypeValue; FLPAREN : LogTypeValue; OCMSGD : LogTypeValue; INDENTAG : LogTypeValue; NFD : LogTypeValue; JDBI : LogTypeValue; SETPAR : LogTypeValue; SETTYP : LogTypeValue; SETFLG : LogTypeValue; NLFUNCT : LogTypeValue; CHUNK : LogTypeValue; GUY98 : LogTypeValue; GUY : LogTypeValue; } export interface TokenTypeValue extends EmscriptenEnumTypeObject {} export interface TokenType extends EmscriptenEnumType { NONE : TokenTypeValue; EOF : TokenTypeValue; UNKNOWN : TokenTypeValue; JUNK : TokenTypeValue; WHITESPACE : TokenTypeValue; SPACE : TokenTypeValue; NEWLINE : TokenTypeValue; NL_CONT : TokenTypeValue; COMMENT_CPP : TokenTypeValue; COMMENT : TokenTypeValue; COMMENT_MULTI : TokenTypeValue; COMMENT_EMBED : TokenTypeValue; COMMENT_START : TokenTypeValue; COMMENT_END : TokenTypeValue; COMMENT_WHOLE : TokenTypeValue; COMMENT_ENDIF : TokenTypeValue; IGNORED : TokenTypeValue; WORD : TokenTypeValue; NUMBER : TokenTypeValue; NUMBER_FP : TokenTypeValue; STRING : TokenTypeValue; STRING_MULTI : TokenTypeValue; IF : TokenTypeValue; ELSE : TokenTypeValue; ELSEIF : TokenTypeValue; FOR : TokenTypeValue; WHILE : TokenTypeValue; WHILE_OF_DO : TokenTypeValue; SWITCH : TokenTypeValue; CASE : TokenTypeValue; DO : TokenTypeValue; SYNCHRONIZED : TokenTypeValue; VOLATILE : TokenTypeValue; TYPEDEF : TokenTypeValue; STRUCT : TokenTypeValue; ENUM : TokenTypeValue; ENUM_CLASS : TokenTypeValue; SIZEOF : TokenTypeValue; DECLTYPE : TokenTypeValue; RETURN : TokenTypeValue; BREAK : TokenTypeValue; UNION : TokenTypeValue; GOTO : TokenTypeValue; CONTINUE : TokenTypeValue; C_CAST : TokenTypeValue; CPP_CAST : TokenTypeValue; D_CAST : TokenTypeValue; TYPE_CAST : TokenTypeValue; TYPENAME : TokenTypeValue; TEMPLATE : TokenTypeValue; WHERE_SPEC : TokenTypeValue; ASSIGN : TokenTypeValue; ASSIGN_NL : TokenTypeValue; SASSIGN : TokenTypeValue; ASSIGN_DEFAULT_ARG : TokenTypeValue; ASSIGN_FUNC_PROTO : TokenTypeValue; COMPARE : TokenTypeValue; SCOMPARE : TokenTypeValue; BOOL : TokenTypeValue; SBOOL : TokenTypeValue; ARITH : TokenTypeValue; SARITH : TokenTypeValue; CARET : TokenTypeValue; DEREF : TokenTypeValue; INCDEC_BEFORE : TokenTypeValue; INCDEC_AFTER : TokenTypeValue; MEMBER : TokenTypeValue; DC_MEMBER : TokenTypeValue; C99_MEMBER : TokenTypeValue; INV : TokenTypeValue; DESTRUCTOR : TokenTypeValue; NOT : TokenTypeValue; D_TEMPLATE : TokenTypeValue; ADDR : TokenTypeValue; NEG : TokenTypeValue; POS : TokenTypeValue; STAR : TokenTypeValue; PLUS : TokenTypeValue; MINUS : TokenTypeValue; AMP : TokenTypeValue; BYREF : TokenTypeValue; POUND : TokenTypeValue; PREPROC : TokenTypeValue; PREPROC_INDENT : TokenTypeValue; PREPROC_BODY : TokenTypeValue; PP : TokenTypeValue; ELLIPSIS : TokenTypeValue; RANGE : TokenTypeValue; NULLCOND : TokenTypeValue; SEMICOLON : TokenTypeValue; VSEMICOLON : TokenTypeValue; COLON : TokenTypeValue; ASM_COLON : TokenTypeValue; CASE_COLON : TokenTypeValue; CLASS_COLON : TokenTypeValue; CONSTR_COLON : TokenTypeValue; D_ARRAY_COLON : TokenTypeValue; COND_COLON : TokenTypeValue; WHERE_COLON : TokenTypeValue; QUESTION : TokenTypeValue; COMMA : TokenTypeValue; ASM : TokenTypeValue; ATTRIBUTE : TokenTypeValue; AUTORELEASEPOOL : TokenTypeValue; OC_AVAILABLE : TokenTypeValue; OC_AVAILABLE_VALUE : TokenTypeValue; CATCH : TokenTypeValue; WHEN : TokenTypeValue; WHERE : TokenTypeValue; CLASS : TokenTypeValue; DELETE : TokenTypeValue; EXPORT : TokenTypeValue; FRIEND : TokenTypeValue; NAMESPACE : TokenTypeValue; PACKAGE : TokenTypeValue; NEW : TokenTypeValue; OPERATOR : TokenTypeValue; OPERATOR_VAL : TokenTypeValue; ASSIGN_OPERATOR : TokenTypeValue; ACCESS : TokenTypeValue; ACCESS_COLON : TokenTypeValue; THROW : TokenTypeValue; NOEXCEPT : TokenTypeValue; TRY : TokenTypeValue; BRACED_INIT_LIST : TokenTypeValue; USING : TokenTypeValue; USING_STMT : TokenTypeValue; USING_ALIAS : TokenTypeValue; D_WITH : TokenTypeValue; D_MODULE : TokenTypeValue; SUPER : TokenTypeValue; DELEGATE : TokenTypeValue; BODY : TokenTypeValue; DEBUG : TokenTypeValue; DEBUGGER : TokenTypeValue; INVARIANT : TokenTypeValue; UNITTEST : TokenTypeValue; UNSAFE : TokenTypeValue; FINALLY : TokenTypeValue; FIXED : TokenTypeValue; IMPORT : TokenTypeValue; D_SCOPE : TokenTypeValue; D_SCOPE_IF : TokenTypeValue; LAZY : TokenTypeValue; D_MACRO : TokenTypeValue; D_VERSION : TokenTypeValue; D_VERSION_IF : TokenTypeValue; PAREN_OPEN : TokenTypeValue; PAREN_CLOSE : TokenTypeValue; ANGLE_OPEN : TokenTypeValue; ANGLE_CLOSE : TokenTypeValue; SPAREN_OPEN : TokenTypeValue; SPAREN_CLOSE : TokenTypeValue; FPAREN_OPEN : TokenTypeValue; FPAREN_CLOSE : TokenTypeValue; TPAREN_OPEN : TokenTypeValue; TPAREN_CLOSE : TokenTypeValue; BRACE_OPEN : TokenTypeValue; BRACE_CLOSE : TokenTypeValue; VBRACE_OPEN : TokenTypeValue; VBRACE_CLOSE : TokenTypeValue; SQUARE_OPEN : TokenTypeValue; SQUARE_CLOSE : TokenTypeValue; TSQUARE : TokenTypeValue; MACRO_OPEN : TokenTypeValue; MACRO_CLOSE : TokenTypeValue; MACRO_ELSE : TokenTypeValue; LABEL : TokenTypeValue; LABEL_COLON : TokenTypeValue; FUNCTION : TokenTypeValue; FUNC_CALL : TokenTypeValue; FUNC_CALL_USER : TokenTypeValue; FUNC_DEF : TokenTypeValue; FUNC_TYPE : TokenTypeValue; FUNC_VAR : TokenTypeValue; FUNC_PROTO : TokenTypeValue; FUNC_START : TokenTypeValue; FUNC_CLASS_DEF : TokenTypeValue; FUNC_CLASS_PROTO : TokenTypeValue; FUNC_CTOR_VAR : TokenTypeValue; FUNC_WRAP : TokenTypeValue; PROTO_WRAP : TokenTypeValue; MACRO_FUNC : TokenTypeValue; MACRO : TokenTypeValue; QUALIFIER : TokenTypeValue; EXTERN : TokenTypeValue; DECLSPEC : TokenTypeValue; ALIGN : TokenTypeValue; TYPE : TokenTypeValue; PTR_TYPE : TokenTypeValue; TYPE_WRAP : TokenTypeValue; CPP_LAMBDA : TokenTypeValue; CPP_LAMBDA_RET : TokenTypeValue; TRAILING_RET : TokenTypeValue; BIT_COLON : TokenTypeValue; OC_DYNAMIC : TokenTypeValue; OC_END : TokenTypeValue; OC_IMPL : TokenTypeValue; OC_INTF : TokenTypeValue; OC_PROTOCOL : TokenTypeValue; OC_PROTO_LIST : TokenTypeValue; OC_GENERIC_SPEC : TokenTypeValue; OC_PROPERTY : TokenTypeValue; OC_CLASS : TokenTypeValue; OC_CLASS_EXT : TokenTypeValue; OC_CATEGORY : TokenTypeValue; OC_SCOPE : TokenTypeValue; OC_MSG : TokenTypeValue; OC_MSG_CLASS : TokenTypeValue; OC_MSG_FUNC : TokenTypeValue; OC_MSG_NAME : TokenTypeValue; OC_MSG_SPEC : TokenTypeValue; OC_MSG_DECL : TokenTypeValue; OC_RTYPE : TokenTypeValue; OC_ATYPE : TokenTypeValue; OC_COLON : TokenTypeValue; OC_DICT_COLON : TokenTypeValue; OC_SEL : TokenTypeValue; OC_SEL_NAME : TokenTypeValue; OC_BLOCK : TokenTypeValue; OC_BLOCK_ARG : TokenTypeValue; OC_BLOCK_TYPE : TokenTypeValue; OC_BLOCK_EXPR : TokenTypeValue; OC_BLOCK_CARET : TokenTypeValue; OC_AT : TokenTypeValue; OC_PROPERTY_ATTR : TokenTypeValue; PP_DEFINE : TokenTypeValue; PP_DEFINED : TokenTypeValue; PP_INCLUDE : TokenTypeValue; PP_IF : TokenTypeValue; PP_ELSE : TokenTypeValue; PP_ENDIF : TokenTypeValue; PP_ASSERT : TokenTypeValue; PP_EMIT : TokenTypeValue; PP_ENDINPUT : TokenTypeValue; PP_ERROR : TokenTypeValue; PP_FILE : TokenTypeValue; PP_LINE : TokenTypeValue; PP_SECTION : TokenTypeValue; PP_ASM : TokenTypeValue; PP_UNDEF : TokenTypeValue; PP_PROPERTY : TokenTypeValue; PP_BODYCHUNK : TokenTypeValue; PP_PRAGMA : TokenTypeValue; PP_REGION : TokenTypeValue; PP_ENDREGION : TokenTypeValue; PP_REGION_INDENT : TokenTypeValue; PP_IF_INDENT : TokenTypeValue; PP_IGNORE : TokenTypeValue; PP_OTHER : TokenTypeValue; CHAR : TokenTypeValue; DEFINED : TokenTypeValue; FORWARD : TokenTypeValue; NATIVE : TokenTypeValue; STATE : TokenTypeValue; STOCK : TokenTypeValue; TAGOF : TokenTypeValue; DOT : TokenTypeValue; TAG : TokenTypeValue; TAG_COLON : TokenTypeValue; LOCK : TokenTypeValue; AS : TokenTypeValue; IN : TokenTypeValue; BRACED : TokenTypeValue; THIS : TokenTypeValue; BASE : TokenTypeValue; DEFAULT : TokenTypeValue; GETSET : TokenTypeValue; GETSET_EMPTY : TokenTypeValue; CONCAT : TokenTypeValue; CS_SQ_STMT : TokenTypeValue; CS_SQ_COLON : TokenTypeValue; CS_PROPERTY : TokenTypeValue; SQL_EXEC : TokenTypeValue; SQL_BEGIN : TokenTypeValue; SQL_END : TokenTypeValue; SQL_WORD : TokenTypeValue; SQL_ASSIGN : TokenTypeValue; CONSTRUCT : TokenTypeValue; LAMBDA : TokenTypeValue; ASSERT : TokenTypeValue; ANNOTATION : TokenTypeValue; FOR_COLON : TokenTypeValue; DOUBLE_BRACE : TokenTypeValue; CNG_HASINC : TokenTypeValue; CNG_HASINCN : TokenTypeValue; Q_EMIT : TokenTypeValue; Q_FOREACH : TokenTypeValue; Q_FOREVER : TokenTypeValue; Q_GADGET : TokenTypeValue; Q_OBJECT : TokenTypeValue; MODE : TokenTypeValue; DI : TokenTypeValue; HI : TokenTypeValue; QI : TokenTypeValue; SI : TokenTypeValue; NOTHROW : TokenTypeValue; WORD_ : TokenTypeValue; } export interface LanguageValue extends EmscriptenEnumTypeObject {} export interface Language extends EmscriptenEnumType { C : LanguageValue; CPP : LanguageValue; D : LanguageValue; CS : LanguageValue; JAVA : LanguageValue; OC : LanguageValue; VALA : LanguageValue; PAWN : LanguageValue; ECMA : LanguageValue; } // endregion enum bindings // export interface GenericOptionPtr { type(): OptionTypeValue; description(): string; name(): string; possibleValues(): EmscriptenVector; defaultStr(): string; minStr(): string; maxStr(): string; isDefault: boolean; reset(): void set(value: string): boolean; value(): string; } export interface OptionGroupPtr { description: string options: EmscriptenVector; } export interface Uncrustify { OptionType: OptionType; IARF: IARF; LineEnd: LineEnd; TokenPos: TokenPos; LogType: LogType; TokenType: TokenType; Language: Language; //! get groups vector get_groups() : EmscriptenVector //! get options vector get_options() : EmscriptenVector //! destroys the current libUncrustify instance destruct() : void; //! returns the UNCRUSTIFY_VERSION string get_version() : string; //! adds a new keyword to Uncrustifys dynamic keyword map (dkwm, keywords.cpp) add_keyword( tag : string, type : TokenType ) : void //! removes a keyword from Uncrustifys dynamic keyword map (dkwm, keywords.cpp) // remove_keyword( tag : string ) // clears Uncrustifys dynamic keyword map (dkwm, keywords.cpp) clear_keywords() : void; //! sets all option values to their default values reset_options() : void; /** * resets value of an option to its default * * @param name: name of the option * @return options enum value of the found option or -1 if option was not found */ option_reset_value( name : string ) : number; /** * sets value of an option * * @param name name of the option * @param value value that is going to be set * @return options enum value of the found option or -1 if option was not found */ option_set_value( name : string, value : string ) : number; /** * returns value of an option * * @param name name of the option * @return currently set value of the option */ option_get_value( name : string ) : string; /** * reads option file string, sets the defined options * * @return returns EXIT_SUCCESS on success */ load_config( cfg : string ) : number; /** * returns the config file string based on the current configuration * * @param withDoc false= without documentation true=with documentation text lines * @param only_not_default false=containing all options true=containing only options with non default values * @return returns the config file string based on the current configuration */ show_config( withDoc : boolean, only_not_default : boolean ) : string; /** * returns the config file string with all options based on the current configuration * * @param withDoc false= without documentation true=with documentation text lines * @return returns the config file string with all options based on the current configuration */ show_config( withDoc : boolean ) : string; /** * returns the config file string with all options and without documentation based on the current configuration * * @return returns the config file string with all options without documentation based on the current configuration */ show_config() : string; //! enable or disable logging of a specific LogType log_type_enable(type : LogType, value : bool) : void /** * Show or hide the severity prefix "<1>" * * @param b true=show false=hide */ log_type_show_name( b : boolean ) : void; //! disables all logging messages quiet() : void; /** * format text * * @param file file string that is going to be formated * @param lang specifies in which language the input file is written (see LangFlag) * @param frag [optional] true=fragmented code input * false=unfragmented code input [default] * * @return formatted file string */ uncrustify( file : string, lang : LanguageValue, frag : boolean ) : string; uncrustify( file : string, lang : LanguageValue ) : string; /** * generate debug output * * @param file file string that is going to be formated * @param lang specifies in which language the input file is written (see LangFlag) * @param frag [optional] true=fragmented code input * false=unfragmented code input [default] * * @return debug output string */ debug( file : string, lang : LanguageValue, frag : boolean ) : string; debug( file : string, lang : LanguageValue ) : string; } var Uncrustify : { (module?: Object): Uncrustify; new (module?: Object): Uncrustify; }; } declare var uncrustify : LibUncrustify.Uncrustify; declare module "libUncrustify" { export = uncrustify; } uncrustify-uncrustify-0.76.0/emscripten/postfix_file000066400000000000000000000001741434072136500230260ustar00rootroot00000000000000if (typeof module !== 'undefined') module.exports = libUncrustify; if (typeof define === 'function') define(libUncrustify); uncrustify-uncrustify-0.76.0/emscripten/postfix_module.js000066400000000000000000000102471434072136500240110ustar00rootroot00000000000000 //! auto initializes the module Module["_initialize"](); //// execute this only one time, Module["_initialize"] = Function.prototype; // and replace it with a noop /** * Takes in a JS string with other params, converts it to UTF8 and * passes it to the actual _uncrustify function while also managing the * memory on the emscripten heap. */ Module["uncrustify"] = function(str, langIDX, frag, defer) { if( !str || typeof(str) !== "string" || str.length === 0 ) {return "";} var nDataBytes = lengthBytesUTF8(str)+1; // +1 for \0 var stringInputPtr = Module._malloc(nDataBytes); Module.stringToUTF8(str, stringInputPtr, nDataBytes); var retStringPointer = 0; switch(arguments.length) { // depending in the number of args the internal select_overload // function resolves the appropriate internal _uncrustify function case 2: { retStringPointer = Module["_uncrustify"](stringInputPtr, langIDX); break; } case 3: { retStringPointer = Module["_uncrustify"](stringInputPtr, langIDX, frag); break; } // case 4: // { // retStringPointer = Module["_uncrustify"](stringInputPtr, langIDX, frag, defer); // break; // } default: { break; } } Module._free(stringInputPtr); var retString = ""; if(retStringPointer !== 0) { retString = Module.UTF8ToString(retStringPointer); Module._free(retStringPointer); } return retString; } /** * Takes in a JS string with other params, converts it to UTF8 and * passes it to the actual _debug function while also managing the * memory on the emscripten heap. */ Module["debug"] = function(str, langIDX, frag) { if( !str || typeof(str) !== "string" || str.length === 0 ) {return "";} var nDataBytes = lengthBytesUTF8(str)+1; // +1 for \0 var stringInputPtr = Module._malloc(nDataBytes); Module.stringToUTF8(str, stringInputPtr, nDataBytes); var retStringPointer = 0; switch(arguments.length) { // depending in the number of args the internal select_overload // function resolves the appropriate internal _uncrustify function case 2: { retStringPointer = Module["_debug"](stringInputPtr, langIDX); break; } case 3: { retStringPointer = Module["_debug"](stringInputPtr, langIDX, frag); break; } default: { break; } } Module._free(stringInputPtr); var retString = ""; if(retStringPointer !== 0) { retString = Module.UTF8ToString(retStringPointer); Module._free(retStringPointer); } return retString; } /** * Takes in a JS string, removes non ascii chars (only those are needed * in a config) and passes it to the actual _loadConfig function while * also managing the memory on the emscripten heap. */ Module.load_config = function(str) { // UTF8 functions return on empty string but they have to be accepted too // to reset the current config if( !str || typeof(str) !== "string" || str.length === 0) {str = " ";} //remove unneeded non asci chars in the config str.replace(/[^\x00-\x7F]/g, ""); var nDataBytes = str.length+1; // +1 for \0 var stringInputPtr = Module._malloc(nDataBytes); Module.writeAsciiToMemory(str, stringInputPtr); var retStringPointer = Module["_load_config"](stringInputPtr); Module._free(stringInputPtr); var retString = ""; if(retStringPointer !== 0) { retString = Module.Pointer_stringify(retStringPointer); Module._free(retStringPointer); } return retString; } uncrustify-uncrustify-0.76.0/emscripten/prefix_file000066400000000000000000000002541434072136500226260ustar00rootroot00000000000000/* * @file libUncrustify.js — JS port of Uncrustify * * @author Ben Gardner, * ported by Daniel Chumak with the help of emscripten * @license GPLv2 */ uncrustify-uncrustify-0.76.0/emscripten/prefix_module.js000066400000000000000000000020061434072136500236040ustar00rootroot00000000000000 if( !Module.hasOwnProperty('noInitialRun') ) { Module.noInitialRun = true; } if( !Module.hasOwnProperty('noExitRuntime') ) { Module.noExitRuntime = true; } if( !Module.hasOwnProperty('print') || typeof Module["print"] != 'function') { Module.print = (function() { return function(text) { if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' '); console.log(text); }; })(); } if( !Module.hasOwnProperty('printErr') || typeof Module["printErr"] != 'function') { Module.printErr = function(text) { if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' '); if (0) { // XXX disabled for safety typeof dump == 'function') { dump(text + '\n'); // fast, straight to the real console } else { console.error(text); } }; } uncrustify-uncrustify-0.76.0/emscripten/test/000077500000000000000000000000001434072136500213655ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/emscripten/test/run_tests.py000077500000000000000000000035521434072136500237750ustar00rootroot00000000000000#!/usr/bin/env python # # Rebuilds the version using git describe # import sys from subprocess import Popen from os import listdir, EX_OK, EX_USAGE, EX_SOFTWARE from os.path import isfile, isdir, abspath, basename from tempfile import NamedTemporaryFile from glob import glob def main(args): if len(args) < 2 or not isfile(args[0]) or not isdir(args[1]): print("Usage:") print(" arg 1: libUncrustify.js file path") print(" arg 2: test directory path") return EX_USAGE c_red = '\033[31m' c_green = '\033[32m' c_end = '\033[0m' js_file_path = args[0] passed = 0 total = 0 test_files_dir = abspath(args[1]) test_files = glob(test_files_dir+"/test_*.js") temp_file = NamedTemporaryFile(delete=True) for test_file_path in test_files: total += 1 pt_strg = "Testing %s: " % basename(test_file_path) pt_strg_len = len(pt_strg) sys.stdout.write(pt_strg) with open(temp_file.name, 'r+') as t: process = Popen(["node", test_file_path, js_file_path], stderr=t, stdout=t) process.wait() if process.returncode == 0: print(("%spassed.%s" % (c_green, c_end)).rjust(86-pt_strg_len)) passed += 1 else: print(("%sfailed!%s" % (c_red, c_end)).rjust(78-pt_strg_len)) t.seek(0) text = t.read() print(text) if total == 0: print("%sError%s: no test files found in %s" % (c_red, c_end, test_files_dir)) return EX_USAGE print('-' * 80) if passed == total: print("%sAll %s tests passed%s" % (c_green, total, c_end)) return EX_OK else: print("%sWarning%s: %s/%s tests passed" % (c_red, c_end, passed, total)) return EX_SOFTWARE if __name__ == '__main__': exit(main(sys.argv[1:])) uncrustify-uncrustify-0.76.0/emscripten/test/test_run.js000066400000000000000000000011501434072136500235630ustar00rootroot00000000000000exports.test = function(libUncrustify, assert){ var uncrustify = libUncrustify(); var input = ' string a = "aaaa";'; var expectedOutput = 'string a = "aaaa";'; var generatedOutput = uncrustify.uncrustify( input, uncrustify.Language.CPP ); assert.deepEqual(expectedOutput, generatedOutput, "comparing expectedOutput and generatedOutput"); uncrustify.destruct(); }; if (module == require.main) { if(process.argv.length < 3) {throw "libUncrustify.js path missing";} var uncrustify = require(process.argv[2]); var assert = require("assert"); exports.test(uncrustify, assert); } uncrustify-uncrustify-0.76.0/etc/000077500000000000000000000000001434072136500170105ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/etc/MS-calling_conventions.cfg000066400000000000000000000002211434072136500240370ustar00rootroot00000000000000# bug 633 set COMMENT __stdcall set COMMENT __clrcall set COMMENT __fastcall set COMMENT __thiscall set COMMENT __vectorcall set COMMENT __cdecl uncrustify-uncrustify-0.76.0/etc/align_assign.txt000066400000000000000000000010561434072136500222110ustar00rootroot00000000000000The alignment at the sign '=' must be divided in different cases. Case CT_ASSIGN The most common case such as: a = 1; Case CT_ASSIGN_DEFAULT_ARG The default value for an argument such as: Foo( int Foo = 5 ); Case CT_ASSIGN_FUNC_PROTO The function prototype modifier such as: void* operator new(std::size_t) = delete; Foo( const Foo & ) = default; Foo( const Foo & ) = 0; Introduce the new option align_assign_func_proto Ref. #2170: https://github.com/uncrustify/uncrustify/issues/2170 uncrustify-uncrustify-0.76.0/etc/amxmodx.cfg000066400000000000000000000242211434072136500211470ustar00rootroot00000000000000# # AMX Mod X style for Pawn (or as close as possible) # ####################### # Basic Indenting Stuff # (a/i/r) comment notation for add/ignore/remove which is the actual setting input_tab_size = 1 # tab size on input file: usually 8 output_tab_size = 8 # tab size for output: usually 8 indent_columns = 8 # ie 3 or 8 indent_with_tabs = 2 # 1=only to the 'level' indent, 2=use tab indenting #indent_paren_nl = 1 # indent-align under paren for open followed by nl pp_indent = remove # indent preproc 1 space per level (a/i/r) pp_space_after = remove # spaces between # and word (add/ignore/remove) #indent_switch_case = 1 # spaces to indent case from switch #indent_case_brace = 0 # spaces to indent '{' from case # (usually 0 or indent_columns) #indent_brace = 0 # spaces to indent '{' from level (usually 0) indent_braces = 0 # whether to indent the braces or not #indent_label = 0 # 0=left >0=col from left (absolute column), # <0=sub from brace indent (relative column) indent_align_string = false # True/False - indent align broken strings indent_col1_comment = false # indent comments in column 1 indent_func_call_param = false # indent continued function calls to indent_columns otherwise index_columns + spaces to align with open paren. indent_namespace = true # indent stuff inside namespace braces indent_class = true # indent stuff inside class braces ############################ # Misc Inter-element Spacing # Force,Ignore,Add,Remove # ignored by nl_*_brace = true sp_paren_brace = force # space between ')' and '{' sp_fparen_brace = force # space between ')' and '{' of function sp_sparen_brace = force # space between ')' and '{' of if, while, etc sp_after_cast = force # space after cast - "(int) a" vs "(int)a" sp_before_byref = force # space before '&' of 'fcn(int& idx)' sp_inside_fparen = force # space inside 'foo( xxx )' vs 'foo(xxx)' sp_inside_fparens = remove # space inside 'foo( )' vs 'foo()' sp_inside_paren = remove # space inside '+ ( xxx )' vs '+ (xxx)' sp_inside_square = remove # space inside 'byte[ 5 ]' vs 'byte[5]' sp_inside_sparen = force # space inside 'if( xxx )' vs 'if(xxx)' sp_inside_for = force # space inside 'for( xxx )' vs 'for(xxx)' sp_inside_angle = ignore # space inside '<>', as in '' sp_before_sparen = force # space before '(' of 'if/for/while/switch' sp_after_sparen = force # space after ')' of 'if/for/while/switch' # the do-while does not get set here sp_before_angle = ignore # space before '<>', as in '' sp_after_angle = ignore # space after '<>', as in '' sp_before_square = ignore # space before single '[' sp_before_squares = remove # space before '[]', as in 'byte []' sp_paren_paren = force # space between nested parens - '( (' vs '((' sp_return_paren = remove # space between 'return' and '(' sp_sizeof_paren = remove # space between 'sizeof' and '(' sp_after_comma = force # space after ',' sp_arith = force # space around + - / * etc sp_bool = force # space around || && sp_compare = force # space around < > ==, etc sp_assign = force # space around =, +=, etc sp_func_def_paren = remove # space between 'func' and '(' - "foo (" vs "foo(" sp_func_call_paren = remove # space between 'func' and '(' - "foo (" vs "foo(" sp_func_proto_paren = remove # space between 'func' and '(' - "foo (" vs "foo(" sp_func_class_paren = remove # space between ctor/dtor and '(' #sp_type_func = 1 # space between return type and 'func' # a minimum of 1 is forced except for '*' sp_special_semi = remove # space empty stmt ';' on while, if, for # example "while (*p++ = ' ') ;" sp_before_semi = remove # space before all ';' sp_inside_braces = force # space inside '{' and '}' - "{ 1, 2, 3 }" sp_inside_braces_enum = force # space inside enum '{' and '}' - "{ a, b, c }" sp_inside_braces_struct = force # space inside struct/union '{' and '}' sp_macro = force # space between macro and value, ie '#define a 6' sp_macro_func = force # space between macro and value, ie '#define a 6' sp_square_fparen = remove # weird pawn stuff: native yark[rect](a[rect]) sp_after_tag = remove # pawn: space after a tag colon ################################ # Code Alignment # (not left column spaces/tabs) align_with_tabs = true # use tabs for aligning (0/1) align_keep_tabs = false # keep non-indenting tabs align_on_tabstop = true # always align on tabstops align_nl_cont = false # align the back-slash \n combo (macros) align_enum_equ_span = 1 # align the '=' in enums align_assign_span = 1 # align on '='. 0=don't align align_assign_thresh = 0 # threshold for aligning on '='. 0=no limit align_right_cmt_span = 8 # align comment that end lines. 0=don't align align_var_def_span = 1 # align variable defs on variable (span for regular stuff) align_var_def_thresh = 0 # align variable defs threshold align_var_def_inline = true # also align inline struct/enum/union var defs align_var_def_star_style = 1 # the star is part of the variable name align_var_def_colon = false # align the colon in struct bit fields align_var_struct_span = 1 # span for struct/union (0=don't align) align_pp_define_span = 1 # align bodies in #define statements align_pp_define_gap = 1 # min space between define label and value "#define a <---> 16" align_struct_init_span = 1 # align structure initializer values align_func_proto_span = 1 # align function prototypes align_number_right = false # right-align numbers (not fully supported, yet) align_typedef_span = 1 # align single-line typedefs align_typedef_gap = 1 # minimum spacing align_typedef_star_style = 1 # Start aligning style # 0: '*' not part of type # 1: '*' part of the type - no space # 2: '*' part of type, dangling ##################################### # Newline Adding and Removing Options # Add/Remove/Ignore nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" nl_func_decl_start = ignore # newline after the '(' in a function decl nl_func_decl_args = ignore # newline after each ',' in a function decl nl_func_decl_end = ignore # newline before the ')' in a function decl nl_func_type_name = ignore # newline between return type and func name in def nl_var_def_blk_end_func_top = 0 # newline after a block of variable defs nl_before_case = false # newline before 'case' statement nl_after_return = false # newline after return statement nl_after_case = false # disallow nested "case 1: a=3;" nl_fcall_brace = add # newline between function call and open brace nl_squeeze_ifdef = false # no blanks after #ifxx, #elxx, or before #endif TRUE/F nl_enum_brace = ignore # nl between enum and brace nl_struct_brace = ignore # nl between struct and brace nl_union_brace = ignore # nl between union and brace nl_assign_brace = ignore # nl between '=' and brace nl_class_brace = ignore # nl between class name and brace nl_namespace_brace = ignore # nl between namespace name and brace nl_do_brace = add # nl between do and { nl_if_brace = add # nl between if and { nl_for_brace = add # nl between for and { nl_else_brace = remove # nl between else and { nl_while_brace = add # nl between while and { nl_switch_brace = add # nl between switch and { nl_brace_else = remove # nl between } and else nl_brace_while = add # nl between } and while of do stmt nl_elseif_brace = add # nl between close paren and open brace in 'else if () {' nl_define_macro = 0 # alter newlines in #define macros nl_start_of_file = ignore # alter newlines at the start of file nl_start_of_file_min = 0 # min number of newlines at the start of the file nl_end_of_file = ignore # alter newlines at the end of file nl_end_of_file_min = 0 # min number of newlines at the end of the file pos_bool = start # end=move &&/|| to EOL ignore=gnore, start=move to SOL ##################### # Blank Line Options nl_before_block_comment = 3 # before a block comment (stand-alone # comment-multi), except after brace open nl_after_func_body = 3 # after the closing brace of a function body nl_after_func_proto = 3 # after each prototype nl_after_func_proto_group = 3 # after a block of prototypes nl_max = 3 # maximum consecutive newlines (3=2 lines) eat_blanks_after_open_brace = true # remove blank lines after { eat_blanks_before_close_brace = true # remove blank lines before } ######################## # Code Modifying Options # (non-whitespace) mod_paren_on_return = force # add or remove paren on return mod_full_brace_nl = 1 # max number of newlines to span w/o braces mod_full_brace_if = ignore # add or remove braces on if mod_full_brace_for = ignore # add or remove braces on for mod_full_brace_do = ignore # add or remove braces on do mod_full_brace_while = ignore # add or remove braces on while mod_pawn_semicolon = True # add optional semicolons mod_full_brace_function = add # add optional braces on Pawn functions ####################### # Comment Modifications cmt_star_cont = true # put a star on subsequent comment lines cmt_cpp_to_c = true # convert CPP comments to C comments cmt_cpp_group = true # if UO_cmt_cpp_to_c, try to group in one big C comment cmt_cpp_nl_start = true # put a blank /* at the start of a converted group cmt_cpp_nl_end = true # put a nl before the */ in a converted group uncrustify-uncrustify-0.76.0/etc/ben.cfg000066400000000000000000001511221434072136500202370ustar00rootroot00000000000000# # General options # # The type of line endings newlines = lf # auto/lf/crlf/cr # The original size of tabs in the input input_tab_size = 8 # number # The size of tabs in the output (only used if align_with_tabs=true) output_tab_size = 3 # number # The ASCII value of the string escape char, usually 92 (\) or 94 (^). (Pawn) string_escape_char = 92 # number # Alternate string escape char for Pawn. Only works right before the quote char. string_escape_char2 = 0 # number # Replace tab characters found in string literals with the escape sequence \t instead. string_replace_tab_chars = false # false/true # Allow interpreting '>=' and '>>=' as part of a template in 'void f(list>=val);'. # If true (default), 'assert(x<0 && y>=3)' will be broken. # Improvements to template detection may make this option obsolete. tok_split_gte = false # false/true # Override the default ' *INDENT-OFF*' in comments for disabling processing of part of the file. disable_processing_cmt = "" # string # Override the default ' *INDENT-ON*' in comments for enabling processing of part of the file. enable_processing_cmt = "" # string # Enable parsing of digraphs. Default=false enable_digraphs = false # false/true # If the file contains bytes with values between 128 and 255, but is not UTF-8, then output as UTF-8 utf8_byte = false # false/true # Force the output encoding to UTF-8 utf8_force = false # false/true # # Indenting # # The number of columns to indent per level. # Usually 2, 3, 4, or 8. indent_columns = 3 # number # The continuation indent. If non-zero, this overrides the indent of '(' and '=' continuation indents. # For FreeBSD, this is set to 4. Negative value is absolute and not increased for each ( level indent_continue = 0 # number # How to use tabs when indenting code # 0=spaces only # 1=indent with tabs to brace level, align with spaces # 2=indent and align with tabs, using spaces when not on a tabstop indent_with_tabs = 0 # number # Comments that are not a brace level are indented with tabs on a tabstop. # Requires indent_with_tabs=2. If false, will use spaces. indent_cmt_with_tabs = false # false/true # Whether to indent strings broken by '\' so that they line up indent_align_string = true # false/true # The number of spaces to indent multi-line XML strings. # Requires indent_align_string=True indent_xml_string = 0 # number # Spaces to indent '{' from level indent_brace = 0 # number # Whether braces are indented to the body level indent_braces = false # false/true # Disabled indenting function braces if indent_braces is true indent_braces_no_func = false # false/true # Disabled indenting class braces if indent_braces is true indent_braces_no_class = false # false/true # Disabled indenting struct braces if indent_braces is true indent_braces_no_struct = false # false/true # Indent based on the size of the brace parent, i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc. indent_brace_parent = false # false/true # Indent based on the paren open instead of the brace open in '({\n', default is to indent by brace. indent_paren_open_brace = false # false/true # Whether the 'namespace' body is indented indent_namespace = false # false/true # Only indent one namespace and no sub-namespaces. # Requires indent_namespace=true. indent_namespace_single_indent = false # false/true # The number of spaces to indent a namespace block indent_namespace_level = 0 # number # If the body of the namespace is longer than this number, it won't be indented. # Requires indent_namespace=true. Default=0 (no limit) indent_namespace_limit = 0 # number # Whether the 'extern "C"' body is indented indent_extern = false # false/true # Whether the 'class' body is indented indent_class = true # false/true # Whether to indent the stuff after a leading base class colon indent_class_colon = true # false/true # Indent based on a class colon instead of the stuff after the colon. # Requires indent_class_colon=true. Default=false indent_class_on_colon = false # false/true # Whether to indent the stuff after a leading class initializer colon indent_constr_colon = false # false/true # Virtual indent from the ':' for member initializers. Default is 2 indent_ctor_init_leading = 2 # number # Additional indenting for constructor initializer list indent_ctor_init = 0 # number # False=treat 'else\nif' as 'else if' for indenting purposes # True=indent the 'if' one level indent_else_if = false # false/true # Amount to indent variable declarations after a open brace. neg=relative, pos=absolute indent_var_def_blk = 0 # number # Indent continued variable declarations instead of aligning. indent_var_def_cont = false # false/true # How to indent continued shift expressions ('<<' and '>>'). # Set align_left_shift=false when using this. # 0: Align shift operators instead of indenting them (default) # 1: Indent by one level # -1: Preserve original indentation indent_shift = 0 # number # True: force indentation of function definition to start in column 1 # False: use the default behavior indent_func_def_force_col1 = false # false/true # True: indent continued function call parameters one indent level # False: align parameters under the open paren indent_func_call_param = false # false/true # Same as indent_func_call_param, but for function defs indent_func_def_param = false # false/true # Same as indent_func_call_param, but for function protos indent_func_proto_param = false # false/true # Same as indent_func_call_param, but for class declarations indent_func_class_param = false # false/true # Same as indent_func_call_param, but for class variable constructors indent_func_ctor_var_param = false # false/true # Same as indent_func_call_param, but for templates indent_template_param = false # false/true # Double the indent for indent_func_xxx_param options indent_func_param_double = false # false/true # Indentation column for standalone 'const' function decl/proto qualifier indent_func_const = 0 # number # Indentation column for standalone 'throw' function decl/proto qualifier indent_func_throw = 0 # number # The number of spaces to indent a continued '->' or '.' # Usually set to 0, 1, or indent_columns. indent_member = 3 # number # Spaces to indent single line ('//') comments on lines before code indent_single_line_comments_before = 0 # number # If set, will indent trailing single line ('//') comments relative # to the code instead of trying to keep the same absolute column indent_relative_single_line_comments = false # false/true # Spaces to indent 'case' from 'switch' # Usually 0 or indent_columns. indent_switch_case = 0 # number # Spaces to shift the 'case' line, without affecting any other lines # Usually 0. indent_case_shift = 0 # number # Spaces to indent '{' from 'case'. # By default, the brace will appear under the 'c' in case. # Usually set to 0 or indent_columns. indent_case_brace = 3 # number # Whether to indent comments found in first column indent_col1_comment = false # false/true # How to indent goto labels # >0 : absolute column where 1 is the leftmost column # <=0 : subtract from brace indent indent_label = 1 # number # Same as indent_label, but for access specifiers that are followed by a colon indent_access_spec = 1 # number # Indent the code after an access specifier by one level. # If set, this option forces 'indent_access_spec=0' indent_access_spec_body = false # false/true # If an open paren is followed by a newline, indent the next line so that it lines up after the open paren (not recommended) indent_paren_nl = false # false/true # Controls the indent of a close paren after a newline. # 0: Indent to body level # 1: Align under the open paren # 2: Indent to the brace level # -1: Preserve original indentation indent_paren_close = 0 # number # Controls the indent of a comma when inside a paren.If 1, aligns under the open paren indent_comma_paren = 0 # number # Controls the indent of a BOOL operator when inside a paren.If 1, aligns under the open paren indent_bool_paren = 0 # number # If 'indent_bool_paren' is 1, controls the indent of the first expression. If TRUE, aligns the first expression to the following ones indent_first_bool_expr = false # false/true # If an open square is followed by a newline, indent the next line so that it lines up after the open square (not recommended) indent_square_nl = false # false/true # Don't change the relative indent of ESQL/C 'EXEC SQL' bodies indent_preserve_sql = false # false/true # Align continued statements at the '='. Default=True # If FALSE or the '=' is followed by a newline, the next line is indent one tab. indent_align_assign = true # false/true # Indent OC blocks at brace level instead of usual rules. indent_oc_block = false # false/true # Indent OC blocks in a message relative to the parameter name. # 0=use indent_oc_block rules, 1+=spaces to indent indent_oc_block_msg = 0 # number # Minimum indent for subsequent parameters indent_oc_msg_colon = 0 # number # If true, prioritize aligning with initial colon (and stripping spaces from lines, if necessary). # Default is true. indent_oc_msg_prioritize_first_colon = true # false/true # If indent_oc_block_msg and this option are on, blocks will be indented the way that Xcode does by default (from keyword if the parameter is on its own line; otherwise, from the previous indentation level). indent_oc_block_msg_xcode_style = false # false/true # If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is relative to a msg keyword. indent_oc_block_msg_from_keyword = false # false/true # If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is relative to a msg colon. indent_oc_block_msg_from_colon = false # false/true # If indent_oc_block_msg and this option are on, blocks will be indented from where the block caret is. indent_oc_block_msg_from_caret = false # false/true # If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is. indent_oc_block_msg_from_brace = false # false/true # When identing after virtual brace open and newline add further spaces to reach this min. indent. indent_min_vbrace_open = 0 # number # TRUE: When identing after virtual brace open and newline add further spaces after regular indent to reach next tabstop. indent_vbrace_open_on_tabstop = false # false/true # # Spacing options # # Add or remove space around arithmetic operator '+', '-', '/', '*', etc # also '>>>' '<<' '>>' '%' '|' sp_arith = force # ignore/add/remove/force # Add or remove space around assignment operator '=', '+=', etc sp_assign = force # ignore/add/remove/force # Add or remove space around preprocessor '##' concatenation operator. Default=Add sp_pp_concat = add # ignore/add/remove/force # Add or remove space after preprocessor '#' stringify operator. Also affects the '#@' charizing operator. sp_pp_stringify = add # ignore/add/remove/force # Add or remove space around boolean operators '&&' and '||' sp_bool = force # ignore/add/remove/force # Add or remove space around compare operator '<', '>', '==', etc sp_compare = force # ignore/add/remove/force # Add or remove space inside '(' and ')' sp_inside_paren = remove # ignore/add/remove/force # Add or remove space between nested parens: '((' vs ') )' sp_paren_paren = remove # ignore/add/remove/force # Whether to balance spaces inside nested parens sp_balance_nested_parens = false # false/true # Add or remove space before pointer star '*' sp_before_ptr_star = force # ignore/add/remove/force # Add or remove space between pointer stars '*' sp_between_ptr_star = remove # ignore/add/remove/force # Add or remove space after pointer star '*', if followed by a word. sp_after_ptr_star = remove # ignore/add/remove/force # Add or remove space before a reference sign '&' sp_before_byref = remove # ignore/add/remove/force # Add or remove space after reference sign '&', if followed by a word. sp_after_byref = force # ignore/add/remove/force # Add or remove space between type and word. Default=Force sp_after_type = force # ignore/add/remove/force # Add or remove space before '<>' sp_before_angle = remove # ignore/add/remove/force # Add or remove space inside '<' and '>' sp_inside_angle = remove # ignore/add/remove/force # Add or remove space after '<>' sp_after_angle = force # ignore/add/remove/force # Add or remove space between '>' and '>' in '>>' (template stuff C++/C# only). Default=Add sp_angle_shift = add # ignore/add/remove/force # Permit removal of the space between '>>' in 'foo >' (C++11 only). Default=False # sp_angle_shift cannot remove the space without this option. sp_permit_cpp11_shift = false # false/true # Add or remove space before '(' of 'if', 'for', 'switch', 'while', etc. sp_before_sparen = force # ignore/add/remove/force # Add or remove space inside if-condition '(' and ')' sp_inside_sparen = remove # ignore/add/remove/force # Add or remove space inside for-loop '(' and ')' sp_inside_for = remove # ignore/add/remove/force # Add or remove space after ')' of 'if', 'for', 'switch', and 'while', etc. sp_after_sparen = force # ignore/add/remove/force # Add or remove space between ')' and '{' of 'if', 'for', 'switch', and 'while', etc. sp_sparen_brace = add # ignore/add/remove/force # Add or remove space before ';'. Default=Remove sp_before_semi = remove # ignore/add/remove/force # Add or remove space before a semicolon of an empty left part of a for statement. sp_before_semi_for_empty = force # ignore/add/remove/force # Add or remove space between the semicolons of an empty middle part of a for statement. sp_between_semi_for_empty = force # ignore/add/remove/force # Add or remove space after ';', except when followed by a comment. Default=Add sp_after_semi = add # ignore/add/remove/force # Add or remove space after ';' in non-empty 'for' statements. Default=Force sp_after_semi_for = force # ignore/add/remove/force # Add or remove space inside a non-empty '[' and ']' sp_inside_square = remove # ignore/add/remove/force # Add or remove space after ',' sp_after_comma = force # ignore/add/remove/force # Add or remove space before ',' sp_before_comma = remove # ignore/add/remove/force # Add or remove space between an open paren and comma: '(,' vs '( ,' sp_paren_comma = force # ignore/add/remove/force # Add or remove space before case ':'. Default=Remove sp_before_case_colon = remove # ignore/add/remove/force # Add or remove space after C/D cast, i.e. 'cast(int)a' vs 'cast(int) a' or '(int)a' vs '(int) a' sp_after_cast = remove # ignore/add/remove/force # Add or remove space between 'sizeof' and '(' sp_sizeof_paren = remove # ignore/add/remove/force # Add or remove space inside enum '{' and '}' sp_inside_braces_enum = force # ignore/add/remove/force # Add or remove space inside struct/union '{' and '}' sp_inside_braces_struct = force # ignore/add/remove/force # Add or remove space inside '{' and '}' sp_inside_braces = force # ignore/add/remove/force # Add or remove space between return type and function name # A minimum of 1 is forced except for pointer return types. sp_type_func = force # ignore/add/remove/force # Add or remove space between function name and '(' on function declaration sp_func_proto_paren = remove # ignore/add/remove/force # Add or remove space between function name and '(' on function definition sp_func_def_paren = remove # ignore/add/remove/force # Add or remove space inside function '(' and ')' sp_inside_fparen = remove # ignore/add/remove/force # Add or remove space between ')' and '{' of function sp_fparen_brace = add # ignore/add/remove/force # Add or remove space between function name and '(' on function calls sp_func_call_paren = remove # ignore/add/remove/force # Add or remove space between a constructor/destructor and the open paren sp_func_class_paren = remove # ignore/add/remove/force # Add or remove space between 'return' and '(' sp_return_paren = remove # ignore/add/remove/force # Add or remove space between '}' and the name of a typedef on the same line sp_brace_typedef = force # ignore/add/remove/force # Add or remove space between type and open brace of an unnamed temporary # direct-list-initialization. sp_type_brace_init_lst = add # ignore/add/remove/force # Add or remove space between a variable and '{' for a namespace sp_word_brace_ns = add # ignore/add/remove/force # Add or remove space before the '::' operator sp_before_dc = remove # ignore/add/remove/force # Add or remove space after the '::' operator sp_after_dc = remove # ignore/add/remove/force # Add or remove space after the '!' (not) operator. Default=Remove sp_not = remove # ignore/add/remove/force # Add or remove space after the '~' (invert) operator. Default=Remove sp_inv = remove # ignore/add/remove/force # Add or remove space after the '&' (address-of) operator. Default=Remove # This does not affect the spacing after a '&' that is part of a type. sp_addr = remove # ignore/add/remove/force # Add or remove space around the '.' or '->' operators. Default=Remove sp_member = remove # ignore/add/remove/force # Add or remove space after the '*' (dereference) operator. Default=Remove # This does not affect the spacing after a '*' that is part of a type. sp_deref = remove # ignore/add/remove/force # Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. Default=Remove sp_sign = remove # ignore/add/remove/force # Add or remove space before or after '++' and '--', as in '(--x)' or 'y++;'. Default=Remove sp_incdec = remove # ignore/add/remove/force # Add or remove space before a backslash-newline at the end of a line. Default=Add sp_before_nl_cont = add # ignore/add/remove/force # Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make sense here. sp_case_label = remove # ignore/add/remove/force # TRUE: If space is added with sp_cmt_cpp_start, do it after doxygen sequences like '///', '///<', '//!' and '//!<'. sp_cmt_cpp_doxygen = false # false/true # TRUE: If space is added with sp_cmt_cpp_start, do it after Qt translator or meta-data comments like '//:', '//=', and '//~'. sp_cmt_cpp_qttr = false # false/true # Number of spaces before a trailing comment sp_num_before_tr_cmt = 0 # number # # Code alignment (not left column spaces/tabs) # # Whether to keep non-indenting tabs align_keep_tabs = false # false/true # Whether to use tabs for aligning align_with_tabs = false # false/true # Whether to bump out to the next tab when aligning align_on_tabstop = false # false/true # Whether to right-align numbers align_number_right = true # false/true # Whether to keep whitespace not required for alignment. align_keep_extra_space = false # false/true # Align variable definitions in prototypes and functions align_func_params = true # false/true # Align parameters in single-line functions that have the same name. # The function names must already be aligned with each other. align_same_func_call_params = false # false/true # The span for aligning parameters in single line functions with the same name (0=don't align). align_same_func_call_params_span = 0 # unsigned number # The thresh for aligning function call parameters (0=no limit). align_same_func_call_params_thresh = 0 # unsigned number # The span for aligning variable definitions (0=don't align) align_var_def_span = 1 # number # How to align the star in variable definitions. # 0=Part of the type 'void * foo;' # 1=Part of the variable 'void *foo;' # 2=Dangling 'void *foo;' align_var_def_star_style = 1 # number # How to align the '&' in variable definitions. # 0=Part of the type # 1=Part of the variable # 2=Dangling align_var_def_amp_style = 0 # number # The threshold for aligning variable definitions (0=no limit) align_var_def_thresh = 16 # number # The gap for aligning variable definitions align_var_def_gap = 0 # number # Whether to align the colon in struct bit fields align_var_def_colon = true # false/true # Whether to align any attribute after the variable name align_var_def_attribute = false # false/true # Whether to align inline struct/enum/union variable definitions align_var_def_inline = true # false/true # The span for aligning on '=' in assignments (0=don't align) align_assign_span = 1 # number # The threshold for aligning on '=' in assignments (0=no limit) align_assign_thresh = 12 # number # The span for aligning on '=' in enums (0=don't align) align_enum_equ_span = 16 # number # The threshold for aligning on '=' in enums (0=no limit) align_enum_equ_thresh = 0 # number # The span for aligning struct/union (0=don't align) align_var_struct_span = 99 # number # The threshold for aligning struct/union member definitions (0=no limit) align_var_struct_thresh = 0 # number # The gap for aligning struct/union member definitions align_var_struct_gap = 0 # number # The span for aligning struct initializer values (0=don't align) align_struct_init_span = 3 # number # The minimum space between the type and the synonym of a typedef align_typedef_gap = 3 # number # The span for aligning single-line typedefs (0=don't align) align_typedef_span = 5 # number # How to align typedef'd functions with other typedefs # 0: Don't mix them at all # 1: align the open paren with the types # 2: align the function type name with the other type names align_typedef_func = 0 # number # Controls the positioning of the '*' in typedefs. Just try it. # 0: Align on typedef type, ignore '*' # 1: The '*' is part of type name: typedef int *pint; # 2: The '*' is part of the type, but dangling: typedef int *pint; align_typedef_star_style = 0 # number # Controls the positioning of the '&' in typedefs. Just try it. # 0: Align on typedef type, ignore '&' # 1: The '&' is part of type name: typedef int &pint; # 2: The '&' is part of the type, but dangling: typedef int &pint; align_typedef_amp_style = 0 # number # The span for aligning comments that end lines (0=don't align) align_right_cmt_span = 3 # number # If aligning comments, mix with comments after '}' and #endif with less than 3 spaces before the comment align_right_cmt_mix = false # false/true # If a trailing comment is more than this number of columns away from the text it follows, # it will qualify for being aligned. This has to be > 0 to do anything. align_right_cmt_gap = 0 # number # Align trailing comment at or beyond column N; 'pulls in' comments as a bonus side effect (0=ignore) align_right_cmt_at_col = 0 # number # The span for aligning function prototypes (0=don't align) align_func_proto_span = 0 # number # Minimum gap between the return type and the function name. align_func_proto_gap = 0 # number # Align function protos on the 'operator' keyword instead of what follows align_on_operator = false # false/true # Whether to mix aligning prototype and variable declarations. # If true, align_var_def_XXX options are used instead of align_func_proto_XXX options. align_mix_var_proto = false # false/true # Align single-line functions with function prototypes, uses align_func_proto_span align_single_line_func = false # false/true # Aligning the open brace of single-line functions. # Requires align_single_line_func=true, uses align_func_proto_span align_single_line_brace = false # false/true # Gap for align_single_line_brace. align_single_line_brace_gap = 0 # number # The span for aligning ObjC msg spec (0=don't align) align_oc_msg_spec_span = 0 # number # Whether to align macros wrapped with a backslash and a newline. # This will not work right if the macro contains a multi-line comment. align_nl_cont = true # false/true # # Align macro functions and variables together align_pp_define_together = false # false/true # The minimum space between label and value of a preprocessor define align_pp_define_gap = 4 # number # The span for aligning on '#define' bodies (0=don't align, other=number of lines including comments between blocks) align_pp_define_span = 3 # number # Align lines that start with '<<' with previous '<<'. Default=true align_left_shift = true # false/true # Align text after asm volatile () colons. align_asm_colon = true # false/true # Span for aligning parameters in an Obj-C message call on the ':' (0=don't align) align_oc_msg_colon_span = 0 # number # If true, always align with the first parameter, even if it is too short. align_oc_msg_colon_first = false # false/true # Aligning parameters in an Obj-C '+' or '-' declaration on the ':' align_oc_decl_colon = false # false/true # # Newline adding and removing options # # Whether to collapse empty blocks between '{' and '}' nl_collapse_empty_body = false # false/true # Don't split one-line braced assignments - 'foo_t f = { 1, 2 };' nl_assign_leave_one_liners = true # false/true # Don't split one-line braced statements inside a class xx { } body nl_class_leave_one_liners = true # false/true # Don't split one-line enums: 'enum foo { BAR = 15 };' nl_enum_leave_one_liners = false # false/true # Don't split one-line get or set functions nl_getset_leave_one_liners = false # false/true # Don't split one-line function definitions - 'int foo() { return 0; }' nl_func_leave_one_liners = false # false/true # Don't split one-line C++11 lambdas - '[]() { return 0; }' nl_cpp_lambda_leave_one_liners = false # false/true # Don't split one-line if/else statements - 'if(a) b++;' nl_if_leave_one_liners = false # false/true # Don't split one-line while statements - 'while(a) b++;' nl_while_leave_one_liners = false # false/true # Don't split one-line OC messages nl_oc_msg_leave_one_liner = false # false/true # Add or remove newlines at the start of the file nl_start_of_file = remove # ignore/add/remove/force # The number of newlines at the start of the file (only used if nl_start_of_file is 'add' or 'force' nl_start_of_file_min = 0 # number # Add or remove newline at the end of the file nl_end_of_file = force # ignore/add/remove/force # The number of newlines at the end of the file (only used if nl_end_of_file is 'add' or 'force') nl_end_of_file_min = 1 # number # Add or remove newline between '=' and '{' nl_assign_brace = add # ignore/add/remove/force # The number of blank lines after a block of variable definitions at the top of a function body # 0 = No change (default) nl_var_def_blk_end_func_top = 1 # number # The number of newlines before a block of typedefs # 0 = No change (default) nl_typedef_blk_start = 0 # number # The number of newlines after a block of typedefs # 0 = No change (default) nl_typedef_blk_end = 0 # number # The maximum consecutive newlines within a block of typedefs # 0 = No change (default) nl_typedef_blk_in = 0 # number # The number of newlines before a block of variable definitions not at the top of a function body # 0 = No change (default) nl_var_def_blk_start = 0 # number # The number of newlines after a block of variable definitions not at the top of a function body # 0 = No change (default) nl_var_def_blk_end = 0 # number # The maximum consecutive newlines within a block of variable definitions # 0 = No change (default) nl_var_def_blk_in = 0 # number # Add or remove newline between a function call's ')' and '{', as in: # list_for_each(item, &list) { } nl_fcall_brace = add # ignore/add/remove/force # Add or remove newline between 'enum' and '{' nl_enum_brace = force # ignore/add/remove/force # Add or remove newline between 'struct and '{' nl_struct_brace = force # ignore/add/remove/force # Add or remove newline between 'union' and '{' nl_union_brace = force # ignore/add/remove/force # Add or remove newline between 'if' and '{' nl_if_brace = add # ignore/add/remove/force # Add or remove newline between '}' and 'else' nl_brace_else = add # ignore/add/remove/force # Add or remove newline between 'else' and '{' nl_else_brace = add # ignore/add/remove/force # Add or remove newline between get/set and '{' nl_getset_brace = force # ignore/add/remove/force # Add or remove newline between 'for' and '{' nl_for_brace = add # ignore/add/remove/force # Add or remove newline between 'while' and '{' nl_while_brace = add # ignore/add/remove/force # Add or remove newline between 'do' and '{' nl_do_brace = add # ignore/add/remove/force # Add or remove newline between '}' and 'while' of 'do' statement nl_brace_while = remove # ignore/add/remove/force # Add or remove newline between 'switch' and '{' nl_switch_brace = add # ignore/add/remove/force # Add a newline between ')' and '{' if the ')' is on a different line than the if/for/etc. # Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch, and nl_catch_brace. nl_multi_line_cond = false # false/true # Force a newline in a define after the macro name for multi-line defines. nl_multi_line_define = true # false/true # Whether to put a newline before 'case' statement nl_before_case = true # false/true # Whether to put a newline after 'case' statement nl_after_case = true # false/true # Add or remove newline between a function name and the opening '(' nl_func_paren = remove # ignore/add/remove/force # Whether to put each OC message parameter on a separate line # See nl_oc_msg_leave_one_liner nl_oc_msg_args = false # false/true # Add or remove newline between function signature and '{' nl_fdef_brace = add # ignore/add/remove/force # Whether to put a newline after semicolons, except in 'for' statements nl_after_semicolon = true # false/true # Whether to put a newline after brace open. nl_after_brace_open = true # false/true # If nl_after_brace_open and nl_after_brace_open_cmt are true, a newline is # placed between the open brace and a trailing single-line comment. nl_after_brace_open_cmt = false # false/true # Whether to put a newline after a virtual brace open with a non-empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open = false # false/true # Whether to put a newline after a virtual brace open with an empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open_empty = false # false/true # Whether to put a newline after a brace close. # Does not apply if followed by a necessary ';'. nl_after_brace_close = true # false/true # Whether to put a newline after a virtual brace close. # Would add a newline before return in: 'if (foo) a++; return;' nl_after_vbrace_close = false # false/true # Whether to alter newlines in '#define' macros nl_define_macro = false # false/true # Whether to not put blanks after '#ifxx', '#elxx', or before '#endif'. Does not affect the whole-file #ifdef. nl_squeeze_ifdef = true # false/true # Whether to double-space commented-entries in struct/enum nl_ds_struct_enum_cmt = false # false/true # Whether to double-space before the close brace of a struct/union/enum # (lower priority than 'eat_blanks_before_close_brace') nl_ds_struct_enum_close_brace = false # false/true # Change simple unbraced if statements into a one-liner # 'if(b)\n i++;' => 'if(b) i++;' nl_create_if_one_liner = false # false/true # Change simple unbraced for statements into a one-liner # 'for (i=0;i<5;i++)\n foo(i);' => 'for (i=0;i<5;i++) foo(i);' nl_create_for_one_liner = false # false/true # Change simple unbraced while statements into a one-liner # 'while (i<5)\n foo(i++);' => 'while (i<5) foo(i++);' nl_create_while_one_liner = false # false/true # # Positioning options # # The position of boolean operators in wrapped expressions pos_bool = trail # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # # Line Splitting options # # Try to limit code width to N number of columns code_width = 0 # number # Whether to fully split long 'for' statements at semi-colons ls_for_split_full = false # false/true # Whether to fully split long function protos/calls at commas ls_func_split_full = false # false/true # Whether to split lines as close to code_width as possible and ignore some groupings ls_code_width = false # false/true # # Blank line options # # The maximum consecutive newlines nl_max = 4 # number # The number of newlines after a function prototype, if followed by another function prototype nl_after_func_proto = 0 # number # The number of newlines after a function prototype, if not followed by another function prototype nl_after_func_proto_group = 2 # number # The number of newlines after '}' of a multi-line function body nl_after_func_body = 3 # number # The number of newlines after '}' of a multi-line function body in a class declaration nl_after_func_body_class = 2 # number # The number of newlines after '}' of a single line function body nl_after_func_body_one_liner = 0 # number # The minimum number of newlines before a multi-line comment. # Doesn't apply if after a brace open or another multi-line comment. nl_before_block_comment = 2 # number # The minimum number of newlines before a single-line C comment. # Doesn't apply if after a brace open or other single-line C comments. nl_before_c_comment = 0 # number # The minimum number of newlines before a CPP comment. # Doesn't apply if after a brace open or other CPP comments. nl_before_cpp_comment = 0 # number # Whether to force a newline after a multi-line comment. nl_after_multiline_comment = false # false/true # Whether to force a newline after a label's colon. nl_after_label_colon = false # false/true # The number of newlines after '}' or ';' of a struct/enum/union definition nl_after_struct = 0 # number # The number of newlines after '}' or ';' of a class definition nl_after_class = 0 # number # The number of newlines after '}' of a namespace nl_after_namespace = 0 # number # The number of newlines before a 'private:', 'public:', 'protected:', 'signals:', or 'slots:' label. # Will not change the newline count if after a brace open. # 0 = No change. nl_before_access_spec = 0 # number # The number of newlines after a 'private:', 'public:', 'protected:', 'signals:', or 'slots:' label. # 0 = No change. nl_after_access_spec = 0 # number # The number of newlines between a function def and the function comment. # 0 = No change. nl_comment_func_def = 1 # number # The number of newlines after a try-catch-finally block that isn't followed by a brace close. # 0 = No change. nl_after_try_catch_finally = 0 # number # The number of newlines before and after a property, indexer or event decl. # 0 = No change. nl_around_cs_property = 0 # number # The number of newlines between the get/set/add/remove handlers in C#. # 0 = No change. nl_between_get_set = 0 # number # Whether to remove blank lines after '{' eat_blanks_after_open_brace = true # false/true # Whether to remove blank lines before '}' eat_blanks_before_close_brace = true # false/true # How aggressively to remove extra newlines not in preproc. # 0: No change # 1: Remove most newlines not handled by other config # 2: Remove all newlines and reformat completely by config nl_remove_extra_newlines = 0 # number # Whether to put a blank line before 'return' statements, unless after an open brace. nl_before_return = false # false/true # Whether to put a blank line after 'return' statements, unless followed by a close brace. nl_after_return = true # false/true # # Code modifying options (non-whitespace) # # Add or remove braces on single-line 'do' statement mod_full_brace_do = add # ignore/add/remove/force # Add or remove braces on single-line 'for' statement mod_full_brace_for = add # ignore/add/remove/force # Add or remove braces on single-line 'if' statement. Will not remove the braces if they contain an 'else'. mod_full_brace_if = add # ignore/add/remove/force # Make all if/elseif/else statements in a chain be braced or not. Overrides mod_full_brace_if. # If any must be braced, they are all braced. If all can be unbraced, then the braces are removed. mod_full_brace_if_chain = 0 # unsigned number # Don't remove braces around statements that span N newlines mod_full_brace_nl = 0 # number # Add or remove braces on single-line 'while' statement mod_full_brace_while = add # ignore/add/remove/force # Whether to change optional semicolons to real semicolons mod_pawn_semicolon = false # false/true # Add parens on 'while' and 'if' statement around bools mod_full_paren_if_bool = true # false/true # Whether to remove superfluous semicolons mod_remove_extra_semicolon = true # false/true # If a function body exceeds the specified number of newlines and doesn't have a comment after # the close brace, a comment will be added. mod_add_long_function_closebrace_comment = 0 # number # If a namespace body exceeds the specified number of newlines and doesn't have a comment after # the close brace, a comment will be added. mod_add_long_namespace_closebrace_comment = 0 # number # If a switch body exceeds the specified number of newlines and doesn't have a comment after # the close brace, a comment will be added. mod_add_long_switch_closebrace_comment = 0 # number # If an #ifdef body exceeds the specified number of newlines and doesn't have a comment after # the #endif, a comment will be added. mod_add_long_ifdef_endif_comment = 0 # number # If an #ifdef or #else body exceeds the specified number of newlines and doesn't have a comment after # the #else, a comment will be added. mod_add_long_ifdef_else_comment = 0 # number # If TRUE, will sort consecutive single-line 'import' statements [Java, D] mod_sort_import = false # false/true # If TRUE, will sort consecutive single-line 'using' statements [C#] mod_sort_using = false # false/true # If TRUE, will sort consecutive single-line '#include' statements [C/C++] and '#import' statements [Obj-C] # This is generally a bad idea, as it may break your code. mod_sort_include = false # false/true # If TRUE, it will move a 'break' that appears after a fully braced 'case' before the close brace. mod_move_case_break = false # false/true # Will add or remove the braces around a fully braced case statement. # Will only remove the braces if there are no variable declarations in the block. mod_case_brace = remove # ignore/add/remove/force # If TRUE, it will remove a void 'return;' that appears as the last statement in a function. mod_remove_empty_return = true # false/true # # Comment modifications # # Try to wrap comments at cmt_width columns cmt_width = 0 # number # Set the comment reflow mode (default: 0) # 0: no reflowing (apart from the line wrapping due to cmt_width) # 1: no touching at all # 2: full reflow cmt_reflow_mode = 0 # number # Whether to convert all tabs to spaces in comments. Default is to leave tabs inside comments alone, unless used for indenting. cmt_convert_tab_to_spaces = false # false/true # If false, disable all multi-line comment changes, including cmt_width. keyword substitution, and leading chars. # Default is true. cmt_indent_multi = true # false/true # Whether to group c-comments that look like they are in a block cmt_c_group = false # false/true # Whether to put an empty '/*' on the first line of the combined c-comment cmt_c_nl_start = false # false/true # Whether to put a newline before the closing '*/' of the combined c-comment cmt_c_nl_end = false # false/true # Whether to group cpp-comments that look like they are in a block cmt_cpp_group = false # false/true # Whether to put an empty '/*' on the first line of the combined cpp-comment cmt_cpp_nl_start = false # false/true # Whether to put a newline before the closing '*/' of the combined cpp-comment cmt_cpp_nl_end = false # false/true # Whether to change cpp-comments into c-comments cmt_cpp_to_c = false # false/true # Whether to put a star on subsequent comment lines cmt_star_cont = true # false/true # The number of spaces to insert at the start of subsequent comment lines cmt_sp_before_star_cont = 0 # number # The number of spaces to insert after the star on subsequent comment lines cmt_sp_after_star_cont = 0 # number # For multi-line comments with a '*' lead, remove leading spaces if the first and last lines of # the comment are the same length. Default=True cmt_multi_check_last = true # false/true # The filename that contains text to insert at the head of a file if the file doesn't start with a C/C++ comment. # Will substitute $(filename) with the current file's name. cmt_insert_file_header = "" # string # The filename that contains text to insert at the end of a file if the file doesn't end with a C/C++ comment. # Will substitute $(filename) with the current file's name. cmt_insert_file_footer = "" # string # The filename that contains text to insert before a function implementation if the function isn't preceded with a C/C++ comment. # Will substitute $(function) with the function name and $(javaparam) with the javadoc @param and @return stuff. # Will also substitute $(fclass) with the class name: void CFoo::Bar() { ... } cmt_insert_func_header = "" # string # The filename that contains text to insert before a class if the class isn't preceded with a C/C++ comment. # Will substitute $(class) with the class name. cmt_insert_class_header = "" # string # The filename that contains text to insert before a Obj-C message specification if the method isn't preceded with a C/C++ comment. # Will substitute $(message) with the function name and $(javaparam) with the javadoc @param and @return stuff. cmt_insert_oc_msg_header = "" # string # If a preprocessor is encountered when stepping backwards from a function name, then # this option decides whether the comment should be inserted. # Affects cmt_insert_oc_msg_header, cmt_insert_func_header and cmt_insert_class_header. cmt_insert_before_preproc = false # false/true # # Preprocessor options # # Control indent of preprocessors inside #if blocks at brace level 0 (file-level) pp_indent = remove # ignore/add/remove/force # Whether to indent #if/#else/#endif at the brace level (true) or from column 1 (false) pp_indent_at_level = false # false/true # Whether to indent #if/#else/#endif at the parenthesis level if the brace # level is 0. If false, these are indented from column 1. pp_indent_at_level0 = false # false/true # Specifies the number of columns to indent preprocessors per level at brace level 0 (file-level). # If pp_indent_at_level=false, specifies the number of columns to indent preprocessors per level at brace level > 0 (function-level). # Default=1. pp_indent_count = 1 # number # Sets the number of spaces added with pp_space_after pp_space_count = 0 # number # The indent for #region and #endregion in C# and '#pragma region' in C/C++ pp_indent_region = 0 # number # Whether to indent the code between #region and #endregion pp_region_indent_code = false # false/true # If pp_indent_at_level=true, sets the indent for #if, #else, and #endif when not at file-level. # 0: indent preprocessors using output_tab_size. # >0: column at which all preprocessors will be indented. pp_indent_if = 0 # number # Control whether to indent the code between #if, #else and #endif. pp_if_indent_code = false # false/true # Whether to indent '#define' at the brace level (true) or from column 1 (false) pp_define_at_level = false # false/true # # Use or Do not Use options # # True: indent_func_call_param will be used # False: indent_func_call_param will NOT be used use_indent_func_call_param = true # false/true # True: indent_continue will be used only once # False: indent_continue will be used every time (default) use_indent_continue_only_once = false # false/true # You can force a token to be a type with the 'type' option. # Example: # type myfoo1 myfoo2 # # You can create custom macro-based indentation using macro-open, # macro-else and macro-close. # Example: # macro-open BEGIN_TEMPLATE_MESSAGE_MAP # macro-open BEGIN_MESSAGE_MAP # macro-close END_MESSAGE_MAP # # You can assign any keyword to any type with the set option. # set func_call_user _ N_ # # The full syntax description of all custom definition config entries # is shown below: # # define custom tokens as: # - embed whitespace in token using '' escape character, or # put token in quotes # - these: ' " and ` are recognized as quote delimiters # # type token1 token2 token3 ... # ^ optionally specify multiple tokens on a single line # define def_token output_token # ^ output_token is optional, then NULL is assumed # macro-open token # macro-close token # macro-else token # set id token1 token2 ... # ^ optionally specify multiple tokens on a single line # ^ id is one of the names in token_enum.h sans the CT_ prefix, # e.g. PP_PRAGMA # # all tokens are separated by any mix of ',' commas, '=' equal signs # and whitespace (space, tab) # # You can add support for other file extensions using the 'file_ext' command. # The first arg is the language name used with the '-l' option. # The remaining args are file extensions, matched with 'endswith'. # file_ext CPP .ch .cxx .cpp.in # uncrustify-uncrustify-0.76.0/etc/ben2.cfg000066400000000000000000000055421434072136500203250ustar00rootroot00000000000000# # My favorite format # indent_with_tabs = 0 # 1=indent with tabs, 2=indent to level only input_tab_size = 8 # original tab size output_tab_size = 3 # new tab size indent_columns = output_tab_size indent_label = 2 # pos: absolute col, neg: relative column indent_align_string = False # align broken strings indent_brace = 0 nl_enum_brace = add # "enum {" vs "enum \n {" nl_union_brace = add # "union {" vs "union \n {" nl_struct_brace = add # "struct {" vs "struct \n {" nl_do_brace = add # "do {" vs "do \n {" nl_if_brace = add # "if () {" vs "if () \n {" nl_for_brace = add # "for () {" vs "for () \n {" nl_else_brace = add # "else {" vs "else \n {" nl_while_brace = add # "while () {" vs "while () \n {" nl_switch_brace = add # "switch () {" vs "switch () \n {" nl_var_def_blk_end_func_top = 1 nl_before_case = 1 nl_fcall_brace = add # "foo() {" vs "foo()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" nl_after_return = TRUE nl_brace_while = remove nl_brace_else = add nl_squeeze_ifdef = TRUE # mod_paren_on_return = add # "return 1;" vs "return (1);" # mod_full_brace_if = add # "if (a) a--;" vs "if (a) { a--; }" # mod_full_brace_for = add # "for () a--;" vs "for () { a--; }" # mod_full_brace_do = add # "do a--; while ();" vs "do { a--; } while ();" # mod_full_brace_while = add # "while (a) a--;" vs "while (a) { a--; }" sp_before_semi = remove sp_paren_paren = remove # space between (( and )) sp_return_paren = remove # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = force # "{ 1 }" vs "{1}" sp_inside_braces_struct = force # "{ 1 }" vs "{1}" sp_inside_braces_enum = force # "{ 1 }" vs "{1}" sp_inside_paren = remove sp_inside_fparen = remove sp_inside_sparen = remove sp_inside_for = remove #sp_type_func = ignore sp_assign = force sp_arith = force sp_bool = force sp_compare = force sp_assign = force sp_after_comma = force sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" align_with_tabs = FALSE # use tabs to align align_on_tabstop = FALSE # align on tabstops align_enum_equ_span = 4 align_nl_cont = TRUE align_var_def_span = 2 align_var_def_inline = TRUE align_var_def_star_style = 1 align_var_def_colon = TRUE align_assign_span = 1 align_struct_init_span = 3 align_var_struct_span = 3 align_right_cmt_span = 3 align_pp_define_span = 3 align_pp_define_gap = 4 align_number_right = TRUE align_typedef_span = 5 align_typedef_gap = 3 cmt_star_cont = TRUE eat_blanks_before_close_brace = TRUE eat_blanks_after_open_brace = TRUE uncrustify-uncrustify-0.76.0/etc/d.cfg000066400000000000000000000055501434072136500177210ustar00rootroot00000000000000# # My favorite format # indent_with_tabs = 0 # 1=indent to level only, 2=indent with tabs input_tab_size = 8 # original tab size output_tab_size = 4 # new tab size indent_columns = output_tab_size indent_label = 2 # pos: absolute col, neg: relative column indent_align_string = False # align broken strings indent_brace = 0 nl_enum_brace = add # "enum {" vs "enum \n {" nl_union_brace = add # "union {" vs "union \n {" nl_struct_brace = add # "struct {" vs "struct \n {" nl_do_brace = add # "do {" vs "do \n {" nl_if_brace = add # "if () {" vs "if () \n {" nl_for_brace = add # "for () {" vs "for () \n {" nl_else_brace = add # "else {" vs "else \n {" nl_while_brace = add # "while () {" vs "while () \n {" nl_switch_brace = add # "switch () {" vs "switch () \n {" # nl_var_def_blk_end_func_top = 1 # nl_before_case = 1 nl_fcall_brace = add # "foo() {" vs "foo()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" # nl_after_return = TRUE nl_brace_while = remove nl_brace_else = add nl_squeeze_ifdef = TRUE # mod_paren_on_return = add # "return 1;" vs "return (1);" # mod_full_brace_if = add # "if (a) a--;" vs "if (a) { a--; }" # mod_full_brace_for = add # "for () a--;" vs "for () { a--; }" # mod_full_brace_do = add # "do a--; while ();" vs "do { a--; } while ();" # mod_full_brace_while = add # "while (a) a--;" vs "while (a) { a--; }" sp_before_semi = remove sp_paren_paren = remove # space between (( and )) sp_return_paren = remove # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = add # "(int) a" vs "(int)a" sp_inside_braces = force # "{ 1 }" vs "{1}" sp_inside_braces_struct = force # "{ 1 }" vs "{1}" sp_inside_braces_enum = force # "{ 1 }" vs "{1}" sp_inside_paren = remove sp_inside_fparen = remove sp_inside_sparen = remove sp_inside_for = remove #sp_type_func = ignore sp_assign = force sp_arith = force sp_bool = force sp_compare = force sp_assign = force sp_after_comma = force sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" align_with_tabs = FALSE # use tabs to align align_on_tabstop = FALSE # align on tabstops align_enum_equ_span = 4 align_nl_cont = TRUE align_var_def_span = 2 align_var_def_inline = TRUE align_var_def_star_style = 1 align_var_def_colon = TRUE align_assign_span = 1 align_struct_init_span = 3 align_var_struct_span = 3 align_right_cmt_span = 3 align_pp_define_span = 3 align_pp_define_gap = 4 align_number_right = TRUE align_typedef_span = 5 align_typedef_gap = 3 # cmt_star_cont = TRUE eat_blanks_before_close_brace = TRUE eat_blanks_after_open_brace = TRUE uncrustify-uncrustify-0.76.0/etc/defaults.cfg000066400000000000000000004404511434072136500213100ustar00rootroot00000000000000# Uncrustify-0.76.0 # # General options # # The type of line endings. # # Default: auto newlines = auto # lf/crlf/cr/auto # The original size of tabs in the input. # # Default: 8 input_tab_size = 8 # unsigned number # The size of tabs in the output (only used if align_with_tabs=true). # # Default: 8 output_tab_size = 8 # unsigned number # The ASCII value of the string escape char, usually 92 (\) or (Pawn) 94 (^). # # Default: 92 string_escape_char = 92 # unsigned number # Alternate string escape char (usually only used for Pawn). # Only works right before the quote char. string_escape_char2 = 0 # unsigned number # Replace tab characters found in string literals with the escape sequence \t # instead. string_replace_tab_chars = false # true/false # Allow interpreting '>=' and '>>=' as part of a template in code like # 'void f(list>=val);'. If true, 'assert(x<0 && y>=3)' will be broken. # Improvements to template detection may make this option obsolete. tok_split_gte = false # true/false # Disable formatting of NL_CONT ('\\n') ended lines (e.g. multi-line macros). disable_processing_nl_cont = false # true/false # Specify the marker used in comments to disable processing of part of the # file. # # Default: *INDENT-OFF* disable_processing_cmt = " *INDENT-OFF*" # string # Specify the marker used in comments to (re)enable processing in a file. # # Default: *INDENT-ON* enable_processing_cmt = " *INDENT-ON*" # string # Enable parsing of digraphs. enable_digraphs = false # true/false # Option to allow both disable_processing_cmt and enable_processing_cmt # strings, if specified, to be interpreted as ECMAScript regular expressions. # If true, a regex search will be performed within comments according to the # specified patterns in order to disable/enable processing. processing_cmt_as_regex = false # true/false # Add or remove the UTF-8 BOM (recommend 'remove'). utf8_bom = ignore # ignore/add/remove/force/not_defined # If the file contains bytes with values between 128 and 255, but is not # UTF-8, then output as UTF-8. utf8_byte = false # true/false # Force the output encoding to UTF-8. utf8_force = false # true/false # # Spacing options # # Add or remove space around non-assignment symbolic operators ('+', '/', '%', # '<<', and so forth). sp_arith = ignore # ignore/add/remove/force/not_defined # Add or remove space around arithmetic operators '+' and '-'. # # Overrides sp_arith. sp_arith_additive = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment operator '=', '+=', etc. sp_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space around '=' in C++11 lambda capture specifications. # # Overrides sp_assign. sp_cpp_lambda_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after the capture specification of a C++11 lambda when # an argument list is present, as in '[] (int x){ ... }'. sp_cpp_lambda_square_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the capture specification of a C++11 lambda with # no argument list is present, as in '[] { ... }'. sp_cpp_lambda_square_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space after the opening parenthesis and before the closing # parenthesis of a argument list of a C++11 lambda, as in # '[]( int x ){ ... }'. sp_cpp_lambda_argument_list = ignore # ignore/add/remove/force/not_defined # Add or remove space after the argument list of a C++11 lambda, as in # '[](int x) { ... }'. sp_cpp_lambda_paren_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between a lambda body and its call operator of an # immediately invoked lambda, as in '[]( ... ){ ... } ( ... )'. sp_cpp_lambda_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment operator '=' in a prototype. # # If set to ignore, use sp_assign. sp_assign_default = ignore # ignore/add/remove/force/not_defined # Add or remove space before assignment operator '=', '+=', etc. # # Overrides sp_assign. sp_before_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after assignment operator '=', '+=', etc. # # Overrides sp_assign. sp_after_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space in 'enum {'. # # Default: add sp_enum_brace = add # ignore/add/remove/force/not_defined # Add or remove space in 'NS_ENUM ('. sp_enum_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment '=' in enum. sp_enum_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space before assignment '=' in enum. # # Overrides sp_enum_assign. sp_enum_before_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space after assignment '=' in enum. # # Overrides sp_enum_assign. sp_enum_after_assign = ignore # ignore/add/remove/force/not_defined # Add or remove space around assignment ':' in enum. sp_enum_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space around preprocessor '##' concatenation operator. # # Default: add sp_pp_concat = add # ignore/add/remove/force/not_defined # Add or remove space after preprocessor '#' stringify operator. # Also affects the '#@' charizing operator. sp_pp_stringify = ignore # ignore/add/remove/force/not_defined # Add or remove space before preprocessor '#' stringify operator # as in '#define x(y) L#y'. sp_before_pp_stringify = ignore # ignore/add/remove/force/not_defined # Add or remove space around boolean operators '&&' and '||'. sp_bool = ignore # ignore/add/remove/force/not_defined # Add or remove space around compare operator '<', '>', '==', etc. sp_compare = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')'. sp_inside_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested parentheses, i.e. '((' vs. ') )'. sp_paren_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('. sp_cparen_oparen = ignore # ignore/add/remove/force/not_defined # Whether to balance spaces inside nested parentheses. sp_balance_nested_parens = false # true/false # Add or remove space between ')' and '{'. sp_paren_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested braces, i.e. '{{' vs. '{ {'. sp_brace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space before pointer star '*'. sp_before_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space before pointer star '*' that isn't followed by a # variable name. If set to ignore, sp_before_ptr_star is used instead. sp_before_unnamed_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space between pointer stars '*', as in 'int ***a;'. sp_between_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer star '*', if followed by a word. # # Overrides sp_type_func. sp_after_ptr_star = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer caret '^', if followed by a word. sp_after_ptr_block_caret = ignore # ignore/add/remove/force/not_defined # Add or remove space after pointer star '*', if followed by a qualifier. sp_after_ptr_star_qualifier = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*', if followed by a function # prototype or function definition. # # Overrides sp_after_ptr_star and sp_type_func. sp_after_ptr_star_func = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*' in the trailing return of a # function prototype or function definition. sp_after_ptr_star_trailing = ignore # ignore/add/remove/force/not_defined # Add or remove space between the pointer star '*' and the name of the variable # in a function pointer definition. sp_ptr_star_func_var = ignore # ignore/add/remove/force/not_defined # Add or remove space between the pointer star '*' and the name of the type # in a function pointer type definition. sp_ptr_star_func_type = ignore # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*', if followed by an open # parenthesis, as in 'void* (*)()'. sp_ptr_star_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space before a pointer star '*', if followed by a function # prototype or function definition. sp_before_ptr_star_func = ignore # ignore/add/remove/force/not_defined # Add or remove space before a pointer star '*' in the trailing return of a # function prototype or function definition. sp_before_ptr_star_trailing = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&'. sp_before_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&' that isn't followed by a # variable name. If set to ignore, sp_before_byref is used instead. sp_before_unnamed_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space after reference sign '&', if followed by a word. # # Overrides sp_type_func. sp_after_byref = ignore # ignore/add/remove/force/not_defined # Add or remove space after a reference sign '&', if followed by a function # prototype or function definition. # # Overrides sp_after_byref and sp_type_func. sp_after_byref_func = ignore # ignore/add/remove/force/not_defined # Add or remove space before a reference sign '&', if followed by a function # prototype or function definition. sp_before_byref_func = ignore # ignore/add/remove/force/not_defined # Add or remove space after a reference sign '&', if followed by an open # parenthesis, as in 'char& (*)()'. sp_byref_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between type and word. In cases where total removal of # whitespace would be a syntax error, a value of 'remove' is treated the same # as 'force'. # # This also affects some other instances of space following a type that are # not covered by other options; for example, between the return type and # parenthesis of a function type template argument, between the type and # parenthesis of an array parameter, or between 'decltype(...)' and the # following word. # # Default: force sp_after_type = force # ignore/add/remove/force/not_defined # Add or remove space between 'decltype(...)' and word, # brace or function call. sp_after_decltype = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space before the parenthesis in the D constructs # 'template Foo(' and 'class Foo('. sp_before_template_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'template' and '<'. # If set to ignore, sp_before_angle is used. sp_template_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space before '<'. sp_before_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '<' and '>'. sp_inside_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '<>'. sp_inside_angle_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and ':'. sp_angle_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after '>'. sp_after_angle = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '(' as found in 'new List(foo);'. sp_angle_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '()' as found in 'new List();'. sp_angle_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and a word as in 'List m;' or # 'template static ...'. sp_angle_word = ignore # ignore/add/remove/force/not_defined # Add or remove space between '>' and '>' in '>>' (template stuff). # # Default: add sp_angle_shift = add # ignore/add/remove/force/not_defined # (C++11) Permit removal of the space between '>>' in 'foo >'. Note # that sp_angle_shift cannot remove the space without this option. sp_permit_cpp11_shift = false # true/false # Add or remove space before '(' of control statements ('if', 'for', 'switch', # 'while', etc.). sp_before_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')' of control statements other than # 'for'. sp_inside_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space after '(' of control statements other than 'for'. # # Overrides sp_inside_sparen. sp_inside_sparen_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before ')' of control statements other than 'for'. # # Overrides sp_inside_sparen. sp_inside_sparen_close = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '(' and ')' of 'for' statements. sp_inside_for = ignore # ignore/add/remove/force/not_defined # Add or remove space after '(' of 'for' statements. # # Overrides sp_inside_for. sp_inside_for_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before ')' of 'for' statements. # # Overrides sp_inside_for. sp_inside_for_close = ignore # ignore/add/remove/force/not_defined # Add or remove space between '((' or '))' of control statements. sp_sparen_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after ')' of control statements. sp_after_sparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of control statements. sp_sparen_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'do' and '{'. sp_do_brace_open = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'while'. sp_brace_close_while = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'while' and '('. Overrides sp_before_sparen. sp_while_paren_open = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'invariant' and '('. sp_invariant_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space after the ')' in 'invariant (C) c'. sp_after_invariant_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space before empty statement ';' on 'if', 'for' and 'while'. sp_special_semi = ignore # ignore/add/remove/force/not_defined # Add or remove space before ';'. # # Default: remove sp_before_semi = remove # ignore/add/remove/force/not_defined # Add or remove space before ';' in non-empty 'for' statements. sp_before_semi_for = ignore # ignore/add/remove/force/not_defined # Add or remove space before a semicolon of an empty left part of a for # statement, as in 'for ( ; ; )'. sp_before_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between the semicolons of an empty middle part of a for # statement, as in 'for ( ; ; )'. sp_between_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after ';', except when followed by a comment. # # Default: add sp_after_semi = add # ignore/add/remove/force/not_defined # Add or remove space after ';' in non-empty 'for' statements. # # Default: force sp_after_semi_for = force # ignore/add/remove/force/not_defined # Add or remove space after the final semicolon of an empty part of a for # statement, as in 'for ( ; ; )'. sp_after_semi_for_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[' (except '[]'). sp_before_square = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[' for a variable definition. # # Default: remove sp_before_vardef_square = remove # ignore/add/remove/force/not_defined # Add or remove space before '[' for asm block. sp_before_square_asm_block = ignore # ignore/add/remove/force/not_defined # Add or remove space before '[]'. sp_before_squares = ignore # ignore/add/remove/force/not_defined # Add or remove space before C++17 structured bindings. sp_cpp_before_struct_binding = ignore # ignore/add/remove/force/not_defined # Add or remove space inside a non-empty '[' and ']'. sp_inside_square = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '[]'. sp_inside_square_empty = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside a non-empty Objective-C boxed array '@[' and # ']'. If set to ignore, sp_inside_square is used. sp_inside_square_oc_array = ignore # ignore/add/remove/force/not_defined # Add or remove space after ',', i.e. 'a,b' vs. 'a, b'. sp_after_comma = ignore # ignore/add/remove/force/not_defined # Add or remove space before ',', i.e. 'a,b' vs. 'a ,b'. # # Default: remove sp_before_comma = remove # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between ',' and ']' in multidimensional array type # like 'int[,,]'. sp_after_mdatype_commas = ignore # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between '[' and ',' in multidimensional array type # like 'int[,,]'. sp_before_mdatype_commas = ignore # ignore/add/remove/force/not_defined # (C#, Vala) Add or remove space between ',' in multidimensional array type # like 'int[,,]'. sp_between_mdatype_commas = ignore # ignore/add/remove/force/not_defined # Add or remove space between an open parenthesis and comma, # i.e. '(,' vs. '( ,'. # # Default: force sp_paren_comma = force # ignore/add/remove/force/not_defined # Add or remove space between a type and ':'. sp_type_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after the variadic '...' when preceded by a # non-punctuator. # The value REMOVE will be overridden with FORCE sp_after_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space before the variadic '...' when preceded by a # non-punctuator. # The value REMOVE will be overridden with FORCE sp_before_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between a type and '...'. sp_type_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between a '*' and '...'. sp_ptr_type_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '...'. sp_paren_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between '&&' and '...'. sp_byref_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and a qualifier such as 'const'. sp_paren_qualifier = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and 'noexcept'. sp_paren_noexcept = ignore # ignore/add/remove/force/not_defined # Add or remove space after class ':'. sp_after_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before class ':'. sp_before_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after class constructor ':'. # # Default: add sp_after_constr_colon = add # ignore/add/remove/force/not_defined # Add or remove space before class constructor ':'. # # Default: add sp_before_constr_colon = add # ignore/add/remove/force/not_defined # Add or remove space before case ':'. # # Default: remove sp_before_case_colon = remove # ignore/add/remove/force/not_defined # Add or remove space between 'operator' and operator sign. sp_after_operator = ignore # ignore/add/remove/force/not_defined # Add or remove space between the operator symbol and the open parenthesis, as # in 'operator ++('. sp_after_operator_sym = ignore # ignore/add/remove/force/not_defined # Overrides sp_after_operator_sym when the operator has no arguments, as in # 'operator *()'. sp_after_operator_sym_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after C/D cast, i.e. 'cast(int)a' vs. 'cast(int) a' or # '(int)a' vs. '(int) a'. sp_after_cast = ignore # ignore/add/remove/force/not_defined # Add or remove spaces inside cast parentheses. sp_inside_paren_cast = ignore # ignore/add/remove/force/not_defined # Add or remove space between the type and open parenthesis in a C++ cast, # i.e. 'int(exp)' vs. 'int (exp)'. sp_cpp_cast_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof' and '('. sp_sizeof_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof' and '...'. sp_sizeof_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'sizeof...' and '('. sp_sizeof_ellipsis_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between '...' and a parameter pack. sp_ellipsis_parameter_pack = ignore # ignore/add/remove/force/not_defined # Add or remove space between a parameter pack and '...'. sp_parameter_pack_ellipsis = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'decltype' and '('. sp_decltype_paren = ignore # ignore/add/remove/force/not_defined # (Pawn) Add or remove space after the tag keyword. sp_after_tag = ignore # ignore/add/remove/force/not_defined # Add or remove space inside enum '{' and '}'. sp_inside_braces_enum = ignore # ignore/add/remove/force/not_defined # Add or remove space inside struct/union '{' and '}'. sp_inside_braces_struct = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}' sp_inside_braces_oc_dict = ignore # ignore/add/remove/force/not_defined # Add or remove space after open brace in an unnamed temporary # direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore. sp_after_type_brace_init_lst_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before close brace in an unnamed temporary # direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore. sp_before_type_brace_init_lst_close = ignore # ignore/add/remove/force/not_defined # Add or remove space inside an unnamed temporary direct-list-initialization # if statement is a brace_init_lst # works only if sp_brace_brace is set to ignore # works only if sp_before_type_brace_init_lst_close is set to ignore. sp_inside_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '{' and '}'. sp_inside_braces = ignore # ignore/add/remove/force/not_defined # Add or remove space inside '{}'. sp_inside_braces_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space around trailing return operator '->'. sp_trailing_return = ignore # ignore/add/remove/force/not_defined # Add or remove space between return type and function name. A minimum of 1 # is forced except for pointer return types. sp_type_func = ignore # ignore/add/remove/force/not_defined # Add or remove space between type and open brace of an unnamed temporary # direct-list-initialization. sp_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' on function declaration. sp_func_proto_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function declaration # without parameters. sp_func_proto_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' with a typedef specifier. sp_func_type_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between alias name and '(' of a non-pointer function type typedef. sp_func_def_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function definition # without parameters. sp_func_def_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space inside empty function '()'. # Overrides sp_after_angle unless use_sp_after_angle_always is set to true. sp_inside_fparens = ignore # ignore/add/remove/force/not_defined # Add or remove space inside function '(' and ')'. sp_inside_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space inside the first parentheses in a function type, as in # 'void (*x)(...)'. sp_inside_tparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between the ')' and '(' in a function type, as in # 'void (*x)(...)'. sp_after_tparen_close = ignore # ignore/add/remove/force/not_defined # Add or remove space between ']' and '(' when part of a function call. sp_square_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of function. sp_fparen_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and '{' of a function call in object # initialization. # # Overrides sp_fparen_brace. sp_fparen_brace_initializer = ignore # ignore/add/remove/force/not_defined # (Java) Add or remove space between ')' and '{{' of double brace initializer. sp_fparen_dbrace = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '(' on function calls. sp_func_call_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between function name and '()' on function calls without # parameters. If set to ignore (the default), sp_func_call_paren is used. sp_func_call_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space between the user function name and '(' on function # calls. You need to set a keyword to be a user function in the config file, # like: # set func_call_user tr _ i18n sp_func_call_user_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space inside user function '(' and ')'. sp_func_call_user_inside_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove space between nested parentheses with user functions, # i.e. '((' vs. '( ('. sp_func_call_user_paren_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between a constructor/destructor and the open # parenthesis. sp_func_class_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between a constructor without parameters or destructor # and '()'. sp_func_class_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove space after 'return'. # # Default: force sp_return = force # ignore/add/remove/force/not_defined # Add or remove space between 'return' and '('. sp_return_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'return' and '{'. sp_return_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '__attribute__' and '('. sp_attribute_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'defined' and '(' in '#if defined (FOO)'. sp_defined_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'throw' and '(' in 'throw (something)'. sp_throw_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'throw' and anything other than '(' as in # '@throw [...];'. sp_after_throw = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'catch' and '(' in 'catch (something) { }'. # If set to ignore, sp_before_sparen is used. sp_catch_paren = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@catch' and '(' # in '@catch (something) { }'. If set to ignore, sp_catch_paren is used. sp_oc_catch_paren = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before Objective-C protocol list # as in '@protocol Protocol' or '@interface MyClass : NSObject'. sp_before_oc_proto_list = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between class name and '(' # in '@interface className(categoryName):BaseClass' sp_oc_classname_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'version' and '(' # in 'version (something) { }'. If set to ignore, sp_before_sparen is used. sp_version_paren = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'scope' and '(' # in 'scope (something) { }'. If set to ignore, sp_before_sparen is used. sp_scope_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'super' and '(' in 'super (something)'. # # Default: remove sp_super_paren = remove # ignore/add/remove/force/not_defined # Add or remove space between 'this' and '(' in 'this (something)'. # # Default: remove sp_this_paren = remove # ignore/add/remove/force/not_defined # Add or remove space between a macro name and its definition. sp_macro = ignore # ignore/add/remove/force/not_defined # Add or remove space between a macro function ')' and its definition. sp_macro_func = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'else' and '{' if on the same line. sp_else_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'else' if on the same line. sp_brace_else = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and the name of a typedef on the same line. sp_brace_typedef = ignore # ignore/add/remove/force/not_defined # Add or remove space before the '{' of a 'catch' statement, if the '{' and # 'catch' are on the same line, as in 'catch (decl) {'. sp_catch_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the '{' of a '@catch' statement, if the '{' # and '@catch' are on the same line, as in '@catch (decl) {'. # If set to ignore, sp_catch_brace is used. sp_oc_catch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'catch' if on the same line. sp_brace_catch = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '}' and '@catch' if on the same line. # If set to ignore, sp_brace_catch is used. sp_oc_brace_catch = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'finally' and '{' if on the same line. sp_finally_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between '}' and 'finally' if on the same line. sp_brace_finally = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'try' and '{' if on the same line. sp_try_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between get/set and '{' if on the same line. sp_getset_brace = ignore # ignore/add/remove/force/not_defined # Add or remove space between a variable and '{' for C++ uniform # initialization. sp_word_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Add or remove space between a variable and '{' for a namespace. # # Default: add sp_word_brace_ns = add # ignore/add/remove/force/not_defined # Add or remove space before the '::' operator. sp_before_dc = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '::' operator. sp_after_dc = ignore # ignore/add/remove/force/not_defined # (D) Add or remove around the D named array initializer ':' operator. sp_d_array_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '!' (not) unary operator. # # Default: remove sp_not = remove # ignore/add/remove/force/not_defined # Add or remove space between two '!' (not) unary operators. # If set to ignore, sp_not will be used. sp_not_not = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '~' (invert) unary operator. # # Default: remove sp_inv = remove # ignore/add/remove/force/not_defined # Add or remove space after the '&' (address-of) unary operator. This does not # affect the spacing after a '&' that is part of a type. # # Default: remove sp_addr = remove # ignore/add/remove/force/not_defined # Add or remove space around the '.' or '->' operators. # # Default: remove sp_member = remove # ignore/add/remove/force/not_defined # Add or remove space after the '*' (dereference) unary operator. This does # not affect the spacing after a '*' that is part of a type. # # Default: remove sp_deref = remove # ignore/add/remove/force/not_defined # Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. # # Default: remove sp_sign = remove # ignore/add/remove/force/not_defined # Add or remove space between '++' and '--' the word to which it is being # applied, as in '(--x)' or 'y++;'. # # Default: remove sp_incdec = remove # ignore/add/remove/force/not_defined # Add or remove space before a backslash-newline at the end of a line. # # Default: add sp_before_nl_cont = add # ignore/add/remove/force/not_defined # (OC) Add or remove space after the scope '+' or '-', as in '-(void) foo;' # or '+(int) bar;'. sp_after_oc_scope = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in message specs, # i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'. sp_after_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in message specs, # i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'. sp_before_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in immutable dictionary expression # 'NSDictionary *test = @{@"foo" :@"bar"};'. sp_after_oc_dict_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in immutable dictionary expression # 'NSDictionary *test = @{@"foo" :@"bar"};'. sp_before_oc_dict_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the colon in message specs, # i.e. '[object setValue:1];' vs. '[object setValue: 1];'. sp_after_send_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before the colon in message specs, # i.e. '[object setValue:1];' vs. '[object setValue :1];'. sp_before_send_oc_colon = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the (type) in message specs, # i.e. '-(int)f: (int) x;' vs. '-(int)f: (int)x;'. sp_after_oc_type = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after the first (type) in message specs, # i.e. '-(int) f:(int)x;' vs. '-(int)f:(int)x;'. sp_after_oc_return_type = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@selector' and '(', # i.e. '@selector(msgName)' vs. '@selector (msgName)'. # Also applies to '@protocol()' constructs. sp_after_oc_at_sel = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@selector(x)' and the following word, # i.e. '@selector(foo) a:' vs. '@selector(foo)a:'. sp_after_oc_at_sel_parens = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space inside '@selector' parentheses, # i.e. '@selector(foo)' vs. '@selector( foo )'. # Also applies to '@protocol()' constructs. sp_inside_oc_at_sel_parens = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space before a block pointer caret, # i.e. '^int (int arg){...}' vs. ' ^int (int arg){...}'. sp_before_oc_block_caret = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after a block pointer caret, # i.e. '^int (int arg){...}' vs. '^ int (int arg){...}'. sp_after_oc_block_caret = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between the receiver and selector in a message, # as in '[receiver selector ...]'. sp_after_oc_msg_receiver = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space after '@property'. sp_after_oc_property = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove space between '@synchronized' and the open parenthesis, # i.e. '@synchronized(foo)' vs. '@synchronized (foo)'. sp_after_oc_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove space around the ':' in 'b ? t : f'. sp_cond_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before the ':' in 'b ? t : f'. # # Overrides sp_cond_colon. sp_cond_colon_before = ignore # ignore/add/remove/force/not_defined # Add or remove space after the ':' in 'b ? t : f'. # # Overrides sp_cond_colon. sp_cond_colon_after = ignore # ignore/add/remove/force/not_defined # Add or remove space around the '?' in 'b ? t : f'. sp_cond_question = ignore # ignore/add/remove/force/not_defined # Add or remove space before the '?' in 'b ? t : f'. # # Overrides sp_cond_question. sp_cond_question_before = ignore # ignore/add/remove/force/not_defined # Add or remove space after the '?' in 'b ? t : f'. # # Overrides sp_cond_question. sp_cond_question_after = ignore # ignore/add/remove/force/not_defined # In the abbreviated ternary form '(a ?: b)', add or remove space between '?' # and ':'. # # Overrides all other sp_cond_* options. sp_cond_ternary_short = ignore # ignore/add/remove/force/not_defined # Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make # sense here. sp_case_label = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space around the D '..' operator. sp_range = ignore # ignore/add/remove/force/not_defined # Add or remove space after ':' in a Java/C++11 range-based 'for', # as in 'for (Type var : expr)'. sp_after_for_colon = ignore # ignore/add/remove/force/not_defined # Add or remove space before ':' in a Java/C++11 range-based 'for', # as in 'for (Type var : expr)'. sp_before_for_colon = ignore # ignore/add/remove/force/not_defined # (D) Add or remove space between 'extern' and '(' as in 'extern (C)'. sp_extern_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the opening of a C++ comment, as in '// A'. sp_cmt_cpp_start = ignore # ignore/add/remove/force/not_defined # Add or remove space in a C++ region marker comment, as in '// BEGIN'. # A region marker is defined as a comment which is not preceded by other text # (i.e. the comment is the first non-whitespace on the line), and which starts # with either 'BEGIN' or 'END'. # # Overrides sp_cmt_cpp_start. sp_cmt_cpp_region = ignore # ignore/add/remove/force/not_defined # If true, space added with sp_cmt_cpp_start will be added after Doxygen # sequences like '///', '///<', '//!' and '//!<'. sp_cmt_cpp_doxygen = false # true/false # If true, space added with sp_cmt_cpp_start will be added after Qt translator # or meta-data comments like '//:', '//=', and '//~'. sp_cmt_cpp_qttr = false # true/false # Add or remove space between #else or #endif and a trailing comment. sp_endif_cmt = ignore # ignore/add/remove/force/not_defined # Add or remove space after 'new', 'delete' and 'delete[]'. sp_after_new = ignore # ignore/add/remove/force/not_defined # Add or remove space between 'new' and '(' in 'new()'. sp_between_new_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space between ')' and type in 'new(foo) BAR'. sp_after_newop_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space inside parentheses of the new operator # as in 'new(foo) BAR'. sp_inside_newop_paren = ignore # ignore/add/remove/force/not_defined # Add or remove space after the open parenthesis of the new operator, # as in 'new(foo) BAR'. # # Overrides sp_inside_newop_paren. sp_inside_newop_paren_open = ignore # ignore/add/remove/force/not_defined # Add or remove space before the close parenthesis of the new operator, # as in 'new(foo) BAR'. # # Overrides sp_inside_newop_paren. sp_inside_newop_paren_close = ignore # ignore/add/remove/force/not_defined # Add or remove space before a trailing comment. sp_before_tr_cmt = ignore # ignore/add/remove/force/not_defined # Number of spaces before a trailing comment. sp_num_before_tr_cmt = 0 # unsigned number # Add or remove space before an embedded comment. # # Default: force sp_before_emb_cmt = force # ignore/add/remove/force/not_defined # Number of spaces before an embedded comment. # # Default: 1 sp_num_before_emb_cmt = 1 # unsigned number # Add or remove space after an embedded comment. # # Default: force sp_after_emb_cmt = force # ignore/add/remove/force/not_defined # Number of spaces after an embedded comment. # # Default: 1 sp_num_after_emb_cmt = 1 # unsigned number # (Java) Add or remove space between an annotation and the open parenthesis. sp_annotation_paren = ignore # ignore/add/remove/force/not_defined # If true, vbrace tokens are dropped to the previous token and skipped. sp_skip_vbrace_tokens = false # true/false # Add or remove space after 'noexcept'. sp_after_noexcept = ignore # ignore/add/remove/force/not_defined # Add or remove space after '_'. sp_vala_after_translation = ignore # ignore/add/remove/force/not_defined # If true, a is inserted after #define. force_tab_after_define = false # true/false # # Indenting options # # The number of columns to indent per level. Usually 2, 3, 4, or 8. # # Default: 8 indent_columns = 8 # unsigned number # Whether to ignore indent for the first continuation line. Subsequent # continuation lines will still be indented to match the first. indent_ignore_first_continue = false # true/false # The continuation indent. If non-zero, this overrides the indent of '(', '[' # and '=' continuation indents. Negative values are OK; negative value is # absolute and not increased for each '(' or '[' level. # # For FreeBSD, this is set to 4. # Requires indent_ignore_first_continue=false. indent_continue = 0 # number # The continuation indent, only for class header line(s). If non-zero, this # overrides the indent of 'class' continuation indents. # Requires indent_ignore_first_continue=false. indent_continue_class_head = 0 # unsigned number # Whether to indent empty lines (i.e. lines which contain only spaces before # the newline character). indent_single_newlines = false # true/false # The continuation indent for func_*_param if they are true. If non-zero, this # overrides the indent. indent_param = 0 # unsigned number # How to use tabs when indenting code. # # 0: Spaces only # 1: Indent with tabs to brace level, align with spaces (default) # 2: Indent and align with tabs, using spaces when not on a tabstop # # Default: 1 indent_with_tabs = 1 # unsigned number # Whether to indent comments that are not at a brace level with tabs on a # tabstop. Requires indent_with_tabs=2. If false, will use spaces. indent_cmt_with_tabs = false # true/false # Whether to indent strings broken by '\' so that they line up. indent_align_string = false # true/false # The number of spaces to indent multi-line XML strings. # Requires indent_align_string=true. indent_xml_string = 0 # unsigned number # Spaces to indent '{' from level. indent_brace = 0 # unsigned number # Whether braces are indented to the body level. indent_braces = false # true/false # Whether to disable indenting function braces if indent_braces=true. indent_braces_no_func = false # true/false # Whether to disable indenting class braces if indent_braces=true. indent_braces_no_class = false # true/false # Whether to disable indenting struct braces if indent_braces=true. indent_braces_no_struct = false # true/false # Whether to indent based on the size of the brace parent, # i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc. indent_brace_parent = false # true/false # Whether to indent based on the open parenthesis instead of the open brace # in '({\n'. indent_paren_open_brace = false # true/false # (C#) Whether to indent the brace of a C# delegate by another level. indent_cs_delegate_brace = false # true/false # (C#) Whether to indent a C# delegate (to handle delegates with no brace) by # another level. indent_cs_delegate_body = false # true/false # Whether to indent the body of a 'namespace'. indent_namespace = false # true/false # Whether to indent only the first namespace, and not any nested namespaces. # Requires indent_namespace=true. indent_namespace_single_indent = false # true/false # The number of spaces to indent a namespace block. # If set to zero, use the value indent_columns indent_namespace_level = 0 # unsigned number # If the body of the namespace is longer than this number, it won't be # indented. Requires indent_namespace=true. 0 means no limit. indent_namespace_limit = 0 # unsigned number # Whether to indent only in inner namespaces (nested in other namespaces). # Requires indent_namespace=true. indent_namespace_inner_only = false # true/false # Whether the 'extern "C"' body is indented. indent_extern = false # true/false # Whether the 'class' body is indented. indent_class = false # true/false # Whether to ignore indent for the leading base class colon. indent_ignore_before_class_colon = false # true/false # Additional indent before the leading base class colon. # Negative values decrease indent down to the first column. # Requires indent_ignore_before_class_colon=false and a newline break before # the colon (see pos_class_colon and nl_class_colon) indent_before_class_colon = 0 # number # Whether to indent the stuff after a leading base class colon. indent_class_colon = false # true/false # Whether to indent based on a class colon instead of the stuff after the # colon. Requires indent_class_colon=true. indent_class_on_colon = false # true/false # Whether to ignore indent for a leading class initializer colon. indent_ignore_before_constr_colon = false # true/false # Whether to indent the stuff after a leading class initializer colon. indent_constr_colon = false # true/false # Virtual indent from the ':' for leading member initializers. # # Default: 2 indent_ctor_init_leading = 2 # unsigned number # Virtual indent from the ':' for following member initializers. # # Default: 2 indent_ctor_init_following = 2 # unsigned number # Additional indent for constructor initializer list. # Negative values decrease indent down to the first column. indent_ctor_init = 0 # number # Whether to indent 'if' following 'else' as a new block under the 'else'. # If false, 'else\nif' is treated as 'else if' for indenting purposes. indent_else_if = false # true/false # Amount to indent variable declarations after a open brace. # # <0: Relative # >=0: Absolute indent_var_def_blk = 0 # number # Whether to indent continued variable declarations instead of aligning. indent_var_def_cont = false # true/false # How to indent continued shift expressions ('<<' and '>>'). # Set align_left_shift=false when using this. # 0: Align shift operators instead of indenting them (default) # 1: Indent by one level # -1: Preserve original indentation indent_shift = 0 # number # Whether to force indentation of function definitions to start in column 1. indent_func_def_force_col1 = false # true/false # Whether to indent continued function call parameters one indent level, # rather than aligning parameters under the open parenthesis. indent_func_call_param = false # true/false # Whether to indent continued function definition parameters one indent level, # rather than aligning parameters under the open parenthesis. indent_func_def_param = false # true/false # for function definitions, only if indent_func_def_param is false # Allows to align params when appropriate and indent them when not # behave as if it was true if paren position is more than this value # if paren position is more than the option value indent_func_def_param_paren_pos_threshold = 0 # unsigned number # Whether to indent continued function call prototype one indent level, # rather than aligning parameters under the open parenthesis. indent_func_proto_param = false # true/false # Whether to indent continued function call declaration one indent level, # rather than aligning parameters under the open parenthesis. indent_func_class_param = false # true/false # Whether to indent continued class variable constructors one indent level, # rather than aligning parameters under the open parenthesis. indent_func_ctor_var_param = false # true/false # Whether to indent continued template parameter list one indent level, # rather than aligning parameters under the open parenthesis. indent_template_param = false # true/false # Double the indent for indent_func_xxx_param options. # Use both values of the options indent_columns and indent_param. indent_func_param_double = false # true/false # Indentation column for standalone 'const' qualifier on a function # prototype. indent_func_const = 0 # unsigned number # Indentation column for standalone 'throw' qualifier on a function # prototype. indent_func_throw = 0 # unsigned number # How to indent within a macro followed by a brace on the same line # This allows reducing the indent in macros that have (for example) # `do { ... } while (0)` blocks bracketing them. # # true: add an indent for the brace on the same line as the macro # false: do not add an indent for the brace on the same line as the macro # # Default: true indent_macro_brace = true # true/false # The number of spaces to indent a continued '->' or '.'. # Usually set to 0, 1, or indent_columns. indent_member = 0 # unsigned number # Whether lines broken at '.' or '->' should be indented by a single indent. # The indent_member option will not be effective if this is set to true. indent_member_single = false # true/false # Spaces to indent single line ('//') comments on lines before code. indent_single_line_comments_before = 0 # unsigned number # Spaces to indent single line ('//') comments on lines after code. indent_single_line_comments_after = 0 # unsigned number # When opening a paren for a control statement (if, for, while, etc), increase # the indent level by this value. Negative values decrease the indent level. indent_sparen_extra = 0 # number # Whether to indent trailing single line ('//') comments relative to the code # instead of trying to keep the same absolute column. indent_relative_single_line_comments = false # true/false # Spaces to indent 'case' from 'switch'. Usually 0 or indent_columns. # It might be wise to choose the same value for the option indent_case_brace. indent_switch_case = 0 # unsigned number # Spaces to indent the body of a 'switch' before any 'case'. # Usually the same as indent_columns or indent_switch_case. indent_switch_body = 0 # unsigned number # Whether to ignore indent for '{' following 'case'. indent_ignore_case_brace = false # true/false # Spaces to indent '{' from 'case'. By default, the brace will appear under # the 'c' in case. Usually set to 0 or indent_columns. Negative values are OK. # It might be wise to choose the same value for the option indent_switch_case. indent_case_brace = 0 # number # indent 'break' with 'case' from 'switch'. indent_switch_break_with_case = false # true/false # Whether to indent preprocessor statements inside of switch statements. # # Default: true indent_switch_pp = true # true/false # Spaces to shift the 'case' line, without affecting any other lines. # Usually 0. indent_case_shift = 0 # unsigned number # Whether to align comments before 'case' with the 'case'. # # Default: true indent_case_comment = true # true/false # Whether to indent comments not found in first column. # # Default: true indent_comment = true # true/false # Whether to indent comments found in first column. indent_col1_comment = false # true/false # Whether to indent multi string literal in first column. indent_col1_multi_string_literal = false # true/false # Align comments on adjacent lines that are this many columns apart or less. # # Default: 3 indent_comment_align_thresh = 3 # unsigned number # Whether to ignore indent for goto labels. indent_ignore_label = false # true/false # How to indent goto labels. Requires indent_ignore_label=false. # # >0: Absolute column where 1 is the leftmost column # <=0: Subtract from brace indent # # Default: 1 indent_label = 1 # number # How to indent access specifiers that are followed by a # colon. # # >0: Absolute column where 1 is the leftmost column # <=0: Subtract from brace indent # # Default: 1 indent_access_spec = 1 # number # Whether to indent the code after an access specifier by one level. # If true, this option forces 'indent_access_spec=0'. indent_access_spec_body = false # true/false # If an open parenthesis is followed by a newline, whether to indent the next # line so that it lines up after the open parenthesis (not recommended). indent_paren_nl = false # true/false # How to indent a close parenthesis after a newline. # # 0: Indent to body level (default) # 1: Align under the open parenthesis # 2: Indent to the brace level # -1: Preserve original indentation indent_paren_close = 0 # number # Whether to indent the open parenthesis of a function definition, # if the parenthesis is on its own line. indent_paren_after_func_def = false # true/false # Whether to indent the open parenthesis of a function declaration, # if the parenthesis is on its own line. indent_paren_after_func_decl = false # true/false # Whether to indent the open parenthesis of a function call, # if the parenthesis is on its own line. indent_paren_after_func_call = false # true/false # How to indent a comma when inside braces. # 0: Indent by one level (default) # 1: Align under the open brace # -1: Preserve original indentation indent_comma_brace = 0 # number # How to indent a comma when inside parentheses. # 0: Indent by one level (default) # 1: Align under the open parenthesis # -1: Preserve original indentation indent_comma_paren = 0 # number # How to indent a Boolean operator when inside parentheses. # 0: Indent by one level (default) # 1: Align under the open parenthesis # -1: Preserve original indentation indent_bool_paren = 0 # number # Whether to ignore the indentation of a Boolean operator when outside # parentheses. indent_ignore_bool = false # true/false # Whether to ignore the indentation of an arithmetic operator. indent_ignore_arith = false # true/false # Whether to indent a semicolon when inside a for parenthesis. # If true, aligns under the open for parenthesis. indent_semicolon_for_paren = false # true/false # Whether to ignore the indentation of a semicolon outside of a 'for' # statement. indent_ignore_semicolon = false # true/false # Whether to align the first expression to following ones # if indent_bool_paren=1. indent_first_bool_expr = false # true/false # Whether to align the first expression to following ones # if indent_semicolon_for_paren=true. indent_first_for_expr = false # true/false # If an open square is followed by a newline, whether to indent the next line # so that it lines up after the open square (not recommended). indent_square_nl = false # true/false # (ESQL/C) Whether to preserve the relative indent of 'EXEC SQL' bodies. indent_preserve_sql = false # true/false # Whether to ignore the indentation of an assignment operator. indent_ignore_assign = false # true/false # Whether to align continued statements at the '='. If false or if the '=' is # followed by a newline, the next line is indent one tab. # # Default: true indent_align_assign = true # true/false # If true, the indentation of the chunks after a '=' sequence will be set at # LHS token indentation column before '='. indent_off_after_assign = false # true/false # Whether to align continued statements at the '('. If false or the '(' is # followed by a newline, the next line indent is one tab. # # Default: true indent_align_paren = true # true/false # (OC) Whether to indent Objective-C code inside message selectors. indent_oc_inside_msg_sel = false # true/false # (OC) Whether to indent Objective-C blocks at brace level instead of usual # rules. indent_oc_block = false # true/false # (OC) Indent for Objective-C blocks in a message relative to the parameter # name. # # =0: Use indent_oc_block rules # >0: Use specified number of spaces to indent indent_oc_block_msg = 0 # unsigned number # (OC) Minimum indent for subsequent parameters indent_oc_msg_colon = 0 # unsigned number # (OC) Whether to prioritize aligning with initial colon (and stripping spaces # from lines, if necessary). # # Default: true indent_oc_msg_prioritize_first_colon = true # true/false # (OC) Whether to indent blocks the way that Xcode does by default # (from the keyword if the parameter is on its own line; otherwise, from the # previous indentation level). Requires indent_oc_block_msg=true. indent_oc_block_msg_xcode_style = false # true/false # (OC) Whether to indent blocks from where the brace is, relative to a # message keyword. Requires indent_oc_block_msg=true. indent_oc_block_msg_from_keyword = false # true/false # (OC) Whether to indent blocks from where the brace is, relative to a message # colon. Requires indent_oc_block_msg=true. indent_oc_block_msg_from_colon = false # true/false # (OC) Whether to indent blocks from where the block caret is. # Requires indent_oc_block_msg=true. indent_oc_block_msg_from_caret = false # true/false # (OC) Whether to indent blocks from where the brace caret is. # Requires indent_oc_block_msg=true. indent_oc_block_msg_from_brace = false # true/false # When indenting after virtual brace open and newline add further spaces to # reach this minimum indent. indent_min_vbrace_open = 0 # unsigned number # Whether to add further spaces after regular indent to reach next tabstop # when indenting after virtual brace open and newline. indent_vbrace_open_on_tabstop = false # true/false # How to indent after a brace followed by another token (not a newline). # true: indent all contained lines to match the token # false: indent all contained lines to match the brace # # Default: true indent_token_after_brace = true # true/false # Whether to indent the body of a C++11 lambda. indent_cpp_lambda_body = false # true/false # How to indent compound literals that are being returned. # true: add both the indent from return & the compound literal open brace # (i.e. 2 indent levels) # false: only indent 1 level, don't add the indent for the open brace, only # add the indent for the return. # # Default: true indent_compound_literal_return = true # true/false # (C#) Whether to indent a 'using' block if no braces are used. # # Default: true indent_using_block = true # true/false # How to indent the continuation of ternary operator. # # 0: Off (default) # 1: When the `if_false` is a continuation, indent it under the `if_true` branch # 2: When the `:` is a continuation, indent it under `?` indent_ternary_operator = 0 # unsigned number # Whether to indent the statements inside ternary operator. indent_inside_ternary_operator = false # true/false # If true, the indentation of the chunks after a `return` sequence will be set at return indentation column. indent_off_after_return = false # true/false # If true, the indentation of the chunks after a `return new` sequence will be set at return indentation column. indent_off_after_return_new = false # true/false # If true, the tokens after return are indented with regular single indentation. By default (false) the indentation is after the return token. indent_single_after_return = false # true/false # Whether to ignore indent and alignment for 'asm' blocks (i.e. assume they # have their own indentation). indent_ignore_asm_block = false # true/false # Don't indent the close parenthesis of a function definition, # if the parenthesis is on its own line. donot_indent_func_def_close_paren = false # true/false # # Newline adding and removing options # # Whether to collapse empty blocks between '{' and '}' except for functions. # Use nl_collapse_empty_body_functions to specify how empty function braces # should be formatted. nl_collapse_empty_body = false # true/false # Whether to collapse empty blocks between '{' and '}' for functions only. # If true, overrides nl_inside_empty_func. nl_collapse_empty_body_functions = false # true/false # Don't split one-line braced assignments, as in 'foo_t f = { 1, 2 };'. nl_assign_leave_one_liners = false # true/false # Don't split one-line braced statements inside a 'class xx { }' body. nl_class_leave_one_liners = false # true/false # Don't split one-line enums, as in 'enum foo { BAR = 15 };' nl_enum_leave_one_liners = false # true/false # Don't split one-line get or set functions. nl_getset_leave_one_liners = false # true/false # (C#) Don't split one-line property get or set functions. nl_cs_property_leave_one_liners = false # true/false # Don't split one-line function definitions, as in 'int foo() { return 0; }'. # might modify nl_func_type_name nl_func_leave_one_liners = false # true/false # Don't split one-line C++11 lambdas, as in '[]() { return 0; }'. nl_cpp_lambda_leave_one_liners = false # true/false # Don't split one-line if/else statements, as in 'if(...) b++;'. nl_if_leave_one_liners = false # true/false # Don't split one-line while statements, as in 'while(...) b++;'. nl_while_leave_one_liners = false # true/false # Don't split one-line do statements, as in 'do { b++; } while(...);'. nl_do_leave_one_liners = false # true/false # Don't split one-line for statements, as in 'for(...) b++;'. nl_for_leave_one_liners = false # true/false # (OC) Don't split one-line Objective-C messages. nl_oc_msg_leave_one_liner = false # true/false # (OC) Add or remove newline between method declaration and '{'. nl_oc_mdef_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between Objective-C block signature and '{'. nl_oc_block_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@interface' statement. nl_oc_before_interface = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@implementation' statement. nl_oc_before_implementation = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove blank line before '@end' statement. nl_oc_before_end = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '@interface' and '{'. nl_oc_interface_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '@implementation' and '{'. nl_oc_implementation_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newlines at the start of the file. nl_start_of_file = ignore # ignore/add/remove/force/not_defined # The minimum number of newlines at the start of the file (only used if # nl_start_of_file is 'add' or 'force'). nl_start_of_file_min = 0 # unsigned number # Add or remove newline at the end of the file. nl_end_of_file = ignore # ignore/add/remove/force/not_defined # The minimum number of newlines at the end of the file (only used if # nl_end_of_file is 'add' or 'force'). nl_end_of_file_min = 0 # unsigned number # Add or remove newline between '=' and '{'. nl_assign_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between '=' and '['. nl_assign_square = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '[]' and '{'. nl_tsquare_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline after '= ['. Will also affect the newline before # the ']'. nl_after_square_assign = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function call's ')' and '{', as in # 'list_for_each(item, &list) { }'. nl_fcall_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum' and '{'. nl_enum_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum' and 'class'. nl_enum_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class' and the identifier. nl_enum_class_identifier = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class' type and ':'. nl_enum_identifier_colon = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'enum class identifier :' and type. nl_enum_colon_type = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'struct and '{'. nl_struct_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'union' and '{'. nl_union_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'if' and '{'. nl_if_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'else'. nl_brace_else = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else if' and '{'. If set to ignore, # nl_if_brace is used instead. nl_elseif_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else' and '{'. nl_else_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'else' and 'if'. nl_else_if = ignore # ignore/add/remove/force/not_defined # Add or remove newline before '{' opening brace nl_before_opening_brace_func_class_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline before 'if'/'else if' closing parenthesis. nl_before_if_closing_paren = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'finally'. nl_brace_finally = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'finally' and '{'. nl_finally_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'try' and '{'. nl_try_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between get/set and '{'. nl_getset_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'for' and '{'. nl_for_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline before the '{' of a 'catch' statement, as in # 'catch (decl) {'. nl_catch_brace = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline before the '{' of a '@catch' statement, as in # '@catch (decl) {'. If set to ignore, nl_catch_brace is used. nl_oc_catch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'catch'. nl_brace_catch = ignore # ignore/add/remove/force/not_defined # (OC) Add or remove newline between '}' and '@catch'. If set to ignore, # nl_brace_catch is used. nl_oc_brace_catch = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and ']'. nl_brace_square = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and ')' in a function invocation. nl_brace_fparen = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'while' and '{'. nl_while_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'scope (x)' and '{'. nl_scope_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'unittest' and '{'. nl_unittest_brace = ignore # ignore/add/remove/force/not_defined # (D) Add or remove newline between 'version (x)' and '{'. nl_version_brace = ignore # ignore/add/remove/force/not_defined # (C#) Add or remove newline between 'using' and '{'. nl_using_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between two open or close braces. Due to general # newline/brace handling, REMOVE may not work. nl_brace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'do' and '{'. nl_do_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '}' and 'while' of 'do' statement. nl_brace_while = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'switch' and '{'. nl_switch_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'synchronized' and '{'. nl_synchronized_brace = ignore # ignore/add/remove/force/not_defined # Add a newline between ')' and '{' if the ')' is on a different line than the # if/for/etc. # # Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch and # nl_catch_brace. nl_multi_line_cond = false # true/false # Add a newline after '(' if an if/for/while/switch condition spans multiple # lines nl_multi_line_sparen_open = ignore # ignore/add/remove/force/not_defined # Add a newline before ')' if an if/for/while/switch condition spans multiple # lines. Overrides nl_before_if_closing_paren if both are specified. nl_multi_line_sparen_close = ignore # ignore/add/remove/force/not_defined # Force a newline in a define after the macro name for multi-line defines. nl_multi_line_define = false # true/false # Whether to add a newline before 'case', and a blank line before a 'case' # statement that follows a ';' or '}'. nl_before_case = false # true/false # Whether to add a newline after a 'case' statement. nl_after_case = false # true/false # Add or remove newline between a case ':' and '{'. # # Overrides nl_after_case. nl_case_colon_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between ')' and 'throw'. nl_before_throw = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'namespace' and '{'. nl_namespace_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class. nl_template_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class declaration. # # Overrides nl_template_class. nl_template_class_decl = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized class declaration. # # Overrides nl_template_class_decl. nl_template_class_decl_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template class definition. # # Overrides nl_template_class. nl_template_class_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized class definition. # # Overrides nl_template_class_def. nl_template_class_def_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function. nl_template_func = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function # declaration. # # Overrides nl_template_func. nl_template_func_decl = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized function # declaration. # # Overrides nl_template_func_decl. nl_template_func_decl_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template function # definition. # # Overrides nl_template_func. nl_template_func_def = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<>' of a specialized function # definition. # # Overrides nl_template_func_def. nl_template_func_def_special = ignore # ignore/add/remove/force/not_defined # Add or remove newline after 'template<...>' of a template variable. nl_template_var = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'template<...>' and 'using' of a templated # type alias. nl_template_using = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'class' and '{'. nl_class_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline before or after (depending on pos_class_comma, # may not be IGNORE) each',' in the base class list. nl_class_init_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in the constructor member # initialization. Related to nl_constr_colon, pos_constr_colon and # pos_constr_comma. nl_constr_init_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline before first element, after comma, and after last # element, in 'enum'. nl_enum_own_lines = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name in a function # definition. # might be modified by nl_func_leave_one_liners nl_func_type_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name inside a class # definition. If set to ignore, nl_func_type_name or nl_func_proto_type_name # is used instead. nl_func_type_name_class = ignore # ignore/add/remove/force/not_defined # Add or remove newline between class specification and '::' # in 'void A::f() { }'. Only appears in separate member implementation (does # not appear with in-line implementation). nl_func_class_scope = ignore # ignore/add/remove/force/not_defined # Add or remove newline between function scope and name, as in # 'void A :: f() { }'. nl_func_scope_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between return type and function name in a prototype. nl_func_proto_type_name = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # declaration. nl_func_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_paren for functions with no parameters. nl_func_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # definition. nl_func_def_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_paren for functions with no parameters. nl_func_def_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between a function name and the opening '(' in the # call. nl_func_call_paren = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_call_paren for functions with no parameters. nl_func_call_paren_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline after '(' in a function declaration. nl_func_decl_start = ignore # ignore/add/remove/force/not_defined # Add or remove newline after '(' in a function definition. nl_func_def_start = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_decl_start when there is only one parameter. nl_func_decl_start_single = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_start when there is only one parameter. nl_func_def_start_single = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function declaration if '(' and ')' # are in different lines. If false, nl_func_decl_start is used instead. nl_func_decl_start_multi_line = false # true/false # Whether to add a newline after '(' in a function definition if '(' and ')' # are in different lines. If false, nl_func_def_start is used instead. nl_func_def_start_multi_line = false # true/false # Add or remove newline after each ',' in a function declaration. nl_func_decl_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in a function definition. nl_func_def_args = ignore # ignore/add/remove/force/not_defined # Add or remove newline after each ',' in a function call. nl_func_call_args = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after each ',' in a function declaration if '(' # and ')' are in different lines. If false, nl_func_decl_args is used instead. nl_func_decl_args_multi_line = false # true/false # Whether to add a newline after each ',' in a function definition if '(' # and ')' are in different lines. If false, nl_func_def_args is used instead. nl_func_def_args_multi_line = false # true/false # Add or remove newline before the ')' in a function declaration. nl_func_decl_end = ignore # ignore/add/remove/force/not_defined # Add or remove newline before the ')' in a function definition. nl_func_def_end = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_decl_end when there is only one parameter. nl_func_decl_end_single = ignore # ignore/add/remove/force/not_defined # Overrides nl_func_def_end when there is only one parameter. nl_func_def_end_single = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before ')' in a function declaration if '(' and ')' # are in different lines. If false, nl_func_decl_end is used instead. nl_func_decl_end_multi_line = false # true/false # Whether to add a newline before ')' in a function definition if '(' and ')' # are in different lines. If false, nl_func_def_end is used instead. nl_func_def_end_multi_line = false # true/false # Add or remove newline between '()' in a function declaration. nl_func_decl_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '()' in a function definition. nl_func_def_empty = ignore # ignore/add/remove/force/not_defined # Add or remove newline between '()' in a function call. nl_func_call_empty = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function call, # has preference over nl_func_call_start_multi_line. nl_func_call_start = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before ')' in a function call. nl_func_call_end = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after '(' in a function call if '(' and ')' are in # different lines. nl_func_call_start_multi_line = false # true/false # Whether to add a newline after each ',' in a function call if '(' and ')' # are in different lines. nl_func_call_args_multi_line = false # true/false # Whether to add a newline before ')' in a function call if '(' and ')' are in # different lines. nl_func_call_end_multi_line = false # true/false # Whether to respect nl_func_call_XXX option in case of closure args. nl_func_call_args_multi_line_ignore_closures = false # true/false # Whether to add a newline after '<' of a template parameter list. nl_template_start = false # true/false # Whether to add a newline after each ',' in a template parameter list. nl_template_args = false # true/false # Whether to add a newline before '>' of a template parameter list. nl_template_end = false # true/false # (OC) Whether to put each Objective-C message parameter on a separate line. # See nl_oc_msg_leave_one_liner. nl_oc_msg_args = false # true/false # (OC) Minimum number of Objective-C message parameters before applying nl_oc_msg_args. nl_oc_msg_args_min_params = 0 # unsigned number # (OC) Max code width of Objective-C message before applying nl_oc_msg_args. nl_oc_msg_args_max_code_width = 0 # unsigned number # Add or remove newline between function signature and '{'. nl_fdef_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between function signature and '{', # if signature ends with ')'. Overrides nl_fdef_brace. nl_fdef_brace_cond = ignore # ignore/add/remove/force/not_defined # Add or remove newline between C++11 lambda signature and '{'. nl_cpp_ldef_brace = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'return' and the return expression. nl_return_expr = ignore # ignore/add/remove/force/not_defined # Add or remove newline between 'throw' and the throw expression. nl_throw_expr = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after semicolons, except in 'for' statements. nl_after_semicolon = false # true/false # (Java) Add or remove newline between the ')' and '{{' of the double brace # initializer. nl_paren_dbrace_open = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after the type in an unnamed temporary # direct-list-initialization, better: # before a direct-list-initialization. nl_type_brace_init_lst = ignore # ignore/add/remove/force/not_defined # Whether to add a newline after the open brace in an unnamed temporary # direct-list-initialization. nl_type_brace_init_lst_open = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before the close brace in an unnamed temporary # direct-list-initialization. nl_type_brace_init_lst_close = ignore # ignore/add/remove/force/not_defined # Whether to add a newline before '{'. nl_before_brace_open = false # true/false # Whether to add a newline after '{'. nl_after_brace_open = false # true/false # Whether to add a newline between the open brace and a trailing single-line # comment. Requires nl_after_brace_open=true. nl_after_brace_open_cmt = false # true/false # Whether to add a newline after a virtual brace open with a non-empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open = false # true/false # Whether to add a newline after a virtual brace open with an empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open_empty = false # true/false # Whether to add a newline after '}'. Does not apply if followed by a # necessary ';'. nl_after_brace_close = false # true/false # Whether to add a newline after a virtual brace close, # as in 'if (foo) a++; return;'. nl_after_vbrace_close = false # true/false # Add or remove newline between the close brace and identifier, # as in 'struct { int a; } b;'. Affects enumerations, unions and # structures. If set to ignore, uses nl_after_brace_close. nl_brace_struct_var = ignore # ignore/add/remove/force/not_defined # Whether to alter newlines in '#define' macros. nl_define_macro = false # true/false # Whether to alter newlines between consecutive parenthesis closes. The number # of closing parentheses in a line will depend on respective open parenthesis # lines. nl_squeeze_paren_close = false # true/false # Whether to remove blanks after '#ifxx' and '#elxx', or before '#elxx' and # '#endif'. Does not affect top-level #ifdefs. nl_squeeze_ifdef = false # true/false # Makes the nl_squeeze_ifdef option affect the top-level #ifdefs as well. nl_squeeze_ifdef_top_level = false # true/false # Add or remove blank line before 'if'. nl_before_if = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'if' statement. Add/Force work only if the # next token is not a closing brace. nl_after_if = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'for'. nl_before_for = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'for' statement. nl_after_for = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'while'. nl_before_while = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'while' statement. nl_after_while = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'switch'. nl_before_switch = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'switch' statement. nl_after_switch = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'synchronized'. nl_before_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'synchronized' statement. nl_after_synchronized = ignore # ignore/add/remove/force/not_defined # Add or remove blank line before 'do'. nl_before_do = ignore # ignore/add/remove/force/not_defined # Add or remove blank line after 'do/while' statement. nl_after_do = ignore # ignore/add/remove/force/not_defined # Ignore nl_before_{if,for,switch,do,synchronized} if the control # statement is immediately after a case statement. # if nl_before_{if,for,switch,do} is set to remove, this option # does nothing. nl_before_ignore_after_case = false # true/false # Whether to put a blank line before 'return' statements, unless after an open # brace. nl_before_return = false # true/false # Whether to put a blank line after 'return' statements, unless followed by a # close brace. nl_after_return = false # true/false # Whether to put a blank line before a member '.' or '->' operators. nl_before_member = ignore # ignore/add/remove/force/not_defined # (Java) Whether to put a blank line after a member '.' or '->' operators. nl_after_member = ignore # ignore/add/remove/force/not_defined # Whether to double-space commented-entries in 'struct'/'union'/'enum'. nl_ds_struct_enum_cmt = false # true/false # Whether to force a newline before '}' of a 'struct'/'union'/'enum'. # (Lower priority than eat_blanks_before_close_brace.) nl_ds_struct_enum_close_brace = false # true/false # Add or remove newline before or after (depending on pos_class_colon) a class # colon, as in 'class Foo : public Bar'. nl_class_colon = ignore # ignore/add/remove/force/not_defined # Add or remove newline around a class constructor colon. The exact position # depends on nl_constr_init_args, pos_constr_colon and pos_constr_comma. nl_constr_colon = ignore # ignore/add/remove/force/not_defined # Whether to collapse a two-line namespace, like 'namespace foo\n{ decl; }' # into a single line. If true, prevents other brace newline rules from turning # such code into four lines. If true, it also preserves one-liner namespaces. nl_namespace_two_to_one_liner = false # true/false # Whether to remove a newline in simple unbraced if statements, turning them # into one-liners, as in 'if(b)\n i++;' => 'if(b) i++;'. nl_create_if_one_liner = false # true/false # Whether to remove a newline in simple unbraced for statements, turning them # into one-liners, as in 'for (...)\n stmt;' => 'for (...) stmt;'. nl_create_for_one_liner = false # true/false # Whether to remove a newline in simple unbraced while statements, turning # them into one-liners, as in 'while (expr)\n stmt;' => 'while (expr) stmt;'. nl_create_while_one_liner = false # true/false # Whether to collapse a function definition whose body (not counting braces) # is only one line so that the entire definition (prototype, braces, body) is # a single line. nl_create_func_def_one_liner = false # true/false # Whether to split one-line simple list definitions into three lines by # adding newlines, as in 'int a[12] = { 0 };'. nl_create_list_one_liner = false # true/false # Whether to split one-line simple unbraced if statements into two lines by # adding a newline, as in 'if(b) i++;'. nl_split_if_one_liner = false # true/false # Whether to split one-line simple unbraced for statements into two lines by # adding a newline, as in 'for (...) stmt;'. nl_split_for_one_liner = false # true/false # Whether to split one-line simple unbraced while statements into two lines by # adding a newline, as in 'while (expr) stmt;'. nl_split_while_one_liner = false # true/false # Don't add a newline before a cpp-comment in a parameter list of a function # call. donot_add_nl_before_cpp_comment = false # true/false # # Blank line options # # The maximum number of consecutive newlines (3 = 2 blank lines). nl_max = 0 # unsigned number # The maximum number of consecutive newlines in a function. nl_max_blank_in_func = 0 # unsigned number # The number of newlines inside an empty function body. # This option overrides eat_blanks_after_open_brace and # eat_blanks_before_close_brace, but is ignored when # nl_collapse_empty_body_functions=true nl_inside_empty_func = 0 # unsigned number # The number of newlines before a function prototype. nl_before_func_body_proto = 0 # unsigned number # The number of newlines before a multi-line function definition. Where # applicable, this option is overridden with eat_blanks_after_open_brace=true nl_before_func_body_def = 0 # unsigned number # The number of newlines before a class constructor/destructor prototype. nl_before_func_class_proto = 0 # unsigned number # The number of newlines before a class constructor/destructor definition. nl_before_func_class_def = 0 # unsigned number # The number of newlines after a function prototype. nl_after_func_proto = 0 # unsigned number # The number of newlines after a function prototype, if not followed by # another function prototype. nl_after_func_proto_group = 0 # unsigned number # The number of newlines after a class constructor/destructor prototype. nl_after_func_class_proto = 0 # unsigned number # The number of newlines after a class constructor/destructor prototype, # if not followed by another constructor/destructor prototype. nl_after_func_class_proto_group = 0 # unsigned number # Whether one-line method definitions inside a class body should be treated # as if they were prototypes for the purposes of adding newlines. # # Requires nl_class_leave_one_liners=true. Overrides nl_before_func_body_def # and nl_before_func_class_def for one-liners. nl_class_leave_one_liner_groups = false # true/false # The number of newlines after '}' of a multi-line function body. nl_after_func_body = 0 # unsigned number # The number of newlines after '}' of a multi-line function body in a class # declaration. Also affects class constructors/destructors. # # Overrides nl_after_func_body. nl_after_func_body_class = 0 # unsigned number # The number of newlines after '}' of a single line function body. Also # affects class constructors/destructors. # # Overrides nl_after_func_body and nl_after_func_body_class. nl_after_func_body_one_liner = 0 # unsigned number # The number of newlines before a block of typedefs. If nl_after_access_spec # is non-zero, that option takes precedence. # # 0: No change (default). nl_typedef_blk_start = 0 # unsigned number # The number of newlines after a block of typedefs. # # 0: No change (default). nl_typedef_blk_end = 0 # unsigned number # The maximum number of consecutive newlines within a block of typedefs. # # 0: No change (default). nl_typedef_blk_in = 0 # unsigned number # The minimum number of blank lines after a block of variable definitions # at the top of a function body. If any preprocessor directives appear # between the opening brace of the function and the variable block, then # it is considered as not at the top of the function.Newlines are added # before trailing preprocessor directives, if any exist. # # 0: No change (default). nl_var_def_blk_end_func_top = 0 # unsigned number # The minimum number of empty newlines before a block of variable definitions # not at the top of a function body. If nl_after_access_spec is non-zero, # that option takes precedence. Newlines are not added at the top of the # file or just after an opening brace. Newlines are added above any # preprocessor directives before the block. # # 0: No change (default). nl_var_def_blk_start = 0 # unsigned number # The minimum number of empty newlines after a block of variable definitions # not at the top of a function body. Newlines are not added if the block # is at the bottom of the file or just before a preprocessor directive. # # 0: No change (default). nl_var_def_blk_end = 0 # unsigned number # The maximum number of consecutive newlines within a block of variable # definitions. # # 0: No change (default). nl_var_def_blk_in = 0 # unsigned number # The minimum number of newlines before a multi-line comment. # Doesn't apply if after a brace open or another multi-line comment. nl_before_block_comment = 0 # unsigned number # The minimum number of newlines before a single-line C comment. # Doesn't apply if after a brace open or other single-line C comments. nl_before_c_comment = 0 # unsigned number # The minimum number of newlines before a CPP comment. # Doesn't apply if after a brace open or other CPP comments. nl_before_cpp_comment = 0 # unsigned number # Whether to force a newline after a multi-line comment. nl_after_multiline_comment = false # true/false # Whether to force a newline after a label's colon. nl_after_label_colon = false # true/false # The number of newlines before a struct definition. nl_before_struct = 0 # unsigned number # The number of newlines after '}' or ';' of a struct/enum/union definition. nl_after_struct = 0 # unsigned number # The number of newlines before a class definition. nl_before_class = 0 # unsigned number # The number of newlines after '}' or ';' of a class definition. nl_after_class = 0 # unsigned number # The number of newlines before a namespace. nl_before_namespace = 0 # unsigned number # The number of newlines after '{' of a namespace. This also adds newlines # before the matching '}'. # # 0: Apply eat_blanks_after_open_brace or eat_blanks_before_close_brace if # applicable, otherwise no change. # # Overrides eat_blanks_after_open_brace and eat_blanks_before_close_brace. nl_inside_namespace = 0 # unsigned number # The number of newlines after '}' of a namespace. nl_after_namespace = 0 # unsigned number # The number of newlines before an access specifier label. This also includes # the Qt-specific 'signals:' and 'slots:'. Will not change the newline count # if after a brace open. # # 0: No change (default). nl_before_access_spec = 0 # unsigned number # The number of newlines after an access specifier label. This also includes # the Qt-specific 'signals:' and 'slots:'. Will not change the newline count # if after a brace open. # # 0: No change (default). # # Overrides nl_typedef_blk_start and nl_var_def_blk_start. nl_after_access_spec = 0 # unsigned number # The number of newlines between a function definition and the function # comment, as in '// comment\n void foo() {...}'. # # 0: No change (default). nl_comment_func_def = 0 # unsigned number # The number of newlines after a try-catch-finally block that isn't followed # by a brace close. # # 0: No change (default). nl_after_try_catch_finally = 0 # unsigned number # (C#) The number of newlines before and after a property, indexer or event # declaration. # # 0: No change (default). nl_around_cs_property = 0 # unsigned number # (C#) The number of newlines between the get/set/add/remove handlers. # # 0: No change (default). nl_between_get_set = 0 # unsigned number # (C#) Add or remove newline between property and the '{'. nl_property_brace = ignore # ignore/add/remove/force/not_defined # Whether to remove blank lines after '{'. eat_blanks_after_open_brace = false # true/false # Whether to remove blank lines before '}'. eat_blanks_before_close_brace = false # true/false # How aggressively to remove extra newlines not in preprocessor. # # 0: No change (default) # 1: Remove most newlines not handled by other config # 2: Remove all newlines and reformat completely by config nl_remove_extra_newlines = 0 # unsigned number # (Java) Add or remove newline after an annotation statement. Only affects # annotations that are after a newline. nl_after_annotation = ignore # ignore/add/remove/force/not_defined # (Java) Add or remove newline between two annotations. nl_between_annotation = ignore # ignore/add/remove/force/not_defined # The number of newlines before a whole-file #ifdef. # # 0: No change (default). nl_before_whole_file_ifdef = 0 # unsigned number # The number of newlines after a whole-file #ifdef. # # 0: No change (default). nl_after_whole_file_ifdef = 0 # unsigned number # The number of newlines before a whole-file #endif. # # 0: No change (default). nl_before_whole_file_endif = 0 # unsigned number # The number of newlines after a whole-file #endif. # # 0: No change (default). nl_after_whole_file_endif = 0 # unsigned number # # Positioning options # # The position of arithmetic operators in wrapped expressions. pos_arith = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of assignment in wrapped expressions. Do not affect '=' # followed by '{'. pos_assign = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of Boolean operators in wrapped expressions. pos_bool = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of comparison operators in wrapped expressions. pos_compare = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of conditional operators, as in the '?' and ':' of # 'expr ? stmt : stmt', in wrapped expressions. pos_conditional = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in wrapped expressions. pos_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in enum entries. pos_enum_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in the base class list if there is more than one # line. Affects nl_class_init_args. pos_class_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of the comma in the constructor initialization list. # Related to nl_constr_colon, nl_constr_init_args and pos_constr_colon. pos_constr_comma = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of trailing/leading class colon, between class and base class # list. Affects nl_class_colon. pos_class_colon = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of colons between constructor and member initialization. # Related to nl_constr_colon, nl_constr_init_args and pos_constr_comma. pos_constr_colon = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # The position of shift operators in wrapped expressions. pos_shift = ignore # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force # # Line splitting options # # Try to limit code width to N columns. code_width = 0 # unsigned number # Whether to fully split long 'for' statements at semi-colons. ls_for_split_full = false # true/false # Whether to fully split long function prototypes/calls at commas. # The option ls_code_width has priority over the option ls_func_split_full. ls_func_split_full = false # true/false # Whether to split lines as close to code_width as possible and ignore some # groupings. # The option ls_code_width has priority over the option ls_func_split_full. ls_code_width = false # true/false # # Code alignment options (not left column spaces/tabs) # # Whether to keep non-indenting tabs. align_keep_tabs = false # true/false # Whether to use tabs for aligning. align_with_tabs = false # true/false # Whether to bump out to the next tab when aligning. align_on_tabstop = false # true/false # Whether to right-align numbers. align_number_right = false # true/false # Whether to keep whitespace not required for alignment. align_keep_extra_space = false # true/false # Whether to align variable definitions in prototypes and functions. align_func_params = false # true/false # The span for aligning parameter definitions in function on parameter name. # # 0: Don't align (default). align_func_params_span = 0 # unsigned number # The threshold for aligning function parameter definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_func_params_thresh = 0 # number # The gap for aligning function parameter definitions. align_func_params_gap = 0 # unsigned number # The span for aligning constructor value. # # 0: Don't align (default). align_constr_value_span = 0 # unsigned number # The threshold for aligning constructor value. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_constr_value_thresh = 0 # number # The gap for aligning constructor value. align_constr_value_gap = 0 # unsigned number # Whether to align parameters in single-line functions that have the same # name. The function names must already be aligned with each other. align_same_func_call_params = false # true/false # The span for aligning function-call parameters for single line functions. # # 0: Don't align (default). align_same_func_call_params_span = 0 # unsigned number # The threshold for aligning function-call parameters for single line # functions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_same_func_call_params_thresh = 0 # number # The span for aligning variable definitions. # # 0: Don't align (default). align_var_def_span = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of variable definitions. # # 0: Part of the type 'void * foo;' (default) # 1: Part of the variable 'void *foo;' # 2: Dangling 'void *foo;' # Dangling: the '*' will not be taken into account when aligning. align_var_def_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of variable definitions. # # 0: Part of the type 'long & foo;' (default) # 1: Part of the variable 'long &foo;' # 2: Dangling 'long &foo;' # Dangling: the '&' will not be taken into account when aligning. align_var_def_amp_style = 0 # unsigned number # The threshold for aligning variable definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_def_thresh = 0 # number # The gap for aligning variable definitions. align_var_def_gap = 0 # unsigned number # Whether to align the colon in struct bit fields. align_var_def_colon = false # true/false # The gap for aligning the colon in struct bit fields. align_var_def_colon_gap = 0 # unsigned number # Whether to align any attribute after the variable name. align_var_def_attribute = false # true/false # Whether to align inline struct/enum/union variable definitions. align_var_def_inline = false # true/false # The span for aligning on '=' in assignments. # # 0: Don't align (default). align_assign_span = 0 # unsigned number # The span for aligning on '=' in function prototype modifier. # # 0: Don't align (default). align_assign_func_proto_span = 0 # unsigned number # The threshold for aligning on '=' in assignments. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_assign_thresh = 0 # number # Whether to align on the left most assignment when multiple # definitions are found on the same line. # Depends on 'align_assign_span' and 'align_assign_thresh' settings. align_assign_on_multi_var_defs = false # true/false # The span for aligning on '{' in braced init list. # # 0: Don't align (default). align_braced_init_list_span = 0 # unsigned number # The threshold for aligning on '{' in braced init list. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_braced_init_list_thresh = 0 # number # How to apply align_assign_span to function declaration "assignments", i.e. # 'virtual void foo() = 0' or '~foo() = {default|delete}'. # # 0: Align with other assignments (default) # 1: Align with each other, ignoring regular assignments # 2: Don't align align_assign_decl_func = 0 # unsigned number # The span for aligning on '=' in enums. # # 0: Don't align (default). align_enum_equ_span = 0 # unsigned number # The threshold for aligning on '=' in enums. # Use a negative number for absolute thresholds. # # 0: no limit (default). align_enum_equ_thresh = 0 # number # The span for aligning class member definitions. # # 0: Don't align (default). align_var_class_span = 0 # unsigned number # The threshold for aligning class member definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_class_thresh = 0 # number # The gap for aligning class member definitions. align_var_class_gap = 0 # unsigned number # The span for aligning struct/union member definitions. # # 0: Don't align (default). align_var_struct_span = 0 # unsigned number # The threshold for aligning struct/union member definitions. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_var_struct_thresh = 0 # number # The gap for aligning struct/union member definitions. align_var_struct_gap = 0 # unsigned number # The span for aligning struct initializer values. # # 0: Don't align (default). align_struct_init_span = 0 # unsigned number # The span for aligning single-line typedefs. # # 0: Don't align (default). align_typedef_span = 0 # unsigned number # The minimum space between the type and the synonym of a typedef. align_typedef_gap = 0 # unsigned number # How to align typedef'd functions with other typedefs. # # 0: Don't mix them at all (default) # 1: Align the open parenthesis with the types # 2: Align the function type name with the other type names align_typedef_func = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of typedefs. # # 0: Part of the typedef type, 'typedef int * pint;' (default) # 1: Part of type name: 'typedef int *pint;' # 2: Dangling: 'typedef int *pint;' # Dangling: the '*' will not be taken into account when aligning. align_typedef_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of typedefs. # # 0: Part of the typedef type, 'typedef int & intref;' (default) # 1: Part of type name: 'typedef int &intref;' # 2: Dangling: 'typedef int &intref;' # Dangling: the '&' will not be taken into account when aligning. align_typedef_amp_style = 0 # unsigned number # The span for aligning comments that end lines. # # 0: Don't align (default). align_right_cmt_span = 0 # unsigned number # Minimum number of columns between preceding text and a trailing comment in # order for the comment to qualify for being aligned. Must be non-zero to have # an effect. align_right_cmt_gap = 0 # unsigned number # If aligning comments, whether to mix with comments after '}' and #endif with # less than three spaces before the comment. align_right_cmt_mix = false # true/false # Whether to only align trailing comments that are at the same brace level. align_right_cmt_same_level = false # true/false # Minimum column at which to align trailing comments. Comments which are # aligned beyond this column, but which can be aligned in a lesser column, # may be "pulled in". # # 0: Ignore (default). align_right_cmt_at_col = 0 # unsigned number # The span for aligning function prototypes. # # 0: Don't align (default). align_func_proto_span = 0 # unsigned number # How to consider (or treat) the '*' in the alignment of function prototypes. # # 0: Part of the type 'void * foo();' (default) # 1: Part of the function 'void *foo();' # 2: Dangling 'void *foo();' # Dangling: the '*' will not be taken into account when aligning. align_func_proto_star_style = 0 # unsigned number # How to consider (or treat) the '&' in the alignment of function prototypes. # # 0: Part of the type 'long & foo();' (default) # 1: Part of the function 'long &foo();' # 2: Dangling 'long &foo();' # Dangling: the '&' will not be taken into account when aligning. align_func_proto_amp_style = 0 # unsigned number # The threshold for aligning function prototypes. # Use a negative number for absolute thresholds. # # 0: No limit (default). align_func_proto_thresh = 0 # number # Minimum gap between the return type and the function name. align_func_proto_gap = 0 # unsigned number # Whether to align function prototypes on the 'operator' keyword instead of # what follows. align_on_operator = false # true/false # Whether to mix aligning prototype and variable declarations. If true, # align_var_def_XXX options are used instead of align_func_proto_XXX options. align_mix_var_proto = false # true/false # Whether to align single-line functions with function prototypes. # Uses align_func_proto_span. align_single_line_func = false # true/false # Whether to align the open brace of single-line functions. # Requires align_single_line_func=true. Uses align_func_proto_span. align_single_line_brace = false # true/false # Gap for align_single_line_brace. align_single_line_brace_gap = 0 # unsigned number # (OC) The span for aligning Objective-C message specifications. # # 0: Don't align (default). align_oc_msg_spec_span = 0 # unsigned number # Whether to align macros wrapped with a backslash and a newline. This will # not work right if the macro contains a multi-line comment. align_nl_cont = false # true/false # Whether to align macro functions and variables together. align_pp_define_together = false # true/false # The span for aligning on '#define' bodies. # # =0: Don't align (default) # >0: Number of lines (including comments) between blocks align_pp_define_span = 0 # unsigned number # The minimum space between label and value of a preprocessor define. align_pp_define_gap = 0 # unsigned number # Whether to align lines that start with '<<' with previous '<<'. # # Default: true align_left_shift = true # true/false # Whether to align comma-separated statements following '<<' (as used to # initialize Eigen matrices). align_eigen_comma_init = false # true/false # Whether to align text after 'asm volatile ()' colons. align_asm_colon = false # true/false # (OC) Span for aligning parameters in an Objective-C message call # on the ':'. # # 0: Don't align. align_oc_msg_colon_span = 0 # unsigned number # (OC) Whether to always align with the first parameter, even if it is too # short. align_oc_msg_colon_first = false # true/false # (OC) Whether to align parameters in an Objective-C '+' or '-' declaration # on the ':'. align_oc_decl_colon = false # true/false # (OC) Whether to not align parameters in an Objectve-C message call if first # colon is not on next line of the message call (the same way Xcode does # alignment) align_oc_msg_colon_xcode_like = false # true/false # # Comment modification options # # Try to wrap comments at N columns. cmt_width = 0 # unsigned number # How to reflow comments. # # 0: No reflowing (apart from the line wrapping due to cmt_width) (default) # 1: No touching at all # 2: Full reflow (enable cmt_indent_multi for indent with line wrapping due to cmt_width) cmt_reflow_mode = 0 # unsigned number # Path to a file that contains regular expressions describing patterns for # which the end of one line and the beginning of the next will be folded into # the same sentence or paragraph during full comment reflow. The regular # expressions are described using ECMAScript syntax. The syntax for this # specification is as follows, where "..." indicates the custom regular # expression and "n" indicates the nth end_of_prev_line_regex and # beg_of_next_line_regex regular expression pair: # # end_of_prev_line_regex[1] = "...$" # beg_of_next_line_regex[1] = "^..." # end_of_prev_line_regex[2] = "...$" # beg_of_next_line_regex[2] = "^..." # . # . # . # end_of_prev_line_regex[n] = "...$" # beg_of_next_line_regex[n] = "^..." # # Note that use of this option overrides the default reflow fold regular # expressions, which are internally defined as follows: # # end_of_prev_line_regex[1] = "[\w,\]\)]$" # beg_of_next_line_regex[1] = "^[\w,\[\(]" # end_of_prev_line_regex[2] = "\.$" # beg_of_next_line_regex[2] = "^[A-Z]" cmt_reflow_fold_regex_file = "" # string # Whether to indent wrapped lines to the start of the encompassing paragraph # during full comment reflow (cmt_reflow_mode = 2). Overrides the value # specified by cmt_sp_after_star_cont. # # Note that cmt_align_doxygen_javadoc_tags overrides this option for # paragraphs associated with javadoc tags cmt_reflow_indent_to_paragraph_start = false # true/false # Whether to convert all tabs to spaces in comments. If false, tabs in # comments are left alone, unless used for indenting. cmt_convert_tab_to_spaces = false # true/false # Whether to apply changes to multi-line comments, including cmt_width, # keyword substitution and leading chars. # # Default: true cmt_indent_multi = true # true/false # Whether to align doxygen javadoc-style tags ('@param', '@return', etc.) # and corresponding fields such that groups of consecutive block tags, # parameter names, and descriptions align with one another. Overrides that # which is specified by the cmt_sp_after_star_cont. If cmt_width > 0, it may # be necessary to enable cmt_indent_multi and set cmt_reflow_mode = 2 # in order to achieve the desired alignment for line-wrapping. cmt_align_doxygen_javadoc_tags = false # true/false # The number of spaces to insert after the star and before doxygen # javadoc-style tags (@param, @return, etc). Requires enabling # cmt_align_doxygen_javadoc_tags. Overrides that which is specified by the # cmt_sp_after_star_cont. # # Default: 1 cmt_sp_before_doxygen_javadoc_tags = 1 # unsigned number # Whether to change trailing, single-line c-comments into cpp-comments. cmt_trailing_single_line_c_to_cpp = false # true/false # Whether to group c-comments that look like they are in a block. cmt_c_group = false # true/false # Whether to put an empty '/*' on the first line of the combined c-comment. cmt_c_nl_start = false # true/false # Whether to add a newline before the closing '*/' of the combined c-comment. cmt_c_nl_end = false # true/false # Whether to change cpp-comments into c-comments. cmt_cpp_to_c = false # true/false # Whether to group cpp-comments that look like they are in a block. Only # meaningful if cmt_cpp_to_c=true. cmt_cpp_group = false # true/false # Whether to put an empty '/*' on the first line of the combined cpp-comment # when converting to a c-comment. # # Requires cmt_cpp_to_c=true and cmt_cpp_group=true. cmt_cpp_nl_start = false # true/false # Whether to add a newline before the closing '*/' of the combined cpp-comment # when converting to a c-comment. # # Requires cmt_cpp_to_c=true and cmt_cpp_group=true. cmt_cpp_nl_end = false # true/false # Whether to put a star on subsequent comment lines. cmt_star_cont = false # true/false # The number of spaces to insert at the start of subsequent comment lines. cmt_sp_before_star_cont = 0 # unsigned number # The number of spaces to insert after the star on subsequent comment lines. cmt_sp_after_star_cont = 0 # unsigned number # For multi-line comments with a '*' lead, remove leading spaces if the first # and last lines of the comment are the same length. # # Default: true cmt_multi_check_last = true # true/false # For multi-line comments with a '*' lead, remove leading spaces if the first # and last lines of the comment are the same length AND if the length is # bigger as the first_len minimum. # # Default: 4 cmt_multi_first_len_minimum = 4 # unsigned number # Path to a file that contains text to insert at the beginning of a file if # the file doesn't start with a C/C++ comment. If the inserted text contains # '$(filename)', that will be replaced with the current file's name. cmt_insert_file_header = "" # string # Path to a file that contains text to insert at the end of a file if the # file doesn't end with a C/C++ comment. If the inserted text contains # '$(filename)', that will be replaced with the current file's name. cmt_insert_file_footer = "" # string # Path to a file that contains text to insert before a function definition if # the function isn't preceded by a C/C++ comment. If the inserted text # contains '$(function)', '$(javaparam)' or '$(fclass)', these will be # replaced with, respectively, the name of the function, the javadoc '@param' # and '@return' stuff, or the name of the class to which the member function # belongs. cmt_insert_func_header = "" # string # Path to a file that contains text to insert before a class if the class # isn't preceded by a C/C++ comment. If the inserted text contains '$(class)', # that will be replaced with the class name. cmt_insert_class_header = "" # string # Path to a file that contains text to insert before an Objective-C message # specification, if the method isn't preceded by a C/C++ comment. If the # inserted text contains '$(message)' or '$(javaparam)', these will be # replaced with, respectively, the name of the function, or the javadoc # '@param' and '@return' stuff. cmt_insert_oc_msg_header = "" # string # Whether a comment should be inserted if a preprocessor is encountered when # stepping backwards from a function name. # # Applies to cmt_insert_oc_msg_header, cmt_insert_func_header and # cmt_insert_class_header. cmt_insert_before_preproc = false # true/false # Whether a comment should be inserted if a function is declared inline to a # class definition. # # Applies to cmt_insert_func_header. # # Default: true cmt_insert_before_inlines = true # true/false # Whether a comment should be inserted if the function is a class constructor # or destructor. # # Applies to cmt_insert_func_header. cmt_insert_before_ctor_dtor = false # true/false # # Code modifying options (non-whitespace) # # Add or remove braces on a single-line 'do' statement. mod_full_brace_do = ignore # ignore/add/remove/force/not_defined # Add or remove braces on a single-line 'for' statement. mod_full_brace_for = ignore # ignore/add/remove/force/not_defined # (Pawn) Add or remove braces on a single-line function definition. mod_full_brace_function = ignore # ignore/add/remove/force/not_defined # Add or remove braces on a single-line 'if' statement. Braces will not be # removed if the braced statement contains an 'else'. mod_full_brace_if = ignore # ignore/add/remove/force/not_defined # Whether to enforce that all blocks of an 'if'/'else if'/'else' chain either # have, or do not have, braces. Overrides mod_full_brace_if. # # 0: Don't override mod_full_brace_if # 1: Add braces to all blocks if any block needs braces and remove braces if # they can be removed from all blocks # 2: Add braces to all blocks if any block already has braces, regardless of # whether it needs them # 3: Add braces to all blocks if any block needs braces and remove braces if # they can be removed from all blocks, except if all blocks have braces # despite none needing them mod_full_brace_if_chain = 0 # unsigned number # Whether to add braces to all blocks of an 'if'/'else if'/'else' chain. # If true, mod_full_brace_if_chain will only remove braces from an 'if' that # does not have an 'else if' or 'else'. mod_full_brace_if_chain_only = false # true/false # Add or remove braces on single-line 'while' statement. mod_full_brace_while = ignore # ignore/add/remove/force/not_defined # Add or remove braces on single-line 'using ()' statement. mod_full_brace_using = ignore # ignore/add/remove/force/not_defined # Don't remove braces around statements that span N newlines mod_full_brace_nl = 0 # unsigned number # Whether to prevent removal of braces from 'if'/'for'/'while'/etc. blocks # which span multiple lines. # # Affects: # mod_full_brace_for # mod_full_brace_if # mod_full_brace_if_chain # mod_full_brace_if_chain_only # mod_full_brace_while # mod_full_brace_using # # Does not affect: # mod_full_brace_do # mod_full_brace_function mod_full_brace_nl_block_rem_mlcond = false # true/false # Add or remove unnecessary parentheses on 'return' statement. mod_paren_on_return = ignore # ignore/add/remove/force/not_defined # Add or remove unnecessary parentheses on 'throw' statement. mod_paren_on_throw = ignore # ignore/add/remove/force/not_defined # (Pawn) Whether to change optional semicolons to real semicolons. mod_pawn_semicolon = false # true/false # Whether to fully parenthesize Boolean expressions in 'while' and 'if' # statement, as in 'if (a && b > c)' => 'if (a && (b > c))'. mod_full_paren_if_bool = false # true/false # Whether to fully parenthesize Boolean expressions after '=' # statement, as in 'x = a && b > c;' => 'x = (a && (b > c));'. mod_full_paren_assign_bool = false # true/false # Whether to fully parenthesize Boolean expressions after '=' # statement, as in 'return a && b > c;' => 'return (a && (b > c));'. mod_full_paren_return_bool = false # true/false # Whether to remove superfluous semicolons. mod_remove_extra_semicolon = false # true/false # Whether to remove duplicate include. mod_remove_duplicate_include = false # true/false # If a function body exceeds the specified number of newlines and doesn't have # a comment after the close brace, a comment will be added. mod_add_long_function_closebrace_comment = 0 # unsigned number # If a namespace body exceeds the specified number of newlines and doesn't # have a comment after the close brace, a comment will be added. mod_add_long_namespace_closebrace_comment = 0 # unsigned number # If a class body exceeds the specified number of newlines and doesn't have a # comment after the close brace, a comment will be added. mod_add_long_class_closebrace_comment = 0 # unsigned number # If a switch body exceeds the specified number of newlines and doesn't have a # comment after the close brace, a comment will be added. mod_add_long_switch_closebrace_comment = 0 # unsigned number # If an #ifdef body exceeds the specified number of newlines and doesn't have # a comment after the #endif, a comment will be added. mod_add_long_ifdef_endif_comment = 0 # unsigned number # If an #ifdef or #else body exceeds the specified number of newlines and # doesn't have a comment after the #else, a comment will be added. mod_add_long_ifdef_else_comment = 0 # unsigned number # Whether to take care of the case by the mod_sort_xx options. mod_sort_case_sensitive = false # true/false # Whether to sort consecutive single-line 'import' statements. mod_sort_import = false # true/false # (C#) Whether to sort consecutive single-line 'using' statements. mod_sort_using = false # true/false # Whether to sort consecutive single-line '#include' statements (C/C++) and # '#import' statements (Objective-C). Be aware that this has the potential to # break your code if your includes/imports have ordering dependencies. mod_sort_include = false # true/false # Whether to prioritize '#include' and '#import' statements that contain # filename without extension when sorting is enabled. mod_sort_incl_import_prioritize_filename = false # true/false # Whether to prioritize '#include' and '#import' statements that does not # contain extensions when sorting is enabled. mod_sort_incl_import_prioritize_extensionless = false # true/false # Whether to prioritize '#include' and '#import' statements that contain # angle over quotes when sorting is enabled. mod_sort_incl_import_prioritize_angle_over_quotes = false # true/false # Whether to ignore file extension in '#include' and '#import' statements # for sorting comparison. mod_sort_incl_import_ignore_extension = false # true/false # Whether to group '#include' and '#import' statements when sorting is enabled. mod_sort_incl_import_grouping_enabled = false # true/false # Whether to move a 'break' that appears after a fully braced 'case' before # the close brace, as in 'case X: { ... } break;' => 'case X: { ... break; }'. mod_move_case_break = false # true/false # Whether to move a 'return' that appears after a fully braced 'case' before # the close brace, as in 'case X: { ... } return;' => 'case X: { ... return; }'. mod_move_case_return = false # true/false # Add or remove braces around a fully braced case statement. Will only remove # braces if there are no variable declarations in the block. mod_case_brace = ignore # ignore/add/remove/force/not_defined # Whether to remove a void 'return;' that appears as the last statement in a # function. mod_remove_empty_return = false # true/false # Add or remove the comma after the last value of an enumeration. mod_enum_last_comma = ignore # ignore/add/remove/force/not_defined # Syntax to use for infinite loops. # # 0: Leave syntax alone (default) # 1: Rewrite as `for(;;)` # 2: Rewrite as `while(true)` # 3: Rewrite as `do`...`while(true);` # 4: Rewrite as `while(1)` # 5: Rewrite as `do`...`while(1);` # # Infinite loops that do not already match one of these syntaxes are ignored. # Other options that affect loop formatting will be applied after transforming # the syntax. mod_infinite_loop = 0 # unsigned number # Add or remove the 'int' keyword in 'int short'. mod_int_short = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'short int'. mod_short_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int long'. mod_int_long = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'long int'. mod_long_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int signed'. mod_int_signed = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'signed int'. mod_signed_int = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'int unsigned'. mod_int_unsigned = ignore # ignore/add/remove/force/not_defined # Add or remove the 'int' keyword in 'unsigned int'. mod_unsigned_int = ignore # ignore/add/remove/force/not_defined # If there is a situation where mod_int_* and mod_*_int would result in # multiple int keywords, whether to keep the rightmost int (the default) or the # leftmost int. mod_int_prefer_int_on_left = false # true/false # (OC) Whether to organize the properties. If true, properties will be # rearranged according to the mod_sort_oc_property_*_weight factors. mod_sort_oc_properties = false # true/false # (OC) Weight of a class property modifier. mod_sort_oc_property_class_weight = 0 # number # (OC) Weight of 'atomic' and 'nonatomic'. mod_sort_oc_property_thread_safe_weight = 0 # number # (OC) Weight of 'readwrite' when organizing properties. mod_sort_oc_property_readwrite_weight = 0 # number # (OC) Weight of a reference type specifier ('retain', 'copy', 'assign', # 'weak', 'strong') when organizing properties. mod_sort_oc_property_reference_weight = 0 # number # (OC) Weight of getter type ('getter=') when organizing properties. mod_sort_oc_property_getter_weight = 0 # number # (OC) Weight of setter type ('setter=') when organizing properties. mod_sort_oc_property_setter_weight = 0 # number # (OC) Weight of nullability type ('nullable', 'nonnull', 'null_unspecified', # 'null_resettable') when organizing properties. mod_sort_oc_property_nullability_weight = 0 # number # # Preprocessor options # # How to use tabs when indenting preprocessor code. # # -1: Use 'indent_with_tabs' setting (default) # 0: Spaces only # 1: Indent with tabs to brace level, align with spaces # 2: Indent and align with tabs, using spaces when not on a tabstop # # Default: -1 pp_indent_with_tabs = -1 # number # Add or remove indentation of preprocessor directives inside #if blocks # at brace level 0 (file-level). pp_indent = ignore # ignore/add/remove/force/not_defined # Whether to indent #if/#else/#endif at the brace level. If false, these are # indented from column 1. pp_indent_at_level = false # true/false # Whether to indent #if/#else/#endif at the parenthesis level if the brace # level is 0. If false, these are indented from column 1. pp_indent_at_level0 = false # true/false # Specifies the number of columns to indent preprocessors per level # at brace level 0 (file-level). If pp_indent_at_level=false, also specifies # the number of columns to indent preprocessors per level # at brace level > 0 (function-level). # # Default: 1 pp_indent_count = 1 # unsigned number # Add or remove space after # based on pp level of #if blocks. pp_space_after = ignore # ignore/add/remove/force/not_defined # Sets the number of spaces per level added with pp_space_after. pp_space_count = 0 # unsigned number # The indent for '#region' and '#endregion' in C# and '#pragma region' in # C/C++. Negative values decrease indent down to the first column. pp_indent_region = 0 # number # Whether to indent the code between #region and #endregion. pp_region_indent_code = false # true/false # If pp_indent_at_level=true, sets the indent for #if, #else and #endif when # not at file-level. Negative values decrease indent down to the first column. # # =0: Indent preprocessors using output_tab_size # >0: Column at which all preprocessors will be indented pp_indent_if = 0 # number # Whether to indent the code between #if, #else and #endif. pp_if_indent_code = false # true/false # Whether to indent the body of an #if that encompasses all the code in the file. pp_indent_in_guard = false # true/false # Whether to indent '#define' at the brace level. If false, these are # indented from column 1. pp_define_at_level = false # true/false # Whether to indent '#include' at the brace level. pp_include_at_level = false # true/false # Whether to ignore the '#define' body while formatting. pp_ignore_define_body = false # true/false # An offset value that controls the indentation of the body of a multiline #define. # 'body' refers to all the lines of a multiline #define except the first line. # Requires 'pp_ignore_define_body = false'. # # <0: Absolute column: the body indentation starts off at the specified column # (ex. -3 ==> the body is indented starting from column 3) # >=0: Relative to the column of the '#' of '#define' # (ex. 3 ==> the body is indented starting 3 columns at the right of '#') # # Default: 8 pp_multiline_define_body_indent = 8 # number # Whether to indent case statements between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the case statements # directly inside of. # # Default: true pp_indent_case = true # true/false # Whether to indent whole function definitions between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the function definition # is directly inside of. # # Default: true pp_indent_func_def = true # true/false # Whether to indent extern C blocks between #if, #else, and #endif. # Only applies to the indent of the preprocessor that the extern block is # directly inside of. # # Default: true pp_indent_extern = true # true/false # How to indent braces directly inside #if, #else, and #endif. # Requires pp_if_indent_code=true and only applies to the indent of the # preprocessor that the braces are directly inside of. # 0: No extra indent # 1: Indent by one level # -1: Preserve original indentation # # Default: 1 pp_indent_brace = 1 # number # Whether to print warning messages for unbalanced #if and #else blocks. # This will print a message in the following cases: # - if an #ifdef block ends on a different indent level than # where it started from. Example: # # #ifdef TEST # int i; # { # int j; # #endif # # - an #elif/#else block ends on a different indent level than # the corresponding #ifdef block. Example: # # #ifdef TEST # int i; # #else # } # int j; # #endif pp_warn_unbalanced_if = false # true/false # # Sort includes options # # The regex for include category with priority 0. include_category_0 = "" # string # The regex for include category with priority 1. include_category_1 = "" # string # The regex for include category with priority 2. include_category_2 = "" # string # # Use or Do not Use options # # true: indent_func_call_param will be used (default) # false: indent_func_call_param will NOT be used # # Default: true use_indent_func_call_param = true # true/false # The value of the indentation for a continuation line is calculated # differently if the statement is: # - a declaration: your case with QString fileName ... # - an assignment: your case with pSettings = new QSettings( ... # # At the second case the indentation value might be used twice: # - at the assignment # - at the function call (if present) # # To prevent the double use of the indentation value, use this option with the # value 'true'. # # true: indent_continue will be used only once # false: indent_continue will be used every time (default) # # Requires indent_ignore_first_continue=false. use_indent_continue_only_once = false # true/false # The indentation can be: # - after the assignment, at the '[' character # - at the beginning of the lambda body # # true: indentation will be at the beginning of the lambda body # false: indentation will be after the assignment (default) indent_cpp_lambda_only_once = false # true/false # Whether sp_after_angle takes precedence over sp_inside_fparen. This was the # historic behavior, but is probably not the desired behavior, so this is off # by default. use_sp_after_angle_always = false # true/false # Whether to apply special formatting for Qt SIGNAL/SLOT macros. Essentially, # this tries to format these so that they match Qt's normalized form (i.e. the # result of QMetaObject::normalizedSignature), which can slightly improve the # performance of the QObject::connect call, rather than how they would # otherwise be formatted. # # See options_for_QT.cpp for details. # # Default: true use_options_overriding_for_qt_macros = true # true/false # If true: the form feed character is removed from the list of whitespace # characters. See https://en.cppreference.com/w/cpp/string/byte/isspace. use_form_feed_no_more_as_whitespace_character = false # true/false # # Warn levels - 1: error, 2: warning (default), 3: note # # (C#) Warning is given if doing tab-to-\t replacement and we have found one # in a C# verbatim string literal. # # Default: 2 warn_level_tabs_found_in_verbatim_string_literals = 2 # unsigned number # Limit the number of loops. # Used by uncrustify.cpp to exit from infinite loop. # 0: no limit. debug_max_number_of_loops = 0 # number # Set the number of the line to protocol; # Used in the function prot_the_line if the 2. parameter is zero. # 0: nothing protocol. debug_line_number_to_protocol = 0 # number # Set the number of second(s) before terminating formatting the current file, # 0: no timeout. # only for linux debug_timeout = 0 # number # Set the number of characters to be printed if the text is too long, # 0: do not truncate. debug_truncate = 0 # unsigned number # sort (or not) the tracking info. # # Default: true debug_sort_the_tracks = true # true/false # decode (or not) the flags as a new line. # only if the -p option is set. debug_decode_the_flags = false # true/false # insert the number of the line at the beginning of each line set_numbering_for_html_output = false # true/false # Meaning of the settings: # Ignore - do not do any changes # Add - makes sure there is 1 or more space/brace/newline/etc # Force - makes sure there is exactly 1 space/brace/newline/etc, # behaves like Add in some contexts # Remove - removes space/brace/newline/etc # # # - Token(s) can be treated as specific type(s) with the 'set' option: # `set tokenType tokenString [tokenString...]` # # Example: # `set BOOL __AND__ __OR__` # # tokenTypes are defined in src/token_enum.h, use them without the # 'CT_' prefix: 'CT_BOOL' => 'BOOL' # # # - Token(s) can be treated as type(s) with the 'type' option. # `type tokenString [tokenString...]` # # Example: # `type int c_uint_8 Rectangle` # # This can also be achieved with `set TYPE int c_uint_8 Rectangle` # # # To embed whitespace in tokenStrings use the '\' escape character, or quote # the tokenStrings. These quotes are supported: "'` # # # - Support for the auto detection of languages through the file ending can be # added using the 'file_ext' command. # `file_ext langType langString [langString..]` # # Example: # `file_ext CPP .ch .cxx .cpp.in` # # langTypes are defined in uncrusify_types.h in the lang_flag_e enum, use # them without the 'LANG_' prefix: 'LANG_CPP' => 'CPP' # # # - Custom macro-based indentation can be set up using 'macro-open', # 'macro-else' and 'macro-close'. # `(macro-open | macro-else | macro-close) tokenString` # # Example: # `macro-open BEGIN_TEMPLATE_MESSAGE_MAP` # `macro-open BEGIN_MESSAGE_MAP` # `macro-close END_MESSAGE_MAP` # # # option(s) with 'not default' value: 0 # uncrustify-uncrustify-0.76.0/etc/dofiles.sh000066400000000000000000000004031434072136500207660ustar00rootroot00000000000000#! /bin/sh if [ -z "$1" ]; then echo "specify the file that contains a list of files" exit fi files=$(cat $1) mkdir -p out for item in $files ; do dn=$(dirname $item) mkdir -p out/$dn src/uncrustify -f $item -c etc/ben.cfg > out/$item done uncrustify-uncrustify-0.76.0/etc/freebsd.cfg000066400000000000000000000443171434072136500211140ustar00rootroot00000000000000# Uncrustify 0.55 newlines = lf input_tab_size = 8 output_tab_size = 8 string_escape_char = 92 string_escape_char2 = 0 indent_columns = 8 indent_continue = 4 indent_with_tabs = 2 indent_align_string = false indent_xml_string = 0 indent_brace = 0 indent_braces = false indent_braces_no_func = false indent_brace_parent = false indent_namespace = false indent_namespace_level = 0 indent_namespace_limit = 0 indent_extern = false indent_class = true indent_class_colon = true indent_else_if = false indent_var_def_blk = 0 indent_func_call_param = false indent_func_def_param = false indent_func_proto_param = false indent_func_class_param = false indent_func_ctor_var_param = false indent_template_param = false indent_func_param_double = false indent_func_const = 0 indent_func_throw = 0 indent_member = 0 indent_single_line_comments_before = 0 indent_relative_single_line_comments = false indent_switch_case = 0 indent_case_shift = 0 indent_case_brace = 0 indent_col1_comment = false indent_label = 1 indent_access_spec = 1 indent_access_spec_body = false indent_paren_nl = false indent_paren_close = 0 indent_comma_paren = 0 indent_bool_paren = 0 indent_square_nl = false indent_preserve_sql = false indent_align_assign = true indent_off_after_assign = false sp_arith = ignore sp_assign = force sp_before_assign = ignore sp_after_assign = ignore sp_enum_assign = ignore sp_enum_before_assign = ignore sp_enum_after_assign = ignore sp_pp_concat = add sp_pp_stringify = add sp_bool = force sp_compare = force sp_inside_paren = remove sp_paren_paren = remove sp_balance_nested_parens = false sp_paren_brace = ignore sp_before_ptr_star = force sp_before_unnamed_ptr_star = ignore sp_between_ptr_star = remove sp_after_ptr_star = remove sp_after_ptr_star_func = ignore sp_before_ptr_star_func = ignore sp_before_byref = remove sp_before_unnamed_byref = ignore sp_after_byref = force sp_after_byref_func = ignore sp_before_byref_func = ignore sp_after_type = force sp_template_angle = ignore sp_before_angle = remove sp_inside_angle = remove sp_after_angle = force sp_angle_paren = ignore sp_angle_word = ignore sp_before_sparen = force sp_inside_sparen = remove sp_inside_sparen_close = ignore sp_inside_for = remove sp_inside_for_close = ignore sp_after_sparen = force sp_sparen_brace = add sp_invariant_paren = ignore sp_after_invariant_paren = ignore sp_special_semi = ignore sp_before_semi = remove sp_before_semi_for = ignore sp_before_semi_for_empty = force sp_between_semi_for_empty = force sp_after_semi = add sp_after_semi_for = force sp_after_semi_for_empty = ignore sp_before_square = ignore sp_before_squares = ignore sp_inside_square = remove sp_after_comma = force sp_before_comma = remove sp_before_ellipsis = ignore sp_after_class_colon = ignore sp_before_class_colon = ignore sp_before_case_colon = remove sp_after_operator = ignore sp_after_operator_sym = ignore sp_after_cast = remove sp_inside_paren_cast = ignore sp_cpp_cast_paren = ignore sp_sizeof_paren = remove sp_after_tag = ignore sp_inside_braces_enum = force sp_inside_braces_struct = force sp_inside_braces = force sp_inside_braces_empty = ignore sp_type_func = force sp_func_proto_paren = remove sp_func_def_paren = remove sp_inside_fparens = ignore sp_inside_fparen = remove sp_square_fparen = ignore sp_fparen_brace = add sp_func_call_paren = remove sp_func_call_user_paren = ignore sp_func_class_paren = remove sp_return_paren = force sp_attribute_paren = ignore sp_defined_paren = ignore sp_throw_paren = ignore sp_macro = ignore sp_macro_func = ignore sp_else_brace = ignore sp_brace_else = ignore sp_brace_typedef = force sp_catch_brace = ignore sp_brace_catch = ignore sp_finally_brace = ignore sp_brace_finally = ignore sp_try_brace = ignore sp_getset_brace = ignore sp_before_dc = remove sp_after_dc = remove sp_d_array_colon = ignore sp_not = remove sp_inv = remove sp_addr = remove sp_member = remove sp_deref = remove sp_sign = remove sp_incdec = remove sp_before_nl_cont = add sp_after_oc_scope = ignore sp_after_oc_colon = ignore sp_before_oc_colon = ignore sp_after_send_oc_colon = ignore sp_before_send_oc_colon = ignore sp_after_oc_type = ignore sp_after_oc_return_type = ignore sp_after_oc_at_sel = ignore sp_before_oc_block_caret = ignore sp_after_oc_block_caret = ignore sp_cond_colon = ignore sp_cond_question = ignore sp_case_label = remove sp_range = ignore sp_cmt_cpp_start = ignore sp_endif_cmt = ignore force_tab_after_define = true align_keep_tabs = false align_with_tabs = true align_on_tabstop = true align_number_right = true align_func_params = false align_same_func_call_params = false align_same_func_call_params_span = 0 align_same_func_call_params_thresh = 0 align_var_def_span = 0 align_var_def_star_style = 0 align_var_def_amp_style = 0 align_var_def_thresh = 0 align_var_def_gap = 0 align_var_def_colon = false align_var_def_attribute = false align_var_def_inline = false align_assign_span = 0 align_assign_thresh = 12 align_enum_equ_span = 16 align_enum_equ_thresh = 0 align_var_struct_span = 99 align_var_struct_thresh = 0 align_var_struct_gap = 0 align_struct_init_span = 3 align_typedef_gap = 3 align_typedef_span = 5 align_typedef_func = 0 align_typedef_star_style = 0 align_typedef_amp_style = 0 align_right_cmt_span = 3 align_right_cmt_mix = false align_right_cmt_gap = 0 align_right_cmt_at_col = 0 align_func_proto_span = 0 align_func_proto_gap = 0 align_on_operator = false align_mix_var_proto = false align_single_line_func = false align_single_line_brace = false align_single_line_brace_gap = 0 align_oc_msg_spec_span = 0 align_nl_cont = true align_pp_define_gap = 4 align_pp_define_span = 3 align_left_shift = true align_oc_msg_colon_span = 0 nl_collapse_empty_body = false nl_assign_leave_one_liners = true nl_class_leave_one_liners = true nl_enum_leave_one_liners = false nl_getset_leave_one_liners = false nl_func_leave_one_liners = false nl_if_leave_one_liners = false nl_start_of_file = remove nl_start_of_file_min = 0 nl_end_of_file = force nl_end_of_file_min = 1 nl_assign_brace = add nl_assign_square = ignore nl_after_square_assign = ignore nl_var_def_blk_end_func_top = 1 nl_fcall_brace = add nl_enum_brace = remove nl_struct_brace = remove nl_union_brace = remove nl_if_brace = remove nl_brace_else = remove nl_elseif_brace = ignore nl_else_brace = remove nl_else_if = remove nl_brace_finally = ignore nl_finally_brace = ignore nl_try_brace = ignore nl_getset_brace = force nl_for_brace = add nl_catch_brace = ignore nl_brace_catch = ignore nl_while_brace = add nl_brace_brace = ignore nl_do_brace = add nl_brace_while = remove nl_switch_brace = add nl_multi_line_cond = false nl_multi_line_define = true nl_before_case = true nl_before_throw = ignore nl_after_case = true nl_namespace_brace = ignore nl_template_class = ignore nl_class_brace = ignore nl_class_init_args = ignore nl_func_type_name = ignore nl_func_type_name_class = ignore nl_func_scope_name = ignore nl_func_proto_type_name = ignore nl_func_paren = remove nl_func_decl_start = ignore nl_func_decl_start_single = ignore nl_func_decl_args = ignore nl_func_decl_end = ignore nl_func_decl_end_single = ignore nl_func_decl_empty = ignore nl_fdef_brace = add nl_after_return = true nl_return_expr = ignore nl_after_semicolon = true nl_after_brace_open = true nl_after_brace_open_cmt = false nl_after_vbrace_open = false nl_after_vbrace_open_empty = false nl_after_brace_close = true nl_define_macro = false nl_squeeze_ifdef = true nl_before_if = ignore nl_after_if = ignore nl_before_for = ignore nl_after_for = ignore nl_before_while = ignore nl_after_while = ignore nl_before_switch = ignore nl_after_switch = ignore nl_before_do = ignore nl_after_do = ignore nl_ds_struct_enum_cmt = false nl_ds_struct_enum_close_brace = false nl_class_colon = ignore nl_create_if_one_liner = false nl_create_for_one_liner = false nl_create_while_one_liner = false pos_arith = ignore pos_assign = ignore pos_bool = trail pos_compare = ignore pos_conditional = ignore pos_comma = ignore pos_class_comma = ignore pos_class_colon = ignore code_width = 80 ls_for_split_full = false ls_func_split_full = false nl_max = 4 nl_after_func_proto = 0 nl_after_func_proto_group = 2 nl_after_func_body = 3 nl_after_func_body_one_liner = 0 nl_before_block_comment = 2 nl_before_c_comment = 0 nl_before_cpp_comment = 0 nl_after_multiline_comment = false nl_before_access_spec = 0 nl_after_access_spec = 0 nl_comment_func_def = 1 nl_after_try_catch_finally = 0 nl_around_cs_property = 0 nl_between_get_set = 0 eat_blanks_after_open_brace = true eat_blanks_before_close_brace = true mod_full_brace_do = add mod_full_brace_for = add mod_full_brace_function = ignore mod_full_brace_if = add mod_full_brace_if_chain = 0 mod_full_brace_nl = 0 mod_full_brace_while = add mod_paren_on_return = add mod_pawn_semicolon = false mod_full_paren_if_bool = true mod_remove_extra_semicolon = true mod_add_long_function_closebrace_comment = 0 mod_add_long_switch_closebrace_comment = 0 mod_add_long_ifdef_endif_comment = 0 mod_add_long_ifdef_else_comment = 0 mod_sort_import = false mod_sort_using = false mod_sort_include = false mod_sort_incl_import_prioritize_filename = false mod_sort_incl_import_prioritize_extensionless = false mod_sort_incl_import_prioritize_angle_over_quotes = false mod_sort_incl_import_ignore_extension = false mod_sort_incl_import_grouping_enabled = false mod_move_case_break = false mod_case_brace = remove mod_remove_empty_return = true cmt_width = 0 cmt_reflow_mode = 0 cmt_indent_multi = true cmt_c_group = false cmt_c_nl_start = false cmt_c_nl_end = false cmt_cpp_group = false cmt_cpp_nl_start = false cmt_cpp_nl_end = false cmt_cpp_to_c = false cmt_star_cont = true cmt_sp_before_star_cont = 0 cmt_sp_after_star_cont = 0 cmt_multi_check_last = true cmt_insert_file_header = "" cmt_insert_file_footer = "" cmt_insert_func_header = "" cmt_insert_class_header = "" cmt_insert_before_preproc = false pp_indent = remove pp_indent_at_level = false pp_indent_at_level0 = false pp_indent_count = 1 pp_space_after = ignore pp_space_count = 0 pp_indent_region = 0 pp_region_indent_code = false pp_indent_if = 0 pp_if_indent_code = false pp_define_at_level = false uncrustify-uncrustify-0.76.0/etc/gnu-indent.cfg000066400000000000000000000055661434072136500215550ustar00rootroot00000000000000# # GNU format (sorta) # indent_with_tabs = 0 # 1=indent to level only, 2=indent with tabs input_tab_size = 8 # original tab size output_tab_size = 8 # new tab size indent_columns = 2 # indent_label = 2 # pos: absolute col, neg: relative column indent_align_string = False # align broken strings indent_brace = 2 nl_enum_brace = remove # "enum {" vs "enum \n {" nl_union_brace = remove # "union {" vs "union \n {" nl_struct_brace = remove # "struct {" vs "struct \n {" nl_do_brace = add # "do {" vs "do \n {" nl_if_brace = add # "if () {" vs "if () \n {" nl_for_brace = add # "for () {" vs "for () \n {" nl_else_brace = add # "else {" vs "else \n {" nl_while_brace = add # "while () {" vs "while () \n {" nl_switch_brace = add # "switch () {" vs "switch () \n {" nl_var_def_blk_end_func_top = 1 nl_before_case = 1 nl_fcall_brace = add # "foo() {" vs "foo()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" # nl_after_return = TRUE nl_brace_while = remove nl_brace_else = add nl_squeeze_ifdef = TRUE # mod_paren_on_return = ignore # "return 1;" vs "return (1);" # mod_full_brace_if = ignore # "if (a) a--;" vs "if (a) { a--; }" # mod_full_brace_for = ignore # "for () a--;" vs "for () { a--; }" # mod_full_brace_do = ignore # "do a--; while ();" vs "do { a--; } while ();" # mod_full_brace_while = ignore # "while (a) a--;" vs "while (a) { a--; }" sp_before_semi = remove sp_paren_paren = remove # space between (( and )) sp_return_paren = remove # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = force # "{ 1 }" vs "{1}" sp_inside_braces_struct = force # "{ 1 }" vs "{1}" sp_inside_braces_enum = force # "{ 1 }" vs "{1}" sp_inside_paren = remove sp_inside_fparen = remove sp_inside_sparen = remove sp_inside_for = remove #sp_type_func = ignore sp_assign = force sp_arith = force sp_bool = force sp_compare = force sp_after_comma = force sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" # align_with_tabs = FALSE # use tabs to align # align_on_tabstop = FALSE # align on tabstops # align_enum_equ_span = 4 # align_nl_cont = TRUE # align_var_def_span = 2 # align_var_def_inline = TRUE # align_var_def_star = TRUE # align_var_def_colon = TRUE # align_assign_span = 1 # align_struct_init_span = 3 # align_var_struct_span = 3 # align_right_cmt_span = 3 # align_pp_define_span = 3 # align_pp_define_gap = 4 # align_number_right = TRUE # align_typedef_span = 5 # align_typedef_gap = 3 # cmt_star_cont = TRUE eat_blanks_before_close_brace = TRUE eat_blanks_after_open_brace = TRUE uncrustify-uncrustify-0.76.0/etc/klaus.cfg000066400000000000000000000447051434072136500206220ustar00rootroot00000000000000 # # General options # # The type of line endings newlines = lf # auto/lf/crlf/cr # The original size of tabs in the input input_tab_size = 8 # number # The size of tabs in the output (only used if align_with_tabs=true) output_tab_size = 3 # number # The ascii value of the string escape char, usually 92 (\). (Pawn) string_escape_char = 92 # number # # Indenting # # The number of columns to indent per level (usually 2, 3, 4, or 8) indent_columns = 3 # number # How to use tabs when indenting code # 0=spaces only # 1=indent with tabs, align with spaces # 2=indent and align with tabs indent_with_tabs = 0 # number # Whether to indent strings broken by '\' so that they line up indent_align_string = false # false/true # Spaces to indent '{' from level indent_brace = 0 # number # Whether braces are indented to the body level indent_braces = false # false/true # Indent based on the size of the brace parent, ie 'if' => 3 spaces, 'for' => 4 spaces, etc. indent_brace_parent = true # false/true # Whether the 'namespace' body is indented indent_namespace = false # false/true # Whether the 'class' body is indented indent_class = true # false/true # Whether to indent the stuff after a leading class colon indent_class_colon = false # false/true # Whether to indent continued function call parameters one indent level (true) or aligns instead of indent (false) indent_func_call_param = false # false/true # The number of spaces to indent a continued '->' or '.' # Usually set to indent_columns. indent_member = 3 # number # Spaces to indent 'case' from 'switch' indent_switch_case = 0 # number # Spaces to indent '{' from 'case' indent_case_brace = 0 # number # Whether to indent comments found in first column indent_col1_comment = false # false/true # How to indent goto labels (>0=absolute column where 1 is the leftmost column, <=0=subtract from brace indent) indent_label = 1 # number # If an open paren is followed by a newline, indent the next line so that it lines up after the open paren (not recommended) indent_paren_nl = false # false/true # If an open square is followed by a newline, indent the next line so that it lines up after the open square (not recommended) indent_square_nl = false # false/true # # Spacing options # # Add or remove space around arithmetic operator '+', '-', '/', '*', etc sp_arith = force # ignore/add/remove/force # Add or remove space around assignment operator '=', '+=', etc sp_assign = force # ignore/add/remove/force # Add or remove space around boolean operators '&&' and '||' sp_bool = force # ignore/add/remove/force # Add or remove space around compare operator '<', '>', '==', etc sp_compare = force # ignore/add/remove/force # Add or remove space inside '(' and ')' sp_inside_paren = remove # ignore/add/remove/force # Add or remove space between nested parens sp_paren_paren = remove # ignore/add/remove/force # Add or remove space between ')' and '{' sp_paren_brace = ignore # ignore/add/remove/force # Add or remove space before pointer star '*' sp_before_ptr_star = force # ignore/add/remove/force # Add or remove space between pointer stars '*' sp_between_ptr_star = remove # ignore/add/remove/force # Add or remove space after pointer star '*' sp_after_ptr_star = remove # ignore/add/remove/force # Add or remove space between the pointer star '*' and the name of the variable # in a function pointer definition. sp_ptr_star_func_var = remove # ignore/add/remove/force # Add or remove space before reference sign '&' sp_before_byref = remove # ignore/add/remove/force # Add or remove space after reference sign '&' sp_after_byref = ignore # ignore/add/remove/force # Add or remove space before '<>' sp_before_angle = force # ignore/add/remove/force # Add or remove space after '<>' sp_after_angle = force # ignore/add/remove/force # Add or remove space before '(' of 'if', 'for', 'switch', and 'while' sp_before_sparen = remove # ignore/add/remove/force # Add or remove space inside if-condition '(' and ')' sp_inside_sparen = remove # ignore/add/remove/force # Add or remove space inside for-loop '(' and ')' sp_inside_for = remove # ignore/add/remove/force # Add or remove space after ')' of 'if', 'for', 'switch', and 'while' sp_after_sparen = remove # ignore/add/remove/force # Add or remove space between ')' and '{' of 'if', 'for', 'switch', and 'while' sp_sparen_brace = remove # ignore/add/remove/force # Add or remove space before empty statement ';' on 'if', 'for' and 'while' sp_special_semi = ignore # ignore/add/remove/force # Add or remove space before ';' sp_before_semi = remove # ignore/add/remove/force # Add or remove space before '[' (except '[]') sp_before_square = ignore # ignore/add/remove/force # Add or remove space before '[]' sp_before_squares = ignore # ignore/add/remove/force # Add or remove space inside '[' and ']' sp_inside_square = remove # ignore/add/remove/force # Add or remove space after ',' sp_after_comma = force # ignore/add/remove/force # Add or remove space between 'operator' and operator sign sp_after_operator = ignore # ignore/add/remove/force # Add or remove space after cast sp_after_cast = remove # ignore/add/remove/force # Add or remove space between 'sizeof' and '(' sp_sizeof_paren = remove # ignore/add/remove/force # Add or remove space after the tag keyword (Pawn) sp_after_tag = ignore # ignore/add/remove/force # Add or remove space inside enum '{' and '}' sp_inside_braces_enum = force # ignore/add/remove/force # Add or remove space inside struct/union '{' and '}' sp_inside_braces_struct = force # ignore/add/remove/force # Add or remove space inside '{' and '}' sp_inside_braces = force # ignore/add/remove/force # Add or remove space inside '<' and '>' sp_inside_angle = remove # ignore/add/remove/force # Add or remove space between return type and function name (a minimum of 1 is forced except for pointer return types) sp_type_func = ignore # ignore/add/remove/force # Add or remove space between function name and '(' on function declaration sp_func_proto_paren = remove # ignore/add/remove/force # Add or remove space between function name and '(' on function definition sp_func_def_paren = remove # ignore/add/remove/force # Add or remove space inside empty function '()' sp_inside_fparens = ignore # ignore/add/remove/force # Add or remove space inside function '(' and ')' sp_inside_fparen = remove # ignore/add/remove/force # Add or remove space between ']' and '(' when part of a function call. sp_square_fparen = ignore # ignore/add/remove/force # Add or remove space between ')' and '{' of function sp_fparen_brace = add # ignore/add/remove/force # Add or remove space between function name and '(' on function calls sp_func_call_paren = remove # ignore/add/remove/force # Add or remove space between a constructor/destructor and the open paren sp_func_class_paren = remove # ignore/add/remove/force # Add or remove space between 'return' and '(' sp_return_paren = remove # ignore/add/remove/force # Add or remove space between macro and value sp_macro = ignore # ignore/add/remove/force # Add or remove space between macro function ')' and value sp_macro_func = ignore # ignore/add/remove/force # Add or remove space between 'else' and '{' if on the same line sp_else_brace = remove # ignore/add/remove/force # Add or remove space between '}' and 'else' if on the same line sp_brace_else = remove # ignore/add/remove/force # # Code alignment (not left column spaces/tabs) # # Whether to keep non-indenting tabs align_keep_tabs = false # false/true # Whether to use tabs for alinging align_with_tabs = false # false/true # Whether to bump out to the next tab when aligning align_on_tabstop = false # false/true # Whether to right-align numbers align_number_right = true # false/true # The span for aligning variable definitions (0=don't align) align_var_def_span = 1 # number # Whether the pointer star is part of the variable name or not align_var_def_star_style = 1 # The threshold for aligning variable definitions (0=no limit) align_var_def_thresh = 12 # number # Whether to align the colon in struct bit fields align_var_def_colon = true # false/true # Whether to align inline struct/enum/union variable definitions align_var_def_inline = true # false/true # The span for aligning on '=' in assignments (0=don't align) align_assign_span = 1 # number # The threshold for aligning on '=' in assignments (0=no limit) align_assign_thresh = 12 # number # The span for aligning on '=' in enums (0=don't align) align_enum_equ_span = 16 # number # The threshold for aligning on '=' in enums (0=no limit) align_enum_equ_thresh = 0 # number # The span for aligning struct/union (0=don't align) align_var_struct_span = 99 # number # The span for aligning struct initializer values (0=don't align) align_struct_init_span = 3 # number # The minimum space between the type and the synonym of a typedef align_typedef_gap = 3 # number # The span for aligning single-line typedefs (0=don't align) align_typedef_span = 5 # number # Controls the positioning of the '*' in typedefs. Just try it. # 0: Align on typdef type, ignore '*' # 1: The '*' is part of type name: typedef int *pint; # 2: The '*' is part of the type: typedef int * pint; align_typedef_star_style = 0 # number # The span for aligning comments that end lines (0=don't align) align_right_cmt_span = 3 # number # The span for aligning function prototypes (0=don't align) align_func_proto_span = 0 # number # Whether to align macros wrapped with a backslash and a newline align_nl_cont = true # false/true # The minimum space between label and value of a preprocessor define align_pp_define_gap = 4 # number # The span for aligning on '#define' bodies (0=don't align) align_pp_define_span = 3 # number # # Newline adding and removing options # # Try to limit code width to N number of columns code_width = 0 # number # Whether to collapse empty blocks between '{' and '}' nl_collapse_empty_body = false # false/true # Add or remove newlines at the start of the file nl_start_of_file = remove # ignore/add/remove/force # The number of newlines at the start of the file (only used if nl_start_of_file is 'add' or 'force' nl_start_of_file_min = 0 # number # Add or remove newline at the end of the file nl_end_of_file = force # ignore/add/remove/force # The number of newlines at the end of the file (only used if nl_end_of_file is 'add' or 'force') nl_end_of_file_min = 1 # number # Add or remove newline between '=' and '{' nl_assign_brace = add # ignore/add/remove/force # The number of newlines after a block of variable definitions nl_var_def_blk_end_func_top = 1 # number # Add or remove newline between function call and '(' nl_fcall_brace = add # ignore/add/remove/force # Add or remove newline between 'enum' and '{' nl_enum_brace = add # ignore/add/remove/force # Add or remove newline between 'struct and '{' nl_struct_brace = add # ignore/add/remove/force # Add or remove newline between 'union' and '{' nl_union_brace = add # ignore/add/remove/force # Add or remove newline between 'if' and '{' nl_if_brace = remove # ignore/add/remove/force # Add or remove newline between '}' and 'else' nl_brace_else = force # ignore/add/remove/force # Add or remove newline between 'else if' and '{' # If set to ignore, nl_if_brace is used instead nl_elseif_brace = ignore # ignore/add/remove/force # Add or remove newline between 'else' and '{' nl_else_brace = remove # ignore/add/remove/force # Add or remove newline between 'for' and '{' nl_for_brace = remove # ignore/add/remove/force # Add or remove newline between 'while' and '{' nl_while_brace = remove # ignore/add/remove/force # Add or remove newline between 'do' and '{' nl_do_brace = remove # ignore/add/remove/force # Add or remove newline between '}' and 'while' of 'do' statement nl_brace_while = remove # ignore/add/remove/force # Add or remove newline between 'switch' and '{' nl_switch_brace = remove # ignore/add/remove/force # Whether to put a newline before 'case' statement nl_before_case = true # false/true # Whether to put a newline after 'case' statement nl_after_case = true # false/true # Newline between namespace and { nl_namespace_brace = ignore # ignore/add/remove/force # Add or remove newline between 'template<>' and 'class' nl_template_class = ignore # ignore/add/remove/force # Add or remove newline between 'class' and '{' nl_class_brace = ignore # ignore/add/remove/force # Add or remove newline after each ',' in the constructor member initialization nl_class_init_args = ignore # ignore/add/remove/force # Add or remove newline between return type and function name in definition nl_func_type_name = ignore # ignore/add/remove/force # Add or remove newline after '(' in a function declaration nl_func_decl_start = ignore # ignore/add/remove/force # Add or remove newline after each ',' in a function declaration nl_func_decl_args = ignore # ignore/add/remove/force # Add or remove newline before the ')' in a function declaration nl_func_decl_end = ignore # ignore/add/remove/force # Add or remove newline between function signature and '{' nl_fdef_brace = add # ignore/add/remove/force # Whether to put a newline after 'return' statement nl_after_return = true # false/true # Whether to put a newline after semicolons, except in 'for' statements nl_after_semicolon = true # false/true # Whether to put a newline after brace open nl_after_brace_open = true # false/true # Whether to alter newlines in '#define' macros nl_define_macro = false # false/true # Whether to not put blanks after '#ifxx', '#elxx', or before '#endif' nl_squeeze_ifdef = true # false/true # # Positioning options # # The position of boolean operators in wrapped expressions pos_bool = trail # ignore/lead/trail # The position of colons between constructor and member initialization pos_class_colon = ignore # ignore/lead/trail # # Blank line options # # The maximum consecutive newlines nl_max = 4 # number # The number of newlines after a function prototype, if followed by another function prototype nl_after_func_proto = 0 # number # The number of newlines after a function prototype, if not followed by another function prototype nl_after_func_proto_group = 2 # number # The number of newlines after '}' of the function body nl_after_func_body = 2 # number # The minimum number of newlines before a multi-line comment (doesn't apply if after a brace open) nl_before_block_comment = 2 # number # Whether to remove blank lines after '{' eat_blanks_after_open_brace = true # false/true # Whether to remove blank lines before '}' eat_blanks_before_close_brace = true # false/true # # Code modifying options (non-whitespace) # # Add or remove braces on single-line 'do' statement mod_full_brace_do = add # ignore/add/remove/force # Add or remove braces on single-line 'for' statement mod_full_brace_for = add # ignore/add/remove/force # Add or remove braces on single-line function defintions. (Pawn) mod_full_brace_function = ignore # ignore/add/remove/force # Add or remove braces on single-line 'if' statement mod_full_brace_if = add # ignore/add/remove/force # Don't remove braces around statements that span N newlines mod_full_brace_nl = 0 # number # Add or remove braces on single-line 'while' statement mod_full_brace_while = add # ignore/add/remove/force # Add or remove unnecessary paren on 'return' statement mod_paren_on_return = add # ignore/add/remove/force # Whether to change optional semicolons to real semicolons mod_pawn_semicolon = false # false/true # # Comment modifications # # Whether to group cpp-comments that look like they are in a block cmt_cpp_group = false # false/true # Whether to put an empty '/*' on the first line of the combined cpp-comment cmt_cpp_nl_start = false # false/true # Whether to put a newline before the closing '*/' of the combined cpp-comment cmt_cpp_nl_end = false # false/true # Whether to change cpp-comments into c-comments cmt_cpp_to_c = false # false/true # Whether to put a star on subsequent comment lines cmt_star_cont = true # false/true # # Preprocessor options # # Add or remove indent of preprocessor directives pp_indent = ignore # ignore/add/remove/force # Add or remove space between # and, say, define pp_space_after = ignore # ignore/add/remove/force uncrustify-uncrustify-0.76.0/etc/kr-indent.cfg000066400000000000000000000060051434072136500213650ustar00rootroot00000000000000# # K&R (sort-of) # indent_with_tabs = 2 # 1=indent to level only, 2=indent with tabs input_tab_size = 8 # original tab size output_tab_size = 8 # new tab size indent_columns = output_tab_size indent_label = 2 # pos: absolute col, neg: relative column # indent_align_string = False # align broken strings # indent_brace = 0 nl_enum_brace = remove # "enum {" vs "enum \n {" nl_union_brace = remove # "union {" vs "union \n {" nl_struct_brace = remove # "struct {" vs "struct \n {" nl_do_brace = remove # "do {" vs "do \n {" nl_if_brace = remove # "if () {" vs "if () \n {" nl_for_brace = remove # "for () {" vs "for () \n {" nl_else_brace = remove # "else {" vs "else \n {" nl_while_brace = remove # "while () {" vs "while () \n {" nl_switch_brace = remove # "switch () {" vs "switch () \n {" # nl_var_def_blk_end_func_top = 1 # nl_before_case = 1 nl_fcall_brace = add # "foo() {" vs "foo()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" # nl_after_return = TRUE nl_brace_while = remove nl_brace_else = remove nl_squeeze_ifdef = TRUE # mod_paren_on_return = add # "return 1;" vs "return (1);" # mod_full_brace_if = add # "if (a) a--;" vs "if (a) { a--; }" # mod_full_brace_for = add # "for () a--;" vs "for () { a--; }" # mod_full_brace_do = add # "do a--; while ();" vs "do { a--; } while ();" # mod_full_brace_while = add # "while (a) a--;" vs "while (a) { a--; }" sp_before_semi = remove sp_paren_paren = remove # space between (( and )) sp_return_paren = remove # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = force # "{ 1 }" vs "{1}" sp_inside_braces_struct = force # "{ 1 }" vs "{1}" sp_inside_braces_enum = force # "{ 1 }" vs "{1}" sp_inside_paren = remove # "( 1 )" vs "(1)" sp_inside_fparen = remove # "( 1 )" vs "(1)" - functions sp_inside_sparen = remove # "( 1 )" vs "(1)" - if etc sp_inside_for = remove # "( 1 )" vs "(1)" - for # sp_type_func = ignore sp_assign = force sp_arith = force sp_bool = force sp_compare = force sp_after_comma = force sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" # align_with_tabs = FALSE # use tabs to align # align_on_tabstop = FALSE # align on tabstops # align_enum_equ_span = 4 # align_nl_cont = TRUE # align_var_def_span = 2 # align_var_def_inline = TRUE # align_var_def_star = TRUE # align_var_def_colon = TRUE # align_assign_span = 1 # align_struct_init_span = 3 # align_var_struct_span = 3 # align_right_cmt_span = 3 # align_pp_define_span = 3 # align_pp_define_gap = 4 # align_number_right = TRUE # align_typedef_span = 5 # align_typedef_gap = 3 # cmt_star_cont = TRUE eat_blanks_before_close_brace = TRUE eat_blanks_after_open_brace = TRUE uncrustify-uncrustify-0.76.0/etc/linux-indent.cfg000066400000000000000000000053351434072136500221150ustar00rootroot00000000000000# # uncrustify config file for the linux kernel # indent_with_tabs = 2 # 1=indent to level only, 2=indent with tabs align_with_tabs = TRUE # use tabs to align align_on_tabstop = TRUE # align on tabstops input_tab_size = 8 # original tab size output_tab_size = 8 # new tab size indent_columns = output_tab_size indent_label = 2 # pos: absolute col, neg: relative column # # inter-symbol newlines # nl_enum_brace = remove # "enum {" vs "enum \n {" nl_union_brace = remove # "union {" vs "union \n {" nl_struct_brace = remove # "struct {" vs "struct \n {" nl_do_brace = remove # "do {" vs "do \n {" nl_if_brace = remove # "if () {" vs "if () \n {" nl_for_brace = remove # "for () {" vs "for () \n {" nl_else_brace = remove # "else {" vs "else \n {" nl_while_brace = remove # "while () {" vs "while () \n {" nl_switch_brace = remove # "switch () {" vs "switch () \n {" nl_brace_while = remove # "} while" vs "} \n while" - cuddle while nl_brace_else = remove # "} else" vs "} \n else" - cuddle else nl_var_def_blk_end_func_top = 1 nl_fcall_brace = remove # "list_for_each() {" vs "list_for_each()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" # nl_after_return = TRUE; # nl_before_case = 1 # # Source code modifications # # mod_paren_on_return = remove # "return 1;" vs "return (1);" # mod_full_brace_if = remove # "if (a) a--;" vs "if (a) { a--; }" # mod_full_brace_for = remove # "for () a--;" vs "for () { a--; }" # mod_full_brace_do = remove # "do a--; while ();" vs "do { a--; } while ();" # mod_full_brace_while = remove # "while (a) a--;" vs "while (a) { a--; }" # # inter-character spacing options # # sp_return_paren = force # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = add # "{ 1 }" vs "{1}" sp_inside_braces_struct = add # "{ 1 }" vs "{1}" sp_inside_braces_enum = add # "{ 1 }" vs "{1}" sp_assign = add sp_arith = add sp_bool = add sp_compare = add sp_assign = add sp_after_comma = add sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" # # Aligning stuff # align_enum_equ_span = 4 # '=' in enum definition # align_nl_cont = TRUE # align_var_def_span = 2 # align_var_def_inline = TRUE # align_var_def_star = FALSE # align_var_def_colon = TRUE # align_assign_span = 1 align_struct_init_span = 3 # align stuff in a structure init '= { }' align_right_cmt_span = 3 # align_pp_define_span = 8; # align_pp_define_gap = 4; # cmt_star_cont = FALSE # indent_brace = 0 uncrustify-uncrustify-0.76.0/etc/linux.cfg000066400000000000000000000071571434072136500206420ustar00rootroot00000000000000# # uncrustify config file for the linux kernel # indent_with_tabs = 2 # 1=indent to level only, 2=indent with tabs input_tab_size = 8 # original tab size output_tab_size = 8 # new tab size indent_columns = output_tab_size indent_label = 1 # pos: absolute col, neg: relative column # # inter-symbol newlines # nl_enum_brace = remove # "enum {" vs "enum \n {" nl_union_brace = remove # "union {" vs "union \n {" nl_struct_brace = remove # "struct {" vs "struct \n {" nl_do_brace = remove # "do {" vs "do \n {" nl_if_brace = remove # "if () {" vs "if () \n {" nl_for_brace = remove # "for () {" vs "for () \n {" nl_else_brace = remove # "else {" vs "else \n {" nl_while_brace = remove # "while () {" vs "while () \n {" nl_switch_brace = remove # "switch () {" vs "switch () \n {" nl_brace_while = remove # "} while" vs "} \n while" - cuddle while nl_brace_else = remove # "} else" vs "} \n else" - cuddle else sp_brace_else = force sp_else_brace = force nl_var_def_blk_end_func_top = 1 nl_fcall_brace = remove # "list_for_each() {" vs "list_for_each()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" nl_after_label_colon = true # "fail:\nfree(foo);" vs "fail: free(foo);" # nl_after_return = TRUE; # nl_before_case = 1 # # Source code modifications # mod_paren_on_return = remove # "return 1;" vs "return (1);" #mod_full_brace_if = remove # "if (a) a--;" vs "if (a) { a--; }" mod_full_brace_if_chain = 1 mod_full_brace_for = remove # "for () a--;" vs "for () { a--; }" mod_full_brace_do = remove # "do a--; while ();" vs "do { a--; } while ();" mod_full_brace_while = remove # "while (a) a--;" vs "while (a) { a--; }" mod_full_brace_nl = 3 # don't remove if more than 3 newlines # # inter-character spacing options # sp_return_paren = force # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = force # "{ 1 }" vs "{1}" sp_inside_braces_struct = force # "{ 1 }" vs "{1}" sp_inside_braces_enum = force # "{ 1 }" vs "{1}" sp_assign = force sp_arith = force sp_bool = force sp_compare = force sp_assign = force sp_after_comma = force sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" # # Aligning stuff # align_with_tabs = TRUE # use tabs to align align_on_tabstop = TRUE # align on tabstops # align_keep_tabs = true align_enum_equ_span = 4 # '=' in enum definition # align_nl_cont = TRUE # align_var_def_span = 2 # align_var_def_inline = TRUE # align_var_def_star = FALSE # align_var_def_colon = TRUE # align_assign_span = 1 align_struct_init_span = 3 # align stuff in a structure init '= { }' align_right_cmt_span = 3 # align_pp_define_span = 8; # align_pp_define_gap = 4; cmt_star_cont = true # indent_brace = 0 nl_func_paren = remove nl_func_decl_start = remove nl_func_decl_empty = remove nl_func_decl_args = remove nl_func_decl_end = remove sp_inside_paren = remove sp_inside_square = remove sp_inside_paren_cast = remove sp_inside_fparen = remove sp_inside_sparen = remove sp_inside_for = remove sp_paren_paren = remove sp_before_ptr_star = force sp_after_ptr_star = remove sp_ptr_star_func_var = remove sp_between_ptr_star = remove align_func_params = true align_var_struct_span = 6 eat_blanks_after_open_brace = true eat_blanks_before_close_brace = true pp_indent = remove nl_start_of_file = remove nl_end_of_file = force nl_end_of_file_min = 1 nl_comment_func_def = 1 uncrustify-uncrustify-0.76.0/etc/mono.cfg000066400000000000000000000060051434072136500204420ustar00rootroot00000000000000# # Mono library format # indent_with_tabs = 0 # 1=indent to level only, 2=indent with tabs input_tab_size = 8 # original tab size output_tab_size = 8 # new tab size indent_columns = output_tab_size indent_label = 2 # pos: absolute col, neg: relative column # indent_align_string = False # align broken strings # indent_brace = 0 indent_func_call_param = true # use indent tabstop nl_enum_brace = remove # "enum {" vs "enum \n {" nl_union_brace = remove # "union {" vs "union \n {" nl_struct_brace = remove # "struct {" vs "struct \n {" nl_do_brace = remove # "do {" vs "do \n {" nl_if_brace = remove # "if () {" vs "if () \n {" nl_for_brace = remove # "for () {" vs "for () \n {" nl_else_brace = remove # "else {" vs "else \n {" nl_while_brace = remove # "while () {" vs "while () \n {" nl_switch_brace = remove # "switch () {" vs "switch () \n {" nl_var_def_blk_end_func_top = 1 nl_before_case = 1 nl_fcall_brace = remove # "foo() {" vs "foo()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" # nl_after_return = TRUE nl_brace_while = remove nl_brace_else = add nl_squeeze_ifdef = TRUE # mod_paren_on_return = add # "return 1;" vs "return (1);" # mod_full_brace_if = add # "if (a) a--;" vs "if (a) { a--; }" # mod_full_brace_for = add # "for () a--;" vs "for () { a--; }" # mod_full_brace_do = add # "do a--; while ();" vs "do { a--; } while ();" # mod_full_brace_while = add # "while (a) a--;" vs "while (a) { a--; }" sp_before_semi = remove sp_paren_paren = remove # space between (( and )) sp_return_paren = remove # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = force # "{ 1 }" vs "{1}" sp_inside_braces_struct = force # "{ 1 }" vs "{1}" sp_inside_braces_enum = force # "{ 1 }" vs "{1}" sp_inside_paren = remove sp_inside_fparen = remove sp_inside_sparen = remove sp_inside_for = remove sp_inside_square = remove sp_before_square = add #sp_type_func = ignore sp_assign = force sp_arith = force sp_bool = force sp_compare = force sp_assign = force sp_after_comma = force sp_func_def_paren = force # "int foo (){" vs "int foo(){" sp_func_call_paren = force # "foo (" vs "foo(" sp_func_proto_paren = force # "int foo ();" vs "int foo();" # align_with_tabs = FALSE # use tabs to align # align_on_tabstop = FALSE # align on tabstops # align_enum_equ_span = 4 # align_nl_cont = TRUE # align_var_def_span = 2 # align_var_def_inline = TRUE # align_var_def_star = TRUE # align_var_def_colon = TRUE # align_assign_span = 1 # align_struct_init_span = 3 # align_var_struct_span = 3 # align_right_cmt_span = 3 # align_pp_define_span = 3 # align_pp_define_gap = 4 # align_number_right = TRUE # align_typedef_span = 5 # align_typedef_gap = 3 cmt_star_cont = TRUE eat_blanks_before_close_brace = TRUE eat_blanks_after_open_brace = TRUE uncrustify-uncrustify-0.76.0/etc/msvc.cfg000066400000000000000000000002211434072136500204340ustar00rootroot00000000000000# bug 633 set COMMENT __stdcall set COMMENT __clrcall set COMMENT __fastcall set COMMENT __thiscall set COMMENT __vectorcall set COMMENT __cdecl uncrustify-uncrustify-0.76.0/etc/objc.cfg000066400000000000000000000125671434072136500204210ustar00rootroot00000000000000# # uncrustify config file for objective-c and objective-c++ # indent_with_tabs = 0 # 1=indent to level only, 2=indent with tabs output_tab_size = 4 # new tab size indent_columns = output_tab_size indent_label = 2 # pos: absolute col, neg: relative column indent_align_assign = FALSE # # Indenting # # indent_brace = 0 indent_switch_case = indent_columns # # Inter-symbol newlines # nl_enum_brace = remove # "enum {" vs "enum \n {" nl_union_brace = remove # "union {" vs "union \n {" nl_struct_brace = remove # "struct {" vs "struct \n {" nl_do_brace = remove # "do {" vs "do \n {" nl_if_brace = remove # "if () {" vs "if () \n {" nl_for_brace = remove # "for () {" vs "for () \n {" nl_else_brace = remove # "else {" vs "else \n {" nl_while_brace = remove # "while () {" vs "while () \n {" nl_switch_brace = remove # "switch () {" vs "switch () \n {" nl_brace_while = remove # "} while" vs "} \n while" - cuddle while nl_brace_else = remove # "} else" vs "} \n else" - cuddle else nl_var_def_blk_end_func_top = 1 nl_fcall_brace = remove # "list_for_each() {" vs "list_for_each()\n{" nl_fdef_brace = remove # "int foo() {" vs "int foo()\n{" # nl_after_return = TRUE; # nl_before_case = 1 # # Source code modifications # mod_paren_on_return = ignore # "return 1;" vs "return (1);" mod_full_brace_if = ignore # "if (a) a--;" vs "if (a) { a--; }" mod_full_brace_for = add # "for () a--;" vs "for () { a--; }" mod_full_brace_do = ignore # "do a--; while ();" vs "do { a--; } while ();" mod_full_brace_while = remove # "while (a) a--;" vs "while (a) { a--; }" mod_full_brace_nl = 3 # don't remove if more than 3 newlines mod_add_long_ifdef_endif_comment = 20 mod_add_long_ifdef_else_comment = mod_add_long_ifdef_endif_comment mod_add_long_switch_closebrace_comment = mod_add_long_ifdef_endif_comment mod_add_long_function_closebrace_comment = mod_add_long_ifdef_endif_comment # # Inter-character spacing options # # sp_return_paren = force # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = add # "{ 1 }" vs "{1}" sp_inside_braces_struct = add # "{ 1 }" vs "{1}" sp_inside_braces_enum = add # "{ 1 }" vs "{1}" sp_inside_fparen = remove # "func( param )" vs "func(param)" sp_paren_brace = force sp_assign = add sp_arith = add sp_bool = add sp_compare = add sp_after_comma = add sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" sp_before_ptr_star = force sp_after_ptr_star = force sp_before_unnamed_ptr_star = ignore sp_between_ptr_star = remove sp_after_ptr_star_func = force sp_before_ptr_star_func = force sp_cmt_cpp_start = add sp_cond_question = force sp_cond_colon = force sp_else_brace = force sp_brace_else = force sp_after_class_colon = force sp_before_class_colon = force sp_before_case_colon = remove # Objective-C specifics sp_before_oc_colon = remove sp_after_oc_colon = remove sp_after_oc_scope = force sp_after_oc_type = remove sp_after_oc_return_type = force sp_before_send_oc_colon = remove sp_after_send_oc_colon = remove sp_after_oc_at_sel = remove sp_before_oc_block_caret = ignore sp_after_oc_block_caret = remove # # Aligning stuff # align_with_tabs = False # use tabs to align align_on_tabstop = False # align on tabstops # align_keep_tabs = True align_enum_equ_span = 4 # '=' in enum definition # align_nl_cont = True # align_var_def_span = 2 # align_var_def_inline = True # align_var_def_star = False # align_var_def_colon = True # align_assign_span = 1 align_struct_init_span = 4 # align stuff in a structure init '= { }' align_right_cmt_span = 8 align_right_cmt_gap = 8 align_pp_define_span = 8 #align_pp_define_gap = 8 align_oc_msg_colon_span = 1 # align parameters in an Obj-C message on the ':' but stop after this many lines (0=don't align) align_oc_msg_spec_span = 0 # the span for aligning ObjC msg spec (0=don't align) # # Line Splitting options # # ls_func_split_full = True # Whether to fully split long function protos/calls at commas # # Comment modifications # cmt_star_cont = True # Whether to put a star on subsequent comment lines uncrustify-uncrustify-0.76.0/etc/sun.cfg000066400000000000000000002422631434072136500203070ustar00rootroot00000000000000# # Sun C/C++/Java # https://www.cis.upenn.edu/~lee/06cse480/data/cstyle.ms.pdf # http://www.oracle.com/technetwork/java/codeconventions-150003.pdf # # The type of line endings newlines = auto # auto/lf/crlf/cr # The original size of tabs in the input input_tab_size = 8 # number # The size of tabs in the output (only used if align_with_tabs=true) output_tab_size = 8 # number # The ASCII value of the string escape char, usually 92 (\) or 94 (^). (Pawn) string_escape_char = 92 # number # Alternate string escape char for Pawn. Only works right before the quote char. string_escape_char2 = 0 # number # Replace tab characters found in string literals with the escape sequence \t instead. string_replace_tab_chars = true # false/true # Allow interpreting '>=' and '>>=' as part of a template in 'void f(list>=val);'. # If true (default), 'assert(x<0 && y>=3)' will be broken. # Improvements to template detection may make this option obsolete. tok_split_gte = false # false/true # Override the default ' *INDENT-OFF*' in comments for disabling processing of part of the file. disable_processing_cmt = "" # string # Override the default ' *INDENT-ON*' in comments for enabling processing of part of the file. enable_processing_cmt = "" # string # Enable parsing of digraphs. Default=false enable_digraphs = false # false/true # If the file contains bytes with values between 128 and 255, but is not UTF-8, then output as UTF-8 utf8_byte = false # false/true # Force the output encoding to UTF-8 utf8_force = false # false/true # # Indenting # # The number of columns to indent per level. # Usually 2, 3, 4, or 8. indent_columns = 4 # number # The continuation indent. If non-zero, this overrides the indent of '(' and '=' continuation indents. # For FreeBSD, this is set to 4. Negative value is absolute and not increased for each ( level indent_continue = -4 # number # How to use tabs when indenting code # 0=spaces only # 1=indent with tabs to brace level, align with spaces # 2=indent and align with tabs, using spaces when not on a tabstop indent_with_tabs = 2 # number # Comments that are not a brace level are indented with tabs on a tabstop. # Requires indent_with_tabs=2. If false, will use spaces. indent_cmt_with_tabs = false # false/true # Whether to indent strings broken by '\' so that they line up indent_align_string = false # false/true # The number of spaces to indent multi-line XML strings. # Requires indent_align_string=True indent_xml_string = 2 # number # Spaces to indent '{' from level indent_brace = 0 # number # Whether braces are indented to the body level indent_braces = false # false/true # Disabled indenting function braces if indent_braces is true indent_braces_no_func = false # false/true # Disabled indenting class braces if indent_braces is true indent_braces_no_class = false # false/true # Disabled indenting struct braces if indent_braces is true indent_braces_no_struct = false # false/true # Indent based on the size of the brace parent, i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc. indent_brace_parent = false # false/true # Indent based on the paren open instead of the brace open in '({\n', default is to indent by brace. indent_paren_open_brace = false # false/true # Whether the 'namespace' body is indented indent_namespace = false # false/true # Only indent one namespace and no sub-namespaces. # Requires indent_namespace=true. indent_namespace_single_indent = false # false/true # The number of spaces to indent a namespace block indent_namespace_level = 0 # number # If the body of the namespace is longer than this number, it won't be indented. # Requires indent_namespace=true. Default=0 (no limit) indent_namespace_limit = 0 # number # Whether the 'extern "C"' body is indented indent_extern = false # false/true # Whether the 'class' body is indented indent_class = true # false/true # Whether to indent the stuff after a leading base class colon indent_class_colon = false # false/true # Indent based on a class colon instead of the stuff after the colon. # Requires indent_class_colon=true. Default=false indent_class_on_colon = false # false/true # Whether to indent the stuff after a leading class initializer colon indent_constr_colon = false # false/true # Virtual indent from the ':' for member initializers. Default is 2 indent_ctor_init_leading = 0 # number # Additional indenting for constructor initializer list indent_ctor_init = 0 # number # False=treat 'else\nif' as 'else if' for indenting purposes # True=indent the 'if' one level indent_else_if = false # false/true # Amount to indent variable declarations after a open brace. neg=relative, pos=absolute indent_var_def_blk = 0 # number # Indent continued variable declarations instead of aligning. indent_var_def_cont = true # false/true # How to indent continued shift expressions ('<<' and '>>'). # Set align_left_shift=false when using this. # 0: Align shift operators instead of indenting them (default) # 1: Indent by one level # -1: Preserve original indentation indent_shift = 0 # number # True: force indentation of function definition to start in column 1 # False: use the default behavior indent_func_def_force_col1 = false # false/true # True: indent continued function call parameters one indent level # False: align parameters under the open paren indent_func_call_param = true # false/true # Same as indent_func_call_param, but for function defs indent_func_def_param = true # false/true # Same as indent_func_call_param, but for function protos indent_func_proto_param = true # false/true # Same as indent_func_call_param, but for class declarations indent_func_class_param = true # false/true # Same as indent_func_call_param, but for class variable constructors indent_func_ctor_var_param = true # false/true # Same as indent_func_call_param, but for templates indent_template_param = true # false/true # Double the indent for indent_func_xxx_param options indent_func_param_double = false # false/true # Indentation column for standalone 'const' function decl/proto qualifier indent_func_const = 0 # number # Indentation column for standalone 'throw' function decl/proto qualifier indent_func_throw = 0 # number # The number of spaces to indent a continued '->' or '.' # Usually set to 0, 1, or indent_columns. indent_member = 4 # number # Spaces to indent single line ('//') comments on lines before code indent_single_line_comments_before = 0 # number # If set, will indent trailing single line ('//') comments relative # to the code instead of trying to keep the same absolute column indent_relative_single_line_comments = false # false/true # Spaces to indent 'case' from 'switch' # Usually 0 or indent_columns. indent_switch_case = 0 # number # Spaces to shift the 'case' line, without affecting any other lines # Usually 0. indent_case_shift = 0 # number # Spaces to indent '{' from 'case'. # By default, the brace will appear under the 'c' in case. # Usually set to 0 or indent_columns. indent_case_brace = 0 # number # Whether to indent comments found in first column indent_col1_comment = false # false/true # How to indent goto labels # >0: absolute column where 1 is the leftmost column # <=0: subtract from brace indent indent_label = -4 # number # Same as indent_label, but for access specifiers that are followed by a colon indent_access_spec = -4 # number # Indent the code after an access specifier by one level. # If set, this option forces 'indent_access_spec=0' indent_access_spec_body = false # false/true # If an open paren is followed by a newline, indent the next line so that it lines up after the open paren (not recommended) indent_paren_nl = false # false/true # Controls the indent of a close paren after a newline. # 0: Indent to body level # 1: Align under the open paren # 2: Indent to the brace level indent_paren_close = 0 # number # Controls the indent of a comma when inside a paren.If 1, aligns under the open paren indent_comma_paren = 0 # number # Controls the indent of a BOOL operator when inside a paren.If 1, aligns under the open paren indent_bool_paren = 0 # number # If 'indent_bool_paren' is 1, controls the indent of the first expression. If TRUE, aligns the first expression to the following ones indent_first_bool_expr = false # false/true # If an open square is followed by a newline, indent the next line so that it lines up after the open square (not recommended) indent_square_nl = false # false/true # Don't change the relative indent of ESQL/C 'EXEC SQL' bodies indent_preserve_sql = false # false/true # Align continued statements at the '='. Default=True # If FALSE or the '=' is followed by a newline, the next line is indent one tab. indent_align_assign = false # false/true # If true, the indentation of the chunks after a '=' sequence will be set at # LHS token indentation column before '='. indent_off_after_assign = false # true/false # Indent OC blocks at brace level instead of usual rules. indent_oc_block = false # false/true # Indent OC blocks in a message relative to the parameter name. # 0=use indent_oc_block rules, 1+=spaces to indent indent_oc_block_msg = 0 # number # Minimum indent for subsequent parameters indent_oc_msg_colon = 0 # number # If true, prioritize aligning with initial colon (and stripping spaces from lines, if necessary). # Default is true. indent_oc_msg_prioritize_first_colon = true # false/true # If indent_oc_block_msg and this option are on, blocks will be indented the way that Xcode does by default (from keyword if the parameter is on its own line; otherwise, from the previous indentation level). indent_oc_block_msg_xcode_style = false # false/true # If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is relative to a msg keyword. indent_oc_block_msg_from_keyword = false # false/true # If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is relative to a msg colon. indent_oc_block_msg_from_colon = false # false/true # If indent_oc_block_msg and this option are on, blocks will be indented from where the block caret is. indent_oc_block_msg_from_caret = false # false/true # If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is. indent_oc_block_msg_from_brace = false # false/true # When identing after virtual brace open and newline add further spaces to reach this min. indent. indent_min_vbrace_open = 0 # number # TRUE: When identing after virtual brace open and newline add further spaces after regular indent to reach next tabstop. indent_vbrace_open_on_tabstop = false # false/true # # Spacing options # # Add or remove space around arithmetic operator '+', '-', '/', '*', etc # also '>>>' '<<' '>>' '%' '|' sp_arith = force # ignore/add/remove/force # Add or remove space around assignment operator '=', '+=', etc sp_assign = force # ignore/add/remove/force # Add or remove space around '=' in C++11 lambda capture specifications. Overrides sp_assign sp_cpp_lambda_assign = force # ignore/add/remove/force # Add or remove space around assignment operator '=' in a prototype sp_assign_default = force # ignore/add/remove/force # Add or remove space before assignment operator '=', '+=', etc. Overrides sp_assign. sp_before_assign = force # ignore/add/remove/force # Add or remove space after assignment operator '=', '+=', etc. Overrides sp_assign. sp_after_assign = force # ignore/add/remove/force # Add or remove space in 'NS_ENUM (' sp_enum_paren = force # ignore/add/remove/force # Add or remove space around assignment '=' in enum sp_enum_assign = force # ignore/add/remove/force # Add or remove space before assignment '=' in enum. Overrides sp_enum_assign. sp_enum_before_assign = force # ignore/add/remove/force # Add or remove space after assignment '=' in enum. Overrides sp_enum_assign. sp_enum_after_assign = force # ignore/add/remove/force # Add or remove space around preprocessor '##' concatenation operator. Default=Add sp_pp_concat = force # ignore/add/remove/force # Add or remove space after preprocessor '#' stringify operator. Also affects the '#@' charizing operator. sp_pp_stringify = force # ignore/add/remove/force # Add or remove space before preprocessor '#' stringify operator as in '#define x(y) L#y'. sp_before_pp_stringify = force # ignore/add/remove/force # Add or remove space around boolean operators '&&' and '||' sp_bool = force # ignore/add/remove/force # Add or remove space around compare operator '<', '>', '==', etc sp_compare = force # ignore/add/remove/force # Add or remove space inside '(' and ')' sp_inside_paren = remove # ignore/add/remove/force # Add or remove space between nested parens: '((' vs ') )' sp_paren_paren = remove # ignore/add/remove/force # Add or remove space between back-to-back parens: ')(' vs ') (' sp_cparen_oparen = remove # ignore/add/remove/force # Whether to balance spaces inside nested parens sp_balance_nested_parens = false # false/true # Add or remove space between ')' and '{' sp_paren_brace = force # ignore/add/remove/force # Add or remove space before pointer star '*' sp_before_ptr_star = force # ignore/add/remove/force # Add or remove space before pointer star '*' that isn't followed by a variable name # If set to 'ignore', sp_before_ptr_star is used instead. sp_before_unnamed_ptr_star = force # ignore/add/remove/force # Add or remove space between pointer stars '*' sp_between_ptr_star = remove # ignore/add/remove/force # Add or remove space after pointer star '*', if followed by a word. sp_after_ptr_star = remove # ignore/add/remove/force # Add or remove space after pointer star '*', if followed by a qualifier. sp_after_ptr_star_qualifier = force # ignore/add/remove/force # Add or remove space after a pointer star '*', if followed by a func proto/def. sp_after_ptr_star_func = remove # ignore/add/remove/force # Add or remove space between the pointer star '*' and the name of the variable # in a function pointer definition. sp_ptr_star_func_var = remove # ignore/add/remove/force/not_defined # Add or remove space after a pointer star '*', if followed by an open paren (function types). sp_ptr_star_paren = remove # ignore/add/remove/force # Add or remove space before a pointer star '*', if followed by a func proto/def. sp_before_ptr_star_func = force # ignore/add/remove/force # Add or remove space before a reference sign '&' sp_before_byref = force # ignore/add/remove/force # Add or remove space before a reference sign '&' that isn't followed by a variable name # If set to 'ignore', sp_before_byref is used instead. sp_before_unnamed_byref = force # ignore/add/remove/force # Add or remove space after reference sign '&', if followed by a word. sp_after_byref = remove # ignore/add/remove/force # Add or remove space after a reference sign '&', if followed by a func proto/def. sp_after_byref_func = remove # ignore/add/remove/force # Add or remove space before a reference sign '&', if followed by a func proto/def. sp_before_byref_func = force # ignore/add/remove/force # Add or remove space between type and word. Default=Force sp_after_type = force # ignore/add/remove/force # Add or remove space before the paren in the D constructs 'template Foo(' and 'class Foo('. sp_before_template_paren = remove # ignore/add/remove/force # Add or remove space in 'template <' vs 'template<'. # If set to ignore, sp_before_angle is used. sp_template_angle = remove # ignore/add/remove/force # Add or remove space before '<>' sp_before_angle = remove # ignore/add/remove/force # Add or remove space inside '<' and '>' sp_inside_angle = remove # ignore/add/remove/force # Add or remove space after '<>' sp_after_angle = force # ignore/add/remove/force # Add or remove space between '<>' and '(' as found in 'new List();' sp_angle_paren = remove # ignore/add/remove/force # Add or remove space between '<>' and a word as in 'List m;' or 'template static ...' sp_angle_word = force # ignore/add/remove/force # Add or remove space between '>' and '>' in '>>' (template stuff C++/C# only). Default=Add sp_angle_shift = force # ignore/add/remove/force # Permit removal of the space between '>>' in 'foo >' (C++11 only). Default=False # sp_angle_shift cannot remove the space without this option. sp_permit_cpp11_shift = false # false/true # Add or remove space before '(' of 'if', 'for', 'switch', 'while', etc. sp_before_sparen = force # ignore/add/remove/force # Add or remove space inside if-condition '(' and ')' sp_inside_sparen = remove # ignore/add/remove/force # Add or remove space before if-condition ')'. Overrides sp_inside_sparen. sp_inside_sparen_close = remove # ignore/add/remove/force # Add or remove space after if-condition '('. Overrides sp_inside_sparen. sp_inside_sparen_open = remove # ignore/add/remove/force # Add or remove space inside for-loop '(' and ')' sp_inside_for = remove # ignore/add/remove/force # Add or remove space before for-loop ')'. Overrides sp_inside_for. sp_inside_for_close = remove # ignore/add/remove/force # Add or remove space after for-loop '('. Overrides sp_inside_for. sp_inside_for_open = remove # ignore/add/remove/force # Add or remove space after ')' of 'if', 'for', 'switch', and 'while', etc. sp_after_sparen = force # ignore/add/remove/force # Add or remove space between ')' and '{' of 'if', 'for', 'switch', and 'while', etc. sp_sparen_brace = force # ignore/add/remove/force # Add or remove space between 'invariant' and '(' in the D language. sp_invariant_paren = remove # ignore/add/remove/force # Add or remove space after the ')' in 'invariant (C) c' in the D language. sp_after_invariant_paren = force # ignore/add/remove/force # Add or remove space before empty statement ';' on 'if', 'for' and 'while' sp_special_semi = remove # ignore/add/remove/force # Add or remove space before ';'. Default=Remove sp_before_semi = remove # ignore/add/remove/force # Add or remove space before ';' in non-empty 'for' statements sp_before_semi_for = remove # ignore/add/remove/force # Add or remove space before a semicolon of an empty left part of a for statement. sp_before_semi_for_empty = remove # ignore/add/remove/force # Add or remove space between the semicolons of an empty middle part of a for statement. sp_between_semi_for_empty = remove # ignore/add/remove/force/not_defined # Add or remove space after ';', except when followed by a comment. Default=Add sp_after_semi = force # ignore/add/remove/force # Add or remove space after ';' in non-empty 'for' statements. Default=Force sp_after_semi_for = force # ignore/add/remove/force # Add or remove space after the final semicolon of an empty part of a for statement: for ( ; ; ). sp_after_semi_for_empty = remove # ignore/add/remove/force # Add or remove space before '[' (except '[]') sp_before_square = remove # ignore/add/remove/force # Add or remove space before '[]' sp_before_squares = remove # ignore/add/remove/force # Add or remove space inside a non-empty '[' and ']' sp_inside_square = remove # ignore/add/remove/force # Add or remove space after ',' sp_after_comma = force # ignore/add/remove/force # Add or remove space before ',' sp_before_comma = remove # ignore/add/remove/force # Add or remove space between ',' and ']' in multidimensional array type 'int[,,]' sp_after_mdatype_commas = remove # ignore/add/remove/force # Add or remove space between '[' and ',' in multidimensional array type 'int[,,]' sp_before_mdatype_commas = remove # ignore/add/remove/force # Add or remove space between ',' in multidimensional array type 'int[,,]' sp_between_mdatype_commas = remove # ignore/add/remove/force # Add or remove space between an open paren and comma: '(,' vs '( ,' sp_paren_comma = force # ignore/add/remove/force # Add or remove space before the variadic '...' when preceded by a non-punctuator sp_before_ellipsis = force # ignore/add/remove/force # Add or remove space after class ':' sp_after_class_colon = force # ignore/add/remove/force # Add or remove space before class ':' sp_before_class_colon = remove # ignore/add/remove/force # Add or remove space after class constructor ':' sp_after_constr_colon = force # ignore/add/remove/force # Add or remove space before class constructor ':' sp_before_constr_colon = remove # ignore/add/remove/force # Add or remove space before case ':'. Default=Remove sp_before_case_colon = remove # ignore/add/remove/force # Add or remove space between 'operator' and operator sign sp_after_operator = force # ignore/add/remove/force # Add or remove space between the operator symbol and the open paren, as in 'operator ++(' sp_after_operator_sym = remove # ignore/add/remove/force # Add or remove space after C/D cast, i.e. 'cast(int)a' vs 'cast(int) a' or '(int)a' vs '(int) a' sp_after_cast = remove # ignore/add/remove/force # Add or remove spaces inside cast parens sp_inside_paren_cast = remove # ignore/add/remove/force # Add or remove space between the type and open paren in a C++ cast, i.e. 'int(exp)' vs 'int (exp)' sp_cpp_cast_paren = remove # ignore/add/remove/force # Add or remove space between 'sizeof' and '(' sp_sizeof_paren = force # ignore/add/remove/force # Add or remove space after the tag keyword (Pawn) sp_after_tag = force # ignore/add/remove/force # Add or remove space inside enum '{' and '}' sp_inside_braces_enum = force # ignore/add/remove/force # Add or remove space inside struct/union '{' and '}' sp_inside_braces_struct = force # ignore/add/remove/force # Add or remove space inside '{' and '}' sp_inside_braces = force # ignore/add/remove/force # Add or remove space inside '{}' sp_inside_braces_empty = remove # ignore/add/remove/force # Add or remove space between return type and function name # A minimum of 1 is forced except for pointer return types. sp_type_func = remove # ignore/add/remove/force # Add or remove space between function name and '(' on function declaration sp_func_proto_paren = remove # ignore/add/remove/force # Add or remove space between function name and '(' on function definition sp_func_def_paren = remove # ignore/add/remove/force # Add or remove space inside empty function '()' sp_inside_fparens = remove # ignore/add/remove/force # Add or remove space inside function '(' and ')' sp_inside_fparen = remove # ignore/add/remove/force # Add or remove space inside the first parens in the function type: 'void (*x)(...)' sp_inside_tparen = remove # ignore/add/remove/force # Add or remove between the parens in the function type: 'void (*x)(...)' sp_after_tparen_close = remove # ignore/add/remove/force # Add or remove space between ']' and '(' when part of a function call. sp_square_fparen = remove # ignore/add/remove/force # Add or remove space between ')' and '{' of function sp_fparen_brace = force # ignore/add/remove/force # Java: Add or remove space between ')' and '{{' of double brace initializer. sp_fparen_dbrace = force # ignore/add/remove/force # Add or remove space between function name and '(' on function calls sp_func_call_paren = remove # ignore/add/remove/force # Add or remove space between function name and '()' on function calls without parameters. # If set to 'ignore' (the default), sp_func_call_paren is used. sp_func_call_paren_empty = remove # ignore/add/remove/force # Add or remove space between the user function name and '(' on function calls # You need to set a keyword to be a user function, like this: 'set func_call_user _' in the config file. sp_func_call_user_paren = remove # ignore/add/remove/force # Add or remove space between a constructor/destructor and the open paren sp_func_class_paren = remove # ignore/add/remove/force # Add or remove space between 'return' and '(' sp_return_paren = force # ignore/add/remove/force # Add or remove space between '__attribute__' and '(' sp_attribute_paren = force # ignore/add/remove/force # Add or remove space between 'defined' and '(' in '#if defined (FOO)' sp_defined_paren = remove # ignore/add/remove/force # Add or remove space between 'throw' and '(' in 'throw (something)' sp_throw_paren = force # ignore/add/remove/force # Add or remove space between 'throw' and anything other than '(' as in '@throw [...];' sp_after_throw = force # ignore/add/remove/force # Add or remove space between 'catch' and '(' in 'catch (something) { }' # If set to ignore, sp_before_sparen is used. sp_catch_paren = force # ignore/add/remove/force # Add or remove space between 'version' and '(' in 'version (something) { }' (D language) # If set to ignore, sp_before_sparen is used. sp_version_paren = force # ignore/add/remove/force # Add or remove space between 'scope' and '(' in 'scope (something) { }' (D language) # If set to ignore, sp_before_sparen is used. sp_scope_paren = force # ignore/add/remove/force # Add or remove space between macro and value sp_macro = force # ignore/add/remove/force # Add or remove space between macro function ')' and value sp_macro_func = force # ignore/add/remove/force # Add or remove space between 'else' and '{' if on the same line sp_else_brace = force # ignore/add/remove/force # Add or remove space between '}' and 'else' if on the same line sp_brace_else = force # ignore/add/remove/force # Add or remove space between '}' and the name of a typedef on the same line sp_brace_typedef = force # ignore/add/remove/force # Add or remove space between 'catch' and '{' if on the same line sp_catch_brace = force # ignore/add/remove/force # Add or remove space between '}' and 'catch' if on the same line sp_brace_catch = force # ignore/add/remove/force # Add or remove space between 'finally' and '{' if on the same line sp_finally_brace = force # ignore/add/remove/force # Add or remove space between '}' and 'finally' if on the same line sp_brace_finally = force # ignore/add/remove/force # Add or remove space between 'try' and '{' if on the same line sp_try_brace = force # ignore/add/remove/force # Add or remove space between get/set and '{' if on the same line sp_getset_brace = force # ignore/add/remove/force # Add or remove space between type and open brace of an unnamed temporary # direct-list-initialization. sp_type_brace_init_lst = add # ignore/add/remove/force # Add or remove space between a variable and '{' for a namespace sp_word_brace_ns = force # ignore/add/remove/force # Add or remove space before the '::' operator sp_before_dc = remove # ignore/add/remove/force # Add or remove space after the '::' operator sp_after_dc = remove # ignore/add/remove/force # Add or remove around the D named array initializer ':' operator sp_d_array_colon = force # ignore/add/remove/force # Add or remove space after the '!' (not) operator. Default=Remove sp_not = remove # ignore/add/remove/force # Add or remove space after the '~' (invert) operator. Default=Remove sp_inv = remove # ignore/add/remove/force # Add or remove space after the '&' (address-of) operator. Default=Remove # This does not affect the spacing after a '&' that is part of a type. sp_addr = remove # ignore/add/remove/force # Add or remove space around the '.' or '->' operators. Default=Remove sp_member = remove # ignore/add/remove/force # Add or remove space after the '*' (dereference) operator. Default=Remove # This does not affect the spacing after a '*' that is part of a type. sp_deref = remove # ignore/add/remove/force # Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. Default=Remove sp_sign = remove # ignore/add/remove/force # Add or remove space before or after '++' and '--', as in '(--x)' or 'y++;'. Default=Remove sp_incdec = remove # ignore/add/remove/force # Add or remove space before a backslash-newline at the end of a line. Default=Add sp_before_nl_cont = force # ignore/add/remove/force # Add or remove space after the scope '+' or '-', as in '-(void) foo;' or '+(int) bar;' sp_after_oc_scope = remove # ignore/add/remove/force # Add or remove space after the colon in message specs # '-(int) f:(int) x;' vs '-(int) f: (int) x;' sp_after_oc_colon = force # ignore/add/remove/force # Add or remove space before the colon in message specs # '-(int) f: (int) x;' vs '-(int) f : (int) x;' sp_before_oc_colon = force # ignore/add/remove/force # Add or remove space after the colon in immutable dictionary expression # 'NSDictionary *test = @{@"foo" :@"bar"};' sp_after_oc_dict_colon = force # ignore/add/remove/force # Add or remove space before the colon in immutable dictionary expression # 'NSDictionary *test = @{@"foo" :@"bar"};' sp_before_oc_dict_colon = force # ignore/add/remove/force # Add or remove space after the colon in message specs # '[object setValue:1];' vs '[object setValue: 1];' sp_after_send_oc_colon = force # ignore/add/remove/force # Add or remove space before the colon in message specs # '[object setValue:1];' vs '[object setValue :1];' sp_before_send_oc_colon = remove # ignore/add/remove/force # Add or remove space after the (type) in message specs # '-(int)f: (int) x;' vs '-(int)f: (int)x;' sp_after_oc_type = remove # ignore/add/remove/force # Add or remove space after the first (type) in message specs # '-(int) f:(int)x;' vs '-(int)f:(int)x;' sp_after_oc_return_type = remove # ignore/add/remove/force # Add or remove space between '@selector' and '(' # '@selector(msgName)' vs '@selector (msgName)' # Also applies to @protocol() constructs sp_after_oc_at_sel = remove # ignore/add/remove/force # Add or remove space between '@selector(x)' and the following word # '@selector(foo) a:' vs '@selector(foo)a:' sp_after_oc_at_sel_parens = force # ignore/add/remove/force # Add or remove space inside '@selector' parens # '@selector(foo)' vs '@selector( foo )' # Also applies to @protocol() constructs sp_inside_oc_at_sel_parens = remove # ignore/add/remove/force # Add or remove space before a block pointer caret # '^int (int arg){...}' vs. ' ^int (int arg){...}' sp_before_oc_block_caret = remove # ignore/add/remove/force # Add or remove space after a block pointer caret # '^int (int arg){...}' vs. '^ int (int arg){...}' sp_after_oc_block_caret = remove # ignore/add/remove/force # Add or remove space between the receiver and selector in a message. # '[receiver selector ...]' sp_after_oc_msg_receiver = remove # ignore/add/remove/force # Add or remove space after @property. sp_after_oc_property = force # ignore/add/remove/force # Add or remove space around the ':' in 'b ? t : f' sp_cond_colon = force # ignore/add/remove/force # Add or remove space before the ':' in 'b ? t : f'. Overrides sp_cond_colon. sp_cond_colon_before = force # ignore/add/remove/force # Add or remove space after the ':' in 'b ? t : f'. Overrides sp_cond_colon. sp_cond_colon_after = force # ignore/add/remove/force # Add or remove space around the '?' in 'b ? t : f' sp_cond_question = force # ignore/add/remove/force # Add or remove space before the '?' in 'b ? t : f'. Overrides sp_cond_question. sp_cond_question_before = force # ignore/add/remove/force # Add or remove space after the '?' in 'b ? t : f'. Overrides sp_cond_question. sp_cond_question_after = force # ignore/add/remove/force # In the abbreviated ternary form (a ?: b), add/remove space between ? and :.'. Overrides all other sp_cond_* options. sp_cond_ternary_short = force # ignore/add/remove/force # Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make sense here. sp_case_label = force # ignore/add/remove/force # Control the space around the D '..' operator. sp_range = force # ignore/add/remove/force # Control the spacing after ':' in 'for (TYPE VAR : EXPR)' sp_after_for_colon = force # ignore/add/remove/force # Control the spacing before ':' in 'for (TYPE VAR : EXPR)' sp_before_for_colon = force # ignore/add/remove/force # Control the spacing in 'extern (C)' (D) sp_extern_paren = force # ignore/add/remove/force # Control the space after the opening of a C++ comment '// A' vs '//A' sp_cmt_cpp_start = force # ignore/add/remove/force # TRUE: If space is added with sp_cmt_cpp_start, do it after doxygen sequences like '///', '///<', '//!' and '//!<'. sp_cmt_cpp_doxygen = false # false/true # TRUE: If space is added with sp_cmt_cpp_start, do it after Qt translator or meta-data comments like '//:', '//=', and '//~'. sp_cmt_cpp_qttr = false # false/true # Controls the spaces between #else or #endif and a trailing comment sp_endif_cmt = force # ignore/add/remove/force # Controls the spaces after 'new', 'delete' and 'delete[]' sp_after_new = force # ignore/add/remove/force # Controls the spaces between new and '(' in 'new()' sp_between_new_paren = remove # ignore/add/remove/force # Controls the spaces before a trailing or embedded comment sp_before_tr_cmt = force # ignore/add/remove/force # Number of spaces before a trailing or embedded comment sp_num_before_tr_cmt = 0 # number # Control space between a Java annotation and the open paren. sp_annotation_paren = remove # ignore/add/remove/force # # Code alignment (not left column spaces/tabs) # # Whether to keep non-indenting tabs align_keep_tabs = false # false/true # Whether to use tabs for aligning align_with_tabs = true # false/true # Whether to bump out to the next tab when aligning align_on_tabstop = true # false/true # Whether to right-align numbers align_number_right = true # false/true # Whether to keep whitespace not required for alignment. align_keep_extra_space = false # false/true # Align variable definitions in prototypes and functions align_func_params = false # false/true # Align parameters in single-line functions that have the same name. # The function names must already be aligned with each other. align_same_func_call_params = false # false/true # The span for aligning parameters in single line functions with the same name (0=don't align). align_same_func_call_params_span = 0 # unsigned number # The thresh for aligning function call parameters (0=no limit). align_same_func_call_params_thresh = 0 # unsigned number # The span for aligning variable definitions (0=don't align) align_var_def_span = 0 # number # How to align the star in variable definitions. # 0=Part of the type 'void * foo;' # 1=Part of the variable 'void *foo;' # 2=Dangling 'void *foo;' align_var_def_star_style = 1 # number # How to align the '&' in variable definitions. # 0=Part of the type # 1=Part of the variable # 2=Dangling align_var_def_amp_style = 1 # number # The threshold for aligning variable definitions (0=no limit) align_var_def_thresh = 10 # number # The gap for aligning variable definitions align_var_def_gap = 0 # number # Whether to align the colon in struct bit fields align_var_def_colon = false # false/true # Whether to align any attribute after the variable name align_var_def_attribute = false # false/true # Whether to align inline struct/enum/union variable definitions align_var_def_inline = false # false/true # The span for aligning on '=' in assignments (0=don't align) align_assign_span = 0 # number # The threshold for aligning on '=' in assignments (0=no limit) align_assign_thresh = 0 # number # The span for aligning on '=' in enums (0=don't align) align_enum_equ_span = 0 # number # The threshold for aligning on '=' in enums (0=no limit) align_enum_equ_thresh = 0 # number # The span for aligning struct/union (0=don't align) align_var_struct_span = 0 # number # The threshold for aligning struct/union member definitions (0=no limit) align_var_struct_thresh = 0 # number # The gap for aligning struct/union member definitions align_var_struct_gap = 0 # number # The span for aligning struct initializer values (0=don't align) align_struct_init_span = 0 # number # The minimum space between the type and the synonym of a typedef align_typedef_gap = 1 # number # The span for aligning single-line typedefs (0=don't align) align_typedef_span = 0 # number # How to align typedef'd functions with other typedefs # 0: Don't mix them at all # 1: align the open paren with the types # 2: align the function type name with the other type names align_typedef_func = 0 # number # Controls the positioning of the '*' in typedefs. Just try it. # 0: Align on typedef type, ignore '*' # 1: The '*' is part of type name: typedef int *pint; # 2: The '*' is part of the type, but dangling: typedef int *pint; align_typedef_star_style = 1 # number # Controls the positioning of the '&' in typedefs. Just try it. # 0: Align on typedef type, ignore '&' # 1: The '&' is part of type name: typedef int &pint; # 2: The '&' is part of the type, but dangling: typedef int &pint; align_typedef_amp_style = 1 # number # The span for aligning comments that end lines (0=don't align) align_right_cmt_span = 4 # number # If aligning comments, mix with comments after '}' and #endif with less than 3 spaces before the comment align_right_cmt_mix = false # false/true # If a trailing comment is more than this number of columns away from the text it follows, # it will qualify for being aligned. This has to be > 0 to do anything. align_right_cmt_gap = 1 # number # Align trailing comment at or beyond column N; 'pulls in' comments as a bonus side effect (0=ignore) align_right_cmt_at_col = 41 # number # The span for aligning function prototypes (0=don't align) align_func_proto_span = 0 # number # Minimum gap between the return type and the function name. align_func_proto_gap = 0 # number # Align function protos on the 'operator' keyword instead of what follows align_on_operator = false # false/true # Whether to mix aligning prototype and variable declarations. # If true, align_var_def_XXX options are used instead of align_func_proto_XXX options. align_mix_var_proto = false # false/true # Align single-line functions with function prototypes, uses align_func_proto_span align_single_line_func = true # false/true # Aligning the open brace of single-line functions. # Requires align_single_line_func=true, uses align_func_proto_span align_single_line_brace = false # false/true # Gap for align_single_line_brace. align_single_line_brace_gap = 0 # number # The span for aligning ObjC msg spec (0=don't align) align_oc_msg_spec_span = 1 # number # Whether to align macros wrapped with a backslash and a newline. # This will not work right if the macro contains a multi-line comment. align_nl_cont = false # false/true # # Align macro functions and variables together align_pp_define_together = true # false/true # The minimum space between label and value of a preprocessor define align_pp_define_gap = 1 # number # The span for aligning on '#define' bodies (0=don't align, other=number of lines including comments between blocks) align_pp_define_span = 8 # number # Align lines that start with '<<' with previous '<<'. Default=true align_left_shift = false # false/true # Align text after asm volatile () colons. align_asm_colon = true # false/true # Span for aligning parameters in an Obj-C message call on the ':' (0=don't align) align_oc_msg_colon_span = 0 # number # If true, always align with the first parameter, even if it is too short. align_oc_msg_colon_first = false # false/true # Aligning parameters in an Obj-C '+' or '-' declaration on the ':' align_oc_decl_colon = false # false/true # # Newline adding and removing options # # Whether to collapse empty blocks between '{' and '}' nl_collapse_empty_body = true # false/true # Don't split one-line braced assignments - 'foo_t f = { 1, 2 };' nl_assign_leave_one_liners = true # false/true # Don't split one-line braced statements inside a class xx { } body nl_class_leave_one_liners = true # false/true # Don't split one-line enums: 'enum foo { BAR = 15 };' nl_enum_leave_one_liners = true # false/true # Don't split one-line get or set functions nl_getset_leave_one_liners = true # false/true # Don't split one-line function definitions - 'int foo() { return 0; }' nl_func_leave_one_liners = true # false/true # Don't split one-line C++11 lambdas - '[]() { return 0; }' nl_cpp_lambda_leave_one_liners = true # false/true # Don't split one-line if/else statements - 'if(a) b++;' nl_if_leave_one_liners = false # false/true # Don't split one-line while statements - 'while(a) b++;' nl_while_leave_one_liners = false # false/true # Don't split one-line OC messages nl_oc_msg_leave_one_liner = true # false/true # Add or remove newlines at the start of the file nl_start_of_file = remove # ignore/add/remove/force # The number of newlines at the start of the file (only used if nl_start_of_file is 'add' or 'force' nl_start_of_file_min = 0 # number # Add or remove newline at the end of the file nl_end_of_file = force # ignore/add/remove/force # The number of newlines at the end of the file (only used if nl_end_of_file is 'add' or 'force') nl_end_of_file_min = 1 # number # Add or remove newline between '=' and '{' nl_assign_brace = remove # ignore/add/remove/force # Add or remove newline between '=' and '[' (D only) nl_assign_square = remove # ignore/add/remove/force # Add or remove newline after '= [' (D only). Will also affect the newline before the ']' nl_after_square_assign = remove # ignore/add/remove/force # The number of blank lines after a block of variable definitions at the top of a function body # 0 = No change (default) nl_var_def_blk_end_func_top = 1 # number # The number of newlines before a block of typedefs # 0 = No change (default) # the option 'nl_after_access_spec' takes preference over 'nl_typedef_blk_start' nl_typedef_blk_start = 2 # number # The number of newlines after a block of typedefs # 0 = No change (default) nl_typedef_blk_end = 2 # number # The maximum consecutive newlines within a block of typedefs # 0 = No change (default) nl_typedef_blk_in = 1 # number # The number of newlines before a block of variable definitions not at the top of a function body # 0 = No change (default) # the option 'nl_after_access_spec' takes preference over 'nl_var_def_blk_start' nl_var_def_blk_start = 2 # number # The number of newlines after a block of variable definitions not at the top of a function body # 0 = No change (default) nl_var_def_blk_end = 2 # number # The maximum consecutive newlines within a block of variable definitions # 0 = No change (default) nl_var_def_blk_in = 1 # number # Add or remove newline between a function call's ')' and '{', as in: # list_for_each(item, &list) { } nl_fcall_brace = remove # ignore/add/remove/force # Add or remove newline between 'enum' and '{' nl_enum_brace = remove # ignore/add/remove/force # Add or remove newline between 'struct and '{' nl_struct_brace = remove # ignore/add/remove/force # Add or remove newline between 'union' and '{' nl_union_brace = remove # ignore/add/remove/force # Add or remove newline between 'if' and '{' nl_if_brace = remove # ignore/add/remove/force # Add or remove newline between '}' and 'else' nl_brace_else = remove # ignore/add/remove/force # Add or remove newline between 'else if' and '{' # If set to ignore, nl_if_brace is used instead nl_elseif_brace = remove # ignore/add/remove/force # Add or remove newline between 'else' and '{' nl_else_brace = remove # ignore/add/remove/force # Add or remove newline between 'else' and 'if' nl_else_if = remove # ignore/add/remove/force # Add or remove newline between '}' and 'finally' nl_brace_finally = remove # ignore/add/remove/force # Add or remove newline between 'finally' and '{' nl_finally_brace = remove # ignore/add/remove/force # Add or remove newline between 'try' and '{' nl_try_brace = remove # ignore/add/remove/force # Add or remove newline between get/set and '{' nl_getset_brace = remove # ignore/add/remove/force # Add or remove newline between 'for' and '{' nl_for_brace = remove # ignore/add/remove/force # Add or remove newline between 'catch' and '{' nl_catch_brace = remove # ignore/add/remove/force # Add or remove newline between '}' and 'catch' nl_brace_catch = remove # ignore/add/remove/force # Add or remove newline between '}' and ']' nl_brace_square = remove # ignore/add/remove/force # Add or remove newline between '}' and ')' in a function invocation nl_brace_fparen = remove # ignore/add/remove/force # Add or remove newline between 'while' and '{' nl_while_brace = remove # ignore/add/remove/force # Add or remove newline between 'scope (x)' and '{' (D) nl_scope_brace = remove # ignore/add/remove/force # Add or remove newline between 'unittest' and '{' (D) nl_unittest_brace = remove # ignore/add/remove/force # Add or remove newline between 'version (x)' and '{' (D) nl_version_brace = remove # ignore/add/remove/force # Add or remove newline between 'using' and '{' nl_using_brace = remove # ignore/add/remove/force # Add or remove newline between two open or close braces. # Due to general newline/brace handling, REMOVE may not work. nl_brace_brace = force # ignore/add/remove/force # Add or remove newline between 'do' and '{' nl_do_brace = remove # ignore/add/remove/force # Add or remove newline between '}' and 'while' of 'do' statement nl_brace_while = remove # ignore/add/remove/force # Add or remove newline between 'switch' and '{' nl_switch_brace = remove # ignore/add/remove/force # Add or remove newline between 'synchronized' and '{' nl_synchronized_brace = remove # ignore/add/remove/force # Add a newline between ')' and '{' if the ')' is on a different line than the if/for/etc. # Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch and nl_catch_brace. nl_multi_line_cond = false # false/true # Force a newline in a define after the macro name for multi-line defines. nl_multi_line_define = false # false/true # Whether to put a newline before 'case' statement, not after the first 'case' nl_before_case = false # false/true # Add or remove newline between ')' and 'throw' nl_before_throw = force # ignore/add/remove/force # Whether to put a newline after 'case' statement nl_after_case = true # false/true # Add or remove a newline between a case ':' and '{'. Overrides nl_after_case. nl_case_colon_brace = remove # ignore/add/remove/force # Newline between namespace and { nl_namespace_brace = remove # ignore/add/remove/force # Add or remove newline between 'template<>' and whatever follows. nl_template_class = force # ignore/add/remove/force # Add or remove newline between 'class' and '{' nl_class_brace = remove # ignore/add/remove/force # Add or remove newline before/after each ',' in the base class list, # (tied to pos_class_comma). nl_class_init_args = remove # ignore/add/remove/force # Add or remove newline after each ',' in the constructor member initialization. # Related to nl_constr_colon, pos_constr_colon and pos_constr_comma. nl_constr_init_args = remove # ignore/add/remove/force # Add or remove newline between return type and function name in a function definition nl_func_type_name = remove # ignore/add/remove/force # Add or remove newline between return type and function name inside a class {} # Uses nl_func_type_name or nl_func_proto_type_name if set to ignore. nl_func_type_name_class = remove # ignore/add/remove/force # Add or remove newline between function scope and name # Controls the newline after '::' in 'void A::f() { }' nl_func_scope_name = remove # ignore/add/remove/force # Add or remove newline between return type and function name in a prototype nl_func_proto_type_name = remove # ignore/add/remove/force # Add or remove newline between a function name and the opening '(' in the declaration nl_func_paren = remove # ignore/add/remove/force # Add or remove newline between a function name and the opening '(' in the definition nl_func_def_paren = remove # ignore/add/remove/force # Add or remove newline after '(' in a function declaration nl_func_decl_start = remove # ignore/add/remove/force # Add or remove newline after '(' in a function definition nl_func_def_start = remove # ignore/add/remove/force # Overrides nl_func_decl_start when there is only one parameter. nl_func_decl_start_single = remove # ignore/add/remove/force # Overrides nl_func_def_start when there is only one parameter. nl_func_def_start_single = remove # ignore/add/remove/force # Add or remove newline after each ',' in a function declaration nl_func_decl_args = remove # ignore/add/remove/force # Add or remove newline after each ',' in a function definition nl_func_def_args = remove # ignore/add/remove/force # Add or remove newline before the ')' in a function declaration nl_func_decl_end = remove # ignore/add/remove/force # Add or remove newline before the ')' in a function definition nl_func_def_end = remove # ignore/add/remove/force # Overrides nl_func_decl_end when there is only one parameter. nl_func_decl_end_single = remove # ignore/add/remove/force # Overrides nl_func_def_end when there is only one parameter. nl_func_def_end_single = remove # ignore/add/remove/force # Add or remove newline between '()' in a function declaration. nl_func_decl_empty = remove # ignore/add/remove/force # Add or remove newline between '()' in a function definition. nl_func_def_empty = remove # ignore/add/remove/force # Whether to put each OC message parameter on a separate line # See nl_oc_msg_leave_one_liner nl_oc_msg_args = false # false/true # Add or remove newline between function signature and '{' nl_fdef_brace = remove # ignore/add/remove/force # Add or remove newline between C++11 lambda signature and '{' nl_cpp_ldef_brace = remove # ignore/add/remove/force # Add or remove a newline between the return keyword and return expression. nl_return_expr = remove # ignore/add/remove/force # Whether to put a newline after semicolons, except in 'for' statements nl_after_semicolon = true # false/true # Java: Control the newline between the ')' and '{{' of the double brace initializer. nl_paren_dbrace_open = remove # ignore/add/remove/force # Whether to put a newline after brace open. nl_after_brace_open = true # false/true # If nl_after_brace_open and nl_after_brace_open_cmt are true, a newline is # placed between the open brace and a trailing single-line comment. nl_after_brace_open_cmt = false # false/true # Whether to put a newline after a virtual brace open with a non-empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open = true # false/true # Whether to put a newline after a virtual brace open with an empty body. # These occur in un-braced if/while/do/for statement bodies. nl_after_vbrace_open_empty = true # false/true # Whether to put a newline after a brace close. # Does not apply if followed by a necessary ';'. nl_after_brace_close = true # false/true # Whether to put a newline after a virtual brace close. # Would add a newline before return in: 'if (foo) a++; return;' nl_after_vbrace_close = true # false/true # Control the newline between the close brace and 'b' in: 'struct { int a; } b;' # Affects enums, unions and structures. If set to ignore, uses nl_after_brace_close nl_brace_struct_var = remove # ignore/add/remove/force # Whether to alter newlines in '#define' macros nl_define_macro = false # false/true # Whether to not put blanks after '#ifxx', '#elxx', or before '#endif'. Does not affect the whole-file #ifdef. nl_squeeze_ifdef = true # false/true # Add or remove blank line before 'if' nl_before_if = remove # ignore/add/remove/force # Add or remove blank line after 'if' statement nl_after_if = remove # ignore/add/remove/force # Add or remove blank line before 'for' nl_before_for = remove # ignore/add/remove/force # Add or remove blank line after 'for' statement nl_after_for = remove # ignore/add/remove/force # Add or remove blank line before 'while' nl_before_while = remove # ignore/add/remove/force # Add or remove blank line after 'while' statement nl_after_while = remove # ignore/add/remove/force # Add or remove blank line before 'switch' nl_before_switch = remove # ignore/add/remove/force # Add or remove blank line after 'switch' statement nl_after_switch = remove # ignore/add/remove/force # Add or remove blank line before 'synchronized' nl_before_synchronized = remove # ignore/add/remove/force # Add or remove blank line after 'synchronized' statement nl_after_synchronized = remove # ignore/add/remove/force # Add or remove blank line before 'do' nl_before_do = remove # ignore/add/remove/force # Add or remove blank line after 'do/while' statement nl_after_do = remove # ignore/add/remove/force # Whether to double-space commented-entries in struct/union/enum nl_ds_struct_enum_cmt = false # false/true # force nl before } of a struct/union/enum # (lower priority than 'eat_blanks_before_close_brace') nl_ds_struct_enum_close_brace = false # false/true # Add or remove a newline before/after a class colon, # (tied to pos_class_colon). nl_class_colon = remove # ignore/add/remove/force # Add or remove a newline around a class constructor colon. # Related to nl_constr_init_args, pos_constr_colon and pos_constr_comma. nl_constr_colon = remove # ignore/add/remove/force # Change simple unbraced if statements into a one-liner # 'if(b)\n i++;' => 'if(b) i++;' nl_create_if_one_liner = false # false/true # Change simple unbraced for statements into a one-liner # 'for (i=0;i<5;i++)\n foo(i);' => 'for (i=0;i<5;i++) foo(i);' nl_create_for_one_liner = false # false/true # Change simple unbraced while statements into a one-liner # 'while (i<5)\n foo(i++);' => 'while (i<5) foo(i++);' nl_create_while_one_liner = false # false/true # # Positioning options # # The position of arithmetic operators in wrapped expressions pos_arith = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of assignment in wrapped expressions. # Do not affect '=' followed by '{' pos_assign = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of boolean operators in wrapped expressions pos_bool = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of comparison operators in wrapped expressions pos_compare = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of conditional (b ? t : f) operators in wrapped expressions pos_conditional = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of the comma in wrapped expressions pos_comma = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of the comma in the base class list if there are more than one line, # (tied to nl_class_init_args). pos_class_comma = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of the comma in the constructor initialization list. # Related to nl_constr_colon, nl_constr_init_args and pos_constr_colon. pos_constr_comma = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of trailing/leading class colon, between class and base class list # (tied to nl_class_colon). pos_class_colon = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # The position of colons between constructor and member initialization, # (tied to UO_nl_constr_colon). # Related to nl_constr_colon, nl_constr_init_args and pos_constr_comma. pos_constr_colon = join # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force # # Line Splitting options # # Try to limit code width to N number of columns code_width = 80 # number # Whether to fully split long 'for' statements at semi-colons ls_for_split_full = false # false/true # Whether to fully split long function protos/calls at commas ls_func_split_full = false # false/true # Whether to split lines as close to code_width as possible and ignore some groupings ls_code_width = true # false/true # # Blank line options # # The maximum consecutive newlines (3 = 2 blank lines) nl_max = 2 # number # The number of newlines after a function prototype, if followed by another function prototype nl_after_func_proto = 1 # number # The number of newlines after a function prototype, if not followed by another function prototype nl_after_func_proto_group = 2 # number # The number of newlines after '}' of a multi-line function body nl_after_func_body = 2 # number # The number of newlines after '}' of a multi-line function body in a class declaration nl_after_func_body_class = 1 # number # The number of newlines after '}' of a single line function body nl_after_func_body_one_liner = 1 # number # The minimum number of newlines before a multi-line comment. # Doesn't apply if after a brace open or another multi-line comment. nl_before_block_comment = 2 # number # The minimum number of newlines before a single-line C comment. # Doesn't apply if after a brace open or other single-line C comments. nl_before_c_comment = 1 # number # The minimum number of newlines before a CPP comment. # Doesn't apply if after a brace open or other CPP comments. nl_before_cpp_comment = 1 # number # Whether to force a newline after a multi-line comment. nl_after_multiline_comment = true # false/true # Whether to force a newline after a label's colon. nl_after_label_colon = false # false/true # The number of newlines after '}' or ';' of a struct/enum/union definition nl_after_struct = 2 # number # The number of newlines after '}' or ';' of a class definition nl_after_class = 2 # number # The number of newlines after '}' of a namespace nl_after_namespace = 2 # number # The number of newlines before a 'private:', 'public:', 'protected:', 'signals:', or 'slots:' label. # Will not change the newline count if after a brace open. # 0 = No change. nl_before_access_spec = 2 # number # The number of newlines after a 'private:', 'public:', 'protected:', 'signals:' or 'slots:' label. # 0 = No change. # the option 'nl_after_access_spec' takes preference over 'nl_typedef_blk_start' and 'nl_var_def_blk_start' nl_after_access_spec = 1 # number # The number of newlines between a function def and the function comment. # 0 = No change. nl_comment_func_def = 1 # number # The number of newlines after a try-catch-finally block that isn't followed by a brace close. # 0 = No change. nl_after_try_catch_finally = 1 # number # The number of newlines before and after a property, indexer or event decl. # 0 = No change. nl_around_cs_property = 1 # number # The number of newlines between the get/set/add/remove handlers in C#. # 0 = No change. nl_between_get_set = 1 # number # Add or remove newline between C# property and the '{' nl_property_brace = remove # ignore/add/remove/force # Whether to remove blank lines after '{' eat_blanks_after_open_brace = true # false/true # Whether to remove blank lines before '}' eat_blanks_before_close_brace = true # false/true # How aggressively to remove extra newlines not in preproc. # 0: No change # 1: Remove most newlines not handled by other config # 2: Remove all newlines and reformat completely by config nl_remove_extra_newlines = 1 # number # Whether to put a blank line before 'return' statements, unless after an open brace. nl_before_return = false # false/true # Whether to put a blank line after 'return' statements, unless followed by a close brace. nl_after_return = false # false/true # Whether to put a newline after a Java annotation statement. # Only affects annotations that are after a newline. nl_after_annotation = force # ignore/add/remove/force # # Code modifying options (non-whitespace) # # Add or remove braces on single-line 'do' statement mod_full_brace_do = force # ignore/add/remove/force # Add or remove braces on single-line 'for' statement mod_full_brace_for = remove # ignore/add/remove/force # Add or remove braces on single-line 'if' statement. Will not remove the braces if they contain an 'else'. mod_full_brace_if = remove # ignore/add/remove/force # Make all if/elseif/else statements in a chain be braced or not. Overrides mod_full_brace_if. # If any must be braced, they are all braced. If all can be unbraced, then the braces are removed. mod_full_brace_if_chain = 1 # unsigned number # Don't remove braces around statements that span N newlines mod_full_brace_nl = 2 # number # Add or remove braces on single-line 'while' statement mod_full_brace_while = remove # ignore/add/remove/force # Add or remove braces on single-line 'using ()' statement mod_full_brace_using = remove # ignore/add/remove/force # Add or remove unnecessary paren on 'return' statement mod_paren_on_return = remove # ignore/add/remove/force # Whether to change optional semicolons to real semicolons mod_pawn_semicolon = false # false/true # Add parens on 'while' and 'if' statement around bools mod_full_paren_if_bool = false # false/true # Whether to remove superfluous semicolons mod_remove_extra_semicolon = true # false/true # If a function body exceeds the specified number of newlines and doesn't have a comment after # the close brace, a comment will be added. mod_add_long_function_closebrace_comment = 0 # number # If a namespace body exceeds the specified number of newlines and doesn't have a comment after # the close brace, a comment will be added. mod_add_long_namespace_closebrace_comment = 0 # number # If a switch body exceeds the specified number of newlines and doesn't have a comment after # the close brace, a comment will be added. mod_add_long_switch_closebrace_comment = 0 # number # If an #ifdef body exceeds the specified number of newlines and doesn't have a comment after # the #endif, a comment will be added. mod_add_long_ifdef_endif_comment = 0 # number # If an #ifdef or #else body exceeds the specified number of newlines and doesn't have a comment after # the #else, a comment will be added. mod_add_long_ifdef_else_comment = 0 # number # If TRUE, will sort consecutive single-line 'import' statements [Java, D] mod_sort_import = true # false/true # If TRUE, will sort consecutive single-line 'using' statements [C#] mod_sort_using = true # false/true # If TRUE, will sort consecutive single-line '#include' statements [C/C++] and '#import' statements [Obj-C] # This is generally a bad idea, as it may break your code. mod_sort_include = false # false/true # If TRUE, it will move a 'break' that appears after a fully braced 'case' before the close brace. mod_move_case_break = false # false/true # If TRUE, it will remove a void 'return;' that appears as the last statement in a function. mod_remove_empty_return = true # false/true # # Comment modifications # # Try to wrap comments at cmt_width columns cmt_width = 80 # number # Set the comment reflow mode (default: 0) # 0: no reflowing (apart from the line wrapping due to cmt_width) # 1: no touching at all # 2: full reflow cmt_reflow_mode = 1 # number # Whether to convert all tabs to spaces in comments. Default is to leave tabs inside comments alone, unless used for indenting. cmt_convert_tab_to_spaces = false # false/true # If false, disable all multi-line comment changes, including cmt_width. keyword substitution and leading chars. # Default is true. cmt_indent_multi = true # false/true # Whether to group c-comments that look like they are in a block cmt_c_group = true # false/true # Whether to put an empty '/*' on the first line of the combined c-comment cmt_c_nl_start = true # false/true # Whether to put a newline before the closing '*/' of the combined c-comment cmt_c_nl_end = true # false/true # Whether to group cpp-comments that look like they are in a block cmt_cpp_group = true # false/true # Whether to put an empty '/*' on the first line of the combined cpp-comment cmt_cpp_nl_start = true # false/true # Whether to put a newline before the closing '*/' of the combined cpp-comment cmt_cpp_nl_end = true # false/true # Whether to change cpp-comments into c-comments cmt_cpp_to_c = false # false/true # Whether to put a star on subsequent comment lines cmt_star_cont = true # false/true # The number of spaces to insert at the start of subsequent comment lines cmt_sp_before_star_cont = 0 # number # The number of spaces to insert after the star on subsequent comment lines cmt_sp_after_star_cont = 0 # number # For multi-line comments with a '*' lead, remove leading spaces if the first and last lines of # the comment are the same length. Default=True cmt_multi_check_last = false # false/true # The filename that contains text to insert at the head of a file if the file doesn't start with a C/C++ comment. # Will substitute $(filename) with the current file's name. cmt_insert_file_header = "" # string # The filename that contains text to insert at the end of a file if the file doesn't end with a C/C++ comment. # Will substitute $(filename) with the current file's name. cmt_insert_file_footer = "" # string # The filename that contains text to insert before a function implementation if the function isn't preceded with a C/C++ comment. # Will substitute $(function) with the function name and $(javaparam) with the javadoc @param and @return stuff. # Will also substitute $(fclass) with the class name: void CFoo::Bar() { ... } cmt_insert_func_header = "" # string # The filename that contains text to insert before a class if the class isn't preceded with a C/C++ comment. # Will substitute $(class) with the class name. cmt_insert_class_header = "" # string # The filename that contains text to insert before a Obj-C message specification if the method isn't preceded with a C/C++ comment. # Will substitute $(message) with the function name and $(javaparam) with the javadoc @param and @return stuff. cmt_insert_oc_msg_header = "" # string # If a preprocessor is encountered when stepping backwards from a function name, then # this option decides whether the comment should be inserted. # Affects cmt_insert_oc_msg_header, cmt_insert_func_header and cmt_insert_class_header. cmt_insert_before_preproc = false # false/true # # Preprocessor options # # Whether to indent #if/#else/#endif at the brace level (true) or from column 1 (false) pp_indent_at_level = false # false/true # Whether to indent #if/#else/#endif at the parenthesis level if the brace # level is 0. If false, these are indented from column 1. pp_indent_at_level0 = false # false/true # Specifies the number of columns to indent preprocessors per level at brace level 0 (file-level). # If pp_indent_at_level=false, specifies the number of columns to indent preprocessors per level at brace level > 0 (function-level). # Default=1. pp_indent_count = 1 # number # Add or remove space after # based on pp level of #if blocks pp_space_after = remove # ignore/add/remove/force # Sets the number of spaces added with pp_space_after pp_space_count = 1 # number # The indent for #region and #endregion in C# and '#pragma region' in C/C++ pp_indent_region = 0 # number # Whether to indent the code between #region and #endregion pp_region_indent_code = false # false/true # If pp_indent_at_level=true, sets the indent for #if, #else and #endif when not at file-level. # 0: indent preprocessors using output_tab_size. # >0: column at which all preprocessors will be indented. pp_indent_if = 0 # number # Control whether to indent the code between #if, #else and #endif. pp_if_indent_code = false # false/true # Whether to indent '#define' at the brace level (true) or from column 1 (false) pp_define_at_level = false # false/true # Use or Do not Use options # # True: indent_func_call_param will be used # False: indent_func_call_param will NOT be used use_indent_func_call_param = true # false/true # True: indent_continue will be used only once # False: indent_continue will be used every time (default) use_indent_continue_only_once = false # false/true # You can force a token to be a type with the 'type' option. # Example: # type myfoo1 myfoo2 # # You can create custom macro-based indentation using macro-open, # macro-else and macro-close. # Example: # macro-open BEGIN_TEMPLATE_MESSAGE_MAP # macro-open BEGIN_MESSAGE_MAP # macro-close END_MESSAGE_MAP # # You can assign any keyword to any type with the set option. # set func_call_user _ N_ # # The full syntax description of all custom definition config entries # is shown below: # # define custom tokens as: # - embed whitespace in token using '' escape character, or # put token in quotes # - these: ' " and ` are recognized as quote delimiters # # type token1 token2 token3 ... # ^ optionally specify multiple tokens on a single line # define def_token output_token # ^ output_token is optional, then NULL is assumed # macro-open token # macro-close token # macro-else token # set id token1 token2 ... # ^ optionally specify multiple tokens on a single line # ^ id is one of the names in token_enum.h sans the CT_ prefix, # e.g. PP_PRAGMA # # all tokens are separated by any mix of ',' commas, '=' equal signs # and whitespace (space, tab) # # You can add support for other file extensions using the 'file_ext' command. # The first arg is the language name used with the '-l' option. # The remaining args are file extensions, matched with 'endswith'. # file_ext CPP .ch .cxx .cpp.in # type byte cchar uchar ushort word uint ulong llong ullong type int8 uint8 int16 uint16 int32 uint32 int64 uint64 type FILE size_t ssize_t va_list wchar_t type BOOL BSTR BYTE CHAR DOUBLE DWORD DWORD64 DWORD_PTR FALSE FLOAT type HANDLE HKEY HRESULT HWND INT INT8 INT16 INT32 INT64 LONG LONG64 LONG_PTR type LPARAM LPSTR LPCSTR LPCWSTR LPTSTR LPVOID LPWSTR PSZ SHORT TRUE type UCHAR UINT UINT8 UINT16 UINT32 UINT64 UINT_PTR ULONG ULONG64 ULONG_PTR type USHORT WCHAR WORD WORD_PTR WPARAM uncrustify-uncrustify-0.76.0/etc/types.txt000066400000000000000000000005201434072136500207120ustar00rootroot00000000000000# # a simple list of stuff that should be detected as a CT_TYPE # this usually isn't necessary because types are detected from the context. # # In the future, I may allow arbitrary CT_xxx stuff to be specified, as # well as a language # INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 FLOAT CHAR DOUBLE TRUE FALSE BOOL FILE DIR bat uncrustify-uncrustify-0.76.0/etc/uigui_uncrustify.ini000066400000000000000000011500741434072136500231360ustar00rootroot00000000000000[header] categories=General options|Spacing options|Indenting options|Newline adding and removing options|Blank line options|Positioning options|Line splitting options|Code alignment options (not left column spaces/tabs)|Comment modification options|Code modifying options (non-whitespace)|Preprocessor options|Sort includes options|Use or Do not Use options|Warn levels - 1: error, 2: warning (default), 3: note cfgFileParameterEnding=cr configFilename=uncrustify.cfg fileTypes=*.c|*.c++|*.cc|*.cp|*.cpp|*.cs|*.cxx|*.d|*.di|*.es|*.h|*.h++|*.hh|*.hp|*.hpp|*.hxx|*.inl|*.java|*.js|*.m|*.mm|*.p|*.pawn|*.sma|*.sqc|*.sql|*.vala indenterFileName=uncrustify indenterName=Uncrustify (C, C++, C#, ObjectiveC, D, Java, Pawn, VALA) inputFileName=indentinput inputFileParameter="-f " manual=http://uncrustify.sourceforge.net/config.txt outputFileName=indentoutput outputFileParameter="-o " stringparaminquotes=false parameterOrder=ipo showHelpParameter=-h stringparaminquotes=false useCfgFileParameter="-c " version=Uncrustify-0.76.0 [Newlines] Category=0 Description="The type of line endings.

Default: auto" Enabled=false EditorType=multiple Choices=newlines=lf|newlines=crlf|newlines=cr|newlines=auto ChoicesReadable="Newlines Unix|Newlines Win|Newlines Mac|Newlines Auto" ValueDefault=auto [Input Tab Size] Category=0 Description="The original size of tabs in the input.

Default: 8" Enabled=false EditorType=numeric CallName="input_tab_size=" MinVal=1 MaxVal=32 ValueDefault=8 [Output Tab Size] Category=0 Description="The size of tabs in the output (only used if align_with_tabs=true).

Default: 8" Enabled=false EditorType=numeric CallName="output_tab_size=" MinVal=1 MaxVal=32 ValueDefault=8 [String Escape Char] Category=0 Description="The ASCII value of the string escape char, usually 92 (\) or (Pawn) 94 (^).

Default: 92" Enabled=false EditorType=numeric CallName="string_escape_char=" MinVal=0 MaxVal=255 ValueDefault=92 [String Escape Char2] Category=0 Description="Alternate string escape char (usually only used for Pawn).
Only works right before the quote char." Enabled=false EditorType=numeric CallName="string_escape_char2=" MinVal=0 MaxVal=255 ValueDefault=0 [String Replace Tab Chars] Category=0 Description="Replace tab characters found in string literals with the escape sequence \t
instead." Enabled=false EditorType=boolean TrueFalse=string_replace_tab_chars=true|string_replace_tab_chars=false ValueDefault=false [Tok Split Gte] Category=0 Description="Allow interpreting '>=' and '>>=' as part of a template in code like
'void f(list<list<B>>=val);'. If true, 'assert(x<0 && y>=3)' will be broken.
Improvements to template detection may make this option obsolete." Enabled=false EditorType=boolean TrueFalse=tok_split_gte=true|tok_split_gte=false ValueDefault=false [Disable Processing Nl Cont] Category=0 Description="Disable formatting of NL_CONT ('\\n') ended lines (e.g. multi-line macros)." Enabled=false EditorType=boolean TrueFalse=disable_processing_nl_cont=true|disable_processing_nl_cont=false ValueDefault=false [Disable Processing Cmt] Category=0 Description="Specify the marker used in comments to disable processing of part of the
file.

Default: *INDENT-OFF*" Enabled=false CallName=disable_processing_cmt= EditorType=string ValueDefault= *INDENT-OFF* [Enable Processing Cmt] Category=0 Description="Specify the marker used in comments to (re)enable processing in a file.

Default: *INDENT-ON*" Enabled=false CallName=enable_processing_cmt= EditorType=string ValueDefault= *INDENT-ON* [Enable Digraphs] Category=0 Description="Enable parsing of digraphs." Enabled=false EditorType=boolean TrueFalse=enable_digraphs=true|enable_digraphs=false ValueDefault=false [Processing Cmt As Regex] Category=0 Description="Option to allow both disable_processing_cmt and enable_processing_cmt
strings, if specified, to be interpreted as ECMAScript regular expressions.
If true, a regex search will be performed within comments according to the
specified patterns in order to disable/enable processing." Enabled=false EditorType=boolean TrueFalse=processing_cmt_as_regex=true|processing_cmt_as_regex=false ValueDefault=false [Utf8 Bom] Category=0 Description="Add or remove the UTF-8 BOM (recommend 'remove')." Enabled=false EditorType=multiple Choices=utf8_bom=ignore|utf8_bom=add|utf8_bom=remove|utf8_bom=force|utf8_bom=not_defined ChoicesReadable="Ignore Utf8 Bom|Add Utf8 Bom|Remove Utf8 Bom|Force Utf8 Bom" ValueDefault=ignore [Utf8 Byte] Category=0 Description="If the file contains bytes with values between 128 and 255, but is not
UTF-8, then output as UTF-8." Enabled=false EditorType=boolean TrueFalse=utf8_byte=true|utf8_byte=false ValueDefault=false [Utf8 Force] Category=0 Description="Force the output encoding to UTF-8." Enabled=false EditorType=boolean TrueFalse=utf8_force=true|utf8_force=false ValueDefault=false [Sp Arith] Category=1 Description="Add or remove space around non-assignment symbolic operators ('+', '/', '%',
'<<', and so forth)." Enabled=false EditorType=multiple Choices=sp_arith=ignore|sp_arith=add|sp_arith=remove|sp_arith=force|sp_arith=not_defined ChoicesReadable="Ignore Sp Arith|Add Sp Arith|Remove Sp Arith|Force Sp Arith" ValueDefault=ignore [Sp Arith Additive] Category=1 Description="Add or remove space around arithmetic operators '+' and '-'.

Overrides sp_arith." Enabled=false EditorType=multiple Choices=sp_arith_additive=ignore|sp_arith_additive=add|sp_arith_additive=remove|sp_arith_additive=force|sp_arith_additive=not_defined ChoicesReadable="Ignore Sp Arith Additive|Add Sp Arith Additive|Remove Sp Arith Additive|Force Sp Arith Additive" ValueDefault=ignore [Sp Assign] Category=1 Description="Add or remove space around assignment operator '=', '+=', etc." Enabled=false EditorType=multiple Choices=sp_assign=ignore|sp_assign=add|sp_assign=remove|sp_assign=force|sp_assign=not_defined ChoicesReadable="Ignore Sp Assign|Add Sp Assign|Remove Sp Assign|Force Sp Assign" ValueDefault=ignore [Sp Cpp Lambda Assign] Category=1 Description="Add or remove space around '=' in C++11 lambda capture specifications.

Overrides sp_assign." Enabled=false EditorType=multiple Choices=sp_cpp_lambda_assign=ignore|sp_cpp_lambda_assign=add|sp_cpp_lambda_assign=remove|sp_cpp_lambda_assign=force|sp_cpp_lambda_assign=not_defined ChoicesReadable="Ignore Sp Cpp Lambda Assign|Add Sp Cpp Lambda Assign|Remove Sp Cpp Lambda Assign|Force Sp Cpp Lambda Assign" ValueDefault=ignore [Sp Cpp Lambda Square Paren] Category=1 Description="Add or remove space after the capture specification of a C++11 lambda when
an argument list is present, as in '[] <here> (int x){ ... }'." Enabled=false EditorType=multiple Choices=sp_cpp_lambda_square_paren=ignore|sp_cpp_lambda_square_paren=add|sp_cpp_lambda_square_paren=remove|sp_cpp_lambda_square_paren=force|sp_cpp_lambda_square_paren=not_defined ChoicesReadable="Ignore Sp Cpp Lambda Square Paren|Add Sp Cpp Lambda Square Paren|Remove Sp Cpp Lambda Square Paren|Force Sp Cpp Lambda Square Paren" ValueDefault=ignore [Sp Cpp Lambda Square Brace] Category=1 Description="Add or remove space after the capture specification of a C++11 lambda with
no argument list is present, as in '[] <here> { ... }'." Enabled=false EditorType=multiple Choices=sp_cpp_lambda_square_brace=ignore|sp_cpp_lambda_square_brace=add|sp_cpp_lambda_square_brace=remove|sp_cpp_lambda_square_brace=force|sp_cpp_lambda_square_brace=not_defined ChoicesReadable="Ignore Sp Cpp Lambda Square Brace|Add Sp Cpp Lambda Square Brace|Remove Sp Cpp Lambda Square Brace|Force Sp Cpp Lambda Square Brace" ValueDefault=ignore [Sp Cpp Lambda Argument List] Category=1 Description="Add or remove space after the opening parenthesis and before the closing
parenthesis of a argument list of a C++11 lambda, as in
'[]( <here> int x <here> ){ ... }'." Enabled=false EditorType=multiple Choices=sp_cpp_lambda_argument_list=ignore|sp_cpp_lambda_argument_list=add|sp_cpp_lambda_argument_list=remove|sp_cpp_lambda_argument_list=force|sp_cpp_lambda_argument_list=not_defined ChoicesReadable="Ignore Sp Cpp Lambda Argument List|Add Sp Cpp Lambda Argument List|Remove Sp Cpp Lambda Argument List|Force Sp Cpp Lambda Argument List" ValueDefault=ignore [Sp Cpp Lambda Paren Brace] Category=1 Description="Add or remove space after the argument list of a C++11 lambda, as in
'[](int x) <here> { ... }'." Enabled=false EditorType=multiple Choices=sp_cpp_lambda_paren_brace=ignore|sp_cpp_lambda_paren_brace=add|sp_cpp_lambda_paren_brace=remove|sp_cpp_lambda_paren_brace=force|sp_cpp_lambda_paren_brace=not_defined ChoicesReadable="Ignore Sp Cpp Lambda Paren Brace|Add Sp Cpp Lambda Paren Brace|Remove Sp Cpp Lambda Paren Brace|Force Sp Cpp Lambda Paren Brace" ValueDefault=ignore [Sp Cpp Lambda Fparen] Category=1 Description="Add or remove space between a lambda body and its call operator of an
immediately invoked lambda, as in '[]( ... ){ ... } <here> ( ... )'." Enabled=false EditorType=multiple Choices=sp_cpp_lambda_fparen=ignore|sp_cpp_lambda_fparen=add|sp_cpp_lambda_fparen=remove|sp_cpp_lambda_fparen=force|sp_cpp_lambda_fparen=not_defined ChoicesReadable="Ignore Sp Cpp Lambda Fparen|Add Sp Cpp Lambda Fparen|Remove Sp Cpp Lambda Fparen|Force Sp Cpp Lambda Fparen" ValueDefault=ignore [Sp Assign Default] Category=1 Description="Add or remove space around assignment operator '=' in a prototype.

If set to ignore, use sp_assign." Enabled=false EditorType=multiple Choices=sp_assign_default=ignore|sp_assign_default=add|sp_assign_default=remove|sp_assign_default=force|sp_assign_default=not_defined ChoicesReadable="Ignore Sp Assign Default|Add Sp Assign Default|Remove Sp Assign Default|Force Sp Assign Default" ValueDefault=ignore [Sp Before Assign] Category=1 Description="Add or remove space before assignment operator '=', '+=', etc.

Overrides sp_assign." Enabled=false EditorType=multiple Choices=sp_before_assign=ignore|sp_before_assign=add|sp_before_assign=remove|sp_before_assign=force|sp_before_assign=not_defined ChoicesReadable="Ignore Sp Before Assign|Add Sp Before Assign|Remove Sp Before Assign|Force Sp Before Assign" ValueDefault=ignore [Sp After Assign] Category=1 Description="Add or remove space after assignment operator '=', '+=', etc.

Overrides sp_assign." Enabled=false EditorType=multiple Choices=sp_after_assign=ignore|sp_after_assign=add|sp_after_assign=remove|sp_after_assign=force|sp_after_assign=not_defined ChoicesReadable="Ignore Sp After Assign|Add Sp After Assign|Remove Sp After Assign|Force Sp After Assign" ValueDefault=ignore [Sp Enum Brace] Category=1 Description="Add or remove space in 'enum {'.

Default: add" Enabled=false EditorType=multiple Choices=sp_enum_brace=ignore|sp_enum_brace=add|sp_enum_brace=remove|sp_enum_brace=force|sp_enum_brace=not_defined ChoicesReadable="Ignore Sp Enum Brace|Add Sp Enum Brace|Remove Sp Enum Brace|Force Sp Enum Brace" ValueDefault=add [Sp Enum Paren] Category=1 Description="Add or remove space in 'NS_ENUM ('." Enabled=false EditorType=multiple Choices=sp_enum_paren=ignore|sp_enum_paren=add|sp_enum_paren=remove|sp_enum_paren=force|sp_enum_paren=not_defined ChoicesReadable="Ignore Sp Enum Paren|Add Sp Enum Paren|Remove Sp Enum Paren|Force Sp Enum Paren" ValueDefault=ignore [Sp Enum Assign] Category=1 Description="Add or remove space around assignment '=' in enum." Enabled=false EditorType=multiple Choices=sp_enum_assign=ignore|sp_enum_assign=add|sp_enum_assign=remove|sp_enum_assign=force|sp_enum_assign=not_defined ChoicesReadable="Ignore Sp Enum Assign|Add Sp Enum Assign|Remove Sp Enum Assign|Force Sp Enum Assign" ValueDefault=ignore [Sp Enum Before Assign] Category=1 Description="Add or remove space before assignment '=' in enum.

Overrides sp_enum_assign." Enabled=false EditorType=multiple Choices=sp_enum_before_assign=ignore|sp_enum_before_assign=add|sp_enum_before_assign=remove|sp_enum_before_assign=force|sp_enum_before_assign=not_defined ChoicesReadable="Ignore Sp Enum Before Assign|Add Sp Enum Before Assign|Remove Sp Enum Before Assign|Force Sp Enum Before Assign" ValueDefault=ignore [Sp Enum After Assign] Category=1 Description="Add or remove space after assignment '=' in enum.

Overrides sp_enum_assign." Enabled=false EditorType=multiple Choices=sp_enum_after_assign=ignore|sp_enum_after_assign=add|sp_enum_after_assign=remove|sp_enum_after_assign=force|sp_enum_after_assign=not_defined ChoicesReadable="Ignore Sp Enum After Assign|Add Sp Enum After Assign|Remove Sp Enum After Assign|Force Sp Enum After Assign" ValueDefault=ignore [Sp Enum Colon] Category=1 Description="Add or remove space around assignment ':' in enum." Enabled=false EditorType=multiple Choices=sp_enum_colon=ignore|sp_enum_colon=add|sp_enum_colon=remove|sp_enum_colon=force|sp_enum_colon=not_defined ChoicesReadable="Ignore Sp Enum Colon|Add Sp Enum Colon|Remove Sp Enum Colon|Force Sp Enum Colon" ValueDefault=ignore [Sp Pp Concat] Category=1 Description="Add or remove space around preprocessor '##' concatenation operator.

Default: add" Enabled=false EditorType=multiple Choices=sp_pp_concat=ignore|sp_pp_concat=add|sp_pp_concat=remove|sp_pp_concat=force|sp_pp_concat=not_defined ChoicesReadable="Ignore Sp Pp Concat|Add Sp Pp Concat|Remove Sp Pp Concat|Force Sp Pp Concat" ValueDefault=add [Sp Pp Stringify] Category=1 Description="Add or remove space after preprocessor '#' stringify operator.
Also affects the '#@' charizing operator." Enabled=false EditorType=multiple Choices=sp_pp_stringify=ignore|sp_pp_stringify=add|sp_pp_stringify=remove|sp_pp_stringify=force|sp_pp_stringify=not_defined ChoicesReadable="Ignore Sp Pp Stringify|Add Sp Pp Stringify|Remove Sp Pp Stringify|Force Sp Pp Stringify" ValueDefault=ignore [Sp Before Pp Stringify] Category=1 Description="Add or remove space before preprocessor '#' stringify operator
as in '#define x(y) L#y'." Enabled=false EditorType=multiple Choices=sp_before_pp_stringify=ignore|sp_before_pp_stringify=add|sp_before_pp_stringify=remove|sp_before_pp_stringify=force|sp_before_pp_stringify=not_defined ChoicesReadable="Ignore Sp Before Pp Stringify|Add Sp Before Pp Stringify|Remove Sp Before Pp Stringify|Force Sp Before Pp Stringify" ValueDefault=ignore [Sp Bool] Category=1 Description="Add or remove space around boolean operators '&&' and '||'." Enabled=false EditorType=multiple Choices=sp_bool=ignore|sp_bool=add|sp_bool=remove|sp_bool=force|sp_bool=not_defined ChoicesReadable="Ignore Sp Bool|Add Sp Bool|Remove Sp Bool|Force Sp Bool" ValueDefault=ignore [Sp Compare] Category=1 Description="Add or remove space around compare operator '<', '>', '==', etc." Enabled=false EditorType=multiple Choices=sp_compare=ignore|sp_compare=add|sp_compare=remove|sp_compare=force|sp_compare=not_defined ChoicesReadable="Ignore Sp Compare|Add Sp Compare|Remove Sp Compare|Force Sp Compare" ValueDefault=ignore [Sp Inside Paren] Category=1 Description="Add or remove space inside '(' and ')'." Enabled=false EditorType=multiple Choices=sp_inside_paren=ignore|sp_inside_paren=add|sp_inside_paren=remove|sp_inside_paren=force|sp_inside_paren=not_defined ChoicesReadable="Ignore Sp Inside Paren|Add Sp Inside Paren|Remove Sp Inside Paren|Force Sp Inside Paren" ValueDefault=ignore [Sp Paren Paren] Category=1 Description="Add or remove space between nested parentheses, i.e. '((' vs. ') )'." Enabled=false EditorType=multiple Choices=sp_paren_paren=ignore|sp_paren_paren=add|sp_paren_paren=remove|sp_paren_paren=force|sp_paren_paren=not_defined ChoicesReadable="Ignore Sp Paren Paren|Add Sp Paren Paren|Remove Sp Paren Paren|Force Sp Paren Paren" ValueDefault=ignore [Sp Cparen Oparen] Category=1 Description="Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('." Enabled=false EditorType=multiple Choices=sp_cparen_oparen=ignore|sp_cparen_oparen=add|sp_cparen_oparen=remove|sp_cparen_oparen=force|sp_cparen_oparen=not_defined ChoicesReadable="Ignore Sp Cparen Oparen|Add Sp Cparen Oparen|Remove Sp Cparen Oparen|Force Sp Cparen Oparen" ValueDefault=ignore [Sp Balance Nested Parens] Category=1 Description="Whether to balance spaces inside nested parentheses." Enabled=false EditorType=boolean TrueFalse=sp_balance_nested_parens=true|sp_balance_nested_parens=false ValueDefault=false [Sp Paren Brace] Category=1 Description="Add or remove space between ')' and '{'." Enabled=false EditorType=multiple Choices=sp_paren_brace=ignore|sp_paren_brace=add|sp_paren_brace=remove|sp_paren_brace=force|sp_paren_brace=not_defined ChoicesReadable="Ignore Sp Paren Brace|Add Sp Paren Brace|Remove Sp Paren Brace|Force Sp Paren Brace" ValueDefault=ignore [Sp Brace Brace] Category=1 Description="Add or remove space between nested braces, i.e. '{{' vs. '{ {'." Enabled=false EditorType=multiple Choices=sp_brace_brace=ignore|sp_brace_brace=add|sp_brace_brace=remove|sp_brace_brace=force|sp_brace_brace=not_defined ChoicesReadable="Ignore Sp Brace Brace|Add Sp Brace Brace|Remove Sp Brace Brace|Force Sp Brace Brace" ValueDefault=ignore [Sp Before Ptr Star] Category=1 Description="Add or remove space before pointer star '*'." Enabled=false EditorType=multiple Choices=sp_before_ptr_star=ignore|sp_before_ptr_star=add|sp_before_ptr_star=remove|sp_before_ptr_star=force|sp_before_ptr_star=not_defined ChoicesReadable="Ignore Sp Before Ptr Star|Add Sp Before Ptr Star|Remove Sp Before Ptr Star|Force Sp Before Ptr Star" ValueDefault=ignore [Sp Before Unnamed Ptr Star] Category=1 Description="Add or remove space before pointer star '*' that isn't followed by a
variable name. If set to ignore, sp_before_ptr_star is used instead." Enabled=false EditorType=multiple Choices=sp_before_unnamed_ptr_star=ignore|sp_before_unnamed_ptr_star=add|sp_before_unnamed_ptr_star=remove|sp_before_unnamed_ptr_star=force|sp_before_unnamed_ptr_star=not_defined ChoicesReadable="Ignore Sp Before Unnamed Ptr Star|Add Sp Before Unnamed Ptr Star|Remove Sp Before Unnamed Ptr Star|Force Sp Before Unnamed Ptr Star" ValueDefault=ignore [Sp Between Ptr Star] Category=1 Description="Add or remove space between pointer stars '*', as in 'int ***a;'." Enabled=false EditorType=multiple Choices=sp_between_ptr_star=ignore|sp_between_ptr_star=add|sp_between_ptr_star=remove|sp_between_ptr_star=force|sp_between_ptr_star=not_defined ChoicesReadable="Ignore Sp Between Ptr Star|Add Sp Between Ptr Star|Remove Sp Between Ptr Star|Force Sp Between Ptr Star" ValueDefault=ignore [Sp After Ptr Star] Category=1 Description="Add or remove space after pointer star '*', if followed by a word.

Overrides sp_type_func." Enabled=false EditorType=multiple Choices=sp_after_ptr_star=ignore|sp_after_ptr_star=add|sp_after_ptr_star=remove|sp_after_ptr_star=force|sp_after_ptr_star=not_defined ChoicesReadable="Ignore Sp After Ptr Star|Add Sp After Ptr Star|Remove Sp After Ptr Star|Force Sp After Ptr Star" ValueDefault=ignore [Sp After Ptr Block Caret] Category=1 Description="Add or remove space after pointer caret '^', if followed by a word." Enabled=false EditorType=multiple Choices=sp_after_ptr_block_caret=ignore|sp_after_ptr_block_caret=add|sp_after_ptr_block_caret=remove|sp_after_ptr_block_caret=force|sp_after_ptr_block_caret=not_defined ChoicesReadable="Ignore Sp After Ptr Block Caret|Add Sp After Ptr Block Caret|Remove Sp After Ptr Block Caret|Force Sp After Ptr Block Caret" ValueDefault=ignore [Sp After Ptr Star Qualifier] Category=1 Description="Add or remove space after pointer star '*', if followed by a qualifier." Enabled=false EditorType=multiple Choices=sp_after_ptr_star_qualifier=ignore|sp_after_ptr_star_qualifier=add|sp_after_ptr_star_qualifier=remove|sp_after_ptr_star_qualifier=force|sp_after_ptr_star_qualifier=not_defined ChoicesReadable="Ignore Sp After Ptr Star Qualifier|Add Sp After Ptr Star Qualifier|Remove Sp After Ptr Star Qualifier|Force Sp After Ptr Star Qualifier" ValueDefault=ignore [Sp After Ptr Star Func] Category=1 Description="Add or remove space after a pointer star '*', if followed by a function
prototype or function definition.

Overrides sp_after_ptr_star and sp_type_func." Enabled=false EditorType=multiple Choices=sp_after_ptr_star_func=ignore|sp_after_ptr_star_func=add|sp_after_ptr_star_func=remove|sp_after_ptr_star_func=force|sp_after_ptr_star_func=not_defined ChoicesReadable="Ignore Sp After Ptr Star Func|Add Sp After Ptr Star Func|Remove Sp After Ptr Star Func|Force Sp After Ptr Star Func" ValueDefault=ignore [Sp After Ptr Star Trailing] Category=1 Description="Add or remove space after a pointer star '*' in the trailing return of a
function prototype or function definition." Enabled=false EditorType=multiple Choices=sp_after_ptr_star_trailing=ignore|sp_after_ptr_star_trailing=add|sp_after_ptr_star_trailing=remove|sp_after_ptr_star_trailing=force|sp_after_ptr_star_trailing=not_defined ChoicesReadable="Ignore Sp After Ptr Star Trailing|Add Sp After Ptr Star Trailing|Remove Sp After Ptr Star Trailing|Force Sp After Ptr Star Trailing" ValueDefault=ignore [Sp Ptr Star Func Var] Category=1 Description="Add or remove space between the pointer star '*' and the name of the variable
in a function pointer definition." Enabled=false EditorType=multiple Choices=sp_ptr_star_func_var=ignore|sp_ptr_star_func_var=add|sp_ptr_star_func_var=remove|sp_ptr_star_func_var=force|sp_ptr_star_func_var=not_defined ChoicesReadable="Ignore Sp Ptr Star Func Var|Add Sp Ptr Star Func Var|Remove Sp Ptr Star Func Var|Force Sp Ptr Star Func Var" ValueDefault=ignore [Sp Ptr Star Func Type] Category=1 Description="Add or remove space between the pointer star '*' and the name of the type
in a function pointer type definition." Enabled=false EditorType=multiple Choices=sp_ptr_star_func_type=ignore|sp_ptr_star_func_type=add|sp_ptr_star_func_type=remove|sp_ptr_star_func_type=force|sp_ptr_star_func_type=not_defined ChoicesReadable="Ignore Sp Ptr Star Func Type|Add Sp Ptr Star Func Type|Remove Sp Ptr Star Func Type|Force Sp Ptr Star Func Type" ValueDefault=ignore [Sp Ptr Star Paren] Category=1 Description="Add or remove space after a pointer star '*', if followed by an open
parenthesis, as in 'void* (*)()'." Enabled=false EditorType=multiple Choices=sp_ptr_star_paren=ignore|sp_ptr_star_paren=add|sp_ptr_star_paren=remove|sp_ptr_star_paren=force|sp_ptr_star_paren=not_defined ChoicesReadable="Ignore Sp Ptr Star Paren|Add Sp Ptr Star Paren|Remove Sp Ptr Star Paren|Force Sp Ptr Star Paren" ValueDefault=ignore [Sp Before Ptr Star Func] Category=1 Description="Add or remove space before a pointer star '*', if followed by a function
prototype or function definition." Enabled=false EditorType=multiple Choices=sp_before_ptr_star_func=ignore|sp_before_ptr_star_func=add|sp_before_ptr_star_func=remove|sp_before_ptr_star_func=force|sp_before_ptr_star_func=not_defined ChoicesReadable="Ignore Sp Before Ptr Star Func|Add Sp Before Ptr Star Func|Remove Sp Before Ptr Star Func|Force Sp Before Ptr Star Func" ValueDefault=ignore [Sp Before Ptr Star Trailing] Category=1 Description="Add or remove space before a pointer star '*' in the trailing return of a
function prototype or function definition." Enabled=false EditorType=multiple Choices=sp_before_ptr_star_trailing=ignore|sp_before_ptr_star_trailing=add|sp_before_ptr_star_trailing=remove|sp_before_ptr_star_trailing=force|sp_before_ptr_star_trailing=not_defined ChoicesReadable="Ignore Sp Before Ptr Star Trailing|Add Sp Before Ptr Star Trailing|Remove Sp Before Ptr Star Trailing|Force Sp Before Ptr Star Trailing" ValueDefault=ignore [Sp Before Byref] Category=1 Description="Add or remove space before a reference sign '&'." Enabled=false EditorType=multiple Choices=sp_before_byref=ignore|sp_before_byref=add|sp_before_byref=remove|sp_before_byref=force|sp_before_byref=not_defined ChoicesReadable="Ignore Sp Before Byref|Add Sp Before Byref|Remove Sp Before Byref|Force Sp Before Byref" ValueDefault=ignore [Sp Before Unnamed Byref] Category=1 Description="Add or remove space before a reference sign '&' that isn't followed by a
variable name. If set to ignore, sp_before_byref is used instead." Enabled=false EditorType=multiple Choices=sp_before_unnamed_byref=ignore|sp_before_unnamed_byref=add|sp_before_unnamed_byref=remove|sp_before_unnamed_byref=force|sp_before_unnamed_byref=not_defined ChoicesReadable="Ignore Sp Before Unnamed Byref|Add Sp Before Unnamed Byref|Remove Sp Before Unnamed Byref|Force Sp Before Unnamed Byref" ValueDefault=ignore [Sp After Byref] Category=1 Description="Add or remove space after reference sign '&', if followed by a word.

Overrides sp_type_func." Enabled=false EditorType=multiple Choices=sp_after_byref=ignore|sp_after_byref=add|sp_after_byref=remove|sp_after_byref=force|sp_after_byref=not_defined ChoicesReadable="Ignore Sp After Byref|Add Sp After Byref|Remove Sp After Byref|Force Sp After Byref" ValueDefault=ignore [Sp After Byref Func] Category=1 Description="Add or remove space after a reference sign '&', if followed by a function
prototype or function definition.

Overrides sp_after_byref and sp_type_func." Enabled=false EditorType=multiple Choices=sp_after_byref_func=ignore|sp_after_byref_func=add|sp_after_byref_func=remove|sp_after_byref_func=force|sp_after_byref_func=not_defined ChoicesReadable="Ignore Sp After Byref Func|Add Sp After Byref Func|Remove Sp After Byref Func|Force Sp After Byref Func" ValueDefault=ignore [Sp Before Byref Func] Category=1 Description="Add or remove space before a reference sign '&', if followed by a function
prototype or function definition." Enabled=false EditorType=multiple Choices=sp_before_byref_func=ignore|sp_before_byref_func=add|sp_before_byref_func=remove|sp_before_byref_func=force|sp_before_byref_func=not_defined ChoicesReadable="Ignore Sp Before Byref Func|Add Sp Before Byref Func|Remove Sp Before Byref Func|Force Sp Before Byref Func" ValueDefault=ignore [Sp Byref Paren] Category=1 Description="Add or remove space after a reference sign '&', if followed by an open
parenthesis, as in 'char& (*)()'." Enabled=false EditorType=multiple Choices=sp_byref_paren=ignore|sp_byref_paren=add|sp_byref_paren=remove|sp_byref_paren=force|sp_byref_paren=not_defined ChoicesReadable="Ignore Sp Byref Paren|Add Sp Byref Paren|Remove Sp Byref Paren|Force Sp Byref Paren" ValueDefault=ignore [Sp After Type] Category=1 Description="Add or remove space between type and word. In cases where total removal of
whitespace would be a syntax error, a value of 'remove' is treated the same
as 'force'.

This also affects some other instances of space following a type that are
not covered by other options; for example, between the return type and
parenthesis of a function type template argument, between the type and
parenthesis of an array parameter, or between 'decltype(...)' and the
following word.

Default: force" Enabled=false EditorType=multiple Choices=sp_after_type=ignore|sp_after_type=add|sp_after_type=remove|sp_after_type=force|sp_after_type=not_defined ChoicesReadable="Ignore Sp After Type|Add Sp After Type|Remove Sp After Type|Force Sp After Type" ValueDefault=force [Sp After Decltype] Category=1 Description="Add or remove space between 'decltype(...)' and word,
brace or function call." Enabled=false EditorType=multiple Choices=sp_after_decltype=ignore|sp_after_decltype=add|sp_after_decltype=remove|sp_after_decltype=force|sp_after_decltype=not_defined ChoicesReadable="Ignore Sp After Decltype|Add Sp After Decltype|Remove Sp After Decltype|Force Sp After Decltype" ValueDefault=ignore [Sp Before Template Paren] Category=1 Description="(D) Add or remove space before the parenthesis in the D constructs
'template Foo(' and 'class Foo('." Enabled=false EditorType=multiple Choices=sp_before_template_paren=ignore|sp_before_template_paren=add|sp_before_template_paren=remove|sp_before_template_paren=force|sp_before_template_paren=not_defined ChoicesReadable="Ignore Sp Before Template Paren|Add Sp Before Template Paren|Remove Sp Before Template Paren|Force Sp Before Template Paren" ValueDefault=ignore [Sp Template Angle] Category=1 Description="Add or remove space between 'template' and '<'.
If set to ignore, sp_before_angle is used." Enabled=false EditorType=multiple Choices=sp_template_angle=ignore|sp_template_angle=add|sp_template_angle=remove|sp_template_angle=force|sp_template_angle=not_defined ChoicesReadable="Ignore Sp Template Angle|Add Sp Template Angle|Remove Sp Template Angle|Force Sp Template Angle" ValueDefault=ignore [Sp Before Angle] Category=1 Description="Add or remove space before '<'." Enabled=false EditorType=multiple Choices=sp_before_angle=ignore|sp_before_angle=add|sp_before_angle=remove|sp_before_angle=force|sp_before_angle=not_defined ChoicesReadable="Ignore Sp Before Angle|Add Sp Before Angle|Remove Sp Before Angle|Force Sp Before Angle" ValueDefault=ignore [Sp Inside Angle] Category=1 Description="Add or remove space inside '<' and '>'." Enabled=false EditorType=multiple Choices=sp_inside_angle=ignore|sp_inside_angle=add|sp_inside_angle=remove|sp_inside_angle=force|sp_inside_angle=not_defined ChoicesReadable="Ignore Sp Inside Angle|Add Sp Inside Angle|Remove Sp Inside Angle|Force Sp Inside Angle" ValueDefault=ignore [Sp Inside Angle Empty] Category=1 Description="Add or remove space inside '<>'." Enabled=false EditorType=multiple Choices=sp_inside_angle_empty=ignore|sp_inside_angle_empty=add|sp_inside_angle_empty=remove|sp_inside_angle_empty=force|sp_inside_angle_empty=not_defined ChoicesReadable="Ignore Sp Inside Angle Empty|Add Sp Inside Angle Empty|Remove Sp Inside Angle Empty|Force Sp Inside Angle Empty" ValueDefault=ignore [Sp Angle Colon] Category=1 Description="Add or remove space between '>' and ':'." Enabled=false EditorType=multiple Choices=sp_angle_colon=ignore|sp_angle_colon=add|sp_angle_colon=remove|sp_angle_colon=force|sp_angle_colon=not_defined ChoicesReadable="Ignore Sp Angle Colon|Add Sp Angle Colon|Remove Sp Angle Colon|Force Sp Angle Colon" ValueDefault=ignore [Sp After Angle] Category=1 Description="Add or remove space after '>'." Enabled=false EditorType=multiple Choices=sp_after_angle=ignore|sp_after_angle=add|sp_after_angle=remove|sp_after_angle=force|sp_after_angle=not_defined ChoicesReadable="Ignore Sp After Angle|Add Sp After Angle|Remove Sp After Angle|Force Sp After Angle" ValueDefault=ignore [Sp Angle Paren] Category=1 Description="Add or remove space between '>' and '(' as found in 'new List<byte>(foo);'." Enabled=false EditorType=multiple Choices=sp_angle_paren=ignore|sp_angle_paren=add|sp_angle_paren=remove|sp_angle_paren=force|sp_angle_paren=not_defined ChoicesReadable="Ignore Sp Angle Paren|Add Sp Angle Paren|Remove Sp Angle Paren|Force Sp Angle Paren" ValueDefault=ignore [Sp Angle Paren Empty] Category=1 Description="Add or remove space between '>' and '()' as found in 'new List<byte>();'." Enabled=false EditorType=multiple Choices=sp_angle_paren_empty=ignore|sp_angle_paren_empty=add|sp_angle_paren_empty=remove|sp_angle_paren_empty=force|sp_angle_paren_empty=not_defined ChoicesReadable="Ignore Sp Angle Paren Empty|Add Sp Angle Paren Empty|Remove Sp Angle Paren Empty|Force Sp Angle Paren Empty" ValueDefault=ignore [Sp Angle Word] Category=1 Description="Add or remove space between '>' and a word as in 'List<byte> m;' or
'template <typename T> static ...'." Enabled=false EditorType=multiple Choices=sp_angle_word=ignore|sp_angle_word=add|sp_angle_word=remove|sp_angle_word=force|sp_angle_word=not_defined ChoicesReadable="Ignore Sp Angle Word|Add Sp Angle Word|Remove Sp Angle Word|Force Sp Angle Word" ValueDefault=ignore [Sp Angle Shift] Category=1 Description="Add or remove space between '>' and '>' in '>>' (template stuff).

Default: add" Enabled=false EditorType=multiple Choices=sp_angle_shift=ignore|sp_angle_shift=add|sp_angle_shift=remove|sp_angle_shift=force|sp_angle_shift=not_defined ChoicesReadable="Ignore Sp Angle Shift|Add Sp Angle Shift|Remove Sp Angle Shift|Force Sp Angle Shift" ValueDefault=add [Sp Permit Cpp11 Shift] Category=1 Description="(C++11) Permit removal of the space between '>>' in 'foo<bar<int> >'. Note
that sp_angle_shift cannot remove the space without this option." Enabled=false EditorType=boolean TrueFalse=sp_permit_cpp11_shift=true|sp_permit_cpp11_shift=false ValueDefault=false [Sp Before Sparen] Category=1 Description="Add or remove space before '(' of control statements ('if', 'for', 'switch',
'while', etc.)." Enabled=false EditorType=multiple Choices=sp_before_sparen=ignore|sp_before_sparen=add|sp_before_sparen=remove|sp_before_sparen=force|sp_before_sparen=not_defined ChoicesReadable="Ignore Sp Before Sparen|Add Sp Before Sparen|Remove Sp Before Sparen|Force Sp Before Sparen" ValueDefault=ignore [Sp Inside Sparen] Category=1 Description="Add or remove space inside '(' and ')' of control statements other than
'for'." Enabled=false EditorType=multiple Choices=sp_inside_sparen=ignore|sp_inside_sparen=add|sp_inside_sparen=remove|sp_inside_sparen=force|sp_inside_sparen=not_defined ChoicesReadable="Ignore Sp Inside Sparen|Add Sp Inside Sparen|Remove Sp Inside Sparen|Force Sp Inside Sparen" ValueDefault=ignore [Sp Inside Sparen Open] Category=1 Description="Add or remove space after '(' of control statements other than 'for'.

Overrides sp_inside_sparen." Enabled=false EditorType=multiple Choices=sp_inside_sparen_open=ignore|sp_inside_sparen_open=add|sp_inside_sparen_open=remove|sp_inside_sparen_open=force|sp_inside_sparen_open=not_defined ChoicesReadable="Ignore Sp Inside Sparen Open|Add Sp Inside Sparen Open|Remove Sp Inside Sparen Open|Force Sp Inside Sparen Open" ValueDefault=ignore [Sp Inside Sparen Close] Category=1 Description="Add or remove space before ')' of control statements other than 'for'.

Overrides sp_inside_sparen." Enabled=false EditorType=multiple Choices=sp_inside_sparen_close=ignore|sp_inside_sparen_close=add|sp_inside_sparen_close=remove|sp_inside_sparen_close=force|sp_inside_sparen_close=not_defined ChoicesReadable="Ignore Sp Inside Sparen Close|Add Sp Inside Sparen Close|Remove Sp Inside Sparen Close|Force Sp Inside Sparen Close" ValueDefault=ignore [Sp Inside For] Category=1 Description="Add or remove space inside '(' and ')' of 'for' statements." Enabled=false EditorType=multiple Choices=sp_inside_for=ignore|sp_inside_for=add|sp_inside_for=remove|sp_inside_for=force|sp_inside_for=not_defined ChoicesReadable="Ignore Sp Inside For|Add Sp Inside For|Remove Sp Inside For|Force Sp Inside For" ValueDefault=ignore [Sp Inside For Open] Category=1 Description="Add or remove space after '(' of 'for' statements.

Overrides sp_inside_for." Enabled=false EditorType=multiple Choices=sp_inside_for_open=ignore|sp_inside_for_open=add|sp_inside_for_open=remove|sp_inside_for_open=force|sp_inside_for_open=not_defined ChoicesReadable="Ignore Sp Inside For Open|Add Sp Inside For Open|Remove Sp Inside For Open|Force Sp Inside For Open" ValueDefault=ignore [Sp Inside For Close] Category=1 Description="Add or remove space before ')' of 'for' statements.

Overrides sp_inside_for." Enabled=false EditorType=multiple Choices=sp_inside_for_close=ignore|sp_inside_for_close=add|sp_inside_for_close=remove|sp_inside_for_close=force|sp_inside_for_close=not_defined ChoicesReadable="Ignore Sp Inside For Close|Add Sp Inside For Close|Remove Sp Inside For Close|Force Sp Inside For Close" ValueDefault=ignore [Sp Sparen Paren] Category=1 Description="Add or remove space between '((' or '))' of control statements." Enabled=false EditorType=multiple Choices=sp_sparen_paren=ignore|sp_sparen_paren=add|sp_sparen_paren=remove|sp_sparen_paren=force|sp_sparen_paren=not_defined ChoicesReadable="Ignore Sp Sparen Paren|Add Sp Sparen Paren|Remove Sp Sparen Paren|Force Sp Sparen Paren" ValueDefault=ignore [Sp After Sparen] Category=1 Description="Add or remove space after ')' of control statements." Enabled=false EditorType=multiple Choices=sp_after_sparen=ignore|sp_after_sparen=add|sp_after_sparen=remove|sp_after_sparen=force|sp_after_sparen=not_defined ChoicesReadable="Ignore Sp After Sparen|Add Sp After Sparen|Remove Sp After Sparen|Force Sp After Sparen" ValueDefault=ignore [Sp Sparen Brace] Category=1 Description="Add or remove space between ')' and '{' of control statements." Enabled=false EditorType=multiple Choices=sp_sparen_brace=ignore|sp_sparen_brace=add|sp_sparen_brace=remove|sp_sparen_brace=force|sp_sparen_brace=not_defined ChoicesReadable="Ignore Sp Sparen Brace|Add Sp Sparen Brace|Remove Sp Sparen Brace|Force Sp Sparen Brace" ValueDefault=ignore [Sp Do Brace Open] Category=1 Description="Add or remove space between 'do' and '{'." Enabled=false EditorType=multiple Choices=sp_do_brace_open=ignore|sp_do_brace_open=add|sp_do_brace_open=remove|sp_do_brace_open=force|sp_do_brace_open=not_defined ChoicesReadable="Ignore Sp Do Brace Open|Add Sp Do Brace Open|Remove Sp Do Brace Open|Force Sp Do Brace Open" ValueDefault=ignore [Sp Brace Close While] Category=1 Description="Add or remove space between '}' and 'while'." Enabled=false EditorType=multiple Choices=sp_brace_close_while=ignore|sp_brace_close_while=add|sp_brace_close_while=remove|sp_brace_close_while=force|sp_brace_close_while=not_defined ChoicesReadable="Ignore Sp Brace Close While|Add Sp Brace Close While|Remove Sp Brace Close While|Force Sp Brace Close While" ValueDefault=ignore [Sp While Paren Open] Category=1 Description="Add or remove space between 'while' and '('. Overrides sp_before_sparen." Enabled=false EditorType=multiple Choices=sp_while_paren_open=ignore|sp_while_paren_open=add|sp_while_paren_open=remove|sp_while_paren_open=force|sp_while_paren_open=not_defined ChoicesReadable="Ignore Sp While Paren Open|Add Sp While Paren Open|Remove Sp While Paren Open|Force Sp While Paren Open" ValueDefault=ignore [Sp Invariant Paren] Category=1 Description="(D) Add or remove space between 'invariant' and '('." Enabled=false EditorType=multiple Choices=sp_invariant_paren=ignore|sp_invariant_paren=add|sp_invariant_paren=remove|sp_invariant_paren=force|sp_invariant_paren=not_defined ChoicesReadable="Ignore Sp Invariant Paren|Add Sp Invariant Paren|Remove Sp Invariant Paren|Force Sp Invariant Paren" ValueDefault=ignore [Sp After Invariant Paren] Category=1 Description="(D) Add or remove space after the ')' in 'invariant (C) c'." Enabled=false EditorType=multiple Choices=sp_after_invariant_paren=ignore|sp_after_invariant_paren=add|sp_after_invariant_paren=remove|sp_after_invariant_paren=force|sp_after_invariant_paren=not_defined ChoicesReadable="Ignore Sp After Invariant Paren|Add Sp After Invariant Paren|Remove Sp After Invariant Paren|Force Sp After Invariant Paren" ValueDefault=ignore [Sp Special Semi] Category=1 Description="Add or remove space before empty statement ';' on 'if', 'for' and 'while'." Enabled=false EditorType=multiple Choices=sp_special_semi=ignore|sp_special_semi=add|sp_special_semi=remove|sp_special_semi=force|sp_special_semi=not_defined ChoicesReadable="Ignore Sp Special Semi|Add Sp Special Semi|Remove Sp Special Semi|Force Sp Special Semi" ValueDefault=ignore [Sp Before Semi] Category=1 Description="Add or remove space before ';'.

Default: remove" Enabled=false EditorType=multiple Choices=sp_before_semi=ignore|sp_before_semi=add|sp_before_semi=remove|sp_before_semi=force|sp_before_semi=not_defined ChoicesReadable="Ignore Sp Before Semi|Add Sp Before Semi|Remove Sp Before Semi|Force Sp Before Semi" ValueDefault=remove [Sp Before Semi For] Category=1 Description="Add or remove space before ';' in non-empty 'for' statements." Enabled=false EditorType=multiple Choices=sp_before_semi_for=ignore|sp_before_semi_for=add|sp_before_semi_for=remove|sp_before_semi_for=force|sp_before_semi_for=not_defined ChoicesReadable="Ignore Sp Before Semi For|Add Sp Before Semi For|Remove Sp Before Semi For|Force Sp Before Semi For" ValueDefault=ignore [Sp Before Semi For Empty] Category=1 Description="Add or remove space before a semicolon of an empty left part of a for
statement, as in 'for ( <here> ; ; )'." Enabled=false EditorType=multiple Choices=sp_before_semi_for_empty=ignore|sp_before_semi_for_empty=add|sp_before_semi_for_empty=remove|sp_before_semi_for_empty=force|sp_before_semi_for_empty=not_defined ChoicesReadable="Ignore Sp Before Semi For Empty|Add Sp Before Semi For Empty|Remove Sp Before Semi For Empty|Force Sp Before Semi For Empty" ValueDefault=ignore [Sp Between Semi For Empty] Category=1 Description="Add or remove space between the semicolons of an empty middle part of a for
statement, as in 'for ( ; <here> ; )'." Enabled=false EditorType=multiple Choices=sp_between_semi_for_empty=ignore|sp_between_semi_for_empty=add|sp_between_semi_for_empty=remove|sp_between_semi_for_empty=force|sp_between_semi_for_empty=not_defined ChoicesReadable="Ignore Sp Between Semi For Empty|Add Sp Between Semi For Empty|Remove Sp Between Semi For Empty|Force Sp Between Semi For Empty" ValueDefault=ignore [Sp After Semi] Category=1 Description="Add or remove space after ';', except when followed by a comment.

Default: add" Enabled=false EditorType=multiple Choices=sp_after_semi=ignore|sp_after_semi=add|sp_after_semi=remove|sp_after_semi=force|sp_after_semi=not_defined ChoicesReadable="Ignore Sp After Semi|Add Sp After Semi|Remove Sp After Semi|Force Sp After Semi" ValueDefault=add [Sp After Semi For] Category=1 Description="Add or remove space after ';' in non-empty 'for' statements.

Default: force" Enabled=false EditorType=multiple Choices=sp_after_semi_for=ignore|sp_after_semi_for=add|sp_after_semi_for=remove|sp_after_semi_for=force|sp_after_semi_for=not_defined ChoicesReadable="Ignore Sp After Semi For|Add Sp After Semi For|Remove Sp After Semi For|Force Sp After Semi For" ValueDefault=force [Sp After Semi For Empty] Category=1 Description="Add or remove space after the final semicolon of an empty part of a for
statement, as in 'for ( ; ; <here> )'." Enabled=false EditorType=multiple Choices=sp_after_semi_for_empty=ignore|sp_after_semi_for_empty=add|sp_after_semi_for_empty=remove|sp_after_semi_for_empty=force|sp_after_semi_for_empty=not_defined ChoicesReadable="Ignore Sp After Semi For Empty|Add Sp After Semi For Empty|Remove Sp After Semi For Empty|Force Sp After Semi For Empty" ValueDefault=ignore [Sp Before Square] Category=1 Description="Add or remove space before '[' (except '[]')." Enabled=false EditorType=multiple Choices=sp_before_square=ignore|sp_before_square=add|sp_before_square=remove|sp_before_square=force|sp_before_square=not_defined ChoicesReadable="Ignore Sp Before Square|Add Sp Before Square|Remove Sp Before Square|Force Sp Before Square" ValueDefault=ignore [Sp Before Vardef Square] Category=1 Description="Add or remove space before '[' for a variable definition.

Default: remove" Enabled=false EditorType=multiple Choices=sp_before_vardef_square=ignore|sp_before_vardef_square=add|sp_before_vardef_square=remove|sp_before_vardef_square=force|sp_before_vardef_square=not_defined ChoicesReadable="Ignore Sp Before Vardef Square|Add Sp Before Vardef Square|Remove Sp Before Vardef Square|Force Sp Before Vardef Square" ValueDefault=remove [Sp Before Square Asm Block] Category=1 Description="Add or remove space before '[' for asm block." Enabled=false EditorType=multiple Choices=sp_before_square_asm_block=ignore|sp_before_square_asm_block=add|sp_before_square_asm_block=remove|sp_before_square_asm_block=force|sp_before_square_asm_block=not_defined ChoicesReadable="Ignore Sp Before Square Asm Block|Add Sp Before Square Asm Block|Remove Sp Before Square Asm Block|Force Sp Before Square Asm Block" ValueDefault=ignore [Sp Before Squares] Category=1 Description="Add or remove space before '[]'." Enabled=false EditorType=multiple Choices=sp_before_squares=ignore|sp_before_squares=add|sp_before_squares=remove|sp_before_squares=force|sp_before_squares=not_defined ChoicesReadable="Ignore Sp Before Squares|Add Sp Before Squares|Remove Sp Before Squares|Force Sp Before Squares" ValueDefault=ignore [Sp Cpp Before Struct Binding] Category=1 Description="Add or remove space before C++17 structured bindings." Enabled=false EditorType=multiple Choices=sp_cpp_before_struct_binding=ignore|sp_cpp_before_struct_binding=add|sp_cpp_before_struct_binding=remove|sp_cpp_before_struct_binding=force|sp_cpp_before_struct_binding=not_defined ChoicesReadable="Ignore Sp Cpp Before Struct Binding|Add Sp Cpp Before Struct Binding|Remove Sp Cpp Before Struct Binding|Force Sp Cpp Before Struct Binding" ValueDefault=ignore [Sp Inside Square] Category=1 Description="Add or remove space inside a non-empty '[' and ']'." Enabled=false EditorType=multiple Choices=sp_inside_square=ignore|sp_inside_square=add|sp_inside_square=remove|sp_inside_square=force|sp_inside_square=not_defined ChoicesReadable="Ignore Sp Inside Square|Add Sp Inside Square|Remove Sp Inside Square|Force Sp Inside Square" ValueDefault=ignore [Sp Inside Square Empty] Category=1 Description="Add or remove space inside '[]'." Enabled=false EditorType=multiple Choices=sp_inside_square_empty=ignore|sp_inside_square_empty=add|sp_inside_square_empty=remove|sp_inside_square_empty=force|sp_inside_square_empty=not_defined ChoicesReadable="Ignore Sp Inside Square Empty|Add Sp Inside Square Empty|Remove Sp Inside Square Empty|Force Sp Inside Square Empty" ValueDefault=ignore [Sp Inside Square Oc Array] Category=1 Description="(OC) Add or remove space inside a non-empty Objective-C boxed array '@[' and
']'. If set to ignore, sp_inside_square is used." Enabled=false EditorType=multiple Choices=sp_inside_square_oc_array=ignore|sp_inside_square_oc_array=add|sp_inside_square_oc_array=remove|sp_inside_square_oc_array=force|sp_inside_square_oc_array=not_defined ChoicesReadable="Ignore Sp Inside Square Oc Array|Add Sp Inside Square Oc Array|Remove Sp Inside Square Oc Array|Force Sp Inside Square Oc Array" ValueDefault=ignore [Sp After Comma] Category=1 Description="Add or remove space after ',', i.e. 'a,b' vs. 'a, b'." Enabled=false EditorType=multiple Choices=sp_after_comma=ignore|sp_after_comma=add|sp_after_comma=remove|sp_after_comma=force|sp_after_comma=not_defined ChoicesReadable="Ignore Sp After Comma|Add Sp After Comma|Remove Sp After Comma|Force Sp After Comma" ValueDefault=ignore [Sp Before Comma] Category=1 Description="Add or remove space before ',', i.e. 'a,b' vs. 'a ,b'.

Default: remove" Enabled=false EditorType=multiple Choices=sp_before_comma=ignore|sp_before_comma=add|sp_before_comma=remove|sp_before_comma=force|sp_before_comma=not_defined ChoicesReadable="Ignore Sp Before Comma|Add Sp Before Comma|Remove Sp Before Comma|Force Sp Before Comma" ValueDefault=remove [Sp After Mdatype Commas] Category=1 Description="(C#, Vala) Add or remove space between ',' and ']' in multidimensional array type
like 'int[,,]'." Enabled=false EditorType=multiple Choices=sp_after_mdatype_commas=ignore|sp_after_mdatype_commas=add|sp_after_mdatype_commas=remove|sp_after_mdatype_commas=force|sp_after_mdatype_commas=not_defined ChoicesReadable="Ignore Sp After Mdatype Commas|Add Sp After Mdatype Commas|Remove Sp After Mdatype Commas|Force Sp After Mdatype Commas" ValueDefault=ignore [Sp Before Mdatype Commas] Category=1 Description="(C#, Vala) Add or remove space between '[' and ',' in multidimensional array type
like 'int[,,]'." Enabled=false EditorType=multiple Choices=sp_before_mdatype_commas=ignore|sp_before_mdatype_commas=add|sp_before_mdatype_commas=remove|sp_before_mdatype_commas=force|sp_before_mdatype_commas=not_defined ChoicesReadable="Ignore Sp Before Mdatype Commas|Add Sp Before Mdatype Commas|Remove Sp Before Mdatype Commas|Force Sp Before Mdatype Commas" ValueDefault=ignore [Sp Between Mdatype Commas] Category=1 Description="(C#, Vala) Add or remove space between ',' in multidimensional array type
like 'int[,,]'." Enabled=false EditorType=multiple Choices=sp_between_mdatype_commas=ignore|sp_between_mdatype_commas=add|sp_between_mdatype_commas=remove|sp_between_mdatype_commas=force|sp_between_mdatype_commas=not_defined ChoicesReadable="Ignore Sp Between Mdatype Commas|Add Sp Between Mdatype Commas|Remove Sp Between Mdatype Commas|Force Sp Between Mdatype Commas" ValueDefault=ignore [Sp Paren Comma] Category=1 Description="Add or remove space between an open parenthesis and comma,
i.e. '(,' vs. '( ,'.

Default: force" Enabled=false EditorType=multiple Choices=sp_paren_comma=ignore|sp_paren_comma=add|sp_paren_comma=remove|sp_paren_comma=force|sp_paren_comma=not_defined ChoicesReadable="Ignore Sp Paren Comma|Add Sp Paren Comma|Remove Sp Paren Comma|Force Sp Paren Comma" ValueDefault=force [Sp Type Colon] Category=1 Description="Add or remove space between a type and ':'." Enabled=false EditorType=multiple Choices=sp_type_colon=ignore|sp_type_colon=add|sp_type_colon=remove|sp_type_colon=force|sp_type_colon=not_defined ChoicesReadable="Ignore Sp Type Colon|Add Sp Type Colon|Remove Sp Type Colon|Force Sp Type Colon" ValueDefault=ignore [Sp After Ellipsis] Category=1 Description="Add or remove space after the variadic '...' when preceded by a
non-punctuator.
The value REMOVE will be overridden with FORCE" Enabled=false EditorType=multiple Choices=sp_after_ellipsis=ignore|sp_after_ellipsis=add|sp_after_ellipsis=remove|sp_after_ellipsis=force|sp_after_ellipsis=not_defined ChoicesReadable="Ignore Sp After Ellipsis|Add Sp After Ellipsis|Remove Sp After Ellipsis|Force Sp After Ellipsis" ValueDefault=ignore [Sp Before Ellipsis] Category=1 Description="Add or remove space before the variadic '...' when preceded by a
non-punctuator.
The value REMOVE will be overridden with FORCE" Enabled=false EditorType=multiple Choices=sp_before_ellipsis=ignore|sp_before_ellipsis=add|sp_before_ellipsis=remove|sp_before_ellipsis=force|sp_before_ellipsis=not_defined ChoicesReadable="Ignore Sp Before Ellipsis|Add Sp Before Ellipsis|Remove Sp Before Ellipsis|Force Sp Before Ellipsis" ValueDefault=ignore [Sp Type Ellipsis] Category=1 Description="Add or remove space between a type and '...'." Enabled=false EditorType=multiple Choices=sp_type_ellipsis=ignore|sp_type_ellipsis=add|sp_type_ellipsis=remove|sp_type_ellipsis=force|sp_type_ellipsis=not_defined ChoicesReadable="Ignore Sp Type Ellipsis|Add Sp Type Ellipsis|Remove Sp Type Ellipsis|Force Sp Type Ellipsis" ValueDefault=ignore [Sp Ptr Type Ellipsis] Category=1 Description="Add or remove space between a '*' and '...'." Enabled=false EditorType=multiple Choices=sp_ptr_type_ellipsis=ignore|sp_ptr_type_ellipsis=add|sp_ptr_type_ellipsis=remove|sp_ptr_type_ellipsis=force|sp_ptr_type_ellipsis=not_defined ChoicesReadable="Ignore Sp Ptr Type Ellipsis|Add Sp Ptr Type Ellipsis|Remove Sp Ptr Type Ellipsis|Force Sp Ptr Type Ellipsis" ValueDefault=ignore [Sp Paren Ellipsis] Category=1 Description="Add or remove space between ')' and '...'." Enabled=false EditorType=multiple Choices=sp_paren_ellipsis=ignore|sp_paren_ellipsis=add|sp_paren_ellipsis=remove|sp_paren_ellipsis=force|sp_paren_ellipsis=not_defined ChoicesReadable="Ignore Sp Paren Ellipsis|Add Sp Paren Ellipsis|Remove Sp Paren Ellipsis|Force Sp Paren Ellipsis" ValueDefault=ignore [Sp Byref Ellipsis] Category=1 Description="Add or remove space between '&&' and '...'." Enabled=false EditorType=multiple Choices=sp_byref_ellipsis=ignore|sp_byref_ellipsis=add|sp_byref_ellipsis=remove|sp_byref_ellipsis=force|sp_byref_ellipsis=not_defined ChoicesReadable="Ignore Sp Byref Ellipsis|Add Sp Byref Ellipsis|Remove Sp Byref Ellipsis|Force Sp Byref Ellipsis" ValueDefault=ignore [Sp Paren Qualifier] Category=1 Description="Add or remove space between ')' and a qualifier such as 'const'." Enabled=false EditorType=multiple Choices=sp_paren_qualifier=ignore|sp_paren_qualifier=add|sp_paren_qualifier=remove|sp_paren_qualifier=force|sp_paren_qualifier=not_defined ChoicesReadable="Ignore Sp Paren Qualifier|Add Sp Paren Qualifier|Remove Sp Paren Qualifier|Force Sp Paren Qualifier" ValueDefault=ignore [Sp Paren Noexcept] Category=1 Description="Add or remove space between ')' and 'noexcept'." Enabled=false EditorType=multiple Choices=sp_paren_noexcept=ignore|sp_paren_noexcept=add|sp_paren_noexcept=remove|sp_paren_noexcept=force|sp_paren_noexcept=not_defined ChoicesReadable="Ignore Sp Paren Noexcept|Add Sp Paren Noexcept|Remove Sp Paren Noexcept|Force Sp Paren Noexcept" ValueDefault=ignore [Sp After Class Colon] Category=1 Description="Add or remove space after class ':'." Enabled=false EditorType=multiple Choices=sp_after_class_colon=ignore|sp_after_class_colon=add|sp_after_class_colon=remove|sp_after_class_colon=force|sp_after_class_colon=not_defined ChoicesReadable="Ignore Sp After Class Colon|Add Sp After Class Colon|Remove Sp After Class Colon|Force Sp After Class Colon" ValueDefault=ignore [Sp Before Class Colon] Category=1 Description="Add or remove space before class ':'." Enabled=false EditorType=multiple Choices=sp_before_class_colon=ignore|sp_before_class_colon=add|sp_before_class_colon=remove|sp_before_class_colon=force|sp_before_class_colon=not_defined ChoicesReadable="Ignore Sp Before Class Colon|Add Sp Before Class Colon|Remove Sp Before Class Colon|Force Sp Before Class Colon" ValueDefault=ignore [Sp After Constr Colon] Category=1 Description="Add or remove space after class constructor ':'.

Default: add" Enabled=false EditorType=multiple Choices=sp_after_constr_colon=ignore|sp_after_constr_colon=add|sp_after_constr_colon=remove|sp_after_constr_colon=force|sp_after_constr_colon=not_defined ChoicesReadable="Ignore Sp After Constr Colon|Add Sp After Constr Colon|Remove Sp After Constr Colon|Force Sp After Constr Colon" ValueDefault=add [Sp Before Constr Colon] Category=1 Description="Add or remove space before class constructor ':'.

Default: add" Enabled=false EditorType=multiple Choices=sp_before_constr_colon=ignore|sp_before_constr_colon=add|sp_before_constr_colon=remove|sp_before_constr_colon=force|sp_before_constr_colon=not_defined ChoicesReadable="Ignore Sp Before Constr Colon|Add Sp Before Constr Colon|Remove Sp Before Constr Colon|Force Sp Before Constr Colon" ValueDefault=add [Sp Before Case Colon] Category=1 Description="Add or remove space before case ':'.

Default: remove" Enabled=false EditorType=multiple Choices=sp_before_case_colon=ignore|sp_before_case_colon=add|sp_before_case_colon=remove|sp_before_case_colon=force|sp_before_case_colon=not_defined ChoicesReadable="Ignore Sp Before Case Colon|Add Sp Before Case Colon|Remove Sp Before Case Colon|Force Sp Before Case Colon" ValueDefault=remove [Sp After Operator] Category=1 Description="Add or remove space between 'operator' and operator sign." Enabled=false EditorType=multiple Choices=sp_after_operator=ignore|sp_after_operator=add|sp_after_operator=remove|sp_after_operator=force|sp_after_operator=not_defined ChoicesReadable="Ignore Sp After Operator|Add Sp After Operator|Remove Sp After Operator|Force Sp After Operator" ValueDefault=ignore [Sp After Operator Sym] Category=1 Description="Add or remove space between the operator symbol and the open parenthesis, as
in 'operator ++('." Enabled=false EditorType=multiple Choices=sp_after_operator_sym=ignore|sp_after_operator_sym=add|sp_after_operator_sym=remove|sp_after_operator_sym=force|sp_after_operator_sym=not_defined ChoicesReadable="Ignore Sp After Operator Sym|Add Sp After Operator Sym|Remove Sp After Operator Sym|Force Sp After Operator Sym" ValueDefault=ignore [Sp After Operator Sym Empty] Category=1 Description="Overrides sp_after_operator_sym when the operator has no arguments, as in
'operator *()'." Enabled=false EditorType=multiple Choices=sp_after_operator_sym_empty=ignore|sp_after_operator_sym_empty=add|sp_after_operator_sym_empty=remove|sp_after_operator_sym_empty=force|sp_after_operator_sym_empty=not_defined ChoicesReadable="Ignore Sp After Operator Sym Empty|Add Sp After Operator Sym Empty|Remove Sp After Operator Sym Empty|Force Sp After Operator Sym Empty" ValueDefault=ignore [Sp After Cast] Category=1 Description="Add or remove space after C/D cast, i.e. 'cast(int)a' vs. 'cast(int) a' or
'(int)a' vs. '(int) a'." Enabled=false EditorType=multiple Choices=sp_after_cast=ignore|sp_after_cast=add|sp_after_cast=remove|sp_after_cast=force|sp_after_cast=not_defined ChoicesReadable="Ignore Sp After Cast|Add Sp After Cast|Remove Sp After Cast|Force Sp After Cast" ValueDefault=ignore [Sp Inside Paren Cast] Category=1 Description="Add or remove spaces inside cast parentheses." Enabled=false EditorType=multiple Choices=sp_inside_paren_cast=ignore|sp_inside_paren_cast=add|sp_inside_paren_cast=remove|sp_inside_paren_cast=force|sp_inside_paren_cast=not_defined ChoicesReadable="Ignore Sp Inside Paren Cast|Add Sp Inside Paren Cast|Remove Sp Inside Paren Cast|Force Sp Inside Paren Cast" ValueDefault=ignore [Sp Cpp Cast Paren] Category=1 Description="Add or remove space between the type and open parenthesis in a C++ cast,
i.e. 'int(exp)' vs. 'int (exp)'." Enabled=false EditorType=multiple Choices=sp_cpp_cast_paren=ignore|sp_cpp_cast_paren=add|sp_cpp_cast_paren=remove|sp_cpp_cast_paren=force|sp_cpp_cast_paren=not_defined ChoicesReadable="Ignore Sp Cpp Cast Paren|Add Sp Cpp Cast Paren|Remove Sp Cpp Cast Paren|Force Sp Cpp Cast Paren" ValueDefault=ignore [Sp Sizeof Paren] Category=1 Description="Add or remove space between 'sizeof' and '('." Enabled=false EditorType=multiple Choices=sp_sizeof_paren=ignore|sp_sizeof_paren=add|sp_sizeof_paren=remove|sp_sizeof_paren=force|sp_sizeof_paren=not_defined ChoicesReadable="Ignore Sp Sizeof Paren|Add Sp Sizeof Paren|Remove Sp Sizeof Paren|Force Sp Sizeof Paren" ValueDefault=ignore [Sp Sizeof Ellipsis] Category=1 Description="Add or remove space between 'sizeof' and '...'." Enabled=false EditorType=multiple Choices=sp_sizeof_ellipsis=ignore|sp_sizeof_ellipsis=add|sp_sizeof_ellipsis=remove|sp_sizeof_ellipsis=force|sp_sizeof_ellipsis=not_defined ChoicesReadable="Ignore Sp Sizeof Ellipsis|Add Sp Sizeof Ellipsis|Remove Sp Sizeof Ellipsis|Force Sp Sizeof Ellipsis" ValueDefault=ignore [Sp Sizeof Ellipsis Paren] Category=1 Description="Add or remove space between 'sizeof...' and '('." Enabled=false EditorType=multiple Choices=sp_sizeof_ellipsis_paren=ignore|sp_sizeof_ellipsis_paren=add|sp_sizeof_ellipsis_paren=remove|sp_sizeof_ellipsis_paren=force|sp_sizeof_ellipsis_paren=not_defined ChoicesReadable="Ignore Sp Sizeof Ellipsis Paren|Add Sp Sizeof Ellipsis Paren|Remove Sp Sizeof Ellipsis Paren|Force Sp Sizeof Ellipsis Paren" ValueDefault=ignore [Sp Ellipsis Parameter Pack] Category=1 Description="Add or remove space between '...' and a parameter pack." Enabled=false EditorType=multiple Choices=sp_ellipsis_parameter_pack=ignore|sp_ellipsis_parameter_pack=add|sp_ellipsis_parameter_pack=remove|sp_ellipsis_parameter_pack=force|sp_ellipsis_parameter_pack=not_defined ChoicesReadable="Ignore Sp Ellipsis Parameter Pack|Add Sp Ellipsis Parameter Pack|Remove Sp Ellipsis Parameter Pack|Force Sp Ellipsis Parameter Pack" ValueDefault=ignore [Sp Parameter Pack Ellipsis] Category=1 Description="Add or remove space between a parameter pack and '...'." Enabled=false EditorType=multiple Choices=sp_parameter_pack_ellipsis=ignore|sp_parameter_pack_ellipsis=add|sp_parameter_pack_ellipsis=remove|sp_parameter_pack_ellipsis=force|sp_parameter_pack_ellipsis=not_defined ChoicesReadable="Ignore Sp Parameter Pack Ellipsis|Add Sp Parameter Pack Ellipsis|Remove Sp Parameter Pack Ellipsis|Force Sp Parameter Pack Ellipsis" ValueDefault=ignore [Sp Decltype Paren] Category=1 Description="Add or remove space between 'decltype' and '('." Enabled=false EditorType=multiple Choices=sp_decltype_paren=ignore|sp_decltype_paren=add|sp_decltype_paren=remove|sp_decltype_paren=force|sp_decltype_paren=not_defined ChoicesReadable="Ignore Sp Decltype Paren|Add Sp Decltype Paren|Remove Sp Decltype Paren|Force Sp Decltype Paren" ValueDefault=ignore [Sp After Tag] Category=1 Description="(Pawn) Add or remove space after the tag keyword." Enabled=false EditorType=multiple Choices=sp_after_tag=ignore|sp_after_tag=add|sp_after_tag=remove|sp_after_tag=force|sp_after_tag=not_defined ChoicesReadable="Ignore Sp After Tag|Add Sp After Tag|Remove Sp After Tag|Force Sp After Tag" ValueDefault=ignore [Sp Inside Braces Enum] Category=1 Description="Add or remove space inside enum '{' and '}'." Enabled=false EditorType=multiple Choices=sp_inside_braces_enum=ignore|sp_inside_braces_enum=add|sp_inside_braces_enum=remove|sp_inside_braces_enum=force|sp_inside_braces_enum=not_defined ChoicesReadable="Ignore Sp Inside Braces Enum|Add Sp Inside Braces Enum|Remove Sp Inside Braces Enum|Force Sp Inside Braces Enum" ValueDefault=ignore [Sp Inside Braces Struct] Category=1 Description="Add or remove space inside struct/union '{' and '}'." Enabled=false EditorType=multiple Choices=sp_inside_braces_struct=ignore|sp_inside_braces_struct=add|sp_inside_braces_struct=remove|sp_inside_braces_struct=force|sp_inside_braces_struct=not_defined ChoicesReadable="Ignore Sp Inside Braces Struct|Add Sp Inside Braces Struct|Remove Sp Inside Braces Struct|Force Sp Inside Braces Struct" ValueDefault=ignore [Sp Inside Braces Oc Dict] Category=1 Description="(OC) Add or remove space inside Objective-C boxed dictionary '{' and '}'" Enabled=false EditorType=multiple Choices=sp_inside_braces_oc_dict=ignore|sp_inside_braces_oc_dict=add|sp_inside_braces_oc_dict=remove|sp_inside_braces_oc_dict=force|sp_inside_braces_oc_dict=not_defined ChoicesReadable="Ignore Sp Inside Braces Oc Dict|Add Sp Inside Braces Oc Dict|Remove Sp Inside Braces Oc Dict|Force Sp Inside Braces Oc Dict" ValueDefault=ignore [Sp After Type Brace Init Lst Open] Category=1 Description="Add or remove space after open brace in an unnamed temporary
direct-list-initialization
if statement is a brace_init_lst
works only if sp_brace_brace is set to ignore." Enabled=false EditorType=multiple Choices=sp_after_type_brace_init_lst_open=ignore|sp_after_type_brace_init_lst_open=add|sp_after_type_brace_init_lst_open=remove|sp_after_type_brace_init_lst_open=force|sp_after_type_brace_init_lst_open=not_defined ChoicesReadable="Ignore Sp After Type Brace Init Lst Open|Add Sp After Type Brace Init Lst Open|Remove Sp After Type Brace Init Lst Open|Force Sp After Type Brace Init Lst Open" ValueDefault=ignore [Sp Before Type Brace Init Lst Close] Category=1 Description="Add or remove space before close brace in an unnamed temporary
direct-list-initialization
if statement is a brace_init_lst
works only if sp_brace_brace is set to ignore." Enabled=false EditorType=multiple Choices=sp_before_type_brace_init_lst_close=ignore|sp_before_type_brace_init_lst_close=add|sp_before_type_brace_init_lst_close=remove|sp_before_type_brace_init_lst_close=force|sp_before_type_brace_init_lst_close=not_defined ChoicesReadable="Ignore Sp Before Type Brace Init Lst Close|Add Sp Before Type Brace Init Lst Close|Remove Sp Before Type Brace Init Lst Close|Force Sp Before Type Brace Init Lst Close" ValueDefault=ignore [Sp Inside Type Brace Init Lst] Category=1 Description="Add or remove space inside an unnamed temporary direct-list-initialization
if statement is a brace_init_lst
works only if sp_brace_brace is set to ignore
works only if sp_before_type_brace_init_lst_close is set to ignore." Enabled=false EditorType=multiple Choices=sp_inside_type_brace_init_lst=ignore|sp_inside_type_brace_init_lst=add|sp_inside_type_brace_init_lst=remove|sp_inside_type_brace_init_lst=force|sp_inside_type_brace_init_lst=not_defined ChoicesReadable="Ignore Sp Inside Type Brace Init Lst|Add Sp Inside Type Brace Init Lst|Remove Sp Inside Type Brace Init Lst|Force Sp Inside Type Brace Init Lst" ValueDefault=ignore [Sp Inside Braces] Category=1 Description="Add or remove space inside '{' and '}'." Enabled=false EditorType=multiple Choices=sp_inside_braces=ignore|sp_inside_braces=add|sp_inside_braces=remove|sp_inside_braces=force|sp_inside_braces=not_defined ChoicesReadable="Ignore Sp Inside Braces|Add Sp Inside Braces|Remove Sp Inside Braces|Force Sp Inside Braces" ValueDefault=ignore [Sp Inside Braces Empty] Category=1 Description="Add or remove space inside '{}'." Enabled=false EditorType=multiple Choices=sp_inside_braces_empty=ignore|sp_inside_braces_empty=add|sp_inside_braces_empty=remove|sp_inside_braces_empty=force|sp_inside_braces_empty=not_defined ChoicesReadable="Ignore Sp Inside Braces Empty|Add Sp Inside Braces Empty|Remove Sp Inside Braces Empty|Force Sp Inside Braces Empty" ValueDefault=ignore [Sp Trailing Return] Category=1 Description="Add or remove space around trailing return operator '->'." Enabled=false EditorType=multiple Choices=sp_trailing_return=ignore|sp_trailing_return=add|sp_trailing_return=remove|sp_trailing_return=force|sp_trailing_return=not_defined ChoicesReadable="Ignore Sp Trailing Return|Add Sp Trailing Return|Remove Sp Trailing Return|Force Sp Trailing Return" ValueDefault=ignore [Sp Type Func] Category=1 Description="Add or remove space between return type and function name. A minimum of 1
is forced except for pointer return types." Enabled=false EditorType=multiple Choices=sp_type_func=ignore|sp_type_func=add|sp_type_func=remove|sp_type_func=force|sp_type_func=not_defined ChoicesReadable="Ignore Sp Type Func|Add Sp Type Func|Remove Sp Type Func|Force Sp Type Func" ValueDefault=ignore [Sp Type Brace Init Lst] Category=1 Description="Add or remove space between type and open brace of an unnamed temporary
direct-list-initialization." Enabled=false EditorType=multiple Choices=sp_type_brace_init_lst=ignore|sp_type_brace_init_lst=add|sp_type_brace_init_lst=remove|sp_type_brace_init_lst=force|sp_type_brace_init_lst=not_defined ChoicesReadable="Ignore Sp Type Brace Init Lst|Add Sp Type Brace Init Lst|Remove Sp Type Brace Init Lst|Force Sp Type Brace Init Lst" ValueDefault=ignore [Sp Func Proto Paren] Category=1 Description="Add or remove space between function name and '(' on function declaration." Enabled=false EditorType=multiple Choices=sp_func_proto_paren=ignore|sp_func_proto_paren=add|sp_func_proto_paren=remove|sp_func_proto_paren=force|sp_func_proto_paren=not_defined ChoicesReadable="Ignore Sp Func Proto Paren|Add Sp Func Proto Paren|Remove Sp Func Proto Paren|Force Sp Func Proto Paren" ValueDefault=ignore [Sp Func Proto Paren Empty] Category=1 Description="Add or remove space between function name and '()' on function declaration
without parameters." Enabled=false EditorType=multiple Choices=sp_func_proto_paren_empty=ignore|sp_func_proto_paren_empty=add|sp_func_proto_paren_empty=remove|sp_func_proto_paren_empty=force|sp_func_proto_paren_empty=not_defined ChoicesReadable="Ignore Sp Func Proto Paren Empty|Add Sp Func Proto Paren Empty|Remove Sp Func Proto Paren Empty|Force Sp Func Proto Paren Empty" ValueDefault=ignore [Sp Func Type Paren] Category=1 Description="Add or remove space between function name and '(' with a typedef specifier." Enabled=false EditorType=multiple Choices=sp_func_type_paren=ignore|sp_func_type_paren=add|sp_func_type_paren=remove|sp_func_type_paren=force|sp_func_type_paren=not_defined ChoicesReadable="Ignore Sp Func Type Paren|Add Sp Func Type Paren|Remove Sp Func Type Paren|Force Sp Func Type Paren" ValueDefault=ignore [Sp Func Def Paren] Category=1 Description="Add or remove space between alias name and '(' of a non-pointer function type typedef." Enabled=false EditorType=multiple Choices=sp_func_def_paren=ignore|sp_func_def_paren=add|sp_func_def_paren=remove|sp_func_def_paren=force|sp_func_def_paren=not_defined ChoicesReadable="Ignore Sp Func Def Paren|Add Sp Func Def Paren|Remove Sp Func Def Paren|Force Sp Func Def Paren" ValueDefault=ignore [Sp Func Def Paren Empty] Category=1 Description="Add or remove space between function name and '()' on function definition
without parameters." Enabled=false EditorType=multiple Choices=sp_func_def_paren_empty=ignore|sp_func_def_paren_empty=add|sp_func_def_paren_empty=remove|sp_func_def_paren_empty=force|sp_func_def_paren_empty=not_defined ChoicesReadable="Ignore Sp Func Def Paren Empty|Add Sp Func Def Paren Empty|Remove Sp Func Def Paren Empty|Force Sp Func Def Paren Empty" ValueDefault=ignore [Sp Inside Fparens] Category=1 Description="Add or remove space inside empty function '()'.
Overrides sp_after_angle unless use_sp_after_angle_always is set to true." Enabled=false EditorType=multiple Choices=sp_inside_fparens=ignore|sp_inside_fparens=add|sp_inside_fparens=remove|sp_inside_fparens=force|sp_inside_fparens=not_defined ChoicesReadable="Ignore Sp Inside Fparens|Add Sp Inside Fparens|Remove Sp Inside Fparens|Force Sp Inside Fparens" ValueDefault=ignore [Sp Inside Fparen] Category=1 Description="Add or remove space inside function '(' and ')'." Enabled=false EditorType=multiple Choices=sp_inside_fparen=ignore|sp_inside_fparen=add|sp_inside_fparen=remove|sp_inside_fparen=force|sp_inside_fparen=not_defined ChoicesReadable="Ignore Sp Inside Fparen|Add Sp Inside Fparen|Remove Sp Inside Fparen|Force Sp Inside Fparen" ValueDefault=ignore [Sp Inside Tparen] Category=1 Description="Add or remove space inside the first parentheses in a function type, as in
'void (*x)(...)'." Enabled=false EditorType=multiple Choices=sp_inside_tparen=ignore|sp_inside_tparen=add|sp_inside_tparen=remove|sp_inside_tparen=force|sp_inside_tparen=not_defined ChoicesReadable="Ignore Sp Inside Tparen|Add Sp Inside Tparen|Remove Sp Inside Tparen|Force Sp Inside Tparen" ValueDefault=ignore [Sp After Tparen Close] Category=1 Description="Add or remove space between the ')' and '(' in a function type, as in
'void (*x)(...)'." Enabled=false EditorType=multiple Choices=sp_after_tparen_close=ignore|sp_after_tparen_close=add|sp_after_tparen_close=remove|sp_after_tparen_close=force|sp_after_tparen_close=not_defined ChoicesReadable="Ignore Sp After Tparen Close|Add Sp After Tparen Close|Remove Sp After Tparen Close|Force Sp After Tparen Close" ValueDefault=ignore [Sp Square Fparen] Category=1 Description="Add or remove space between ']' and '(' when part of a function call." Enabled=false EditorType=multiple Choices=sp_square_fparen=ignore|sp_square_fparen=add|sp_square_fparen=remove|sp_square_fparen=force|sp_square_fparen=not_defined ChoicesReadable="Ignore Sp Square Fparen|Add Sp Square Fparen|Remove Sp Square Fparen|Force Sp Square Fparen" ValueDefault=ignore [Sp Fparen Brace] Category=1 Description="Add or remove space between ')' and '{' of function." Enabled=false EditorType=multiple Choices=sp_fparen_brace=ignore|sp_fparen_brace=add|sp_fparen_brace=remove|sp_fparen_brace=force|sp_fparen_brace=not_defined ChoicesReadable="Ignore Sp Fparen Brace|Add Sp Fparen Brace|Remove Sp Fparen Brace|Force Sp Fparen Brace" ValueDefault=ignore [Sp Fparen Brace Initializer] Category=1 Description="Add or remove space between ')' and '{' of a function call in object
initialization.

Overrides sp_fparen_brace." Enabled=false EditorType=multiple Choices=sp_fparen_brace_initializer=ignore|sp_fparen_brace_initializer=add|sp_fparen_brace_initializer=remove|sp_fparen_brace_initializer=force|sp_fparen_brace_initializer=not_defined ChoicesReadable="Ignore Sp Fparen Brace Initializer|Add Sp Fparen Brace Initializer|Remove Sp Fparen Brace Initializer|Force Sp Fparen Brace Initializer" ValueDefault=ignore [Sp Fparen Dbrace] Category=1 Description="(Java) Add or remove space between ')' and '{{' of double brace initializer." Enabled=false EditorType=multiple Choices=sp_fparen_dbrace=ignore|sp_fparen_dbrace=add|sp_fparen_dbrace=remove|sp_fparen_dbrace=force|sp_fparen_dbrace=not_defined ChoicesReadable="Ignore Sp Fparen Dbrace|Add Sp Fparen Dbrace|Remove Sp Fparen Dbrace|Force Sp Fparen Dbrace" ValueDefault=ignore [Sp Func Call Paren] Category=1 Description="Add or remove space between function name and '(' on function calls." Enabled=false EditorType=multiple Choices=sp_func_call_paren=ignore|sp_func_call_paren=add|sp_func_call_paren=remove|sp_func_call_paren=force|sp_func_call_paren=not_defined ChoicesReadable="Ignore Sp Func Call Paren|Add Sp Func Call Paren|Remove Sp Func Call Paren|Force Sp Func Call Paren" ValueDefault=ignore [Sp Func Call Paren Empty] Category=1 Description="Add or remove space between function name and '()' on function calls without
parameters. If set to ignore (the default), sp_func_call_paren is used." Enabled=false EditorType=multiple Choices=sp_func_call_paren_empty=ignore|sp_func_call_paren_empty=add|sp_func_call_paren_empty=remove|sp_func_call_paren_empty=force|sp_func_call_paren_empty=not_defined ChoicesReadable="Ignore Sp Func Call Paren Empty|Add Sp Func Call Paren Empty|Remove Sp Func Call Paren Empty|Force Sp Func Call Paren Empty" ValueDefault=ignore [Sp Func Call User Paren] Category=1 Description="Add or remove space between the user function name and '(' on function
calls. You need to set a keyword to be a user function in the config file,
like:
set func_call_user tr _ i18n" Enabled=false EditorType=multiple Choices=sp_func_call_user_paren=ignore|sp_func_call_user_paren=add|sp_func_call_user_paren=remove|sp_func_call_user_paren=force|sp_func_call_user_paren=not_defined ChoicesReadable="Ignore Sp Func Call User Paren|Add Sp Func Call User Paren|Remove Sp Func Call User Paren|Force Sp Func Call User Paren" ValueDefault=ignore [Sp Func Call User Inside Fparen] Category=1 Description="Add or remove space inside user function '(' and ')'." Enabled=false EditorType=multiple Choices=sp_func_call_user_inside_fparen=ignore|sp_func_call_user_inside_fparen=add|sp_func_call_user_inside_fparen=remove|sp_func_call_user_inside_fparen=force|sp_func_call_user_inside_fparen=not_defined ChoicesReadable="Ignore Sp Func Call User Inside Fparen|Add Sp Func Call User Inside Fparen|Remove Sp Func Call User Inside Fparen|Force Sp Func Call User Inside Fparen" ValueDefault=ignore [Sp Func Call User Paren Paren] Category=1 Description="Add or remove space between nested parentheses with user functions,
i.e. '((' vs. '( ('." Enabled=false EditorType=multiple Choices=sp_func_call_user_paren_paren=ignore|sp_func_call_user_paren_paren=add|sp_func_call_user_paren_paren=remove|sp_func_call_user_paren_paren=force|sp_func_call_user_paren_paren=not_defined ChoicesReadable="Ignore Sp Func Call User Paren Paren|Add Sp Func Call User Paren Paren|Remove Sp Func Call User Paren Paren|Force Sp Func Call User Paren Paren" ValueDefault=ignore [Sp Func Class Paren] Category=1 Description="Add or remove space between a constructor/destructor and the open
parenthesis." Enabled=false EditorType=multiple Choices=sp_func_class_paren=ignore|sp_func_class_paren=add|sp_func_class_paren=remove|sp_func_class_paren=force|sp_func_class_paren=not_defined ChoicesReadable="Ignore Sp Func Class Paren|Add Sp Func Class Paren|Remove Sp Func Class Paren|Force Sp Func Class Paren" ValueDefault=ignore [Sp Func Class Paren Empty] Category=1 Description="Add or remove space between a constructor without parameters or destructor
and '()'." Enabled=false EditorType=multiple Choices=sp_func_class_paren_empty=ignore|sp_func_class_paren_empty=add|sp_func_class_paren_empty=remove|sp_func_class_paren_empty=force|sp_func_class_paren_empty=not_defined ChoicesReadable="Ignore Sp Func Class Paren Empty|Add Sp Func Class Paren Empty|Remove Sp Func Class Paren Empty|Force Sp Func Class Paren Empty" ValueDefault=ignore [Sp Return] Category=1 Description="Add or remove space after 'return'.

Default: force" Enabled=false EditorType=multiple Choices=sp_return=ignore|sp_return=add|sp_return=remove|sp_return=force|sp_return=not_defined ChoicesReadable="Ignore Sp Return|Add Sp Return|Remove Sp Return|Force Sp Return" ValueDefault=force [Sp Return Paren] Category=1 Description="Add or remove space between 'return' and '('." Enabled=false EditorType=multiple Choices=sp_return_paren=ignore|sp_return_paren=add|sp_return_paren=remove|sp_return_paren=force|sp_return_paren=not_defined ChoicesReadable="Ignore Sp Return Paren|Add Sp Return Paren|Remove Sp Return Paren|Force Sp Return Paren" ValueDefault=ignore [Sp Return Brace] Category=1 Description="Add or remove space between 'return' and '{'." Enabled=false EditorType=multiple Choices=sp_return_brace=ignore|sp_return_brace=add|sp_return_brace=remove|sp_return_brace=force|sp_return_brace=not_defined ChoicesReadable="Ignore Sp Return Brace|Add Sp Return Brace|Remove Sp Return Brace|Force Sp Return Brace" ValueDefault=ignore [Sp Attribute Paren] Category=1 Description="Add or remove space between '__attribute__' and '('." Enabled=false EditorType=multiple Choices=sp_attribute_paren=ignore|sp_attribute_paren=add|sp_attribute_paren=remove|sp_attribute_paren=force|sp_attribute_paren=not_defined ChoicesReadable="Ignore Sp Attribute Paren|Add Sp Attribute Paren|Remove Sp Attribute Paren|Force Sp Attribute Paren" ValueDefault=ignore [Sp Defined Paren] Category=1 Description="Add or remove space between 'defined' and '(' in '#if defined (FOO)'." Enabled=false EditorType=multiple Choices=sp_defined_paren=ignore|sp_defined_paren=add|sp_defined_paren=remove|sp_defined_paren=force|sp_defined_paren=not_defined ChoicesReadable="Ignore Sp Defined Paren|Add Sp Defined Paren|Remove Sp Defined Paren|Force Sp Defined Paren" ValueDefault=ignore [Sp Throw Paren] Category=1 Description="Add or remove space between 'throw' and '(' in 'throw (something)'." Enabled=false EditorType=multiple Choices=sp_throw_paren=ignore|sp_throw_paren=add|sp_throw_paren=remove|sp_throw_paren=force|sp_throw_paren=not_defined ChoicesReadable="Ignore Sp Throw Paren|Add Sp Throw Paren|Remove Sp Throw Paren|Force Sp Throw Paren" ValueDefault=ignore [Sp After Throw] Category=1 Description="Add or remove space between 'throw' and anything other than '(' as in
'@throw [...];'." Enabled=false EditorType=multiple Choices=sp_after_throw=ignore|sp_after_throw=add|sp_after_throw=remove|sp_after_throw=force|sp_after_throw=not_defined ChoicesReadable="Ignore Sp After Throw|Add Sp After Throw|Remove Sp After Throw|Force Sp After Throw" ValueDefault=ignore [Sp Catch Paren] Category=1 Description="Add or remove space between 'catch' and '(' in 'catch (something) { }'.
If set to ignore, sp_before_sparen is used." Enabled=false EditorType=multiple Choices=sp_catch_paren=ignore|sp_catch_paren=add|sp_catch_paren=remove|sp_catch_paren=force|sp_catch_paren=not_defined ChoicesReadable="Ignore Sp Catch Paren|Add Sp Catch Paren|Remove Sp Catch Paren|Force Sp Catch Paren" ValueDefault=ignore [Sp Oc Catch Paren] Category=1 Description="(OC) Add or remove space between '@catch' and '('
in '@catch (something) { }'. If set to ignore, sp_catch_paren is used." Enabled=false EditorType=multiple Choices=sp_oc_catch_paren=ignore|sp_oc_catch_paren=add|sp_oc_catch_paren=remove|sp_oc_catch_paren=force|sp_oc_catch_paren=not_defined ChoicesReadable="Ignore Sp Oc Catch Paren|Add Sp Oc Catch Paren|Remove Sp Oc Catch Paren|Force Sp Oc Catch Paren" ValueDefault=ignore [Sp Before Oc Proto List] Category=1 Description="(OC) Add or remove space before Objective-C protocol list
as in '@protocol Protocol<here><Protocol_A>' or '@interface MyClass : NSObject<here><MyProtocol>'." Enabled=false EditorType=multiple Choices=sp_before_oc_proto_list=ignore|sp_before_oc_proto_list=add|sp_before_oc_proto_list=remove|sp_before_oc_proto_list=force|sp_before_oc_proto_list=not_defined ChoicesReadable="Ignore Sp Before Oc Proto List|Add Sp Before Oc Proto List|Remove Sp Before Oc Proto List|Force Sp Before Oc Proto List" ValueDefault=ignore [Sp Oc Classname Paren] Category=1 Description="(OC) Add or remove space between class name and '('
in '@interface className(categoryName)<ProtocolName>:BaseClass'" Enabled=false EditorType=multiple Choices=sp_oc_classname_paren=ignore|sp_oc_classname_paren=add|sp_oc_classname_paren=remove|sp_oc_classname_paren=force|sp_oc_classname_paren=not_defined ChoicesReadable="Ignore Sp Oc Classname Paren|Add Sp Oc Classname Paren|Remove Sp Oc Classname Paren|Force Sp Oc Classname Paren" ValueDefault=ignore [Sp Version Paren] Category=1 Description="(D) Add or remove space between 'version' and '('
in 'version (something) { }'. If set to ignore, sp_before_sparen is used." Enabled=false EditorType=multiple Choices=sp_version_paren=ignore|sp_version_paren=add|sp_version_paren=remove|sp_version_paren=force|sp_version_paren=not_defined ChoicesReadable="Ignore Sp Version Paren|Add Sp Version Paren|Remove Sp Version Paren|Force Sp Version Paren" ValueDefault=ignore [Sp Scope Paren] Category=1 Description="(D) Add or remove space between 'scope' and '('
in 'scope (something) { }'. If set to ignore, sp_before_sparen is used." Enabled=false EditorType=multiple Choices=sp_scope_paren=ignore|sp_scope_paren=add|sp_scope_paren=remove|sp_scope_paren=force|sp_scope_paren=not_defined ChoicesReadable="Ignore Sp Scope Paren|Add Sp Scope Paren|Remove Sp Scope Paren|Force Sp Scope Paren" ValueDefault=ignore [Sp Super Paren] Category=1 Description="Add or remove space between 'super' and '(' in 'super (something)'.

Default: remove" Enabled=false EditorType=multiple Choices=sp_super_paren=ignore|sp_super_paren=add|sp_super_paren=remove|sp_super_paren=force|sp_super_paren=not_defined ChoicesReadable="Ignore Sp Super Paren|Add Sp Super Paren|Remove Sp Super Paren|Force Sp Super Paren" ValueDefault=remove [Sp This Paren] Category=1 Description="Add or remove space between 'this' and '(' in 'this (something)'.

Default: remove" Enabled=false EditorType=multiple Choices=sp_this_paren=ignore|sp_this_paren=add|sp_this_paren=remove|sp_this_paren=force|sp_this_paren=not_defined ChoicesReadable="Ignore Sp This Paren|Add Sp This Paren|Remove Sp This Paren|Force Sp This Paren" ValueDefault=remove [Sp Macro] Category=1 Description="Add or remove space between a macro name and its definition." Enabled=false EditorType=multiple Choices=sp_macro=ignore|sp_macro=add|sp_macro=remove|sp_macro=force|sp_macro=not_defined ChoicesReadable="Ignore Sp Macro|Add Sp Macro|Remove Sp Macro|Force Sp Macro" ValueDefault=ignore [Sp Macro Func] Category=1 Description="Add or remove space between a macro function ')' and its definition." Enabled=false EditorType=multiple Choices=sp_macro_func=ignore|sp_macro_func=add|sp_macro_func=remove|sp_macro_func=force|sp_macro_func=not_defined ChoicesReadable="Ignore Sp Macro Func|Add Sp Macro Func|Remove Sp Macro Func|Force Sp Macro Func" ValueDefault=ignore [Sp Else Brace] Category=1 Description="Add or remove space between 'else' and '{' if on the same line." Enabled=false EditorType=multiple Choices=sp_else_brace=ignore|sp_else_brace=add|sp_else_brace=remove|sp_else_brace=force|sp_else_brace=not_defined ChoicesReadable="Ignore Sp Else Brace|Add Sp Else Brace|Remove Sp Else Brace|Force Sp Else Brace" ValueDefault=ignore [Sp Brace Else] Category=1 Description="Add or remove space between '}' and 'else' if on the same line." Enabled=false EditorType=multiple Choices=sp_brace_else=ignore|sp_brace_else=add|sp_brace_else=remove|sp_brace_else=force|sp_brace_else=not_defined ChoicesReadable="Ignore Sp Brace Else|Add Sp Brace Else|Remove Sp Brace Else|Force Sp Brace Else" ValueDefault=ignore [Sp Brace Typedef] Category=1 Description="Add or remove space between '}' and the name of a typedef on the same line." Enabled=false EditorType=multiple Choices=sp_brace_typedef=ignore|sp_brace_typedef=add|sp_brace_typedef=remove|sp_brace_typedef=force|sp_brace_typedef=not_defined ChoicesReadable="Ignore Sp Brace Typedef|Add Sp Brace Typedef|Remove Sp Brace Typedef|Force Sp Brace Typedef" ValueDefault=ignore [Sp Catch Brace] Category=1 Description="Add or remove space before the '{' of a 'catch' statement, if the '{' and
'catch' are on the same line, as in 'catch (decl) <here> {'." Enabled=false EditorType=multiple Choices=sp_catch_brace=ignore|sp_catch_brace=add|sp_catch_brace=remove|sp_catch_brace=force|sp_catch_brace=not_defined ChoicesReadable="Ignore Sp Catch Brace|Add Sp Catch Brace|Remove Sp Catch Brace|Force Sp Catch Brace" ValueDefault=ignore [Sp Oc Catch Brace] Category=1 Description="(OC) Add or remove space before the '{' of a '@catch' statement, if the '{'
and '@catch' are on the same line, as in '@catch (decl) <here> {'.
If set to ignore, sp_catch_brace is used." Enabled=false EditorType=multiple Choices=sp_oc_catch_brace=ignore|sp_oc_catch_brace=add|sp_oc_catch_brace=remove|sp_oc_catch_brace=force|sp_oc_catch_brace=not_defined ChoicesReadable="Ignore Sp Oc Catch Brace|Add Sp Oc Catch Brace|Remove Sp Oc Catch Brace|Force Sp Oc Catch Brace" ValueDefault=ignore [Sp Brace Catch] Category=1 Description="Add or remove space between '}' and 'catch' if on the same line." Enabled=false EditorType=multiple Choices=sp_brace_catch=ignore|sp_brace_catch=add|sp_brace_catch=remove|sp_brace_catch=force|sp_brace_catch=not_defined ChoicesReadable="Ignore Sp Brace Catch|Add Sp Brace Catch|Remove Sp Brace Catch|Force Sp Brace Catch" ValueDefault=ignore [Sp Oc Brace Catch] Category=1 Description="(OC) Add or remove space between '}' and '@catch' if on the same line.
If set to ignore, sp_brace_catch is used." Enabled=false EditorType=multiple Choices=sp_oc_brace_catch=ignore|sp_oc_brace_catch=add|sp_oc_brace_catch=remove|sp_oc_brace_catch=force|sp_oc_brace_catch=not_defined ChoicesReadable="Ignore Sp Oc Brace Catch|Add Sp Oc Brace Catch|Remove Sp Oc Brace Catch|Force Sp Oc Brace Catch" ValueDefault=ignore [Sp Finally Brace] Category=1 Description="Add or remove space between 'finally' and '{' if on the same line." Enabled=false EditorType=multiple Choices=sp_finally_brace=ignore|sp_finally_brace=add|sp_finally_brace=remove|sp_finally_brace=force|sp_finally_brace=not_defined ChoicesReadable="Ignore Sp Finally Brace|Add Sp Finally Brace|Remove Sp Finally Brace|Force Sp Finally Brace" ValueDefault=ignore [Sp Brace Finally] Category=1 Description="Add or remove space between '}' and 'finally' if on the same line." Enabled=false EditorType=multiple Choices=sp_brace_finally=ignore|sp_brace_finally=add|sp_brace_finally=remove|sp_brace_finally=force|sp_brace_finally=not_defined ChoicesReadable="Ignore Sp Brace Finally|Add Sp Brace Finally|Remove Sp Brace Finally|Force Sp Brace Finally" ValueDefault=ignore [Sp Try Brace] Category=1 Description="Add or remove space between 'try' and '{' if on the same line." Enabled=false EditorType=multiple Choices=sp_try_brace=ignore|sp_try_brace=add|sp_try_brace=remove|sp_try_brace=force|sp_try_brace=not_defined ChoicesReadable="Ignore Sp Try Brace|Add Sp Try Brace|Remove Sp Try Brace|Force Sp Try Brace" ValueDefault=ignore [Sp Getset Brace] Category=1 Description="Add or remove space between get/set and '{' if on the same line." Enabled=false EditorType=multiple Choices=sp_getset_brace=ignore|sp_getset_brace=add|sp_getset_brace=remove|sp_getset_brace=force|sp_getset_brace=not_defined ChoicesReadable="Ignore Sp Getset Brace|Add Sp Getset Brace|Remove Sp Getset Brace|Force Sp Getset Brace" ValueDefault=ignore [Sp Word Brace Init Lst] Category=1 Description="Add or remove space between a variable and '{' for C++ uniform
initialization." Enabled=false EditorType=multiple Choices=sp_word_brace_init_lst=ignore|sp_word_brace_init_lst=add|sp_word_brace_init_lst=remove|sp_word_brace_init_lst=force|sp_word_brace_init_lst=not_defined ChoicesReadable="Ignore Sp Word Brace Init Lst|Add Sp Word Brace Init Lst|Remove Sp Word Brace Init Lst|Force Sp Word Brace Init Lst" ValueDefault=ignore [Sp Word Brace Ns] Category=1 Description="Add or remove space between a variable and '{' for a namespace.

Default: add" Enabled=false EditorType=multiple Choices=sp_word_brace_ns=ignore|sp_word_brace_ns=add|sp_word_brace_ns=remove|sp_word_brace_ns=force|sp_word_brace_ns=not_defined ChoicesReadable="Ignore Sp Word Brace Ns|Add Sp Word Brace Ns|Remove Sp Word Brace Ns|Force Sp Word Brace Ns" ValueDefault=add [Sp Before Dc] Category=1 Description="Add or remove space before the '::' operator." Enabled=false EditorType=multiple Choices=sp_before_dc=ignore|sp_before_dc=add|sp_before_dc=remove|sp_before_dc=force|sp_before_dc=not_defined ChoicesReadable="Ignore Sp Before Dc|Add Sp Before Dc|Remove Sp Before Dc|Force Sp Before Dc" ValueDefault=ignore [Sp After Dc] Category=1 Description="Add or remove space after the '::' operator." Enabled=false EditorType=multiple Choices=sp_after_dc=ignore|sp_after_dc=add|sp_after_dc=remove|sp_after_dc=force|sp_after_dc=not_defined ChoicesReadable="Ignore Sp After Dc|Add Sp After Dc|Remove Sp After Dc|Force Sp After Dc" ValueDefault=ignore [Sp D Array Colon] Category=1 Description="(D) Add or remove around the D named array initializer ':' operator." Enabled=false EditorType=multiple Choices=sp_d_array_colon=ignore|sp_d_array_colon=add|sp_d_array_colon=remove|sp_d_array_colon=force|sp_d_array_colon=not_defined ChoicesReadable="Ignore Sp D Array Colon|Add Sp D Array Colon|Remove Sp D Array Colon|Force Sp D Array Colon" ValueDefault=ignore [Sp Not] Category=1 Description="Add or remove space after the '!' (not) unary operator.

Default: remove" Enabled=false EditorType=multiple Choices=sp_not=ignore|sp_not=add|sp_not=remove|sp_not=force|sp_not=not_defined ChoicesReadable="Ignore Sp Not|Add Sp Not|Remove Sp Not|Force Sp Not" ValueDefault=remove [Sp Not Not] Category=1 Description="Add or remove space between two '!' (not) unary operators.
If set to ignore, sp_not will be used." Enabled=false EditorType=multiple Choices=sp_not_not=ignore|sp_not_not=add|sp_not_not=remove|sp_not_not=force|sp_not_not=not_defined ChoicesReadable="Ignore Sp Not Not|Add Sp Not Not|Remove Sp Not Not|Force Sp Not Not" ValueDefault=ignore [Sp Inv] Category=1 Description="Add or remove space after the '~' (invert) unary operator.

Default: remove" Enabled=false EditorType=multiple Choices=sp_inv=ignore|sp_inv=add|sp_inv=remove|sp_inv=force|sp_inv=not_defined ChoicesReadable="Ignore Sp Inv|Add Sp Inv|Remove Sp Inv|Force Sp Inv" ValueDefault=remove [Sp Addr] Category=1 Description="Add or remove space after the '&' (address-of) unary operator. This does not
affect the spacing after a '&' that is part of a type.

Default: remove" Enabled=false EditorType=multiple Choices=sp_addr=ignore|sp_addr=add|sp_addr=remove|sp_addr=force|sp_addr=not_defined ChoicesReadable="Ignore Sp Addr|Add Sp Addr|Remove Sp Addr|Force Sp Addr" ValueDefault=remove [Sp Member] Category=1 Description="Add or remove space around the '.' or '->' operators.

Default: remove" Enabled=false EditorType=multiple Choices=sp_member=ignore|sp_member=add|sp_member=remove|sp_member=force|sp_member=not_defined ChoicesReadable="Ignore Sp Member|Add Sp Member|Remove Sp Member|Force Sp Member" ValueDefault=remove [Sp Deref] Category=1 Description="Add or remove space after the '*' (dereference) unary operator. This does
not affect the spacing after a '*' that is part of a type.

Default: remove" Enabled=false EditorType=multiple Choices=sp_deref=ignore|sp_deref=add|sp_deref=remove|sp_deref=force|sp_deref=not_defined ChoicesReadable="Ignore Sp Deref|Add Sp Deref|Remove Sp Deref|Force Sp Deref" ValueDefault=remove [Sp Sign] Category=1 Description="Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'.

Default: remove" Enabled=false EditorType=multiple Choices=sp_sign=ignore|sp_sign=add|sp_sign=remove|sp_sign=force|sp_sign=not_defined ChoicesReadable="Ignore Sp Sign|Add Sp Sign|Remove Sp Sign|Force Sp Sign" ValueDefault=remove [Sp Incdec] Category=1 Description="Add or remove space between '++' and '--' the word to which it is being
applied, as in '(--x)' or 'y++;'.

Default: remove" Enabled=false EditorType=multiple Choices=sp_incdec=ignore|sp_incdec=add|sp_incdec=remove|sp_incdec=force|sp_incdec=not_defined ChoicesReadable="Ignore Sp Incdec|Add Sp Incdec|Remove Sp Incdec|Force Sp Incdec" ValueDefault=remove [Sp Before Nl Cont] Category=1 Description="Add or remove space before a backslash-newline at the end of a line.

Default: add" Enabled=false EditorType=multiple Choices=sp_before_nl_cont=ignore|sp_before_nl_cont=add|sp_before_nl_cont=remove|sp_before_nl_cont=force|sp_before_nl_cont=not_defined ChoicesReadable="Ignore Sp Before Nl Cont|Add Sp Before Nl Cont|Remove Sp Before Nl Cont|Force Sp Before Nl Cont" ValueDefault=add [Sp After Oc Scope] Category=1 Description="(OC) Add or remove space after the scope '+' or '-', as in '-(void) foo;'
or '+(int) bar;'." Enabled=false EditorType=multiple Choices=sp_after_oc_scope=ignore|sp_after_oc_scope=add|sp_after_oc_scope=remove|sp_after_oc_scope=force|sp_after_oc_scope=not_defined ChoicesReadable="Ignore Sp After Oc Scope|Add Sp After Oc Scope|Remove Sp After Oc Scope|Force Sp After Oc Scope" ValueDefault=ignore [Sp After Oc Colon] Category=1 Description="(OC) Add or remove space after the colon in message specs,
i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'." Enabled=false EditorType=multiple Choices=sp_after_oc_colon=ignore|sp_after_oc_colon=add|sp_after_oc_colon=remove|sp_after_oc_colon=force|sp_after_oc_colon=not_defined ChoicesReadable="Ignore Sp After Oc Colon|Add Sp After Oc Colon|Remove Sp After Oc Colon|Force Sp After Oc Colon" ValueDefault=ignore [Sp Before Oc Colon] Category=1 Description="(OC) Add or remove space before the colon in message specs,
i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'." Enabled=false EditorType=multiple Choices=sp_before_oc_colon=ignore|sp_before_oc_colon=add|sp_before_oc_colon=remove|sp_before_oc_colon=force|sp_before_oc_colon=not_defined ChoicesReadable="Ignore Sp Before Oc Colon|Add Sp Before Oc Colon|Remove Sp Before Oc Colon|Force Sp Before Oc Colon" ValueDefault=ignore [Sp After Oc Dict Colon] Category=1 Description="(OC) Add or remove space after the colon in immutable dictionary expression
'NSDictionary *test = @{@"foo" :@"bar"};'." Enabled=false EditorType=multiple Choices=sp_after_oc_dict_colon=ignore|sp_after_oc_dict_colon=add|sp_after_oc_dict_colon=remove|sp_after_oc_dict_colon=force|sp_after_oc_dict_colon=not_defined ChoicesReadable="Ignore Sp After Oc Dict Colon|Add Sp After Oc Dict Colon|Remove Sp After Oc Dict Colon|Force Sp After Oc Dict Colon" ValueDefault=ignore [Sp Before Oc Dict Colon] Category=1 Description="(OC) Add or remove space before the colon in immutable dictionary expression
'NSDictionary *test = @{@"foo" :@"bar"};'." Enabled=false EditorType=multiple Choices=sp_before_oc_dict_colon=ignore|sp_before_oc_dict_colon=add|sp_before_oc_dict_colon=remove|sp_before_oc_dict_colon=force|sp_before_oc_dict_colon=not_defined ChoicesReadable="Ignore Sp Before Oc Dict Colon|Add Sp Before Oc Dict Colon|Remove Sp Before Oc Dict Colon|Force Sp Before Oc Dict Colon" ValueDefault=ignore [Sp After Send Oc Colon] Category=1 Description="(OC) Add or remove space after the colon in message specs,
i.e. '[object setValue:1];' vs. '[object setValue: 1];'." Enabled=false EditorType=multiple Choices=sp_after_send_oc_colon=ignore|sp_after_send_oc_colon=add|sp_after_send_oc_colon=remove|sp_after_send_oc_colon=force|sp_after_send_oc_colon=not_defined ChoicesReadable="Ignore Sp After Send Oc Colon|Add Sp After Send Oc Colon|Remove Sp After Send Oc Colon|Force Sp After Send Oc Colon" ValueDefault=ignore [Sp Before Send Oc Colon] Category=1 Description="(OC) Add or remove space before the colon in message specs,
i.e. '[object setValue:1];' vs. '[object setValue :1];'." Enabled=false EditorType=multiple Choices=sp_before_send_oc_colon=ignore|sp_before_send_oc_colon=add|sp_before_send_oc_colon=remove|sp_before_send_oc_colon=force|sp_before_send_oc_colon=not_defined ChoicesReadable="Ignore Sp Before Send Oc Colon|Add Sp Before Send Oc Colon|Remove Sp Before Send Oc Colon|Force Sp Before Send Oc Colon" ValueDefault=ignore [Sp After Oc Type] Category=1 Description="(OC) Add or remove space after the (type) in message specs,
i.e. '-(int)f: (int) x;' vs. '-(int)f: (int)x;'." Enabled=false EditorType=multiple Choices=sp_after_oc_type=ignore|sp_after_oc_type=add|sp_after_oc_type=remove|sp_after_oc_type=force|sp_after_oc_type=not_defined ChoicesReadable="Ignore Sp After Oc Type|Add Sp After Oc Type|Remove Sp After Oc Type|Force Sp After Oc Type" ValueDefault=ignore [Sp After Oc Return Type] Category=1 Description="(OC) Add or remove space after the first (type) in message specs,
i.e. '-(int) f:(int)x;' vs. '-(int)f:(int)x;'." Enabled=false EditorType=multiple Choices=sp_after_oc_return_type=ignore|sp_after_oc_return_type=add|sp_after_oc_return_type=remove|sp_after_oc_return_type=force|sp_after_oc_return_type=not_defined ChoicesReadable="Ignore Sp After Oc Return Type|Add Sp After Oc Return Type|Remove Sp After Oc Return Type|Force Sp After Oc Return Type" ValueDefault=ignore [Sp After Oc At Sel] Category=1 Description="(OC) Add or remove space between '@selector' and '(',
i.e. '@selector(msgName)' vs. '@selector (msgName)'.
Also applies to '@protocol()' constructs." Enabled=false EditorType=multiple Choices=sp_after_oc_at_sel=ignore|sp_after_oc_at_sel=add|sp_after_oc_at_sel=remove|sp_after_oc_at_sel=force|sp_after_oc_at_sel=not_defined ChoicesReadable="Ignore Sp After Oc At Sel|Add Sp After Oc At Sel|Remove Sp After Oc At Sel|Force Sp After Oc At Sel" ValueDefault=ignore [Sp After Oc At Sel Parens] Category=1 Description="(OC) Add or remove space between '@selector(x)' and the following word,
i.e. '@selector(foo) a:' vs. '@selector(foo)a:'." Enabled=false EditorType=multiple Choices=sp_after_oc_at_sel_parens=ignore|sp_after_oc_at_sel_parens=add|sp_after_oc_at_sel_parens=remove|sp_after_oc_at_sel_parens=force|sp_after_oc_at_sel_parens=not_defined ChoicesReadable="Ignore Sp After Oc At Sel Parens|Add Sp After Oc At Sel Parens|Remove Sp After Oc At Sel Parens|Force Sp After Oc At Sel Parens" ValueDefault=ignore [Sp Inside Oc At Sel Parens] Category=1 Description="(OC) Add or remove space inside '@selector' parentheses,
i.e. '@selector(foo)' vs. '@selector( foo )'.
Also applies to '@protocol()' constructs." Enabled=false EditorType=multiple Choices=sp_inside_oc_at_sel_parens=ignore|sp_inside_oc_at_sel_parens=add|sp_inside_oc_at_sel_parens=remove|sp_inside_oc_at_sel_parens=force|sp_inside_oc_at_sel_parens=not_defined ChoicesReadable="Ignore Sp Inside Oc At Sel Parens|Add Sp Inside Oc At Sel Parens|Remove Sp Inside Oc At Sel Parens|Force Sp Inside Oc At Sel Parens" ValueDefault=ignore [Sp Before Oc Block Caret] Category=1 Description="(OC) Add or remove space before a block pointer caret,
i.e. '^int (int arg){...}' vs. ' ^int (int arg){...}'." Enabled=false EditorType=multiple Choices=sp_before_oc_block_caret=ignore|sp_before_oc_block_caret=add|sp_before_oc_block_caret=remove|sp_before_oc_block_caret=force|sp_before_oc_block_caret=not_defined ChoicesReadable="Ignore Sp Before Oc Block Caret|Add Sp Before Oc Block Caret|Remove Sp Before Oc Block Caret|Force Sp Before Oc Block Caret" ValueDefault=ignore [Sp After Oc Block Caret] Category=1 Description="(OC) Add or remove space after a block pointer caret,
i.e. '^int (int arg){...}' vs. '^ int (int arg){...}'." Enabled=false EditorType=multiple Choices=sp_after_oc_block_caret=ignore|sp_after_oc_block_caret=add|sp_after_oc_block_caret=remove|sp_after_oc_block_caret=force|sp_after_oc_block_caret=not_defined ChoicesReadable="Ignore Sp After Oc Block Caret|Add Sp After Oc Block Caret|Remove Sp After Oc Block Caret|Force Sp After Oc Block Caret" ValueDefault=ignore [Sp After Oc Msg Receiver] Category=1 Description="(OC) Add or remove space between the receiver and selector in a message,
as in '[receiver selector ...]'." Enabled=false EditorType=multiple Choices=sp_after_oc_msg_receiver=ignore|sp_after_oc_msg_receiver=add|sp_after_oc_msg_receiver=remove|sp_after_oc_msg_receiver=force|sp_after_oc_msg_receiver=not_defined ChoicesReadable="Ignore Sp After Oc Msg Receiver|Add Sp After Oc Msg Receiver|Remove Sp After Oc Msg Receiver|Force Sp After Oc Msg Receiver" ValueDefault=ignore [Sp After Oc Property] Category=1 Description="(OC) Add or remove space after '@property'." Enabled=false EditorType=multiple Choices=sp_after_oc_property=ignore|sp_after_oc_property=add|sp_after_oc_property=remove|sp_after_oc_property=force|sp_after_oc_property=not_defined ChoicesReadable="Ignore Sp After Oc Property|Add Sp After Oc Property|Remove Sp After Oc Property|Force Sp After Oc Property" ValueDefault=ignore [Sp After Oc Synchronized] Category=1 Description="(OC) Add or remove space between '@synchronized' and the open parenthesis,
i.e. '@synchronized(foo)' vs. '@synchronized (foo)'." Enabled=false EditorType=multiple Choices=sp_after_oc_synchronized=ignore|sp_after_oc_synchronized=add|sp_after_oc_synchronized=remove|sp_after_oc_synchronized=force|sp_after_oc_synchronized=not_defined ChoicesReadable="Ignore Sp After Oc Synchronized|Add Sp After Oc Synchronized|Remove Sp After Oc Synchronized|Force Sp After Oc Synchronized" ValueDefault=ignore [Sp Cond Colon] Category=1 Description="Add or remove space around the ':' in 'b ? t : f'." Enabled=false EditorType=multiple Choices=sp_cond_colon=ignore|sp_cond_colon=add|sp_cond_colon=remove|sp_cond_colon=force|sp_cond_colon=not_defined ChoicesReadable="Ignore Sp Cond Colon|Add Sp Cond Colon|Remove Sp Cond Colon|Force Sp Cond Colon" ValueDefault=ignore [Sp Cond Colon Before] Category=1 Description="Add or remove space before the ':' in 'b ? t : f'.

Overrides sp_cond_colon." Enabled=false EditorType=multiple Choices=sp_cond_colon_before=ignore|sp_cond_colon_before=add|sp_cond_colon_before=remove|sp_cond_colon_before=force|sp_cond_colon_before=not_defined ChoicesReadable="Ignore Sp Cond Colon Before|Add Sp Cond Colon Before|Remove Sp Cond Colon Before|Force Sp Cond Colon Before" ValueDefault=ignore [Sp Cond Colon After] Category=1 Description="Add or remove space after the ':' in 'b ? t : f'.

Overrides sp_cond_colon." Enabled=false EditorType=multiple Choices=sp_cond_colon_after=ignore|sp_cond_colon_after=add|sp_cond_colon_after=remove|sp_cond_colon_after=force|sp_cond_colon_after=not_defined ChoicesReadable="Ignore Sp Cond Colon After|Add Sp Cond Colon After|Remove Sp Cond Colon After|Force Sp Cond Colon After" ValueDefault=ignore [Sp Cond Question] Category=1 Description="Add or remove space around the '?' in 'b ? t : f'." Enabled=false EditorType=multiple Choices=sp_cond_question=ignore|sp_cond_question=add|sp_cond_question=remove|sp_cond_question=force|sp_cond_question=not_defined ChoicesReadable="Ignore Sp Cond Question|Add Sp Cond Question|Remove Sp Cond Question|Force Sp Cond Question" ValueDefault=ignore [Sp Cond Question Before] Category=1 Description="Add or remove space before the '?' in 'b ? t : f'.

Overrides sp_cond_question." Enabled=false EditorType=multiple Choices=sp_cond_question_before=ignore|sp_cond_question_before=add|sp_cond_question_before=remove|sp_cond_question_before=force|sp_cond_question_before=not_defined ChoicesReadable="Ignore Sp Cond Question Before|Add Sp Cond Question Before|Remove Sp Cond Question Before|Force Sp Cond Question Before" ValueDefault=ignore [Sp Cond Question After] Category=1 Description="Add or remove space after the '?' in 'b ? t : f'.

Overrides sp_cond_question." Enabled=false EditorType=multiple Choices=sp_cond_question_after=ignore|sp_cond_question_after=add|sp_cond_question_after=remove|sp_cond_question_after=force|sp_cond_question_after=not_defined ChoicesReadable="Ignore Sp Cond Question After|Add Sp Cond Question After|Remove Sp Cond Question After|Force Sp Cond Question After" ValueDefault=ignore [Sp Cond Ternary Short] Category=1 Description="In the abbreviated ternary form '(a ?: b)', add or remove space between '?'
and ':'.

Overrides all other sp_cond_* options." Enabled=false EditorType=multiple Choices=sp_cond_ternary_short=ignore|sp_cond_ternary_short=add|sp_cond_ternary_short=remove|sp_cond_ternary_short=force|sp_cond_ternary_short=not_defined ChoicesReadable="Ignore Sp Cond Ternary Short|Add Sp Cond Ternary Short|Remove Sp Cond Ternary Short|Force Sp Cond Ternary Short" ValueDefault=ignore [Sp Case Label] Category=1 Description="Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make
sense here." Enabled=false EditorType=multiple Choices=sp_case_label=ignore|sp_case_label=add|sp_case_label=remove|sp_case_label=force|sp_case_label=not_defined ChoicesReadable="Ignore Sp Case Label|Add Sp Case Label|Remove Sp Case Label|Force Sp Case Label" ValueDefault=ignore [Sp Range] Category=1 Description="(D) Add or remove space around the D '..' operator." Enabled=false EditorType=multiple Choices=sp_range=ignore|sp_range=add|sp_range=remove|sp_range=force|sp_range=not_defined ChoicesReadable="Ignore Sp Range|Add Sp Range|Remove Sp Range|Force Sp Range" ValueDefault=ignore [Sp After For Colon] Category=1 Description="Add or remove space after ':' in a Java/C++11 range-based 'for',
as in 'for (Type var : <here> expr)'." Enabled=false EditorType=multiple Choices=sp_after_for_colon=ignore|sp_after_for_colon=add|sp_after_for_colon=remove|sp_after_for_colon=force|sp_after_for_colon=not_defined ChoicesReadable="Ignore Sp After For Colon|Add Sp After For Colon|Remove Sp After For Colon|Force Sp After For Colon" ValueDefault=ignore [Sp Before For Colon] Category=1 Description="Add or remove space before ':' in a Java/C++11 range-based 'for',
as in 'for (Type var <here> : expr)'." Enabled=false EditorType=multiple Choices=sp_before_for_colon=ignore|sp_before_for_colon=add|sp_before_for_colon=remove|sp_before_for_colon=force|sp_before_for_colon=not_defined ChoicesReadable="Ignore Sp Before For Colon|Add Sp Before For Colon|Remove Sp Before For Colon|Force Sp Before For Colon" ValueDefault=ignore [Sp Extern Paren] Category=1 Description="(D) Add or remove space between 'extern' and '(' as in 'extern <here> (C)'." Enabled=false EditorType=multiple Choices=sp_extern_paren=ignore|sp_extern_paren=add|sp_extern_paren=remove|sp_extern_paren=force|sp_extern_paren=not_defined ChoicesReadable="Ignore Sp Extern Paren|Add Sp Extern Paren|Remove Sp Extern Paren|Force Sp Extern Paren" ValueDefault=ignore [Sp Cmt Cpp Start] Category=1 Description="Add or remove space after the opening of a C++ comment, as in '// <here> A'." Enabled=false EditorType=multiple Choices=sp_cmt_cpp_start=ignore|sp_cmt_cpp_start=add|sp_cmt_cpp_start=remove|sp_cmt_cpp_start=force|sp_cmt_cpp_start=not_defined ChoicesReadable="Ignore Sp Cmt Cpp Start|Add Sp Cmt Cpp Start|Remove Sp Cmt Cpp Start|Force Sp Cmt Cpp Start" ValueDefault=ignore [Sp Cmt Cpp Region] Category=1 Description="Add or remove space in a C++ region marker comment, as in '// <here> BEGIN'.
A region marker is defined as a comment which is not preceded by other text
(i.e. the comment is the first non-whitespace on the line), and which starts
with either 'BEGIN' or 'END'.

Overrides sp_cmt_cpp_start." Enabled=false EditorType=multiple Choices=sp_cmt_cpp_region=ignore|sp_cmt_cpp_region=add|sp_cmt_cpp_region=remove|sp_cmt_cpp_region=force|sp_cmt_cpp_region=not_defined ChoicesReadable="Ignore Sp Cmt Cpp Region|Add Sp Cmt Cpp Region|Remove Sp Cmt Cpp Region|Force Sp Cmt Cpp Region" ValueDefault=ignore [Sp Cmt Cpp Doxygen] Category=1 Description="If true, space added with sp_cmt_cpp_start will be added after Doxygen
sequences like '///', '///<', '//!' and '//!<'." Enabled=false EditorType=boolean TrueFalse=sp_cmt_cpp_doxygen=true|sp_cmt_cpp_doxygen=false ValueDefault=false [Sp Cmt Cpp Qttr] Category=1 Description="If true, space added with sp_cmt_cpp_start will be added after Qt translator
or meta-data comments like '//:', '//=', and '//~'." Enabled=false EditorType=boolean TrueFalse=sp_cmt_cpp_qttr=true|sp_cmt_cpp_qttr=false ValueDefault=false [Sp Endif Cmt] Category=1 Description="Add or remove space between #else or #endif and a trailing comment." Enabled=false EditorType=multiple Choices=sp_endif_cmt=ignore|sp_endif_cmt=add|sp_endif_cmt=remove|sp_endif_cmt=force|sp_endif_cmt=not_defined ChoicesReadable="Ignore Sp Endif Cmt|Add Sp Endif Cmt|Remove Sp Endif Cmt|Force Sp Endif Cmt" ValueDefault=ignore [Sp After New] Category=1 Description="Add or remove space after 'new', 'delete' and 'delete[]'." Enabled=false EditorType=multiple Choices=sp_after_new=ignore|sp_after_new=add|sp_after_new=remove|sp_after_new=force|sp_after_new=not_defined ChoicesReadable="Ignore Sp After New|Add Sp After New|Remove Sp After New|Force Sp After New" ValueDefault=ignore [Sp Between New Paren] Category=1 Description="Add or remove space between 'new' and '(' in 'new()'." Enabled=false EditorType=multiple Choices=sp_between_new_paren=ignore|sp_between_new_paren=add|sp_between_new_paren=remove|sp_between_new_paren=force|sp_between_new_paren=not_defined ChoicesReadable="Ignore Sp Between New Paren|Add Sp Between New Paren|Remove Sp Between New Paren|Force Sp Between New Paren" ValueDefault=ignore [Sp After Newop Paren] Category=1 Description="Add or remove space between ')' and type in 'new(foo) BAR'." Enabled=false EditorType=multiple Choices=sp_after_newop_paren=ignore|sp_after_newop_paren=add|sp_after_newop_paren=remove|sp_after_newop_paren=force|sp_after_newop_paren=not_defined ChoicesReadable="Ignore Sp After Newop Paren|Add Sp After Newop Paren|Remove Sp After Newop Paren|Force Sp After Newop Paren" ValueDefault=ignore [Sp Inside Newop Paren] Category=1 Description="Add or remove space inside parentheses of the new operator
as in 'new(foo) BAR'." Enabled=false EditorType=multiple Choices=sp_inside_newop_paren=ignore|sp_inside_newop_paren=add|sp_inside_newop_paren=remove|sp_inside_newop_paren=force|sp_inside_newop_paren=not_defined ChoicesReadable="Ignore Sp Inside Newop Paren|Add Sp Inside Newop Paren|Remove Sp Inside Newop Paren|Force Sp Inside Newop Paren" ValueDefault=ignore [Sp Inside Newop Paren Open] Category=1 Description="Add or remove space after the open parenthesis of the new operator,
as in 'new(foo) BAR'.

Overrides sp_inside_newop_paren." Enabled=false EditorType=multiple Choices=sp_inside_newop_paren_open=ignore|sp_inside_newop_paren_open=add|sp_inside_newop_paren_open=remove|sp_inside_newop_paren_open=force|sp_inside_newop_paren_open=not_defined ChoicesReadable="Ignore Sp Inside Newop Paren Open|Add Sp Inside Newop Paren Open|Remove Sp Inside Newop Paren Open|Force Sp Inside Newop Paren Open" ValueDefault=ignore [Sp Inside Newop Paren Close] Category=1 Description="Add or remove space before the close parenthesis of the new operator,
as in 'new(foo) BAR'.

Overrides sp_inside_newop_paren." Enabled=false EditorType=multiple Choices=sp_inside_newop_paren_close=ignore|sp_inside_newop_paren_close=add|sp_inside_newop_paren_close=remove|sp_inside_newop_paren_close=force|sp_inside_newop_paren_close=not_defined ChoicesReadable="Ignore Sp Inside Newop Paren Close|Add Sp Inside Newop Paren Close|Remove Sp Inside Newop Paren Close|Force Sp Inside Newop Paren Close" ValueDefault=ignore [Sp Before Tr Cmt] Category=1 Description="Add or remove space before a trailing comment." Enabled=false EditorType=multiple Choices=sp_before_tr_cmt=ignore|sp_before_tr_cmt=add|sp_before_tr_cmt=remove|sp_before_tr_cmt=force|sp_before_tr_cmt=not_defined ChoicesReadable="Ignore Sp Before Tr Cmt|Add Sp Before Tr Cmt|Remove Sp Before Tr Cmt|Force Sp Before Tr Cmt" ValueDefault=ignore [Sp Num Before Tr Cmt] Category=1 Description="Number of spaces before a trailing comment." Enabled=false EditorType=numeric CallName="sp_num_before_tr_cmt=" MinVal=0 MaxVal=16 ValueDefault=0 [Sp Before Emb Cmt] Category=1 Description="Add or remove space before an embedded comment.

Default: force" Enabled=false EditorType=multiple Choices=sp_before_emb_cmt=ignore|sp_before_emb_cmt=add|sp_before_emb_cmt=remove|sp_before_emb_cmt=force|sp_before_emb_cmt=not_defined ChoicesReadable="Ignore Sp Before Emb Cmt|Add Sp Before Emb Cmt|Remove Sp Before Emb Cmt|Force Sp Before Emb Cmt" ValueDefault=force [Sp Num Before Emb Cmt] Category=1 Description="Number of spaces before an embedded comment.

Default: 1" Enabled=false EditorType=numeric CallName="sp_num_before_emb_cmt=" MinVal=0 MaxVal=16 ValueDefault=1 [Sp After Emb Cmt] Category=1 Description="Add or remove space after an embedded comment.

Default: force" Enabled=false EditorType=multiple Choices=sp_after_emb_cmt=ignore|sp_after_emb_cmt=add|sp_after_emb_cmt=remove|sp_after_emb_cmt=force|sp_after_emb_cmt=not_defined ChoicesReadable="Ignore Sp After Emb Cmt|Add Sp After Emb Cmt|Remove Sp After Emb Cmt|Force Sp After Emb Cmt" ValueDefault=force [Sp Num After Emb Cmt] Category=1 Description="Number of spaces after an embedded comment.

Default: 1" Enabled=false EditorType=numeric CallName="sp_num_after_emb_cmt=" MinVal=0 MaxVal=16 ValueDefault=1 [Sp Annotation Paren] Category=1 Description="(Java) Add or remove space between an annotation and the open parenthesis." Enabled=false EditorType=multiple Choices=sp_annotation_paren=ignore|sp_annotation_paren=add|sp_annotation_paren=remove|sp_annotation_paren=force|sp_annotation_paren=not_defined ChoicesReadable="Ignore Sp Annotation Paren|Add Sp Annotation Paren|Remove Sp Annotation Paren|Force Sp Annotation Paren" ValueDefault=ignore [Sp Skip Vbrace Tokens] Category=1 Description="If true, vbrace tokens are dropped to the previous token and skipped." Enabled=false EditorType=boolean TrueFalse=sp_skip_vbrace_tokens=true|sp_skip_vbrace_tokens=false ValueDefault=false [Sp After Noexcept] Category=1 Description="Add or remove space after 'noexcept'." Enabled=false EditorType=multiple Choices=sp_after_noexcept=ignore|sp_after_noexcept=add|sp_after_noexcept=remove|sp_after_noexcept=force|sp_after_noexcept=not_defined ChoicesReadable="Ignore Sp After Noexcept|Add Sp After Noexcept|Remove Sp After Noexcept|Force Sp After Noexcept" ValueDefault=ignore [Sp Vala After Translation] Category=1 Description="Add or remove space after '_'." Enabled=false EditorType=multiple Choices=sp_vala_after_translation=ignore|sp_vala_after_translation=add|sp_vala_after_translation=remove|sp_vala_after_translation=force|sp_vala_after_translation=not_defined ChoicesReadable="Ignore Sp Vala After Translation|Add Sp Vala After Translation|Remove Sp Vala After Translation|Force Sp Vala After Translation" ValueDefault=ignore [Force Tab After Define] Category=1 Description="If true, a <TAB> is inserted after #define." Enabled=false EditorType=boolean TrueFalse=force_tab_after_define=true|force_tab_after_define=false ValueDefault=false [Indent Columns] Category=2 Description="The number of columns to indent per level. Usually 2, 3, 4, or 8.

Default: 8" Enabled=false EditorType=numeric CallName="indent_columns=" MinVal=0 MaxVal=16 ValueDefault=8 [Indent Ignore First Continue] Category=2 Description="Whether to ignore indent for the first continuation line. Subsequent
continuation lines will still be indented to match the first." Enabled=false EditorType=boolean TrueFalse=indent_ignore_first_continue=true|indent_ignore_first_continue=false ValueDefault=false [Indent Continue] Category=2 Description="The continuation indent. If non-zero, this overrides the indent of '(', '['
and '=' continuation indents. Negative values are OK; negative value is
absolute and not increased for each '(' or '[' level.

For FreeBSD, this is set to 4.
Requires indent_ignore_first_continue=false." Enabled=false EditorType=numeric CallName="indent_continue=" MinVal=-16 MaxVal=16 ValueDefault=0 [Indent Continue Class Head] Category=2 Description="The continuation indent, only for class header line(s). If non-zero, this
overrides the indent of 'class' continuation indents.
Requires indent_ignore_first_continue=false." Enabled=false EditorType=numeric CallName="indent_continue_class_head=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Single Newlines] Category=2 Description="Whether to indent empty lines (i.e. lines which contain only spaces before
the newline character)." Enabled=false EditorType=boolean TrueFalse=indent_single_newlines=true|indent_single_newlines=false ValueDefault=false [Indent Param] Category=2 Description="The continuation indent for func_*_param if they are true. If non-zero, this
overrides the indent." Enabled=false EditorType=numeric CallName="indent_param=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent With Tabs] Category=2 Description="How to use tabs when indenting code.

0: Spaces only
1: Indent with tabs to brace level, align with spaces (default)
2: Indent and align with tabs, using spaces when not on a tabstop

Default: 1" Enabled=true EditorType=multiple Choices="indent_with_tabs=0|indent_with_tabs=1|indent_with_tabs=2" ChoicesReadable="Spaces only|Indent with tabs, align with spaces|Indent and align with tabs" ValueDefault=1 [Indent Cmt With Tabs] Category=2 Description="Whether to indent comments that are not at a brace level with tabs on a
tabstop. Requires indent_with_tabs=2. If false, will use spaces." Enabled=false EditorType=boolean TrueFalse=indent_cmt_with_tabs=true|indent_cmt_with_tabs=false ValueDefault=false [Indent Align String] Category=2 Description="Whether to indent strings broken by '\' so that they line up." Enabled=false EditorType=boolean TrueFalse=indent_align_string=true|indent_align_string=false ValueDefault=false [Indent Xml String] Category=2 Description="The number of spaces to indent multi-line XML strings.
Requires indent_align_string=true." Enabled=false EditorType=numeric CallName="indent_xml_string=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Brace] Category=2 Description="Spaces to indent '{' from level." Enabled=false EditorType=numeric CallName="indent_brace=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Braces] Category=2 Description="Whether braces are indented to the body level." Enabled=false EditorType=boolean TrueFalse=indent_braces=true|indent_braces=false ValueDefault=false [Indent Braces No Func] Category=2 Description="Whether to disable indenting function braces if indent_braces=true." Enabled=false EditorType=boolean TrueFalse=indent_braces_no_func=true|indent_braces_no_func=false ValueDefault=false [Indent Braces No Class] Category=2 Description="Whether to disable indenting class braces if indent_braces=true." Enabled=false EditorType=boolean TrueFalse=indent_braces_no_class=true|indent_braces_no_class=false ValueDefault=false [Indent Braces No Struct] Category=2 Description="Whether to disable indenting struct braces if indent_braces=true." Enabled=false EditorType=boolean TrueFalse=indent_braces_no_struct=true|indent_braces_no_struct=false ValueDefault=false [Indent Brace Parent] Category=2 Description="Whether to indent based on the size of the brace parent,
i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc." Enabled=false EditorType=boolean TrueFalse=indent_brace_parent=true|indent_brace_parent=false ValueDefault=false [Indent Paren Open Brace] Category=2 Description="Whether to indent based on the open parenthesis instead of the open brace
in '({\n'." Enabled=false EditorType=boolean TrueFalse=indent_paren_open_brace=true|indent_paren_open_brace=false ValueDefault=false [Indent Cs Delegate Brace] Category=2 Description="(C#) Whether to indent the brace of a C# delegate by another level." Enabled=false EditorType=boolean TrueFalse=indent_cs_delegate_brace=true|indent_cs_delegate_brace=false ValueDefault=false [Indent Cs Delegate Body] Category=2 Description="(C#) Whether to indent a C# delegate (to handle delegates with no brace) by
another level." Enabled=false EditorType=boolean TrueFalse=indent_cs_delegate_body=true|indent_cs_delegate_body=false ValueDefault=false [Indent Namespace] Category=2 Description="Whether to indent the body of a 'namespace'." Enabled=false EditorType=boolean TrueFalse=indent_namespace=true|indent_namespace=false ValueDefault=false [Indent Namespace Single Indent] Category=2 Description="Whether to indent only the first namespace, and not any nested namespaces.
Requires indent_namespace=true." Enabled=false EditorType=boolean TrueFalse=indent_namespace_single_indent=true|indent_namespace_single_indent=false ValueDefault=false [Indent Namespace Level] Category=2 Description="The number of spaces to indent a namespace block.
If set to zero, use the value indent_columns" Enabled=false EditorType=numeric CallName="indent_namespace_level=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Namespace Limit] Category=2 Description="If the body of the namespace is longer than this number, it won't be
indented. Requires indent_namespace=true. 0 means no limit." Enabled=false EditorType=numeric CallName="indent_namespace_limit=" MinVal=0 MaxVal=255 ValueDefault=0 [Indent Namespace Inner Only] Category=2 Description="Whether to indent only in inner namespaces (nested in other namespaces).
Requires indent_namespace=true." Enabled=false EditorType=boolean TrueFalse=indent_namespace_inner_only=true|indent_namespace_inner_only=false ValueDefault=false [Indent Extern] Category=2 Description="Whether the 'extern "C"' body is indented." Enabled=false EditorType=boolean TrueFalse=indent_extern=true|indent_extern=false ValueDefault=false [Indent Class] Category=2 Description="Whether the 'class' body is indented." Enabled=false EditorType=boolean TrueFalse=indent_class=true|indent_class=false ValueDefault=false [Indent Ignore Before Class Colon] Category=2 Description="Whether to ignore indent for the leading base class colon." Enabled=false EditorType=boolean TrueFalse=indent_ignore_before_class_colon=true|indent_ignore_before_class_colon=false ValueDefault=false [Indent Before Class Colon] Category=2 Description="Additional indent before the leading base class colon.
Negative values decrease indent down to the first column.
Requires indent_ignore_before_class_colon=false and a newline break before
the colon (see pos_class_colon and nl_class_colon)" Enabled=false EditorType=numeric CallName="indent_before_class_colon=" MinVal=-16 MaxVal=16 ValueDefault=0 [Indent Class Colon] Category=2 Description="Whether to indent the stuff after a leading base class colon." Enabled=false EditorType=boolean TrueFalse=indent_class_colon=true|indent_class_colon=false ValueDefault=false [Indent Class On Colon] Category=2 Description="Whether to indent based on a class colon instead of the stuff after the
colon. Requires indent_class_colon=true." Enabled=false EditorType=boolean TrueFalse=indent_class_on_colon=true|indent_class_on_colon=false ValueDefault=false [Indent Ignore Before Constr Colon] Category=2 Description="Whether to ignore indent for a leading class initializer colon." Enabled=false EditorType=boolean TrueFalse=indent_ignore_before_constr_colon=true|indent_ignore_before_constr_colon=false ValueDefault=false [Indent Constr Colon] Category=2 Description="Whether to indent the stuff after a leading class initializer colon." Enabled=false EditorType=boolean TrueFalse=indent_constr_colon=true|indent_constr_colon=false ValueDefault=false [Indent Ctor Init Leading] Category=2 Description="Virtual indent from the ':' for leading member initializers.

Default: 2" Enabled=false EditorType=numeric CallName="indent_ctor_init_leading=" MinVal=0 MaxVal=16 ValueDefault=2 [Indent Ctor Init Following] Category=2 Description="Virtual indent from the ':' for following member initializers.

Default: 2" Enabled=false EditorType=numeric CallName="indent_ctor_init_following=" MinVal=0 MaxVal=16 ValueDefault=2 [Indent Ctor Init] Category=2 Description="Additional indent for constructor initializer list.
Negative values decrease indent down to the first column." Enabled=false EditorType=numeric CallName="indent_ctor_init=" MinVal=-16 MaxVal=16 ValueDefault=0 [Indent Else If] Category=2 Description="Whether to indent 'if' following 'else' as a new block under the 'else'.
If false, 'else\nif' is treated as 'else if' for indenting purposes." Enabled=false EditorType=boolean TrueFalse=indent_else_if=true|indent_else_if=false ValueDefault=false [Indent Var Def Blk] Category=2 Description="Amount to indent variable declarations after a open brace.

<0: Relative
>=0: Absolute" Enabled=false EditorType=numeric CallName="indent_var_def_blk=" MinVal=-16 MaxVal=16 ValueDefault=0 [Indent Var Def Cont] Category=2 Description="Whether to indent continued variable declarations instead of aligning." Enabled=false EditorType=boolean TrueFalse=indent_var_def_cont=true|indent_var_def_cont=false ValueDefault=false [Indent Shift] Category=2 Description="How to indent continued shift expressions ('<<' and '>>').
Set align_left_shift=false when using this.
0: Align shift operators instead of indenting them (default)
1: Indent by one level
-1: Preserve original indentation" Enabled=false EditorType=numeric CallName="indent_shift=" MinVal=-1 MaxVal=1 ValueDefault=0 [Indent Func Def Force Col1] Category=2 Description="Whether to force indentation of function definitions to start in column 1." Enabled=false EditorType=boolean TrueFalse=indent_func_def_force_col1=true|indent_func_def_force_col1=false ValueDefault=false [Indent Func Call Param] Category=2 Description="Whether to indent continued function call parameters one indent level,
rather than aligning parameters under the open parenthesis." Enabled=false EditorType=boolean TrueFalse=indent_func_call_param=true|indent_func_call_param=false ValueDefault=false [Indent Func Def Param] Category=2 Description="Whether to indent continued function definition parameters one indent level,
rather than aligning parameters under the open parenthesis." Enabled=false EditorType=boolean TrueFalse=indent_func_def_param=true|indent_func_def_param=false ValueDefault=false [Indent Func Def Param Paren Pos Threshold] Category=2 Description="for function definitions, only if indent_func_def_param is false
Allows to align params when appropriate and indent them when not
behave as if it was true if paren position is more than this value
if paren position is more than the option value" Enabled=false EditorType=numeric CallName="indent_func_def_param_paren_pos_threshold=" MinVal=0 MaxVal=160 ValueDefault=0 [Indent Func Proto Param] Category=2 Description="Whether to indent continued function call prototype one indent level,
rather than aligning parameters under the open parenthesis." Enabled=false EditorType=boolean TrueFalse=indent_func_proto_param=true|indent_func_proto_param=false ValueDefault=false [Indent Func Class Param] Category=2 Description="Whether to indent continued function call declaration one indent level,
rather than aligning parameters under the open parenthesis." Enabled=false EditorType=boolean TrueFalse=indent_func_class_param=true|indent_func_class_param=false ValueDefault=false [Indent Func Ctor Var Param] Category=2 Description="Whether to indent continued class variable constructors one indent level,
rather than aligning parameters under the open parenthesis." Enabled=false EditorType=boolean TrueFalse=indent_func_ctor_var_param=true|indent_func_ctor_var_param=false ValueDefault=false [Indent Template Param] Category=2 Description="Whether to indent continued template parameter list one indent level,
rather than aligning parameters under the open parenthesis." Enabled=false EditorType=boolean TrueFalse=indent_template_param=true|indent_template_param=false ValueDefault=false [Indent Func Param Double] Category=2 Description="Double the indent for indent_func_xxx_param options.
Use both values of the options indent_columns and indent_param." Enabled=false EditorType=boolean TrueFalse=indent_func_param_double=true|indent_func_param_double=false ValueDefault=false [Indent Func Const] Category=2 Description="Indentation column for standalone 'const' qualifier on a function
prototype." Enabled=false EditorType=numeric CallName="indent_func_const=" MinVal=0 MaxVal=69 ValueDefault=0 [Indent Func Throw] Category=2 Description="Indentation column for standalone 'throw' qualifier on a function
prototype." Enabled=false EditorType=numeric CallName="indent_func_throw=" MinVal=0 MaxVal=41 ValueDefault=0 [Indent Macro Brace] Category=2 Description="How to indent within a macro followed by a brace on the same line
This allows reducing the indent in macros that have (for example)
`do { ... } while (0)` blocks bracketing them.

true: add an indent for the brace on the same line as the macro
false: do not add an indent for the brace on the same line as the macro

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_macro_brace=true|indent_macro_brace=false ValueDefault=true [Indent Member] Category=2 Description="The number of spaces to indent a continued '->' or '.'.
Usually set to 0, 1, or indent_columns." Enabled=false EditorType=numeric CallName="indent_member=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Member Single] Category=2 Description="Whether lines broken at '.' or '->' should be indented by a single indent.
The indent_member option will not be effective if this is set to true." Enabled=false EditorType=boolean TrueFalse=indent_member_single=true|indent_member_single=false ValueDefault=false [Indent Single Line Comments Before] Category=2 Description="Spaces to indent single line ('//') comments on lines before code." Enabled=false EditorType=numeric CallName="indent_single_line_comments_before=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Single Line Comments After] Category=2 Description="Spaces to indent single line ('//') comments on lines after code." Enabled=false EditorType=numeric CallName="indent_single_line_comments_after=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Sparen Extra] Category=2 Description="When opening a paren for a control statement (if, for, while, etc), increase
the indent level by this value. Negative values decrease the indent level." Enabled=false EditorType=numeric CallName="indent_sparen_extra=" MinVal=-16 MaxVal=16 ValueDefault=0 [Indent Relative Single Line Comments] Category=2 Description="Whether to indent trailing single line ('//') comments relative to the code
instead of trying to keep the same absolute column." Enabled=false EditorType=boolean TrueFalse=indent_relative_single_line_comments=true|indent_relative_single_line_comments=false ValueDefault=false [Indent Switch Case] Category=2 Description="Spaces to indent 'case' from 'switch'. Usually 0 or indent_columns.
It might be wise to choose the same value for the option indent_case_brace." Enabled=false EditorType=numeric CallName="indent_switch_case=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Switch Body] Category=2 Description="Spaces to indent the body of a 'switch' before any 'case'.
Usually the same as indent_columns or indent_switch_case." Enabled=false EditorType=numeric CallName="indent_switch_body=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Ignore Case Brace] Category=2 Description="Whether to ignore indent for '{' following 'case'." Enabled=false EditorType=boolean TrueFalse=indent_ignore_case_brace=true|indent_ignore_case_brace=false ValueDefault=false [Indent Case Brace] Category=2 Description="Spaces to indent '{' from 'case'. By default, the brace will appear under
the 'c' in case. Usually set to 0 or indent_columns. Negative values are OK.
It might be wise to choose the same value for the option indent_switch_case." Enabled=false EditorType=numeric CallName="indent_case_brace=" MinVal=-16 MaxVal=16 ValueDefault=0 [Indent Switch Break With Case] Category=2 Description="indent 'break' with 'case' from 'switch'." Enabled=false EditorType=boolean TrueFalse=indent_switch_break_with_case=true|indent_switch_break_with_case=false ValueDefault=false [Indent Switch Pp] Category=2 Description="Whether to indent preprocessor statements inside of switch statements.

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_switch_pp=true|indent_switch_pp=false ValueDefault=true [Indent Case Shift] Category=2 Description="Spaces to shift the 'case' line, without affecting any other lines.
Usually 0." Enabled=false EditorType=numeric CallName="indent_case_shift=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Case Comment] Category=2 Description="Whether to align comments before 'case' with the 'case'.

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_case_comment=true|indent_case_comment=false ValueDefault=true [Indent Comment] Category=2 Description="Whether to indent comments not found in first column.

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_comment=true|indent_comment=false ValueDefault=true [Indent Col1 Comment] Category=2 Description="Whether to indent comments found in first column." Enabled=false EditorType=boolean TrueFalse=indent_col1_comment=true|indent_col1_comment=false ValueDefault=false [Indent Col1 Multi String Literal] Category=2 Description="Whether to indent multi string literal in first column." Enabled=false EditorType=boolean TrueFalse=indent_col1_multi_string_literal=true|indent_col1_multi_string_literal=false ValueDefault=false [Indent Comment Align Thresh] Category=2 Description="Align comments on adjacent lines that are this many columns apart or less.

Default: 3" Enabled=false EditorType=numeric CallName="indent_comment_align_thresh=" MinVal=0 MaxVal=16 ValueDefault=3 [Indent Ignore Label] Category=2 Description="Whether to ignore indent for goto labels." Enabled=false EditorType=boolean TrueFalse=indent_ignore_label=true|indent_ignore_label=false ValueDefault=false [Indent Label] Category=2 Description="How to indent goto labels. Requires indent_ignore_label=false.

>0: Absolute column where 1 is the leftmost column
<=0: Subtract from brace indent

Default: 1" Enabled=false EditorType=numeric CallName="indent_label=" MinVal=-16 MaxVal=16 ValueDefault=1 [Indent Access Spec] Category=2 Description="How to indent access specifiers that are followed by a
colon.

>0: Absolute column where 1 is the leftmost column
<=0: Subtract from brace indent

Default: 1" Enabled=false EditorType=numeric CallName="indent_access_spec=" MinVal=-16 MaxVal=16 ValueDefault=1 [Indent Access Spec Body] Category=2 Description="Whether to indent the code after an access specifier by one level.
If true, this option forces 'indent_access_spec=0'." Enabled=false EditorType=boolean TrueFalse=indent_access_spec_body=true|indent_access_spec_body=false ValueDefault=false [Indent Paren Nl] Category=2 Description="If an open parenthesis is followed by a newline, whether to indent the next
line so that it lines up after the open parenthesis (not recommended)." Enabled=false EditorType=boolean TrueFalse=indent_paren_nl=true|indent_paren_nl=false ValueDefault=false [Indent Paren Close] Category=2 Description="How to indent a close parenthesis after a newline.

0: Indent to body level (default)
1: Align under the open parenthesis
2: Indent to the brace level
-1: Preserve original indentation" Enabled=false EditorType=numeric CallName="indent_paren_close=" MinVal=-1 MaxVal=2 ValueDefault=0 [Indent Paren After Func Def] Category=2 Description="Whether to indent the open parenthesis of a function definition,
if the parenthesis is on its own line." Enabled=false EditorType=boolean TrueFalse=indent_paren_after_func_def=true|indent_paren_after_func_def=false ValueDefault=false [Indent Paren After Func Decl] Category=2 Description="Whether to indent the open parenthesis of a function declaration,
if the parenthesis is on its own line." Enabled=false EditorType=boolean TrueFalse=indent_paren_after_func_decl=true|indent_paren_after_func_decl=false ValueDefault=false [Indent Paren After Func Call] Category=2 Description="Whether to indent the open parenthesis of a function call,
if the parenthesis is on its own line." Enabled=false EditorType=boolean TrueFalse=indent_paren_after_func_call=true|indent_paren_after_func_call=false ValueDefault=false [Indent Comma Brace] Category=2 Description="How to indent a comma when inside braces.
0: Indent by one level (default)
1: Align under the open brace
-1: Preserve original indentation" Enabled=false EditorType=numeric CallName="indent_comma_brace=" MinVal=-1 MaxVal=1 ValueDefault=0 [Indent Comma Paren] Category=2 Description="How to indent a comma when inside parentheses.
0: Indent by one level (default)
1: Align under the open parenthesis
-1: Preserve original indentation" Enabled=false EditorType=numeric CallName="indent_comma_paren=" MinVal=-1 MaxVal=1 ValueDefault=0 [Indent Bool Paren] Category=2 Description="How to indent a Boolean operator when inside parentheses.
0: Indent by one level (default)
1: Align under the open parenthesis
-1: Preserve original indentation" Enabled=false EditorType=numeric CallName="indent_bool_paren=" MinVal=-1 MaxVal=1 ValueDefault=0 [Indent Ignore Bool] Category=2 Description="Whether to ignore the indentation of a Boolean operator when outside
parentheses." Enabled=false EditorType=boolean TrueFalse=indent_ignore_bool=true|indent_ignore_bool=false ValueDefault=false [Indent Ignore Arith] Category=2 Description="Whether to ignore the indentation of an arithmetic operator." Enabled=false EditorType=boolean TrueFalse=indent_ignore_arith=true|indent_ignore_arith=false ValueDefault=false [Indent Semicolon For Paren] Category=2 Description="Whether to indent a semicolon when inside a for parenthesis.
If true, aligns under the open for parenthesis." Enabled=false EditorType=boolean TrueFalse=indent_semicolon_for_paren=true|indent_semicolon_for_paren=false ValueDefault=false [Indent Ignore Semicolon] Category=2 Description="Whether to ignore the indentation of a semicolon outside of a 'for'
statement." Enabled=false EditorType=boolean TrueFalse=indent_ignore_semicolon=true|indent_ignore_semicolon=false ValueDefault=false [Indent First Bool Expr] Category=2 Description="Whether to align the first expression to following ones
if indent_bool_paren=1." Enabled=false EditorType=boolean TrueFalse=indent_first_bool_expr=true|indent_first_bool_expr=false ValueDefault=false [Indent First For Expr] Category=2 Description="Whether to align the first expression to following ones
if indent_semicolon_for_paren=true." Enabled=false EditorType=boolean TrueFalse=indent_first_for_expr=true|indent_first_for_expr=false ValueDefault=false [Indent Square Nl] Category=2 Description="If an open square is followed by a newline, whether to indent the next line
so that it lines up after the open square (not recommended)." Enabled=false EditorType=boolean TrueFalse=indent_square_nl=true|indent_square_nl=false ValueDefault=false [Indent Preserve Sql] Category=2 Description="(ESQL/C) Whether to preserve the relative indent of 'EXEC SQL' bodies." Enabled=false EditorType=boolean TrueFalse=indent_preserve_sql=true|indent_preserve_sql=false ValueDefault=false [Indent Ignore Assign] Category=2 Description="Whether to ignore the indentation of an assignment operator." Enabled=false EditorType=boolean TrueFalse=indent_ignore_assign=true|indent_ignore_assign=false ValueDefault=false [Indent Align Assign] Category=2 Description="Whether to align continued statements at the '='. If false or if the '=' is
followed by a newline, the next line is indent one tab.

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_align_assign=true|indent_align_assign=false ValueDefault=true [Indent Off After Assign] Category=2 Description="If true, the indentation of the chunks after a '=' sequence will be set at
LHS token indentation column before '='." Enabled=false EditorType=boolean TrueFalse=indent_off_after_assign=true|indent_off_after_assign=false ValueDefault=false [Indent Align Paren] Category=2 Description="Whether to align continued statements at the '('. If false or the '(' is
followed by a newline, the next line indent is one tab.

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_align_paren=true|indent_align_paren=false ValueDefault=true [Indent Oc Inside Msg Sel] Category=2 Description="(OC) Whether to indent Objective-C code inside message selectors." Enabled=false EditorType=boolean TrueFalse=indent_oc_inside_msg_sel=true|indent_oc_inside_msg_sel=false ValueDefault=false [Indent Oc Block] Category=2 Description="(OC) Whether to indent Objective-C blocks at brace level instead of usual
rules." Enabled=false EditorType=boolean TrueFalse=indent_oc_block=true|indent_oc_block=false ValueDefault=false [Indent Oc Block Msg] Category=2 Description="(OC) Indent for Objective-C blocks in a message relative to the parameter
name.

=0: Use indent_oc_block rules
>0: Use specified number of spaces to indent" Enabled=false EditorType=numeric CallName="indent_oc_block_msg=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Oc Msg Colon] Category=2 Description="(OC) Minimum indent for subsequent parameters" Enabled=false EditorType=numeric CallName="indent_oc_msg_colon=" MinVal=0 MaxVal=5000 ValueDefault=0 [Indent Oc Msg Prioritize First Colon] Category=2 Description="(OC) Whether to prioritize aligning with initial colon (and stripping spaces
from lines, if necessary).

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_oc_msg_prioritize_first_colon=true|indent_oc_msg_prioritize_first_colon=false ValueDefault=true [Indent Oc Block Msg Xcode Style] Category=2 Description="(OC) Whether to indent blocks the way that Xcode does by default
(from the keyword if the parameter is on its own line; otherwise, from the
previous indentation level). Requires indent_oc_block_msg=true." Enabled=false EditorType=boolean TrueFalse=indent_oc_block_msg_xcode_style=true|indent_oc_block_msg_xcode_style=false ValueDefault=false [Indent Oc Block Msg From Keyword] Category=2 Description="(OC) Whether to indent blocks from where the brace is, relative to a
message keyword. Requires indent_oc_block_msg=true." Enabled=false EditorType=boolean TrueFalse=indent_oc_block_msg_from_keyword=true|indent_oc_block_msg_from_keyword=false ValueDefault=false [Indent Oc Block Msg From Colon] Category=2 Description="(OC) Whether to indent blocks from where the brace is, relative to a message
colon. Requires indent_oc_block_msg=true." Enabled=false EditorType=boolean TrueFalse=indent_oc_block_msg_from_colon=true|indent_oc_block_msg_from_colon=false ValueDefault=false [Indent Oc Block Msg From Caret] Category=2 Description="(OC) Whether to indent blocks from where the block caret is.
Requires indent_oc_block_msg=true." Enabled=false EditorType=boolean TrueFalse=indent_oc_block_msg_from_caret=true|indent_oc_block_msg_from_caret=false ValueDefault=false [Indent Oc Block Msg From Brace] Category=2 Description="(OC) Whether to indent blocks from where the brace caret is.
Requires indent_oc_block_msg=true." Enabled=false EditorType=boolean TrueFalse=indent_oc_block_msg_from_brace=true|indent_oc_block_msg_from_brace=false ValueDefault=false [Indent Min Vbrace Open] Category=2 Description="When indenting after virtual brace open and newline add further spaces to
reach this minimum indent." Enabled=false EditorType=numeric CallName="indent_min_vbrace_open=" MinVal=0 MaxVal=16 ValueDefault=0 [Indent Vbrace Open On Tabstop] Category=2 Description="Whether to add further spaces after regular indent to reach next tabstop
when indenting after virtual brace open and newline." Enabled=false EditorType=boolean TrueFalse=indent_vbrace_open_on_tabstop=true|indent_vbrace_open_on_tabstop=false ValueDefault=false [Indent Token After Brace] Category=2 Description="How to indent after a brace followed by another token (not a newline).
true: indent all contained lines to match the token
false: indent all contained lines to match the brace

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_token_after_brace=true|indent_token_after_brace=false ValueDefault=true [Indent Cpp Lambda Body] Category=2 Description="Whether to indent the body of a C++11 lambda." Enabled=false EditorType=boolean TrueFalse=indent_cpp_lambda_body=true|indent_cpp_lambda_body=false ValueDefault=false [Indent Compound Literal Return] Category=2 Description="How to indent compound literals that are being returned.
true: add both the indent from return & the compound literal open brace
(i.e. 2 indent levels)
false: only indent 1 level, don't add the indent for the open brace, only
add the indent for the return.

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_compound_literal_return=true|indent_compound_literal_return=false ValueDefault=true [Indent Using Block] Category=2 Description="(C#) Whether to indent a 'using' block if no braces are used.

Default: true" Enabled=false EditorType=boolean TrueFalse=indent_using_block=true|indent_using_block=false ValueDefault=true [Indent Ternary Operator] Category=2 Description="How to indent the continuation of ternary operator.

0: Off (default)
1: When the `if_false` is a continuation, indent it under the `if_true` branch
2: When the `:` is a continuation, indent it under `?`" Enabled=false EditorType=numeric CallName="indent_ternary_operator=" MinVal=0 MaxVal=2 ValueDefault=0 [Indent Inside Ternary Operator] Category=2 Description="Whether to indent the statements inside ternary operator." Enabled=false EditorType=boolean TrueFalse=indent_inside_ternary_operator=true|indent_inside_ternary_operator=false ValueDefault=false [Indent Off After Return] Category=2 Description="If true, the indentation of the chunks after a `return` sequence will be set at return indentation column." Enabled=false EditorType=boolean TrueFalse=indent_off_after_return=true|indent_off_after_return=false ValueDefault=false [Indent Off After Return New] Category=2 Description="If true, the indentation of the chunks after a `return new` sequence will be set at return indentation column." Enabled=false EditorType=boolean TrueFalse=indent_off_after_return_new=true|indent_off_after_return_new=false ValueDefault=false [Indent Single After Return] Category=2 Description="If true, the tokens after return are indented with regular single indentation. By default (false) the indentation is after the return token." Enabled=false EditorType=boolean TrueFalse=indent_single_after_return=true|indent_single_after_return=false ValueDefault=false [Indent Ignore Asm Block] Category=2 Description="Whether to ignore indent and alignment for 'asm' blocks (i.e. assume they
have their own indentation)." Enabled=false EditorType=boolean TrueFalse=indent_ignore_asm_block=true|indent_ignore_asm_block=false ValueDefault=false [Donot Indent Func Def Close Paren] Category=2 Description="Don't indent the close parenthesis of a function definition,
if the parenthesis is on its own line." Enabled=false EditorType=boolean TrueFalse=donot_indent_func_def_close_paren=true|donot_indent_func_def_close_paren=false ValueDefault=false [Nl Collapse Empty Body] Category=3 Description="Whether to collapse empty blocks between '{' and '}' except for functions.
Use nl_collapse_empty_body_functions to specify how empty function braces
should be formatted." Enabled=false EditorType=boolean TrueFalse=nl_collapse_empty_body=true|nl_collapse_empty_body=false ValueDefault=false [Nl Collapse Empty Body Functions] Category=3 Description="Whether to collapse empty blocks between '{' and '}' for functions only.
If true, overrides nl_inside_empty_func." Enabled=false EditorType=boolean TrueFalse=nl_collapse_empty_body_functions=true|nl_collapse_empty_body_functions=false ValueDefault=false [Nl Assign Leave One Liners] Category=3 Description="Don't split one-line braced assignments, as in 'foo_t f = { 1, 2 };'." Enabled=false EditorType=boolean TrueFalse=nl_assign_leave_one_liners=true|nl_assign_leave_one_liners=false ValueDefault=false [Nl Class Leave One Liners] Category=3 Description="Don't split one-line braced statements inside a 'class xx { }' body." Enabled=false EditorType=boolean TrueFalse=nl_class_leave_one_liners=true|nl_class_leave_one_liners=false ValueDefault=false [Nl Enum Leave One Liners] Category=3 Description="Don't split one-line enums, as in 'enum foo { BAR = 15 };'" Enabled=false EditorType=boolean TrueFalse=nl_enum_leave_one_liners=true|nl_enum_leave_one_liners=false ValueDefault=false [Nl Getset Leave One Liners] Category=3 Description="Don't split one-line get or set functions." Enabled=false EditorType=boolean TrueFalse=nl_getset_leave_one_liners=true|nl_getset_leave_one_liners=false ValueDefault=false [Nl Cs Property Leave One Liners] Category=3 Description="(C#) Don't split one-line property get or set functions." Enabled=false EditorType=boolean TrueFalse=nl_cs_property_leave_one_liners=true|nl_cs_property_leave_one_liners=false ValueDefault=false [Nl Func Leave One Liners] Category=3 Description="Don't split one-line function definitions, as in 'int foo() { return 0; }'.
might modify nl_func_type_name" Enabled=false EditorType=boolean TrueFalse=nl_func_leave_one_liners=true|nl_func_leave_one_liners=false ValueDefault=false [Nl Cpp Lambda Leave One Liners] Category=3 Description="Don't split one-line C++11 lambdas, as in '[]() { return 0; }'." Enabled=false EditorType=boolean TrueFalse=nl_cpp_lambda_leave_one_liners=true|nl_cpp_lambda_leave_one_liners=false ValueDefault=false [Nl If Leave One Liners] Category=3 Description="Don't split one-line if/else statements, as in 'if(...) b++;'." Enabled=false EditorType=boolean TrueFalse=nl_if_leave_one_liners=true|nl_if_leave_one_liners=false ValueDefault=false [Nl While Leave One Liners] Category=3 Description="Don't split one-line while statements, as in 'while(...) b++;'." Enabled=false EditorType=boolean TrueFalse=nl_while_leave_one_liners=true|nl_while_leave_one_liners=false ValueDefault=false [Nl Do Leave One Liners] Category=3 Description="Don't split one-line do statements, as in 'do { b++; } while(...);'." Enabled=false EditorType=boolean TrueFalse=nl_do_leave_one_liners=true|nl_do_leave_one_liners=false ValueDefault=false [Nl For Leave One Liners] Category=3 Description="Don't split one-line for statements, as in 'for(...) b++;'." Enabled=false EditorType=boolean TrueFalse=nl_for_leave_one_liners=true|nl_for_leave_one_liners=false ValueDefault=false [Nl Oc Msg Leave One Liner] Category=3 Description="(OC) Don't split one-line Objective-C messages." Enabled=false EditorType=boolean TrueFalse=nl_oc_msg_leave_one_liner=true|nl_oc_msg_leave_one_liner=false ValueDefault=false [Nl Oc Mdef Brace] Category=3 Description="(OC) Add or remove newline between method declaration and '{'." Enabled=false EditorType=multiple Choices=nl_oc_mdef_brace=ignore|nl_oc_mdef_brace=add|nl_oc_mdef_brace=remove|nl_oc_mdef_brace=force|nl_oc_mdef_brace=not_defined ChoicesReadable="Ignore Nl Oc Mdef Brace|Add Nl Oc Mdef Brace|Remove Nl Oc Mdef Brace|Force Nl Oc Mdef Brace" ValueDefault=ignore [Nl Oc Block Brace] Category=3 Description="(OC) Add or remove newline between Objective-C block signature and '{'." Enabled=false EditorType=multiple Choices=nl_oc_block_brace=ignore|nl_oc_block_brace=add|nl_oc_block_brace=remove|nl_oc_block_brace=force|nl_oc_block_brace=not_defined ChoicesReadable="Ignore Nl Oc Block Brace|Add Nl Oc Block Brace|Remove Nl Oc Block Brace|Force Nl Oc Block Brace" ValueDefault=ignore [Nl Oc Before Interface] Category=3 Description="(OC) Add or remove blank line before '@interface' statement." Enabled=false EditorType=multiple Choices=nl_oc_before_interface=ignore|nl_oc_before_interface=add|nl_oc_before_interface=remove|nl_oc_before_interface=force|nl_oc_before_interface=not_defined ChoicesReadable="Ignore Nl Oc Before Interface|Add Nl Oc Before Interface|Remove Nl Oc Before Interface|Force Nl Oc Before Interface" ValueDefault=ignore [Nl Oc Before Implementation] Category=3 Description="(OC) Add or remove blank line before '@implementation' statement." Enabled=false EditorType=multiple Choices=nl_oc_before_implementation=ignore|nl_oc_before_implementation=add|nl_oc_before_implementation=remove|nl_oc_before_implementation=force|nl_oc_before_implementation=not_defined ChoicesReadable="Ignore Nl Oc Before Implementation|Add Nl Oc Before Implementation|Remove Nl Oc Before Implementation|Force Nl Oc Before Implementation" ValueDefault=ignore [Nl Oc Before End] Category=3 Description="(OC) Add or remove blank line before '@end' statement." Enabled=false EditorType=multiple Choices=nl_oc_before_end=ignore|nl_oc_before_end=add|nl_oc_before_end=remove|nl_oc_before_end=force|nl_oc_before_end=not_defined ChoicesReadable="Ignore Nl Oc Before End|Add Nl Oc Before End|Remove Nl Oc Before End|Force Nl Oc Before End" ValueDefault=ignore [Nl Oc Interface Brace] Category=3 Description="(OC) Add or remove newline between '@interface' and '{'." Enabled=false EditorType=multiple Choices=nl_oc_interface_brace=ignore|nl_oc_interface_brace=add|nl_oc_interface_brace=remove|nl_oc_interface_brace=force|nl_oc_interface_brace=not_defined ChoicesReadable="Ignore Nl Oc Interface Brace|Add Nl Oc Interface Brace|Remove Nl Oc Interface Brace|Force Nl Oc Interface Brace" ValueDefault=ignore [Nl Oc Implementation Brace] Category=3 Description="(OC) Add or remove newline between '@implementation' and '{'." Enabled=false EditorType=multiple Choices=nl_oc_implementation_brace=ignore|nl_oc_implementation_brace=add|nl_oc_implementation_brace=remove|nl_oc_implementation_brace=force|nl_oc_implementation_brace=not_defined ChoicesReadable="Ignore Nl Oc Implementation Brace|Add Nl Oc Implementation Brace|Remove Nl Oc Implementation Brace|Force Nl Oc Implementation Brace" ValueDefault=ignore [Nl Start Of File] Category=3 Description="Add or remove newlines at the start of the file." Enabled=false EditorType=multiple Choices=nl_start_of_file=ignore|nl_start_of_file=add|nl_start_of_file=remove|nl_start_of_file=force|nl_start_of_file=not_defined ChoicesReadable="Ignore Nl Start Of File|Add Nl Start Of File|Remove Nl Start Of File|Force Nl Start Of File" ValueDefault=ignore [Nl Start Of File Min] Category=3 Description="The minimum number of newlines at the start of the file (only used if
nl_start_of_file is 'add' or 'force')." Enabled=false EditorType=numeric CallName="nl_start_of_file_min=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl End Of File] Category=3 Description="Add or remove newline at the end of the file." Enabled=false EditorType=multiple Choices=nl_end_of_file=ignore|nl_end_of_file=add|nl_end_of_file=remove|nl_end_of_file=force|nl_end_of_file=not_defined ChoicesReadable="Ignore Nl End Of File|Add Nl End Of File|Remove Nl End Of File|Force Nl End Of File" ValueDefault=ignore [Nl End Of File Min] Category=3 Description="The minimum number of newlines at the end of the file (only used if
nl_end_of_file is 'add' or 'force')." Enabled=false EditorType=numeric CallName="nl_end_of_file_min=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Assign Brace] Category=3 Description="Add or remove newline between '=' and '{'." Enabled=false EditorType=multiple Choices=nl_assign_brace=ignore|nl_assign_brace=add|nl_assign_brace=remove|nl_assign_brace=force|nl_assign_brace=not_defined ChoicesReadable="Ignore Nl Assign Brace|Add Nl Assign Brace|Remove Nl Assign Brace|Force Nl Assign Brace" ValueDefault=ignore [Nl Assign Square] Category=3 Description="(D) Add or remove newline between '=' and '['." Enabled=false EditorType=multiple Choices=nl_assign_square=ignore|nl_assign_square=add|nl_assign_square=remove|nl_assign_square=force|nl_assign_square=not_defined ChoicesReadable="Ignore Nl Assign Square|Add Nl Assign Square|Remove Nl Assign Square|Force Nl Assign Square" ValueDefault=ignore [Nl Tsquare Brace] Category=3 Description="Add or remove newline between '[]' and '{'." Enabled=false EditorType=multiple Choices=nl_tsquare_brace=ignore|nl_tsquare_brace=add|nl_tsquare_brace=remove|nl_tsquare_brace=force|nl_tsquare_brace=not_defined ChoicesReadable="Ignore Nl Tsquare Brace|Add Nl Tsquare Brace|Remove Nl Tsquare Brace|Force Nl Tsquare Brace" ValueDefault=ignore [Nl After Square Assign] Category=3 Description="(D) Add or remove newline after '= ['. Will also affect the newline before
the ']'." Enabled=false EditorType=multiple Choices=nl_after_square_assign=ignore|nl_after_square_assign=add|nl_after_square_assign=remove|nl_after_square_assign=force|nl_after_square_assign=not_defined ChoicesReadable="Ignore Nl After Square Assign|Add Nl After Square Assign|Remove Nl After Square Assign|Force Nl After Square Assign" ValueDefault=ignore [Nl Fcall Brace] Category=3 Description="Add or remove newline between a function call's ')' and '{', as in
'list_for_each(item, &list) { }'." Enabled=false EditorType=multiple Choices=nl_fcall_brace=ignore|nl_fcall_brace=add|nl_fcall_brace=remove|nl_fcall_brace=force|nl_fcall_brace=not_defined ChoicesReadable="Ignore Nl Fcall Brace|Add Nl Fcall Brace|Remove Nl Fcall Brace|Force Nl Fcall Brace" ValueDefault=ignore [Nl Enum Brace] Category=3 Description="Add or remove newline between 'enum' and '{'." Enabled=false EditorType=multiple Choices=nl_enum_brace=ignore|nl_enum_brace=add|nl_enum_brace=remove|nl_enum_brace=force|nl_enum_brace=not_defined ChoicesReadable="Ignore Nl Enum Brace|Add Nl Enum Brace|Remove Nl Enum Brace|Force Nl Enum Brace" ValueDefault=ignore [Nl Enum Class] Category=3 Description="Add or remove newline between 'enum' and 'class'." Enabled=false EditorType=multiple Choices=nl_enum_class=ignore|nl_enum_class=add|nl_enum_class=remove|nl_enum_class=force|nl_enum_class=not_defined ChoicesReadable="Ignore Nl Enum Class|Add Nl Enum Class|Remove Nl Enum Class|Force Nl Enum Class" ValueDefault=ignore [Nl Enum Class Identifier] Category=3 Description="Add or remove newline between 'enum class' and the identifier." Enabled=false EditorType=multiple Choices=nl_enum_class_identifier=ignore|nl_enum_class_identifier=add|nl_enum_class_identifier=remove|nl_enum_class_identifier=force|nl_enum_class_identifier=not_defined ChoicesReadable="Ignore Nl Enum Class Identifier|Add Nl Enum Class Identifier|Remove Nl Enum Class Identifier|Force Nl Enum Class Identifier" ValueDefault=ignore [Nl Enum Identifier Colon] Category=3 Description="Add or remove newline between 'enum class' type and ':'." Enabled=false EditorType=multiple Choices=nl_enum_identifier_colon=ignore|nl_enum_identifier_colon=add|nl_enum_identifier_colon=remove|nl_enum_identifier_colon=force|nl_enum_identifier_colon=not_defined ChoicesReadable="Ignore Nl Enum Identifier Colon|Add Nl Enum Identifier Colon|Remove Nl Enum Identifier Colon|Force Nl Enum Identifier Colon" ValueDefault=ignore [Nl Enum Colon Type] Category=3 Description="Add or remove newline between 'enum class identifier :' and type." Enabled=false EditorType=multiple Choices=nl_enum_colon_type=ignore|nl_enum_colon_type=add|nl_enum_colon_type=remove|nl_enum_colon_type=force|nl_enum_colon_type=not_defined ChoicesReadable="Ignore Nl Enum Colon Type|Add Nl Enum Colon Type|Remove Nl Enum Colon Type|Force Nl Enum Colon Type" ValueDefault=ignore [Nl Struct Brace] Category=3 Description="Add or remove newline between 'struct and '{'." Enabled=false EditorType=multiple Choices=nl_struct_brace=ignore|nl_struct_brace=add|nl_struct_brace=remove|nl_struct_brace=force|nl_struct_brace=not_defined ChoicesReadable="Ignore Nl Struct Brace|Add Nl Struct Brace|Remove Nl Struct Brace|Force Nl Struct Brace" ValueDefault=ignore [Nl Union Brace] Category=3 Description="Add or remove newline between 'union' and '{'." Enabled=false EditorType=multiple Choices=nl_union_brace=ignore|nl_union_brace=add|nl_union_brace=remove|nl_union_brace=force|nl_union_brace=not_defined ChoicesReadable="Ignore Nl Union Brace|Add Nl Union Brace|Remove Nl Union Brace|Force Nl Union Brace" ValueDefault=ignore [Nl If Brace] Category=3 Description="Add or remove newline between 'if' and '{'." Enabled=false EditorType=multiple Choices=nl_if_brace=ignore|nl_if_brace=add|nl_if_brace=remove|nl_if_brace=force|nl_if_brace=not_defined ChoicesReadable="Ignore Nl If Brace|Add Nl If Brace|Remove Nl If Brace|Force Nl If Brace" ValueDefault=ignore [Nl Brace Else] Category=3 Description="Add or remove newline between '}' and 'else'." Enabled=false EditorType=multiple Choices=nl_brace_else=ignore|nl_brace_else=add|nl_brace_else=remove|nl_brace_else=force|nl_brace_else=not_defined ChoicesReadable="Ignore Nl Brace Else|Add Nl Brace Else|Remove Nl Brace Else|Force Nl Brace Else" ValueDefault=ignore [Nl Elseif Brace] Category=3 Description="Add or remove newline between 'else if' and '{'. If set to ignore,
nl_if_brace is used instead." Enabled=false EditorType=multiple Choices=nl_elseif_brace=ignore|nl_elseif_brace=add|nl_elseif_brace=remove|nl_elseif_brace=force|nl_elseif_brace=not_defined ChoicesReadable="Ignore Nl Elseif Brace|Add Nl Elseif Brace|Remove Nl Elseif Brace|Force Nl Elseif Brace" ValueDefault=ignore [Nl Else Brace] Category=3 Description="Add or remove newline between 'else' and '{'." Enabled=false EditorType=multiple Choices=nl_else_brace=ignore|nl_else_brace=add|nl_else_brace=remove|nl_else_brace=force|nl_else_brace=not_defined ChoicesReadable="Ignore Nl Else Brace|Add Nl Else Brace|Remove Nl Else Brace|Force Nl Else Brace" ValueDefault=ignore [Nl Else If] Category=3 Description="Add or remove newline between 'else' and 'if'." Enabled=false EditorType=multiple Choices=nl_else_if=ignore|nl_else_if=add|nl_else_if=remove|nl_else_if=force|nl_else_if=not_defined ChoicesReadable="Ignore Nl Else If|Add Nl Else If|Remove Nl Else If|Force Nl Else If" ValueDefault=ignore [Nl Before Opening Brace Func Class Def] Category=3 Description="Add or remove newline before '{' opening brace" Enabled=false EditorType=multiple Choices=nl_before_opening_brace_func_class_def=ignore|nl_before_opening_brace_func_class_def=add|nl_before_opening_brace_func_class_def=remove|nl_before_opening_brace_func_class_def=force|nl_before_opening_brace_func_class_def=not_defined ChoicesReadable="Ignore Nl Before Opening Brace Func Class Def|Add Nl Before Opening Brace Func Class Def|Remove Nl Before Opening Brace Func Class Def|Force Nl Before Opening Brace Func Class Def" ValueDefault=ignore [Nl Before If Closing Paren] Category=3 Description="Add or remove newline before 'if'/'else if' closing parenthesis." Enabled=false EditorType=multiple Choices=nl_before_if_closing_paren=ignore|nl_before_if_closing_paren=add|nl_before_if_closing_paren=remove|nl_before_if_closing_paren=force|nl_before_if_closing_paren=not_defined ChoicesReadable="Ignore Nl Before If Closing Paren|Add Nl Before If Closing Paren|Remove Nl Before If Closing Paren|Force Nl Before If Closing Paren" ValueDefault=ignore [Nl Brace Finally] Category=3 Description="Add or remove newline between '}' and 'finally'." Enabled=false EditorType=multiple Choices=nl_brace_finally=ignore|nl_brace_finally=add|nl_brace_finally=remove|nl_brace_finally=force|nl_brace_finally=not_defined ChoicesReadable="Ignore Nl Brace Finally|Add Nl Brace Finally|Remove Nl Brace Finally|Force Nl Brace Finally" ValueDefault=ignore [Nl Finally Brace] Category=3 Description="Add or remove newline between 'finally' and '{'." Enabled=false EditorType=multiple Choices=nl_finally_brace=ignore|nl_finally_brace=add|nl_finally_brace=remove|nl_finally_brace=force|nl_finally_brace=not_defined ChoicesReadable="Ignore Nl Finally Brace|Add Nl Finally Brace|Remove Nl Finally Brace|Force Nl Finally Brace" ValueDefault=ignore [Nl Try Brace] Category=3 Description="Add or remove newline between 'try' and '{'." Enabled=false EditorType=multiple Choices=nl_try_brace=ignore|nl_try_brace=add|nl_try_brace=remove|nl_try_brace=force|nl_try_brace=not_defined ChoicesReadable="Ignore Nl Try Brace|Add Nl Try Brace|Remove Nl Try Brace|Force Nl Try Brace" ValueDefault=ignore [Nl Getset Brace] Category=3 Description="Add or remove newline between get/set and '{'." Enabled=false EditorType=multiple Choices=nl_getset_brace=ignore|nl_getset_brace=add|nl_getset_brace=remove|nl_getset_brace=force|nl_getset_brace=not_defined ChoicesReadable="Ignore Nl Getset Brace|Add Nl Getset Brace|Remove Nl Getset Brace|Force Nl Getset Brace" ValueDefault=ignore [Nl For Brace] Category=3 Description="Add or remove newline between 'for' and '{'." Enabled=false EditorType=multiple Choices=nl_for_brace=ignore|nl_for_brace=add|nl_for_brace=remove|nl_for_brace=force|nl_for_brace=not_defined ChoicesReadable="Ignore Nl For Brace|Add Nl For Brace|Remove Nl For Brace|Force Nl For Brace" ValueDefault=ignore [Nl Catch Brace] Category=3 Description="Add or remove newline before the '{' of a 'catch' statement, as in
'catch (decl) <here> {'." Enabled=false EditorType=multiple Choices=nl_catch_brace=ignore|nl_catch_brace=add|nl_catch_brace=remove|nl_catch_brace=force|nl_catch_brace=not_defined ChoicesReadable="Ignore Nl Catch Brace|Add Nl Catch Brace|Remove Nl Catch Brace|Force Nl Catch Brace" ValueDefault=ignore [Nl Oc Catch Brace] Category=3 Description="(OC) Add or remove newline before the '{' of a '@catch' statement, as in
'@catch (decl) <here> {'. If set to ignore, nl_catch_brace is used." Enabled=false EditorType=multiple Choices=nl_oc_catch_brace=ignore|nl_oc_catch_brace=add|nl_oc_catch_brace=remove|nl_oc_catch_brace=force|nl_oc_catch_brace=not_defined ChoicesReadable="Ignore Nl Oc Catch Brace|Add Nl Oc Catch Brace|Remove Nl Oc Catch Brace|Force Nl Oc Catch Brace" ValueDefault=ignore [Nl Brace Catch] Category=3 Description="Add or remove newline between '}' and 'catch'." Enabled=false EditorType=multiple Choices=nl_brace_catch=ignore|nl_brace_catch=add|nl_brace_catch=remove|nl_brace_catch=force|nl_brace_catch=not_defined ChoicesReadable="Ignore Nl Brace Catch|Add Nl Brace Catch|Remove Nl Brace Catch|Force Nl Brace Catch" ValueDefault=ignore [Nl Oc Brace Catch] Category=3 Description="(OC) Add or remove newline between '}' and '@catch'. If set to ignore,
nl_brace_catch is used." Enabled=false EditorType=multiple Choices=nl_oc_brace_catch=ignore|nl_oc_brace_catch=add|nl_oc_brace_catch=remove|nl_oc_brace_catch=force|nl_oc_brace_catch=not_defined ChoicesReadable="Ignore Nl Oc Brace Catch|Add Nl Oc Brace Catch|Remove Nl Oc Brace Catch|Force Nl Oc Brace Catch" ValueDefault=ignore [Nl Brace Square] Category=3 Description="Add or remove newline between '}' and ']'." Enabled=false EditorType=multiple Choices=nl_brace_square=ignore|nl_brace_square=add|nl_brace_square=remove|nl_brace_square=force|nl_brace_square=not_defined ChoicesReadable="Ignore Nl Brace Square|Add Nl Brace Square|Remove Nl Brace Square|Force Nl Brace Square" ValueDefault=ignore [Nl Brace Fparen] Category=3 Description="Add or remove newline between '}' and ')' in a function invocation." Enabled=false EditorType=multiple Choices=nl_brace_fparen=ignore|nl_brace_fparen=add|nl_brace_fparen=remove|nl_brace_fparen=force|nl_brace_fparen=not_defined ChoicesReadable="Ignore Nl Brace Fparen|Add Nl Brace Fparen|Remove Nl Brace Fparen|Force Nl Brace Fparen" ValueDefault=ignore [Nl While Brace] Category=3 Description="Add or remove newline between 'while' and '{'." Enabled=false EditorType=multiple Choices=nl_while_brace=ignore|nl_while_brace=add|nl_while_brace=remove|nl_while_brace=force|nl_while_brace=not_defined ChoicesReadable="Ignore Nl While Brace|Add Nl While Brace|Remove Nl While Brace|Force Nl While Brace" ValueDefault=ignore [Nl Scope Brace] Category=3 Description="(D) Add or remove newline between 'scope (x)' and '{'." Enabled=false EditorType=multiple Choices=nl_scope_brace=ignore|nl_scope_brace=add|nl_scope_brace=remove|nl_scope_brace=force|nl_scope_brace=not_defined ChoicesReadable="Ignore Nl Scope Brace|Add Nl Scope Brace|Remove Nl Scope Brace|Force Nl Scope Brace" ValueDefault=ignore [Nl Unittest Brace] Category=3 Description="(D) Add or remove newline between 'unittest' and '{'." Enabled=false EditorType=multiple Choices=nl_unittest_brace=ignore|nl_unittest_brace=add|nl_unittest_brace=remove|nl_unittest_brace=force|nl_unittest_brace=not_defined ChoicesReadable="Ignore Nl Unittest Brace|Add Nl Unittest Brace|Remove Nl Unittest Brace|Force Nl Unittest Brace" ValueDefault=ignore [Nl Version Brace] Category=3 Description="(D) Add or remove newline between 'version (x)' and '{'." Enabled=false EditorType=multiple Choices=nl_version_brace=ignore|nl_version_brace=add|nl_version_brace=remove|nl_version_brace=force|nl_version_brace=not_defined ChoicesReadable="Ignore Nl Version Brace|Add Nl Version Brace|Remove Nl Version Brace|Force Nl Version Brace" ValueDefault=ignore [Nl Using Brace] Category=3 Description="(C#) Add or remove newline between 'using' and '{'." Enabled=false EditorType=multiple Choices=nl_using_brace=ignore|nl_using_brace=add|nl_using_brace=remove|nl_using_brace=force|nl_using_brace=not_defined ChoicesReadable="Ignore Nl Using Brace|Add Nl Using Brace|Remove Nl Using Brace|Force Nl Using Brace" ValueDefault=ignore [Nl Brace Brace] Category=3 Description="Add or remove newline between two open or close braces. Due to general
newline/brace handling, REMOVE may not work." Enabled=false EditorType=multiple Choices=nl_brace_brace=ignore|nl_brace_brace=add|nl_brace_brace=remove|nl_brace_brace=force|nl_brace_brace=not_defined ChoicesReadable="Ignore Nl Brace Brace|Add Nl Brace Brace|Remove Nl Brace Brace|Force Nl Brace Brace" ValueDefault=ignore [Nl Do Brace] Category=3 Description="Add or remove newline between 'do' and '{'." Enabled=false EditorType=multiple Choices=nl_do_brace=ignore|nl_do_brace=add|nl_do_brace=remove|nl_do_brace=force|nl_do_brace=not_defined ChoicesReadable="Ignore Nl Do Brace|Add Nl Do Brace|Remove Nl Do Brace|Force Nl Do Brace" ValueDefault=ignore [Nl Brace While] Category=3 Description="Add or remove newline between '}' and 'while' of 'do' statement." Enabled=false EditorType=multiple Choices=nl_brace_while=ignore|nl_brace_while=add|nl_brace_while=remove|nl_brace_while=force|nl_brace_while=not_defined ChoicesReadable="Ignore Nl Brace While|Add Nl Brace While|Remove Nl Brace While|Force Nl Brace While" ValueDefault=ignore [Nl Switch Brace] Category=3 Description="Add or remove newline between 'switch' and '{'." Enabled=false EditorType=multiple Choices=nl_switch_brace=ignore|nl_switch_brace=add|nl_switch_brace=remove|nl_switch_brace=force|nl_switch_brace=not_defined ChoicesReadable="Ignore Nl Switch Brace|Add Nl Switch Brace|Remove Nl Switch Brace|Force Nl Switch Brace" ValueDefault=ignore [Nl Synchronized Brace] Category=3 Description="Add or remove newline between 'synchronized' and '{'." Enabled=false EditorType=multiple Choices=nl_synchronized_brace=ignore|nl_synchronized_brace=add|nl_synchronized_brace=remove|nl_synchronized_brace=force|nl_synchronized_brace=not_defined ChoicesReadable="Ignore Nl Synchronized Brace|Add Nl Synchronized Brace|Remove Nl Synchronized Brace|Force Nl Synchronized Brace" ValueDefault=ignore [Nl Multi Line Cond] Category=3 Description="Add a newline between ')' and '{' if the ')' is on a different line than the
if/for/etc.

Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch and
nl_catch_brace." Enabled=false EditorType=boolean TrueFalse=nl_multi_line_cond=true|nl_multi_line_cond=false ValueDefault=false [Nl Multi Line Sparen Open] Category=3 Description="Add a newline after '(' if an if/for/while/switch condition spans multiple
lines" Enabled=false EditorType=multiple Choices=nl_multi_line_sparen_open=ignore|nl_multi_line_sparen_open=add|nl_multi_line_sparen_open=remove|nl_multi_line_sparen_open=force|nl_multi_line_sparen_open=not_defined ChoicesReadable="Ignore Nl Multi Line Sparen Open|Add Nl Multi Line Sparen Open|Remove Nl Multi Line Sparen Open|Force Nl Multi Line Sparen Open" ValueDefault=ignore [Nl Multi Line Sparen Close] Category=3 Description="Add a newline before ')' if an if/for/while/switch condition spans multiple
lines. Overrides nl_before_if_closing_paren if both are specified." Enabled=false EditorType=multiple Choices=nl_multi_line_sparen_close=ignore|nl_multi_line_sparen_close=add|nl_multi_line_sparen_close=remove|nl_multi_line_sparen_close=force|nl_multi_line_sparen_close=not_defined ChoicesReadable="Ignore Nl Multi Line Sparen Close|Add Nl Multi Line Sparen Close|Remove Nl Multi Line Sparen Close|Force Nl Multi Line Sparen Close" ValueDefault=ignore [Nl Multi Line Define] Category=3 Description="Force a newline in a define after the macro name for multi-line defines." Enabled=false EditorType=boolean TrueFalse=nl_multi_line_define=true|nl_multi_line_define=false ValueDefault=false [Nl Before Case] Category=3 Description="Whether to add a newline before 'case', and a blank line before a 'case'
statement that follows a ';' or '}'." Enabled=false EditorType=boolean TrueFalse=nl_before_case=true|nl_before_case=false ValueDefault=false [Nl After Case] Category=3 Description="Whether to add a newline after a 'case' statement." Enabled=false EditorType=boolean TrueFalse=nl_after_case=true|nl_after_case=false ValueDefault=false [Nl Case Colon Brace] Category=3 Description="Add or remove newline between a case ':' and '{'.

Overrides nl_after_case." Enabled=false EditorType=multiple Choices=nl_case_colon_brace=ignore|nl_case_colon_brace=add|nl_case_colon_brace=remove|nl_case_colon_brace=force|nl_case_colon_brace=not_defined ChoicesReadable="Ignore Nl Case Colon Brace|Add Nl Case Colon Brace|Remove Nl Case Colon Brace|Force Nl Case Colon Brace" ValueDefault=ignore [Nl Before Throw] Category=3 Description="Add or remove newline between ')' and 'throw'." Enabled=false EditorType=multiple Choices=nl_before_throw=ignore|nl_before_throw=add|nl_before_throw=remove|nl_before_throw=force|nl_before_throw=not_defined ChoicesReadable="Ignore Nl Before Throw|Add Nl Before Throw|Remove Nl Before Throw|Force Nl Before Throw" ValueDefault=ignore [Nl Namespace Brace] Category=3 Description="Add or remove newline between 'namespace' and '{'." Enabled=false EditorType=multiple Choices=nl_namespace_brace=ignore|nl_namespace_brace=add|nl_namespace_brace=remove|nl_namespace_brace=force|nl_namespace_brace=not_defined ChoicesReadable="Ignore Nl Namespace Brace|Add Nl Namespace Brace|Remove Nl Namespace Brace|Force Nl Namespace Brace" ValueDefault=ignore [Nl Template Class] Category=3 Description="Add or remove newline after 'template<...>' of a template class." Enabled=false EditorType=multiple Choices=nl_template_class=ignore|nl_template_class=add|nl_template_class=remove|nl_template_class=force|nl_template_class=not_defined ChoicesReadable="Ignore Nl Template Class|Add Nl Template Class|Remove Nl Template Class|Force Nl Template Class" ValueDefault=ignore [Nl Template Class Decl] Category=3 Description="Add or remove newline after 'template<...>' of a template class declaration.

Overrides nl_template_class." Enabled=false EditorType=multiple Choices=nl_template_class_decl=ignore|nl_template_class_decl=add|nl_template_class_decl=remove|nl_template_class_decl=force|nl_template_class_decl=not_defined ChoicesReadable="Ignore Nl Template Class Decl|Add Nl Template Class Decl|Remove Nl Template Class Decl|Force Nl Template Class Decl" ValueDefault=ignore [Nl Template Class Decl Special] Category=3 Description="Add or remove newline after 'template<>' of a specialized class declaration.

Overrides nl_template_class_decl." Enabled=false EditorType=multiple Choices=nl_template_class_decl_special=ignore|nl_template_class_decl_special=add|nl_template_class_decl_special=remove|nl_template_class_decl_special=force|nl_template_class_decl_special=not_defined ChoicesReadable="Ignore Nl Template Class Decl Special|Add Nl Template Class Decl Special|Remove Nl Template Class Decl Special|Force Nl Template Class Decl Special" ValueDefault=ignore [Nl Template Class Def] Category=3 Description="Add or remove newline after 'template<...>' of a template class definition.

Overrides nl_template_class." Enabled=false EditorType=multiple Choices=nl_template_class_def=ignore|nl_template_class_def=add|nl_template_class_def=remove|nl_template_class_def=force|nl_template_class_def=not_defined ChoicesReadable="Ignore Nl Template Class Def|Add Nl Template Class Def|Remove Nl Template Class Def|Force Nl Template Class Def" ValueDefault=ignore [Nl Template Class Def Special] Category=3 Description="Add or remove newline after 'template<>' of a specialized class definition.

Overrides nl_template_class_def." Enabled=false EditorType=multiple Choices=nl_template_class_def_special=ignore|nl_template_class_def_special=add|nl_template_class_def_special=remove|nl_template_class_def_special=force|nl_template_class_def_special=not_defined ChoicesReadable="Ignore Nl Template Class Def Special|Add Nl Template Class Def Special|Remove Nl Template Class Def Special|Force Nl Template Class Def Special" ValueDefault=ignore [Nl Template Func] Category=3 Description="Add or remove newline after 'template<...>' of a template function." Enabled=false EditorType=multiple Choices=nl_template_func=ignore|nl_template_func=add|nl_template_func=remove|nl_template_func=force|nl_template_func=not_defined ChoicesReadable="Ignore Nl Template Func|Add Nl Template Func|Remove Nl Template Func|Force Nl Template Func" ValueDefault=ignore [Nl Template Func Decl] Category=3 Description="Add or remove newline after 'template<...>' of a template function
declaration.

Overrides nl_template_func." Enabled=false EditorType=multiple Choices=nl_template_func_decl=ignore|nl_template_func_decl=add|nl_template_func_decl=remove|nl_template_func_decl=force|nl_template_func_decl=not_defined ChoicesReadable="Ignore Nl Template Func Decl|Add Nl Template Func Decl|Remove Nl Template Func Decl|Force Nl Template Func Decl" ValueDefault=ignore [Nl Template Func Decl Special] Category=3 Description="Add or remove newline after 'template<>' of a specialized function
declaration.

Overrides nl_template_func_decl." Enabled=false EditorType=multiple Choices=nl_template_func_decl_special=ignore|nl_template_func_decl_special=add|nl_template_func_decl_special=remove|nl_template_func_decl_special=force|nl_template_func_decl_special=not_defined ChoicesReadable="Ignore Nl Template Func Decl Special|Add Nl Template Func Decl Special|Remove Nl Template Func Decl Special|Force Nl Template Func Decl Special" ValueDefault=ignore [Nl Template Func Def] Category=3 Description="Add or remove newline after 'template<...>' of a template function
definition.

Overrides nl_template_func." Enabled=false EditorType=multiple Choices=nl_template_func_def=ignore|nl_template_func_def=add|nl_template_func_def=remove|nl_template_func_def=force|nl_template_func_def=not_defined ChoicesReadable="Ignore Nl Template Func Def|Add Nl Template Func Def|Remove Nl Template Func Def|Force Nl Template Func Def" ValueDefault=ignore [Nl Template Func Def Special] Category=3 Description="Add or remove newline after 'template<>' of a specialized function
definition.

Overrides nl_template_func_def." Enabled=false EditorType=multiple Choices=nl_template_func_def_special=ignore|nl_template_func_def_special=add|nl_template_func_def_special=remove|nl_template_func_def_special=force|nl_template_func_def_special=not_defined ChoicesReadable="Ignore Nl Template Func Def Special|Add Nl Template Func Def Special|Remove Nl Template Func Def Special|Force Nl Template Func Def Special" ValueDefault=ignore [Nl Template Var] Category=3 Description="Add or remove newline after 'template<...>' of a template variable." Enabled=false EditorType=multiple Choices=nl_template_var=ignore|nl_template_var=add|nl_template_var=remove|nl_template_var=force|nl_template_var=not_defined ChoicesReadable="Ignore Nl Template Var|Add Nl Template Var|Remove Nl Template Var|Force Nl Template Var" ValueDefault=ignore [Nl Template Using] Category=3 Description="Add or remove newline between 'template<...>' and 'using' of a templated
type alias." Enabled=false EditorType=multiple Choices=nl_template_using=ignore|nl_template_using=add|nl_template_using=remove|nl_template_using=force|nl_template_using=not_defined ChoicesReadable="Ignore Nl Template Using|Add Nl Template Using|Remove Nl Template Using|Force Nl Template Using" ValueDefault=ignore [Nl Class Brace] Category=3 Description="Add or remove newline between 'class' and '{'." Enabled=false EditorType=multiple Choices=nl_class_brace=ignore|nl_class_brace=add|nl_class_brace=remove|nl_class_brace=force|nl_class_brace=not_defined ChoicesReadable="Ignore Nl Class Brace|Add Nl Class Brace|Remove Nl Class Brace|Force Nl Class Brace" ValueDefault=ignore [Nl Class Init Args] Category=3 Description="Add or remove newline before or after (depending on pos_class_comma,
may not be IGNORE) each',' in the base class list." Enabled=false EditorType=multiple Choices=nl_class_init_args=ignore|nl_class_init_args=add|nl_class_init_args=remove|nl_class_init_args=force|nl_class_init_args=not_defined ChoicesReadable="Ignore Nl Class Init Args|Add Nl Class Init Args|Remove Nl Class Init Args|Force Nl Class Init Args" ValueDefault=ignore [Nl Constr Init Args] Category=3 Description="Add or remove newline after each ',' in the constructor member
initialization. Related to nl_constr_colon, pos_constr_colon and
pos_constr_comma." Enabled=false EditorType=multiple Choices=nl_constr_init_args=ignore|nl_constr_init_args=add|nl_constr_init_args=remove|nl_constr_init_args=force|nl_constr_init_args=not_defined ChoicesReadable="Ignore Nl Constr Init Args|Add Nl Constr Init Args|Remove Nl Constr Init Args|Force Nl Constr Init Args" ValueDefault=ignore [Nl Enum Own Lines] Category=3 Description="Add or remove newline before first element, after comma, and after last
element, in 'enum'." Enabled=false EditorType=multiple Choices=nl_enum_own_lines=ignore|nl_enum_own_lines=add|nl_enum_own_lines=remove|nl_enum_own_lines=force|nl_enum_own_lines=not_defined ChoicesReadable="Ignore Nl Enum Own Lines|Add Nl Enum Own Lines|Remove Nl Enum Own Lines|Force Nl Enum Own Lines" ValueDefault=ignore [Nl Func Type Name] Category=3 Description="Add or remove newline between return type and function name in a function
definition.
might be modified by nl_func_leave_one_liners" Enabled=false EditorType=multiple Choices=nl_func_type_name=ignore|nl_func_type_name=add|nl_func_type_name=remove|nl_func_type_name=force|nl_func_type_name=not_defined ChoicesReadable="Ignore Nl Func Type Name|Add Nl Func Type Name|Remove Nl Func Type Name|Force Nl Func Type Name" ValueDefault=ignore [Nl Func Type Name Class] Category=3 Description="Add or remove newline between return type and function name inside a class
definition. If set to ignore, nl_func_type_name or nl_func_proto_type_name
is used instead." Enabled=false EditorType=multiple Choices=nl_func_type_name_class=ignore|nl_func_type_name_class=add|nl_func_type_name_class=remove|nl_func_type_name_class=force|nl_func_type_name_class=not_defined ChoicesReadable="Ignore Nl Func Type Name Class|Add Nl Func Type Name Class|Remove Nl Func Type Name Class|Force Nl Func Type Name Class" ValueDefault=ignore [Nl Func Class Scope] Category=3 Description="Add or remove newline between class specification and '::'
in 'void A::f() { }'. Only appears in separate member implementation (does
not appear with in-line implementation)." Enabled=false EditorType=multiple Choices=nl_func_class_scope=ignore|nl_func_class_scope=add|nl_func_class_scope=remove|nl_func_class_scope=force|nl_func_class_scope=not_defined ChoicesReadable="Ignore Nl Func Class Scope|Add Nl Func Class Scope|Remove Nl Func Class Scope|Force Nl Func Class Scope" ValueDefault=ignore [Nl Func Scope Name] Category=3 Description="Add or remove newline between function scope and name, as in
'void A :: <here> f() { }'." Enabled=false EditorType=multiple Choices=nl_func_scope_name=ignore|nl_func_scope_name=add|nl_func_scope_name=remove|nl_func_scope_name=force|nl_func_scope_name=not_defined ChoicesReadable="Ignore Nl Func Scope Name|Add Nl Func Scope Name|Remove Nl Func Scope Name|Force Nl Func Scope Name" ValueDefault=ignore [Nl Func Proto Type Name] Category=3 Description="Add or remove newline between return type and function name in a prototype." Enabled=false EditorType=multiple Choices=nl_func_proto_type_name=ignore|nl_func_proto_type_name=add|nl_func_proto_type_name=remove|nl_func_proto_type_name=force|nl_func_proto_type_name=not_defined ChoicesReadable="Ignore Nl Func Proto Type Name|Add Nl Func Proto Type Name|Remove Nl Func Proto Type Name|Force Nl Func Proto Type Name" ValueDefault=ignore [Nl Func Paren] Category=3 Description="Add or remove newline between a function name and the opening '(' in the
declaration." Enabled=false EditorType=multiple Choices=nl_func_paren=ignore|nl_func_paren=add|nl_func_paren=remove|nl_func_paren=force|nl_func_paren=not_defined ChoicesReadable="Ignore Nl Func Paren|Add Nl Func Paren|Remove Nl Func Paren|Force Nl Func Paren" ValueDefault=ignore [Nl Func Paren Empty] Category=3 Description="Overrides nl_func_paren for functions with no parameters." Enabled=false EditorType=multiple Choices=nl_func_paren_empty=ignore|nl_func_paren_empty=add|nl_func_paren_empty=remove|nl_func_paren_empty=force|nl_func_paren_empty=not_defined ChoicesReadable="Ignore Nl Func Paren Empty|Add Nl Func Paren Empty|Remove Nl Func Paren Empty|Force Nl Func Paren Empty" ValueDefault=ignore [Nl Func Def Paren] Category=3 Description="Add or remove newline between a function name and the opening '(' in the
definition." Enabled=false EditorType=multiple Choices=nl_func_def_paren=ignore|nl_func_def_paren=add|nl_func_def_paren=remove|nl_func_def_paren=force|nl_func_def_paren=not_defined ChoicesReadable="Ignore Nl Func Def Paren|Add Nl Func Def Paren|Remove Nl Func Def Paren|Force Nl Func Def Paren" ValueDefault=ignore [Nl Func Def Paren Empty] Category=3 Description="Overrides nl_func_def_paren for functions with no parameters." Enabled=false EditorType=multiple Choices=nl_func_def_paren_empty=ignore|nl_func_def_paren_empty=add|nl_func_def_paren_empty=remove|nl_func_def_paren_empty=force|nl_func_def_paren_empty=not_defined ChoicesReadable="Ignore Nl Func Def Paren Empty|Add Nl Func Def Paren Empty|Remove Nl Func Def Paren Empty|Force Nl Func Def Paren Empty" ValueDefault=ignore [Nl Func Call Paren] Category=3 Description="Add or remove newline between a function name and the opening '(' in the
call." Enabled=false EditorType=multiple Choices=nl_func_call_paren=ignore|nl_func_call_paren=add|nl_func_call_paren=remove|nl_func_call_paren=force|nl_func_call_paren=not_defined ChoicesReadable="Ignore Nl Func Call Paren|Add Nl Func Call Paren|Remove Nl Func Call Paren|Force Nl Func Call Paren" ValueDefault=ignore [Nl Func Call Paren Empty] Category=3 Description="Overrides nl_func_call_paren for functions with no parameters." Enabled=false EditorType=multiple Choices=nl_func_call_paren_empty=ignore|nl_func_call_paren_empty=add|nl_func_call_paren_empty=remove|nl_func_call_paren_empty=force|nl_func_call_paren_empty=not_defined ChoicesReadable="Ignore Nl Func Call Paren Empty|Add Nl Func Call Paren Empty|Remove Nl Func Call Paren Empty|Force Nl Func Call Paren Empty" ValueDefault=ignore [Nl Func Decl Start] Category=3 Description="Add or remove newline after '(' in a function declaration." Enabled=false EditorType=multiple Choices=nl_func_decl_start=ignore|nl_func_decl_start=add|nl_func_decl_start=remove|nl_func_decl_start=force|nl_func_decl_start=not_defined ChoicesReadable="Ignore Nl Func Decl Start|Add Nl Func Decl Start|Remove Nl Func Decl Start|Force Nl Func Decl Start" ValueDefault=ignore [Nl Func Def Start] Category=3 Description="Add or remove newline after '(' in a function definition." Enabled=false EditorType=multiple Choices=nl_func_def_start=ignore|nl_func_def_start=add|nl_func_def_start=remove|nl_func_def_start=force|nl_func_def_start=not_defined ChoicesReadable="Ignore Nl Func Def Start|Add Nl Func Def Start|Remove Nl Func Def Start|Force Nl Func Def Start" ValueDefault=ignore [Nl Func Decl Start Single] Category=3 Description="Overrides nl_func_decl_start when there is only one parameter." Enabled=false EditorType=multiple Choices=nl_func_decl_start_single=ignore|nl_func_decl_start_single=add|nl_func_decl_start_single=remove|nl_func_decl_start_single=force|nl_func_decl_start_single=not_defined ChoicesReadable="Ignore Nl Func Decl Start Single|Add Nl Func Decl Start Single|Remove Nl Func Decl Start Single|Force Nl Func Decl Start Single" ValueDefault=ignore [Nl Func Def Start Single] Category=3 Description="Overrides nl_func_def_start when there is only one parameter." Enabled=false EditorType=multiple Choices=nl_func_def_start_single=ignore|nl_func_def_start_single=add|nl_func_def_start_single=remove|nl_func_def_start_single=force|nl_func_def_start_single=not_defined ChoicesReadable="Ignore Nl Func Def Start Single|Add Nl Func Def Start Single|Remove Nl Func Def Start Single|Force Nl Func Def Start Single" ValueDefault=ignore [Nl Func Decl Start Multi Line] Category=3 Description="Whether to add a newline after '(' in a function declaration if '(' and ')'
are in different lines. If false, nl_func_decl_start is used instead." Enabled=false EditorType=boolean TrueFalse=nl_func_decl_start_multi_line=true|nl_func_decl_start_multi_line=false ValueDefault=false [Nl Func Def Start Multi Line] Category=3 Description="Whether to add a newline after '(' in a function definition if '(' and ')'
are in different lines. If false, nl_func_def_start is used instead." Enabled=false EditorType=boolean TrueFalse=nl_func_def_start_multi_line=true|nl_func_def_start_multi_line=false ValueDefault=false [Nl Func Decl Args] Category=3 Description="Add or remove newline after each ',' in a function declaration." Enabled=false EditorType=multiple Choices=nl_func_decl_args=ignore|nl_func_decl_args=add|nl_func_decl_args=remove|nl_func_decl_args=force|nl_func_decl_args=not_defined ChoicesReadable="Ignore Nl Func Decl Args|Add Nl Func Decl Args|Remove Nl Func Decl Args|Force Nl Func Decl Args" ValueDefault=ignore [Nl Func Def Args] Category=3 Description="Add or remove newline after each ',' in a function definition." Enabled=false EditorType=multiple Choices=nl_func_def_args=ignore|nl_func_def_args=add|nl_func_def_args=remove|nl_func_def_args=force|nl_func_def_args=not_defined ChoicesReadable="Ignore Nl Func Def Args|Add Nl Func Def Args|Remove Nl Func Def Args|Force Nl Func Def Args" ValueDefault=ignore [Nl Func Call Args] Category=3 Description="Add or remove newline after each ',' in a function call." Enabled=false EditorType=multiple Choices=nl_func_call_args=ignore|nl_func_call_args=add|nl_func_call_args=remove|nl_func_call_args=force|nl_func_call_args=not_defined ChoicesReadable="Ignore Nl Func Call Args|Add Nl Func Call Args|Remove Nl Func Call Args|Force Nl Func Call Args" ValueDefault=ignore [Nl Func Decl Args Multi Line] Category=3 Description="Whether to add a newline after each ',' in a function declaration if '('
and ')' are in different lines. If false, nl_func_decl_args is used instead." Enabled=false EditorType=boolean TrueFalse=nl_func_decl_args_multi_line=true|nl_func_decl_args_multi_line=false ValueDefault=false [Nl Func Def Args Multi Line] Category=3 Description="Whether to add a newline after each ',' in a function definition if '('
and ')' are in different lines. If false, nl_func_def_args is used instead." Enabled=false EditorType=boolean TrueFalse=nl_func_def_args_multi_line=true|nl_func_def_args_multi_line=false ValueDefault=false [Nl Func Decl End] Category=3 Description="Add or remove newline before the ')' in a function declaration." Enabled=false EditorType=multiple Choices=nl_func_decl_end=ignore|nl_func_decl_end=add|nl_func_decl_end=remove|nl_func_decl_end=force|nl_func_decl_end=not_defined ChoicesReadable="Ignore Nl Func Decl End|Add Nl Func Decl End|Remove Nl Func Decl End|Force Nl Func Decl End" ValueDefault=ignore [Nl Func Def End] Category=3 Description="Add or remove newline before the ')' in a function definition." Enabled=false EditorType=multiple Choices=nl_func_def_end=ignore|nl_func_def_end=add|nl_func_def_end=remove|nl_func_def_end=force|nl_func_def_end=not_defined ChoicesReadable="Ignore Nl Func Def End|Add Nl Func Def End|Remove Nl Func Def End|Force Nl Func Def End" ValueDefault=ignore [Nl Func Decl End Single] Category=3 Description="Overrides nl_func_decl_end when there is only one parameter." Enabled=false EditorType=multiple Choices=nl_func_decl_end_single=ignore|nl_func_decl_end_single=add|nl_func_decl_end_single=remove|nl_func_decl_end_single=force|nl_func_decl_end_single=not_defined ChoicesReadable="Ignore Nl Func Decl End Single|Add Nl Func Decl End Single|Remove Nl Func Decl End Single|Force Nl Func Decl End Single" ValueDefault=ignore [Nl Func Def End Single] Category=3 Description="Overrides nl_func_def_end when there is only one parameter." Enabled=false EditorType=multiple Choices=nl_func_def_end_single=ignore|nl_func_def_end_single=add|nl_func_def_end_single=remove|nl_func_def_end_single=force|nl_func_def_end_single=not_defined ChoicesReadable="Ignore Nl Func Def End Single|Add Nl Func Def End Single|Remove Nl Func Def End Single|Force Nl Func Def End Single" ValueDefault=ignore [Nl Func Decl End Multi Line] Category=3 Description="Whether to add a newline before ')' in a function declaration if '(' and ')'
are in different lines. If false, nl_func_decl_end is used instead." Enabled=false EditorType=boolean TrueFalse=nl_func_decl_end_multi_line=true|nl_func_decl_end_multi_line=false ValueDefault=false [Nl Func Def End Multi Line] Category=3 Description="Whether to add a newline before ')' in a function definition if '(' and ')'
are in different lines. If false, nl_func_def_end is used instead." Enabled=false EditorType=boolean TrueFalse=nl_func_def_end_multi_line=true|nl_func_def_end_multi_line=false ValueDefault=false [Nl Func Decl Empty] Category=3 Description="Add or remove newline between '()' in a function declaration." Enabled=false EditorType=multiple Choices=nl_func_decl_empty=ignore|nl_func_decl_empty=add|nl_func_decl_empty=remove|nl_func_decl_empty=force|nl_func_decl_empty=not_defined ChoicesReadable="Ignore Nl Func Decl Empty|Add Nl Func Decl Empty|Remove Nl Func Decl Empty|Force Nl Func Decl Empty" ValueDefault=ignore [Nl Func Def Empty] Category=3 Description="Add or remove newline between '()' in a function definition." Enabled=false EditorType=multiple Choices=nl_func_def_empty=ignore|nl_func_def_empty=add|nl_func_def_empty=remove|nl_func_def_empty=force|nl_func_def_empty=not_defined ChoicesReadable="Ignore Nl Func Def Empty|Add Nl Func Def Empty|Remove Nl Func Def Empty|Force Nl Func Def Empty" ValueDefault=ignore [Nl Func Call Empty] Category=3 Description="Add or remove newline between '()' in a function call." Enabled=false EditorType=multiple Choices=nl_func_call_empty=ignore|nl_func_call_empty=add|nl_func_call_empty=remove|nl_func_call_empty=force|nl_func_call_empty=not_defined ChoicesReadable="Ignore Nl Func Call Empty|Add Nl Func Call Empty|Remove Nl Func Call Empty|Force Nl Func Call Empty" ValueDefault=ignore [Nl Func Call Start] Category=3 Description="Whether to add a newline after '(' in a function call,
has preference over nl_func_call_start_multi_line." Enabled=false EditorType=multiple Choices=nl_func_call_start=ignore|nl_func_call_start=add|nl_func_call_start=remove|nl_func_call_start=force|nl_func_call_start=not_defined ChoicesReadable="Ignore Nl Func Call Start|Add Nl Func Call Start|Remove Nl Func Call Start|Force Nl Func Call Start" ValueDefault=ignore [Nl Func Call End] Category=3 Description="Whether to add a newline before ')' in a function call." Enabled=false EditorType=multiple Choices=nl_func_call_end=ignore|nl_func_call_end=add|nl_func_call_end=remove|nl_func_call_end=force|nl_func_call_end=not_defined ChoicesReadable="Ignore Nl Func Call End|Add Nl Func Call End|Remove Nl Func Call End|Force Nl Func Call End" ValueDefault=ignore [Nl Func Call Start Multi Line] Category=3 Description="Whether to add a newline after '(' in a function call if '(' and ')' are in
different lines." Enabled=false EditorType=boolean TrueFalse=nl_func_call_start_multi_line=true|nl_func_call_start_multi_line=false ValueDefault=false [Nl Func Call Args Multi Line] Category=3 Description="Whether to add a newline after each ',' in a function call if '(' and ')'
are in different lines." Enabled=false EditorType=boolean TrueFalse=nl_func_call_args_multi_line=true|nl_func_call_args_multi_line=false ValueDefault=false [Nl Func Call End Multi Line] Category=3 Description="Whether to add a newline before ')' in a function call if '(' and ')' are in
different lines." Enabled=false EditorType=boolean TrueFalse=nl_func_call_end_multi_line=true|nl_func_call_end_multi_line=false ValueDefault=false [Nl Func Call Args Multi Line Ignore Closures] Category=3 Description="Whether to respect nl_func_call_XXX option in case of closure args." Enabled=false EditorType=boolean TrueFalse=nl_func_call_args_multi_line_ignore_closures=true|nl_func_call_args_multi_line_ignore_closures=false ValueDefault=false [Nl Template Start] Category=3 Description="Whether to add a newline after '<' of a template parameter list." Enabled=false EditorType=boolean TrueFalse=nl_template_start=true|nl_template_start=false ValueDefault=false [Nl Template Args] Category=3 Description="Whether to add a newline after each ',' in a template parameter list." Enabled=false EditorType=boolean TrueFalse=nl_template_args=true|nl_template_args=false ValueDefault=false [Nl Template End] Category=3 Description="Whether to add a newline before '>' of a template parameter list." Enabled=false EditorType=boolean TrueFalse=nl_template_end=true|nl_template_end=false ValueDefault=false [Nl Oc Msg Args] Category=3 Description="(OC) Whether to put each Objective-C message parameter on a separate line.
See nl_oc_msg_leave_one_liner." Enabled=false EditorType=boolean TrueFalse=nl_oc_msg_args=true|nl_oc_msg_args=false ValueDefault=false [Nl Oc Msg Args Min Params] Category=3 Description="(OC) Minimum number of Objective-C message parameters before applying nl_oc_msg_args." Enabled=false EditorType=numeric CallName="nl_oc_msg_args_min_params=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Oc Msg Args Max Code Width] Category=3 Description="(OC) Max code width of Objective-C message before applying nl_oc_msg_args." Enabled=false EditorType=numeric CallName="nl_oc_msg_args_max_code_width=" MinVal=0 MaxVal=10000 ValueDefault=0 [Nl Fdef Brace] Category=3 Description="Add or remove newline between function signature and '{'." Enabled=false EditorType=multiple Choices=nl_fdef_brace=ignore|nl_fdef_brace=add|nl_fdef_brace=remove|nl_fdef_brace=force|nl_fdef_brace=not_defined ChoicesReadable="Ignore Nl Fdef Brace|Add Nl Fdef Brace|Remove Nl Fdef Brace|Force Nl Fdef Brace" ValueDefault=ignore [Nl Fdef Brace Cond] Category=3 Description="Add or remove newline between function signature and '{',
if signature ends with ')'. Overrides nl_fdef_brace." Enabled=false EditorType=multiple Choices=nl_fdef_brace_cond=ignore|nl_fdef_brace_cond=add|nl_fdef_brace_cond=remove|nl_fdef_brace_cond=force|nl_fdef_brace_cond=not_defined ChoicesReadable="Ignore Nl Fdef Brace Cond|Add Nl Fdef Brace Cond|Remove Nl Fdef Brace Cond|Force Nl Fdef Brace Cond" ValueDefault=ignore [Nl Cpp Ldef Brace] Category=3 Description="Add or remove newline between C++11 lambda signature and '{'." Enabled=false EditorType=multiple Choices=nl_cpp_ldef_brace=ignore|nl_cpp_ldef_brace=add|nl_cpp_ldef_brace=remove|nl_cpp_ldef_brace=force|nl_cpp_ldef_brace=not_defined ChoicesReadable="Ignore Nl Cpp Ldef Brace|Add Nl Cpp Ldef Brace|Remove Nl Cpp Ldef Brace|Force Nl Cpp Ldef Brace" ValueDefault=ignore [Nl Return Expr] Category=3 Description="Add or remove newline between 'return' and the return expression." Enabled=false EditorType=multiple Choices=nl_return_expr=ignore|nl_return_expr=add|nl_return_expr=remove|nl_return_expr=force|nl_return_expr=not_defined ChoicesReadable="Ignore Nl Return Expr|Add Nl Return Expr|Remove Nl Return Expr|Force Nl Return Expr" ValueDefault=ignore [Nl Throw Expr] Category=3 Description="Add or remove newline between 'throw' and the throw expression." Enabled=false EditorType=multiple Choices=nl_throw_expr=ignore|nl_throw_expr=add|nl_throw_expr=remove|nl_throw_expr=force|nl_throw_expr=not_defined ChoicesReadable="Ignore Nl Throw Expr|Add Nl Throw Expr|Remove Nl Throw Expr|Force Nl Throw Expr" ValueDefault=ignore [Nl After Semicolon] Category=3 Description="Whether to add a newline after semicolons, except in 'for' statements." Enabled=false EditorType=boolean TrueFalse=nl_after_semicolon=true|nl_after_semicolon=false ValueDefault=false [Nl Paren Dbrace Open] Category=3 Description="(Java) Add or remove newline between the ')' and '{{' of the double brace
initializer." Enabled=false EditorType=multiple Choices=nl_paren_dbrace_open=ignore|nl_paren_dbrace_open=add|nl_paren_dbrace_open=remove|nl_paren_dbrace_open=force|nl_paren_dbrace_open=not_defined ChoicesReadable="Ignore Nl Paren Dbrace Open|Add Nl Paren Dbrace Open|Remove Nl Paren Dbrace Open|Force Nl Paren Dbrace Open" ValueDefault=ignore [Nl Type Brace Init Lst] Category=3 Description="Whether to add a newline after the type in an unnamed temporary
direct-list-initialization, better:
before a direct-list-initialization." Enabled=false EditorType=multiple Choices=nl_type_brace_init_lst=ignore|nl_type_brace_init_lst=add|nl_type_brace_init_lst=remove|nl_type_brace_init_lst=force|nl_type_brace_init_lst=not_defined ChoicesReadable="Ignore Nl Type Brace Init Lst|Add Nl Type Brace Init Lst|Remove Nl Type Brace Init Lst|Force Nl Type Brace Init Lst" ValueDefault=ignore [Nl Type Brace Init Lst Open] Category=3 Description="Whether to add a newline after the open brace in an unnamed temporary
direct-list-initialization." Enabled=false EditorType=multiple Choices=nl_type_brace_init_lst_open=ignore|nl_type_brace_init_lst_open=add|nl_type_brace_init_lst_open=remove|nl_type_brace_init_lst_open=force|nl_type_brace_init_lst_open=not_defined ChoicesReadable="Ignore Nl Type Brace Init Lst Open|Add Nl Type Brace Init Lst Open|Remove Nl Type Brace Init Lst Open|Force Nl Type Brace Init Lst Open" ValueDefault=ignore [Nl Type Brace Init Lst Close] Category=3 Description="Whether to add a newline before the close brace in an unnamed temporary
direct-list-initialization." Enabled=false EditorType=multiple Choices=nl_type_brace_init_lst_close=ignore|nl_type_brace_init_lst_close=add|nl_type_brace_init_lst_close=remove|nl_type_brace_init_lst_close=force|nl_type_brace_init_lst_close=not_defined ChoicesReadable="Ignore Nl Type Brace Init Lst Close|Add Nl Type Brace Init Lst Close|Remove Nl Type Brace Init Lst Close|Force Nl Type Brace Init Lst Close" ValueDefault=ignore [Nl Before Brace Open] Category=3 Description="Whether to add a newline before '{'." Enabled=false EditorType=boolean TrueFalse=nl_before_brace_open=true|nl_before_brace_open=false ValueDefault=false [Nl After Brace Open] Category=3 Description="Whether to add a newline after '{'." Enabled=false EditorType=boolean TrueFalse=nl_after_brace_open=true|nl_after_brace_open=false ValueDefault=false [Nl After Brace Open Cmt] Category=3 Description="Whether to add a newline between the open brace and a trailing single-line
comment. Requires nl_after_brace_open=true." Enabled=false EditorType=boolean TrueFalse=nl_after_brace_open_cmt=true|nl_after_brace_open_cmt=false ValueDefault=false [Nl After Vbrace Open] Category=3 Description="Whether to add a newline after a virtual brace open with a non-empty body.
These occur in un-braced if/while/do/for statement bodies." Enabled=false EditorType=boolean TrueFalse=nl_after_vbrace_open=true|nl_after_vbrace_open=false ValueDefault=false [Nl After Vbrace Open Empty] Category=3 Description="Whether to add a newline after a virtual brace open with an empty body.
These occur in un-braced if/while/do/for statement bodies." Enabled=false EditorType=boolean TrueFalse=nl_after_vbrace_open_empty=true|nl_after_vbrace_open_empty=false ValueDefault=false [Nl After Brace Close] Category=3 Description="Whether to add a newline after '}'. Does not apply if followed by a
necessary ';'." Enabled=false EditorType=boolean TrueFalse=nl_after_brace_close=true|nl_after_brace_close=false ValueDefault=false [Nl After Vbrace Close] Category=3 Description="Whether to add a newline after a virtual brace close,
as in 'if (foo) a++; <here> return;'." Enabled=false EditorType=boolean TrueFalse=nl_after_vbrace_close=true|nl_after_vbrace_close=false ValueDefault=false [Nl Brace Struct Var] Category=3 Description="Add or remove newline between the close brace and identifier,
as in 'struct { int a; } <here> b;'. Affects enumerations, unions and
structures. If set to ignore, uses nl_after_brace_close." Enabled=false EditorType=multiple Choices=nl_brace_struct_var=ignore|nl_brace_struct_var=add|nl_brace_struct_var=remove|nl_brace_struct_var=force|nl_brace_struct_var=not_defined ChoicesReadable="Ignore Nl Brace Struct Var|Add Nl Brace Struct Var|Remove Nl Brace Struct Var|Force Nl Brace Struct Var" ValueDefault=ignore [Nl Define Macro] Category=3 Description="Whether to alter newlines in '#define' macros." Enabled=false EditorType=boolean TrueFalse=nl_define_macro=true|nl_define_macro=false ValueDefault=false [Nl Squeeze Paren Close] Category=3 Description="Whether to alter newlines between consecutive parenthesis closes. The number
of closing parentheses in a line will depend on respective open parenthesis
lines." Enabled=false EditorType=boolean TrueFalse=nl_squeeze_paren_close=true|nl_squeeze_paren_close=false ValueDefault=false [Nl Squeeze Ifdef] Category=3 Description="Whether to remove blanks after '#ifxx' and '#elxx', or before '#elxx' and
'#endif'. Does not affect top-level #ifdefs." Enabled=false EditorType=boolean TrueFalse=nl_squeeze_ifdef=true|nl_squeeze_ifdef=false ValueDefault=false [Nl Squeeze Ifdef Top Level] Category=3 Description="Makes the nl_squeeze_ifdef option affect the top-level #ifdefs as well." Enabled=false EditorType=boolean TrueFalse=nl_squeeze_ifdef_top_level=true|nl_squeeze_ifdef_top_level=false ValueDefault=false [Nl Before If] Category=3 Description="Add or remove blank line before 'if'." Enabled=false EditorType=multiple Choices=nl_before_if=ignore|nl_before_if=add|nl_before_if=remove|nl_before_if=force|nl_before_if=not_defined ChoicesReadable="Ignore Nl Before If|Add Nl Before If|Remove Nl Before If|Force Nl Before If" ValueDefault=ignore [Nl After If] Category=3 Description="Add or remove blank line after 'if' statement. Add/Force work only if the
next token is not a closing brace." Enabled=false EditorType=multiple Choices=nl_after_if=ignore|nl_after_if=add|nl_after_if=remove|nl_after_if=force|nl_after_if=not_defined ChoicesReadable="Ignore Nl After If|Add Nl After If|Remove Nl After If|Force Nl After If" ValueDefault=ignore [Nl Before For] Category=3 Description="Add or remove blank line before 'for'." Enabled=false EditorType=multiple Choices=nl_before_for=ignore|nl_before_for=add|nl_before_for=remove|nl_before_for=force|nl_before_for=not_defined ChoicesReadable="Ignore Nl Before For|Add Nl Before For|Remove Nl Before For|Force Nl Before For" ValueDefault=ignore [Nl After For] Category=3 Description="Add or remove blank line after 'for' statement." Enabled=false EditorType=multiple Choices=nl_after_for=ignore|nl_after_for=add|nl_after_for=remove|nl_after_for=force|nl_after_for=not_defined ChoicesReadable="Ignore Nl After For|Add Nl After For|Remove Nl After For|Force Nl After For" ValueDefault=ignore [Nl Before While] Category=3 Description="Add or remove blank line before 'while'." Enabled=false EditorType=multiple Choices=nl_before_while=ignore|nl_before_while=add|nl_before_while=remove|nl_before_while=force|nl_before_while=not_defined ChoicesReadable="Ignore Nl Before While|Add Nl Before While|Remove Nl Before While|Force Nl Before While" ValueDefault=ignore [Nl After While] Category=3 Description="Add or remove blank line after 'while' statement." Enabled=false EditorType=multiple Choices=nl_after_while=ignore|nl_after_while=add|nl_after_while=remove|nl_after_while=force|nl_after_while=not_defined ChoicesReadable="Ignore Nl After While|Add Nl After While|Remove Nl After While|Force Nl After While" ValueDefault=ignore [Nl Before Switch] Category=3 Description="Add or remove blank line before 'switch'." Enabled=false EditorType=multiple Choices=nl_before_switch=ignore|nl_before_switch=add|nl_before_switch=remove|nl_before_switch=force|nl_before_switch=not_defined ChoicesReadable="Ignore Nl Before Switch|Add Nl Before Switch|Remove Nl Before Switch|Force Nl Before Switch" ValueDefault=ignore [Nl After Switch] Category=3 Description="Add or remove blank line after 'switch' statement." Enabled=false EditorType=multiple Choices=nl_after_switch=ignore|nl_after_switch=add|nl_after_switch=remove|nl_after_switch=force|nl_after_switch=not_defined ChoicesReadable="Ignore Nl After Switch|Add Nl After Switch|Remove Nl After Switch|Force Nl After Switch" ValueDefault=ignore [Nl Before Synchronized] Category=3 Description="Add or remove blank line before 'synchronized'." Enabled=false EditorType=multiple Choices=nl_before_synchronized=ignore|nl_before_synchronized=add|nl_before_synchronized=remove|nl_before_synchronized=force|nl_before_synchronized=not_defined ChoicesReadable="Ignore Nl Before Synchronized|Add Nl Before Synchronized|Remove Nl Before Synchronized|Force Nl Before Synchronized" ValueDefault=ignore [Nl After Synchronized] Category=3 Description="Add or remove blank line after 'synchronized' statement." Enabled=false EditorType=multiple Choices=nl_after_synchronized=ignore|nl_after_synchronized=add|nl_after_synchronized=remove|nl_after_synchronized=force|nl_after_synchronized=not_defined ChoicesReadable="Ignore Nl After Synchronized|Add Nl After Synchronized|Remove Nl After Synchronized|Force Nl After Synchronized" ValueDefault=ignore [Nl Before Do] Category=3 Description="Add or remove blank line before 'do'." Enabled=false EditorType=multiple Choices=nl_before_do=ignore|nl_before_do=add|nl_before_do=remove|nl_before_do=force|nl_before_do=not_defined ChoicesReadable="Ignore Nl Before Do|Add Nl Before Do|Remove Nl Before Do|Force Nl Before Do" ValueDefault=ignore [Nl After Do] Category=3 Description="Add or remove blank line after 'do/while' statement." Enabled=false EditorType=multiple Choices=nl_after_do=ignore|nl_after_do=add|nl_after_do=remove|nl_after_do=force|nl_after_do=not_defined ChoicesReadable="Ignore Nl After Do|Add Nl After Do|Remove Nl After Do|Force Nl After Do" ValueDefault=ignore [Nl Before Ignore After Case] Category=3 Description="Ignore nl_before_{if,for,switch,do,synchronized} if the control
statement is immediately after a case statement.
if nl_before_{if,for,switch,do} is set to remove, this option
does nothing." Enabled=false EditorType=boolean TrueFalse=nl_before_ignore_after_case=true|nl_before_ignore_after_case=false ValueDefault=false [Nl Before Return] Category=3 Description="Whether to put a blank line before 'return' statements, unless after an open
brace." Enabled=false EditorType=boolean TrueFalse=nl_before_return=true|nl_before_return=false ValueDefault=false [Nl After Return] Category=3 Description="Whether to put a blank line after 'return' statements, unless followed by a
close brace." Enabled=false EditorType=boolean TrueFalse=nl_after_return=true|nl_after_return=false ValueDefault=false [Nl Before Member] Category=3 Description="Whether to put a blank line before a member '.' or '->' operators." Enabled=false EditorType=multiple Choices=nl_before_member=ignore|nl_before_member=add|nl_before_member=remove|nl_before_member=force|nl_before_member=not_defined ChoicesReadable="Ignore Nl Before Member|Add Nl Before Member|Remove Nl Before Member|Force Nl Before Member" ValueDefault=ignore [Nl After Member] Category=3 Description="(Java) Whether to put a blank line after a member '.' or '->' operators." Enabled=false EditorType=multiple Choices=nl_after_member=ignore|nl_after_member=add|nl_after_member=remove|nl_after_member=force|nl_after_member=not_defined ChoicesReadable="Ignore Nl After Member|Add Nl After Member|Remove Nl After Member|Force Nl After Member" ValueDefault=ignore [Nl Ds Struct Enum Cmt] Category=3 Description="Whether to double-space commented-entries in 'struct'/'union'/'enum'." Enabled=false EditorType=boolean TrueFalse=nl_ds_struct_enum_cmt=true|nl_ds_struct_enum_cmt=false ValueDefault=false [Nl Ds Struct Enum Close Brace] Category=3 Description="Whether to force a newline before '}' of a 'struct'/'union'/'enum'.
(Lower priority than eat_blanks_before_close_brace.)" Enabled=false EditorType=boolean TrueFalse=nl_ds_struct_enum_close_brace=true|nl_ds_struct_enum_close_brace=false ValueDefault=false [Nl Class Colon] Category=3 Description="Add or remove newline before or after (depending on pos_class_colon) a class
colon, as in 'class Foo <here> : <or here> public Bar'." Enabled=false EditorType=multiple Choices=nl_class_colon=ignore|nl_class_colon=add|nl_class_colon=remove|nl_class_colon=force|nl_class_colon=not_defined ChoicesReadable="Ignore Nl Class Colon|Add Nl Class Colon|Remove Nl Class Colon|Force Nl Class Colon" ValueDefault=ignore [Nl Constr Colon] Category=3 Description="Add or remove newline around a class constructor colon. The exact position
depends on nl_constr_init_args, pos_constr_colon and pos_constr_comma." Enabled=false EditorType=multiple Choices=nl_constr_colon=ignore|nl_constr_colon=add|nl_constr_colon=remove|nl_constr_colon=force|nl_constr_colon=not_defined ChoicesReadable="Ignore Nl Constr Colon|Add Nl Constr Colon|Remove Nl Constr Colon|Force Nl Constr Colon" ValueDefault=ignore [Nl Namespace Two To One Liner] Category=3 Description="Whether to collapse a two-line namespace, like 'namespace foo\n{ decl; }'
into a single line. If true, prevents other brace newline rules from turning
such code into four lines. If true, it also preserves one-liner namespaces." Enabled=false EditorType=boolean TrueFalse=nl_namespace_two_to_one_liner=true|nl_namespace_two_to_one_liner=false ValueDefault=false [Nl Create If One Liner] Category=3 Description="Whether to remove a newline in simple unbraced if statements, turning them
into one-liners, as in 'if(b)\n i++;' => 'if(b) i++;'." Enabled=false EditorType=boolean TrueFalse=nl_create_if_one_liner=true|nl_create_if_one_liner=false ValueDefault=false [Nl Create For One Liner] Category=3 Description="Whether to remove a newline in simple unbraced for statements, turning them
into one-liners, as in 'for (...)\n stmt;' => 'for (...) stmt;'." Enabled=false EditorType=boolean TrueFalse=nl_create_for_one_liner=true|nl_create_for_one_liner=false ValueDefault=false [Nl Create While One Liner] Category=3 Description="Whether to remove a newline in simple unbraced while statements, turning
them into one-liners, as in 'while (expr)\n stmt;' => 'while (expr) stmt;'." Enabled=false EditorType=boolean TrueFalse=nl_create_while_one_liner=true|nl_create_while_one_liner=false ValueDefault=false [Nl Create Func Def One Liner] Category=3 Description="Whether to collapse a function definition whose body (not counting braces)
is only one line so that the entire definition (prototype, braces, body) is
a single line." Enabled=false EditorType=boolean TrueFalse=nl_create_func_def_one_liner=true|nl_create_func_def_one_liner=false ValueDefault=false [Nl Create List One Liner] Category=3 Description="Whether to split one-line simple list definitions into three lines by
adding newlines, as in 'int a[12] = { <here> 0 <here> };'." Enabled=false EditorType=boolean TrueFalse=nl_create_list_one_liner=true|nl_create_list_one_liner=false ValueDefault=false [Nl Split If One Liner] Category=3 Description="Whether to split one-line simple unbraced if statements into two lines by
adding a newline, as in 'if(b) <here> i++;'." Enabled=false EditorType=boolean TrueFalse=nl_split_if_one_liner=true|nl_split_if_one_liner=false ValueDefault=false [Nl Split For One Liner] Category=3 Description="Whether to split one-line simple unbraced for statements into two lines by
adding a newline, as in 'for (...) <here> stmt;'." Enabled=false EditorType=boolean TrueFalse=nl_split_for_one_liner=true|nl_split_for_one_liner=false ValueDefault=false [Nl Split While One Liner] Category=3 Description="Whether to split one-line simple unbraced while statements into two lines by
adding a newline, as in 'while (expr) <here> stmt;'." Enabled=false EditorType=boolean TrueFalse=nl_split_while_one_liner=true|nl_split_while_one_liner=false ValueDefault=false [Donot Add Nl Before Cpp Comment] Category=3 Description="Don't add a newline before a cpp-comment in a parameter list of a function
call." Enabled=false EditorType=boolean TrueFalse=donot_add_nl_before_cpp_comment=true|donot_add_nl_before_cpp_comment=false ValueDefault=false [Nl Max] Category=4 Description="The maximum number of consecutive newlines (3 = 2 blank lines)." Enabled=false EditorType=numeric CallName="nl_max=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Max Blank In Func] Category=4 Description="The maximum number of consecutive newlines in a function." Enabled=false EditorType=numeric CallName="nl_max_blank_in_func=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Inside Empty Func] Category=4 Description="The number of newlines inside an empty function body.
This option overrides eat_blanks_after_open_brace and
eat_blanks_before_close_brace, but is ignored when
nl_collapse_empty_body_functions=true" Enabled=false EditorType=numeric CallName="nl_inside_empty_func=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Func Body Proto] Category=4 Description="The number of newlines before a function prototype." Enabled=false EditorType=numeric CallName="nl_before_func_body_proto=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Func Body Def] Category=4 Description="The number of newlines before a multi-line function definition. Where
applicable, this option is overridden with eat_blanks_after_open_brace=true" Enabled=false EditorType=numeric CallName="nl_before_func_body_def=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Func Class Proto] Category=4 Description="The number of newlines before a class constructor/destructor prototype." Enabled=false EditorType=numeric CallName="nl_before_func_class_proto=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Func Class Def] Category=4 Description="The number of newlines before a class constructor/destructor definition." Enabled=false EditorType=numeric CallName="nl_before_func_class_def=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Func Proto] Category=4 Description="The number of newlines after a function prototype." Enabled=false EditorType=numeric CallName="nl_after_func_proto=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Func Proto Group] Category=4 Description="The number of newlines after a function prototype, if not followed by
another function prototype." Enabled=false EditorType=numeric CallName="nl_after_func_proto_group=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Func Class Proto] Category=4 Description="The number of newlines after a class constructor/destructor prototype." Enabled=false EditorType=numeric CallName="nl_after_func_class_proto=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Func Class Proto Group] Category=4 Description="The number of newlines after a class constructor/destructor prototype,
if not followed by another constructor/destructor prototype." Enabled=false EditorType=numeric CallName="nl_after_func_class_proto_group=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Class Leave One Liner Groups] Category=4 Description="Whether one-line method definitions inside a class body should be treated
as if they were prototypes for the purposes of adding newlines.

Requires nl_class_leave_one_liners=true. Overrides nl_before_func_body_def
and nl_before_func_class_def for one-liners." Enabled=false EditorType=boolean TrueFalse=nl_class_leave_one_liner_groups=true|nl_class_leave_one_liner_groups=false ValueDefault=false [Nl After Func Body] Category=4 Description="The number of newlines after '}' of a multi-line function body." Enabled=false EditorType=numeric CallName="nl_after_func_body=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Func Body Class] Category=4 Description="The number of newlines after '}' of a multi-line function body in a class
declaration. Also affects class constructors/destructors.

Overrides nl_after_func_body." Enabled=false EditorType=numeric CallName="nl_after_func_body_class=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Func Body One Liner] Category=4 Description="The number of newlines after '}' of a single line function body. Also
affects class constructors/destructors.

Overrides nl_after_func_body and nl_after_func_body_class." Enabled=false EditorType=numeric CallName="nl_after_func_body_one_liner=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Typedef Blk Start] Category=4 Description="The number of newlines before a block of typedefs. If nl_after_access_spec
is non-zero, that option takes precedence.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_typedef_blk_start=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Typedef Blk End] Category=4 Description="The number of newlines after a block of typedefs.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_typedef_blk_end=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Typedef Blk In] Category=4 Description="The maximum number of consecutive newlines within a block of typedefs.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_typedef_blk_in=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Var Def Blk End Func Top] Category=4 Description="The minimum number of blank lines after a block of variable definitions
at the top of a function body. If any preprocessor directives appear
between the opening brace of the function and the variable block, then
it is considered as not at the top of the function.Newlines are added
before trailing preprocessor directives, if any exist.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_var_def_blk_end_func_top=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Var Def Blk Start] Category=4 Description="The minimum number of empty newlines before a block of variable definitions
not at the top of a function body. If nl_after_access_spec is non-zero,
that option takes precedence. Newlines are not added at the top of the
file or just after an opening brace. Newlines are added above any
preprocessor directives before the block.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_var_def_blk_start=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Var Def Blk End] Category=4 Description="The minimum number of empty newlines after a block of variable definitions
not at the top of a function body. Newlines are not added if the block
is at the bottom of the file or just before a preprocessor directive.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_var_def_blk_end=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Var Def Blk In] Category=4 Description="The maximum number of consecutive newlines within a block of variable
definitions.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_var_def_blk_in=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Block Comment] Category=4 Description="The minimum number of newlines before a multi-line comment.
Doesn't apply if after a brace open or another multi-line comment." Enabled=false EditorType=numeric CallName="nl_before_block_comment=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before C Comment] Category=4 Description="The minimum number of newlines before a single-line C comment.
Doesn't apply if after a brace open or other single-line C comments." Enabled=false EditorType=numeric CallName="nl_before_c_comment=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Cpp Comment] Category=4 Description="The minimum number of newlines before a CPP comment.
Doesn't apply if after a brace open or other CPP comments." Enabled=false EditorType=numeric CallName="nl_before_cpp_comment=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Multiline Comment] Category=4 Description="Whether to force a newline after a multi-line comment." Enabled=false EditorType=boolean TrueFalse=nl_after_multiline_comment=true|nl_after_multiline_comment=false ValueDefault=false [Nl After Label Colon] Category=4 Description="Whether to force a newline after a label's colon." Enabled=false EditorType=boolean TrueFalse=nl_after_label_colon=true|nl_after_label_colon=false ValueDefault=false [Nl Before Struct] Category=4 Description="The number of newlines before a struct definition." Enabled=false EditorType=numeric CallName="nl_before_struct=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Struct] Category=4 Description="The number of newlines after '}' or ';' of a struct/enum/union definition." Enabled=false EditorType=numeric CallName="nl_after_struct=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Class] Category=4 Description="The number of newlines before a class definition." Enabled=false EditorType=numeric CallName="nl_before_class=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Class] Category=4 Description="The number of newlines after '}' or ';' of a class definition." Enabled=false EditorType=numeric CallName="nl_after_class=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Namespace] Category=4 Description="The number of newlines before a namespace." Enabled=false EditorType=numeric CallName="nl_before_namespace=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Inside Namespace] Category=4 Description="The number of newlines after '{' of a namespace. This also adds newlines
before the matching '}'.

0: Apply eat_blanks_after_open_brace or eat_blanks_before_close_brace if
applicable, otherwise no change.

Overrides eat_blanks_after_open_brace and eat_blanks_before_close_brace." Enabled=false EditorType=numeric CallName="nl_inside_namespace=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Namespace] Category=4 Description="The number of newlines after '}' of a namespace." Enabled=false EditorType=numeric CallName="nl_after_namespace=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Access Spec] Category=4 Description="The number of newlines before an access specifier label. This also includes
the Qt-specific 'signals:' and 'slots:'. Will not change the newline count
if after a brace open.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_before_access_spec=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Access Spec] Category=4 Description="The number of newlines after an access specifier label. This also includes
the Qt-specific 'signals:' and 'slots:'. Will not change the newline count
if after a brace open.

0: No change (default).

Overrides nl_typedef_blk_start and nl_var_def_blk_start." Enabled=false EditorType=numeric CallName="nl_after_access_spec=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Comment Func Def] Category=4 Description="The number of newlines between a function definition and the function
comment, as in '// comment\n <here> void foo() {...}'.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_comment_func_def=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Try Catch Finally] Category=4 Description="The number of newlines after a try-catch-finally block that isn't followed
by a brace close.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_after_try_catch_finally=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Around Cs Property] Category=4 Description="(C#) The number of newlines before and after a property, indexer or event
declaration.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_around_cs_property=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Between Get Set] Category=4 Description="(C#) The number of newlines between the get/set/add/remove handlers.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_between_get_set=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Property Brace] Category=4 Description="(C#) Add or remove newline between property and the '{'." Enabled=false EditorType=multiple Choices=nl_property_brace=ignore|nl_property_brace=add|nl_property_brace=remove|nl_property_brace=force|nl_property_brace=not_defined ChoicesReadable="Ignore Nl Property Brace|Add Nl Property Brace|Remove Nl Property Brace|Force Nl Property Brace" ValueDefault=ignore [Eat Blanks After Open Brace] Category=4 Description="Whether to remove blank lines after '{'." Enabled=false EditorType=boolean TrueFalse=eat_blanks_after_open_brace=true|eat_blanks_after_open_brace=false ValueDefault=false [Eat Blanks Before Close Brace] Category=4 Description="Whether to remove blank lines before '}'." Enabled=false EditorType=boolean TrueFalse=eat_blanks_before_close_brace=true|eat_blanks_before_close_brace=false ValueDefault=false [Nl Remove Extra Newlines] Category=4 Description="How aggressively to remove extra newlines not in preprocessor.

0: No change (default)
1: Remove most newlines not handled by other config
2: Remove all newlines and reformat completely by config" Enabled=false EditorType=numeric CallName="nl_remove_extra_newlines=" MinVal=0 MaxVal=2 ValueDefault=0 [Nl After Annotation] Category=4 Description="(Java) Add or remove newline after an annotation statement. Only affects
annotations that are after a newline." Enabled=false EditorType=multiple Choices=nl_after_annotation=ignore|nl_after_annotation=add|nl_after_annotation=remove|nl_after_annotation=force|nl_after_annotation=not_defined ChoicesReadable="Ignore Nl After Annotation|Add Nl After Annotation|Remove Nl After Annotation|Force Nl After Annotation" ValueDefault=ignore [Nl Between Annotation] Category=4 Description="(Java) Add or remove newline between two annotations." Enabled=false EditorType=multiple Choices=nl_between_annotation=ignore|nl_between_annotation=add|nl_between_annotation=remove|nl_between_annotation=force|nl_between_annotation=not_defined ChoicesReadable="Ignore Nl Between Annotation|Add Nl Between Annotation|Remove Nl Between Annotation|Force Nl Between Annotation" ValueDefault=ignore [Nl Before Whole File Ifdef] Category=4 Description="The number of newlines before a whole-file #ifdef.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_before_whole_file_ifdef=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Whole File Ifdef] Category=4 Description="The number of newlines after a whole-file #ifdef.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_after_whole_file_ifdef=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl Before Whole File Endif] Category=4 Description="The number of newlines before a whole-file #endif.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_before_whole_file_endif=" MinVal=0 MaxVal=16 ValueDefault=0 [Nl After Whole File Endif] Category=4 Description="The number of newlines after a whole-file #endif.

0: No change (default)." Enabled=false EditorType=numeric CallName="nl_after_whole_file_endif=" MinVal=0 MaxVal=16 ValueDefault=0 [Pos Arith] Category=5 Description="The position of arithmetic operators in wrapped expressions." Enabled=false EditorType=multiple Choices=pos_arith=ignore|pos_arith=break|pos_arith=force|pos_arith=lead|pos_arith=trail|pos_arith=join|pos_arith=lead_break|pos_arith=lead_force|pos_arith=trail_break|pos_arith=trail_force ChoicesReadable="Ignore Pos Arith|Break Pos Arith|Force Pos Arith|Lead Pos Arith|Trail Pos Arith|Join Pos Arith|Lead Break Pos Arith|Lead Force Pos Arith|Trail Break Pos Arith|Trail Force Pos Arith" ValueDefault=ignore [Pos Assign] Category=5 Description="The position of assignment in wrapped expressions. Do not affect '='
followed by '{'." Enabled=false EditorType=multiple Choices=pos_assign=ignore|pos_assign=break|pos_assign=force|pos_assign=lead|pos_assign=trail|pos_assign=join|pos_assign=lead_break|pos_assign=lead_force|pos_assign=trail_break|pos_assign=trail_force ChoicesReadable="Ignore Pos Assign|Break Pos Assign|Force Pos Assign|Lead Pos Assign|Trail Pos Assign|Join Pos Assign|Lead Break Pos Assign|Lead Force Pos Assign|Trail Break Pos Assign|Trail Force Pos Assign" ValueDefault=ignore [Pos Bool] Category=5 Description="The position of Boolean operators in wrapped expressions." Enabled=false EditorType=multiple Choices=pos_bool=ignore|pos_bool=break|pos_bool=force|pos_bool=lead|pos_bool=trail|pos_bool=join|pos_bool=lead_break|pos_bool=lead_force|pos_bool=trail_break|pos_bool=trail_force ChoicesReadable="Ignore Pos Bool|Break Pos Bool|Force Pos Bool|Lead Pos Bool|Trail Pos Bool|Join Pos Bool|Lead Break Pos Bool|Lead Force Pos Bool|Trail Break Pos Bool|Trail Force Pos Bool" ValueDefault=ignore [Pos Compare] Category=5 Description="The position of comparison operators in wrapped expressions." Enabled=false EditorType=multiple Choices=pos_compare=ignore|pos_compare=break|pos_compare=force|pos_compare=lead|pos_compare=trail|pos_compare=join|pos_compare=lead_break|pos_compare=lead_force|pos_compare=trail_break|pos_compare=trail_force ChoicesReadable="Ignore Pos Compare|Break Pos Compare|Force Pos Compare|Lead Pos Compare|Trail Pos Compare|Join Pos Compare|Lead Break Pos Compare|Lead Force Pos Compare|Trail Break Pos Compare|Trail Force Pos Compare" ValueDefault=ignore [Pos Conditional] Category=5 Description="The position of conditional operators, as in the '?' and ':' of
'expr ? stmt : stmt', in wrapped expressions." Enabled=false EditorType=multiple Choices=pos_conditional=ignore|pos_conditional=break|pos_conditional=force|pos_conditional=lead|pos_conditional=trail|pos_conditional=join|pos_conditional=lead_break|pos_conditional=lead_force|pos_conditional=trail_break|pos_conditional=trail_force ChoicesReadable="Ignore Pos Conditional|Break Pos Conditional|Force Pos Conditional|Lead Pos Conditional|Trail Pos Conditional|Join Pos Conditional|Lead Break Pos Conditional|Lead Force Pos Conditional|Trail Break Pos Conditional|Trail Force Pos Conditional" ValueDefault=ignore [Pos Comma] Category=5 Description="The position of the comma in wrapped expressions." Enabled=false EditorType=multiple Choices=pos_comma=ignore|pos_comma=break|pos_comma=force|pos_comma=lead|pos_comma=trail|pos_comma=join|pos_comma=lead_break|pos_comma=lead_force|pos_comma=trail_break|pos_comma=trail_force ChoicesReadable="Ignore Pos Comma|Break Pos Comma|Force Pos Comma|Lead Pos Comma|Trail Pos Comma|Join Pos Comma|Lead Break Pos Comma|Lead Force Pos Comma|Trail Break Pos Comma|Trail Force Pos Comma" ValueDefault=ignore [Pos Enum Comma] Category=5 Description="The position of the comma in enum entries." Enabled=false EditorType=multiple Choices=pos_enum_comma=ignore|pos_enum_comma=break|pos_enum_comma=force|pos_enum_comma=lead|pos_enum_comma=trail|pos_enum_comma=join|pos_enum_comma=lead_break|pos_enum_comma=lead_force|pos_enum_comma=trail_break|pos_enum_comma=trail_force ChoicesReadable="Ignore Pos Enum Comma|Break Pos Enum Comma|Force Pos Enum Comma|Lead Pos Enum Comma|Trail Pos Enum Comma|Join Pos Enum Comma|Lead Break Pos Enum Comma|Lead Force Pos Enum Comma|Trail Break Pos Enum Comma|Trail Force Pos Enum Comma" ValueDefault=ignore [Pos Class Comma] Category=5 Description="The position of the comma in the base class list if there is more than one
line. Affects nl_class_init_args." Enabled=false EditorType=multiple Choices=pos_class_comma=ignore|pos_class_comma=break|pos_class_comma=force|pos_class_comma=lead|pos_class_comma=trail|pos_class_comma=join|pos_class_comma=lead_break|pos_class_comma=lead_force|pos_class_comma=trail_break|pos_class_comma=trail_force ChoicesReadable="Ignore Pos Class Comma|Break Pos Class Comma|Force Pos Class Comma|Lead Pos Class Comma|Trail Pos Class Comma|Join Pos Class Comma|Lead Break Pos Class Comma|Lead Force Pos Class Comma|Trail Break Pos Class Comma|Trail Force Pos Class Comma" ValueDefault=ignore [Pos Constr Comma] Category=5 Description="The position of the comma in the constructor initialization list.
Related to nl_constr_colon, nl_constr_init_args and pos_constr_colon." Enabled=false EditorType=multiple Choices=pos_constr_comma=ignore|pos_constr_comma=break|pos_constr_comma=force|pos_constr_comma=lead|pos_constr_comma=trail|pos_constr_comma=join|pos_constr_comma=lead_break|pos_constr_comma=lead_force|pos_constr_comma=trail_break|pos_constr_comma=trail_force ChoicesReadable="Ignore Pos Constr Comma|Break Pos Constr Comma|Force Pos Constr Comma|Lead Pos Constr Comma|Trail Pos Constr Comma|Join Pos Constr Comma|Lead Break Pos Constr Comma|Lead Force Pos Constr Comma|Trail Break Pos Constr Comma|Trail Force Pos Constr Comma" ValueDefault=ignore [Pos Class Colon] Category=5 Description="The position of trailing/leading class colon, between class and base class
list. Affects nl_class_colon." Enabled=false EditorType=multiple Choices=pos_class_colon=ignore|pos_class_colon=break|pos_class_colon=force|pos_class_colon=lead|pos_class_colon=trail|pos_class_colon=join|pos_class_colon=lead_break|pos_class_colon=lead_force|pos_class_colon=trail_break|pos_class_colon=trail_force ChoicesReadable="Ignore Pos Class Colon|Break Pos Class Colon|Force Pos Class Colon|Lead Pos Class Colon|Trail Pos Class Colon|Join Pos Class Colon|Lead Break Pos Class Colon|Lead Force Pos Class Colon|Trail Break Pos Class Colon|Trail Force Pos Class Colon" ValueDefault=ignore [Pos Constr Colon] Category=5 Description="The position of colons between constructor and member initialization.
Related to nl_constr_colon, nl_constr_init_args and pos_constr_comma." Enabled=false EditorType=multiple Choices=pos_constr_colon=ignore|pos_constr_colon=break|pos_constr_colon=force|pos_constr_colon=lead|pos_constr_colon=trail|pos_constr_colon=join|pos_constr_colon=lead_break|pos_constr_colon=lead_force|pos_constr_colon=trail_break|pos_constr_colon=trail_force ChoicesReadable="Ignore Pos Constr Colon|Break Pos Constr Colon|Force Pos Constr Colon|Lead Pos Constr Colon|Trail Pos Constr Colon|Join Pos Constr Colon|Lead Break Pos Constr Colon|Lead Force Pos Constr Colon|Trail Break Pos Constr Colon|Trail Force Pos Constr Colon" ValueDefault=ignore [Pos Shift] Category=5 Description="The position of shift operators in wrapped expressions." Enabled=false EditorType=multiple Choices=pos_shift=ignore|pos_shift=break|pos_shift=force|pos_shift=lead|pos_shift=trail|pos_shift=join|pos_shift=lead_break|pos_shift=lead_force|pos_shift=trail_break|pos_shift=trail_force ChoicesReadable="Ignore Pos Shift|Break Pos Shift|Force Pos Shift|Lead Pos Shift|Trail Pos Shift|Join Pos Shift|Lead Break Pos Shift|Lead Force Pos Shift|Trail Break Pos Shift|Trail Force Pos Shift" ValueDefault=ignore [Code Width] Category=6 Description="Try to limit code width to N columns." Enabled=false EditorType=numeric CallName="code_width=" MinVal=0 MaxVal=10000 ValueDefault=0 [Ls For Split Full] Category=6 Description="Whether to fully split long 'for' statements at semi-colons." Enabled=false EditorType=boolean TrueFalse=ls_for_split_full=true|ls_for_split_full=false ValueDefault=false [Ls Func Split Full] Category=6 Description="Whether to fully split long function prototypes/calls at commas.
The option ls_code_width has priority over the option ls_func_split_full." Enabled=false EditorType=boolean TrueFalse=ls_func_split_full=true|ls_func_split_full=false ValueDefault=false [Ls Code Width] Category=6 Description="Whether to split lines as close to code_width as possible and ignore some
groupings.
The option ls_code_width has priority over the option ls_func_split_full." Enabled=false EditorType=boolean TrueFalse=ls_code_width=true|ls_code_width=false ValueDefault=false [Align Keep Tabs] Category=7 Description="Whether to keep non-indenting tabs." Enabled=false EditorType=boolean TrueFalse=align_keep_tabs=true|align_keep_tabs=false ValueDefault=false [Align With Tabs] Category=7 Description="Whether to use tabs for aligning." Enabled=false EditorType=boolean TrueFalse=align_with_tabs=true|align_with_tabs=false ValueDefault=false [Align On Tabstop] Category=7 Description="Whether to bump out to the next tab when aligning." Enabled=false EditorType=boolean TrueFalse=align_on_tabstop=true|align_on_tabstop=false ValueDefault=false [Align Number Right] Category=7 Description="Whether to right-align numbers." Enabled=false EditorType=boolean TrueFalse=align_number_right=true|align_number_right=false ValueDefault=false [Align Keep Extra Space] Category=7 Description="Whether to keep whitespace not required for alignment." Enabled=false EditorType=boolean TrueFalse=align_keep_extra_space=true|align_keep_extra_space=false ValueDefault=false [Align Func Params] Category=7 Description="Whether to align variable definitions in prototypes and functions." Enabled=false EditorType=boolean TrueFalse=align_func_params=true|align_func_params=false ValueDefault=false [Align Func Params Span] Category=7 Description="The span for aligning parameter definitions in function on parameter name.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_func_params_span=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Func Params Thresh] Category=7 Description="The threshold for aligning function parameter definitions.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_func_params_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Func Params Gap] Category=7 Description="The gap for aligning function parameter definitions." Enabled=false EditorType=numeric CallName="align_func_params_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Constr Value Span] Category=7 Description="The span for aligning constructor value.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_constr_value_span=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Constr Value Thresh] Category=7 Description="The threshold for aligning constructor value.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_constr_value_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Constr Value Gap] Category=7 Description="The gap for aligning constructor value." Enabled=false EditorType=numeric CallName="align_constr_value_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Same Func Call Params] Category=7 Description="Whether to align parameters in single-line functions that have the same
name. The function names must already be aligned with each other." Enabled=false EditorType=boolean TrueFalse=align_same_func_call_params=true|align_same_func_call_params=false ValueDefault=false [Align Same Func Call Params Span] Category=7 Description="The span for aligning function-call parameters for single line functions.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_same_func_call_params_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Same Func Call Params Thresh] Category=7 Description="The threshold for aligning function-call parameters for single line
functions.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_same_func_call_params_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Var Def Span] Category=7 Description="The span for aligning variable definitions.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_var_def_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Var Def Star Style] Category=7 Description="How to consider (or treat) the '*' in the alignment of variable definitions.

0: Part of the type 'void * foo;' (default)
1: Part of the variable 'void *foo;'
2: Dangling 'void *foo;'
Dangling: the '*' will not be taken into account when aligning." Enabled=false EditorType=numeric CallName="align_var_def_star_style=" MinVal=0 MaxVal=2 ValueDefault=0 [Align Var Def Amp Style] Category=7 Description="How to consider (or treat) the '&' in the alignment of variable definitions.

0: Part of the type 'long & foo;' (default)
1: Part of the variable 'long &foo;'
2: Dangling 'long &foo;'
Dangling: the '&' will not be taken into account when aligning." Enabled=false EditorType=numeric CallName="align_var_def_amp_style=" MinVal=0 MaxVal=2 ValueDefault=0 [Align Var Def Thresh] Category=7 Description="The threshold for aligning variable definitions.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_var_def_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Var Def Gap] Category=7 Description="The gap for aligning variable definitions." Enabled=false EditorType=numeric CallName="align_var_def_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Var Def Colon] Category=7 Description="Whether to align the colon in struct bit fields." Enabled=false EditorType=boolean TrueFalse=align_var_def_colon=true|align_var_def_colon=false ValueDefault=false [Align Var Def Colon Gap] Category=7 Description="The gap for aligning the colon in struct bit fields." Enabled=false EditorType=numeric CallName="align_var_def_colon_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Var Def Attribute] Category=7 Description="Whether to align any attribute after the variable name." Enabled=false EditorType=boolean TrueFalse=align_var_def_attribute=true|align_var_def_attribute=false ValueDefault=false [Align Var Def Inline] Category=7 Description="Whether to align inline struct/enum/union variable definitions." Enabled=false EditorType=boolean TrueFalse=align_var_def_inline=true|align_var_def_inline=false ValueDefault=false [Align Assign Span] Category=7 Description="The span for aligning on '=' in assignments.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_assign_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Assign Func Proto Span] Category=7 Description="The span for aligning on '=' in function prototype modifier.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_assign_func_proto_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Assign Thresh] Category=7 Description="The threshold for aligning on '=' in assignments.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_assign_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Assign On Multi Var Defs] Category=7 Description="Whether to align on the left most assignment when multiple
definitions are found on the same line.
Depends on 'align_assign_span' and 'align_assign_thresh' settings." Enabled=false EditorType=boolean TrueFalse=align_assign_on_multi_var_defs=true|align_assign_on_multi_var_defs=false ValueDefault=false [Align Braced Init List Span] Category=7 Description="The span for aligning on '{' in braced init list.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_braced_init_list_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Braced Init List Thresh] Category=7 Description="The threshold for aligning on '{' in braced init list.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_braced_init_list_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Assign Decl Func] Category=7 Description="How to apply align_assign_span to function declaration "assignments", i.e.
'virtual void foo() = 0' or '~foo() = {default|delete}'.

0: Align with other assignments (default)
1: Align with each other, ignoring regular assignments
2: Don't align" Enabled=false EditorType=numeric CallName="align_assign_decl_func=" MinVal=0 MaxVal=2 ValueDefault=0 [Align Enum Equ Span] Category=7 Description="The span for aligning on '=' in enums.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_enum_equ_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Enum Equ Thresh] Category=7 Description="The threshold for aligning on '=' in enums.
Use a negative number for absolute thresholds.

0: no limit (default)." Enabled=false EditorType=numeric CallName="align_enum_equ_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Var Class Span] Category=7 Description="The span for aligning class member definitions.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_var_class_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Var Class Thresh] Category=7 Description="The threshold for aligning class member definitions.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_var_class_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Var Class Gap] Category=7 Description="The gap for aligning class member definitions." Enabled=false EditorType=numeric CallName="align_var_class_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Var Struct Span] Category=7 Description="The span for aligning struct/union member definitions.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_var_struct_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Var Struct Thresh] Category=7 Description="The threshold for aligning struct/union member definitions.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_var_struct_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Var Struct Gap] Category=7 Description="The gap for aligning struct/union member definitions." Enabled=false EditorType=numeric CallName="align_var_struct_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Struct Init Span] Category=7 Description="The span for aligning struct initializer values.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_struct_init_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Typedef Span] Category=7 Description="The span for aligning single-line typedefs.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_typedef_span=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Typedef Gap] Category=7 Description="The minimum space between the type and the synonym of a typedef." Enabled=false EditorType=numeric CallName="align_typedef_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Typedef Func] Category=7 Description="How to align typedef'd functions with other typedefs.

0: Don't mix them at all (default)
1: Align the open parenthesis with the types
2: Align the function type name with the other type names" Enabled=false EditorType=numeric CallName="align_typedef_func=" MinVal=0 MaxVal=2 ValueDefault=0 [Align Typedef Star Style] Category=7 Description="How to consider (or treat) the '*' in the alignment of typedefs.

0: Part of the typedef type, 'typedef int * pint;' (default)
1: Part of type name: 'typedef int *pint;'
2: Dangling: 'typedef int *pint;'
Dangling: the '*' will not be taken into account when aligning." Enabled=false EditorType=numeric CallName="align_typedef_star_style=" MinVal=0 MaxVal=2 ValueDefault=0 [Align Typedef Amp Style] Category=7 Description="How to consider (or treat) the '&' in the alignment of typedefs.

0: Part of the typedef type, 'typedef int & intref;' (default)
1: Part of type name: 'typedef int &intref;'
2: Dangling: 'typedef int &intref;'
Dangling: the '&' will not be taken into account when aligning." Enabled=false EditorType=numeric CallName="align_typedef_amp_style=" MinVal=0 MaxVal=2 ValueDefault=0 [Align Right Cmt Span] Category=7 Description="The span for aligning comments that end lines.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_right_cmt_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Right Cmt Gap] Category=7 Description="Minimum number of columns between preceding text and a trailing comment in
order for the comment to qualify for being aligned. Must be non-zero to have
an effect." Enabled=false EditorType=numeric CallName="align_right_cmt_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Right Cmt Mix] Category=7 Description="If aligning comments, whether to mix with comments after '}' and #endif with
less than three spaces before the comment." Enabled=false EditorType=boolean TrueFalse=align_right_cmt_mix=true|align_right_cmt_mix=false ValueDefault=false [Align Right Cmt Same Level] Category=7 Description="Whether to only align trailing comments that are at the same brace level." Enabled=false EditorType=boolean TrueFalse=align_right_cmt_same_level=true|align_right_cmt_same_level=false ValueDefault=false [Align Right Cmt At Col] Category=7 Description="Minimum column at which to align trailing comments. Comments which are
aligned beyond this column, but which can be aligned in a lesser column,
may be "pulled in".

0: Ignore (default)." Enabled=false EditorType=numeric CallName="align_right_cmt_at_col=" MinVal=0 MaxVal=200 ValueDefault=0 [Align Func Proto Span] Category=7 Description="The span for aligning function prototypes.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_func_proto_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Func Proto Star Style] Category=7 Description="How to consider (or treat) the '*' in the alignment of function prototypes.

0: Part of the type 'void * foo();' (default)
1: Part of the function 'void *foo();'
2: Dangling 'void *foo();'
Dangling: the '*' will not be taken into account when aligning." Enabled=false EditorType=numeric CallName="align_func_proto_star_style=" MinVal=0 MaxVal=2 ValueDefault=0 [Align Func Proto Amp Style] Category=7 Description="How to consider (or treat) the '&' in the alignment of function prototypes.

0: Part of the type 'long & foo();' (default)
1: Part of the function 'long &foo();'
2: Dangling 'long &foo();'
Dangling: the '&' will not be taken into account when aligning." Enabled=false EditorType=numeric CallName="align_func_proto_amp_style=" MinVal=0 MaxVal=2 ValueDefault=0 [Align Func Proto Thresh] Category=7 Description="The threshold for aligning function prototypes.
Use a negative number for absolute thresholds.

0: No limit (default)." Enabled=false EditorType=numeric CallName="align_func_proto_thresh=" MinVal=-1000 MaxVal=5000 ValueDefault=0 [Align Func Proto Gap] Category=7 Description="Minimum gap between the return type and the function name." Enabled=false EditorType=numeric CallName="align_func_proto_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align On Operator] Category=7 Description="Whether to align function prototypes on the 'operator' keyword instead of
what follows." Enabled=false EditorType=boolean TrueFalse=align_on_operator=true|align_on_operator=false ValueDefault=false [Align Mix Var Proto] Category=7 Description="Whether to mix aligning prototype and variable declarations. If true,
align_var_def_XXX options are used instead of align_func_proto_XXX options." Enabled=false EditorType=boolean TrueFalse=align_mix_var_proto=true|align_mix_var_proto=false ValueDefault=false [Align Single Line Func] Category=7 Description="Whether to align single-line functions with function prototypes.
Uses align_func_proto_span." Enabled=false EditorType=boolean TrueFalse=align_single_line_func=true|align_single_line_func=false ValueDefault=false [Align Single Line Brace] Category=7 Description="Whether to align the open brace of single-line functions.
Requires align_single_line_func=true. Uses align_func_proto_span." Enabled=false EditorType=boolean TrueFalse=align_single_line_brace=true|align_single_line_brace=false ValueDefault=false [Align Single Line Brace Gap] Category=7 Description="Gap for align_single_line_brace." Enabled=false EditorType=numeric CallName="align_single_line_brace_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Oc Msg Spec Span] Category=7 Description="(OC) The span for aligning Objective-C message specifications.

0: Don't align (default)." Enabled=false EditorType=numeric CallName="align_oc_msg_spec_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Nl Cont] Category=7 Description="Whether to align macros wrapped with a backslash and a newline. This will
not work right if the macro contains a multi-line comment." Enabled=false EditorType=boolean TrueFalse=align_nl_cont=true|align_nl_cont=false ValueDefault=false [Align Pp Define Together] Category=7 Description="Whether to align macro functions and variables together." Enabled=false EditorType=boolean TrueFalse=align_pp_define_together=true|align_pp_define_together=false ValueDefault=false [Align Pp Define Span] Category=7 Description="The span for aligning on '#define' bodies.

=0: Don't align (default)
>0: Number of lines (including comments) between blocks" Enabled=false EditorType=numeric CallName="align_pp_define_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Pp Define Gap] Category=7 Description="The minimum space between label and value of a preprocessor define." Enabled=false EditorType=numeric CallName="align_pp_define_gap=" MinVal=0 MaxVal=16 ValueDefault=0 [Align Left Shift] Category=7 Description="Whether to align lines that start with '<<' with previous '<<'.

Default: true" Enabled=false EditorType=boolean TrueFalse=align_left_shift=true|align_left_shift=false ValueDefault=true [Align Eigen Comma Init] Category=7 Description="Whether to align comma-separated statements following '<<' (as used to
initialize Eigen matrices)." Enabled=false EditorType=boolean TrueFalse=align_eigen_comma_init=true|align_eigen_comma_init=false ValueDefault=false [Align Asm Colon] Category=7 Description="Whether to align text after 'asm volatile ()' colons." Enabled=false EditorType=boolean TrueFalse=align_asm_colon=true|align_asm_colon=false ValueDefault=false [Align Oc Msg Colon Span] Category=7 Description="(OC) Span for aligning parameters in an Objective-C message call
on the ':'.

0: Don't align." Enabled=false EditorType=numeric CallName="align_oc_msg_colon_span=" MinVal=0 MaxVal=5000 ValueDefault=0 [Align Oc Msg Colon First] Category=7 Description="(OC) Whether to always align with the first parameter, even if it is too
short." Enabled=false EditorType=boolean TrueFalse=align_oc_msg_colon_first=true|align_oc_msg_colon_first=false ValueDefault=false [Align Oc Decl Colon] Category=7 Description="(OC) Whether to align parameters in an Objective-C '+' or '-' declaration
on the ':'." Enabled=false EditorType=boolean TrueFalse=align_oc_decl_colon=true|align_oc_decl_colon=false ValueDefault=false [Align Oc Msg Colon Xcode Like] Category=7 Description="(OC) Whether to not align parameters in an Objectve-C message call if first
colon is not on next line of the message call (the same way Xcode does
alignment)" Enabled=false EditorType=boolean TrueFalse=align_oc_msg_colon_xcode_like=true|align_oc_msg_colon_xcode_like=false ValueDefault=false [Cmt Width] Category=8 Description="Try to wrap comments at N columns." Enabled=false EditorType=numeric CallName="cmt_width=" MinVal=0 MaxVal=256 ValueDefault=0 [Cmt Reflow Mode] Category=8 Description="How to reflow comments.

0: No reflowing (apart from the line wrapping due to cmt_width) (default)
1: No touching at all
2: Full reflow (enable cmt_indent_multi for indent with line wrapping due to cmt_width)" Enabled=false EditorType=numeric CallName="cmt_reflow_mode=" MinVal=0 MaxVal=2 ValueDefault=0 [Cmt Reflow Fold Regex File] Category=8 Description="Path to a file that contains regular expressions describing patterns for
which the end of one line and the beginning of the next will be folded into
the same sentence or paragraph during full comment reflow. The regular
expressions are described using ECMAScript syntax. The syntax for this
specification is as follows, where "..." indicates the custom regular
expression and "n" indicates the nth end_of_prev_line_regex and
beg_of_next_line_regex regular expression pair:

end_of_prev_line_regex[1] = "...$"
beg_of_next_line_regex[1] = "^..."
end_of_prev_line_regex[2] = "...$"
beg_of_next_line_regex[2] = "^..."
.
.
.
end_of_prev_line_regex[n] = "...$"
beg_of_next_line_regex[n] = "^..."

Note that use of this option overrides the default reflow fold regular
expressions, which are internally defined as follows:

end_of_prev_line_regex[1] = "[\w,\]\)]$"
beg_of_next_line_regex[1] = "^[\w,\[\(]"
end_of_prev_line_regex[2] = "\.$"
beg_of_next_line_regex[2] = "^[A-Z]"" Enabled=false CallName=cmt_reflow_fold_regex_file= EditorType=string ValueDefault= [Cmt Reflow Indent To Paragraph Start] Category=8 Description="Whether to indent wrapped lines to the start of the encompassing paragraph
during full comment reflow (cmt_reflow_mode = 2). Overrides the value
specified by cmt_sp_after_star_cont.

Note that cmt_align_doxygen_javadoc_tags overrides this option for
paragraphs associated with javadoc tags" Enabled=false EditorType=boolean TrueFalse=cmt_reflow_indent_to_paragraph_start=true|cmt_reflow_indent_to_paragraph_start=false ValueDefault=false [Cmt Convert Tab To Spaces] Category=8 Description="Whether to convert all tabs to spaces in comments. If false, tabs in
comments are left alone, unless used for indenting." Enabled=false EditorType=boolean TrueFalse=cmt_convert_tab_to_spaces=true|cmt_convert_tab_to_spaces=false ValueDefault=false [Cmt Indent Multi] Category=8 Description="Whether to apply changes to multi-line comments, including cmt_width,
keyword substitution and leading chars.

Default: true" Enabled=false EditorType=boolean TrueFalse=cmt_indent_multi=true|cmt_indent_multi=false ValueDefault=true [Cmt Align Doxygen Javadoc Tags] Category=8 Description="Whether to align doxygen javadoc-style tags ('@param', '@return', etc.)
and corresponding fields such that groups of consecutive block tags,
parameter names, and descriptions align with one another. Overrides that
which is specified by the cmt_sp_after_star_cont. If cmt_width > 0, it may
be necessary to enable cmt_indent_multi and set cmt_reflow_mode = 2
in order to achieve the desired alignment for line-wrapping." Enabled=false EditorType=boolean TrueFalse=cmt_align_doxygen_javadoc_tags=true|cmt_align_doxygen_javadoc_tags=false ValueDefault=false [Cmt Sp Before Doxygen Javadoc Tags] Category=8 Description="The number of spaces to insert after the star and before doxygen
javadoc-style tags (@param, @return, etc). Requires enabling
cmt_align_doxygen_javadoc_tags. Overrides that which is specified by the
cmt_sp_after_star_cont.

Default: 1" Enabled=false EditorType=numeric CallName="cmt_sp_before_doxygen_javadoc_tags=" MinVal=0 MaxVal=16 ValueDefault=1 [Cmt Trailing Single Line C To Cpp] Category=8 Description="Whether to change trailing, single-line c-comments into cpp-comments." Enabled=false EditorType=boolean TrueFalse=cmt_trailing_single_line_c_to_cpp=true|cmt_trailing_single_line_c_to_cpp=false ValueDefault=false [Cmt C Group] Category=8 Description="Whether to group c-comments that look like they are in a block." Enabled=false EditorType=boolean TrueFalse=cmt_c_group=true|cmt_c_group=false ValueDefault=false [Cmt C Nl Start] Category=8 Description="Whether to put an empty '/*' on the first line of the combined c-comment." Enabled=false EditorType=boolean TrueFalse=cmt_c_nl_start=true|cmt_c_nl_start=false ValueDefault=false [Cmt C Nl End] Category=8 Description="Whether to add a newline before the closing '*/' of the combined c-comment." Enabled=false EditorType=boolean TrueFalse=cmt_c_nl_end=true|cmt_c_nl_end=false ValueDefault=false [Cmt Cpp To C] Category=8 Description="Whether to change cpp-comments into c-comments." Enabled=false EditorType=boolean TrueFalse=cmt_cpp_to_c=true|cmt_cpp_to_c=false ValueDefault=false [Cmt Cpp Group] Category=8 Description="Whether to group cpp-comments that look like they are in a block. Only
meaningful if cmt_cpp_to_c=true." Enabled=false EditorType=boolean TrueFalse=cmt_cpp_group=true|cmt_cpp_group=false ValueDefault=false [Cmt Cpp Nl Start] Category=8 Description="Whether to put an empty '/*' on the first line of the combined cpp-comment
when converting to a c-comment.

Requires cmt_cpp_to_c=true and cmt_cpp_group=true." Enabled=false EditorType=boolean TrueFalse=cmt_cpp_nl_start=true|cmt_cpp_nl_start=false ValueDefault=false [Cmt Cpp Nl End] Category=8 Description="Whether to add a newline before the closing '*/' of the combined cpp-comment
when converting to a c-comment.

Requires cmt_cpp_to_c=true and cmt_cpp_group=true." Enabled=false EditorType=boolean TrueFalse=cmt_cpp_nl_end=true|cmt_cpp_nl_end=false ValueDefault=false [Cmt Star Cont] Category=8 Description="Whether to put a star on subsequent comment lines." Enabled=false EditorType=boolean TrueFalse=cmt_star_cont=true|cmt_star_cont=false ValueDefault=false [Cmt Sp Before Star Cont] Category=8 Description="The number of spaces to insert at the start of subsequent comment lines." Enabled=false EditorType=numeric CallName="cmt_sp_before_star_cont=" MinVal=0 MaxVal=16 ValueDefault=0 [Cmt Sp After Star Cont] Category=8 Description="The number of spaces to insert after the star on subsequent comment lines." Enabled=false EditorType=numeric CallName="cmt_sp_after_star_cont=" MinVal=0 MaxVal=16 ValueDefault=0 [Cmt Multi Check Last] Category=8 Description="For multi-line comments with a '*' lead, remove leading spaces if the first
and last lines of the comment are the same length.

Default: true" Enabled=false EditorType=boolean TrueFalse=cmt_multi_check_last=true|cmt_multi_check_last=false ValueDefault=true [Cmt Multi First Len Minimum] Category=8 Description="For multi-line comments with a '*' lead, remove leading spaces if the first
and last lines of the comment are the same length AND if the length is
bigger as the first_len minimum.

Default: 4" Enabled=false EditorType=numeric CallName="cmt_multi_first_len_minimum=" MinVal=1 MaxVal=20 ValueDefault=4 [Cmt Insert File Header] Category=8 Description="Path to a file that contains text to insert at the beginning of a file if
the file doesn't start with a C/C++ comment. If the inserted text contains
'$(filename)', that will be replaced with the current file's name." Enabled=false CallName=cmt_insert_file_header= EditorType=string ValueDefault= [Cmt Insert File Footer] Category=8 Description="Path to a file that contains text to insert at the end of a file if the
file doesn't end with a C/C++ comment. If the inserted text contains
'$(filename)', that will be replaced with the current file's name." Enabled=false CallName=cmt_insert_file_footer= EditorType=string ValueDefault= [Cmt Insert Func Header] Category=8 Description="Path to a file that contains text to insert before a function definition if
the function isn't preceded by a C/C++ comment. If the inserted text
contains '$(function)', '$(javaparam)' or '$(fclass)', these will be
replaced with, respectively, the name of the function, the javadoc '@param'
and '@return' stuff, or the name of the class to which the member function
belongs." Enabled=false CallName=cmt_insert_func_header= EditorType=string ValueDefault= [Cmt Insert Class Header] Category=8 Description="Path to a file that contains text to insert before a class if the class
isn't preceded by a C/C++ comment. If the inserted text contains '$(class)',
that will be replaced with the class name." Enabled=false CallName=cmt_insert_class_header= EditorType=string ValueDefault= [Cmt Insert Oc Msg Header] Category=8 Description="Path to a file that contains text to insert before an Objective-C message
specification, if the method isn't preceded by a C/C++ comment. If the
inserted text contains '$(message)' or '$(javaparam)', these will be
replaced with, respectively, the name of the function, or the javadoc
'@param' and '@return' stuff." Enabled=false CallName=cmt_insert_oc_msg_header= EditorType=string ValueDefault= [Cmt Insert Before Preproc] Category=8 Description="Whether a comment should be inserted if a preprocessor is encountered when
stepping backwards from a function name.

Applies to cmt_insert_oc_msg_header, cmt_insert_func_header and
cmt_insert_class_header." Enabled=false EditorType=boolean TrueFalse=cmt_insert_before_preproc=true|cmt_insert_before_preproc=false ValueDefault=false [Cmt Insert Before Inlines] Category=8 Description="Whether a comment should be inserted if a function is declared inline to a
class definition.

Applies to cmt_insert_func_header.

Default: true" Enabled=false EditorType=boolean TrueFalse=cmt_insert_before_inlines=true|cmt_insert_before_inlines=false ValueDefault=true [Cmt Insert Before Ctor Dtor] Category=8 Description="Whether a comment should be inserted if the function is a class constructor
or destructor.

Applies to cmt_insert_func_header." Enabled=false EditorType=boolean TrueFalse=cmt_insert_before_ctor_dtor=true|cmt_insert_before_ctor_dtor=false ValueDefault=false [Mod Full Brace Do] Category=9 Description="Add or remove braces on a single-line 'do' statement." Enabled=false EditorType=multiple Choices=mod_full_brace_do=ignore|mod_full_brace_do=add|mod_full_brace_do=remove|mod_full_brace_do=force|mod_full_brace_do=not_defined ChoicesReadable="Ignore Mod Full Brace Do|Add Mod Full Brace Do|Remove Mod Full Brace Do|Force Mod Full Brace Do" ValueDefault=ignore [Mod Full Brace For] Category=9 Description="Add or remove braces on a single-line 'for' statement." Enabled=false EditorType=multiple Choices=mod_full_brace_for=ignore|mod_full_brace_for=add|mod_full_brace_for=remove|mod_full_brace_for=force|mod_full_brace_for=not_defined ChoicesReadable="Ignore Mod Full Brace For|Add Mod Full Brace For|Remove Mod Full Brace For|Force Mod Full Brace For" ValueDefault=ignore [Mod Full Brace Function] Category=9 Description="(Pawn) Add or remove braces on a single-line function definition." Enabled=false EditorType=multiple Choices=mod_full_brace_function=ignore|mod_full_brace_function=add|mod_full_brace_function=remove|mod_full_brace_function=force|mod_full_brace_function=not_defined ChoicesReadable="Ignore Mod Full Brace Function|Add Mod Full Brace Function|Remove Mod Full Brace Function|Force Mod Full Brace Function" ValueDefault=ignore [Mod Full Brace If] Category=9 Description="Add or remove braces on a single-line 'if' statement. Braces will not be
removed if the braced statement contains an 'else'." Enabled=false EditorType=multiple Choices=mod_full_brace_if=ignore|mod_full_brace_if=add|mod_full_brace_if=remove|mod_full_brace_if=force|mod_full_brace_if=not_defined ChoicesReadable="Ignore Mod Full Brace If|Add Mod Full Brace If|Remove Mod Full Brace If|Force Mod Full Brace If" ValueDefault=ignore [Mod Full Brace If Chain] Category=9 Description="Whether to enforce that all blocks of an 'if'/'else if'/'else' chain either
have, or do not have, braces. Overrides mod_full_brace_if.

0: Don't override mod_full_brace_if
1: Add braces to all blocks if any block needs braces and remove braces if
they can be removed from all blocks
2: Add braces to all blocks if any block already has braces, regardless of
whether it needs them
3: Add braces to all blocks if any block needs braces and remove braces if
they can be removed from all blocks, except if all blocks have braces
despite none needing them" Enabled=false EditorType=numeric CallName="mod_full_brace_if_chain=" MinVal=0 MaxVal=3 ValueDefault=0 [Mod Full Brace If Chain Only] Category=9 Description="Whether to add braces to all blocks of an 'if'/'else if'/'else' chain.
If true, mod_full_brace_if_chain will only remove braces from an 'if' that
does not have an 'else if' or 'else'." Enabled=false EditorType=boolean TrueFalse=mod_full_brace_if_chain_only=true|mod_full_brace_if_chain_only=false ValueDefault=false [Mod Full Brace While] Category=9 Description="Add or remove braces on single-line 'while' statement." Enabled=false EditorType=multiple Choices=mod_full_brace_while=ignore|mod_full_brace_while=add|mod_full_brace_while=remove|mod_full_brace_while=force|mod_full_brace_while=not_defined ChoicesReadable="Ignore Mod Full Brace While|Add Mod Full Brace While|Remove Mod Full Brace While|Force Mod Full Brace While" ValueDefault=ignore [Mod Full Brace Using] Category=9 Description="Add or remove braces on single-line 'using ()' statement." Enabled=false EditorType=multiple Choices=mod_full_brace_using=ignore|mod_full_brace_using=add|mod_full_brace_using=remove|mod_full_brace_using=force|mod_full_brace_using=not_defined ChoicesReadable="Ignore Mod Full Brace Using|Add Mod Full Brace Using|Remove Mod Full Brace Using|Force Mod Full Brace Using" ValueDefault=ignore [Mod Full Brace Nl] Category=9 Description="Don't remove braces around statements that span N newlines" Enabled=false EditorType=numeric CallName="mod_full_brace_nl=" MinVal=0 MaxVal=5000 ValueDefault=0 [Mod Full Brace Nl Block Rem Mlcond] Category=9 Description="Whether to prevent removal of braces from 'if'/'for'/'while'/etc. blocks
which span multiple lines.

Affects:
mod_full_brace_for
mod_full_brace_if
mod_full_brace_if_chain
mod_full_brace_if_chain_only
mod_full_brace_while
mod_full_brace_using

Does not affect:
mod_full_brace_do
mod_full_brace_function" Enabled=false EditorType=boolean TrueFalse=mod_full_brace_nl_block_rem_mlcond=true|mod_full_brace_nl_block_rem_mlcond=false ValueDefault=false [Mod Paren On Return] Category=9 Description="Add or remove unnecessary parentheses on 'return' statement." Enabled=false EditorType=multiple Choices=mod_paren_on_return=ignore|mod_paren_on_return=add|mod_paren_on_return=remove|mod_paren_on_return=force|mod_paren_on_return=not_defined ChoicesReadable="Ignore Mod Paren On Return|Add Mod Paren On Return|Remove Mod Paren On Return|Force Mod Paren On Return" ValueDefault=ignore [Mod Paren On Throw] Category=9 Description="Add or remove unnecessary parentheses on 'throw' statement." Enabled=false EditorType=multiple Choices=mod_paren_on_throw=ignore|mod_paren_on_throw=add|mod_paren_on_throw=remove|mod_paren_on_throw=force|mod_paren_on_throw=not_defined ChoicesReadable="Ignore Mod Paren On Throw|Add Mod Paren On Throw|Remove Mod Paren On Throw|Force Mod Paren On Throw" ValueDefault=ignore [Mod Pawn Semicolon] Category=9 Description="(Pawn) Whether to change optional semicolons to real semicolons." Enabled=false EditorType=boolean TrueFalse=mod_pawn_semicolon=true|mod_pawn_semicolon=false ValueDefault=false [Mod Full Paren If Bool] Category=9 Description="Whether to fully parenthesize Boolean expressions in 'while' and 'if'
statement, as in 'if (a && b > c)' => 'if (a && (b > c))'." Enabled=false EditorType=boolean TrueFalse=mod_full_paren_if_bool=true|mod_full_paren_if_bool=false ValueDefault=false [Mod Full Paren Assign Bool] Category=9 Description="Whether to fully parenthesize Boolean expressions after '='
statement, as in 'x = a && b > c;' => 'x = (a && (b > c));'." Enabled=false EditorType=boolean TrueFalse=mod_full_paren_assign_bool=true|mod_full_paren_assign_bool=false ValueDefault=false [Mod Full Paren Return Bool] Category=9 Description="Whether to fully parenthesize Boolean expressions after '='
statement, as in 'return a && b > c;' => 'return (a && (b > c));'." Enabled=false EditorType=boolean TrueFalse=mod_full_paren_return_bool=true|mod_full_paren_return_bool=false ValueDefault=false [Mod Remove Extra Semicolon] Category=9 Description="Whether to remove superfluous semicolons." Enabled=false EditorType=boolean TrueFalse=mod_remove_extra_semicolon=true|mod_remove_extra_semicolon=false ValueDefault=false [Mod Remove Duplicate Include] Category=9 Description="Whether to remove duplicate include." Enabled=false EditorType=boolean TrueFalse=mod_remove_duplicate_include=true|mod_remove_duplicate_include=false ValueDefault=false [Mod Add Long Function Closebrace Comment] Category=9 Description="If a function body exceeds the specified number of newlines and doesn't have
a comment after the close brace, a comment will be added." Enabled=false EditorType=numeric CallName="mod_add_long_function_closebrace_comment=" MinVal=0 MaxVal=255 ValueDefault=0 [Mod Add Long Namespace Closebrace Comment] Category=9 Description="If a namespace body exceeds the specified number of newlines and doesn't
have a comment after the close brace, a comment will be added." Enabled=false EditorType=numeric CallName="mod_add_long_namespace_closebrace_comment=" MinVal=0 MaxVal=255 ValueDefault=0 [Mod Add Long Class Closebrace Comment] Category=9 Description="If a class body exceeds the specified number of newlines and doesn't have a
comment after the close brace, a comment will be added." Enabled=false EditorType=numeric CallName="mod_add_long_class_closebrace_comment=" MinVal=0 MaxVal=255 ValueDefault=0 [Mod Add Long Switch Closebrace Comment] Category=9 Description="If a switch body exceeds the specified number of newlines and doesn't have a
comment after the close brace, a comment will be added." Enabled=false EditorType=numeric CallName="mod_add_long_switch_closebrace_comment=" MinVal=0 MaxVal=255 ValueDefault=0 [Mod Add Long Ifdef Endif Comment] Category=9 Description="If an #ifdef body exceeds the specified number of newlines and doesn't have
a comment after the #endif, a comment will be added." Enabled=false EditorType=numeric CallName="mod_add_long_ifdef_endif_comment=" MinVal=0 MaxVal=255 ValueDefault=0 [Mod Add Long Ifdef Else Comment] Category=9 Description="If an #ifdef or #else body exceeds the specified number of newlines and
doesn't have a comment after the #else, a comment will be added." Enabled=false EditorType=numeric CallName="mod_add_long_ifdef_else_comment=" MinVal=0 MaxVal=255 ValueDefault=0 [Mod Sort Case Sensitive] Category=9 Description="Whether to take care of the case by the mod_sort_xx options." Enabled=false EditorType=boolean TrueFalse=mod_sort_case_sensitive=true|mod_sort_case_sensitive=false ValueDefault=false [Mod Sort Import] Category=9 Description="Whether to sort consecutive single-line 'import' statements." Enabled=false EditorType=boolean TrueFalse=mod_sort_import=true|mod_sort_import=false ValueDefault=false [Mod Sort Using] Category=9 Description="(C#) Whether to sort consecutive single-line 'using' statements." Enabled=false EditorType=boolean TrueFalse=mod_sort_using=true|mod_sort_using=false ValueDefault=false [Mod Sort Include] Category=9 Description="Whether to sort consecutive single-line '#include' statements (C/C++) and
'#import' statements (Objective-C). Be aware that this has the potential to
break your code if your includes/imports have ordering dependencies." Enabled=false EditorType=boolean TrueFalse=mod_sort_include=true|mod_sort_include=false ValueDefault=false [Mod Sort Incl Import Prioritize Filename] Category=9 Description="Whether to prioritize '#include' and '#import' statements that contain
filename without extension when sorting is enabled." Enabled=false EditorType=boolean TrueFalse=mod_sort_incl_import_prioritize_filename=true|mod_sort_incl_import_prioritize_filename=false ValueDefault=false [Mod Sort Incl Import Prioritize Extensionless] Category=9 Description="Whether to prioritize '#include' and '#import' statements that does not
contain extensions when sorting is enabled." Enabled=false EditorType=boolean TrueFalse=mod_sort_incl_import_prioritize_extensionless=true|mod_sort_incl_import_prioritize_extensionless=false ValueDefault=false [Mod Sort Incl Import Prioritize Angle Over Quotes] Category=9 Description="Whether to prioritize '#include' and '#import' statements that contain
angle over quotes when sorting is enabled." Enabled=false EditorType=boolean TrueFalse=mod_sort_incl_import_prioritize_angle_over_quotes=true|mod_sort_incl_import_prioritize_angle_over_quotes=false ValueDefault=false [Mod Sort Incl Import Ignore Extension] Category=9 Description="Whether to ignore file extension in '#include' and '#import' statements
for sorting comparison." Enabled=false EditorType=boolean TrueFalse=mod_sort_incl_import_ignore_extension=true|mod_sort_incl_import_ignore_extension=false ValueDefault=false [Mod Sort Incl Import Grouping Enabled] Category=9 Description="Whether to group '#include' and '#import' statements when sorting is enabled." Enabled=false EditorType=boolean TrueFalse=mod_sort_incl_import_grouping_enabled=true|mod_sort_incl_import_grouping_enabled=false ValueDefault=false [Mod Move Case Break] Category=9 Description="Whether to move a 'break' that appears after a fully braced 'case' before
the close brace, as in 'case X: { ... } break;' => 'case X: { ... break; }'." Enabled=false EditorType=boolean TrueFalse=mod_move_case_break=true|mod_move_case_break=false ValueDefault=false [Mod Move Case Return] Category=9 Description="Whether to move a 'return' that appears after a fully braced 'case' before
the close brace, as in 'case X: { ... } return;' => 'case X: { ... return; }'." Enabled=false EditorType=boolean TrueFalse=mod_move_case_return=true|mod_move_case_return=false ValueDefault=false [Mod Case Brace] Category=9 Description="Add or remove braces around a fully braced case statement. Will only remove
braces if there are no variable declarations in the block." Enabled=false EditorType=multiple Choices=mod_case_brace=ignore|mod_case_brace=add|mod_case_brace=remove|mod_case_brace=force|mod_case_brace=not_defined ChoicesReadable="Ignore Mod Case Brace|Add Mod Case Brace|Remove Mod Case Brace|Force Mod Case Brace" ValueDefault=ignore [Mod Remove Empty Return] Category=9 Description="Whether to remove a void 'return;' that appears as the last statement in a
function." Enabled=false EditorType=boolean TrueFalse=mod_remove_empty_return=true|mod_remove_empty_return=false ValueDefault=false [Mod Enum Last Comma] Category=9 Description="Add or remove the comma after the last value of an enumeration." Enabled=false EditorType=multiple Choices=mod_enum_last_comma=ignore|mod_enum_last_comma=add|mod_enum_last_comma=remove|mod_enum_last_comma=force|mod_enum_last_comma=not_defined ChoicesReadable="Ignore Mod Enum Last Comma|Add Mod Enum Last Comma|Remove Mod Enum Last Comma|Force Mod Enum Last Comma" ValueDefault=ignore [Mod Infinite Loop] Category=9 Description="Syntax to use for infinite loops.

0: Leave syntax alone (default)
1: Rewrite as `for(;;)`
2: Rewrite as `while(true)`
3: Rewrite as `do`...`while(true);`
4: Rewrite as `while(1)`
5: Rewrite as `do`...`while(1);`

Infinite loops that do not already match one of these syntaxes are ignored.
Other options that affect loop formatting will be applied after transforming
the syntax." Enabled=false EditorType=numeric CallName="mod_infinite_loop=" MinVal=0 MaxVal=5 ValueDefault=0 [Mod Int Short] Category=9 Description="Add or remove the 'int' keyword in 'int short'." Enabled=false EditorType=multiple Choices=mod_int_short=ignore|mod_int_short=add|mod_int_short=remove|mod_int_short=force|mod_int_short=not_defined ChoicesReadable="Ignore Mod Int Short|Add Mod Int Short|Remove Mod Int Short|Force Mod Int Short" ValueDefault=ignore [Mod Short Int] Category=9 Description="Add or remove the 'int' keyword in 'short int'." Enabled=false EditorType=multiple Choices=mod_short_int=ignore|mod_short_int=add|mod_short_int=remove|mod_short_int=force|mod_short_int=not_defined ChoicesReadable="Ignore Mod Short Int|Add Mod Short Int|Remove Mod Short Int|Force Mod Short Int" ValueDefault=ignore [Mod Int Long] Category=9 Description="Add or remove the 'int' keyword in 'int long'." Enabled=false EditorType=multiple Choices=mod_int_long=ignore|mod_int_long=add|mod_int_long=remove|mod_int_long=force|mod_int_long=not_defined ChoicesReadable="Ignore Mod Int Long|Add Mod Int Long|Remove Mod Int Long|Force Mod Int Long" ValueDefault=ignore [Mod Long Int] Category=9 Description="Add or remove the 'int' keyword in 'long int'." Enabled=false EditorType=multiple Choices=mod_long_int=ignore|mod_long_int=add|mod_long_int=remove|mod_long_int=force|mod_long_int=not_defined ChoicesReadable="Ignore Mod Long Int|Add Mod Long Int|Remove Mod Long Int|Force Mod Long Int" ValueDefault=ignore [Mod Int Signed] Category=9 Description="Add or remove the 'int' keyword in 'int signed'." Enabled=false EditorType=multiple Choices=mod_int_signed=ignore|mod_int_signed=add|mod_int_signed=remove|mod_int_signed=force|mod_int_signed=not_defined ChoicesReadable="Ignore Mod Int Signed|Add Mod Int Signed|Remove Mod Int Signed|Force Mod Int Signed" ValueDefault=ignore [Mod Signed Int] Category=9 Description="Add or remove the 'int' keyword in 'signed int'." Enabled=false EditorType=multiple Choices=mod_signed_int=ignore|mod_signed_int=add|mod_signed_int=remove|mod_signed_int=force|mod_signed_int=not_defined ChoicesReadable="Ignore Mod Signed Int|Add Mod Signed Int|Remove Mod Signed Int|Force Mod Signed Int" ValueDefault=ignore [Mod Int Unsigned] Category=9 Description="Add or remove the 'int' keyword in 'int unsigned'." Enabled=false EditorType=multiple Choices=mod_int_unsigned=ignore|mod_int_unsigned=add|mod_int_unsigned=remove|mod_int_unsigned=force|mod_int_unsigned=not_defined ChoicesReadable="Ignore Mod Int Unsigned|Add Mod Int Unsigned|Remove Mod Int Unsigned|Force Mod Int Unsigned" ValueDefault=ignore [Mod Unsigned Int] Category=9 Description="Add or remove the 'int' keyword in 'unsigned int'." Enabled=false EditorType=multiple Choices=mod_unsigned_int=ignore|mod_unsigned_int=add|mod_unsigned_int=remove|mod_unsigned_int=force|mod_unsigned_int=not_defined ChoicesReadable="Ignore Mod Unsigned Int|Add Mod Unsigned Int|Remove Mod Unsigned Int|Force Mod Unsigned Int" ValueDefault=ignore [Mod Int Prefer Int On Left] Category=9 Description="If there is a situation where mod_int_* and mod_*_int would result in
multiple int keywords, whether to keep the rightmost int (the default) or the
leftmost int." Enabled=false EditorType=boolean TrueFalse=mod_int_prefer_int_on_left=true|mod_int_prefer_int_on_left=false ValueDefault=false [Mod Sort Oc Properties] Category=9 Description="(OC) Whether to organize the properties. If true, properties will be
rearranged according to the mod_sort_oc_property_*_weight factors." Enabled=false EditorType=boolean TrueFalse=mod_sort_oc_properties=true|mod_sort_oc_properties=false ValueDefault=false [Mod Sort Oc Property Class Weight] Category=9 Description="(OC) Weight of a class property modifier." Enabled=false EditorType=numeric CallName="mod_sort_oc_property_class_weight=" MinVal= MaxVal= ValueDefault=0 [Mod Sort Oc Property Thread Safe Weight] Category=9 Description="(OC) Weight of 'atomic' and 'nonatomic'." Enabled=false EditorType=numeric CallName="mod_sort_oc_property_thread_safe_weight=" MinVal= MaxVal= ValueDefault=0 [Mod Sort Oc Property Readwrite Weight] Category=9 Description="(OC) Weight of 'readwrite' when organizing properties." Enabled=false EditorType=numeric CallName="mod_sort_oc_property_readwrite_weight=" MinVal= MaxVal= ValueDefault=0 [Mod Sort Oc Property Reference Weight] Category=9 Description="(OC) Weight of a reference type specifier ('retain', 'copy', 'assign',
'weak', 'strong') when organizing properties." Enabled=false EditorType=numeric CallName="mod_sort_oc_property_reference_weight=" MinVal= MaxVal= ValueDefault=0 [Mod Sort Oc Property Getter Weight] Category=9 Description="(OC) Weight of getter type ('getter=') when organizing properties." Enabled=false EditorType=numeric CallName="mod_sort_oc_property_getter_weight=" MinVal= MaxVal= ValueDefault=0 [Mod Sort Oc Property Setter Weight] Category=9 Description="(OC) Weight of setter type ('setter=') when organizing properties." Enabled=false EditorType=numeric CallName="mod_sort_oc_property_setter_weight=" MinVal= MaxVal= ValueDefault=0 [Mod Sort Oc Property Nullability Weight] Category=9 Description="(OC) Weight of nullability type ('nullable', 'nonnull', 'null_unspecified',
'null_resettable') when organizing properties." Enabled=false EditorType=numeric CallName="mod_sort_oc_property_nullability_weight=" MinVal= MaxVal= ValueDefault=0 [Pp Indent With Tabs] Category=10 Description="How to use tabs when indenting preprocessor code.

-1: Use 'indent_with_tabs' setting (default)
0: Spaces only
1: Indent with tabs to brace level, align with spaces
2: Indent and align with tabs, using spaces when not on a tabstop

Default: -1" Enabled=false EditorType=numeric CallName="pp_indent_with_tabs=" MinVal=-1 MaxVal=2 ValueDefault=-1 [Pp Indent] Category=10 Description="Add or remove indentation of preprocessor directives inside #if blocks
at brace level 0 (file-level)." Enabled=false EditorType=multiple Choices=pp_indent=ignore|pp_indent=add|pp_indent=remove|pp_indent=force|pp_indent=not_defined ChoicesReadable="Ignore Pp Indent|Add Pp Indent|Remove Pp Indent|Force Pp Indent" ValueDefault=ignore [Pp Indent At Level] Category=10 Description="Whether to indent #if/#else/#endif at the brace level. If false, these are
indented from column 1." Enabled=false EditorType=boolean TrueFalse=pp_indent_at_level=true|pp_indent_at_level=false ValueDefault=false [Pp Indent At Level0] Category=10 Description="Whether to indent #if/#else/#endif at the parenthesis level if the brace
level is 0. If false, these are indented from column 1." Enabled=false EditorType=boolean TrueFalse=pp_indent_at_level0=true|pp_indent_at_level0=false ValueDefault=false [Pp Indent Count] Category=10 Description="Specifies the number of columns to indent preprocessors per level
at brace level 0 (file-level). If pp_indent_at_level=false, also specifies
the number of columns to indent preprocessors per level
at brace level > 0 (function-level).

Default: 1" Enabled=false EditorType=numeric CallName="pp_indent_count=" MinVal=0 MaxVal=16 ValueDefault=1 [Pp Space After] Category=10 Description="Add or remove space after # based on pp level of #if blocks." Enabled=false EditorType=multiple Choices=pp_space_after=ignore|pp_space_after=add|pp_space_after=remove|pp_space_after=force|pp_space_after=not_defined ChoicesReadable="Ignore Pp Space After|Add Pp Space After|Remove Pp Space After|Force Pp Space After" ValueDefault=ignore [Pp Space Count] Category=10 Description="Sets the number of spaces per level added with pp_space_after." Enabled=false EditorType=numeric CallName="pp_space_count=" MinVal=0 MaxVal=16 ValueDefault=0 [Pp Indent Region] Category=10 Description="The indent for '#region' and '#endregion' in C# and '#pragma region' in
C/C++. Negative values decrease indent down to the first column." Enabled=false EditorType=numeric CallName="pp_indent_region=" MinVal=-16 MaxVal=16 ValueDefault=0 [Pp Region Indent Code] Category=10 Description="Whether to indent the code between #region and #endregion." Enabled=false EditorType=boolean TrueFalse=pp_region_indent_code=true|pp_region_indent_code=false ValueDefault=false [Pp Indent If] Category=10 Description="If pp_indent_at_level=true, sets the indent for #if, #else and #endif when
not at file-level. Negative values decrease indent down to the first column.

=0: Indent preprocessors using output_tab_size
>0: Column at which all preprocessors will be indented" Enabled=false EditorType=numeric CallName="pp_indent_if=" MinVal=-16 MaxVal=16 ValueDefault=0 [Pp If Indent Code] Category=10 Description="Whether to indent the code between #if, #else and #endif." Enabled=false EditorType=boolean TrueFalse=pp_if_indent_code=true|pp_if_indent_code=false ValueDefault=false [Pp Indent In Guard] Category=10 Description="Whether to indent the body of an #if that encompasses all the code in the file." Enabled=false EditorType=boolean TrueFalse=pp_indent_in_guard=true|pp_indent_in_guard=false ValueDefault=false [Pp Define At Level] Category=10 Description="Whether to indent '#define' at the brace level. If false, these are
indented from column 1." Enabled=false EditorType=boolean TrueFalse=pp_define_at_level=true|pp_define_at_level=false ValueDefault=false [Pp Include At Level] Category=10 Description="Whether to indent '#include' at the brace level." Enabled=false EditorType=boolean TrueFalse=pp_include_at_level=true|pp_include_at_level=false ValueDefault=false [Pp Ignore Define Body] Category=10 Description="Whether to ignore the '#define' body while formatting." Enabled=false EditorType=boolean TrueFalse=pp_ignore_define_body=true|pp_ignore_define_body=false ValueDefault=false [Pp Multiline Define Body Indent] Category=10 Description="An offset value that controls the indentation of the body of a multiline #define.
'body' refers to all the lines of a multiline #define except the first line.
Requires 'pp_ignore_define_body = false'.

<0: Absolute column: the body indentation starts off at the specified column
(ex. -3 ==> the body is indented starting from column 3)
>=0: Relative to the column of the '#' of '#define'
(ex. 3 ==> the body is indented starting 3 columns at the right of '#')

Default: 8" Enabled=false EditorType=numeric CallName="pp_multiline_define_body_indent=" MinVal=-32 MaxVal=32 ValueDefault=8 [Pp Indent Case] Category=10 Description="Whether to indent case statements between #if, #else, and #endif.
Only applies to the indent of the preprocessor that the case statements
directly inside of.

Default: true" Enabled=false EditorType=boolean TrueFalse=pp_indent_case=true|pp_indent_case=false ValueDefault=true [Pp Indent Func Def] Category=10 Description="Whether to indent whole function definitions between #if, #else, and #endif.
Only applies to the indent of the preprocessor that the function definition
is directly inside of.

Default: true" Enabled=false EditorType=boolean TrueFalse=pp_indent_func_def=true|pp_indent_func_def=false ValueDefault=true [Pp Indent Extern] Category=10 Description="Whether to indent extern C blocks between #if, #else, and #endif.
Only applies to the indent of the preprocessor that the extern block is
directly inside of.

Default: true" Enabled=false EditorType=boolean TrueFalse=pp_indent_extern=true|pp_indent_extern=false ValueDefault=true [Pp Indent Brace] Category=10 Description="How to indent braces directly inside #if, #else, and #endif.
Requires pp_if_indent_code=true and only applies to the indent of the
preprocessor that the braces are directly inside of.
0: No extra indent
1: Indent by one level
-1: Preserve original indentation

Default: 1" Enabled=false EditorType=numeric CallName="pp_indent_brace=" MinVal=-1 MaxVal=1 ValueDefault=1 [Pp Warn Unbalanced If] Category=10 Description="Whether to print warning messages for unbalanced #if and #else blocks.
This will print a message in the following cases:
- if an #ifdef block ends on a different indent level than
where it started from. Example:

#ifdef TEST
int i;
{
int j;
#endif

- an #elif/#else block ends on a different indent level than
the corresponding #ifdef block. Example:

#ifdef TEST
int i;
#else
}
int j;
#endif" Enabled=false EditorType=boolean TrueFalse=pp_warn_unbalanced_if=true|pp_warn_unbalanced_if=false ValueDefault=false [Include Category 0] Category=11 Description="The regex for include category with priority 0." Enabled=false CallName=include_category_0= EditorType=string ValueDefault= [Include Category 1] Category=11 Description="The regex for include category with priority 1." Enabled=false CallName=include_category_1= EditorType=string ValueDefault= [Include Category 2] Category=11 Description="The regex for include category with priority 2." Enabled=false CallName=include_category_2= EditorType=string ValueDefault= [Use Indent Func Call Param] Category=12 Description="true: indent_func_call_param will be used (default)
false: indent_func_call_param will NOT be used

Default: true" Enabled=false EditorType=boolean TrueFalse=use_indent_func_call_param=true|use_indent_func_call_param=false ValueDefault=true [Use Indent Continue Only Once] Category=12 Description="The value of the indentation for a continuation line is calculated
differently if the statement is:
- a declaration: your case with QString fileName ...
- an assignment: your case with pSettings = new QSettings( ...

At the second case the indentation value might be used twice:
- at the assignment
- at the function call (if present)

To prevent the double use of the indentation value, use this option with the
value 'true'.

true: indent_continue will be used only once
false: indent_continue will be used every time (default)

Requires indent_ignore_first_continue=false." Enabled=false EditorType=boolean TrueFalse=use_indent_continue_only_once=true|use_indent_continue_only_once=false ValueDefault=false [Indent Cpp Lambda Only Once] Category=12 Description="The indentation can be:
- after the assignment, at the '[' character
- at the beginning of the lambda body

true: indentation will be at the beginning of the lambda body
false: indentation will be after the assignment (default)" Enabled=false EditorType=boolean TrueFalse=indent_cpp_lambda_only_once=true|indent_cpp_lambda_only_once=false ValueDefault=false [Use Sp After Angle Always] Category=12 Description="Whether sp_after_angle takes precedence over sp_inside_fparen. This was the
historic behavior, but is probably not the desired behavior, so this is off
by default." Enabled=false EditorType=boolean TrueFalse=use_sp_after_angle_always=true|use_sp_after_angle_always=false ValueDefault=false [Use Options Overriding For Qt Macros] Category=12 Description="Whether to apply special formatting for Qt SIGNAL/SLOT macros. Essentially,
this tries to format these so that they match Qt's normalized form (i.e. the
result of QMetaObject::normalizedSignature), which can slightly improve the
performance of the QObject::connect call, rather than how they would
otherwise be formatted.

See options_for_QT.cpp for details.

Default: true" Enabled=false EditorType=boolean TrueFalse=use_options_overriding_for_qt_macros=true|use_options_overriding_for_qt_macros=false ValueDefault=true [Use Form Feed No More As Whitespace Character] Category=12 Description="If true: the form feed character is removed from the list of whitespace
characters. See https://en.cppreference.com/w/cpp/string/byte/isspace." Enabled=false EditorType=boolean TrueFalse=use_form_feed_no_more_as_whitespace_character=true|use_form_feed_no_more_as_whitespace_character=false ValueDefault=false [Warn Level Tabs Found In Verbatim String Literals] Category=13 Description="(C#) Warning is given if doing tab-to-\t replacement and we have found one
in a C# verbatim string literal.

Default: 2" Enabled=false EditorType=numeric CallName="warn_level_tabs_found_in_verbatim_string_literals=" MinVal=1 MaxVal=3 ValueDefault=2 [Debug Max Number Of Loops] Category=13 Description="Limit the number of loops.
Used by uncrustify.cpp to exit from infinite loop.
0: no limit." Enabled=false EditorType=numeric CallName="debug_max_number_of_loops=" MinVal= MaxVal= ValueDefault=0 [Debug Line Number To Protocol] Category=13 Description="Set the number of the line to protocol;
Used in the function prot_the_line if the 2. parameter is zero.
0: nothing protocol." Enabled=false EditorType=numeric CallName="debug_line_number_to_protocol=" MinVal= MaxVal= ValueDefault=0 [Debug Timeout] Category=13 Description="Set the number of second(s) before terminating formatting the current file,
0: no timeout.
only for linux" Enabled=false EditorType=numeric CallName="debug_timeout=" MinVal= MaxVal= ValueDefault=0 [Debug Truncate] Category=13 Description="Set the number of characters to be printed if the text is too long,
0: do not truncate." Enabled=false EditorType=numeric CallName="debug_truncate=" MinVal=0 MaxVal=960 ValueDefault=0 [Debug Sort The Tracks] Category=13 Description="sort (or not) the tracking info.

Default: true" Enabled=false EditorType=boolean TrueFalse=debug_sort_the_tracks=true|debug_sort_the_tracks=false ValueDefault=true [Debug Decode The Flags] Category=13 Description="decode (or not) the flags as a new line.
only if the -p option is set." Enabled=false EditorType=boolean TrueFalse=debug_decode_the_flags=true|debug_decode_the_flags=false ValueDefault=false [Set Numbering For Html Output] Category=13 Description="insert the number of the line at the beginning of each line" Enabled=false EditorType=boolean TrueFalse=set_numbering_for_html_output=true|set_numbering_for_html_output=false ValueDefault=false uncrustify-uncrustify-0.76.0/etc/uncrust-files.sh000066400000000000000000000004271434072136500221520ustar00rootroot00000000000000#! /bin/sh if [ -z "$1" ]; then echo "specify the file that contains a list of files" exit fi files=$(cat $1) mkdir -p out for item in $files ; do dn=$(dirname $item) mkdir -p out/$dn ~/bin/uncrustify -f $item -c ~/.uncrustify/xsupplicant.cfg > out/$item done uncrustify-uncrustify-0.76.0/etc/uncrustify.xml.in000066400000000000000000000070041434072136500223530ustar00rootroot00000000000000 ##OPTION_KEYWORDS## ##VALUE_KEYWORDS## ##TOKEN_TYPE_KEYWORDS## file_ext include macro-close macro-else macro-open type using uncrustify-uncrustify-0.76.0/etc/xsupplicant.cfg000066400000000000000000000056001434072136500220440ustar00rootroot00000000000000# # GNU-like format # indent_with_tabs = 0 # 1=indent to level only, 2=indent with tabs input_tab_size = 8 # original tab size output_tab_size = 2 # new tab size indent_columns = 2 # should usually match output_tab_size indent_label = 2 # pos: absolute col, neg: relative column indent_align_string = False # align broken strings indent_brace = 2 nl_enum_brace = remove # "enum {" vs "enum \n {" nl_union_brace = remove # "union {" vs "union \n {" nl_struct_brace = remove # "struct {" vs "struct \n {" nl_do_brace = add # "do {" vs "do \n {" nl_if_brace = add # "if () {" vs "if () \n {" nl_for_brace = add # "for () {" vs "for () \n {" nl_else_brace = add # "else {" vs "else \n {" nl_while_brace = add # "while () {" vs "while () \n {" nl_switch_brace = add # "switch () {" vs "switch () \n {" nl_var_def_blk_end_func_top = 1 nl_before_case = 1 nl_fcall_brace = add # "foo() {" vs "foo()\n{" nl_fdef_brace = add # "int foo() {" vs "int foo()\n{" # nl_after_return = TRUE nl_brace_while = remove nl_brace_else = add nl_squeeze_ifdef = TRUE # mod_paren_on_return = ignore # "return 1;" vs "return (1);" # mod_full_brace_if = ignore # "if (a) a--;" vs "if (a) { a--; }" # mod_full_brace_for = ignore # "for () a--;" vs "for () { a--; }" # mod_full_brace_do = ignore # "do a--; while ();" vs "do { a--; } while ();" # mod_full_brace_while = ignore # "while (a) a--;" vs "while (a) { a--; }" sp_before_semi = remove sp_paren_paren = remove # space between (( and )) sp_return_paren = remove # "return (1);" vs "return(1);" sp_sizeof_paren = remove # "sizeof (int)" vs "sizeof(int)" sp_before_sparen = force # "if (" vs "if(" sp_after_sparen = force # "if () {" vs "if (){" sp_after_cast = remove # "(int) a" vs "(int)a" sp_inside_braces = force # "{ 1 }" vs "{1}" sp_inside_braces_struct = force # "{ 1 }" vs "{1}" sp_inside_braces_enum = force # "{ 1 }" vs "{1}" sp_inside_paren = remove sp_inside_fparen = remove sp_inside_sparen = remove #sp_type_func = ignore sp_assign = force sp_arith = force sp_bool = force sp_compare = force sp_after_comma = force sp_func_def_paren = remove # "int foo (){" vs "int foo(){" sp_func_call_paren = remove # "foo (" vs "foo(" sp_func_proto_paren = remove # "int foo ();" vs "int foo();" # align_with_tabs = FALSE # use tabs to align # align_on_tabstop = FALSE # align on tabstops # align_enum_equ_span = 4 # align_nl_cont = TRUE # align_var_def_span = 2 # align_var_def_inline = TRUE # align_var_def_star = TRUE # align_var_def_colon = TRUE # align_assign_span = 1 # align_struct_init_span = 3 # align_var_struct_span = 3 # align_right_cmt_span = 3 # align_pp_define_span = 3 # align_pp_define_gap = 4 # align_number_right = TRUE # align_typedef_span = 5 # align_typedef_gap = 3 # cmt_star_cont = TRUE eat_blanks_before_close_brace = TRUE eat_blanks_after_open_brace = TRUE uncrustify-uncrustify-0.76.0/extras.vpj000066400000000000000000000105601434072136500202660ustar00rootroot00000000000000 uncrustify-uncrustify-0.76.0/forUncrustifySources.cfg000066400000000000000000000452171434072136500231550ustar00rootroot00000000000000# The uncrustify sources are uncrustified with this config file. using 0.70.0 # General options output_tab_size = 3 tok_split_gte = true # Code alignment options align_asm_colon = true align_assign_decl_func = 2 align_assign_func_proto_span = 4 align_assign_span = 1 align_enum_equ_span = 4 align_enum_equ_thresh = 8 align_func_params = true align_func_proto_star_style = 1 align_nl_cont = true align_number_right = true align_pp_define_gap = 4 align_pp_define_span = 3 align_right_cmt_same_level = true align_right_cmt_span = 3 align_struct_init_span = 3 align_typedef_gap = 3 align_typedef_span = 5 align_typedef_star_style = 1 align_var_class_span = 2 align_var_def_amp_style = 1 align_var_def_colon = true align_var_def_inline = true align_var_def_span = 2 align_var_def_star_style = 1 align_var_struct_span = 3 # Indenting options indent_bool_paren = 1 indent_class = true indent_columns = 3 indent_compound_literal_return = false indent_cpp_lambda_only_once = true indent_first_bool_expr = true indent_macro_brace = true indent_member = 3 indent_sparen_extra = 0 indent_with_tabs = 0 indent_oc_inside_msg_sel = false indent_off_after_assign = false indent_inside_ternary_operator = false # Newline adding and removing options nl_after_access_spec = 1 nl_after_brace_close = true nl_after_brace_open = true nl_after_case = true nl_after_do = force nl_after_for = force nl_after_func_proto = 1 nl_after_func_proto_group = 2 nl_after_if = remove nl_after_member = remove nl_after_namespace = 2 nl_after_return = true nl_after_semicolon = true nl_after_switch = remove nl_after_vbrace_open = true nl_after_while = remove nl_assign_brace = add nl_assign_leave_one_liners = true nl_before_brace_open = false nl_before_case = true nl_before_do = force nl_before_for = force nl_before_func_body_def = 3 nl_before_if = force nl_before_if_closing_paren = remove nl_before_namespace = 2 nl_before_opening_brace_func_class_def = force nl_before_switch = force nl_before_while = force nl_brace_catch = force nl_brace_else = add nl_brace_fparen = remove nl_brace_while = remove nl_case_colon_brace = force nl_catch_brace = add nl_class_brace = force nl_class_colon = remove nl_class_leave_one_liner_groups = true nl_class_leave_one_liners = true nl_template_args = false nl_template_class_decl = remove nl_template_class_def = force nl_template_end = false nl_template_func_decl = remove nl_template_func_def = force nl_template_start = false nl_template_var = remove nl_template_using = remove nl_comment_func_def = 1 nl_constr_colon = force nl_constr_init_args = force nl_do_brace = add nl_else_brace = add nl_else_if = remove nl_elseif_brace = add nl_end_of_file = force nl_end_of_file_min = 1 nl_enum_brace = force nl_enum_class_identifier = remove nl_enum_class = remove nl_enum_colon_type = remove nl_enum_identifier_colon = remove nl_enum_leave_one_liners = true nl_fcall_brace = add nl_fdef_brace = force nl_fdef_brace_cond = force nl_finally_brace = add nl_for_brace = add nl_func_call_empty = remove nl_func_call_paren = remove nl_func_call_paren_empty = remove nl_func_class_scope = remove nl_func_decl_args = remove nl_func_decl_empty = remove nl_func_decl_end = remove nl_func_decl_end_single = remove nl_func_decl_start = remove nl_func_decl_start_single = remove nl_func_def_empty = remove nl_func_def_end = remove nl_func_def_end_single = remove nl_func_def_paren = remove nl_func_def_paren_empty = remove nl_func_def_start = remove nl_func_def_start_single = remove nl_func_paren = remove nl_func_paren_empty = remove nl_func_proto_type_name = remove nl_func_scope_name = remove nl_func_type_name = remove nl_func_type_name_class = remove nl_getset_leave_one_liners = true nl_if_brace = add nl_inside_empty_func = 1 nl_inside_namespace = 2 nl_max = 3 nl_namespace_brace = force nl_return_expr = remove nl_squeeze_ifdef = true nl_start_of_file = remove nl_struct_brace = add nl_switch_brace = add nl_try_brace = add nl_type_brace_init_lst = force nl_type_brace_init_lst_close = force nl_type_brace_init_lst_open = force nl_union_brace = add nl_var_def_blk_end_func_top = 1 nl_while_brace = add # Positioning options pos_bool = lead pos_constr_colon = lead_break pos_constr_comma = lead_force pos_enum_comma = trail_force # Preprocessor options pp_indent = remove pp_space_after = remove pp_multiline_define_body_indent = 3 # Spacing options sp_addr = remove sp_after_angle = force sp_after_byref_func = remove sp_after_byref = remove sp_after_cast = remove sp_after_class_colon = force sp_after_comma = force sp_after_constr_colon = force sp_after_dc = remove sp_after_for_colon = force sp_after_new = force sp_after_operator = remove sp_after_operator_sym = remove sp_after_ptr_star_func = remove sp_after_ptr_star_qualifier = remove sp_after_ptr_star = remove sp_after_semi = force sp_after_semi_for = force sp_after_semi_for_empty = remove sp_after_sparen = force sp_after_tparen_close = remove sp_after_type = force sp_after_type_brace_init_lst_open = force sp_angle_paren_empty = remove sp_angle_paren = remove sp_angle_word = force sp_arith_additive = force sp_arith = force sp_assign_default = force sp_assign = force sp_attribute_paren = remove sp_balance_nested_parens = false sp_before_angle = remove sp_before_byref = force sp_before_byref_func = force sp_before_case_colon = remove sp_before_class_colon = force sp_before_comma = remove sp_before_dc = remove sp_before_ellipsis = remove sp_before_for_colon = force sp_before_ptr_star = force sp_before_ptr_star_func = force sp_before_semi = remove sp_before_semi_for_empty = force sp_before_semi_for = remove sp_before_sparen = force sp_before_square = remove sp_before_squares = remove sp_before_type_brace_init_lst_close = force sp_before_unnamed_byref = force sp_before_unnamed_ptr_star = force sp_before_vardef_square = remove sp_between_ptr_star = remove sp_between_semi_for_empty = force sp_bool = force sp_brace_brace = force sp_brace_close_while = force sp_brace_typedef = force sp_catch_paren = force sp_compare = force sp_cond_colon_after = force sp_cond_colon_before = force sp_cond_question_after = force sp_cond_question_before = force sp_cpp_before_struct_binding = remove sp_cpp_cast_paren = remove sp_cpp_lambda_fparen = remove sp_cpp_lambda_paren_brace = force sp_cpp_lambda_square_brace = force sp_cpp_lambda_square_paren = remove sp_decltype_paren = remove sp_defined_paren = force sp_deref = remove sp_do_brace_open = force sp_endif_cmt = force sp_enum_after_assign = force sp_enum_assign = force sp_enum_before_assign = force sp_enum_colon = force sp_fparen_brace = force sp_fparen_brace_initializer = force sp_func_call_paren_empty = remove sp_func_call_paren = remove sp_func_class_paren = remove sp_func_class_paren_empty = remove sp_func_def_paren_empty = remove sp_func_def_paren = remove sp_func_proto_paren_empty = remove sp_func_proto_paren = remove sp_func_type_paren = remove sp_incdec = remove sp_inside_angle_empty = remove sp_inside_angle = remove sp_inside_braces_empty = remove sp_inside_braces_enum = force sp_inside_braces = force sp_inside_braces_struct = force sp_inside_fparen = remove sp_inside_fparens = remove sp_inside_paren = remove sp_inside_paren_cast = remove sp_inside_sparen = remove sp_inside_sparen_close = remove sp_inside_sparen_open = remove sp_inside_square = remove sp_inside_square_empty = remove sp_inside_tparen = remove sp_inv = remove sp_member = remove sp_not = remove sp_paren_paren = remove sp_paren_qualifier = force sp_pp_concat = force sp_pp_stringify = force sp_ptr_star_func_var = remove sp_ptr_star_func_type = remove sp_ptr_star_paren = force sp_return_brace = remove sp_return_paren = remove sp_sign = remove sp_sizeof_paren = remove sp_sparen_brace = force sp_template_angle = remove sp_trailing_return = force sp_type_brace_init_lst = remove sp_type_func = force sp_while_paren_open = force sp_word_brace_init_lst = remove # Comment modification options cmt_star_cont = true # eat eat_blanks_after_open_brace = true eat_blanks_before_close_brace = true # Code modifying options mod_add_long_function_closebrace_comment = 40 mod_add_long_namespace_closebrace_comment = 5 mod_add_long_switch_closebrace_comment = 40 mod_full_brace_do = add mod_full_brace_for = add mod_full_brace_if = add mod_full_brace_while = add mod_paren_on_return = add #mod_remove_empty_return = true mod_remove_empty_return = false mod_remove_extra_semicolon = true mod_sort_include = true mod_sort_incl_import_prioritize_filename = false mod_sort_incl_import_prioritize_extensionless = false mod_sort_incl_import_prioritize_angle_over_quotes = false mod_sort_incl_import_ignore_extension = false mod_sort_incl_import_grouping_enabled = false debug_timeout = 0 # the build of uncrustify needs the options to be set to ignore sp_after_assign = ignore sp_before_assign = ignore sp_before_tr_cmt = ignore sp_cmt_cpp_start = ignore nl_before_member = ignore nl_brace_brace = ignore nl_cpp_ldef_brace = ignore // TODO nl_enum_own_lines = ignore nl_func_call_args = ignore nl_func_call_start = ignore // remove nl_func_call_end = ignore // remove nl_func_def_args = ignore use_form_feed_no_more_as_whitespace_character = false # NOT yet used sp_xx options # sp_after_decltype # sp_after_invariant_paren # sp_after_mdatype_commas # sp_after_newop_paren # sp_after_noexcept # sp_after_oc_at_sel # sp_after_oc_at_sel_parens # sp_after_oc_block_caret # sp_after_oc_colon # sp_after_oc_dict_colon # sp_after_oc_msg_receiver # sp_after_oc_property # sp_after_oc_return_type # sp_after_oc_scope # sp_after_oc_synchronized # sp_after_oc_type # sp_after_operator_sym_empty # sp_after_ptr_block_caret # sp_after_send_oc_colon # sp_after_tag # sp_after_throw # sp_angle_colon # sp_angle_shift # sp_annotation_paren # sp_before_constr_colon # sp_before_mdatype_commas # sp_before_nl_cont # sp_before_oc_block_caret # sp_before_oc_colon # sp_before_oc_dict_colon # sp_before_oc_proto_list # sp_before_pp_stringify # sp_before_send_oc_colon # sp_before_square_asm_block # sp_before_template_paren # sp_between_mdatype_commas # sp_between_new_paren # sp_brace_catch # sp_brace_else # sp_brace_finally # sp_case_label # sp_catch_brace # sp_cond_question # sp_cond_ternary_short # sp_cparen_oparen # sp_cpp_lambda_assign # sp_d_array_colon # sp_else_brace # sp_enum_brace # sp_enum_paren # sp_extern_paren # sp_finally_brace # sp_fparen_dbrace # sp_func_call_user_inside_fparen # sp_func_call_user_paren # sp_func_call_user_paren_paren # sp_getset_brace # sp_inside_braces_oc_dict # sp_inside_newop_paren # sp_inside_newop_paren_close # sp_inside_newop_paren_open # sp_inside_oc_at_sel_parens # sp_inside_square_oc_array # sp_inside_type_brace_init_lst # sp_invariant_paren # sp_macro # sp_macro_func # sp_oc_brace_catch # sp_oc_catch_brace # sp_oc_catch_paren # sp_oc_classname_paren # sp_paren_brace # sp_paren_comma # sp_paren_ellipsis # sp_paren_noexcept # sp_range # sp_scope_paren # sp_sizeof_ellipsis # sp_sizeof_ellipsis_paren # sp_special_semi # sp_square_fparen # sp_super_paren # sp_this_paren # sp_throw_paren # sp_trailing_ret_t # sp_try_brace # sp_type_ellipsis # sp_vala_after_translation # sp_version_paren # sp_word_brace # sp_word_brace_ns # NOT yet used nl_xx options # nl_after_annotation # nl_after_square_assign # nl_after_synchronized # nl_assign_square # nl_before_synchronized # nl_before_throw # nl_between_annotation # nl_brace_finally # nl_brace_square # nl_brace_struct_var # nl_class_init_args # nl_getset_brace # nl_oc_before_end # nl_oc_before_implementation # nl_oc_before_interface # nl_oc_block_brace # nl_oc_brace_catch # nl_oc_catch_brace # nl_oc_implementation_brace # nl_oc_interface_brace # nl_oc_mdef_brace # nl_paren_dbrace_open # nl_property_brace # nl_scope_brace # nl_synchronized_brace # nl_template_class # nl_tsquare_brace # nl_unittest_brace # nl_using_brace # nl_version_brace # nl_func_call_args_multi_line_ignore_closures # NOT yet used indent_xx options # indent_off_after_return uncrustify-uncrustify-0.76.0/forUncrustifySources.txt000066400000000000000000000027171434072136500232330ustar00rootroot000000000000002016-04-27 The configuration file forUncrustifySources.cfg is the file to uncrustify the sources of uncrustify. It should be "stable". This means that if one changes (allmost) anything in a file, a new run of uncrustify with that configuration file, should produce the same output as the original input. This cannot work for really anything, but one should try this approach. About the comments: While a line is indented, the comment at the end of the line stays at the original column. If we have: else if ((pc->GetType() == CT_FUNC_CLASS_DEF) || (pc->GetType() == CT_FUNC_DEF) || (pc->GetType() == CT_FUNC_CLASS_PROTO) || (pc->GetType() == CT_FUNC_PROTO)) { // guy 2016-04-16 where the brace { is at new line with a comment. The option nl_elseif_brace = remove gives: else if ((pc->GetType() == CT_FUNC_CLASS_DEF) || (pc->GetType() == CT_FUNC_DEF) || (pc->GetType() == CT_FUNC_CLASS_PROTO) || (pc->GetType() == CT_FUNC_PROTO)) { // guy 2016-04-16 If using at new the same option again with a new value nl_elseif_brace = add is not able to reconstruct the original source. The comment has changed the line: else if ((pc->GetType() == CT_FUNC_CLASS_DEF) || (pc->GetType() == CT_FUNC_DEF) || (pc->GetType() == CT_FUNC_CLASS_PROTO) || (pc->GetType() == CT_FUNC_PROTO)) // guy 2016-04-16 { uncrustify-uncrustify-0.76.0/lnt/000077500000000000000000000000001434072136500170325ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/lnt/ChunkStack.lnt000066400000000000000000000002441434072136500216070ustar00rootroot00000000000000-esym(526, clear, empty, size) -esym(628, clear, empty, size) -esym(746, clear, empty, size, pop_back, pop_front) -esym(1013, empty) -esym(1055, clear, empty, size)uncrustify-uncrustify-0.76.0/lnt/align.lnt000066400000000000000000000007001434072136500206400ustar00rootroot00000000000000-esym(526, End, resize, text) -esym(526, Add, Flush, NewLines, push_back, Start) -esym(628, Add, Flush, NewLines, push_back, Start) -esym(628, push_back, flush, End, text, resize) -esym(746, End, text, resize, Start) -esym(746, Add, Flush, NewLines, push_back) -esym(1013, size, End, text, resize, Start, type, m_right_align, clear) -esym(1013, Add, Flush, NewLines, push_back) -esym(1055, Add, Flush, NewLines, push_back, End, text, resize, Start)uncrustify-uncrustify-0.76.0/lnt/chunk_list.lnt000066400000000000000000000000001434072136500217020ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/lnt/logger.lnt000066400000000000000000000000201434072136500210200ustar00rootroot00000000000000-esym(530, args)uncrustify-uncrustify-0.76.0/lnt/readme.txt000066400000000000000000000004701434072136500210310ustar00rootroot00000000000000The *.lnt files in the /lnt directory hold exclusion patterns for pclint. If you find pclint errors/warnings that you are sure to be of no interest they should be suppressed here. Don't add suppression messages directly into the source files as this clutters the code and disturbs users that do not use pclint.uncrustify-uncrustify-0.76.0/lnt/unc_text.lnt000066400000000000000000000000361434072136500214010ustar00rootroot00000000000000-esym(550, di) -esym(746, end)uncrustify-uncrustify-0.76.0/lnt/uncrustify_types.lnt000066400000000000000000000000001434072136500231760ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/man/000077500000000000000000000000001434072136500170105ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/man/uncrustify.1.in000066400000000000000000000121661434072136500217200ustar00rootroot00000000000000.TH UNCRUSTIFY "1" "Oct 2014" "uncrustify @PACKAGE_VERSION@" "User Commands" .SH NAME uncrustify \- C, C++, C#, D, Java and Pawn source code beautifier .SH SYNOPSIS .B uncrustify \fR[\fIOPTIONS\fR] [\fIFILES\fR] .SH DESCRIPTION If no input files are specified, the input is read from stdin. .br If reading from stdin, you should specify the language using \-l. If \-F is used or files are specified on the command line, the output filename is \fIPFX\fR + "/" + filename + \fISFX\fR. .br Unless, of course, the options \fB\-\-replace\fR or \fB\-\-no\-backup\fR are used. When reading from stdin or doing a single file via the '\-f' option, the output is dumped to stdout, unless redirected with \-o FILE. Errors are always dumped to stderr .SH OPTIONS .SS "Basic Options:" .TP \fB\-c\fI CFG\fR Use the config file \fICFG\fR, or defaults if \fICFG\fR is set to '-'. .br If not specified, uncrustify will use \fB$UNCRUSTIFY_CONFIG\fR or \fB$HOME/.uncrustify.cfg\fR. .TP \fB\-f\fI FILE\fR Process the single file \fIFILE\fR, sending output to stdout or the file specified with \fB\-o\fR. .TP \fB\-o\fI FILE\fR Redirect output to \fIFILE\fR. .br Use with \fB\-f\fR, \fB\-\-update\-config\fR, \fB\-\-update\-config\-with\-doc\fR, \fB\-\-universalindent\fR. .TP \fB\-\-check\fR Do not output the new text, instead verify that nothing changes when the file(s) are processed. The status of every file is printed to stderr. The exit code is EXIT_SUCCESS if there were no changes, EXIT_FAILURE otherwise. .TP \fB\-F\fI FILE\fR Read files to process from \fIFILE\fR, one filename per line. If \fIFILE\fR is \'\-\' then read filenames from standard input instead of a file. .br You can create this file using something like \'\fBfind . \-name "*.c" > list.txt\fR\'. .br This cannot be combined with \fB\-f\fR. .TP \fB\-\-prefix\fI PFX\fR Prepend \fIPFX\fR to the output filename path. .br This cannot be combined with \fB\-f\fR, \fB\-\-replace\fR, or \fB\-\-no\-backup\fR. .TP \fB\-\-suffix\fI SFX\fR Append \fISFX\fR to the output filename. .br The default is '.uncrustify' if neither \fISFX\fR or \fIPFX\fR are specified. .br This cannot be combined with \fB\-f\fR, \fB\-\-replace\fR, or \fB\-\-no\-backup\fR. .TP \fB\-\-frag\fR Assume the input is a code fragment and the first line is properly indented. .TP \fB\-\-replace\fR Replace source files (creates a backup). .br This cannot be combined with \fB\-f\fR, \fB\-\-prefix\fR, or \fB\-\-suffix\fR. .TP \fB\-\-no\-backup\fR Replace files, no backup. Useful if files are under source control .br This cannot be combined with \fB\-f\fR, \fB\-\-prefix\fR, or \fB\-\-suffix\fR. .TP \fB\-\-mtime\fR Preserve mtime on replaced files. .TP \fB\-l\fR Language override: C, CPP, D, CS, JAVA, PAWN, VALA, OC, OC+ .TP \fB\-t\fR Load a file with types (usually not needed) .TP \fB\-q\fR Quiet mode \- no output on stderr (\fB\-L\fR will override) .SS "Config/Help Options:" .TP \fB\-h\fR \-? \fB\-\-help\fR \fB\-\-usage\fR Print this message and exit .TP \fB\-\-version\fR Print the version and exit .TP \fB\-\-count\-options\fR Print the number of available options and exit .TP \fB\-\-show\-config\fR Print out option documentation and exit .TP \fB\-\-update\-config\fR Output a new config file. .TP \fB\-\-update\-config\-with\-doc\fR Output a new config file with embedded usage comments. .TP \fB\-\-universalindent\fR Output a config file for Universal Indent GUI. .TP \fB\-\-detect\fR Detects the config from a source file. Use with '\-f \fIFILE\fR'. Detection is currently fairly limited. .SS "Debug Options:" .TP \fB\-p \fIFILE\fR Dump debug info into \fIFILE\fR, or to stdout if \fIFILE\fR is set to '-'. .br Must be used in combination with '-f \fIFILE\fR'. .TP \fB\-ds \fIFILE\fR \fB\-\-dump\-steps \fIFILE\fR Dump parsing info at various moments of the formatting process. .br This creates a series of files named '\fIFILE\fR_nnn.log', each .br corresponding to a formatting step in uncrustify. .br The file '\fIFILE\fR_000.log' lists the formatting options in use. .br Must be used in combination with '-f \fIFILE\fR'. .TP \fB\-L\fI SEV\fR Set the log severity (see log_levels.h) .TP \fB\-s\fR Show the log severity in the logs .TP \fB\-\-decode\fI FLAG\fR Print \fIFLAG\fR as text and exit .SH EXAMPLES .TP Read a D file from stdin, output to stdout. cat foo.d | uncrustify \-q \-c my.cfg \-l d .TP Process a file, output to stdout. uncrustify \-c my.cfg \-d foo.d .TP Process a source tree, output to a different tree. find src \-name "*.[ch]" > files.txt .br uncrustify \-c my.cfg \-F files.txt \-\-prefix out .TP Process a source tree in\(hyplace. uncrustify \-c my.cfg \-\-no\-backup $(find src \-name "*.[ch]") .SH NOTES Use comments containing ' *INDENT\-OFF*' and ' *INDENT\-ON*' to disable processing of parts of the source file. .SH AUTHOR Written by Ben Gardner .SH REPORTING BUGS Use the issue tracker at .SH COPYRIGHT Copyright (C) 2006\(hy2014 Ben Gardner .br Copyright (C) 2015, 2016 Guy Maurel .SH LICENSE GNU GPL version 2 or later This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. uncrustify-uncrustify-0.76.0/osx/000077500000000000000000000000001434072136500170465ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/osx/Xcode Organizer Actions.xccommands000066400000000000000000000103211434072136500254650ustar00rootroot00000000000000// !$*UTF8*$! { commands = ( { directory = .; name = make; script = "#!/bin/sh\n./configure\nmake\n"; type = other; }, { directory = .; name = "Build uncrustify with configuration Debug"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration Debug build\n"; type = build; }, { directory = .; name = "Build uncrustify with configuration Release"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration Release build\n"; type = build; }, { directory = .; name = "Build uncrustify with configuration Install (xcodebuild only!)"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration \"Install (xcodebuild only!)\" build\n"; type = build; }, { directory = .; name = "Clean uncrustify with configuration Debug"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration Debug clean\n"; type = clean; }, { directory = .; name = "Clean uncrustify with configuration Release"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration Release clean\n"; type = clean; }, { directory = .; name = "Clean uncrustify with configuration Install (xcodebuild only!)"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration \"Install (xcodebuild only!)\" clean\n"; type = clean; }, { directory = selection; name = "----"; type = clean; }, { directory = .; name = "Clean All in uncrustify with configuration Debug"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration Debug -alltargets clean\n"; type = clean; }, { directory = .; name = "Clean All in uncrustify with configuration Release"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration Release -alltargets clean\n"; type = clean; }, { directory = .; name = "Clean All in uncrustify with configuration Install (xcodebuild only!)"; script = "#!/bin/sh\n\nxcodebuild -project uncrustify.xcodeproj -configuration \"Install (xcodebuild only!)\" -alltargets clean\n"; type = clean; }, { arguments = "-l oc+ -c $SOURCE_ROOT/etc/objc.cfg -q -f $SOURCE_ROOT/tests/input/oc/Fraction.m"; directory = .; name = "Run uncrustify from uncrustify with configuration Debug"; script = "/Users/andre/Documents/Xcode/CommandLineUtility/C++Tool/uncrustify/build/Debug/uncrustify"; type = run; }, { arguments = "-l oc+ -c $SOURCE_ROOT/etc/objc.cfg -q -f $SOURCE_ROOT/tests/input/oc/Fraction.m"; directory = .; name = "Run uncrustify from uncrustify with configuration Release"; script = "/Users/andre/Documents/Xcode/CommandLineUtility/C++Tool/uncrustify/build/Release/uncrustify"; type = run; }, { arguments = "-l oc+ -c $SOURCE_ROOT/etc/objc.cfg -q -f $SOURCE_ROOT/tests/input/oc/Fraction.m"; directory = .; name = "Run uncrustify from uncrustify with configuration Install (xcodebuild only!)"; script = "/Users/andre/Documents/Xcode/CommandLineUtility/C++Tool/uncrustify/build/Install (xcodebuild only!)/uncrustify"; type = run; }, { directory = selection; name = "----"; type = run; }, { arguments = "-l oc+ -c $SOURCE_ROOT/etc/objc.cfg -q -f $SOURCE_ROOT/tests/input/oc/Fraction.m"; debugger = gdb; directory = .; name = "Debug uncrustify from uncrustify with configuration Debug"; script = "/Users/andre/Documents/Xcode/CommandLineUtility/C++Tool/uncrustify/build/Debug/uncrustify"; type = run; }, { arguments = "-l oc+ -c $SOURCE_ROOT/etc/objc.cfg -q -f $SOURCE_ROOT/tests/input/oc/Fraction.m"; debugger = gdb; directory = .; name = "Debug uncrustify from uncrustify with configuration Release"; script = "/Users/andre/Documents/Xcode/CommandLineUtility/C++Tool/uncrustify/build/Release/uncrustify"; type = run; }, { arguments = "-l oc+ -c $SOURCE_ROOT/etc/objc.cfg -q -f $SOURCE_ROOT/tests/input/oc/Fraction.m"; debugger = gdb; directory = .; name = "Debug uncrustify from uncrustify with configuration Install (xcodebuild only!)"; script = "/Users/andre/Documents/Xcode/CommandLineUtility/C++Tool/uncrustify/build/Install (xcodebuild only!)/uncrustify"; type = run; }, ); } uncrustify-uncrustify-0.76.0/package.json000066400000000000000000000010751434072136500205260ustar00rootroot00000000000000{ "name": "uncrustify", "version": "0.76.0", "description": "A highly configurable, easily modifiable source code beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and VALA", "main": "uncrustify", "scripts": { "preinstall": "mkdir -p build && cd build && cmake .. && make" }, "bin": "src/uncrustify", "repository": { "type": "git", "url": "https://github.com/uncrustify/uncrustify" }, "keywords": [ "uncrustify", "source code beautifier" ], "author": "Ben Gardner", "author": "Guy Maurel", "license": "GPL-2.0-or-later" } uncrustify-uncrustify-0.76.0/release-process.rst000066400000000000000000000247331434072136500220740ustar00rootroot00000000000000============================ Uncrustify Release Process ============================ .. Update the date in the next line when editing this document! *This document was last updated on 2022-11-22, for Uncrustify 0.76.0.* This document uses "0.1.2" throughout as an example version number. Whenever you see this, you should substitute the version number of the new release being prepared. Paths are specified in git syntax, i.e. ``:/`` is the repository root. Requirements ============ This document assumes you are using a Linux-based OS. While it should be possible to cut a release on Windows, using e.g. the `Git for Windows SDK `_ or a MinGW_ environment, the names and/or arguments to some commands may be different. In addition to the build and test requirements for Uncrustify itself (CMake, a C++ compiler, Python, git), you will also need: - tar - python3-git - Binutils-mingw-w64 - Gcc-mingw-w64 - G++-mingw-w64 - zip - wget (optional) - scp (to update documentation on the SourceForge page) Using packages provided by your OS distribution is *strongly* recommended. (Exact package names may vary depending on your distribution.) Examples use ``wget`` to download files via command line, but any mechanism of obtaining files over HTTPS may be employed. Preparing a Candidate ===================== The first step, obviously, is deciding to make a release. Prior to making a release, verify that the repository is in a stable state and that all CI (continuous integration - AppVeyor) has passed. This should ensure all tests pass and building (including cross-compiling) for Windows is working. Once the release process is started, only pull requests needed to fix critical bugs, or related to the release process, should be accepted. (This will minimize the need to redo or repeat work such as updating the documentation, especially the change log.) To start the release process, first check that: - You are on the ``master`` branch - Your local clone is up to date - ``CMAKE_BUILD_TYPE`` is set to ``Release`` (or ``RelWithDebInfo``) - Your build is up to date - check the list of authors with scripts/prepare_list_of_authors.sh Then, run:: $ scripts/release_tool.py init $ scripts/release_tool.py update path/to/uncrustify (Replace ``path/to/uncrustify`` with the path to the Uncrustify executable you just built, e.g. ``build/uncrustify``.) This will create a branch for the release candidate and perform some automated updates to various files. With no arguments, ``init`` will prompt you for the new version number, defaulting to ``x.(y+1).0``, where ``x.y.z`` is the previous release. The ``--version`` argument may also be used to specify the version (e.g. if the script will not be able to prompt for input). After, you should check that the following files show the correct version number and option count: - ``:/CMakeLists.txt`` (version number only; look for ``UNCRUSTIFY_VERSION``) - ``:/package.json`` (version number only; you'll see it, the file is tiny) - ``:/README.md`` (look for "options as of version") - ``:/documentation/htdocs/index.html`` (look for "options as of version") (Note that ``uncrustify`` itself will not show the new version number until the final release has been tagged.) Update Documentation ==================== Update ``:/ChangeLog``. There is a helper script, ``:/scripts/gen_changelog.py``, that can help extract new options since the previous release: .. code:: $ scripts/gen_changelog.py uncrustify-0.0.0 Replace ``0.0.0`` with the version of the *previous* release. This will generate a bunch of output like:: 0123456789abcdef0123456789abcdef01234567 Added : better_name Jan 13 1970 Removed : poor_name Jan 13 1970 fedcba9876543210fedcba9876543210fedcba98 Added : new_option_1 Jan 18 1970 Added : new_option_2 Jan 18 1970 Your goal is to turn the "raw" output into something like this:: Deprecated options: - poor_name Jan 13 1970 Renamed to better_name New options: - new_option_1 Jan 18 1970 - new_option_1 Jan 18 1970 To accomplish this, you will need to inspect any removed options, possibly consulting the commits in which they were removed, to determine the reason for deprecation and what replacement is recommended. (Note that it may not be as simple as "use X instead".) Also watch for options that were added and subsequently renamed since the last release. (This has happened a few times. In such cases, the new name should show up as an ordinary "new" option, and the old name should be entirely omitted from the change log.) It helps to copy the output to a scratch file for editing. Move deprecated options to the top and add a "Deprecated options:" header, then add a "New options:" header in front of what's left, and remove the commit SHAs (``sed -r '/^[[:xdigit:]]{40}/d`` if you don't want to do it by hand). Then, check that the options are in order by date; date of authorship vs. date of merge may cause discrepancies. Finally, replace occurrences of ``\w+ +:`` with ``-`` (if your editor supports regular expressions; otherwise you can individually replace ``Added :`` and ``Removed :``). Add a new release header (don't forget to add the date!) to the change log and insert the list of option changes as created above. Also fill in the list of resolved issues, new keywords (if any), as well as any other changes that need to be mentioned. If any command line arguments have been added or changed, including descriptions for the same, check to see if ``:/man/uncrustify.1.in`` needs to be updated. (Hopefully this happened when the source was changed!) Finalize the Code Changes ========================= Inspect your working tree. Use ``git add -p`` to stage the changes made to the documentation and other artifacts that contain version-dependent information. Verify that only desired changes are staged, and that your working tree is otherwise clean. Now is a good time to recheck that everything builds, and that all the tests pass. This is also a good time to manually test 32- and 64-bit builds. When you are ready, commit the changes using: .. code:: $ scripts/release_tool.py commit (If you prefer, you can also commit the changes manually; the script just fills in the commit message for you.) Submit and Tag the Release ========================== Push the release candidate branch to GitHub, and create a pull request. Once the pull request is merged, tag the release using: Make sure, the file .git/config has the right value: [remote "origin"] url = https://github.com/uncrustify/uncrustify.git .. code:: $ scripts/release_tool.py tag Note that this will only work if the merge of the release candidate is the most recent commit upstream. Otherwise, the merge commit must be specified by using the ``-c`` option. (Tagging the release does not need to be done on any particular branch. The command will not affect or look at your work tree at all.) Create Binaries =============== Now that the release is published, grab a copy of the sources from GitHub: .. code:: $ wget https://github.com/uncrustify/uncrustify/archive/uncrustify-0.1.2.zip $ unzip -e uncrustify-0.1.2.zip Next, build the 32- and 64-bit Windows binaries: .. code:: $ cd /path/to/uncrustify-uncrustify-0.1.2 $ mkdir buildwin-32 $ cd buildwin-32 $ cmake -G Ninja \ -DCMAKE_BUILD_TYPE=Release \ -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-mingw32.cmake \ -DCMAKE_EXE_LINKER_FLAGS="-static -s" \ .. $ ninja $ cpack .. code:: $ cd /path/to/uncrustify-uncrustify-0.1.2 $ mkdir buildwin-64 $ cd buildwin-64 $ cmake -G Ninja \ -DCMAKE_BUILD_TYPE=Release \ -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-mingw64.cmake \ -DCMAKE_EXE_LINKER_FLAGS="-static -s" \ .. $ ninja $ cpack Create a tarball: .. code:: $ cd /path/to/uncrustify $ git archive -o uncrustify-0.1.2.tar.gz --prefix=uncrustify-0.1.2/ uncrustify-0.1.2 TODO: find the best strategie... (If you don't have Ninja_, or just don't want to use it for whatever reason, omit ``-G Ninja`` and run ``make`` instead of ``ninja``.) This is also a good time to test the tagged build on Linux: .. code:: $ wget https://github.com/uncrustify/uncrustify/archive/uncrustify-0.1.2.tar.gz $ tar xzf uncrustify-0.1.2.tar.gz $ cd uncrustify-uncrustify-0.1.2 $ mkdir build $ cd build $ cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. $ ninja $ ctest $ ./uncrustify --version Upload to SourceForge ===================== - Login as admin under https://sourceforge.net/projects/uncrustify/ - Change to https://sourceforge.net/projects/uncrustify/files/ - "Add Folder"; the name should be e.g. "uncrustify-0.1.2" - Navigate to the new folder (e.g. https://sourceforge.net/projects/uncrustify/files/uncrustify-0.1.2/) - "Add File"; upload the following files (adjusting for the actual version number): - README.md - uncrustify-0.1.2.tar.gz - buildwin-32/uncrustify-0.1.2_f-win32.zip - buildwin-64/uncrustify-0.1.2_f-win64.zip - "Done" - Upload the documentation: .. code:: $ scp -r documentation/htdocs/* ChangeLog \ USER,uncrustify@web.sourceforge.net:htdocs/ - Use the web interface (file manager) to create the release folder and upload the files to SourceForge. Announce the Release (Optional) =============================== The new release is live! Spread the word! Consider these ideas: - Create a news item. - Update freshmeat.net project. Release Checklist ================= The following list serves as a quick reference for making a release. These items are explained in greater detail above. #. Verify that CI passes #. Use ``release_tool.py`` to initialize the release and perform automated updates. Check: #. ``:/CMakeLists.txt`` #. ``:/package.json`` #. ``:/README.md`` #. ``:/documentation/htdocs/index.html`` #. Update documentation as needed: #. ``:/ChangeLog`` #. ``:/man/uncrustify.1.in`` #. Stage changes. #. Test everything again. #. Finalize the code changes. #. Push to GitHub and create a merge request. #. Tag the merged release branch. #. Create Windows (32- and 64-bit) binaries. #. Run a test build on Linux. #. Upload the release and documentation to SourceForge. #. Announce the release! .. _MinGW: http://www.mingw.org/ .. _GitPython: https://github.com/gitpython-developers/GitPython .. _Ninja: https://ninja-build.org/ uncrustify-uncrustify-0.76.0/scripts/000077500000000000000000000000001434072136500177245ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/scripts/Gcov_test.sh000077500000000000000000000117451434072136500222300ustar00rootroot00000000000000#!/bin/bash # # @author Guy Maurel # @license GPL v2+ # # 30. 4. 2018 # # The script prepare a new version of uncrustify with the compile options: # CMAKE_CXX_FLAGS -fprofile-arcs -ftest-coverage # CMAKE_C_FLAGS -fprofile-arcs -ftest-coverage # to use the facilities from gcov. # Running uncrustify with all the test data will mark all parts of the sources # which are used. # The "not marked" portions, if any, should give the opportunity to prepare new # test data to complete the whole tests. # The results are stored in the directory ${TOTALS_DIR} # The name of the file is ${source_file}.total # The line(s) of code which are still not used by any of the tests cases are # marked which the token "#####" at the beginning of the line. # As the testing part (unc_tools.cpp, backup.cpp) are only used by a developper, # all the lines are marked. # Also the detect.cpp part of uncrustify is completly marked. # # TAKE ATTENTION: # =============== # # Running the test is long. I need about 20 minutes. # This is about 40 times so much as the ctest. # The disk space necessary is also very big, about 3 Gbytes # This is about 1500 times bigger as the sources. # SCRIPT_NAME=$0 #echo "SCRIPT_NAME="${SCRIPT_NAME} BASE_NAME=`basename ${SCRIPT_NAME}` DIR_NAME=`dirname ${SCRIPT_NAME}` if [ ${DIR_NAME} != "." ] ; then echo "you must use the script at the directory /scripts" exit fi cd .. SOURCES_LIST_H=`ls -1 src/*.h | cut -b 5-` SOURCES_LIST_CPP=`ls -1 src/*.cpp | cut -b 5-` # rm -rf gcov_test mkdir gcov_test # cd gcov_test # build a new uncrustify binary cmake -D CMAKE_BUILD_TYPE=Release \ -D CMAKE_C_FLAGS="-fprofile-arcs -ftest-coverage" \ -D CMAKE_CXX_FLAGS="-fprofile-arcs -ftest-coverage" .. make # use uncrustify without parameter ./uncrustify # GCNO_LIST=`ls -1 ./CMakeFiles/uncrustify.dir/src/*.gcno` for gcno_file in ${GCNO_LIST} do echo "gcno_file=${gcno_file}" gcno_base_name=`basename ${gcno_file} .gcno` echo ${gcno_base_name} gcov ${gcno_file} -m done # ADD_TEST_LIST="add_test_list.txt" ADD_TEST_LIST_10="add_test_list_10.txt" ADD_TEST_LIST_NUMBER="add_test_list_number.txt" ADD_TEST_LIST_AWK="../scripts/add_test_list.awk" ADD_TEST_LIST_CMD="add_test_list.sh" # # prepare a list of all tests grep add_test ../build/tests/CTestTestfile.cmake > ${ADD_TEST_LIST} cut -b 10- < ${ADD_TEST_LIST} > ${ADD_TEST_LIST_10} cut --delimiter=" " --fields=1 < ${ADD_TEST_LIST_10} > ${ADD_TEST_LIST_NUMBER} # NUMBER_LIST=`cat ${ADD_TEST_LIST_NUMBER}` # # prepare a new script file to use uncrustify with all the tests cases gawk --file ${ADD_TEST_LIST_AWK} \ --assign sources_cpp="${SOURCES_LIST_CPP}" \ --assign sources_h="${SOURCES_LIST_H}" < ${ADD_TEST_LIST} > ${ADD_TEST_LIST_CMD} chmod +x ${ADD_TEST_LIST_CMD} # # ATTENTION: this takes about 10 minutes # use the new script file ADD_TEST_LIST_CMD to build the information ./${ADD_TEST_LIST_CMD} # # compare, add the counts of each lines of generated gcov-tests COMPARE_AND_ADD="../scripts/compare_the_gcov.awk" TOTALS_DIR="Totals" mkdir -p Totals # # choose DO_IT_WITH_TEST="yes" #DO_IT_WITH_TEST="no" # # and apply if [ ${DO_IT_WITH_TEST} == "yes" ] then # do it with intermediate files # to save the last file of each test for test_number in ${NUMBER_LIST} do last_test_number=${test_number} done # for source_file in ${SOURCES_LIST_CPP} do echo "source_file is ${source_file}" I_file="blabla" # this file doesn' exists for test_number in ${NUMBER_LIST} do echo "source_file is ${source_file}: test_number=${test_number}" H_DIR="${source_file}_Dir" mkdir -p ${TOTALS_DIR}/${H_DIR} TEST_FILE=${test_number}/${source_file}.gcov if [ -s ${TEST_FILE} ] ; then O_file="${TOTALS_DIR}/${H_DIR}/${test_number}" gawk --file ${COMPARE_AND_ADD} \ --assign in_file="${I_file}" \ --assign out_file="${O_file}" < ${TEST_FILE} I_file=${O_file} fi # to brake before the end #if [ "${test_number}" == "c-sharp_10010" ] #if [ "${test_number}" == "c_10005" ] #if [ "${test_number}" == "cpp_60042" ] #then # exit #fi done # save the last file of each test cp ${O_file} ${TOTALS_DIR}/${source_file}.total done else # do it directly, without intermediate files for source_file in ${SOURCES_LIST_CPP} do for test_number in ${NUMBER_LIST} do echo "source_file is ${source_file}: test_number=${test_number}" TEST_FILE=${test_number}/${source_file}.gcov TOTALS_FILE=${source_file} if [ -s ${TEST_FILE} ] ; then gawk --file ${COMPARE_AND_ADD} \ --assign in_file="${TOTALS_DIR}/${TOTALS_FILE}" \ --assign out_file="${TOTALS_DIR}/${TOTALS_FILE}" < ${TEST_FILE} fi # to brake before the end #if [ "${test_number}" == "c-sharp_10010" ] #if [ "${test_number}" == "c_10005" ] #if [ "${test_number}" == "cpp_60042" ] #then # exit #fi done done fi uncrustify-uncrustify-0.76.0/scripts/Run_clang-tidy.sh000077500000000000000000000141641434072136500231500ustar00rootroot00000000000000#!/bin/bash # # 2017-02-27 # script_dir="$(dirname "$(readlink -f "$0")")" # SRC="${script_dir}/../src" BUILD="${script_dir}/../build" # where=`pwd` # # build the lists cd ${SRC} list_of_C=`ls *.cpp` list_of_H=`ls *.h` list_of_files="${list_of_C} ${list_of_H}" cd ${where} # RESULTS="${script_dir}/../results" # rm -rf ${RESULTS} mkdir ${RESULTS} # COMPILE_COMMANDS="compile_commands.json" cp ${BUILD}/${COMPILE_COMMANDS} ${SRC} # # choise one of list of checks list_of_Check="\ boost-use-to-string\ cert-dcl21-cpp\ cert-dcl50-cpp\ cert-dcl58-cpp\ cert-env33-c\ cert-err34-c\ cert-err52-cpp\ cert-err58-cpp\ cert-err60-cpp\ cert-flp30-c\ cert-msc50-cpp\ cppcoreguidelines-interfaces-global-init\ cppcoreguidelines-no-malloc\ cppcoreguidelines-pro-bounds-array-to-pointer-decay\ cppcoreguidelines-pro-bounds-constant-array-index\ cppcoreguidelines-pro-bounds-pointer-arithmetic\ cppcoreguidelines-pro-type-const-cast\ cppcoreguidelines-pro-type-cstyle-cast\ cppcoreguidelines-pro-type-member-init\ cppcoreguidelines-pro-type-reinterpret-cast\ cppcoreguidelines-pro-type-static-cast-downcast\ cppcoreguidelines-pro-type-union-access\ cppcoreguidelines-pro-type-vararg\ cppcoreguidelines-slicing\ cppcoreguidelines-special-member-functions\ google-build-explicit-make-pair\ google-build-namespaces\ google-build-using-namespace\ google-default-arguments\ google-explicit-constructor\ google-global-names-in-headers\ google-readability-casting\ google-readability-todo\ google-runtime-int\ google-runtime-member-string-references\ google-runtime-memset\ google-runtime-operator\ google-runtime-references\ hicpp-explicit-conversions\ hicpp-function-size\ hicpp-invalid-access-moved\ hicpp-member-init\ hicpp-named-parameter\ hicpp-new-delete-operators\ hicpp-no-assembler\ hicpp-noexcept-move\ hicpp-special-member-functions\ hicpp-undelegated-constructor\ hicpp-use-equals-default\ hicpp-use-equals-delete\ hicpp-use-override\ llvm-header-guard\ llvm-include-order\ llvm-namespace-comment\ llvm-twine-local" #list_of_Check="misc-argument-comment\ # misc-assert-side-effect\ # misc-bool-pointer-implicit-conversion\ # misc-dangling-handle\ # misc-definitions-in-headers\ # misc-fold-init-type\ # misc-forward-declaration-namespace\ # misc-forwarding-reference-overload\ # misc-inaccurate-erase\ # misc-incorrect-roundings\ # misc-inefficient-algorithm\ # misc-macro-parentheses\ # misc-macro-repeated-side-effects\ # misc-misplaced-const\ # misc-misplaced-widening-cast\ # misc-move-const-arg\ # misc-move-constructor-init\ # misc-move-forwarding-reference\ # misc-multiple-statement-macro\ # misc-new-delete-overloads\ # misc-noexcept-move-constructor\ # misc-non-copyable-objects\ # misc-redundant-expression\ # misc-sizeof-container\ # misc-sizeof-expression\ # misc-static-assert\ # misc-string-compare\ # misc-string-constructor\ # misc-string-integer-assignment\ # misc-string-literal-with-embedded-nul\ # misc-suspicious-enum-usage\ # misc-suspicious-missing-comma\ # misc-suspicious-semicolon\ # misc-suspicious-string-compare\ # misc-swapped-arguments\ # misc-throw-by-value-catch-by-reference\ # misc-unconventional-assign-operator\ # misc-undelegated-constructor\ # misc-uniqueptr-reset-release\ # misc-unused-alias-decls\ # misc-unused-parameters\ # misc-unused-raii\ # misc-unused-using-decls\ # misc-use-after-move\ # misc-virtual-near-miss" #list_of_Check="modernize-avoid-bind\ # modernize-deprecated-headers\ # modernize-loop-convert\ # modernize-make-shared\ # modernize-make-unique\ # modernize-pass-by-value\ # modernize-raw-string-literal\ # modernize-redundant-void-arg\ # modernize-replace-auto-ptr\ # modernize-replace-random-shuffle\ # modernize-return-braced-init-list\ # modernize-shrink-to-fit\ # modernize-use-auto\ # modernize-use-bool-literals\ # modernize-use-default-member-init\ # modernize-use-emplace\ # modernize-use-equals-default\ # modernize-use-equals-delete\ # modernize-use-nullptr\ # modernize-use-override\ # modernize-use-transparent-functors\ # modernize-use-using\ # mpi-buffer-deref\ # mpi-type-mismatch\ # performance-faster-string-find\ # performance-for-range-copy\ # performance-implicit-cast-in-loop\ # performance-inefficient-string-concatenation\ # performance-inefficient-vector-operation\ # performance-type-promotion-in-math-fn\ # performance-unnecessary-copy-initialization\ # performance-unnecessary-value-param" #list_of_Check="readability-avoid-const-params-in-decls\ # readability-braces-around-statements\ # readability-container-size-empty\ # readability-delete-null-pointer\ # readability-deleted-default\ # readability-else-after-return\ # readability-function-size\ # readability-identifier-naming\ # readability-implicit-bool-cast\ # readability-inconsistent-declaration-parameter-name\ # readability-misleading-indentation\ # readability-misplaced-array-index\ # readability-named-parameter\ # readability-non-const-parameter\ # readability-redundant-control-flow\ # readability-redundant-declaration\ # readability-redundant-function-ptr-dereference\ # readability-redundant-member-init\ # readability-redundant-smartptr-get\ # readability-redundant-string-cstr\ # readability-redundant-string-init\ # readability-simplify-boolean-expr\ # readability-static-definition-in-anonymous-namespace\ # readability-uniqueptr-delete-release" # for file in ${list_of_files} do echo "test for "${file} OUTPUT="${RESULTS}/${file}.txt" for check in ${list_of_Check} do echo " test for "${check} clang-tidy -checks="-*, ${check}" -header-filter="./${SRC}/*" ${SRC}/${file} \ > ${OUTPUT} 2>/dev/null if [[ -s ${OUTPUT} ]] then head ${OUTPUT} break else rm -f ${OUTPUT} fi done done # rm ${SRC}/${COMPILE_COMMANDS} rmdir --ignore-fail-on-non-empty ${RESULTS} if [[ -d ${RESULTS} ]] then echo "some problem(s) are still present" exit 1 else echo "all clang-tidy are OK" exit 0 fi uncrustify-uncrustify-0.76.0/scripts/add_test_list.awk000066400000000000000000000033531434072136500232560ustar00rootroot00000000000000BEGIN { Test_Count = 0; count_cpp = split(sources_cpp, source_list_cpp, " "); printf("#count_cpp= %d\n", count_cpp); count_h = split(sources_h, source_list_h, " "); printf("#count_h= %d\n", count_h); } { theLine = $0; command = substr(theLine, 10); split(command, parts, " "); number = parts[1]; lang = substr(parts[4], 14); l_lang = length(lang); lang_2 = substr(lang, 1, l_lang - 1); config = substr(parts[5], 16); input_file = substr(parts[7], 15); printf("echo \"Run uncrustify: The TESTNUMBER is %s\"\n", number); printf("rm -rf %s\n", number); printf("mkdir %s\n", number); printf("cd %s\n", number); printf("mkdir save\n"); printf("../uncrustify -q -c \"../../tests/%s -f \"../../tests/%s -l %s -o /dev/null\n", config, input_file, lang_2); for (i = 1; i <= count_cpp; i++) { source_file = source_list_cpp[i]; function_file = sprintf("../CMakeFiles/uncrustify.dir/src/%s.gcno", source_file); printf("if [ -s %s ] ;\n", function_file); printf("then\n"); printf(" gcov %s 2> /dev/null 1> /dev/null\n", function_file, source_file); printf("fi\n"); printf("if [ -s %s.* ] ;\n", source_file); printf("then\n"); printf(" mv -f %s.* ./save/\n", source_file); printf("fi\n"); } for (i = 1; i <= count_h; i++) { source_file = source_list_h[i]; printf("if [ -s %s.* ] ;\n", source_file); printf("then\n"); printf(" mv -f %s.* ./save/\n", source_file); printf("fi\n"); } printf(" rm *.gcov\n"); printf(" mv save/* .\n"); printf("rmdir save\n"); printf("cd ..\n\n"); # to brake before the end #Test_Count = Test_Count + 1; #if ( Test_Count == 1000) { #if ( Test_Count == 109) { #if ( Test_Count == 2) { # printf("exit\n"); #} } uncrustify-uncrustify-0.76.0/scripts/check_options.py000066400000000000000000000044351434072136500231340ustar00rootroot00000000000000#! /usr/bin/env python # # Check the option usage. # Make sure the union member matches the option type. # from os.path import dirname, join, abspath from os import listdir, EX_OK, EX_DATAERR from fnmatch import filter # just use the first letter of the member name - should be unique map_access_type = { 'b': 'AT_BOOL', 'a': 'AT_IARF', 'n': 'AT_NUM', 'u': 'AT_UNUM', 'l': 'AT_LINE', 't': 'AT_POS', } map_option_type = {} # checks if while accessing the cpd.settings the right union accessor is used in the file def check_file(file_path): problems = 0 line_no = 0 fd = open(file_path, 'r') for line in fd: line_no += 1 pos_cpd_s = line.find('cpd.settings[UO_') pos_cpd_e = line[pos_cpd_s:].find(']') if pos_cpd_s > 0 and pos_cpd_e > 0: pos_option_s = pos_cpd_s + 13 pos_option_e = pos_cpd_s + pos_cpd_e option = line[pos_option_s : pos_option_e] union_access = line[pos_option_e + 2] if option in map_option_type and union_access in map_access_type: if map_option_type[option] != map_access_type[union_access]: print("%s [%d] %s should use %s not %s" % (file_path, line_no, option, map_option_type[option], map_access_type[union_access])) problems += 1 return problems def fill_map_option_type(file_path): # Read in all the options fd = open(file_path, 'r') for line in fd: if line.find('unc_add_option') > 0 and line.find('UO_') > 0: splits = line.split(',') if len(splits) >= 3: map_option_type[splits[1].strip()] = splits[2].strip() fd.close() def main(): src_dir = join(dirname(dirname(abspath(__file__))), 'src') fill_map_option_type(join(src_dir, 'options.cpp')) # Get a list of all the source files ld = listdir(src_dir) src_files = filter(ld, '*.cpp') src_files.extend(filter(ld, '*.h')) # Check each source file problems = 0 for fn in src_files: problems += check_file(join(src_dir, fn)) if problems == 0: print("No problems found") return EX_OK else: return EX_DATAERR if __name__ == '__main__': exit(main()) uncrustify-uncrustify-0.76.0/scripts/cmpcfg.pl000077500000000000000000000056171434072136500215340ustar00rootroot00000000000000#!/usr/bin/perl # # Copyright (c) 2006 David Thompson # da.thompson@yahoo.com # Fri Nov 17 20:41:23 PST 2006 # License: GPL # Purpose of this script is to process config files and # produce a comparision chart of values. The input files # are simple series of parameter definitions, of the form # 'name=value' pairs, whitespace and comments are correctly # ignored. Invoke on multiple config files to compare # parameter values for all files, try this, # cd /usr/local/share/uncrustify # cmpcfg.pl *.cfg # first build hashes from all input files # 1. %name is a master hash of all parameter names found # across all files, we use a hash to remember the keys, # we don't compare about the values stored for each key # 2. %table is a per file 2 dimensional hash array indexed # by the current filename and parameter; ie, this hash # stores the 'name=value' pairs on per file basis foreach my $file (@ARGV) { open FH, "<$file" or die "Can't open file: $file"; while () { chomp; next if (/^[ \t]*$/); # ignore blank lines next if (/^[ \t]*#/); # ignore comment lines s/#.*$//; # strip trailing comments s/^[ \t]*//; # strip leading whitespace s/[ \t]*$//; # strip trailing whitespace s/[ \t]*=[ \t]*/=/; # remove whitespace around '=' $_ = lc; # lowercase everything ($name, $value) = split /=/; # extract name and value $names{$name} = $name; # master hash of all names $table{$file}{$name} = $value; # per file hash of names } close FH; } # find longest parameter name # we'll use this later for report printing foreach $name (sort keys %names) { if (length($name) > $maxlen) { $maxlen = length($name); } } $maxlen += 4; # add extra padding # return string centered in specified width sub center { ($wid, $str) = @_; $flg = 0; while (length($str) < $wid) { if ($flg) { $flg = 0; $str = " " . $str; } else { $flg = 1; $str = $str . " "; } } return $str; } # print legend for filenames $cnt = 0; foreach $file (@ARGV) { $cnt++; print " <$cnt> $file\n"; } # blank line separates legend & header print "\n"; # print header line print " " x $maxlen . " "; $cnt = 0; foreach (@ARGV) { $cnt++; $fmt = "<$cnt>"; print " ".¢er(6, $fmt); } print "\n"; # print body of report, one line per parameter name foreach $name (sort keys %names) { printf "%-*s ", $maxlen, $name; foreach $file (@ARGV) { if (defined($table{$file}{$name})) { print " ".¢er(6, $table{$file}{$name}); } else { # parameter not defined for this file print " ".¢er(6, "*"); } } print "\n"; } uncrustify-uncrustify-0.76.0/scripts/compare_the_gcov.awk000066400000000000000000000103511434072136500237340ustar00rootroot00000000000000BEGIN { number_of_lines = 0; number_of_header = 0; T_number_of_lines = 0; T_number_of_header = 0; input_file = in_file; output_file = out_file; # # get the first line, if any. getline aaa 0) { # don't take care } else { where_2 = index(part_1, "#####"); if (where_2 > 0) { # don't take care } else { d_part_1 = part_1 + 0; # look at T_source_part1[part_2] where_3 = index(T_source_part1[part_2], "#####"); if (where_3 > 0) { sum = d_part_1; # write the sum to T_source_part1 T_source_part1[part_2] = d_part_1; } else { d_T = T_source_part1[part_2] + 0; sum = d_part_1 + d_T; # write the sum back to T_source_part1 T_source_part1[part_2] = sum; } } } } } END { if (first_run == "yes") { # copy to T_ T_number_of_header = number_of_header; T_number_of_lines = number_of_lines; for(i = 1; i <= T_number_of_header; i++) { T_header_part1[i] = header_part1[i]; T_header_part2[i] = header_part2[i]; T_header_part3[i] = header_part3[i]; } for (i = 1; i <= T_number_of_lines; i++) { T_source_part1[i] = source_part1[i]; T_source_part2[i] = source_part2[i]; T_source_part3[i] = source_part3[i]; } } #printf("T_number_of_header is %d\n", T_number_of_header); #printf("T_number_of_lines is %d\n", T_number_of_lines); # delete the previous version printf("") > output_file; for(i = 1; i <= T_number_of_header; i++) { printf("%9s:%5d:%s\n", T_header_part1[i], T_header_part2[i], T_header_part3[i]) >> output_file; } for (i = 1; i <= T_number_of_lines; i++) { printf("%9s:%5d:%s\n", T_source_part1[i], T_source_part2[i], T_source_part3[i]) >> output_file; } close(output_file); } uncrustify-uncrustify-0.76.0/scripts/gen_changelog.py000077500000000000000000000073541434072136500230720ustar00rootroot00000000000000#!/usr/bin/env python ''' This script attempts to extract what options have been added since the specified revision (usually a tag, but any revision that git recognizes may be provided). It accepts an optional second revision to use as the cut-off. The default is your LOCAL "master". Thus, you should ensure that this is up to date before running this script. This script works by extracting the set of options before and after every commit that affected ':src/options.h' and computing the differences. It should, therefore, be fairly robust (for example, options that moved around won't show up). However, if an option is removed and subsequently re-added, or if an option was added and subsequently removed, the resulting records will need to be reconciled manually. ''' import argparse import git import os import re import sys import time re_option = re.compile(r'extern (Bounded)?Option<[^>]+>') # ----------------------------------------------------------------------------- def extract_options(repo, blob_id): from git.util import hex_to_bin blob = git.Blob(repo, hex_to_bin(blob_id)) content = blob.data_stream.stream options = set() for line in iter(content.readline, b''): line = line.decode('utf-8').strip() if re_option.match(line): line = content.readline().decode('utf-8').strip() options.add(line.split(';')[0]) return options # ============================================================================= class Changeset(object): # ------------------------------------------------------------------------- def __init__(self, repo, sha): self.sha = sha self.added_options = set() self.removed_options = set() commit = repo.commit(sha) ad = time.gmtime(commit.authored_date) self.date = time.strftime('%b %d %Y', ad).replace(' 0', ' ') info = repo.git.log('-1', '--raw', '--abbrev=40', '--pretty=', sha, '--', ':src/options.h').split(' ') if len(info) < 5: return old_options = extract_options(repo, info[2]) new_options = extract_options(repo, info[3]) self.added_options = new_options.difference(old_options) self.removed_options = old_options.difference(new_options) # ----------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser( description='Generate changelog for new options') root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) parser.add_argument('--repo', type=str, default=root, help='Path to uncrustify git repository') parser.add_argument('since', type=str, help='Revision (tag) of previous uncrustify version') parser.add_argument('until', type=str, default='master', nargs='?', help='Revision (tag) of next uncrustify version') args = parser.parse_args() repo = git.Repo(args.repo) revs = repo.git.log('--pretty=%H', '--reverse', '{}..{}'.format(args.since, args.until), '--', ':src/options.h').split('\n') if revs == ['']: print('No changes were found') return 1 changes = [] for r in revs: c = Changeset(repo, r) if len(c.added_options) or len(c.removed_options): changes.append(c) for c in changes: print(c.sha) for o in c.added_options: print(' Added : {:36} {}'.format(o, c.date)) for o in c.removed_options: print(' Removed : {:36} {}'.format(o, c.date)) return 0 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if __name__ == '__main__': sys.exit(main()) uncrustify-uncrustify-0.76.0/scripts/gen_config_combinations_uniq_output.py000066400000000000000000000406731434072136500276270ustar00rootroot00000000000000from __future__ import print_function # python >= 2.6 from os import makedirs, path, listdir, rename, remove from subprocess import Popen from filecmp import cmp from glob import iglob from shutil import rmtree from json import loads as json_loads, dump as json_dump from sys import stderr, argv, path as sys_path """ gen_config_combinations_uniq_output.py Creates from a given set of options all possible option settings combinations, formats files with those and displays how much non equal formatted outputs have been created. Expects arg1 to be a filepath to a json config file (see config example below) :author: Daniel Chumak :license: GPL v2+ """ # config = { # "option_settings": { # "AT_BOOL": ["False", "True"], # "AT_IARF": ["ignore", "add", "remove", "force"], # "AT_POS": ["ignore", "join", "lead", "lead_break", "lead_force", # "trail", "trail_break", "trail_force"], # "AT_LINE": ["auto", "lf", "crlf", "cr"], # "AT_NUM": [-2, -1, 0, 1, 2, 3], # "AT_UNUM": [0, 1, 2, 3] # }, # "options": [{ # "name": "nl_func_type_name", # "type": "AT_IARF" # }, { # "name": "nl_template_class", # "type": "AT_IARF" # }], # "out_dir": "./Out", # "in_files": ["./t.cpp", "./t2.cpp"], # "unc_bin": "../build/uncrustify", # "cleanup_lvl": 2, # "force_cleanup": false, # "json_output": false # } # def len_index_combinations(max_indices): """generator function that yields a list starting from n_0 = 0, ... n_m-1 = 0, n_m = 0 ... n_0 = 0, ... n_m-1 = 0, n_m = n_m_max ... n_0 = 0, ... n_m-1 = 1, n_m = 0 n_0 = 0, ... n_m-1 = 1, n_m = 1 ... n_0 = 0, ... n_m-1 = n_m-1_max, n_m = n_m_max ... n_0 = n_0_max, ... n_m-1 = n_m-1_max, n_m = n_m_max :param max_indices: list of max values every position is going to reach :yield: list of values at the current step """ fields = len(max_indices) accu = [0] * fields # increment last position n, on max val move pos by one (n-1) and increment # if (n-1) is max move again (n-2) and increment, ... pos = fields while pos >= 0: yield (accu) pos = fields - 1 accu[pos] += 1 # on reaching max reset value, move pos and increment at pos while pos >= 0 and accu[pos] >= max_indices[pos]: accu[pos] = 0 pos -= 1 if pos >= 0: accu[pos] += 1 def write_config_files(config): """Writes a configuration file for each possible combination of 'option' settings :param config: configuration object, expects that it was processed by check_config """ options_len = len(config["options"]) # populate len_options with amount of settings for the types of each option len_options = [0] * options_len for i in range(options_len): option_setting = config["options"][i]["type"] len_options[i] = len(config["option_settings"][option_setting]) # write configuration files, one per possible combination for combination in len_index_combinations(len_options): len_indices = len(combination) # generate output filepath file_path = config['out_dir'] + "/" for i in range(len_indices): option_name = config["options"][i]["name"] file_path += ("%s__" % option_name) for i in range(len_indices): option_type = config["options"][i]["type"] option_setting = combination[i] file_path += ("%d__" % option_setting) file_path += "unc.cfg" # write configuration file with open(file_path, 'w') as f: for i in range(len_indices): option_name = config["options"][i]["name"] option_type = config["options"][i]["type"] option_setting = config["option_settings"][option_type][ combination[i]] f.write("%s = %s\n" % (option_name, option_setting)) def gen_equal_output_map(config): """Formats 'in_files' with configs inside the 'out_dir' with Uncrustify and groups formatted files with equal content together. Expects config filename format generated by write_config_files :param config: configuration object, expects that it was processed by check_config :return: dict of files with equal content key -- group index value -- filepath list """ # maps that will hold configurations that produce the same formatted files equal_output_map = {} # map len counter map_val_idx = 0 # iterate through all generated config file names for cfg_path in sorted(iglob('%s/*.cfg' % config["out_dir"])): for in_file_idx in range(len(config["in_files"])): # extract substring form config gile name (removes __unc.cfg) splits_file = cfg_path.split("__unc") if len(splits_file) < 1: raise Exception('split with "__unc" | Wrong split len: %d' % len(splits_file)) out_path = ("%s__%d" % (splits_file[0], in_file_idx)) # gen formatted files with uncrustify binary proc = Popen([config["unc_bin"], "-c", cfg_path, "-f", config["in_files"][in_file_idx], "-o", out_path, ]) proc.wait() if proc.returncode != 0: continue # populate 'equal_output_map' map if len(equal_output_map) == 0: equal_output_map[0] = [out_path] map_val_idx += 1 else: found_flag = False for i in range(map_val_idx): # compare first file of group i with the generated file if cmp(equal_output_map[i][0], out_path): equal_output_map[i].append(out_path) found_flag = True break # create new group if files do not match if not found_flag: equal_output_map[map_val_idx] = [out_path] map_val_idx += 1 return equal_output_map def gen_output_dict(config, equal_output_map): """Makes an output dict with the generated results. :param config: configuration object, expects that it was processed by check_config :param equal_output_map: dict of files with equal content, expects format generated by gen_equal_output_map :return: output dict, format: copies objects option_settings, options and in_files (renamed as files) from the config object. Additionally has the object groups that holds gourp - file - settings combination data format: groups = [ [fileIdx0[ [settingIdx0, settingIdx1, ...], [settingIdx0, settingIdx1, ...] ] ] [fileIdx1[ [settingIdx0, settingIdx1, ...], [settingIdx0, settingIdx1, ...] ] ] ] """ output_dict = {"option_settings": config["option_settings"], "options": config["options"], "files": config["in_files"], "groups": []} options_len = len(output_dict["options"]) files_len = len(output_dict["files"]) for key in equal_output_map: group_dict = [] for file_arr_idx in range(files_len): group_dict.append([]) for list_value in equal_output_map[key]: split = list_value.rsplit("/", 1) split = split[len(split) - 1].split("__") split_len = len(split) # n option names + n option values + file idx if split_len < options_len * 2 + 1: print(" wrong split len on %s\n" % list_value, file=stderr) continue file_idx = int(split[split_len - 1]) file_combinations = [int(i) for i in split[options_len:split_len-1]] group_dict[file_idx].append(file_combinations) output_dict["groups"].append(group_dict) return output_dict def write_output_dict_pretty(out_dict, out_path): """pretty prints the output dict into a file :param out_dict: dict that will be printed, expects format generated by gen_output_dict :param out_path: output filepath """ group_id = 0 options_len = len(out_dict["options"]) with open(out_path, 'w') as f: f.write("Files:\n") for in_file_idx in range(len(out_dict["files"])): f.write(" %d: %s\n" % (in_file_idx, out_dict["files"][in_file_idx])) f.write("\nOptions:\n") for option_idx in range(options_len): f.write(" %d: %s\n" % (option_idx, out_dict["options"][option_idx]["name"])) f.write("\n\n") for group in out_dict["groups"]: f.write("Group: %d\n" % group_id) group_id += 1 for file_idx in range(len(group)): file = group[file_idx] for combinations in file: combination_strings = [] for combination_idx in range(len(combinations)): combination_id = combinations[combination_idx] combination_string = out_dict["option_settings"][ out_dict["options"][combination_idx]["type"]][ combination_id] combination_strings.append(str(combination_string)) f.write(" (%s: %s)\n" % (file_idx, " - ".join(combination_strings))) f.write("\n") def load_config(file_path): """reads a file and parses it as json :param file_path: path to the json file :return: json object """ with open(file_path, 'r') as f: string = f.read() json = json_loads(string) return json def make_abs_path(basis_abs_path, rel_path): return path.normpath(path.join(basis_abs_path, rel_path)) def check_config(config, cfg_path=""): """checks if the provided config has all needed options, sets default settings for optional options and transform relative paths into absolute paths. :param config: config dict that will be checked :param cfg_path: if not empty transforms relative to absolute paths, paths will be based upon the cfg_path. """ extend_relative_paths = True if len(cfg_path) > 0 else False cfg_path = path.abspath(path.dirname(cfg_path)) # -------------------------------------------------------------------------- if "option_settings" not in config: raise Exception("config file: 'option_settings' missing") if len(config["option_settings"]) == 0: raise Exception("config file: 'option_settings' values missing") # -------------------------------------------------------------------------- if "options" not in config: raise Exception("config file: 'options' missing") if len(config["options"]) < 2: raise Exception("config file: 'options' min. two options needed") for option_obj in config["options"]: if "name" not in option_obj: raise Exception("config file: 'options[{}]' name missing") if "type" not in option_obj: raise Exception("config file: 'options[{}]' type missing") if option_obj["type"] not in config["option_settings"]: raise Exception("config file: 'options[{type='%s'}]' not in option_" "settings" % option_obj["type"]) # -------------------------------------------------------------------------- if "out_dir" not in config: raise Exception("config file: 'out_dir' missing") if len(config['out_dir']) == 0: raise Exception("config file: 'out_dir' value missing") if extend_relative_paths and not path.isabs(config['out_dir']): config['out_dir'] = make_abs_path(cfg_path, config['out_dir']) # -------------------------------------------------------------------------- if "in_files" not in config: raise Exception("config file: 'in_files' missing") if len(config['in_files']) == 0: raise Exception("config file: 'in_files' values missing") for file_idx in range(len(config['in_files'])): if extend_relative_paths and not path.isabs( config['in_files'][file_idx]): config['in_files'][file_idx] = make_abs_path(cfg_path, config['in_files'][ file_idx]) if not path.isfile(config['in_files'][file_idx]): raise Exception("config file: '%s' is not a file" % config['in_files'][file_idx]) # -------------------------------------------------------------------------- if "unc_bin" not in config: raise Exception("config file: 'in_files' missing") if extend_relative_paths and not path.isabs(config['unc_bin']): config['unc_bin'] = make_abs_path(cfg_path, config['unc_bin']) if not path.isfile(config['unc_bin']): raise Exception("config file: '%s' is not a file" % config['unc_bin']) # Optional ----------------------------------------------------------------- if "cleanup_lvl" not in config: config["cleanup_lvl"] = 1 if "force_cleanup" not in config: config["force_cleanup"] = False if "json_output" not in config: config["json_output"] = False def cleanup(level, eq_map, clean_target_dir, keep_files=()): """cleans up output_dir :param level: 0 - do nothing, 1 - keep `keep_files` and 1 file for each group, 2 - remove everything :param equal_output_map: dict of files with equal content, expects format generated by gen_equal_output_map :param clean_target_dir: directory which content will be cleaned :param keep_files: list of files should not be removed """ if level == 0: return if level == 2: rmtree(clean_target_dir) if level == 1: rm_files = [clean_target_dir + "/" + f for f in listdir(clean_target_dir)] for f in keep_files: rm_files.remove(f) for idx in eq_map: old_path = eq_map[idx][0] new_path = ("%s/g_%d" % (path.dirname(path.abspath(old_path)), idx)) rename(old_path, new_path) try: rm_files.remove(old_path) except ValueError: pass # ignore that it is missing try: rm_files.remove(new_path) except ValueError: pass # ignore that it is missing for f in rm_files: remove(f) def main(args): config = load_config(args[0]) check_config(config, args[0]) # gen output directory if path.isfile(config["out_dir"]): raise Exception("%s is a file" % config["out_dir"]) if not path.isdir(config["out_dir"]): makedirs(config["out_dir"]) elif not config["force_cleanup"] and config["cleanup_lvl"] > 0: raise Exception("cleanup_lvl > 0 on an existing directory: %s" % config["out_dir"]) write_config_files(config) eq_map = gen_equal_output_map(config) output_dict = gen_output_dict(config, eq_map) # write output as txt file output_dict_path = path.join(config["out_dir"], "out.txt") write_output_dict_pretty(output_dict, output_dict_path) # read ouput txt file to print it with open(output_dict_path, 'r') as f: print() print(f.read()) keep_files = [output_dict_path] # write output as json file if config["json_output"]: output_dict_json_path = path.join(config["out_dir"], "out.json") with open(output_dict_json_path, 'w') as f: json_dump(output_dict, f) keep_files.append(output_dict_json_path) # clean output directory cleanup(config["cleanup_lvl"], eq_map, config["out_dir"], keep_files) if __name__ == "__main__": main(argv[1:]) uncrustify-uncrustify-0.76.0/scripts/gen_config_combinations_uniq_output_example.json000066400000000000000000000014111434072136500316460ustar00rootroot00000000000000{ "option_settings": { "AT_BOOL": ["False", "True"], "AT_IARF": ["ignore", "add", "remove", "force"], "AT_POS": ["ignore", "join", "lead", "lead_break", "lead_force", "trail", "trail_break", "trail_force" ], "AT_LINE": ["auto", "lf", "crlf", "cr"], "AT_NUM": [-2, -1, 0, 1, 2, 3], "AT_UNUM": [0, 1, 2, 3] }, "options": [{ "name": "nl_func_type_name", "type": "AT_IARF" }, { "name": "nl_template_class", "type": "AT_IARF" }], "out_dir": "./out_uniq_outputs", "in_files": ["../src/uncrustify.cpp", "../src/width.h"], "unc_bin": "../build/uncrustify", "cleanup_lvl" : 0, "force_cleanup": false, "json_output": false } uncrustify-uncrustify-0.76.0/scripts/grammar_permutator.py000077500000000000000000000045771434072136500242260ustar00rootroot00000000000000#!/usr/bin/python import argparse from nltk.parse.generate import generate from nltk import CFG from os.path import exists from sys import exit as sys_exit DEMO_GRAMMAR = """ S -> 'import ' ImportList ';' | 'static import ' ImportList ';' ImportList -> Import | ImportBindings | Import ', ' ImportList Import -> ModuleFullyQualifiedName | ModuleAliasIdentifier ' = ' ModuleFullyQualifiedName ImportBindings -> Import ' : ' ImportBindList ImportBindList -> ImportBind | ImportBind ', ' ImportBindList ImportBind -> Identifier | Identifier ' = ' Identifier ModuleAliasIdentifier -> Identifier Packages -> PackageName | Packages '.' PackageName ModuleFullyQualifiedName -> ModuleName | Packages '.' ModuleName PackageName -> Identifier ModuleName -> Identifier Identifier -> 'x' """ def valid_file(arg_parser, *args): """ checks if on of the provided paths is a file Parameters ---------------------------------------------------------------------------- :param arg_parser: argument parser object that is called if no file is found :param args: list< str > a list of file path that is going to be checked :return: str ---------------------------------------------------------------------------- path to an existing file """ arg = None found_flag = False for arg in args: if exists(arg): found_flag = True break if not found_flag: arg_parser.error("file(s) do not exist: %s" % args) return arg def main(args): grammar_string = DEMO_GRAMMAR if args.input_file_path: with open(args.input_file_path, 'r') as f: grammar_string = f.read() grammar = CFG.fromstring(grammar_string) for sentence in generate(grammar, depth=args.depth): print(''.join(sentence)) return 0 if __name__ == "__main__": arg_parser = argparse.ArgumentParser() arg_parser.add_argument( '-i', '--input_file_path', metavar='', type=lambda x: valid_file(arg_parser, x), help="Path to the grammar file", required=False ) arg_parser.add_argument( '-d', '--depth', metavar='', type=int, default=9, help='Max depth of grammar tree.' ) FLAGS, unparsed = arg_parser.parse_known_args() sys_exit(main(FLAGS)) uncrustify-uncrustify-0.76.0/scripts/make_katehl.py000077500000000000000000000115021434072136500225450ustar00rootroot00000000000000#!/usr/bin/env python import argparse import io import os import re re_token = re.compile(r'^CT_(\w+),') re_version = re.compile(r'.*UNCRUSTIFY_VERSION\s*"Uncrustify-([^"]+)"') re_option = re.compile(r'extern (Bounded)?Option<[^>]+>') re_enum_decl = re.compile(r'enum class (\w+)( *// *<(\w+)>)?') re_enum_value = re.compile(r'(\w+)(?= *([,=]|//|$))') re_aliases = re.compile(r'UNC_OPTVAL_ALIAS\(([^)]+)\)') version = '0.0' options = set() values = set() tokens = set() root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) script = os.path.relpath(__file__, root) # ----------------------------------------------------------------------------- def read_enum(f): global values for line in iter(f.readline, ''): line = line.strip() if line.startswith('{'): for line in iter(f.readline, ''): line = line.strip() if line.startswith('};'): return if 'UNC_INTERNAL' in line: return if 'UNC_CONVERT_INTERNAL' in line: return mv = re_enum_value.match(line) if mv is not None: values.add(mv.group(1).lower()) # ----------------------------------------------------------------------------- def write_items(out, items): for i in sorted(items): out.write(u' {}\n'.format(i)) # ----------------------------------------------------------------------------- def write_options(out, args): write_items(out, options) # ----------------------------------------------------------------------------- def write_values(out, args): write_items(out, values) # ----------------------------------------------------------------------------- def write_tokens(out, args): write_items(out, tokens) # ----------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser(description='Generate uncrustify.xml') parser.add_argument('output', type=str, help='location of uncrustify.xml to write') parser.add_argument('template', type=str, help='location of uncrustify.xml.in ' + 'to use as template') parser.add_argument('version', type=str, help='location of uncrustify_version.h to read') parser.add_argument('options', type=str, help='location of options.h to read') parser.add_argument('optvals', type=str, help='location of option.h to read') parser.add_argument('tokens', type=str, help='location of token_enum.h to read') args = parser.parse_args() # Read version with io.open(args.version, 'rt', encoding='utf-8') as f: global version for line in iter(f.readline, ''): line = line.strip() mv = re_version.match(line) if mv: version = mv.group(1) # Read options with io.open(args.options, 'rt', encoding='utf-8') as f: global options for line in iter(f.readline, ''): line = line.strip() if re_option.match(line): n, d = f.readline().split(';') options.add(n) # Read option values with io.open(args.optvals, 'rt', encoding='utf-8') as f: global values for line in iter(f.readline, ''): line = line.strip() if re_enum_decl.match(line): read_enum(f) continue ma = re_aliases.match(line) if ma: for v in ma.group(1).split(',')[2:]: v = v.strip()[1:-1] values.add(v) # Read tokens with io.open(args.tokens, 'rt', encoding='utf-8') as f: global tokens for line in iter(f.readline, ''): line = line.strip() m = re_token.match(line) if m and not m.group(1).endswith(u'_'): tokens.add(m.group(1).lower()) # Declare replacements replacements = { u'##OPTION_KEYWORDS##': write_options, u'##VALUE_KEYWORDS##': write_values, u'##TOKEN_TYPE_KEYWORDS##': write_tokens, } # Write output file with io.open(args.output, 'wt', encoding='utf-8') as out: with io.open(args.template, 'rt', encoding='utf-8') as t: for line in t: directive = line.strip() if directive in replacements: replacements[directive](out, args) else: if '##VERSION##' in line: line = line.replace('##VERSION##', version) out.write(line) # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if __name__ == '__main__': main() uncrustify-uncrustify-0.76.0/scripts/make_option_enum.py000066400000000000000000000156661434072136500236450ustar00rootroot00000000000000#!/usr/bin/env python import argparse import io import os import re re_enum_decl = re.compile(r'enum class (\w+)( *// *<(\w+)>)?') re_enum_value = re.compile(r'(\w+)(?= *([,=]|//|$))') re_values = re.compile(r'UNC_OPTVALS\((\w+)\)') re_aliases = re.compile(r'UNC_OPTVAL_ALIAS\(([^)]+)\)') enums = {} values = {} root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) script = os.path.relpath(__file__, root) # ============================================================================= class Enumeration(object): # ------------------------------------------------------------------------- def __init__(self, name, prefix, f): self.name = name self.prefix = prefix self.values = [] self.value_aliases = {} self.convert_internal = False for line in iter(f.readline, ''): line = line.strip() if line.startswith('{'): for line in iter(f.readline, ''): line = line.strip() if line.startswith('};'): return if 'UNC_INTERNAL' in line: return if 'UNC_CONVERT_INTERNAL' in line: self.convert_internal = True continue mv = re_enum_value.match(line) if mv is not None: v = mv.group(1) self.values.append(v) self.value_aliases[v] = [v.lower()] # ------------------------------------------------------------------------- def add_aliases(self, value, *args): aliases = [x[1:-1] for x in args] # strip quotes self.value_aliases[value] += aliases # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% # ----------------------------------------------------------------------------- def enum_value(enum, value): if enum.prefix is not None: return u'{}_{}'.format(enum.prefix, value) return value # ----------------------------------------------------------------------------- def write_banner(out, args): out.write( u'/**\n' u' * @file {out_name}\n' u' * Helpers for option enumerators.\n' u' * Automatically generated by {script}\n' u' * from {in_name}.\n' u' */\n' u'\n'.format( in_name=os.path.basename(args.header), out_name=os.path.basename(args.output), script=script)) # ----------------------------------------------------------------------------- def write_value_strings(out, args): for vn, vs in values.items(): out.write(u'const char *const {}_values[] = {{\n'.format(vn)) out.write(u'{}\n nullptr\n}};\n\n'.format( u'\n'.join([u' "{}",'.format(x.lower()) for x in vs]))) # ----------------------------------------------------------------------------- def write_aliases(out, args): for enum in enums.values(): if enum.prefix is None: continue for v in enum.values: out.write(u'constexpr auto {p}_{v} = {n}::{v};\n'.format( p=enum.prefix, n=enum.name, v=v)) out.write(u'\n') # ----------------------------------------------------------------------------- def write_conversions(out, args): header = u'\n//{}\n'.format('-' * 77) for enum in enums.values(): if enum.convert_internal: continue out.write(header) out.write( u'bool convert_string(const char *in, {} &out)\n'.format( enum.name)) out.write( u'{\n' u' if (false)\n' u' {\n' u' }\n') for v in enum.values: for a in enum.value_aliases[v]: out.write( u' else if (strcasecmp(in, "{}") == 0)\n' u' {{\n' u' out = {};\n' u' return(true);\n' u' }}\n'.format(a, enum_value(enum, v))) out.write( u' else\n' u' {\n' u' return(false);\n' u' }\n' u'}\n\n') for enum in enums.values(): out.write(header) out.write(u'const char *to_string({} val)\n'.format(enum.name)) out.write(u'{\n' u' switch (val)\n' u' {\n') for v in enum.values: vs = v if enum.convert_internal else v.lower() out.write( u' case {}:\n' u' return "{}";\n\n'.format( enum_value(enum, v), vs)) out.write( u' default:\n' u' fprintf(stderr, "%s: Unknown {} \'%d\'\\n",\n' u' __func__, static_cast(val));\n' u' log_flush(true);\n' u' exit(EX_SOFTWARE);\n' u' }}\n' u'}}\n\n'.format(enum.name)) # ----------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser(description='Generate options.cpp') parser.add_argument('output', type=str, help='location of options.cpp to write') parser.add_argument('header', type=str, help='location of options.h to read') parser.add_argument('template', type=str, help='location of option_enum.cpp.in ' 'to use as template') args = parser.parse_args() with io.open(args.header, 'rt', encoding='utf-8') as f: for line in iter(f.readline, ''): line = line.strip() me = re_enum_decl.match(line) if me is not None: e = Enumeration(me.group(1), me.group(3), f) enums[e.name] = e continue mv = re_values.match(line) if mv is not None: enum_name = mv.group(1) enum = enums['{}_e'.format(enum_name)] values[enum_name] = enum.values ma = re_aliases.match(line) if ma is not None: alias_args = [x.strip() for x in ma.group(1).split(',')] enum = enums[alias_args[0]] enum.add_aliases(*alias_args[1:]) replacements = { u'##BANNER##': write_banner, u'##VALUE_STRINGS##': write_value_strings, u'##ALIASES##': write_aliases, u'##CONVERSIONS##': write_conversions, } with io.open(args.output, 'wt', encoding='utf-8') as out: with io.open(args.template, 'rt', encoding='utf-8') as t: for line in t: directive = line.strip() if directive in replacements: replacements[directive](out, args) else: out.write(line) # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if __name__ == '__main__': main() uncrustify-uncrustify-0.76.0/scripts/make_options.py000077500000000000000000000117101434072136500227710ustar00rootroot00000000000000#!/usr/bin/env python import argparse import io import os import re max_name_len = 60 re_name = re.compile(r'^[a-z][a-z0-9_]*$') re_group = re.compile(r'//BEGIN') re_option = re.compile(r'extern (Bounded)?Option<[^>]+>') re_default = re.compile(r' *// *= *(.*)') groups = [] root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) script = os.path.relpath(__file__, root) # ============================================================================= class Group(object): # ------------------------------------------------------------------------- def __init__(self, desc): self.desc = desc self.options = [] # ------------------------------------------------------------------------- def append(self, option): self.options.append(option) # ============================================================================= class Option(object): # ------------------------------------------------------------------------- def __init__(self, name, dval, decl, desc): if re_name.match(name) is None: raise ValueError('{!r} is not a valid option name'.format(name)) if len(name) > max_name_len: raise ValueError( '{!r} (length={:d}) exceeds the maximum length {:d}'.format( name, len(name), max_name_len)) self.desc = u'\n'.join(desc) self.decl = decl[7:] self.name = name self.dval = dval # ------------------------------------------------------------------------- def write_declaration(self, out): out.write(u'{} {} = {{\n'.format(self.decl, self.name)) out.write(u' "{}",\n'.format(self.name)) out.write(u' u8R"__(\n{}\n)__"'.format(self.desc)) if self.dval is not None: out.write(u',\n {}'.format(self.dval)) out.write(u'\n};\n\n') # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% # ----------------------------------------------------------------------------- def extract_default(decl): m = re_default.match(decl) if m: return m.group(1) return None # ----------------------------------------------------------------------------- def write_banner(out, args): out.write( u'/**\n' u' * @file {out_name}\n' u' * Declaration and initializers for all options.\n' u' * Automatically generated by {script}\n' u' * from {in_name}.\n' u' */\n' u'\n'.format( in_name=os.path.basename(args.header), out_name=os.path.basename(args.output), script=script)) # ----------------------------------------------------------------------------- def write_declarations(out, args): for group in groups: for option in group.options: option.write_declaration(out) # ----------------------------------------------------------------------------- def write_registrations(out, args): for group in groups: out.write(u'\n begin_option_group(u8R"__(\n{}\n)__");\n\n'.format( group.desc)) for option in group.options: out.write(u' register_option(&options::{});\n'.format( option.name)) # ----------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser(description='Generate options.cpp') parser.add_argument('output', type=str, help='location of options.cpp to write') parser.add_argument('header', type=str, help='location of options.h to read') parser.add_argument('template', type=str, help='location of options.cpp.in to use as template') args = parser.parse_args() with io.open(args.header, 'rt', encoding='utf-8') as f: desc = [] for line in iter(f.readline, ''): line = line.strip() if re_group.match(line): groups.append(Group(line[8:])) elif not len(line): desc = [] elif line == '//': desc.append('') elif line.startswith('// '): desc.append(line[3:]) elif re_option.match(line): n, d = f.readline().split(';') o = Option(n, extract_default(d.strip()), line, desc) groups[-1].append(o) replacements = { u'##BANNER##': write_banner, u'##DECLARATIONS##': write_declarations, u'##REGISTRATIONS##': write_registrations, } with io.open(args.output, 'wt', encoding='utf-8') as out: with io.open(args.template, 'rt', encoding='utf-8') as t: for line in t: directive = line.strip() if directive in replacements: replacements[directive](out, args) else: out.write(line) # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if __name__ == '__main__': main() uncrustify-uncrustify-0.76.0/scripts/make_punctuator_table.py000077500000000000000000000130731434072136500246550ustar00rootroot00000000000000#! /usr/bin/env python # # Creates a possibly faster lookup table for tokens, etc. # # @author Ben Gardner # @author Matthew Woehlke # @license GPL v2+ # import argparse import os import sys # ----------------------------------------------------------------------------- def scan_file(file_path): cur_token = '' token_idx = 0 args = [] fd = open(file_path, 'r') for line in fd: line = line.strip() if line.startswith('static const chunk_tag_t'): idx = line.find('[') if idx > 0: cur_token = line[25:idx].strip() token_idx = 0 else: if len(cur_token) > 0: idx1 = line.find('{') idx2 = line.find('CT_') if idx1 >= 0 and idx2 > idx1: tok = line[idx1 + 1:idx2].strip() if tok.startswith('R"'): pos_paren_open = tok.find('(') pos_paren_close = tok.rfind(')') if pos_paren_open == -1 or pos_paren_close == -1: sys.stderr.write( 'raw string parenthesis not found\n') sys.exit(-1) tok = tok[pos_paren_open+1:pos_paren_close] else: tok = tok[1:-2] # strip off open quotes and commas args.append([tok, '%s[%d]' % (cur_token, token_idx)]) token_idx += 1 return args # ----------------------------------------------------------------------------- def build_table(db, prev, arr): # do the current level first k = sorted(db) if len(k) <= 0: return k.sort() start_idx = len(arr) num_left = len(k) for i in k: en = db[i] # [ char, full-string, left-in-group, next_index, table-entry ] num_left -= 1 arr.append([en[0], prev + en[0], num_left, 0, en[2]]) # update the one-up level index if len(prev) > 0: for idx in range(0, len(arr)): if arr[idx][1] == prev: arr[idx][3] = start_idx break # Now do each sub level for i in k: en = db[i] build_table(en[3], prev + en[0], arr) # ----------------------------------------------------------------------------- def add_to_db(entry, db_top): """ find or create the entry for the first char """ strng = entry[0] db_cur = db_top for idx in range(0, len(strng)): if not strng[idx] in db_cur: db_cur[strng[idx]] = [strng[idx], 0, None, {}] dbe = db_cur[strng[idx]] if idx == len(strng) - 1: dbe[2] = entry else: db_cur = dbe[3] # ----------------------------------------------------------------------------- def quote(s): return '\'{}\''.format(s) # ----------------------------------------------------------------------------- def escape(s): return quote(s.replace('\'', '\\\'')) # ----------------------------------------------------------------------------- def write_entry(out, max_len, ch, left_in_group, next_idx, tag, idx, tok): out.write( ' {{ {:>4}, {:>3d}, {:>3d}, {:{}} }}, // {:3d}: {}'.format( ch, left_in_group, next_idx, tag, max_len, idx, tok).rstrip()) out.write('\n') # ----------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser(description='Generate punctuator_table.h') parser.add_argument('output', type=str, help='location of punctuator_table.h to write') parser.add_argument('header', type=str, help='location of symbols_table.h to read') args = parser.parse_args() root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) pl = scan_file(args.header) pl.sort() db = {} for a in pl: add_to_db(a, db) arr = [] build_table(db, '', arr) max_len = len('nullptr') for i in arr: rec = i[4] if rec is not None and (len(rec[1]) + 1) > max_len: max_len = len(rec[1]) + 1 in_name = os.path.basename(args.header) out_name = os.path.basename(args.output) guard = out_name.replace('.', '_').upper() with open(args.output, 'wt') as out: out.write( '/**\n' ' * @file {out_name}\n' ' * Automatically generated by {script}\n' ' * from {in_name}.\n' ' */\n' '\n' '#ifndef SRC_{guard}_\n' '#define SRC_{guard}_\n' '\n' '// *INDENT-OFF*\n' 'static const lookup_entry_t punc_table[] =\n' '{{\n'.format( in_name=in_name, out_name=out_name, guard=guard, script=os.path.relpath(__file__, root))) idx = 0 for i in arr: rec = i[4] if len(i[0]) == 0: write_entry(out, max_len, '0', '0', '0', 'nullptr', idx, '') elif rec is None: write_entry(out, max_len, escape(i[0]), i[2], i[3], 'nullptr', idx, quote(i[1])) else: write_entry(out, max_len, escape(i[0]), i[2], i[3], '&' + rec[1], idx, quote(i[1])) idx += 1 out.write( '}};\n' '// *INDENT-ON*\n' '\n' '#endif /* SRC_{guard}_ */\n'.format(guard=guard)) # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if __name__ == '__main__': main() uncrustify-uncrustify-0.76.0/scripts/make_version.py000077500000000000000000000064421434072136500227710ustar00rootroot00000000000000#!/usr/bin/env python # # Rebuilds the version using git describe # from sys import exit from subprocess import Popen, check_call, PIPE from os.path import join, dirname, abspath, exists from os import name as os_name from sys import argv, exit import re if os_name == 'nt': EX_OK = 0 EX_USAGE = 64 EX_IOERR = 74 else: from os import EX_IOERR, EX_OK, EX_USAGE def main(args): root = dirname(dirname(abspath(__file__))) git_path = join(root, '.git') hg_path = join(root, '.hg') txt = "" error_txt= "" if exists(git_path): try: proc = Popen(['git', 'describe', '--always', '--dirty'], stdout=PIPE, stderr=PIPE, cwd=root) txt_b, error_txt_b = proc.communicate() txt = txt_b.decode("UTF-8").strip().lower() error_txt = "%d: %s" % (proc.returncode, error_txt_b.decode("UTF-8").strip().lower()) except: print("Failed to retrieve version from git") exit(EX_IOERR) elif exists(hg_path): try: check_call(['hg', 'gexport']) proc0 = Popen(['hg', '--config', 'defaults.log=', 'log', '-r', '.', '--template', '{gitnode}'], stdout=PIPE, stderr=PIPE, cwd=root) node_b, error_txt_b = proc0.communicate() node = node_b.decode("UTF-8") error_txt = "%d: %s" % (proc0.returncode, error_txt_b.decode("UTF-8").strip().lower()) proc1 = Popen(['git', '--git-dir=.hg/git', 'describe', '--long', '--tags', '--always', node], stdout=PIPE, stderr=PIPE, cwd=root) txt_b, error_txt_b = proc1.communicate() txt = txt_b.decode("UTF-8").lower() error_txt += ", %d: %s" % (proc1.returncode, error_txt_b.decode("UTF-8").strip().lower()) except: print("Failed to retrieve version from hg") exit(EX_IOERR) else: print("Unknown version control system in '%s'." % root) exit(EX_USAGE) version_pattern = re.compile(r""" ^ ( #1: full match uncrustify- (\d+\.\d+(\.\d+)?) #2: version 0.64.2 (,#3 optional 3rd nr) ( #4: additional version info (long string format) -(\d+) #5: tag commit distance -g(\w{7,}) #g-prefix + #6: commithash )? | (\w{7,}) #7: commithash only format (last N commits pulled and no tag available) ) (-(dirty))? #9: optional dirty specifier (#8,) $ """, re.X) r_match = version_pattern.match(txt) if r_match is None: print("Regex version match failed on: '%s' (%s)" % (txt, error_txt)) exit(EX_IOERR) if r_match.group(2) is not None: string_groups = [r_match.group(2)] if r_match.group(5) is not None and r_match.group(6) is not None: string_groups.append(r_match.group(5)) string_groups.append(r_match.group(6)) else: string_groups = [r_match.group(7)] if r_match.group(9) is not None: string_groups.append(r_match.group(9)) for g in string_groups: if g is None: print("Unexpected empty regex group") exit(EX_IOERR) print("%s" % "-".join(string_groups)) return EX_OK if __name__ == "__main__": main(argv[1:]) uncrustify-uncrustify-0.76.0/scripts/option_reducer.py000077500000000000000000001054241434072136500233300ustar00rootroot00000000000000#!/usr/bin/python """ option_reducer.py reduces options in a given config file to the minimum while still maintaining desired formatting :author: Daniel Chumak :license: GPL v2+ """ # Possible improvements: # - parallelize add_back() # - (maybe) reduce amount of written config file, see Uncrustify --set from __future__ import print_function # python >= 2.6 import argparse from os import name as os_name, sep as os_path_sep, fdopen as os_fdopen, \ remove as os_remove from os.path import exists, join as path_join from subprocess import Popen, PIPE from sys import exit as sys_exit, stderr, stdout from shutil import rmtree from multiprocessing import cpu_count from tempfile import mkdtemp, mkstemp from contextlib import contextmanager from collections import OrderedDict from threading import Timer from multiprocessing.pool import Pool from itertools import combinations FLAGS = None NULL_DEV = "/dev/null" if os_name != "nt" else "nul" def enum(**enums): return type('Enum', (), enums) RESTULTSFLAG = enum(NONE=0, REMOVE=1, KEEP=2) ERROR_CODE = enum(NONE=0, FLAGS=200, SANITY0=201, SANITY1=202) MODES = ("reduce", "no-default") @contextmanager def make_temp_directory(): """ Wraps tempfile.mkdtemp to use it inside a with statement that auto deletes the temporary directory with its content after the with block closes :return: str ---------------------------------------------------------------------------- path to the generated directory """ temp_dir = mkdtemp() try: yield temp_dir finally: rmtree(temp_dir) @contextmanager def make_raw_temp_file(*args, **kwargs): """ Wraps tempfile.mkstemp to use it inside a with statement that auto deletes the file after the with block closes Parameters ---------------------------------------------------------------------------- :param args, kwargs: arguments passed to mkstemp :return: int, str ---------------------------------------------------------------------------- the file descriptor and the file path of the created temporary file """ fd, tmp_file_name = mkstemp(*args, **kwargs) try: yield (fd, tmp_file_name) finally: os_remove(tmp_file_name) @contextmanager def open_fd(*args, **kwargs): """ Wraps os.fdopen to use it inside a with statement that auto closes the generated file descriptor after the with block closes Parameters ---------------------------------------------------------------------------- :param args, kwargs: arguments passed to os.fdopen :return: TextIOWrapper ---------------------------------------------------------------------------- open file object connected to the file descriptor """ fp = os_fdopen(*args, **kwargs) try: yield fp finally: fp.close() def term_proc(proc, timeout): """ helper function to terminate a process Parameters ---------------------------------------------------------------------------- :param proc: process object the process object that is going to be terminated :param timeout: dictionary a dictionary (used as object reference) to set a flag that indicates that the process is going to be terminated """ timeout["value"] = True proc.terminate() def uncrustify(unc_bin_path, cfg_file_path, unformatted_file_path, lang=None, debug_file=None, check=False): """ executes Uncrustify and captures its stdout Parameters ---------------------------------------------------------------------------- :param unc_bin_path: str path to the Uncrustify binary :param cfg_file_path: str path to a config file for Uncrustify :param unformatted_file_path: str path to a file that is going to be formatted :param lang: str / None Uncrustifys -l argument :param debug_file: str / None Uncrustifys -p argument :param check: bool Used to control whether Uncrustifys --check is going to be used :return: str / None ---------------------------------------------------------------------------- returns the stdout from Uncrustify or None if the process takes to much time (set to 5 sec) """ args = [unc_bin_path, "-q", "-c", cfg_file_path, '-f', unformatted_file_path] if lang: args.extend(("-l", lang)) if debug_file: args.extend(('-p', debug_file)) if check: args.append('--check') proc = Popen(args, stdout=PIPE, stderr=PIPE) timeout = {"value": False} timer = Timer(5, term_proc, [proc, timeout]) timer.start() output_b, error_txt_b = proc.communicate() timer.cancel() if timeout["value"]: print("uncrustify proc timeout: %s" % ' '.join(args), file=stderr) return None error = error_txt_b.decode("UTF-8") if error: print("Uncrustify %s stderr:\n %s" % (unformatted_file_path, error), file=stderr) return output_b def same_expected_generated(formatted_path, unc_bin_path, cfg_file_path, input_path, lang=None): """ Calls uncrustify and compares its generated output with the content of a file Parameters ---------------------------------------------------------------------------- :param formatted_path: str path to a file containing the expected content :params unc_bin_path, cfg_file_path, input_path, lang: str, str, str, str / None see uncrustify() :return: bool ---------------------------------------------------------------------------- True if the strings match, False otherwise """ expected_string = '' with open(formatted_path, 'rb') as f: expected_string = f.read() formatted_string = uncrustify(unc_bin_path, cfg_file_path, input_path, lang) return True if formatted_string == expected_string else False def process_uncrustify(args): """ special wrapper for same_expected_generated() accesses global var(s): RESTULTSFLAG Parameters ---------------------------------------------------------------------------- :param args: list / tuple< int, ... > this function is intended to be called by multiprocessing.pool.map() therefore all arguments are inside a list / tuple: id: int an index number needed by the caller to differentiate runs other parameters: see same_expected_generated() :return: tuple< int, RESTULTSFLAG > ---------------------------------------------------------------------------- returns a tuple containing the id and a RESTULTSFLAG, REMOVE if both strings are equal, KEEP if not """ id = args[0] res = same_expected_generated(*args[1:]) return id, RESTULTSFLAG.REMOVE if res else RESTULTSFLAG.KEEP def write_config_file(args): """ Writes all but one excluded option into a config file Parameters ---------------------------------------------------------------------------- :param args: list / tuple< list< tuple< str, str > >, str, int > this function is intended to be called by multiprocessing.pool.map() therefore all arguments are inside a list / tuple: config_list: list< tuple< str, str > > a list of tuples containing option names and values tmp_dir: str path to a directory in which the config file is going to be written exclude_idx: int index for an option that is not going to be written into the config file """ config_list, tmp_dir, exclude_idx = args with open("%s%suncr-%d.cfg" % (tmp_dir, os_path_sep, exclude_idx), 'w') as f: print_config(config_list, target_file_obj=f, exclude_idx=exclude_idx) def write_config_file2(args): """ Writes two option lists into a config file Parameters ---------------------------------------------------------------------------- :param args: list< tuple< str, str > >, list< tuple< str, str > >, str, int this function is intended to be called by multiprocessing.pool.map() therefore all arguments are inside a list / tuple: config_list: list< tuple< str, str > > the first list of tuples containing option names and values test_list: list< tuple< str, str > > the second list of tuples containing option names and values tmp_dir: str path to a directory in which the config file is going to be written idx: int index that is going to be used for the filename """ config_list0, config_list1, tmp_dir, idx = args with open("%s%suncr-r-%d.cfg" % (tmp_dir, os_path_sep, idx), 'w') as f: print_config(config_list0, target_file_obj=f) print("", end='\n', file=f) print_config(config_list1, target_file_obj=f) def gen_multi_combinations(elements, N): """ generator function that generates, based on a set of elements, all combinations of 1..N elements Parameters ---------------------------------------------------------------------------- :param elements: list / tuple a list of elements from which the combinations will be generated :param N: the max number of element in a combination :return: list ---------------------------------------------------------------------------- yields a single combination of the elements >>> gen_multi_combinations(["a", "b", "c"], 3) (a); (b); (c); (a,b); (a,c); (b,c); (a,b,c) """ fields = len(elements) if N > fields: raise Exception("Error: N > len(options)") if N <= 0: raise Exception("Error: N <= 0") for n in range(1, N + 1): yield combinations(elements, n) def add_back(unc_bin_path, input_files, formatted_files, langs, options_r, options_k, tmp_dir): """ lets Uncrustify format files with generated configs files until all formatted files match their according expected files. Multiple config files are generated based on a (base) list of Uncrustify options combined with additional (new) options derived from combinations of another list of options. accesses global var(s): RESTULTSFLAG Parameters ---------------------------------------------------------------------------- :param unc_bin_path: str path to the Uncrustify binary :param input_files: list / tuple< str > a list containing paths to a files that are going to be formatted :param formatted_files: list / tuple< str > a list containing paths to files containing the expected contents :param langs: list / tuple< str > / None a list of languages the files, used as Uncrustifys -l argument can be None or shorter than the amount of provided files :param options_r: list< tuple< str, str > > the list of options from which combinations will be derived :param options_k: list< tuple< str, str > > the (base) list of Uncrustify options :param tmp_dir: str the directory in which the config files will be written to :return: list< tuple< str, str > > / None ---------------------------------------------------------------------------- list of additional option that were needed to generate matching file contents """ lang_max_idx = -1 if langs is None else len(langs) - 1 file_len = len(input_files) if len(formatted_files) != file_len: raise Exception("len(input_files) != len(formatted_files)") for m_combination in gen_multi_combinations(options_r, len(options_r)): for idx, (r_combination) in enumerate(m_combination): write_config_file2((options_k, r_combination, tmp_dir, idx)) cfg_file_path = "%s%suncr-r-%d.cfg" % (tmp_dir, os_path_sep, idx) res = [] for file_idx in range(file_len): lang = None if idx > lang_max_idx else langs[file_idx] r = process_uncrustify( (0, formatted_files[file_idx], unc_bin_path, cfg_file_path, input_files[file_idx], lang)) res.append(r[1]) # all files, flag = remove -> option can be removed -> equal output if res.count(RESTULTSFLAG.REMOVE) == len(res): return r_combination return None def sanity_raw_run(args): """ wrapper for same_expected_generated(), prints error message if the config file does not generate the expected result Parameters ---------------------------------------------------------------------------- :param args: see same_expected_generated :return: ---------------------------------------------------------------------------- see same_expected_generated """ res = same_expected_generated(*args) if not res: formatted_file_path = args[0] config_file_path = args[2] input_file_path = args[3] print("\nprovided config does not create formatted source file:\n" " %s\n %s\n->| %s" % (input_file_path, config_file_path, formatted_file_path), file=stderr) return res def sanity_run(args): """ wrapper for same_expected_generated(), prints error message if the config file does not generate the expected result Parameters ---------------------------------------------------------------------------- :param args: see same_expected_generated :return: ---------------------------------------------------------------------------- see same_expected_generated """ res = same_expected_generated(*args) if not res: formatted_file_path = args[0] input_file_path = args[3] print("\ngenerated config does not create formatted source file:\n" " %s\n %s" % (input_file_path, formatted_file_path), file=stderr) return res def sanity_run_splitter(uncr_bin, config_list, input_files, formatted_files, langs, tmp_dir, jobs): """ writes config option into a file and tests if every input file is formatted so that is matches the content of the according expected file Parameters ---------------------------------------------------------------------------- :param uncr_bin: str path to the Uncrustify binary :param config_list: list< tuple< str, str > > a list of tuples containing option names and values :param input_files: list / tuple< str > a list containing paths to a files that are going to be formatted :param formatted_files: list / tuple< str > a list containing paths to files containing the expected contents :param langs: list / tuple< str > / None a list of languages the files, used as Uncrustifys -l argument can be None or shorter than the amount of provided files :param tmp_dir: str the directory in which the config files will be written to :param jobs: int number of processes to use :return: bool ---------------------------------------------------------------------------- True if all files generate correct results, False oterhwise """ file_len = len(input_files) if len(formatted_files) != file_len: raise Exception("len(input_files) != len(formatted_files)") gen_cfg_path = path_join(tmp_dir, "gen.cfg") with open(gen_cfg_path, 'w') as f: print_config(config_list, target_file_obj=f) lang_max_idx = -1 if langs is None else len(langs) - 1 args = [] for idx in range(file_len): lang = None if idx > lang_max_idx else langs[idx] args.append((formatted_files[idx], uncr_bin, gen_cfg_path, input_files[idx], lang)) pool = Pool(processes=jobs) sr = pool.map(sanity_run, args) return False not in sr def print_config(config_list, target_file_obj=stdout, exclude_idx=()): """ prints config options into a config file Parameters ---------------------------------------------------------------------------- :param config_list: list< tuple< str, str > > a list containing pairs of option names and option values :param target_file_obj: file object see file param of print() :param exclude_idx: int / list< int > index of option(s) that are not going to be printed """ if not config_list: return config_list_len = len(config_list) # check if exclude_idx list is empty -> assign len if type(exclude_idx) in (list, tuple) and not exclude_idx: exclude_idx = [config_list_len] else: # sort it, unless it is an int -> transform into a list try: exclude_idx = sorted(exclude_idx) except TypeError: exclude_idx = [exclude_idx] # extracted first loop round: # do not print '\n' for the ( here non-existing) previous line if exclude_idx[0] != 0: print("%s = %s" % (config_list[0][0].ljust(31, ' '), config_list[0][1]), end='', file=target_file_obj) # also print space if a single option was provided and it is going to be # excluded. This is done in order to be able to differentiate between # --empty-nochange and the case where all options can be removed elif config_list_len == 1: print(' ', end='', file=target_file_obj) return start_idx = 1 for end in exclude_idx: end = min(end, config_list_len) for idx in range(start_idx, end): print("\n%s = %s" % (config_list[idx][0].ljust(31, ' '), config_list[idx][1]), end='', file=target_file_obj) start_idx = min(end + 1, config_list_len) # after for idx in range(start_idx, config_list_len): print("\n%s = %s" % (config_list[idx][0].ljust(31, ' '), config_list[idx][1]), end='', file=target_file_obj) def get_non_default_options(unc_bin_path, cfg_file_path): """ calls Uncrustify to generate a debug file from which a config only with non default valued options are extracted accesses global var(s): NULL_DEV Parameters ---------------------------------------------------------------------------- :param unc_bin_path: str path to the Uncrustify binary :param cfg_file_path: str path to a config file for Uncrustify :return: list< str > ---------------------------------------------------------------------------- amount of lines in the provided and shortened config """ lines = [] with make_raw_temp_file(suffix='.unc') as (fd, file_path): # make debug file uncrustify(unc_bin_path, cfg_file_path, NULL_DEV, debug_file=file_path, check=True) # extract non comment lines -> non default config lines with open_fd(fd, 'r') as fp: lines = fp.read().splitlines() lines = [line for line in lines if not line[:1] == '#'] return lines def parse_config_file(file_obj): """ Reads in a Uncrustify config file Parameters ---------------------------------------------------------------------------- :param file_obj: the file object of an opened config file :return: list< tuple< str, str > > ---------------------------------------------------------------------------- a list containing pairs of option names and option values """ # dict used to only save the last option setting if the same option occurs # multiple times, without this: # optionA0 can be removed because optionA1 = s0, and # optionA1 can be removed because optionA0 = s0 # -> optionA0, optionA1 are both removed config_map = OrderedDict() # special keys may not have this limitation, as for example # 'set x y' and 'set x z' do not overwrite each other special_keys = {'macro-open', 'macro-else', 'macro-close', 'set', 'type', 'file_ext', 'define'} special_list = [] for line in file_obj: # cut comments pound_pos = line.find('#') if pound_pos != -1: line = line[:pound_pos] split_pos = line.find('=') if split_pos == -1: split_pos = line.find(' ') if split_pos == -1: continue key = line[:split_pos].strip() value = line[split_pos + 1:].strip() if key in special_keys: special_list.append((key, value)) else: config_map[key] = value config_list = list(config_map.items()) config_list += special_list return config_list def count_lines(file_path): """ returns the count of lines in a file by counting '\n' chars Parameters ---------------------------------------------------------------------------- :param file_path: str file in which the lines will be counted :return: int ---------------------------------------------------------------------------- number a lines """ in_count = 0 with open(file_path, 'r') as f: in_count = f.read().count('\n') + 1 return in_count def reduce(options_list): """ Reduces the given options to a minimum accesses global var(s): FLAGS, RESTULTSFLAG, ERROR_CODE Parameters ---------------------------------------------------------------------------- :param options_list: list< tuple< str, str > > the list of options that are going to be reduced :return: int, list< tuple< str, str > > status return code, reduced options """ config_list_len = len(options_list) ret_flag = ERROR_CODE.NONE file_count = len(FLAGS.input_file_path) lang_max_idx = -1 if FLAGS.lang is None else len(FLAGS.lang) - 1 pool = Pool(processes=FLAGS.jobs) with make_temp_directory() as tmp_dir: # region sanity run ---------------------------------------------------- args = [] for idx in range(file_count): lang = None if idx > lang_max_idx else FLAGS.lang[idx] args.append((FLAGS.formatted_file_path[idx], FLAGS.uncrustify_binary_path, FLAGS.config_file_path, FLAGS.input_file_path[idx], lang)) sr = pool.map(sanity_raw_run, args) del args[:] if False in sr: return ERROR_CODE.SANITY0, [] del sr[:] # endregion # region config generator loop ----------------------------------------- args = [] for e_idx in range(config_list_len): args.append((options_list, tmp_dir, e_idx)) pool.map(write_config_file, args) del args[:] # endregion # region main loop ----------------------------------------------------- args = [] jobs = config_list_len * file_count for idx in range(jobs): file_idx = idx // config_list_len option_idx = idx % config_list_len cfg_file_path = "%s%suncr-%d.cfg" \ % (tmp_dir, os_path_sep, option_idx) lang = None if idx > lang_max_idx else FLAGS.lang[file_idx] args.append((idx, FLAGS.formatted_file_path[file_idx], FLAGS.uncrustify_binary_path, cfg_file_path, FLAGS.input_file_path[file_idx], lang)) results = pool.map(process_uncrustify, args) del args[:] # endregion # region clean results ------------------------------------------------- option_flags = [RESTULTSFLAG.NONE] * config_list_len for r in results: idx = r[0] flag = r[1] option_idx = idx % config_list_len if option_flags[option_idx] == RESTULTSFLAG.KEEP: continue option_flags[option_idx] = flag del results[:] # endregion options_r = [options_list[idx] for idx, x in enumerate(option_flags) if x == RESTULTSFLAG.REMOVE] options_list = [options_list[idx] for idx, x in enumerate(option_flags) if x == RESTULTSFLAG.KEEP] del option_flags[:] # region sanity run ---------------------------------------------------- # options can be removed one at a time generating appropriate results, # oddly enough sometimes a config generated this way can fail when a # combination of multiple options is missing s_flag = True if options_r: s_flag = sanity_run_splitter( FLAGS.uncrustify_binary_path, options_list, FLAGS.input_file_path, FLAGS.formatted_file_path, FLAGS.lang, tmp_dir, FLAGS.jobs) if not s_flag: ret_flag = ERROR_CODE.SANITY1 print("\n\nstumbled upon complex option dependencies in \n" " %s\n" "trying to add back minimal amount of removed options\n" % FLAGS.config_file_path, file=stderr) ret_options = add_back( FLAGS.uncrustify_binary_path, FLAGS.input_file_path, FLAGS.formatted_file_path, FLAGS.lang, options_r, options_list, tmp_dir) if ret_options: options_list.extend(ret_options) s_flag = sanity_run_splitter( FLAGS.uncrustify_binary_path, options_list, FLAGS.input_file_path, FLAGS.formatted_file_path, FLAGS.lang, tmp_dir, FLAGS.jobs) if s_flag: print("Success!", file=stderr) ret_flag = ERROR_CODE.NONE # endregion return ret_flag, options_list if ret_flag == ERROR_CODE.NONE else [] def reduce_mode(): """ the mode that minimizes a config file as much as possible accesses global var(s): FLAGS, ERROR_CODE """ ret_flag = ERROR_CODE.NONE option_list = {} # gen & parse non default config lines = get_non_default_options(FLAGS.uncrustify_binary_path, FLAGS.config_file_path) option_list = parse_config_file(lines) config_list_len = len(option_list) config_lines_init = count_lines(FLAGS.config_file_path) config_lines_ndef = len(lines) del lines[:] # early return if all options are already removed at this point if config_list_len == 0: if not FLAGS.empty_nochange \ or (config_lines_init - config_lines_ndef) > 0: if not FLAGS.quiet: print("\n%s" % '# '.ljust(78, '-')) print(" ") if not FLAGS.quiet: print("%s" % '# '.ljust(78, '-')) print("# initial config lines: %d,\n" "# default options and unneeded lines: %d,\n" "# unneeded options: 0,\n" "# kept options: 0" % (config_lines_init, config_lines_init)) print("ret_flag: 0", file=stderr) return ERROR_CODE.NONE # gen reduced options config_lines_redu = -1 for i in range(FLAGS.passes): old_config_lines_redu = config_lines_redu ret_flag, option_list = reduce(option_list) config_lines_redu = len(option_list) if ret_flag != ERROR_CODE.NONE \ or config_lines_redu == old_config_lines_redu: break if ret_flag == ERROR_CODE.NONE: # use the debug file trick again to get correctly sorted options with make_raw_temp_file(suffix='.unc') as (fd, file_path): with open_fd(fd, 'w') as f: print_config(option_list, target_file_obj=f) lines = get_non_default_options(FLAGS.uncrustify_binary_path, file_path) option_list = parse_config_file(lines) # print output + stats if not FLAGS.empty_nochange or config_lines_ndef != config_lines_redu: if not FLAGS.quiet: print("\n%s" % '# '.ljust(78, '-')) print_config(option_list) if not FLAGS.quiet: print("\n%s" % '# '.ljust(78, '-')) print("# initial config lines: %d,\n" "# default options and unneeded lines: %d,\n" "# unneeded options: %d,\n" "# kept options: %d" % (config_lines_init, config_lines_init - config_lines_ndef, config_lines_ndef - config_lines_redu, config_lines_redu)) print("ret_flag: %d" % ret_flag, file=stderr) return ret_flag def no_default_mode(): """ the mode removes all unnecessary lines and options with default values accesses global var(s): FLAGS, ERROR_CODE """ lines = get_non_default_options(FLAGS.uncrustify_binary_path, FLAGS.config_file_path, ) config_lines_ndef = len(lines) config_lines_init = count_lines(FLAGS.config_file_path) if not FLAGS.empty_nochange or (config_lines_ndef != config_lines_init): if not FLAGS.quiet: print("%s" % '# '.ljust(78, '-')) options_str = '\n'.join(lines) if not options_str: print(" ") else: print(options_str, file=stdout) if not FLAGS.quiet: print("%s" % '# '.ljust(78, '-')) print("# initial config lines: %d,\n" "# default options and unneeded lines: %d,\n" % (config_lines_init, config_lines_init - config_lines_ndef)) return ERROR_CODE.NONE def main(): """ calls the mode that was specified by the -m script argument, defaults to reduce_mode if not provided or unknown mode accesses global var(s): MODES, FLAGS :return: int ---------------------------------------------------------------------------- return code """ if FLAGS.mode == MODES[1]: return no_default_mode() return reduce_mode() def valid_file(arg_parser, *args): """ checks if on of the provided paths is a file Parameters ---------------------------------------------------------------------------- :param arg_parser: argument parser object that is called if no file is found :param args: list< str > a list of file path that is going to be checked :return: str ---------------------------------------------------------------------------- path to an existing file """ arg = None found_flag = False for arg in args: if exists(arg): found_flag = True break if not found_flag: arg_parser.error("file(s) do not exist: %s" % args) return arg if __name__ == "__main__": """ parses all script arguments and calls main() accesses global var(s): FLAGS, ERROR_CODE, MODES """ arg_parser = argparse.ArgumentParser() group_general = arg_parser.add_argument_group( 'general options', 'Options used by both modes') group_general.add_argument( '-q', '--quiet', default=False, action='store_true', help='Whether or not messages, other than the actual config output, ' 'should be printed to stdout.' ) group_general.add_argument( '--empty-nochange', default=False, action='store_true', help='Do not print anything to stdout if no options could be removed' ) group_general.add_argument( '-m', '--mode', type=str, choices=MODES, default=MODES[0], help="The script operation mode. Defaults to '%s'" % MODES[0] ) group_general.add_argument( '-b', '--uncrustify_binary_path', metavar='', type=lambda x: valid_file( arg_parser, x, "../build/uncrustify.exe", "../build/Debug/uncrustify", "../build/Debug/uncrustify.exe", "../build/Release/uncrustify", "../build/Release/uncrustify.exe"), default="../build/uncrustify", help="The Uncrustify binary file path. Is searched in known locations " "in the 'Uncrustify/build/' directory if no is provided." ) group_general.add_argument( '-c', '--config_file_path', metavar='', type=lambda x: valid_file(arg_parser, x), required=True, help='Path to the config file.' ) group_reduce = arg_parser.add_argument_group( 'reduce mode', 'Options to reduce configuration file options') group_reduce.add_argument( '-i', '--input_file_path', metavar='', type=lambda x: valid_file(arg_parser, x), nargs='+', action='append', help="Path to the unformatted source file. " "Required if mode '%s' is used" % MODES[0] ) group_reduce.add_argument( '-f', '--formatted_file_path', metavar='', type=lambda x: valid_file(arg_parser, x), nargs='+', action='append', help="Path to the formatted source file. " "Required if mode '%s' is used" % MODES[0] ) group_reduce.add_argument( '-l', '--lang', metavar='', nargs='+', required=False, action='append', help='Uncrustify processing language for each input file' ) group_reduce.add_argument( '-j', '--jobs', metavar='', type=int, default=cpu_count(), help='Number of concurrent jobs.' ) group_reduce.add_argument( '-p', '--passes', metavar='', type=int, default=5, help='Max. number of cleaning passes.' ) group_no_default = arg_parser.add_argument_group( 'no-default mode', 'Options to remove configuration file option with ' 'default values: ~~_Currently only the general' ' options are used for this mode_~~') FLAGS, unparsed = arg_parser.parse_known_args() if FLAGS.lang is not None: FLAGS.lang = [j for i in FLAGS.lang for j in i] if FLAGS.mode == MODES[0]: if not FLAGS.input_file_path or not FLAGS.formatted_file_path: arg_parser.error("Flags -f and -i are required in Mode '%s'!" % MODES[0]) sys_exit(ERROR_CODE.FLAGS) # flatten 2 dimensional args: -f p -f p -f p -f p0 p1 p2 -> [[],[], ...] FLAGS.input_file_path = [j for i in FLAGS.input_file_path for j in i] FLAGS.formatted_file_path = [j for i in FLAGS.formatted_file_path for j in i] if len(FLAGS.input_file_path) != len(FLAGS.formatted_file_path): print("Unequal amount of input and formatted file paths.", file=stderr) sys_exit(ERROR_CODE.FLAGS) sys_exit(main()) uncrustify-uncrustify-0.76.0/scripts/pclint/000077500000000000000000000000001434072136500212155ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/scripts/pclint/au-sm123.lnt000066400000000000000000000313661434072136500232150ustar00rootroot00000000000000/* Date Stamp */ -d"_lint_au_sm123_lnt=au-sm123.lnt modified 5-Jan-2006" /* To document usage use: -message( "Using " _lint_au_sm123_lnt ) */ // --------------------------------------------------------------------- // This file is provided by Gimpel Software (www.gimpel.com) for use with // its products PC-lint and FlexeLint. // // Redistribution and use of this file, with or without modification, is // permitted provided that any such redistribution retains this notice. // --------------------------------------------------------------------- // au-sm123.lnt -- Author options - Scott Meyers /* This options file can be used to explicitly activate those checks advocated in the publications: [12] Meyers, Scott, Effective C++, Addison-Wesley, Reading Mass., 1992 [23] Meyers, Scott, More Effective C++, Addison-Wesley, 1996 [30] Meyers, Scott, Effective C++ Third Edition, Addison-Wesley, 2005 You can use this file directly when linting your programs as in: lin au-sm123 files Most of the Scott Meyers checks are on by default. The Elective Notes (19??), however, are not and so this file is necessary to get the full impact of the Scott Meyers multi-volume set of recommendations. Also, this file explicitly activates those Warnings and Informationals advocated by Scott Meyers just in case they were suppressed previously. For example, lin -w2 au-sm123 files has the effect of removing all Informational messages other than those reactivated in this file. If you do not want code to adhere to all of the Scott Meyers' checks we recommend that, rather than editing this file, you include it within a file of your own. For example: let my-sm.lnt contain au-sm123.lnt -e1932 // allow concrete base classes In this way you inherit the checks specified in this file except for the ones that you wish to specifically exclude. Then you can use my-sm.lnt in place of au-sm123.lnt You might consider placing this file (au-sm123.lnt) or your own derivation of it (as shown above) in your global options file. */ +e424 // Inappropriate deallocation -- [12, Item 5], [30, Item 16] -append(424, -- Effective C++ #5 & Eff. C++ 3rd Ed. item 16) +e530 // Symbol not initialized -- [30, Item 4] -append( 530, --- Eff. C++ 3rd Ed. item 4 ) +e603 // Symbol not initialized -- [30, Item 4] -append( 603, --- Eff. C++ 3rd Ed. item 4 ) +e605 // Increase in pointer capability -- [12, Item 29] -append(605, -- Effective C++ #29 ) +e644 // Variable may not have been initialized -- [30, Item 4] -append( 644, --- Eff. C++ 3rd Ed. item 4 ) +e645 // Symbol may not have been initialized -- [30, Item 4] -append( 645, --- Eff. C++ 3rd Ed. item 4 ) +e673 // Possibly inappropriate deallocation (Name1) for 'Name2' data. -- [30, Item 16] -append( 673, --- Eff. C++ 3rd Ed. item 16 ) +e727 // Symbol not explicitly initialized -- [30, Item 4] -append( 727, --- Eff. C++ 3rd Ed. item 4 ) +e728 // Symbol not explicitly initialized -- [30, Item 4] -append( 728, --- Eff. C++ 3rd Ed. item 4 ) +e729 // Symbol not explicitly initialized -- [30, Item 4] -append( 729, --- Eff. C++ 3rd Ed. item 4 ) +e738 // Symbol not explicitly initialized -- [30, Item 4] -append( 738, --- Eff. C++ 3rd Ed. item 4 ) +e771 // Symbol conceivably not initialized -- [30, Item 4] -append( 771, --- Eff. C++ 3rd Ed. item 4 ) +e772 // Symbol conceivably not initialized -- [30, Item 4] -append( 772, --- Eff. C++ 3rd Ed. item 4 ) +e794 // Conceivable use of null pointer -- [12, Item 7] -append(794, -- Effective C++ #7 ) +e802 // Conceivably passing a null pointer to function -- [12, Item 7] -append(802, -- Effective C++ #7 ) +e818 // Pointer parameter could be declared ptr to const -- [30, Item 3] -append( 818, --- Eff. C++ 3rd Ed. item 3 ) +e952 // Parameter could be declared const -- [30, Item 3] -append( 952, --- Eff. C++ 3rd Ed. item 3 ) +e953 // Variable could be declared as const -- [30, Item 3] -append( 953, --- Eff. C++ 3rd Ed. item 3 ) +e954 // Pointer variable could be declared as pointing to a const -- [30, Item 3] -append( 954, --- Eff. C++ 3rd Ed. item 3 ) +e1072 // Reference variable must be initialized -- [30, Item 4] -append( 1072, --- Eff. C++ 3rd Ed. item 4 ) +e1401 // member symbol not initialized by constructor -- [30, Item 4], [30, Item 13] -append( 1401, --- Eff. C++ 3rd Ed. item 4 & Eff. C++ 3rd Ed. item 13) +e1402 // member not initialized -- [30, Item 4] -append( 1402, --- Eff. C++ 3rd Ed. item 4 ) +e1403 // member not initialized -- [30, Item 4] -append( 1403, --- Eff. C++ 3rd Ed. item 4 ) +e1411 // Member with different signature hides virtual member -- [30, Item 33] -append( 1411, --- Eff. C++ 3rd Ed. item 33 ) +e1412 // Reference member is not initialized -- [30, Item 4] -append( 1412, --- Eff. C++ 3rd Ed. item 4 ) +e1413 // function is returning a temporary via a reference -- [30, Item 21] -append( 1413, --- Eff. C++ 3rd Ed. item 21 ) +e1506 // Call to virtual function within a constructor or destructor -- [30, Item 9] -append( 1506, --- Eff. C++ 3rd Ed. item 9 ) +e1509 // base class destructor for class is not virtual -- [12, Item 14], [30, Item 7] -append(1509, -- Effective C++ #14 & Eff. C++ 3rd Ed. item 7) +e1510 // base class has no destructor -- [12, Item 14] -append(1510, -- Effective C++ #14 ) +e1511 // Member hides non-virtual member -- [12, Item 37], [30, Item 33], [30, Item 36] -append(1511, -- Effective C++ #37 & Eff. C++ 3rd Ed. item 33& Eff. C++ 3rd Ed. item 36) +e1516 // Data member hides inherited member -- [30, Item 33] -append( 1516, --- Eff. C++ 3rd Ed. item 33 ) +e1529 // not first checking for assignment to this -- [12, Item 17], [30, Item 11] -append(1529, -- Effective C++ #17 & Eff. C++ 3rd Ed. item 11) +e1531 // Symbol should have compared argument against sizeof(class) -- [30, Item 51] -append( 1531, --- Eff. C++ 3rd Ed. item 51 ) +e1534 // static variable found within inline function -- [23, Item 26], [30, Item 30] -append(1534, -- More Effective C++ #26 & Eff. C++ 3rd Ed. item 30) +e1536 // Exposing low access member -- [12, Item 30] -append(1536, -- Effective C++ #30 ) +e1537 // const function returns pointer data member -- [12, Item 29 ], [30, Item 28] -append(1537, -- Effective C++ #29 & Eff. C++ 3rd Ed. item 28) +e1539 // member not assigned by assignment operator -- [12, Item 16], [30, Item 12] -append(1539, -- Effective C++ #16 & Eff. C++ 3rd Ed. item 12) +e1540 // pointer member freed nor zero'ed by destructor -- [12, Item 6] -append(1540, -- Effective C++ #6 ) +e1541 // member possibly not initialized by constructor -- [30, Item 4], [30, Item 13] -append( 1541, --- Eff. C++ 3rd Ed. item 4 & Eff. C++ 3rd Ed. item 13) +e1542 // member possibly not initialized -- [30, Item 4] -append( 1542, --- Eff. C++ 3rd Ed. item 4 ) +e1543 // member possibly not initialized -- [30, Item 4] -append( 1543, --- Eff. C++ 3rd Ed. item 4 ) +e1544 // value indeterminate (order of initialization) -- [12, Item 47] -append(1544, -- Effective C++ #47 ) +e1546 // throw() called within destuctor -- [23, Item 11], [30, Item 8] -append(1546, -- Effective C++ #11 & Eff. C++ 3rd Ed. item 8) +e1547 // Assignment of array to pointer to base -- [23, Item 3] -append(1547, -- More Effective C++ #3 ) +e1549 // Exception thrown for function not declared to throw -- [23, Item 11] -append(1549, -- More Effective C++ #11 ) +e1551 // function may throw an exception in destructor -- [23, Item 11], [30, Item 8] -append(1551, -- More Effective C++ #11 & Eff. C++ 3rd Ed. item 8) +e1557 // const member is not initialized -- [30, Item 4] -append( 1557, --- Eff. C++ 3rd Ed. item 4 ) +e1559 // Uncaught exception 'Name' may be thrown in destructor -- [30, Item 8] -append( 1559, --- Eff. C++ 3rd Ed. item 8 ) +e1722 // assignment operator does not return a reference -- [12, Item 15], [30, Item 10] -append(1722, -- Effective C++ #15 & Eff. C++ 3rd Ed. item 10) +e1724 // Argument to copy constructor for class should be a const reference -- [30, Item 3], [30, Item 20] -append( 1724, --- Eff. C++ 3rd Ed. item 3 & Eff. C++ 3rd Ed. item 20) +e1727 // inline not previously defined inline at -- [30, Item 30] -append( 1727, --- Eff. C++ 3rd Ed. item 30 ) +e1729 // Initializer inversion detected for member -- [12, Item 13] -append(1729, -- Effective C++ #13 ) +e1732 // new in constructor for class which has no assignment operator -- [12, Item 11] -append(1732, -- Effective C++ #11 ) +e1733 // new in constructor for class which has no copy constructor -- [12, Item 11] -append(1733, -- Effective C++ #11 ) +e1735 // Virtual function has default parameter -- [12, Item 38] -append(1735, -- Effective C++ #38 ) +e1737 // 'Symbol' hides global operator new -- [12, Item 9] -append(1737, -- Effective C++ #9 ) +e1739 // Binary operator should be non-member function -- [12, Item 19], [30, Item 24] -append(1739, -- Effective C++ #19 & Eff. C++ 3rd Ed. item 24) +e1740 // pointer member not directly freed or zero'ed by destructor -- [12, Item 6] -append(1740, -- Effective C++ #6 ) +e1741 // member conceivably not initialized by constructor -- [30, Item 4], [30, Item 13] -append( 1741, --- Eff. C++ 3rd Ed. item 4 & Eff. C++ 3rd Ed. item 13) +e1742 // member conceivably not initialized -- [30, Item 4] -append( 1742, --- Eff. C++ 3rd Ed. item 4 ) +e1743 // member conceivably not initialized -- [30, Item 4] -append( 1743, --- Eff. C++ 3rd Ed. item 4 ) +e1744 // member possibly not initialized by private constructor -- [30, Item 4] -append( 1744, --- Eff. C++ 3rd Ed. item 4 ) +e1745 // member not assigned by private assignment operator -- [12, Item 16], [30, Item 12] -append(1745, -- Effective C++ #16 & Eff. C++ 3rd Ed. item 12) +e1746 // parameter of function could be made const ref -- [12, Item 22], [30, Item 3], [30, Item 20] -append(1746, -- Effective C++ #22 & Eff. C++ 3rd Ed. item 3& Eff. C++ 3rd Ed. item 20) +e1747 // binary operator returning a reference -- [12, Item 23] -append(1747, -- Effective C++ #23 ) +e1749 // base class of class need not be virtual -- [23, Item 24] -append(1749, -- More Effective C++ #24 ) +e1752 // catch parameter Integer is not a reference -- [23, Item 13] -append(1752, -- More Effective C++ #13 ) +e1753 // Overloading special operator -- [23, Item 7] -append(1753, -- More Effective C++ #7 ) +e1754 // Expected 'Symbol' to be declared for class 'Symbol' -- [23, Item 22] -append(1754, -- More Effective C++ #22 ) +e1757 // Discarded instance of post decrement/increment -- [23, Item 6] -append(1757, -- More Effective C++ #6 ) +e1758 // Prefix increment/decrement operator returns a non-reference. -- [23, Item 6] -append(1758, -- More Effective C++ #6 ) +e1759 // Postfix increment/decrement operator returns a reference. -- [23, Item 6] -append(1759, -- More Effective C++ #6 ) +e1762 // Member function could be made const -- [30, Item 3] -append( 1762, --- Eff. C++ 3rd Ed. item 3 ) +e1764 // Reference parameter could be declared const reference -- [30, Item 3] -append( 1764, --- Eff. C++ 3rd Ed. item 3 ) +e1770 // function defined without function 'String' -- [30, Item 52] -append( 1770, --- Eff. C++ 3rd Ed. item 52 ) +e1772 // Assignment operator is not returning *this -- [30, Item 10] -append( 1772, --- Eff. C++ 3rd Ed. item 10 ) +e1904 // Old-style C comment -- [12, Item 4] -append(1904, -- Effective C++ #4 ) +e1921 // Symbol not checking argument against sizeof(class) -- [30, Item 51] -append( 1921, --- Eff. C++ 3rd Ed. item 51 ) +e1923 // macro could become const variable -- [12, Item 1], [30, Item 2] -append(1923, -- Effective C++ #1 & Eff. C++ 3rd Ed. item 2) +e1924 // C-style cast -- [23, Item 2] -append(1924, -- More Effective C++ #2 ) +e1925 // public data member -- [12, Item 20], [30, Item 22] -append(1925, -- Effective C++ #20 & Eff. C++ 3rd Ed. item 22) +e1926 // 'Symbol's default constructor implicitly called -- [12, Item 12] -append(1926, -- Effective C++ #12 ) +e1927 // 'Symbol' was not initialized in the constructor init list -- [12, Item 12] -append(1927, -- Effective C++ #12 ) +e1928 // 'Symbol' did not appear in the ctor initializer list -- [12, Item 12] -append(1928, -- Effective C++ #12 ) +e1929 // function returning a reference -- [12, Item 23], [30, Item 21] -append(1929, -- Effective C++ #23 & Eff. C++ 3rd Ed. item 21) -esym( 1929, operator<<, operator>> ) // but these op's are OK +e1930 // Conversion operator found -- [23, Item 5] -append(1930, -- More Effective C++ #5 ) +e1931 // Constructor can be used for implicit conversions -- [23, Item 5] -append(1931, -- More Effective C++ #5 ) +e1932 // Base class is not abstract. -- [23, Item 33] -append(1932, -- More Effective C++ #33 ) +e1934 // flags member functions operator<< and operator>> -append(1934, -- Effective C++ #19 ) +e1961 // virtual member function could be made const -- [30, Item 3] -append( 1961, --- Eff. C++ 3rd Ed. item 3 ) uncrustify-uncrustify-0.76.0/scripts/pclint/co-gcc.h000066400000000000000000000016011434072136500225170ustar00rootroot00000000000000#ifndef CO_GCC_H_ #define CO_GCC_H_ #ifdef _lint /* Make sure no compiler comes this way */ /* The headers included below must be generated; For C++, generate with: g++ [usual build options] -E -dM t.cpp >lint_cppmac.h For C, generate with: gcc [usual build options] -E -dM t.c >lint_cmac.h ...where "t.cpp" and "t.c" are empty source files. It's important to use the same compiler options used when compiling project code because they can affect the existence and precise definitions of certain predefined macros. See the preamble to co-gcc.lnt for details and a tutorial. */ #if defined(__cplusplus) //# include "lint_cppmac.h" #else # include "lint_cmac.h" #endif /* If the macros given by the generated macro files must be adjusted in order for Lint to cope, then you can do so here. */ #endif /* _lint */ #endif /* CO_GCC_H_ */ uncrustify-uncrustify-0.76.0/scripts/pclint/co-gcc.lnt000066400000000000000000000172161434072136500230760ustar00rootroot00000000000000/* co-gcc.lnt: This is the seed file for configuring Lint for use with GCC versions 2.95.3 and later. Like all compiler options files this file is intended to be used as follows: lint co-gcc.lnt source-files-to-be-linted Some of the information that co-gcc.lnt requires needs to be furnished with the help of the gcc system itself. If any of these directions are unclear, you may gain a better insight into what is happening by checking the file gcc-readme.txt For C, first create an empty file named empty.c and then run the command (options are case sensitive): gcc -E -dM empty.c >lint_cmac.h This will capture macro definitions in a file that will be included automatically at the beginning of each module by use of the -header option within co-gcc.lnt. The macros may change as you change compiler options so that ultimately you may want to incorporate this step into a make facility. Next we need to determine the search directories. If you run gcc -c -v empty.c you will see among other things this coveted list. For example you might get: ... #include "..." search starts here #include <...> search starts here /usr/local/include /usr/lib/gcc/i686-apple-darwin8/4.0.1/include /usr/include /System/Library/Frameworks /Library/Frameworks End of search list. ... For each directory shown (there are five in the list above) prefix the directory name by a "--i" and place it in a file whose name is, say, include.lnt. You may then begin linting programs by using the command lint co-gcc.lnt include.lnt source-files Note: it is conventional to place both .lnt files into a single .lnt file called std.lnt For C++, run the command (options are again case sensitive): g++ -E -dM empty.c >lint_cppmac.h This will capture C++ macro definitions in a file that will be included automatically at the beginning of each C++ module at the request of co-gcc.lnt. Next we need to determine C++ search directories. If you run g++ -c -v empty.c As in the case of C you should prepend a --i onto each directory displayed and place these options into a file such as include.lnt. Again, there is nothing sacred about the name and if you intend to do mixed C and C++ programming it will be necessary for you to use a differently named file. The rest proceeds as before. Note, some options in this file (such as the size options, i.e. -sp4 indicating that pointers are four bytes wide) may need to be changed. See "System Dependent Options" below. */ -cgnu // Notifies FlexeLint that gcc is being used. // Begin: System Dependent Options // ------------------------------- -a#machine(i386) // #assert's machine(i386) (SVR4 facility). +fdi // Use the directory of the including file -si4 // size of int -sp4 // size of pointer // ----------------------------- // End: System Dependent Options +cpp(.cc,.c) // extensions for C++ that are commonly used in addition // to the default extensions of .cpp and .cxx -header(scripts/pclint/co-gcc.h) // Includes header generated by GCC. +libh(co-gcc.h) // Marks that header as library code. // ========================================================= // +rw and -d options to cope with GNU syntax: +ppw(ident) // Tolerate #ident keyword definitions for SCCS/RCS +ppw(warning) // GCC provides alternative spellings of certain keywords: -rw_asgn(__inline,inline) -rw_asgn(__inline__,inline) -rw_asgn(__signed__,signed) -rw_asgn( __volatile__, volatile ) -rw_asgn( __volatile, volatile ) ++d__const=const // gconv.h uses __const rather than const ++dconst=const // ensure const expands to const. -rw_asgn( asm, _up_to_brackets ) -rw_asgn( __asm, _up_to_brackets ) -rw_asgn( __asm__, _up_to_brackets ) // This re-definition of the various spellings of the asm keyword enables // Lint to pass gracefully over expression-statements like: // __asm __volatile ("fsqrt" : "=t" (__result) : "0" (__x)); ++d__attribute__()= // ignore this keyword and following parenthetical ++d__attribute()= // variant spelling of "__attribute__" // "__extension__" is GCC's way of allowing the use of non-standard // constructs in a strict Standard-conforming mode. We don't currently // have explicit support for it, but we can use local suppressions. For // example, we can use -e(160) so that we will not see any Errors about // GNU statement-expressions wrapped in __extension__(). ++d"__extension__=/*lint -e(160) */" ++d__builtin_va_list=void* // used by stdarg.h ++d__builtin_stdarg_start()=_to_semi // ditto ++d__builtin_va_end()=_to_semi // ditto ++d"__builtin_va_arg(a,b)=(*( (b *) ( ((a) += sizeof(b)) - sizeof(b) )))" ++d__null=0 +rw(_to_semi) // needed for the two macros above. +rw(__typeof__) // activate __typeof__ keyword -d__typeof=__typeof__ // an alternative to using __typeof__ +rw( __restrict ) +rw( __restrict__ ) -rw(__except) // This MS reserved word is used as an identifier +rw( __complex__, __real__, __imag__ ) // reserved words that can be ignored. ++d__builtin_strchr=(char*) // permits the inline definition ... ++d__builtin_strpbrk=(char*) // of these functions to be linted ... ++d__builtin_strrchr=(char*) // without drawing a complaint ++d__builtin_strstr=(char*) // about the use of a non-standard name ++d__PRETTY_FUNCTION__=___function___ // lint defines ___function___ internally ++d__FUNCTION__=___function___ // lint defines ___function___ internally // ========================================================= // Other options supporting GNU C/C++ syntax: +fld // enables the processing of _L_abel _D_esignators E.g.: // union { double d; int i; } u = { d: 3.141 }; // +fwc // wchar_t might be builtin; if so, uncomment // this option. // ========================================================= // Generally useful suppressions: -wlib(1) // sets the warning level within library headers to 1 // (no warnings, just syntax errors). Comment out if you // are actually linting library headers. -elib(123) // 123 is really a warning, but it's in the "Error" range. -elib(93) // allow newlines within quoted string arguments to macros -elibsym(628) // Suppress 628 for __builtin symbols. -esym(528,__huge_val,__nan,__qnan,__qnanf,__snan,__snanf) // We don't care if we don't reference some GNU functions -esym(528,__gnu_malloc,__gnu_calloc) // The following functions exhibit variable return modes. // That is, they may equally-usefully be called for a value // as called just for their effects. Accordingly we inhibit // Warning 534 for these functions. // Feel free to add to or subtract from this list. -esym(534,close,creat,fclose,fprintf,fputc, nanosleep, time) -esym(534,fputs,fscanf,fseek,fwrite,lseek,memcpy,memmove,memset) -esym(534,printf,puts,scanf,sprintf,sscanf,strcat,strcpy) -esym(534,strncat,strncpy,unlink,write, snprintf, dprintf) // For non-ANSI compilers we suppress messages 515 and 516 // for functions known to have variable argument lists. // For ANSI compilers, header files should take care of this. -esym(515,fprintf,printf,sprintf,fscanf,scanf,sscanf) -esym(516,fprintf,printf,sprintf,fscanf,scanf,sscanf) -esym(1702,*operator<<,*operator>>) -esym(534,*operator<<,*operator>>) -esym(1055,*__builtin*) -esym(718,*__builtin*) // The compiler does not need these ... -esym(746,*__builtin*) // declared and it knows their prototypes. uncrustify-uncrustify-0.76.0/scripts/pclint/lint_cfg.lnt000066400000000000000000000035341434072136500235260ustar00rootroot00000000000000// These settings are used to adjust the pcLint checking for // the operating unit source code // show pclint where to find Header files -i".\include" -i".\lib" -i".\src" -iC:\mingw\include -iC:\mingw\lib\gcc\mingw32\4.8.1\include\ -iC:\mingw\lib\gcc\mingw32\4.8.1\include\-fixed -iC:\mingw\lib\gcc\mingw32\4.8.1\include\c++\ -iC:\mingw\lib\gcc\mingw32\4.8.1\include\c++\mingw32 //+libdir(D:\Programme\linaro\gcc-linaro-arm-linux-gnueabihf-4.9-2014.08\*) // define a directory as holding only headers, may be used with * or ? //+libdir(D:\Programme\linaro\gcc-linaro-arm-linux-gnueabihf-4.9-2014.08\libc\usr\include\*) //+libclass(ansi) // use this if only ANSI headers are seen as unchecked libraries +libclass(foreign) // ignore all headers comeing from a foreign directory using -i or the INCLUDE environment variable //+libclass(angle) // ingore all headers specified with angle brackets //+libclass(all) // ignore all header files +libh(co-ggc.lnt) // ignore this file //+libdir(uncrustify/scripts/*) //-wlib(1) // Compiler specific configuration for Visual DSP // co-tiger.lnt use this file for tiger sharc as reference scripts\pclint\co-gcc.lnt // Compiler Options for GCC // Configuration for checking the operating unit source code //-d__ARM_PCS_VFP -d__cplusplus -d_GNU_SOURCE //-d__GNUC__ -d__STDC__ //-d__GLIBCXX__=20130531 //-d__SIZE_TYPE__=int //-d__PTRDIFF_TYPE__=int //-d__CHAR_BIT__=8 -dWIN32 -d__i386__ -dDEFINE_CHAR_TABLE -dDEFINE_PCF_NAMES // define compiler specific keywords //+rw(__inline) // activate the __inline keyword //+ppw(import) // activate #import //-d"_exit=_up_to_brackets" //-d"extern 'C'=gobble" //+fkp // complain about non-KR extensions // To print a stack usage report pclint has to know how much space is required by some functions // define an upper limit of stack space usage for recursion and function pointers uncrustify-uncrustify-0.76.0/scripts/pclint/pclint_cfg_eclipse.lnt000066400000000000000000000046561434072136500255630ustar00rootroot00000000000000// These are generale configuration options used for pcLint // throughout all kind of projects. // This was adjusted to nuinno policy. // See manual (chapter LIVING WITH LINT) for further details. // // Project specific settings shall be included from a separate file // at the end of this file //-i"%PCLINT_HOME%" // add pclint home directory to include path //-p // only run preprocessor (use this for debugging pclint test) //+source // print source code (use this for debugging pclint test) -v // be not verbose (standard setting for normal operation) //-voif // show the options that pclint uses (only for debugging pclint) //+v // be verbose (use this for debugging pclint test) //-v* // be more verbose (use this for debugging pclint) //-vf // print included files (useful for debugging pclint test) -summary // prints a summary of all pclint results (useful for debugging pclint test) //-format_summary=. //-format_template= //-format_verbosity=. +fan // allow anonymous unions ++fim // use multiple include directories +fus // automatically recognize std namespace +fbo // activate keyword bool, true, false -fkp // allow ANSI/ISO standard do not insist on Kernighan Richy style -fdh // do not append a .h to header names -ffb // do not establish a separate scope for declares within for clauses +fsv // track static variables +fll // enable long long types +fqb // expect const and volatile before type +e900 // print total number of errors/warnings -d__USE_GNU=1 scripts\pclint\lint_cfg.lnt // include project specific settings scripts\pclint\policy.lnt // pclint rules from nuinno -esym(123,min,max) // allows users to use min, max as variables // Disable unwanted warnings //-strong(AB,bool) //-strong(AB,boolean) //-strong(AJX) // all typedef must match exactly // create output that is understood from Jenkins +ffn // force full path names -width(0) // don't insert line breaks (unlimited output width). -hF1 // set message height one +program_info(output_prefix = "tests\pclint\pclint_") // make error format same as GCC to display it in Eclipse -"format=%(%f:%l:%C:%) %t %n: %m" -frl // Enable warning 831 +flm // make sure no foreign includes change the format // env-xml.lnt // create output in xml format // -"format_stack=%-20f %5a %-20t %5n %c %e" // +stack( &file=test\pclint\pclint-stack-report.txt ) uncrustify-uncrustify-0.76.0/scripts/pclint/policy.lnt000066400000000000000000000507151434072136500232430ustar00rootroot00000000000000// uncrustify policy -passes(2) // number of analysis passes (higher values give better detection but slower) -static_depth(2) // number of analyzed redirection for static variables //-w2 // suppress informational messages // -strong(AJX) // All typedefs must match exactly -w3 // display informational messages //-w4 // use the maximum warning level //+fpn // warns about the use of pointer parameters without first checking for NULL //+fsc // assumes string constants are const char* // all checks from 0 to 599 are enabled by +w2 -e10 // Expecting identifier or other declarator -e18 // symbol redefined -e19 // useless declaration -e14 // symbol previously defined -e26 // expected an expression found const/return -e30 // expected an integer constant -e31 // redefinition of symbol -e32 // field size should not be zero -e36 // redefining the storage class of symbol -e40 // undeclared identifier -e46 // field type should be an integral or enumeration type -e48 // bad type -e49 // expected a typed -e50 // attempted to take the address of a non-lvalue -e52 // expected an lvalue -e55 // bad type -e56 // bad type -e63 // expected an lvalue -e64 // type mismatch -e78 // typedef'd symbol used in expression -e85 // array has dimension 0 -e96 // unmatched left brace for linkage specification -e114 // inconsistent -e119 // too many arguments -e123 // macro defined with arguments -e129 // declaration expected -e200 // internal error -e438 // last value assignd to variable not used -e451 // header without include guard -e457 // enable for checking multithreading -e458 // enable for checking multithreading -e459 // enable for checking multithreading -e506 // allow constant value booleans -e514 // unusual use of boolean expression -e516 // symbol has arg type conflict -e520 // highest operation lacks side effects -e522 // highest operation lacks side effects -e526 // symbol not defined -e528 // symbol not referenced -e534 // ignoring return value of function -e537 // do not warn about repeated inclusion -e574 // signed / unsigned mix with relational -e578 // Declaration of symbol hides symbol -e585 // not a valid Trigraph sequence +e601 // Expected a type for symbol Symbol +e602 // Comment within comment +e603 // Symbol not initialized +e604 // Returning address of auto variable +e605 // Increase in pointer capability +e606 // Non-ANSI escape sequence: +e607 // Parameter of macro found within string +e608 // Assigning to an array parameter +e609 // Suspicious pointer conversion +e610 // Suspicious pointer combination +e611 // Suspicious cast +e612 // Expected a declarator -e613 // Possible use of null pointer +e614 // auto aggregate initializer not constant +e615 // auto aggregate initializer has side effects +e616 // control flows into case/default +e617 // String is both a module and an include file +e618 // Storage class specified after a type +e619 // Loss of precision (Context) (Pointer to Pointer) +e620 // Suspicious constant (small L or one?) +e621 // Identifier clash +e622 // Size of argument no. Integer inconsistent with format +e623 // redefining the storage class of symbol +e624 // typedef redeclared +e625 // auto symbol has unusual type modifier +e626 // Integer inconsistent with format +e627 // indirect object inconsistent with format -e628 // no argument information provided for function +e629 // static class for function is non standard +e630 // ambiguous reference to symbol +e631 // tag 'Symbol' defined differently at Location +e632 // Assignment to strong type +e633 // Assignment from a strong type +e634 // Strong type mismatch in equality or conditional +e635 // resetting strong parent of type +e636 // ptr to strong type versus another type +e637 // Expected index type for strong type +e638 // Strong type mismatch for type in relational +e639 // Strong type mismatch for type in binary operation +e640 // Expected strong type 'Name' in Boolean context -e641 // Converting enum to int +e642 // Format char 'Char' not supported by wsprintf +e643 // Loss of precision in pointer cast +e644 // Variable may not have been initialized +e645 // Symbol may not have been initialized +e646 // case/default within Kind loop; may have been misplaced +e647 // Suspicious truncation +e648 // Overflow in computing constant for operation: +e649 // Sign fill during constant shift +e650 // Constant out of range for operator +e651 // Potentially confusing initializer -e652 // #define of symbol 'Symbol' declared previously +e653 // Possible loss of fraction +e654 // Option String obsolete; use -width(W,I) -e655 // bit-wise operation uses (compatible) enum's +e656 // Arithmetic operation uses (compatible) enum's +e657 // Unusual (nonportable) anonymous struct or union +e658 // Anonymous union assumed +e659 // Nothing follows '}' +e660 // Option requests removing an extent that is not on the list +e661 // possible access of out-of-bounds pointer +e662 // possible creation of out-of-bounds pointer +e663 // Suspicious array to pointer conversion +e664 // Left side of logical OR (||) or logical AND (&&) does not return +e665 // Unparenthesized parameter Integer in macro is passed an expression +e666 // Expression with side effects passed to repeated parameter +e667 // Inconsistent use of qualifiers for symbol +e668 // Possibly passing a null pointer to function +e669 // Possible data overrun for function +e670 // Possible access beyond array for function +e671 // Possibly passing to function a negative value +e672 // Possible memory leak in assignment to pointer +e673 // Possibly inappropriate deallocation +e674 // Returning address of auto through variable +e675 // No prior semantics associated with symbol +e676 // Possibly negative subscript +e677 // sizeof used within preprocessor statement +e678 // Member field length (Integer) too small for enum precision +e679 // Suspicious Truncation in arithmetic expression combining with pointer +e680 // Suspicious Truncation in arithmetic expression converted to pointer +e681 // Loop is not entered +e682 // sizeof applied to a parameter whose type is a sized array +e683 // function 'Symbol' #define'd +e684 // Passing address of auto variable into caller space +e685 // Relational operator always evaluates to same result +e686 // Option is suspicious +e687 // Suspicious use of comma operator +e688 // Cast used within preprocessor conditional statement +e689 // Apparent end of comment ignored +e690 // Possible access of pointer pointing Integer bytes past null character by operator +e691 // Suspicious use of backslash +e692 // Decimal character follows octal escape sequence +e693 // Hexadecimal digit immediately after is suspicious in string literal. +e694 // The type of constant (precision Integer) is dialect dependent +e695 // Inline function defined without a storage-class specifier ('static' recommended) +e696 // Variable has value that is out of range for operator +e697 // Quasi-boolean values should be equality-compared only with 0 +e698 // Casual use of realloc can create a memory leak +e701 // Shift left of signed int variable -e702 // Shift right of signed int variable +e703 // Shift left of signed long variable +e704 // Shift right of signed long variable +e705 // Integer nominally inconsistent with format +e706 // indirect object inconsistent with format +e707 // Mixing narrow and wide string literals in concatenation +e708 // union initialization -e712 // Loss of precision -e713 // Loss of precision -e714 // external variable not referenced -e715 // Symbol not referenced -e716 // while(1) found, allow endless loops -e717 // do ... while(0) found +e718 // Symbol undeclared, assumed to return int +e719 // Too many arguments for format +e720 // Boolean test of assignment +e721 // Suspicious use of ; +e722 // Suspicious use of ; +e723 // Suspicious use of = -- A preprocessor definition began with an = sign. +e725 // Expected positive indentation from Location -e726 // Extraneous comma ignored +e727 // local static variable not explicitly initialized +e728 // global static variable not explicitly initialized +e729 // exteral variable not explicitly initialized -e730 // Boolean argument to function -e731 // Boolean argument to equal/not equal -e732 // Loss of sign +e733 // Assigning address of auto variable to outer scope symbol +e734 // Loss of precision int +e735 // Loss of precision double +e736 // Loss of precision float -e737 // Loss of sign in promotion from Type1 to Type2 +e738 // Symbol not explicitly initialized +e739 // Trigraph Sequence in literal (Quiet Change) +e740 // Unusual pointer cast (incompatible indirect types) +e741 // Unusual pointer cast (function qualification) +e742 // Multiple character constant +e743 // Negative character constant +e744 // switch statement has no default +e745 // function has no explicit type or class, int assumed +e746 // call to function not made in the presence of a prototype -e747 // (noisy when using bool) Significant prototype coercion Type1 to Type2 +e748 // Symbol is a register variable used with setjmp -e749 // check for unused enum values -e750 // ignore unused local macros -e751 // check for unused local typedefs -e752 // check for unused local declarations -e753 // check for unused local struct, union or enum tag -e754 // check for unused local structure member -e755 // ignore unused global macros -e756 // check for unused global typedefs -e757 // check for unused global declarations -e758 // check for unused global struct, union or enum tag -e759 // check if symbol can be moved from header to module +e760 // check for redundant macros -e761 // check for redundant typedefs +e762 // check for redundantly declared symbol +e763 // check for redundant declaration for symbol +e764 // check for switch statement without a case -e765 // check for external symbols that could be made static +e766 // check for unused headers +e767 // check for differing macros -e768 // check for global struct member that is never referenced -e769 // check for global enumeration constant that is never referenced +e770 // tag is defined identically at several locations +e771 // check for uninitialized symbols +e772 // check for uninitialized symbols +e773 // Expression-like macro not parenthesized -e774 // Boolean within 'String' always evaluates to [True/False] +e775 // non-negative quantity cannot be less than zero +e776 // Possible truncation of addition +e777 // Testing float's for equality -e778 // Constant expression evaluates to 0 +e779 // String constant in comparison operator +e780 // Vacuous array element +e782 // Line exceeds Integer characters +e783 // Line does not end with new-line +e784 // Nul character truncated from string +e785 // Too few initializers for aggregate +e786 // String concatenation within initializer +e787 // enum constant should not be used within switch -e788 // enum constant not used within defaulted switch +e789 // Assigning address of auto variable to static +e790 // Suspicious truncation, integral to float +e791 // unusual option sequence +e792 // void cast of void expression +e793 // ANSI/ISO limit of String 'Name' exceeded +e794 // Conceivable use of null pointer +e795 // Conceivable division by 0 +e796 // Conceivable access of out-of-bounds pointer +e797 // Conceivable creation of out-of-bounds pointer +e798 // Redundant character +e799 // numerical constant 'Integer' larger than unsigned long -e801 // Use of goto is deprecated +e802 // Conceivably passing a null pointer to function +e803 // Conceivable data overrun for function +e804 // Conceivable access beyond array for function +e805 // Expected L"..." to initialize wide char string +e806 // Small bit field is signed rather than unsigned +e807 // Conceivably passing to function a negative value +e808 // No explicit type given to symbol +e809 // Possible return of address of auto through variable +e810 // Arithmetic modification of custodial variable +e811 // Possible deallocation of pointer alias +e812 // static variable 'Symbol' has size 'Integer' +e813 // auto variable 'Symbol' in function 'Symbol' has size 'Integer' +e814 // useless declaration +e815 // Arithmetic modification of unsaved pointer +e816 // Non-ANSI format specification +e817 // Conceivably negative subscript -e818 // Pointer parameter could be declared ptr to const +e820 // Boolean test of a parenthesized assignment +e821 // Right hand side of assignment not parenthesized +e825 // control flows into case/default without -fallthrough comment +e826 // Suspicious pointer-to-pointer conversion +e827 // Loop not reachable +e828 // redefinition of functions +e829 // dangerous header was used +e830 // print error location indicator +e831 // print error location indicator +e832 // Parameter 'Symbol' not explicitly declared +e833 // Symbol is typed differently in another module -e834 // missing parentheses between operators -e835 // A zero has been given as [left/right] argument to operator +e836 // Conceivable access of pointer pointing Integer bytes past nul +e838 // Previously assigned value to variable has not been used +e839 // Storage class of symbol 'Symbol' assumed static +e840 // Use of null character in a string literal -e843 // Variable 'Symbol' (Location) could be declared as const +e844 // Pointer variable could be declared as pointing to const -e845 // The [left/right] argument to operator is certain to be 0 +e846 // Signedness of bit-field is implementation defined +e847 // Thread has unprotected call to thread unsafe function +e849 // Two enumerators have the same value -e850 // loop index variable is modified in body of the for loop -e864 // Expression possibly depends on order of evaluation +e866 // Unusual use of 'String' in argument to sizeof +e900 // print total number of errors/warnings -e904 // Return statement before end of function 'Symbol' +e905 // Non-literal format specifier used (with arguments) -e909 // Implicit conversion from Type to bool -e910 // Implicit conversion (Context) from 0 to pointer -e911 // (noisy) Implicit expression promotion from Type to Type -e912 // (noisy) Implicit binary conversion from Type1 to Type2 +e913 // Implicit adjustment of expected argument type from Type1 to Type2 +e914 // Implicit adjustment of function return value from Type1 to Type2 -e915 // (noisy) Implicit conversion (Context) Type1 to Type2 -e916 // Implicit pointer assignment conversion -e917 // (noisy) Prototype coercion Type1 to Type2 -e918 // Prototype coercion (Context) of pointers -e919 // (noisy) Implicit conversion (Context) Type to Type -e920 // Cast from Type to void -e931 // Both sides have side effects +e932 // Passing near pointer to library function 'Symbol' +e933 // Passing near pointer to far function (Context) +e934 // taking address of near auto variable 'Symbol' -e935 // (noisy) int within struct +e936 // type is missing for function arguments +e937 // type is missing for function arguments +e939 // return type is missing for function +e940 // omitted braces within an initialize +e943 // Too few initializers for aggregate +e945 // Undefined struct used with extern -e946 // Relational or subtract operator applied to pointers +e947 // Subtract operator applied to pointers -e950 // Non-ISO/ANSI reserved word or construct: +e951 // Pointer to incomplete type employed in operation -e952 // Parameter could be declared const -e953 // Variable could be declared as const -e954 // Pointer variable could be declared as pointing to a const +e955 // Parameter name missing from prototype for function -e956 // (use for multithreaded SW) Non const, non volatile static or external variable +e957 // Function defined without a prototype in scope -e958 // (can help to save some bytes of memory) Padding of Integer byte(s) is required to align string on Integer byte boundary +e962 // Macro defined identically at another location +e963 // expect modifier (const, volatile) before type -e964 // Header file not directly used in module -e966 // Indirectly included header file 'FileName' not used in module +e967 // Header file 'FileName' does not have a standard include guard -e970 // (noisy) Use of modifier or type outside of a typedef -e971 // (noisy) Use of 'char' without 'signed' or 'unsigned' +e974 // print Worst case function for stack usage: -e1013 // symbol is not a member of class -e1015 // symbol not found in class -e1025 // no function or template matches invocation -e1039 // symbol is not a member of class -e1040 // symbol is not a legal declaration within class -e1042 // a least one class like operand is required with operator -e1048 // expected a constant expression -e1051 // symbol is both a function and a variable -e1052 // a type was expected, class assumed -e1054 // template variable declaration expects a type -e1055 // symbol undeclared, assumed to return int -e1057 // member cannot be used without an object -e1058 // initializing a non-const reference -e1065 // symbol not declared as "C" -e1062 // template must be either a class or a function -e1066 // symbol declared as "C" -e1075 // Ambiguous reference to symbol -e1077 // could not evaluate default template parameter -e1086 // do not warn about compount literals -e1087 // previous declaration is incompatible -e1401 // member not initialized by constructor -e1502 // object has no nonstatic data member -e1526 // Member function not defined -e1529 // symbol not first checking for assignment to this -e1536 // exposing low access member -e1540 // pointer member neither freed nor zeroed by destructor -e1551 // function may throw exception in destructor -e1554 // direct pointer copy of member within copy constructor -e1561 // reference initialization causes loss of const/volatile -e1566 // member might have been initialized by a separate function -e1702 // operator is both an ordinary function and a member function -e1704 // constructor has private access specification -e1711 // function needs not to be virtual -e1712 // default constructor not defined for class -e1714 // Member function not referenced -e1725 // class member is a reference -e1732 // constructor for class has no assignment operator -e1733 // constructor for class has no copy constructor -e1736 // redundant access specifier -e1740 // pointer member not directly freed or zeroed by destructor -e1746 // parameter could be made const reference -e1757 // discarded instance of post decrement/increment -e1762 // member could be made const -e1764 // reference parameter could be declared const -e1776 // converting a string literal to char* -e1786 // implicit conversion to bool -e1788 // variable is referenced only by its constructor or destructor -e1795 // Template was defined but not instantiated -e1904 // allow old style comments -e1923 // ignore defines that could be const variables -e1924 // C-style cast //scripts/pclint/au-sm123.lnt // also check Scott Meyers rules of all three books //scripts/pclint/au-misra3.lnt // Misra 2012 rules //scripts/pclint/au-barr10.lnt // Top 10 Bug-Killing Rules //scripts/pclint/au-ds.lnt // Dan Saks uncrustify-uncrustify-0.76.0/scripts/pclint/run-pclint-eclipse.bat000066400000000000000000000103731434072136500254260ustar00rootroot00000000000000rem set to on for debugging @echo off setlocal rem Run this script from the project root directory echo ------------------------------------------------------ echo Start pcLint analysis to check code quality ... set SRC_DIR=src set EXC_DIR=lnt set OUT_DIR=tests\pclint set LNT_DIR=scripts\pclint rem Check if pcLint program is available set prog=lint-nt.exe for %%i in ("%path:;=";"%") do ( rem echo %%~i if exist %%~i\%prog% ( set found=%%i echo found %prog% in %%i ) ) if %found%=="" goto PROG_MISSING if NOT EXIST tests md tests if NOT EXIST tests\pclint md tests\pclint rem create list of all C source files to analyze rem FIXME: works only if there are no spaces in the paths dir /s/b %EXC_DIR%\*.lnt > .\%OUT_DIR%\exceptions.lnt rem to check single files activate one of the lines below rem dir /s/b %SRC_DIR%\align_stack.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\align.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\args.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\backup.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\brace_cleanup.cpp> .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\braces.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\chunk.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\ChunkStack.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\combine.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\compat_posix.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\compat_win32.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\defines.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\detect.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\indent.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\keywords.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\lang_pawn.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\logger.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\logmask.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\md5.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\newlines.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\options_for_QT.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\options.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\output.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\parens.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\parse_frame.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\punctuators.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\semicolons.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\sorting.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\space.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\tokenize_cleanup.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\tokenize.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\unc_text.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\unc_tools.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\uncrustify_emscripten.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\uncrustify.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\unicode.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\universalindentgui.cpp > .\%OUT_DIR%\files.lnt rem dir /s/b %SRC_DIR%\width.cpp > .\%OUT_DIR%\files.lnt rem to check all source files use the line below dir /s/b %SRC_DIR%\*.cpp > .\%OUT_DIR%\files.lnt rem use this to save the pclint errors to a file for later review rem lint-nt .\%LNT_DIR%\pclint_cfg_eclipse.lnt .\%OUT_DIR%\exceptions.lnt .\%OUT_DIR%\files.lnt > .\%OUT_DIR%\pclint-results.xml rem to make eclipse parse the pclint errors it has to be output to the console lint-nt .\%LNT_DIR%\pclint_cfg_eclipse.lnt .\%OUT_DIR%\exceptions.lnt .\%OUT_DIR%\files.lnt rem type %OUT_DIR%\pclint-results.xml | more rem type %OUT_DIR%\pclint-results.xml rem echo pcLint output placed in %OUT_DIR%\pclint-results.xml goto END :PROG_MISSING echo. echo ------------------------------------------------------ echo pcLint Error: %prog% not found. echo Verify that PCLINT is correctly installed, the echo installation was added to the PATH and the echo environment variable PCLINT_HOME was set to its path. echo ------------------------------------------------------ echo. goto END :END echo pcLint finished echo ------------------------------------------------------ endlocal uncrustify-uncrustify-0.76.0/scripts/pclint/usage.txt000066400000000000000000000016071434072136500230660ustar00rootroot00000000000000"pclint" is a static source code checker. It helps detecting programming errors during development. To run the check you need a license for pclint. The results can either be saved to a text file or be displayed on top of the source code when using Eclipse. The present configuration is ment for Windows using Mingw as toolchain. To run the check with another toolchain the paths in run-pclint-eclipse.bat need to be change. To run the check under Linux another tool called "flexelint" is required. Run the check from the top level directory of uncrustify by calling run-pclint-eclipse.bat To run the check from Eclipse create a new target and use the script as build command like that: ${workspace_loc:/uncrustify}/scripts/pclint/run-pclint-eclipse.bat The file policy.lnt determines which tests are performed. The more tests are used the longer it takes but the more precise will be the results. uncrustify-uncrustify-0.76.0/scripts/prepare_list_of_authors.sh000077500000000000000000000026201434072136500252050ustar00rootroot00000000000000#! /bin/sh # # Prepare the list of authors # guy maurel # 2022-11-22 # LIST_1="TheListOfAuthors.txt" echo "Author:" > ${LIST_1} echo "2005 - 2016 : Ben Gardner" >> ${LIST_1} echo "" >> ${LIST_1} echo "Maintenance:" >> ${LIST_1} echo "Guy Maurel" >> ${LIST_1} echo "Michele Calgaro" >> ${LIST_1} echo "Matthew Woehlke" >> ${LIST_1} echo "" >> ${LIST_1} echo "until 2022-11-22:" >> ${LIST_1} echo "Other collaborators:" >> ${LIST_1} git log --format='%aN' \ | sort -u \ | grep -v "^ben$" \ | grep -v "^bengardner$" \ | grep -v "^Ben Gardner$" \ | grep -v "^CDanU$" \ | grep -v "^DVE2000$" \ | grep -v "^Gilles$" \ | grep -v "^Guy Maurel$" \ | grep -v "^brmqk3$" \ | grep -v "^csobeski$" \ | grep -v "^dbeard$" \ | grep -v "^dundargoc$" \ | grep -v "^fwojcik$" \ | grep -v "^gmaurel$" \ | grep -v "^hdwobben$" \ | grep -v "^ipaterson$" \ | grep -v "^jlee975$" \ | grep -v "^logan.gauthier@metova.com$" \ | grep -v "^micheleCTDE$" \ | grep -v "^micheleCTDEAdmin$" \ | grep -v "^nivekkagicom$" \ | grep -v "^Pawel Benetkiewicz$" \ | grep -v "^popipo$" \ | grep -v "^raefaldhia$" \ | grep -v "^rdan$" \ | grep -v "^tpltnt$" \ | grep -v "^versusvoid$" \ | grep -v "^void$" \ >> ${LIST_1} # mv ${LIST_1} AUTHORS uncrustify-uncrustify-0.76.0/scripts/release_tool.py000077500000000000000000000203321434072136500227560ustar00rootroot00000000000000#!/usr/bin/env python import argparse import git import os import re import sys if sys.version_info[0] < 3: input = raw_input re_desc = re.compile(r'^uncrustify-([0-9]+[.][0-9]+[.][0-9]+)') re_branch = re.compile(r'^uncrustify-RC-([0-9]+[.][0-9]+[.][0-9]+)') re_merge = re.compile(r'^Merge pull request #[0-9]+ from [^/]+/(.*)') re_version = re.compile(r'^[0-9]+[.][0-9]+[.][0-9]+$') re_option_count = re.compile(r'There are currently ([0-9]+) options') # ----------------------------------------------------------------------------- def fatal(msg): raise Exception(msg) # ----------------------------------------------------------------------------- def get_version_str(repo, candidate=True, required=True): if candidate: b = repo.git.symbolic_ref('-q', '--short', 'HEAD') m = re_branch.match(b) if m: return m.group(1) d = repo.git.describe('HEAD') m = re_desc.match(d) if m: return m.group(1) if required: fatal('Unable to determine current version') return None # ----------------------------------------------------------------------------- def get_version_info(repo, candidate=True, required=True): s = get_version_str(repo, candidate, required) return tuple(map(int, s.split('.'))) # ----------------------------------------------------------------------------- def get_option_count(executable): import subprocess out = subprocess.check_output([executable, '--count-options']) m = re_option_count.match(out.decode('utf-8')) if m is None: fatal('Failed to get option count from \'{}\''.format(executable)) return int(m.group(1)) # ----------------------------------------------------------------------------- def alter(repo, path, old, new): p = os.path.join(repo.working_tree_dir, path) with open(p, 'r') as f: content = f.read() content = re.sub(old, new, content) with open(p, 'w') as f: f.write(content) print('Updated: {}'.format(path)) # ----------------------------------------------------------------------------- def generate(repo, version, path, *args): import subprocess p = os.path.join(repo.working_tree_dir, path) with open(p, 'w') as f: c = subprocess.check_call(args, stdout=f) print('Created: {}'.format(path)) alter(repo, path, r'Uncrustify-[0-9.]+(-[0-9]+-[0-9a-f]+(-dirty)?)?', r'Uncrustify-{}'.format(version)) # ----------------------------------------------------------------------------- def cmd_init(repo, args): v = args.version if v is None: c = get_version_info(repo, candidate=False, required=False) if c: n = '.'.join(map(str, (c[0], c[1] + 1, 0))) v = input('Version to be created? [{}] '.format(n)) if len(v) == 0: v = n else: v = input('Version to be created? ') if not re_version.match(v): fatal('Bad version number, \'{}\''.format(v)) repo.git.checkout('-b', 'uncrustify-RC-{}'.format(v)) # ----------------------------------------------------------------------------- def cmd_update(repo, args): v = get_version_str(repo) c = get_option_count(args.executable) alter(repo, 'CMakeLists.txt', r'(set *[(] *UNCRUSTIFY_VERSION +")[0-9.]+', r'\g<1>{}'.format(v)) alter(repo, 'package.json', r'("version" *): *"[0-9.]+"', r'\g<1>: "{}"'.format(v)) alter(repo, 'README.md', r'[0-9]+ configurable options as of version [0-9.]+', r'{} configurable options as of version {}'.format(c, v)) alter(repo, 'documentation/htdocs/index.html', r'[0-9]+ configurable options as of version [0-9.]+', r'{} configurable options as of version {}'.format(c, v)) generate(repo, v, 'etc/defaults.cfg', args.executable, '--show-config') generate(repo, v, 'documentation/htdocs/default.cfg', args.executable, '--show-config') generate(repo, v, 'documentation/htdocs/config.txt', args.executable, '--show-config') generate(repo, v, 'etc/uigui_uncrustify.ini', args.executable, '--universalindent') # ----------------------------------------------------------------------------- def cmd_commit(repo, args): v = get_version_str(repo) message = 'Prepare Uncrustify v{} release'.format(v) extra_args = [] if args.amend: extra_args += ['--amend', '--date=now'] repo.git.commit('-m', message, *extra_args) # ----------------------------------------------------------------------------- def cmd_tag(repo, args): import uuid # Determine location of remote repository if args.ssh: s = 'git@{}:'.format(args.server) else: s = 'https://{}/'.format(args.server) r = '{}{}/{}.git'.format(s, args.organization, args.project) # Fetch upstream u = repo.create_remote(str(uuid.uuid4()), r) try: u.fetch(refspec='master') # Get log if hasattr(args, 'commit'): c = repo.commit(args.commit) else: c = repo.commit('{}/master'.format(u.name)) m = re_merge.match(c.message.split('\n')[0]) if m is None: fatal('Last commit is not a merge of a release candidate?') m = re_branch.match(m.group(1)) if m is None: fatal('Failed to extract version from release candidate merge') v = m.group(1) # Create and push tag extra_args = {} if args.force: extra_args['force_with_lease'] = True tag = 'uncrustify-{}'.format(v) message = 'Create Uncrustify v{} release'.format(v) repo.git.tag('-a', tag, c, '-m', message, '--force') u.push(refspec=tag, **extra_args) finally: repo.delete_remote(u) # ----------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser( description='Perform release-related actions') root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) parser.add_argument('--repo', type=str, default=root, help='path to uncrustify git repository') subparsers = parser.add_subparsers(title='subcommands', help='action to perform') parser_init = subparsers.add_parser( 'init', help='initialize new version') parser_init.set_defaults(func=cmd_init) parser_init.add_argument('-v', '--version', help='version number for release') parser_update = subparsers.add_parser( 'update', help='update version information') parser_update.set_defaults(func=cmd_update, keepversion=False) parser_update.add_argument('executable', help='path to uncrustify executable') parser_commit = subparsers.add_parser( 'commit', help='commit changes for new version') parser_commit.set_defaults(func=cmd_commit) parser_commit.add_argument('-a', '--amend', action='store_true', help='amend a previous release commit') parser_tag = subparsers.add_parser( 'tag', help='tag release and push tag to github') parser_tag.set_defaults(func=cmd_tag) parser_tag.add_argument('--ssh', action='store_true', help='use ssh (instead of HTTPS) to push') parser_tag.add_argument('-s', '--server', default='github.com', help='push to specified server') parser_tag.add_argument('-o', '--organization', default='uncrustify', help='push to specified user or organization') parser_tag.add_argument('-p', '--project', default='uncrustify', help='push to specified project') parser_tag.add_argument('-c', '--commit', help='tag specified commit ' '(instead of latest \'master\')') parser_tag.add_argument('-f', '--force', action='store_true', help='force push the tag') args = parser.parse_args() repo = git.Repo(args.repo) args.func(repo, args) return 0 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if __name__ == '__main__': sys.exit(main()) uncrustify-uncrustify-0.76.0/scripts/run_ctest.py000077500000000000000000000025361434072136500223150ustar00rootroot00000000000000#!/usr/bin/env python import argparse import math import os import subprocess import sys from multiprocessing import cpu_count default_jobs = min(cpu_count() + 2, cpu_count() * 2) # ----------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser(description='Run CTest') parser.add_argument('-q', '--quiet', action='store_true', help='suppress output of failing tests') parser.add_argument('-j', '--parallel', type=int, default=default_jobs, help='number of jobs to use for parallel execution') parser.add_argument('args', metavar='ARGS', nargs='*', default=[], help='additional arguments to pass to CTest') args = parser.parse_args() if not os.path.exists('CTestTestfile.cmake'): print('No test configuration file found!') print('(Note: This script must be run from your build directory.)') sys.exit(-1) cmd = ['ctest', '-j{}'.format(args.parallel)] if not args.quiet: cmd.append('--output-on-failure') cmd += args.args try: subprocess.check_call(cmd) except subprocess.CalledProcessError as exc: sys.exit(exc.returncode) # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if __name__ == '__main__': main() uncrustify-uncrustify-0.76.0/scripts/tokenizer.py000077500000000000000000000253211434072136500223160ustar00rootroot00000000000000#! /usr/bin/env python # tokenize.py # # Parses a C/C++/C#/D/Java/Pawn/whatever file in an array of # tuples (string, type) # # punctuator lookup table punc_table = [ [ '!', 25, 26, '!' ], # 0: '!' [ '#', 24, 35, '#' ], # 1: '#' [ '$', 23, 0, '$' ], # 2: '$' [ '%', 22, 36, '%' ], # 3: '%' [ '&', 21, 41, '&' ], # 4: '&' [ '(', 20, 0, '(' ], # 5: '(' [ ')', 19, 0, ')' ], # 6: ')' [ '*', 18, 43, '*' ], # 7: '*' [ '+', 17, 44, '+' ], # 8: '+' [ ',', 16, 0, ',' ], # 9: ',' [ '-', 15, 46, '-' ], # 10: '-' [ '.', 14, 50, '.' ], # 11: '.' [ '/', 13, 53, '/' ], # 12: '/' [ ':', 12, 54, ':' ], # 13: ':' [ ';', 11, 0, ';' ], # 14: ';' [ '<', 10, 56, '<' ], # 15: '<' [ '=', 9, 63, '=' ], # 16: '=' [ '>', 8, 65, '>' ], # 17: '>' [ '?', 7, 0, '?' ], # 18: '?' [ '[', 6, 70, '[' ], # 19: '[' [ ']', 5, 0, ']' ], # 20: ']' [ '^', 4, 71, '^' ], # 21: '^' [ '{', 3, 0, '{' ], # 22: '{' [ '|', 2, 72, '|' ], # 23: '|' [ '}', 1, 0, '}' ], # 24: '}' [ '~', 0, 74, '~' ], # 25: '~' [ '<', 3, 30, '!<' ], # 26: '!<' [ '=', 2, 33, '!=' ], # 27: '!=' [ '>', 1, 34, '!>' ], # 28: '!>' [ '~', 0, 0, '!~' ], # 29: '!~' [ '=', 1, 0, '!<=' ], # 30: '!<=' [ '>', 0, 32, '!<>' ], # 31: '!<>' [ '=', 0, 0, '!<>='], # 32: '!<>=' [ '=', 0, 0, '!==' ], # 33: '!==' [ '=', 0, 0, '!>=' ], # 34: '!>=' [ '#', 0, 0, '##' ], # 35: '##' [ ':', 2, 39, '%:' ], # 36: '%:' [ '=', 1, 0, '%=' ], # 37: '%=' [ '>', 0, 0, '%>' ], # 38: '%>' [ '%', 0, 40, None ], # 39: '%:%' [ ':', 0, 0, '%:%:'], # 40: '%:%:' [ '&', 1, 0, '&&' ], # 41: '&&' [ '=', 0, 0, '&=' ], # 42: '&=' [ '=', 0, 0, '*=' ], # 43: '*=' [ '+', 1, 0, '++' ], # 44: '++' [ '=', 0, 0, '+=' ], # 45: '+=' [ '-', 2, 0, '--' ], # 46: '--' [ '=', 1, 0, '-=' ], # 47: '-=' [ '>', 0, 49, '->' ], # 48: '->' [ '*', 0, 0, '->*' ], # 49: '->*' [ '*', 1, 0, '.*' ], # 50: '.*' [ '.', 0, 52, '..' ], # 51: '..' [ '.', 0, 0, '...' ], # 52: '...' [ '=', 0, 0, '/=' ], # 53: '/=' [ ':', 1, 0, '::' ], # 54: '::' [ '>', 0, 0, ':>' ], # 55: ':>' [ '%', 4, 0, '<%' ], # 56: '<%' [ ':', 3, 0, '<:' ], # 57: '<:' [ '<', 2, 61, '<<' ], # 58: '<<' [ '=', 1, 0, '<=' ], # 59: '<=' [ '>', 0, 62, '<>' ], # 60: '<>' [ '=', 0, 0, '<<=' ], # 61: '<<=' [ '=', 0, 0, '<>=' ], # 62: '<>=' [ '=', 0, 64, '==' ], # 63: '==' [ '=', 0, 0, '===' ], # 64: '===' [ '=', 1, 0, '>=' ], # 65: '>=' [ '>', 0, 67, '>>' ], # 66: '>>' [ '=', 1, 0, '>>=' ], # 67: '>>=' [ '>', 0, 69, '>>>' ], # 68: '>>>' [ '=', 0, 0, '>>>='], # 69: '>>>=' [ ']', 0, 0, '[]' ], # 70: '[]' [ '=', 0, 0, '^=' ], # 71: '^=' [ '=', 1, 0, '|=' ], # 72: '|=' [ '|', 0, 0, '||' ], # 73: '||' [ '=', 1, 0, '~=' ], # 74: '~=' [ '~', 0, 0, '~~' ], # 75: '~~' ] # # Token types: # 0 = newline # 1 = punctuator # 2 = integer # 3 = float # 4 = string # 5 = identifier # class Tokenizer: def __init__(self): self.tokens = [] self.text = '' self.text_idx = 0 def tokenize_text(self, in_text): self.tokens = [] self.text = in_text self.text_idx = 0 print(in_text) try: while self.text_idx < len(self.text): if self.parse_whitespace(): continue elif self.text[self.text_idx] == '\\' and self.text[self.text_idx + 1] == '\n': self.text_idx += 2 continue elif self.parse_comment(): continue elif self.parse_number(): continue elif self.parse_identifier(): continue elif self.parse_string(): continue elif self.parse_punctuator(): continue else: print("confused: %s" % self.text[self.text_idx:]) break except: print("bombed") raise def parse_whitespace(self): start_idx = self.text_idx hit_newline = False while self.text_idx < len(self.text): if self.text[self.text_idx] in '\n\r': hit_newline = True elif not self.text[self.text_idx] in ' \t': break self.text_idx += 1 if hit_newline: self.tokens.append(('\n', 0)) return start_idx != self.text_idx def parse_comment(self): if not self.text[self.text_idx] == '/' or not self.text[self.text_idx + 1] in '/*': return False if self.text[self.text_idx + 1] == '/': while self.text_idx < len(self.text): if self.text[self.text_idx] in '\n\r': break self.text_idx += 1 else: while self.text_idx < len(self.text) - 1: if self.text[self.text_idx] == '*' and self.text[self.text_idx + 1] == '/': self.text_idx += 2 break self.text_idx += 1 return True def parse_identifier(self): if not self.text[self.text_idx].upper() in '@_ABCDEFGHIJKLMNOPQRSTUVWXYZ': return False start_idx = self.text_idx while self.text_idx < len(self.text) and \ self.text[self.text_idx].upper() in '@_ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890': self.text_idx += 1 self.tokens.append((self.text[start_idx : self.text_idx], 5)) return True def parse_string(self): starter = 0 start_ch = self.text[self.text_idx] if start_ch == 'L': starter = 1 start_ch = self.text[self.text_idx + 1] if not start_ch in '"\'': return False start_idx = self.text_idx self.text_idx += starter + 1 escaped = False while self.text_idx < len(self.text): if escaped: escaped = False else: if self.text[self.text_idx] == '\\': escaped = True elif self.text[self.text_idx] == start_ch: self.text_idx += 1 break self.text_idx += 1 self.tokens.append((self.text[start_idx : self.text_idx], 4)) return True # Checks for punctuators # Returns whether a punctuator was consumed (True or False) def parse_punctuator(self): tab_idx = 0 punc_len = 0 saved_punc = None while 1: pte = punc_table[tab_idx] if pte[0] == self.text[self.text_idx]: if pte[3] is not None: saved_punc = pte[3] self.text_idx += 1 tab_idx = pte[2] if tab_idx == 0: break elif pte[1] == 0: break else: tab_idx += 1 if saved_punc is not None: self.tokens.append((saved_punc, 1)) return True return False def parse_number(self): # A number must start with a digit or a dot followed by a digit ch = self.text[self.text_idx] if not ch.isdigit() and (ch != '.' or not self.text[self.text_idx + 1].isdigit()): return False token_type = 2 # integer if ch == '.': token_type = 3 # float did_hex = False start_idx = self.text_idx # Check for Hex, Octal, or Binary # Note that only D and Pawn support binary, but who cares? # if ch == '0': self.text_idx += 1 ch = self.text[self.text_idx].upper() if ch == 'X': # hex did_hex = True self.text_idx += 1 while self.text[self.text_idx] in '_0123456789abcdefABCDEF': self.text_idx += 1 elif ch == 'B': # binary self.text_idx += 1 while self.text[self.text_idx] in '_01': self.text_idx += 1 elif ch >= '0' and ch <= 7: # octal (but allow decimal) self.text_idx += 1 while self.text[self.text_idx] in '_0123456789': self.text_idx += 1 else: # either just 0 or 0.1 or 0UL, etc pass else: # Regular int or float while self.text[self.text_idx] in '_0123456789': self.text_idx += 1 # Check if we stopped on a decimal point if self.text[self.text_idx] == '.': self.text_idx += 1 token_type = 3 # float if did_hex: while self.text[self.text_idx] in '_0123456789abcdefABCDEF': self.text_idx += 1 else: while self.text[self.text_idx] in '_0123456789': self.text_idx += 1 # Check exponent # Valid exponents per language (not that it matters): # C/C++/D/Java: eEpP # C#/Pawn: eE if self.text[self.text_idx] in 'eEpP': token_type = 3 # float self.text_idx += 1 if self.text[self.text_idx] in '+-': self.text_idx += 1 while self.text[self.text_idx] in '_0123456789': self.text_idx += 1 # Check the suffixes # Valid suffixes per language (not that it matters): # Integer Float # C/C++: uUlL lLfF # C#: uUlL fFdDMm # D: uUL ifFL # Java: lL fFdD # Pawn: (none) (none) # # Note that i, f, d, and m only appear in floats. while 1: if self.text[self.text_idx] in 'tTfFdDmM': token_type = 3 # float elif not self.text[self.text_idx] in 'lLuU': break self.text_idx += 1 self.tokens.append((self.text[start_idx : self.text_idx], token_type)) return True text = """ 1.23+4-3*16%2 *sin(1.e-3 + .5p32) "hello" and "hello\\"there" 123 // some comment a = b + c; #define abc \\ 5 d = 5 /* hello */ + 3; """ t = Tokenizer() t.tokenize_text(text) print(t.tokens) uncrustify-uncrustify-0.76.0/scripts/update_emscripten_bindings.py000066400000000000000000000231421434072136500256700ustar00rootroot00000000000000#!/bin/python from __future__ import print_function # python >= 2.6, chained 'with' >= 2.7 from os.path import dirname, abspath from os import fdopen as os_fdopen, remove as os_remove, name as os_name from shutil import copy2 from subprocess import Popen, PIPE from sys import exit as sys_exit, stderr from tempfile import mkstemp from contextlib import contextmanager from threading import Timer import re ROOT_DIR = dirname(dirname(abspath(__file__))) # ============================================================================== FILE_BINDINGS = "%s/src/uncrustify_emscripten.cpp" % ROOT_DIR FILE_TS = "%s/emscripten/libUncrustify.d.ts" % ROOT_DIR REGION_START = "region enum bindings" REGION_END = "endregion enum bindings" ''' Enums which values need to be updated in the binding code ''' ENUMS_INFO = [ { 'name': 'option_type_e', 'substitute_name': 'OptionType', 'filepath': '%s/src/option.h' % ROOT_DIR, 'extra_arg': [], 'filter_values': [], 'suffix_chars': 0, }, { 'name': 'iarf_e', 'substitute_name': 'IARF', 'filepath': '%s/src/option.h' % ROOT_DIR, 'extra_arg': [], 'filter_values': ['NOT_DEFINED'], 'suffix_chars': 0, }, { 'name': 'line_end_e', 'substitute_name': 'LineEnd', 'filepath': '%s/src/option.h' % ROOT_DIR, 'extra_arg': [], 'filter_values': [], 'suffix_chars': 0, }, { 'name': 'token_pos_e', 'substitute_name': 'TokenPos', 'filepath': '%s/src/option.h' % ROOT_DIR, 'extra_arg': [], 'filter_values': [], 'suffix_chars': 0, }, { 'name': 'log_sev_t', 'substitute_name': 'LogType', 'filepath': '%s/src/log_levels.h' % ROOT_DIR, 'extra_arg': [], 'filter_values': [], 'suffix_chars': 1, }, { 'name': 'E_Token', 'substitute_name': 'TokenType', 'filepath': '%s/src/token_enum.h' % ROOT_DIR, 'extra_arg': [], 'filter_values': ['CT_TOKEN_COUNT_'], 'suffix_chars': 3, }, { 'name': 'lang_flag_e', 'substitute_name': 'Language', 'filepath': '%s/src/uncrustify_types.h' % ROOT_DIR, 'extra_arg': ["-extra-arg=-std=c++1z", "-extra-arg=-DEMSCRIPTEN"], 'filter_values': [ 'LANG_ALLC', 'LANG_ALL', 'FLAG_HDR', 'FLAG_DIG', 'FLAG_PP', ], 'suffix_chars': 5, }, ] # ============================================================================== NULL_DEV = "/dev/null" if os_name != "nt" else "nul" @contextmanager def make_raw_temp_file(*args, **kwargs): fd, tmp_file_name = mkstemp(*args, **kwargs) try: yield (fd, tmp_file_name) finally: os_remove(tmp_file_name) @contextmanager def open_fd(*args, **kwargs): fp = os_fdopen(*args, **kwargs) try: yield fp finally: fp.close() def term_proc(proc, timeout): """ helper function terminate a process if a timer times out :param proc: the process object that is going to be terminated :param timeout: value that will be set to indicate termination """ timeout["value"] = True proc.terminate() def proc_output(args, timeout_sec=10): """ grabs output from called program :param args: string array containing program name and program arguments :param timeout_sec: max sec the program can run without being terminated :return: utf8 decoded program output in a string """ proc = Popen(args, stdout=PIPE) timeout = {"value": False} if timeout_sec is not None: timeout = {"value": False} timer = Timer(timeout_sec, term_proc, [proc, timeout]) timer.start() output_b, error_txt_b = proc.communicate() if timeout_sec is not None: timer.cancel() output = output_b.decode("UTF-8") if timeout["value"]: print("proc timeout: %s" % ' '.join(args), file=stderr) return output if not timeout["value"] else None def get_enum_lines(enum_info): """ extracts enum values from a file via clang-check :param enum_info: dict with: 'name' (name of the enum), 'filepath' (file containing the enum definition), 'extra_arg' (extra arguments passed to clang-check) :return: list containing enum values """ cut_len = len(enum_info['name']) proc_args = ["clang-check", enum_info['filepath'], "-ast-dump", '-ast-dump-filter=%s' % enum_info['name']] proc_args += enum_info['extra_arg'] output = proc_output(proc_args) if output is None or len(output) == 0: print("ScriptError: %s - empty clang-check return" % get_enum_lines.__name__, file=stderr) return () reg_obj = re.compile("EnumConstantDecl.+col:\d+ (referenced )?(\w+)") lines = [m.group(2) for l in output.splitlines() for m in [re.search(reg_obj, l)] if m] lines = [line for line in lines if line not in enum_info['filter_values']] if len(lines) == 0: print("ScriptError: %s - no enum_info names found" % get_enum_lines.__name__, file=stderr) return () return lines def write_ts(opened_file_obj, enum_info): """ writes enum values in a specific typescript d.ts file format :param opened_file_obj: opened file file object (with write permissions) :param enum_info: dict with: 'name' (name of the enum), 'substitute_name' (substitute name for the enum), 'filepath' (file containing the enum definition), 'extra_arg' (extra arguments passed to clang-check) :return: False on failure else True """ lines = get_enum_lines(enum_info) if len(lines) == 0: return False opened_file_obj.write( ' export interface %sValue extends EmscriptenEnumTypeObject {}\n' ' export interface %s extends EmscriptenEnumType\n' ' {\n' % (enum_info['substitute_name'], enum_info['substitute_name']) ) for line in lines: opened_file_obj.write( ' %s : %sValue;\n' % (line[enum_info['suffix_chars']:], enum_info['substitute_name']) ) opened_file_obj.write( ' }\n\n' ) return True def write_bindings(opened_file_obj, enum_info): """ writes enum values in a specific emscripten embind enum bindings format :param opened_file_obj: opened file file object (with write permissions) :param enum_info: dict with: 'name' (name of the enum), 'filepath' (file containing the enum definition), 'extra_arg' (extra arguments passed to clang-check) :return: False on failure else True """ lines = get_enum_lines(enum_info) if len(lines) == 0: return False opened_file_obj.write( ' enum_<%s>("%s")' % (enum_info['name'], enum_info['substitute_name']) ) for line in lines: opened_file_obj.write( '\n .value("%s", %s::%s)' % (line[enum_info['suffix_chars']:], enum_info['name'], line) ) opened_file_obj.write( ';\n\n' ) return True def update_file(file_path, writer_func, enums_info): """ reads in a file and replaces old enum value in a region, which is defined by region start and end string, with updated ones :param file_path: file in which the replacement will be made :param writer_func: name of the function that will be called to write new content :param enums_info:list of dicts each containing: 'name' (name of the enum), 'substitute_name' (substitute name for the enum), 'filepath' (file containing the enum definition), 'extra_arg' (extra arguments passed to clang-check) :return: False on failure else True """ in_target_region = False reg_obj_start = re.compile(".*%s$" % REGION_START) reg_obj_end = re.compile(".*%s$" % REGION_END) reg_obj = reg_obj_start with make_raw_temp_file(suffix='.unc') as (fd, tmp_file_path): with open(file_path, 'r') as fr, open_fd(fd, 'w') as fw: for line in fr: match = None if reg_obj is None else re.search(reg_obj, line) if match is None and not in_target_region: fw.write(line) # write out of region code elif match is not None and not in_target_region: fw.write(line) # hit the start region in_target_region = True reg_obj = reg_obj_end for enum in enums_info: succes_flag = writer_func(fw, enum) if not succes_flag: # abort, keep input file clean return False elif match is None and in_target_region: pass # ignore old binding code elif match and in_target_region: # hit the endregion fw.write(line) in_target_region = False reg_obj = None copy2(tmp_file_path, file_path) # overwrite input file return True def main(): flag = update_file(FILE_BINDINGS, write_bindings, ENUMS_INFO) if not flag: return 1 flag = update_file(FILE_TS, write_ts, ENUMS_INFO) if not flag: return 1 return 0 if __name__ == "__main__": sys_exit(main()) uncrustify-uncrustify-0.76.0/src/000077500000000000000000000000001434072136500170245ustar00rootroot00000000000000uncrustify-uncrustify-0.76.0/src/.kateconfig000066400000000000000000000000261434072136500211350ustar00rootroot00000000000000kate: indent-width 3; uncrustify-uncrustify-0.76.0/src/ChunkStack.cpp000066400000000000000000000034631434072136500215740ustar00rootroot00000000000000/** * @file ChunkStack.cpp * Manages a chunk stack * * @author Ben Gardner * @license GPL v2+ */ #include "ChunkStack.h" void ChunkStack::Set(const ChunkStack &cs) { m_cse.resize(cs.m_cse.size()); for (size_t idx = 0; idx < m_cse.size(); idx++) { m_cse[idx].m_pc = cs.m_cse[idx].m_pc; m_cse[idx].m_seqnum = cs.m_cse[idx].m_seqnum; } m_seqnum = cs.m_seqnum; } const ChunkStack::Entry *ChunkStack::Top() const { if (!m_cse.empty()) { return(&m_cse[m_cse.size() - 1]); } return(nullptr); } const ChunkStack::Entry *ChunkStack::Get(size_t idx) const { if (idx < m_cse.size()) { return(&m_cse[idx]); } return(nullptr); } Chunk *ChunkStack::GetChunk(size_t idx) const { if (idx < m_cse.size()) { return(m_cse[idx].m_pc); } return(nullptr); } Chunk *ChunkStack::Pop_Front() { Chunk *pc = nullptr; if (!m_cse.empty()) { pc = m_cse[0].m_pc; m_cse.pop_front(); } return(pc); } Chunk *ChunkStack::Pop_Back() { Chunk *pc = nullptr; if (!m_cse.empty()) { pc = m_cse[m_cse.size() - 1].m_pc; m_cse.pop_back(); } return(pc); } void ChunkStack::Push_Back(Chunk *pc, size_t seqnum) { m_cse.push_back(Entry(seqnum, pc)); if (m_seqnum < seqnum) { m_seqnum = seqnum; } } void ChunkStack::Zap(size_t idx) { if (idx < m_cse.size()) { m_cse[idx].m_pc = nullptr; } } void ChunkStack::Collapse() { size_t wr_idx = 0; for (size_t rd_idx = 0; rd_idx < m_cse.size(); rd_idx++) { if (m_cse[rd_idx].m_pc != nullptr) { if (rd_idx != wr_idx) { m_cse[wr_idx].m_pc = m_cse[rd_idx].m_pc; m_cse[wr_idx].m_seqnum = m_cse[rd_idx].m_seqnum; } wr_idx++; } } m_cse.resize(wr_idx); } uncrustify-uncrustify-0.76.0/src/ChunkStack.h000066400000000000000000000030531434072136500212340ustar00rootroot00000000000000/** * @file ChunkStack.h * Manages a simple stack of chunks * * @author Ben Gardner * @license GPL v2+ */ #ifndef CHUNKSTACK_H_INCLUDED #define CHUNKSTACK_H_INCLUDED #include "uncrustify_types.h" class ChunkStack { public: struct Entry { Entry() : m_seqnum(0) , m_pc(0) { } Entry(const Entry &ref) : m_seqnum(ref.m_seqnum) , m_pc(ref.m_pc) { } Entry(size_t sn, Chunk *pc) : m_seqnum(sn) , m_pc(pc) { } size_t m_seqnum; Chunk *m_pc; }; protected: std::deque m_cse; size_t m_seqnum; //! current sequence number public: ChunkStack() : m_seqnum(0) { } ChunkStack(const ChunkStack &cs) { Set(cs); } virtual ~ChunkStack() { } void Set(const ChunkStack &cs); void Push_Back(Chunk *pc) { Push_Back(pc, ++m_seqnum); } bool Empty() const { return(m_cse.empty()); } size_t Len() const { return(m_cse.size()); } const Entry *Top() const; const Entry *Get(size_t idx) const; Chunk *GetChunk(size_t idx) const; Chunk *Pop_Back(); void Push_Back(Chunk *pc, size_t seqnum); Chunk *Pop_Front(); void Reset() { m_cse.clear(); } /** * Mark an entry to be removed by Collapse() * * @param idx The item to remove */ void Zap(size_t idx); //! Compresses down the stack by removing dead entries void Collapse(); }; #endif /* CHUNKSTACK_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/EnumStructUnionParser.cpp000066400000000000000000002502131434072136500240320ustar00rootroot00000000000000/** * @file EnumStructUnionParser.cpp * * @author * @license GPL v2+ */ #include "EnumStructUnionParser.h" #include "combine_fix_mark.h" #include "combine_skip.h" #include "combine_tools.h" #include "flag_parens.h" #include "lang_pawn.h" /** * Extern declarations */ extern const char *get_token_name(E_Token); /** * Forward declarations */ static std::pair match_variable_end(Chunk *, std::size_t); static std::pair match_variable_start(Chunk *, std::size_t); static Chunk *skip_scope_resolution_and_nested_name_specifiers(Chunk *); static Chunk *skip_scope_resolution_and_nested_name_specifiers_rev(Chunk *); /** * Returns true if two adjacent chunks potentially match a pattern consistent * with that of a qualified identifier */ static bool adj_tokens_match_qualified_identifier_pattern(Chunk *prev, Chunk *next) { LOG_FUNC_ENTRY(); if ( prev != nullptr && next != nullptr) { auto prev_token_type = prev->GetType(); auto next_token_type = next->GetType(); switch (prev_token_type) { case CT_ANGLE_CLOSE: /** * assuming the previous token is possibly the closing angle of a * templated type, the next token may be a scope resolution operator ("::") */ return(next_token_type == CT_DC_MEMBER); case CT_ANGLE_OPEN: /** * assuming the previous token is possibly the opening angle of a * templated type, just check to see if there's a matching closing * angle */ return(prev->GetClosingParen(E_Scope::PREPROC)->IsNotNullChunk()); case CT_DC_MEMBER: /** * if the previous token is a double colon ("::"), it is likely part * of a chain of scope-resolution qualifications preceding a word or * type */ return( next_token_type == CT_TYPE || next_token_type == CT_WORD); case CT_TYPE: case CT_WORD: /** * if the previous token is an identifier, the next token may be * one of the following: * - an opening angle, which may indicate a templated type as part of a * scope resolution preceding the actual variable identifier * - a double colon ("::") */ return( next_token_type == CT_ANGLE_OPEN || next_token_type == CT_DC_MEMBER); default: // do nothing break; } // switch } return(false); } // adj_tokens_match_qualified_identifier_pattern /** * Returns true if two adjacent chunks potentially match a pattern consistent * with that of a variable definition */ static bool adj_tokens_match_var_def_pattern(Chunk *prev, Chunk *next) { LOG_FUNC_ENTRY(); if ( prev != nullptr && next != nullptr) { auto prev_token_type = prev->GetType(); auto next_token_type = next->GetType(); switch (prev_token_type) { case CT_ANGLE_CLOSE: /** * assuming the previous token is possibly the closing angle of a * templated type, the next token may be one of the following: * - a pointer symbol ('*', '^') * - a double colon ("::") * - a reference symbol ('&') * - a qualifier (const, etc.) * - an identifier */ return( next->IsPointerOrReference() || next_token_type == CT_DC_MEMBER || next_token_type == CT_QUALIFIER || next_token_type == CT_WORD); case CT_ANGLE_OPEN: /** * assuming the previous token is possibly the opening angle of a * templated type, just check to see if there's a matching closing * angle */ return(prev->GetClosingParen(E_Scope::PREPROC)->IsNotNullChunk()); case CT_BRACE_CLOSE: /** * assuming the previous token is possibly the closing brace of a * class/enum/struct/union definition, one or more inline variable * definitions may follow; in that case, the next token may be one of * the following: * - a pointer symbol ('*', '^') * - a reference symbol ('&') * - a qualifier (const, etc.) * - an identifier */ return( next->IsPointerOrReference() || next_token_type == CT_QUALIFIER || next_token_type == CT_WORD); case CT_BRACE_OPEN: /** * if the previous token is an opening brace, it may indicate the * start of a braced initializer list - skip ahead to find a matching * closing brace */ return(prev->GetClosingParen(E_Scope::PREPROC)->IsNotNullChunk()); case CT_BYREF: /** * if the previous token is a reference symbol ('&'), the next token * may be an identifier */ return(next_token_type == CT_WORD); case CT_CARET: /** * if the previous token is a managed C++/CLI pointer symbol ('^'), * the next token may be one of the following: * - a pointer symbol ('*', '^') * - a reference symbol ('&') * - a qualifier (const, etc.) * - an identifier */ return( language_is_set(LANG_CPP) && ( next->IsPointerOrReference() || next_token_type == CT_QUALIFIER || next_token_type == CT_WORD)); case CT_COMMA: /** * if the previous token is a comma, this may indicate a variable * declaration trailing a prior declaration; in that case, the next * token may be one of the following: * - a pointer symbol ('*', '^') * - a reference symbol ('&') * - an identifier */ return( next->IsPointerOrReference() || next_token_type == CT_WORD); case CT_DC_MEMBER: /** * if the previous token is a double colon ("::"), it is likely part * of a chain of scope-resolution qualifications preceding a word or * type */ return( next_token_type == CT_TYPE || next_token_type == CT_WORD); case CT_PAREN_OPEN: /** * if the previous token is an opening paren, it may indicate the * start of a constructor call parameter list - skip ahead to find a * matching closing paren */ next = prev->GetClosingParen(E_Scope::PREPROC); if (next->IsNotNullChunk()) { next_token_type = next->GetType(); } return(next_token_type == CT_PAREN_CLOSE); case CT_PTR_TYPE: /** * if the previous token is a pointer type, ('*', '^'), the next token * may be one of the following: * - another pointer symbol ('*', '^') * - a reference symbol ('&') * - a qualifier (const, etc.) * - an identifier */ return( next->IsPointerOrReference() || next_token_type == CT_QUALIFIER || next_token_type == CT_WORD); case CT_QUALIFIER: /** * if the previous token is a qualifier (const, etc.), the next token * may be one of the following: * - a pointer symbol ('*', '^') * - a reference symbol ('&') * - another qualifier * - an identifier */ return( next->IsPointerOrReference() || next_token_type == CT_QUALIFIER || next_token_type == CT_WORD); case CT_SQUARE_CLOSE: /** * if the previous token is a closing bracket, the next token may be * an assignment following an array variable declaration */ return(next_token_type == CT_ASSIGN); case CT_SQUARE_OPEN: /** * if the previous token is an opening bracket, it may indicate an * array declaration - skip ahead to find a matching closing bracket */ return(prev->GetClosingParen(E_Scope::PREPROC)->IsNotNullChunk()); case CT_STAR: /** * if the previous token is a pointer symbol, ('*'), the next token * may be one of the following: * - another pointer symbol ('*', '^') * - a reference symbol ('&') * - a qualifier (const, etc.) * - an identifier */ return( next->IsPointerOrReference() || next_token_type == CT_QUALIFIER || next_token_type == CT_WORD); case CT_TSQUARE: /** * if the previous token is a set of brackets, the next token may be * an assignment following an array variable declaration */ return(next_token_type == CT_ASSIGN); case CT_TYPE: /** * if the previous token is marked as a type, the next token may be * one of the following: * - a pointer symbol ('*', '^') * - a reference symbol ('&') * - an opening angle, which may indicate a templated type as part of a * scope resolution preceding the actual variable identifier * - a double colon ("::") * - a qualifier (const, etc.) * - an identifier */ return( next->IsPointerOrReference() || next_token_type == CT_ANGLE_OPEN || next_token_type == CT_DC_MEMBER || next_token_type == CT_QUALIFIER || next_token_type == CT_WORD); case CT_WORD: /** * if the previous token is an identifier, the next token may be one * of the following: * - an assignment symbol ('=') * - an opening angle, which may indicate a templated type as part of a * scope resolution preceding the actual variable identifier * - an opening brace, which may indicate a braced-initializer list * - a double colon ("::") * - an opening paren, which may indicate a constructor call parameter * list * - an opening square bracket, which may indicate an array variable * - an set of empty square brackets, which also may indicate an array * variable */ return( next_token_type == CT_ANGLE_OPEN || next_token_type == CT_ASSIGN || next_token_type == CT_BRACE_OPEN || next_token_type == CT_DC_MEMBER || next_token_type == CT_PAREN_OPEN || next_token_type == CT_SQUARE_OPEN || next_token_type == CT_TSQUARE); default: // do nothing break; } // switch } return(false); } // adj_tokens_match_var_def_pattern /** * Returns true if the first chunk occurs AFTER the second chunk in the argument * list * @param pc points to the first chunk * @param after points to the second chunk * @param test_equal if true, returns true when both chunks refer to the same chunk */ static bool chunk_is_after(Chunk *pc, Chunk *after, bool test_equal = true) { LOG_FUNC_ENTRY(); if ( pc != nullptr && pc->IsNotNullChunk()) { if ( test_equal && pc == after) { return(true); } else if (after != nullptr) { auto pc_column = pc->GetOrigCol(); auto pc_line = pc->GetOrigLine(); auto after_column = after->GetOrigCol(); auto after_line = after->GetOrigLine(); return( pc_line > after_line || ( pc_line == after_line && pc_column > after_column)); } } return(false); } // chunk_is_after /** * Returns true if the first chunk occurs BEFORE the second chunk in the argument * list * @param pc points to the first chunk * @param before points to the second chunk * @param test_equal if true, returns true when both chunks refer to the same chunk */ static bool chunk_is_before(Chunk *pc, Chunk *before, bool test_equal = true) { LOG_FUNC_ENTRY(); if ( pc != nullptr && pc->IsNotNullChunk()) { if ( test_equal && pc == before) { return(true); } else if (before != nullptr) { auto pc_column = pc->GetOrigCol(); auto pc_line = pc->GetOrigLine(); auto before_column = before->GetOrigCol(); auto before_line = before->GetOrigLine(); return( pc_line < before_line || ( pc_line == before_line && pc_column < before_column)); } } return(false); } // chunk_is_before /** * Returns true if the first chunk occurs both AFTER and BEFORE * the second and third chunks, respectively, in the argument list * @param pc points to the first chunk * @param after points to the second chunk * @param before points to the third chunk * @param test_equal if true, returns true when the first chunk tests equal to * either the second or third chunk */ static bool chunk_is_between(Chunk *pc, Chunk *after, Chunk *before, bool test_equal = true) { LOG_FUNC_ENTRY(); return( chunk_is_before(pc, before, test_equal) && chunk_is_after(pc, after, test_equal)); } // chunk_is_between /** * Returns true if the chunk under test is a reference to a macro defined elsewhere in * the source file currently being processed. Note that a macro may be defined in * another source or header file, for which this function does not currently account */ static bool chunk_is_macro_reference(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *next = Chunk::GetHead(); if ( ( language_is_set(LANG_CPP) || language_is_set(LANG_C)) && pc->Is(CT_WORD) && !pc->TestFlags(PCF_IN_PREPROC)) { while (next->IsNotNullChunk()) { if ( next->TestFlags(PCF_IN_PREPROC) && std::strcmp(pc->GetStr().c_str(), next->GetStr().c_str()) == 0) { return(true); } next = next->GetNextType(CT_MACRO); } } return(false); } // chunk_is_macro_reference bool Chunk::IsPointerReferenceOrQualifier() const { LOG_FUNC_ENTRY(); return( IsPointerOrReference() || ( Is(CT_QUALIFIER) && !IsCppInheritanceAccessSpecifier())); } /** * This function attempts to match the starting and ending chunks of a qualified * identifier, which consists of one or more scope resolution operator(s) and * zero or more nested name specifiers * specifiers * @param pc the starting chunk * @return an std::pair, where the first chunk indicates the starting chunk of the * match and second indicates the ending chunk. Upon finding a successful * match, the starting chunk may consist of an identifier or a scope * resolution operator, while the ending chunk may consist of identifier * or the closing angle bracket of a template. If no match is found, a * pair of null chunks is returned */ static std::pair match_qualified_identifier(Chunk *pc) { LOG_FUNC_ENTRY(); auto *end = skip_scope_resolution_and_nested_name_specifiers(pc); auto *start = skip_scope_resolution_and_nested_name_specifiers_rev(pc); if ( end != nullptr && start != nullptr) { auto *double_colon = start->GetNextType(CT_DC_MEMBER); if ( double_colon->IsNotNullChunk() && chunk_is_between(double_colon, start, end)) { return(std::make_pair(start, end)); } } return(std::make_pair(nullptr, nullptr)); } // match_qualified_identifier /** * Starting from the input chunk, this function attempts to match a variable * declaration/definition in both the forward and reverse directions; each pair of * consecutive chunks is tested to determine if a potential match is satisfied. * @param pc the starting chunk * @param level the brace level * @return upon successful match, function returns an std::tuple, where the * first chunk indicates the starting chunk, the second chunk indicates * the identifier name, and the third chunk indicates the end associated * with the variable declaration/definition */ static std::tuple match_variable(Chunk *pc, std::size_t level) { LOG_FUNC_ENTRY(); auto identifier_end_pair = match_variable_end(pc, level); auto start_identifier_pair = match_variable_start(pc, level); auto *end = identifier_end_pair.second; auto *identifier = identifier_end_pair.first != nullptr ? identifier_end_pair.first : start_identifier_pair.second; auto *start = start_identifier_pair.first; /** * a forward search starting at the chunk under test will fail if two consecutive chunks marked as CT_WORD * are encountered; in that case, it's likely that the preceding chunk indicates a type and the subsequent * chunk indicates a variable declaration/definition */ if ( identifier->IsNotNullChunk() && start->IsNotNullChunk() && ( end != nullptr || identifier->GetPrevNcNnlNi()->Is(CT_WORD))) { return(std::make_tuple(start, identifier, end)); } return(std::make_tuple(nullptr, nullptr, nullptr)); } // match_variable /** * Starting from the input chunk, this function attempts to match a variable in the * forward direction, and tests each pair of consecutive chunks to determine if a * potential variable declaration/definition match is satisfied. Secondly, the * function attempts to identify the end chunk associated with the candidate variable * match. For scalar variables (simply declared and not defined), both the end chunk * and identifier chunk should be one in the same * @param pc the starting chunk * @param level the brace level * @return an std::pair, where the first chunk indicates the identifier * (if non-null) and the second chunk indicates the end associated with * the variable declaration/definition; assuming a valid match, the first * chunk may be null if the function is called with a starting chunk * that occurs after the identifier */ static std::pair match_variable_end(Chunk *pc, std::size_t level) { LOG_FUNC_ENTRY(); Chunk *identifier = nullptr; while ( pc != nullptr && pc->IsNotNullChunk()) { /** * skip any right-hand side assignments */ Chunk *rhs_exp_end = nullptr; if (pc->Is(CT_ASSIGN)) { /** * store a pointer to the end chunk of the rhs expression; * use it later to test against setting the identifier */ rhs_exp_end = skip_to_expression_end(pc); pc = rhs_exp_end; } /** * skip current and preceding chunks if at a higher brace level */ while ( pc != nullptr && pc->IsNotNullChunk() && pc->GetLevel() > level) { pc = pc->GetNextNcNnl(); } /** * skip to any following match for angle brackets, braces, parens, * or square brackets */ if ( pc->Is(CT_ANGLE_OPEN) || pc->Is(CT_BRACE_OPEN) || pc->IsParenOpen() || pc->Is(CT_SQUARE_OPEN)) { pc = pc->GetClosingParen(E_Scope::PREPROC); } /** * call a separate function to validate adjacent tokens as potentially * matching a variable declaration/definition */ Chunk *next = pc->GetNextNcNnl(); if ( next->IsNot(CT_COMMA) && next->IsNot(CT_FPAREN_CLOSE) && !next->IsSemicolon() && !adj_tokens_match_var_def_pattern(pc, next)) { /** * error, pattern is not consistent with a variable declaration/definition */ break; } if ( pc->Is(CT_WORD) && pc != rhs_exp_end) { /** * we've encountered a candidate for the variable name */ identifier = pc; } /** * we're done searching if we've previously identified a variable name * and then encounter a comma or semicolon */ if ( next->Is(CT_COMMA) || next->Is(CT_FPAREN_CLOSE) || next->IsSemicolon()) { return(std::make_pair(identifier, pc)); } pc = next; } return(std::make_pair(nullptr, nullptr)); } // match_variable_end /** * Starting from the input chunk, this function attempts to match a variable in the * reverse direction, and tests each pair of consecutive chunks to determine if a * potential variable declaration/definition match is satisfied. Secondly, the * function attempts to identify the starting chunk associated with the candidate * variable match. The start and identifier chunks may refer to each other in cases * where the identifier is not preceded by pointer or reference operators or qualifiers, * etc. * @param pc the starting chunk * @param level the brace level * @return an std::pair, where the first chunk indicates the starting chunk and * the second chunk indicates the identifier associated with the variable * match; assuming a valid match, the second chunk may be null if the * function is called with a starting chunk that occurs before the * identifier */ static std::pair match_variable_start(Chunk *pc, std::size_t level) { LOG_FUNC_ENTRY(); Chunk *identifier = Chunk::NullChunkPtr; if (pc == nullptr) { pc = Chunk::NullChunkPtr; } while (pc->IsNotNullChunk()) { /** * skip any right-hand side assignments */ Chunk *before_rhs_exp_start = skip_expression_rev(pc); Chunk *prev = Chunk::NullChunkPtr; Chunk *next = pc; while ( chunk_is_after(next, before_rhs_exp_start) && pc != prev) { next = prev; prev = next->GetPrevNcNnlNi(); if (next->Is(CT_ASSIGN)) { pc = prev; } } /** * skip current and preceding chunks if at a higher brace level */ while ( pc->IsNotNullChunk() && pc->GetLevel() > level) { pc = pc->GetPrevNcNnlNi(); } /** * skip to any preceding match for angle brackets, braces, parens, * or square brackets */ if ( pc->Is(CT_ANGLE_CLOSE) || pc->Is(CT_BRACE_CLOSE) || pc->IsParenClose() || pc->Is(CT_SQUARE_CLOSE)) { pc = pc->GetOpeningParen(E_Scope::PREPROC); } /** * call a separate function to validate adjacent tokens as potentially * matching a variable declaration/definition */ prev = pc->GetPrevNcNnlNi(); if (!adj_tokens_match_var_def_pattern(prev, pc)) { /** * perhaps the previous chunk possibly indicates a type that yet to be * marked? if not, then break */ if ( prev->IsNot(CT_WORD) || ( !pc->IsPointerOrReference() && pc->IsNot(CT_WORD))) { /** * error, pattern is not consistent with a variable declaration/definition */ break; } } if ( identifier->IsNullChunk() && pc->Is(CT_WORD)) { /** * we've encountered a candidate for the variable name */ identifier = pc; } /** * we're done searching if we've previously identified a variable name * and then encounter another identifier, or we encounter a closing * brace (which would likely indicate an inline variable definition) */ if ( prev->Is(CT_ANGLE_CLOSE) || prev->Is(CT_BRACE_CLOSE) || prev->Is(CT_COMMA) || prev->Is(CT_TYPE) || prev->Is(CT_WORD)) { return(std::make_pair(pc, identifier)); } pc = prev; } return(std::make_pair(Chunk::NullChunkPtr, Chunk::NullChunkPtr)); } // match_variable_start /** * Skip forward past any scope resolution operators and nested name specifiers and return * just the qualified identifier name; while similar to the existing skip_dc_member() * function, this function also takes into account templates that may comprise any * nested name specifiers */ static Chunk *skip_scope_resolution_and_nested_name_specifiers(Chunk *pc) { LOG_FUNC_ENTRY(); if ( ( pc != nullptr && pc->TestFlags(PCF_IN_TEMPLATE)) || pc->Is(CT_DC_MEMBER) || pc->Is(CT_TYPE) || pc->Is(CT_WORD)) { while (pc->IsNotNullChunk()) { /** * skip to any following match for angle brackets */ if (pc->Is(CT_ANGLE_OPEN)) { pc = pc->GetClosingParen(E_Scope::PREPROC); } Chunk *next = pc->GetNextNcNnl(); /** * call a separate function to validate adjacent tokens as potentially * matching a qualified identifier */ if (!adj_tokens_match_qualified_identifier_pattern(pc, next)) { break; } pc = next; } } return(pc); } // skip_scope_resolution_and_nested_name_specifiers /** * Skip in reverse to the beginning chunk of a qualified identifier; while similar to * the existing skip_dc_member_rev() function, this function also takes into account * templates that may comprise any nested name specifiers */ static Chunk *skip_scope_resolution_and_nested_name_specifiers_rev(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc == nullptr) { pc = Chunk::NullChunkPtr; } if ( ( pc->IsNotNullChunk() && pc->TestFlags(PCF_IN_TEMPLATE)) || pc->Is(CT_DC_MEMBER) || pc->Is(CT_TYPE) || pc->Is(CT_WORD)) { while (pc->IsNotNullChunk()) { /** * skip to any preceding match for angle brackets */ if (pc->Is(CT_ANGLE_CLOSE)) { pc = pc->GetOpeningParen(E_Scope::PREPROC); } Chunk *prev = pc->GetPrevNcNnlNi(); /** * call a separate function to validate adjacent tokens as potentially * matching a qualified identifier */ if (!adj_tokens_match_qualified_identifier_pattern(prev, pc)) { break; } pc = prev; } } return(pc); } // skip_scope_resolution_and_nested_name_specifiers_rev EnumStructUnionParser::EnumStructUnionParser() : m_end(nullptr) , m_parse_error(false) , m_start(nullptr) , m_type(nullptr) { } // EnumStructUnionParser::EnumStructUnionParser EnumStructUnionParser::~EnumStructUnionParser() { } // EnumStructUnionParser::~EnumStructUnionParser void EnumStructUnionParser::analyze_identifiers() { LOG_FUNC_ENTRY(); /** * the enum (and variable declarations thereof) could be of * the following forms: * * "enum type [: integral_type] { ... } [x, ...]" * "enum type : integral_type" * "enum type x, ..." * "enum class type [: integral_type] { ... } [x, ...]" * "enum class type [: integral_type]" * "enum [: integral_type] { ... } x, ..." */ /** * the class/struct (and variable declarations thereof) could be of * the following forms: * * "template<...> class/struct[<...>] [macros/attributes ...] type [: bases ...] { }" * "template<...> class/struct[<...>] [macros/attributes ...] type" * "class/struct [macros/attributes ...] type [: bases ...] { } [x, ...]" * "class/struct [macros/attributes ...] type [x, ...]" * "class/struct [macros/attributes ...] [: bases] { } x, ..." */ Chunk *template_end = get_template_end(); auto *body_end = get_body_end(); auto *body_start = get_body_start(); T_PcfFlags flags = PCF_VAR_1ST_DEF; auto *inheritance_start = get_inheritance_start(); Chunk *pc = body_end ? body_end : m_start; /** * first, try a simple approach to identify any associated type */ if (try_pre_identify_type()) { /** * a type was identified, meaning a pair of braces, angle brackets, or * a colon was found; if a colon was found, then there should be a * balanced set of braces that follow; therefore, start the search for * variable identifiers after the closing brace or close angle bracket */ if (body_end != nullptr) { pc = body_end; } else if (template_end != nullptr) { pc = template_end; } } if (pc == nullptr) { pc = Chunk::NullChunkPtr; } if (pc->GetNextNcNnl() == m_end) { /** * we're likely at the end of a class/enum/struct/union body which lacks * any trailing inline definitions */ pc = m_end->GetNextNcNnl(); } if ( type_identified() || pc->IsClassEnumStructOrUnion() || pc == m_end) { /** * in case we're pointing at the end chunk, advance the chunk pointer * by one more so that we don't perform a variable identifier search * below */ pc = pc->GetNextNcNnl(); } if (body_end != nullptr) { /** * a closing brace was found, so any identifiers trailing the closing * brace are probably inline variable declarations following a * class/enum/struct/union definition */ flags |= PCF_VAR_INLINE; } else if (!type_identified()) { /** * skip any chain of one or more function-like macro calls, * declspecs, and attributes */ Chunk *tmp = pc; do { pc = tmp; tmp = skip_attribute_next(tmp); tmp = skip_declspec_next(tmp); } while (tmp != pc); } /** * try to match some variable identifiers in the loop below */ while (chunk_is_between(pc, m_start, m_end, false)) { auto match = match_variable(pc, m_start->GetLevel()); auto *start = std::get<0>(match); auto *identifier = std::get<1>(match); auto *end = std::get<2>(match); if ( start != nullptr && identifier != nullptr) { if (end != nullptr) { mark_variable(identifier, flags); if (flags & PCF_VAR_1ST) { flags &= ~PCF_VAR_1ST; // clear the first flag for the next items } } } if (end != nullptr) { pc = end; } pc = pc->GetNextNcNnl(); /** * skip any right-hand side assignments */ if (pc->Is(CT_ASSIGN)) { pc = skip_to_expression_end(pc); } /** * if we're sitting at a comma or semicolon, skip it */ if ( pc->IsSemicolon() || ( pc->Is(CT_COMMA) && !pc->GetFlags().test_any(PCF_IN_FCN_DEF | PCF_IN_FCN_CALL | PCF_IN_TEMPLATE) && !chunk_is_between(pc, inheritance_start, body_start))) { pc = pc->GetNextNcNnl(); } } /** * if we still haven't identified a type, try doing so now that the * variables, if any, have been marked */ try_post_identify_type(); /** * identify possible macros preceding the type name */ try_post_identify_macro_calls(); if ( m_start->IsClassOrStruct() && ( m_start->IsNot(CT_STRUCT) || !language_is_set(LANG_C))) { /** * if a type has been identified, mark any constructor matching constructor * declarations/definitions */ mark_constructors(); } if (type_identified()) { if (~flags & PCF_VAR_1ST) { /** * PCF_VAR_1ST was cleared and a type was identified; therefore, set * PCF_VAR_TYPE for the identified type */ m_type->SetFlagBits(PCF_VAR_TYPE); } else if (~flags & PCF_VAR_INLINE) { /** * if a type was identified but no braced-enclosed body was found and no * identifiers were marked as variables, then we're likely we're likely * dealing with a forward declaration */ flag_series(m_start, m_type, PCF_INCOMPLETE); } } } // EnumStructUnionParser::analyze_identifiers bool EnumStructUnionParser::body_detected() const { LOG_FUNC_ENTRY(); auto *body_end = get_body_end(); auto *body_start = get_body_start(); return( body_end != nullptr && body_start != nullptr); } // EnumStructUnionParser::body_detected bool EnumStructUnionParser::comma_separated_values_detected() const { LOG_FUNC_ENTRY(); return(!get_top_level_commas().empty()); } // EnumStructUnionParser::comma_separated_values_detected bool EnumStructUnionParser::enum_base_detected() const { LOG_FUNC_ENTRY(); return(m_chunk_map.find(CT_BIT_COLON) != m_chunk_map.cend()); } // EnumStructUnionParser::enum_base_detected Chunk *EnumStructUnionParser::get_body_end() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_BRACE_CLOSE); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second.at(0)); } return(nullptr); } // EnumStructUnionParser::get_body_end Chunk *EnumStructUnionParser::get_body_start() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_BRACE_OPEN); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second.at(0)); } return(nullptr); } // EnumStructUnionParser::get_body_start Chunk *EnumStructUnionParser::get_enum_base_start() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_BIT_COLON); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second.at(0)); } return(nullptr); } // EnumStructUnionParser::get_enum_base_start Chunk *EnumStructUnionParser::get_first_top_level_comma() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_COMMA); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second.at(0)); } return(nullptr); } // EnumStructUnionParser::get_first_top_level_comma Chunk *EnumStructUnionParser::get_inheritance_end() const { LOG_FUNC_ENTRY(); Chunk *brace_open = nullptr; auto *inheritance_start = get_inheritance_start(); if (inheritance_start != nullptr) { brace_open = get_body_start(); if (brace_open == nullptr) { brace_open = inheritance_start->GetNextType(CT_BRACE_OPEN, m_start->GetLevel(), E_Scope::ALL); } } return(brace_open); } // EnumStructUnionParser::get_inheritance_end Chunk *EnumStructUnionParser::get_inheritance_start() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_COLON); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second.at(0)); } return(nullptr); } // EnumStructUnionParser::get_inheritance_start std::map EnumStructUnionParser::get_question_operators() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_QUESTION); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second); } return(std::map()); } // EnumStructUnionParser::get_question_operators Chunk *EnumStructUnionParser::get_template_end() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_ANGLE_CLOSE); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second.at(0)); } return(nullptr); } // EnumStructUnionParser::get_template_end Chunk *EnumStructUnionParser::get_template_start() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_ANGLE_OPEN); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second.at(0)); } return(nullptr); } // EnumStructUnionParser::get_template_start std::map EnumStructUnionParser::get_top_level_commas() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_COMMA); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second); } return(std::map()); } // EnumStructUnionParser::get_top_level_commas Chunk *EnumStructUnionParser::get_where_end() const { LOG_FUNC_ENTRY(); Chunk *brace_open = nullptr; auto *where_start = get_where_start(); if (where_start != nullptr) { brace_open = get_body_start(); if (brace_open == nullptr) { brace_open = where_start->GetNextType(CT_BRACE_OPEN, m_start->GetLevel(), E_Scope::ALL); } } return(brace_open); } // EnumStructUnionParser::get_where_end Chunk *EnumStructUnionParser::get_where_start() const { LOG_FUNC_ENTRY(); auto &&it_token_chunk_map_pair = m_chunk_map.find(CT_WHERE); if (it_token_chunk_map_pair != m_chunk_map.cend()) { return(it_token_chunk_map_pair->second.at(0)); } return(nullptr); } // EnumStructUnionParser::get_where_start bool EnumStructUnionParser::inheritance_detected() const { LOG_FUNC_ENTRY(); return(m_chunk_map.find(CT_COLON) != m_chunk_map.cend()); } // EnumStructUnionParser::inheritance_detected void EnumStructUnionParser::initialize(Chunk *pc) { LOG_FUNC_ENTRY(); parse_error_detected(false); m_chunk_map.clear(); m_start = pc; m_type = nullptr; pc = try_find_end_chunk(pc); if (parse_error_detected()) { return; } m_end = refine_end_chunk(pc); } // EnumStructUnionParser::initialize bool EnumStructUnionParser::is_potential_end_chunk(Chunk *pc) const { LOG_FUNC_ENTRY(); LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); /** * test for a semicolon or closing brace at the level of the starting chunk */ if ( pc->IsNullChunk() || parse_error_detected() || ( ( pc->IsSemicolon() || pc->Is(CT_BRACE_CLOSE)) && pc->GetLevel() == m_start->GetLevel())) { LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); return(true); } /** * check for the following: * 1) did we encounter a closing paren, which may indicate the end of cast? * 2) did we cross a preprocessor boundary? * 3) did we cross the closing paren of a function signature? */ auto const pc_in_funcdef = pc->GetFlags() & PCF_IN_FCN_DEF; auto const pc_in_preproc = pc->GetFlags() & PCF_IN_PREPROC; auto const start_in_funcdef = m_start->GetFlags() & PCF_IN_FCN_DEF; auto const start_in_preproc = m_start->GetFlags() & PCF_IN_PREPROC; /** * the following may identify cases where we've reached the * end of a cast terminated by a closing paren */ if ( ( pc->IsParenClose() // Issue #3538 && pc->GetLevel() < m_start->GetLevel()) || (start_in_funcdef ^ pc_in_funcdef).test_any() || (start_in_preproc ^ pc_in_preproc).test_any()) { LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); return(true); } /** * check whether the current chunk's nest level is less than that * of the starting chunk */ std::size_t pc_template_nest = get_cpp_template_angle_nest_level(pc); std::size_t start_template_nest = get_cpp_template_angle_nest_level(m_start); if (start_template_nest > pc_template_nest) { LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); return(true); } /** * assuming the chunk is within a function call/definition, check the following: * 1) chunk is a closing function paren at a lower level than the starting chunk * 2) chunk is an assignment ('=') or comma at the level of the starting chunk */ auto const pc_in_funccall = pc->GetFlags() & PCF_IN_FCN_CALL; auto const start_in_funccall = m_start->GetFlags() & PCF_IN_FCN_CALL; if ( ( pc_in_funccall.test_any() && start_in_funccall.test_any() && pc->Is(CT_COMMA) && pc->GetLevel() == m_start->GetLevel()) || ( pc_in_funcdef.test_any() && ( ( pc->Is(CT_FPAREN_CLOSE) && pc->GetLevel() < m_start->GetLevel()) || ( ( pc->Is(CT_ASSIGN) || pc->Is(CT_COMMA)) && pc->GetLevel() == m_start->GetLevel())))) { LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); return(true); } LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); return(false); } // EnumStructUnionParser::is_potential_end_chunk bool EnumStructUnionParser::is_within_conditional(Chunk *pc) const { LOG_FUNC_ENTRY(); auto question_operators = get_question_operators(); if (!question_operators.empty()) { auto &&it_token_chunk_pair = question_operators.cbegin(); while (it_token_chunk_pair != question_operators.cend()) { auto *question = it_token_chunk_pair->second; auto *end = skip_to_expression_end(question); auto *start = skip_to_expression_start(question); if (chunk_is_between(pc, start, end)) { return(true); } ++it_token_chunk_pair; } } return(false); } // EnumStructUnionParser::is_within_conditional bool EnumStructUnionParser::is_within_inheritance_list(Chunk *pc) const { LOG_FUNC_ENTRY(); if ( pc != nullptr && pc->TestFlags(PCF_IN_CLASS_BASE)) { return(true); } auto *inheritance_end = get_inheritance_end(); auto *inheritance_start = get_inheritance_start(); if ( inheritance_end != nullptr && inheritance_start != nullptr) { return(chunk_is_between(pc, inheritance_start, inheritance_end)); } return(false); } // EnumStructUnionParser::is_within_inheritance_list bool EnumStructUnionParser::is_within_where_clause(Chunk *pc) const { LOG_FUNC_ENTRY(); if ( pc != nullptr && pc->TestFlags(PCF_IN_WHERE_SPEC)) { return(true); } auto *where_end = get_where_end(); auto *where_start = get_where_start(); if ( where_end != nullptr && where_start != nullptr) { return(chunk_is_between(pc, where_start, where_end)); } return(false); } // EnumStructUnionParser::is_within_where_clause void EnumStructUnionParser::mark_base_classes(Chunk *pc) { LOG_FUNC_ENTRY(); T_PcfFlags flags = PCF_VAR_1ST_DEF; while ( pc != nullptr && pc->IsNotNullChunk()) { pc->SetFlagBits(PCF_IN_CLASS_BASE); /** * clear the PCF_VAR_TYPE flag for all chunks within the inheritance list * TODO: this may not be necessary in the future once code outside this * class is improved such that PCF_VAR_TYPE is not set for these chunks */ pc->ResetFlagBits(PCF_VAR_TYPE); Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); if (next->Is(CT_DC_MEMBER)) { /** * just in case it's a templated type */ pc = skip_template_prev(pc); if (pc->Is(CT_WORD)) { /** * TODO: * To comply with conventions used elsewhere in the code, we're going * to change chunks marked CT_WORD to CT_TYPE if followed by a scope- * resolution operator; if a chunk marked CT_WORD is followed by a set * of angle brackets, then it's obviously a templated type. However, * in the absence of a pair trailing angle brackets, the chunk may be * a namespace rather than a type. Need to revisit this! */ pc->SetType(CT_TYPE); } } else if ( ( next->Is(CT_BRACE_OPEN) || ( next->Is(CT_COMMA) && !is_within_where_clause(next))) && next->GetLevel() == m_start->GetLevel()) { /** * just in case it's a templated type */ pc = skip_template_prev(pc); if (pc->Is(CT_WORD)) { pc->SetFlagBits(flags); if (flags & PCF_VAR_1ST) { flags &= ~PCF_VAR_1ST; // clear the first flag for the next items } } if (next->Is(CT_BRACE_OPEN)) { break; } } pc = next; } pc->SetFlagBits(PCF_IN_CLASS_BASE); } // EnumStructUnionParser::mark_base_classes void EnumStructUnionParser::mark_braces(Chunk *brace_open) { LOG_FUNC_ENTRY(); T_PcfFlags flags = PCF_NONE; if (m_start->Is(CT_CLASS)) { flags = PCF_IN_CLASS; } else if (m_start->IsEnum()) { flags = PCF_IN_ENUM; } else if (m_start->Is(CT_STRUCT)) { flags = PCF_IN_STRUCT; } /** * TODO: why does flag_parens() flag the closing paren, * but it doesn't flag the opening paren? */ flag_parens(brace_open, flags, CT_NONE, CT_NONE, false); if (m_start->IsClassStructOrUnion()) { mark_struct_union_body(brace_open); auto *inheritance_start = get_inheritance_start(); if (inheritance_start != nullptr) { /** * the class/struct/union is a derived class; mark the base * classes between the colon/java "implements" keyword and the * opening brace */ mark_base_classes(inheritance_start); } } brace_open->SetParentType(m_start->GetType()); auto *brace_close = brace_open->GetClosingParen(E_Scope::PREPROC); if (brace_close->IsNotNullChunk()) { brace_close->SetParentType(m_start->GetType()); } } // EnumStructUnionParser::mark_braces void EnumStructUnionParser::mark_class_colon(Chunk *colon) { LOG_FUNC_ENTRY(); LOG_FMT(LFTOR, "%s(%d): Class colon detected: orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, colon->GetOrigLine(), colon->GetOrigCol()); colon->SetType(CT_CLASS_COLON); colon->SetParentType(m_start->GetType()); } // EnumStructUnionParser::mark_class_colon void EnumStructUnionParser::mark_conditional_colon(Chunk *colon) { colon->SetType(CT_COND_COLON); } // EnumStructUnionParser::mark_conditional_colon void EnumStructUnionParser::mark_constructors() { LOG_FUNC_ENTRY(); /** * if a type was previously identified, then look for * class/struct constructors in the body */ if ( body_detected() && type_identified() && m_start->IsClassOrStruct()) { LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, start is '%s', parent type is %s\n", __unqualified_func__, __LINE__, m_start->GetOrigLine(), m_start->GetOrigCol(), m_start->Text(), get_token_name(m_start->GetParentType())); log_pcf_flags(LFTOR, m_start->GetFlags()); /** * get the name of the type */ auto *body_end = get_body_end(); auto *body_start = get_body_start(); auto *name = m_type->Text(); LOG_FMT(LFTOR, "%s(%d): Name of type is '%s'\n", __unqualified_func__, __LINE__, name); log_pcf_flags(LFTOR, m_type->GetFlags()); Chunk *next = Chunk::NullChunkPtr; std::size_t level = m_type->GetBraceLevel() + 1; for (auto *prev = body_start; next != body_end; prev = next) { prev->SetFlagBits(PCF_IN_CLASS); next = skip_template_next(prev->GetNextNcNnl(E_Scope::PREPROC)); // Issue #3368 /** * find a chunk within the class/struct body that */ if ( prev->IsNotNullChunk() && std::strcmp(prev->Text(), name) == 0 && prev->GetLevel() == level && next->IsParenOpen()) { prev->SetType(CT_FUNC_CLASS_DEF); LOG_FMT(LFTOR, "%s(%d): Constructor/destructor detected: '%s' at orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, name, prev->GetOrigLine(), prev->GetOrigCol(), get_token_name(prev->GetType())); mark_cpp_constructor(prev); } } next->SetFlagBits(PCF_IN_CLASS); } } // EnumStructUnionParser::mark_constructor void EnumStructUnionParser::mark_enum_integral_type(Chunk *colon) { LOG_FUNC_ENTRY(); colon->SetType(CT_BIT_COLON); colon->SetParentType(m_start->GetType()); auto *body_start = get_body_start(); auto *pc = colon->GetNextNcNnl(); /** * the chunk(s) between the colon and opening * brace (if present) should specify the enum's * integral type */ while ( chunk_is_between(pc, m_start, m_end) && pc != body_start && pc->IsNot(CT_BRACE_OPEN) && !pc->IsSemicolon()) { /** * clear the PCF_VAR_TYPE flag for all chunks within the enum integral base * TODO: this may not be necessary in the future once code outside this * class is improved such that PCF_VAR_TYPE is not set for these chunks */ if (pc->IsNot(CT_DC_MEMBER)) // Issue #3198 { pc->ResetFlagBits(PCF_VAR_TYPE); pc->SetType(CT_TYPE); pc->SetParentType(colon->GetType()); } pc = pc->GetNextNcNnl(); } } // EnumStructUnionParser::mark_enum_integral_type void EnumStructUnionParser::mark_extracorporeal_lvalues() { /** * clear the PCF_LVALUE flag for all chunks outside the body definition, * as this flag may have been set elsewhere by code outside this class * TODO: the mark_lvalue() function needs some improvement so that the * following isn't necessary */ Chunk *next = m_start; Chunk *prev = Chunk::NullChunkPtr; /** * if the class is a template, go the extra step and correct the * erroneously marked chunks - as previously mentioned, this likely * won't be necessary with improvements to the mark_lvalue() function */ if (next->GetParentType() == CT_TEMPLATE) { while (true) { prev = next->GetPrevNcNnlNi(); if ( prev->IsNullChunk() || ( !prev->TestFlags(PCF_IN_TEMPLATE) && prev->IsNot(CT_TEMPLATE))) { break; } next = prev; } } Chunk *body_end = get_body_end(); Chunk *body_start = get_body_start(); while (next != m_end) { if ( !chunk_is_between(next, body_start, body_end) && next->TestFlags(PCF_LVALUE)) { next->ResetFlagBits(PCF_LVALUE); } else if ( ( next->Is(CT_ASSIGN) || next->Is(CT_BRACE_OPEN)) && prev->Is(CT_WORD) && prev->GetFlags().test_any(PCF_VAR_DEF | PCF_VAR_1ST | PCF_VAR_INLINE)) { prev->SetFlagBits(PCF_LVALUE); } prev = next; next = next->GetNextNcNnl(); } } // EnumStructUnionParser::mark_extracorporeal_lavlues void EnumStructUnionParser::mark_nested_name_specifiers(Chunk *pc) { LOG_FUNC_ENTRY(); auto start_end_pair = match_qualified_identifier(pc); auto start = start_end_pair.first; auto end = start_end_pair.second; for (pc = start; chunk_is_between(pc, start, end); pc = pc->GetNextNcNnl()) { if (pc->Is(CT_WORD)) { /** * if the next token is an opening angle, then we can safely * mark the current identifier as a type */ auto *next = pc->GetNextNcNnl(); if (next->Is(CT_ANGLE_OPEN)) { /** * the template may have already been previously marked elsewhere... */ auto *angle_open = next; auto *angle_close = angle_open->GetClosingParen(E_Scope::PREPROC); if (angle_close->IsNullChunk()) { // parse error parse_error_detected(true); // TODO: should this be just a warning or an error (with exit condition?) LOG_FMT(LWARN, "%s(%d): Unmatched '<' at orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, angle_open->GetOrigLine(), angle_open->GetOrigCol()); break; } pc->SetType(CT_TYPE); mark_template(next); pc = angle_close; } else if ( is_within_inheritance_list(pc) && ( next->Is(CT_COMMA) || next->Is(CT_BRACE_OPEN))) { pc->SetType(CT_TYPE); } } } } // EnumStructUnionParser::mark_nested_name_specifiers void EnumStructUnionParser::mark_pointer_types(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc->Is(CT_WORD)) { do { // TODO: should there be a CT_BYREF_TYPE? pc = pc->GetPrevNcNnlNi(); if (pc->IsPointerOperator()) { pc->SetParentType(m_start->GetType()); pc->SetType(CT_PTR_TYPE); } } while (pc->IsPointerReferenceOrQualifier()); } } // EnumStructUnionParser::mark_pointer_types void EnumStructUnionParser::mark_template(Chunk *start) const { LOG_FUNC_ENTRY(); if (start != nullptr) { LOG_FMT(LTEMPL, "%s(%d): Template detected: '%s' at orig line %zu, orig col %zu\n", __unqualified_func__, __LINE__, start->Text(), start->GetOrigLine(), start->GetOrigCol()); } start->SetParentType(CT_TEMPLATE); auto *end = start->GetClosingParen(E_Scope::PREPROC); if (end->IsNotNullChunk()) { end->SetParentType(CT_TEMPLATE); mark_template_args(start, end); } } // EnumStructUnionParser::mark_template void EnumStructUnionParser::mark_template_args(Chunk *start, Chunk *end) const { LOG_FUNC_ENTRY(); if ( end != nullptr && start != nullptr) { LOG_FMT(LTEMPL, "%s(%d): Start of template detected: '%s' at orig line %zu, orig col %zu\n", __unqualified_func__, __LINE__, start->Text(), start->GetOrigLine(), start->GetOrigCol()); T_PcfFlags flags = PCF_IN_TEMPLATE; Chunk *next = start; /** * TODO: for now, just mark the chunks within the template as PCF_IN_TEMPLATE; * we probably need to create a TemplateParser class to handle all * things template-related */ while (true) { next = next->GetNextNcNnl(); if (next == end) { break; } next->SetFlagBits(flags); } LOG_FMT(LTEMPL, "%s(%d): End of template detected: '%s' at orig line %zu, orig col %zu\n", __unqualified_func__, __LINE__, end->Text(), end->GetOrigLine(), end->GetOrigCol()); } } // EnumStructUnionParser::mark_template_args void EnumStructUnionParser::mark_type(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc != nullptr) { m_type = pc; do { make_type(pc); pc->SetParentType(m_start->GetType()); pc = pc->GetNextNcNnl(E_Scope::PREPROC); } while (pc->IsPointerOrReference()); } } // EnumStructUnionParser::mark_type void EnumStructUnionParser::mark_variable(Chunk *variable, T_PcfFlags flags) { LOG_FUNC_ENTRY(); if (variable != nullptr) { LOG_FMT(LVARDEF, "%s(%d): Variable definition detected: '%s' at orig line is %zu, orig col is %zu, set %s\n", __unqualified_func__, __LINE__, variable->Text(), variable->GetOrigLine(), variable->GetOrigCol(), flags & PCF_VAR_1ST_DEF ? "PCF_VAR_1ST_DEF" : "PCF_VAR_1ST"); variable->SetFlagBits(flags); variable->SetType(CT_WORD); mark_pointer_types(variable); } } // EnumStructUnionParser::mark_variable void EnumStructUnionParser::mark_where_clause(Chunk *where) { LOG_FUNC_ENTRY(); if (where != nullptr) { LOG_FMT(LFTOR, "%s(%d): Where clause detected: orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, where->GetOrigLine(), where->GetOrigCol()); } set_where_start(where); auto *where_end = get_where_end(); auto *where_start = get_where_start(); set_where_end(where_end); T_PcfFlags flags; for (auto *pc = where_start; pc != where_end; pc = pc->GetNextNcNnl()) { flags = mark_where_chunk(pc, m_start->GetType(), flags); } } // EnumStructUnionParser::mark_where_clause void EnumStructUnionParser::mark_where_colon(Chunk *colon) { LOG_FUNC_ENTRY(); if (colon != nullptr) { LOG_FMT(LFTOR, "%s(%d): Where colon detected: orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, colon->GetOrigLine(), colon->GetOrigCol()); } colon->SetType(CT_WHERE_COLON); colon->SetParentType(m_start->GetType()); } // EnumStructUnionParser::mark_where_colon void EnumStructUnionParser::parse(Chunk *pc) { LOG_FUNC_ENTRY(); initialize(pc); if (parse_error_detected()) { return; } /** * make sure this wasn't a cast, and also make sure we're * actually dealing with a class/enum/struct/union type */ if ( m_start->GetParentType() == CT_C_CAST || !m_start->IsClassEnumStructOrUnion()) { return; } Chunk *prev = m_start; Chunk *next = prev->GetNextNcNnl(); /** * the enum-key might be enum, enum class or enum struct */ if (next->IsEnum()) { prev = next; next = prev->GetNextNcNnl(); } else if (prev->IsEnum()) { Chunk *prev_prev = prev->GetPrevNcNnlNi(); if ( prev_prev->IsEnum() && prev->IsEnum()) { m_start = prev_prev; } } /** * pre-process all chunks between the starting and ending chunks identified * in the initial pass */ while (chunk_is_between(next, m_start, m_end)) { /** * skip attributes */ next = skip_attribute(next); /** * skip declspec */ next = skip_declspec(next); /** * skip any right-hand side assignments */ if (next->Is(CT_ASSIGN)) { next = skip_to_expression_end(next); } if ( next->Is(CT_ANGLE_OPEN) && !template_detected()) { next = parse_angles(next); } else if ( next->Is(CT_BRACE_OPEN) && !body_detected()) { next = parse_braces(next); } else if (next->IsColon()) { parse_colon(next); } else if (next->Is(CT_COMMA)) { record_top_level_comma(next); } else if (next->Is(CT_DC_MEMBER)) { next = parse_double_colon(next); } else if ( next->IsParenOpen() && ( language_is_set(LANG_D) || ( language_is_set(LANG_PAWN) && m_start->IsEnum()))) { set_paren_parent(next, m_start->GetType()); if ( prev->Is(CT_WORD) && language_is_set(LANG_D)) { mark_template(next); } next = next->GetClosingParen(E_Scope::PREPROC); } else if ( next->Is(CT_QUALIFIER) && language_is_set(LANG_JAVA) && std::strncmp(next->GetStr().c_str(), "implements", 10) == 0) { mark_base_classes(next); } else if (next->Is(CT_QUESTION)) { record_question_operator(next); } else if ( next->Is(CT_WHERE) && !where_clause_detected()) { mark_where_clause(next); } prev = next; do { next = next->GetNextNcNnl(); } while ( next->IsNotNullChunk() && next->GetLevel() > m_start->GetLevel()); } /** * identify the type and/or variable(s) */ analyze_identifiers(); /** * identify and mark lvalues occurring outside the body definition */ mark_extracorporeal_lvalues(); if ( prev->IsNotNullChunk() && prev->IsSemicolon() && prev->GetLevel() == m_start->GetLevel() && !prev->TestFlags(PCF_IN_FOR)) { prev->SetParentType(m_start->GetType()); } } // EnumStructUnionParser::parse Chunk *EnumStructUnionParser::parse_angles(Chunk *angle_open) { LOG_FUNC_ENTRY(); /** * first check to see if the open angle occurs within an inheritance list */ auto *pc = angle_open; if (!is_within_inheritance_list(pc)) { /** * check to see if there's a matching closing angle bracket */ auto *angle_close = angle_open->GetClosingParen(E_Scope::PREPROC); if (angle_close->IsNullChunk()) { // parse error parse_error_detected(true); // TODO: should this be just a warning or an error (with exit condition?) LOG_FMT(LWARN, "%s(%d): Unmatched '<' at orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, angle_open->GetOrigLine(), angle_open->GetOrigCol()); } else { /** * check to make sure that the template is the final chunk in a list * of scope-resolution qualifications */ auto *next = angle_close->GetNextNcNnl(); if (next->IsNot(CT_DC_MEMBER)) { set_template_start(angle_open); /** * we could be dealing with a template type; if so, the opening angle * bracket should be preceded by a CT_WORD token and we should have * found a closing angle bracket */ auto *prev = angle_open->GetPrevNcNnlNi(); if (prev->IsNot(CT_WORD)) { // parse error parse_error_detected(true); // TODO: should this be just a warning or an error (with exit condition?) LOG_FMT(LWARN, "%s(%d): Identifier missing before '<' at orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, angle_open->GetOrigLine(), angle_open->GetOrigCol()); } else { set_template_end(angle_close); mark_template(angle_open); } } /** * update input argument to point to the closing angle bracket */ pc = angle_close; } } return(pc); } // EnumStructUnionParser::parse_angles Chunk *EnumStructUnionParser::parse_braces(Chunk *brace_open) { LOG_FUNC_ENTRY(); /** * check to see if there's a matching closing brace */ auto *pc = brace_open; auto *brace_close = pc->GetClosingParen(E_Scope::PREPROC); if (brace_close->IsNotNullChunk()) { /** * we could be dealing with a variable definition preceded by * the class/struct keyword. It's possible that the variable is * assigned via direct-list initialization, hence the open brace * is NOT part of a class/struct type definition. */ auto *first_comma = get_first_top_level_comma(); if (chunk_is_after(pc, first_comma)) { /** * the open brace occurs after a top-level comma was encountered, which * likely implies a direct-initialization or braced initializer list in * the midst of a list of variable definitions */ return(pc); } set_body_end(brace_close); set_body_start(brace_open); auto *enum_base_start = get_enum_base_start(); auto *inheritance_start = get_inheritance_start(); auto *prev = pc->GetPrevNcNnlNi(); /** * check to see if the open brace was preceded by a closing paren; * it could possibly be a function-like macro call preceding the * open brace, but it's more likely that we're dealing with a * signature associated with a function definition */ bool is_potential_function_definition = false; if ( ( language_is_set(LANG_C) || language_is_set(LANG_CPP)) && prev->IsParenClose()) { /** * we may be dealing with a c/cpp function definition, where the 'struct' * or 'class' keywords appear as the return type preceding a pair of braces * and therefore may be associated with a function definition body */ auto *paren_close = prev; // skip in reverse to the matching open paren auto *paren_open = paren_close->GetOpeningParen(); if (paren_open->IsNotNullChunk()) { /** * determine if there's an identifier preceding the open paren; * if so, the identifier is very likely to be associated with * a function definition */ auto *type = m_start->GetNextNcNnl(); auto *identifier = paren_open->GetPrevNcNnlNi(E_Scope::PREPROC); is_potential_function_definition = ( ( identifier->Is(CT_FUNCTION) || identifier->Is(CT_FUNC_DEF) || identifier->Is(CT_WORD)) && type != identifier); } } if ( language_is_set(LANG_D) || language_is_set(LANG_PAWN) || !prev->IsParenClose() || is_potential_function_definition || chunk_is_between(prev, enum_base_start, brace_open) || chunk_is_between(prev, inheritance_start, brace_open)) { mark_braces(brace_open); /** * D does not require a semicolon after an enum, but we add one to make * other code happy. */ if ( language_is_set(LANG_D) && m_start->IsEnum()) { pawn_add_vsemi_after(brace_close); // Issue #2279 } pc = brace_close; } else { // TODO: should this be just a warning or an error (with exit condition?) LOG_FMT(LWARN, "%s(%d): Parsing error precedes start of body '{' at orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, brace_open->GetOrigLine(), brace_open->GetOrigCol()); // parse error parse_error_detected(true); } } return(pc); } // EnumStructUnionParser::parse_braces void EnumStructUnionParser::parse_colon(Chunk *colon) { LOG_FUNC_ENTRY(); if (m_start->Is(CT_UNION)) { /** * unions do not implement inheritance */ // TODO: should this be just a warning or an error (with exit condition?) LOG_FMT(LWARN, "%s(%d): Colon follows union declaration at orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, colon->GetOrigLine(), colon->GetOrigCol()); // parse error parse_error_detected(true); } else if (is_within_conditional(colon)) { mark_conditional_colon(colon); } else if (is_within_where_clause(colon)) { mark_where_colon(colon); } else if (!inheritance_detected()) { if (m_start->IsClassOrStruct()) { /** * the colon likely specifies an inheritance list for a struct * or class type */ set_inheritance_start(colon); mark_class_colon(colon); } else if (m_start->IsEnum()) { set_enum_base_start(colon); mark_enum_integral_type(colon); } } } // EnumStructUnionParser::parse_colon Chunk *EnumStructUnionParser::parse_double_colon(Chunk *double_colon) { LOG_FUNC_ENTRY(); auto *pc = double_colon; if ( language_is_set(LANG_CPP) && pc->Is(CT_DC_MEMBER)) { mark_nested_name_specifiers(pc); pc = skip_scope_resolution_and_nested_name_specifiers(pc); } return(pc); } // EnumStructUnionParser::parse_double_colon bool EnumStructUnionParser::parse_error_detected() const { LOG_FUNC_ENTRY(); return(m_parse_error); } // EnumStructUnionParser::parse_error_detected void EnumStructUnionParser::parse_error_detected(bool status) { LOG_FUNC_ENTRY(); m_parse_error = status; } // EnumStructUnionParser::parse_error_detected void EnumStructUnionParser::record_question_operator(Chunk *question) { LOG_FUNC_ENTRY(); if (question->Is(CT_QUESTION)) { std::size_t index = m_chunk_map[CT_QUESTION].size(); m_chunk_map[CT_QUESTION][index] = question; } } // EnumStructUnionParser::record_question_operator void EnumStructUnionParser::record_top_level_comma(Chunk *comma) { if ( comma != nullptr && comma->GetLevel() == m_start->GetLevel() && !is_within_conditional(comma) && !is_within_inheritance_list(comma)) { std::size_t index = m_chunk_map[CT_COMMA].size(); m_chunk_map[CT_COMMA][index] = comma; } } // EnumStructUnionParser::record_top_level_comma Chunk *EnumStructUnionParser::refine_end_chunk(Chunk *pc) { LOG_FUNC_ENTRY(); if ( ( language_is_set(LANG_C) || language_is_set(LANG_CPP)) && pc->Is(CT_BRACE_CLOSE)) { /** * if dealing with C/C++, one or more trailing variable definitions may * follow the closing brace; a semi-colon should've been good enough to * indicate the terminating condition, however some of the classes defined * in the input tests cases for Continuous Integration DO NOT correctly * terminate classes/struct with a semicolon (which is compilation error). * As a consequence, more checks must be performed to determine where * the terminating chunk is located. For instance, see operator.cpp and * enum_comma.h for examples of offenders */ auto *next = pc->GetNextNcNnl(); while (true) { if (next->IsSemicolon()) { pc = next; break; } else { /** * if we're sitting at a comma, skip it */ if (next->Is(CT_COMMA)) { next = next->GetNextNcNnl(); } auto match = match_variable(next, m_start->GetLevel()); auto *start = std::get<0>(match); auto *identifier = std::get<1>(match); auto *end = std::get<2>(match); if ( end == nullptr || identifier == nullptr || start == nullptr) { break; } else { pc = end->GetNextNcNnl(); /** * skip any right-hand side assignments */ if (pc->Is(CT_ASSIGN)) { pc = skip_to_expression_end(pc); } next = pc; } } } } return(pc); } // EnumStructUnionParser::refine_end_chunk void EnumStructUnionParser::set_body_end(Chunk *body_end) { LOG_FUNC_ENTRY(); if (body_end->Is(CT_BRACE_CLOSE)) { m_chunk_map[CT_BRACE_CLOSE][0] = body_end; } } // EnumStructUnionParser::set_body_end void EnumStructUnionParser::set_body_start(Chunk *body_start) { LOG_FUNC_ENTRY(); if (body_start->Is(CT_BRACE_OPEN)) { m_chunk_map[CT_BRACE_OPEN][0] = body_start; } } // EnumStructUnionParser::set_body_start void EnumStructUnionParser::set_enum_base_start(Chunk *enum_base_start) { LOG_FUNC_ENTRY(); if (enum_base_start->IsColon()) { m_chunk_map[CT_BIT_COLON][0] = enum_base_start; } } // EnumStructUnionParser::set_enum_base_start void EnumStructUnionParser::set_inheritance_start(Chunk *inheritance_start) { LOG_FUNC_ENTRY(); if (inheritance_start->IsColon()) { m_chunk_map[CT_COLON][0] = inheritance_start; } } // EnumStructUnionParser::set_inheritance_start void EnumStructUnionParser::set_template_end(Chunk *template_end) { LOG_FUNC_ENTRY(); if (template_end->Is(CT_ANGLE_CLOSE)) { m_chunk_map[CT_ANGLE_CLOSE][0] = template_end; } } // EnumStructUnionParser::set_template_end void EnumStructUnionParser::set_template_start(Chunk *template_start) { LOG_FUNC_ENTRY(); if (template_start->Is(CT_ANGLE_OPEN)) { m_chunk_map[CT_ANGLE_OPEN][0] = template_start; } } // EnumStructUnionParser::set_template_start void EnumStructUnionParser::set_where_end(Chunk *where_end) { LOG_FUNC_ENTRY(); if (where_end->Is(CT_BRACE_OPEN)) { m_chunk_map[CT_WHERE][0] = where_end; } } // EnumStructUnionParser::set_where_end void EnumStructUnionParser::set_where_start(Chunk *where_start) { LOG_FUNC_ENTRY(); if (where_start->Is(CT_WHERE)) { m_chunk_map[CT_WHERE][0] = where_start; } } // EnumStructUnionParser::set_where_start bool EnumStructUnionParser::template_detected() const { LOG_FUNC_ENTRY(); auto *template_end = get_template_end(); auto *template_start = get_template_start(); return( template_end != nullptr && template_start != nullptr); } // EnumStructUnionParser::template_detected Chunk *EnumStructUnionParser::try_find_end_chunk(Chunk *pc) { LOG_FUNC_ENTRY(); LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); do { LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); /** * clear some previously marked token types, some of which have likely * been erroneously marked up to this point; a good example of this * arises when macro variables and/or macro function calls follow the * class/enum/struct/union keyword and precede the actual type name */ if ( pc->Is(CT_TYPE) || pc->Is(CT_WORD)) { pc->SetType(CT_WORD); pc->SetParentType(CT_NONE); } LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); do { pc = pc->GetNextNcNnl(E_Scope::PREPROC); LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); } while ( pc->IsNotNullChunk() && pc->GetLevel() > m_start->GetLevel()); if (pc->IsNullChunk()) { LOG_FMT(LFTOR, "%s(%d): IsNullChunk\n", __unqualified_func__, __LINE__); // parse error parse_error_detected(true); return(Chunk::NullChunkPtr); } else { LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, type is %s\n", __unqualified_func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); } } while (!is_potential_end_chunk(pc)); /** * perform a second pass for c++ that */ pc = refine_end_chunk(pc); return(pc); } // EnumStructUnionParser::try_find_end_chunk void EnumStructUnionParser::try_post_identify_macro_calls() { LOG_FUNC_ENTRY(); if ( language_is_set(LANG_CPP) && type_identified()) { /** * for all chunks at class/enum/struct/union level, identify function-like * macro calls and mark them as CT_MACRO_FUNC_CALL. The reason for doing * so is to avoid mis-interpretation by code executed at a later time */ auto *body_start = get_body_start(); auto *inheritance_start = get_inheritance_start(); Chunk *pc = m_start; Chunk *prev = Chunk::NullChunkPtr; do { if ( !chunk_is_between(prev, inheritance_start, body_start) && ( prev->Is(CT_WORD) || prev->Is(CT_FUNCTION) || prev->Is(CT_FUNC_DEF)) && !prev->GetFlags().test_any(PCF_VAR_DEF | PCF_VAR_1ST | PCF_VAR_INLINE) && prev->GetLevel() == m_start->GetLevel()) { if (pc->IsParenOpen()) { auto *paren_open = pc; auto *paren_close = paren_open->GetClosingParen(E_Scope::PREPROC); if (paren_close->IsNotNullChunk()) { paren_open->SetType(CT_FPAREN_OPEN); paren_open->SetParentType(CT_MACRO_FUNC_CALL); paren_close->SetType(CT_FPAREN_CLOSE); paren_close->SetParentType(CT_MACRO_FUNC_CALL); prev->SetType(CT_MACRO_FUNC_CALL); } } } prev = pc; pc = prev->GetNextNcNnl(); } while (chunk_is_between(pc, m_start, m_end)); } } // EnumStructUnionParser::try_post_identify_macro_calls void EnumStructUnionParser::try_post_identify_type() { LOG_FUNC_ENTRY(); Chunk *body_end = get_body_end(); if ( !type_identified() && body_end == nullptr) { /** * a type wasn't identified and no closing brace is present; we're * likely not dealing with an anonymous enum/class/struct */ /** * a type has yet to be identified, so search for the last word * that hasn't been marked as a variable */ Chunk *type = nullptr; Chunk *pc = m_start; do { /** * in case it's a qualified identifier, skip scope-resolution and * nested name specifiers and return just the qualified identifier name */ pc = skip_scope_resolution_and_nested_name_specifiers(pc); if (pc->GetFlags().test_any(PCF_VAR_DEF | PCF_VAR_1ST | PCF_VAR_INLINE)) { break; } else if ( pc->Is(CT_WORD) || pc->Is(CT_ANGLE_CLOSE)) { type = skip_template_prev(pc); } pc = pc->GetNextNcNnl(); } while (chunk_is_between(pc, m_start, m_end)); if (type != nullptr) { mark_type(type); } } } // EnumStructUnionParser::try_post_identify_type bool EnumStructUnionParser::try_pre_identify_type() { LOG_FUNC_ENTRY(); Chunk *pc = get_body_start(); if ( language_is_set(LANG_PAWN) && m_start->IsEnum()) { set_paren_parent(pc, m_start->GetType()); } else if (template_detected()) { pc = get_template_start(); } else if (enum_base_detected()) { pc = get_enum_base_start(); } else if (inheritance_detected()) { pc = get_inheritance_start(); if (m_start->Is(CT_UNION)) { /** * unions do not implement inheritance */ // TODO: should this be just a warning or an error (with exit condition?) LOG_FMT(LWARN, "%s(%d): Bad union declaration detected at orig line is %zu, orig col is %zu\n", __unqualified_func__, __LINE__, m_start->GetOrigLine(), m_start->GetOrigCol()); parse_error_detected(true); return(false); } } if (pc == nullptr) { Chunk *next = m_start->GetNextNcNnl(); /** * in case it's a qualified identifier, skip scope-resolution and * nested name specifiers and return just the qualified identifier name */ next = skip_scope_resolution_and_nested_name_specifiers(next); Chunk *next_next = next->GetNextNcNnl(); /** * in case it's a qualified identifier, skip scope-resolution and * nested name specifiers and return just the qualified identifier name */ next_next = skip_scope_resolution_and_nested_name_specifiers(next_next); /** * if there is one word between the start and end chunks, then we've likely * identified the type; if there are two words, then the first is likely a * type and the second is an instantiation thereof; however, it is possible * that the first word is actually a reference to a macro definition, in which * the second word would be the type */ if (next_next == m_end) { pc = next_next; } else if ( next->IsNotNullChunk() && next->Is(CT_WORD) && next_next->Is(CT_WORD) && m_end->GetPrevNcNnlNi() == next_next) { /** * check to see if we've got a macro reference preceding the last word chunk; * this won't work in all cases, because a macro may be defined in another header * file, but this is an attempt to increase the chances of identifying the correct * chunk as the type */ if ( chunk_is_macro_reference(next) || m_start->GetParentType() == CT_TEMPLATE) { pc = m_end; } else { pc = next_next; } } else { /** * search for some common patterns that may indicate a type */ Chunk *prev = m_start; while ( chunk_is_between(next, m_start, m_end) && ( ( next->IsNot(CT_ASSIGN) && next->IsNot(CT_COMMA)) || next->GetLevel() != m_start->GetLevel()) && !next->IsSemicolon()) { prev = next; next = next->GetNextNcNnl(); /** * in case it's a qualified identifier, skip scope-resolution and * nested name specifiers and return just the qualified identifier name */ next = skip_scope_resolution_and_nested_name_specifiers(next); /** * skip array brackets, as the type cannot be located within; * also skip a set of parens - there may be a type embedded within, * but it's not the type with which we're concerned */ if ( next->IsSquareBracket() // Issue #3601 || next->IsParenOpen()) { prev = next->GetClosingParen(E_Scope::PREPROC); next = prev->GetNextNcNnl(E_Scope::PREPROC); } if ( prev->Is(CT_WORD) && next->IsPointerOrReference()) { pc = next; break; } } } } if ( pc != nullptr && pc->IsNotNullChunk()) { /** * the chunk preceding the previously selected chunk should indicate the type */ pc = pc->GetPrevNcNnlNi(E_Scope::PREPROC); if ( pc->Is(CT_QUALIFIER) && std::strncmp(pc->GetStr().c_str(), "final", 5) == 0) { pc = pc->GetPrevNcNnlNi(E_Scope::PREPROC); } if ( language_is_set(LANG_D) && pc->IsParenClose()) { pc = pc->GetOpeningParen(); pc = pc->GetPrevNcNnlNi(); } if (pc->Is(CT_WORD)) { mark_type(pc); return(true); } } return(false); } // EnumStructUnionParser::try_pre_identify_type bool EnumStructUnionParser::type_identified() const { LOG_FUNC_ENTRY(); return(m_type != nullptr); } // EnumStructUnionParser::type_identified /** * Returns true if a where clause was detected during parsing */ bool EnumStructUnionParser::where_clause_detected() const { LOG_FUNC_ENTRY(); auto *where_end = get_where_end(); auto *where_start = get_where_start(); return( where_end != nullptr && where_start != nullptr); } // EnumStructUnionParser::where_clause_detected uncrustify-uncrustify-0.76.0/src/EnumStructUnionParser.h000066400000000000000000000264051434072136500235030ustar00rootroot00000000000000/** * @file combine_fix_mark_enum_struct_union.h * * @author Joshua Parker * @license GPL v2+ * extract from combine_fix_mark.h */ #ifndef ENUM_STRUCT_UNION_PARSER_H_INCLUDED #define ENUM_STRUCT_UNION_PARSER_H_INCLUDED #include "pcf_flags.h" #include "token_enum.h" #include "uncrustify_types.h" #include /** * Class EnumStructUnionParser : This class facilitates the parsing and interpretation * of ALL instances of the class, enum, union, and * struct keywords, including user-defined types with * a body {} and any trailing inline variable declarations * that may follow the definition (as permitted by * the coding language in question). The class also * interprets variable declarations preceded by one * of those keywords, as well as any C/C++ forward * declarations */ class EnumStructUnionParser { public: /** * Constructor */ EnumStructUnionParser(); /** * Destructor */ ~EnumStructUnionParser(); private: /** * Analyzes all identifiers (marked as CT_WORD) between the starting and * ending chunks and changes CT_WORD to one of CT_TYPE, CT_MACRO_FUNC_CALL, * etc. and sets flags (PCF_VAR_1ST, PCF_VAR_1ST_DEF, PCF_VAR_INLINE, etc.) * for variable identifiers accordingly. Flags C++ forward declarations as * PCF_INCOMPLETE */ void analyze_identifiers(); /** * Returns true if a pair of braces were both detected AND determined to be * part of a class/enum/struct/union body */ bool body_detected() const; /** * Returns true if comma-separated values were detected during parsing */ bool comma_separated_values_detected() const; /** * Returns true if an enumerated integral type was detected during parsing */ bool enum_base_detected() const; /** * Returns the end chunk of a class/enum/struct/union body, if detected * during parsing */ Chunk *get_body_end() const; /** * Returns the starting chunk of a class/enum/struct/union body, if detected * during parsing */ Chunk *get_body_start() const; /** * Returns the starting chunk associated with an enumerated type's base * specifier statement, if detected during parsing */ Chunk *get_enum_base_start() const; /** * Returns the first comma encountered at the level of the starting chunk, * if detected during parsing */ Chunk *get_first_top_level_comma() const; /** * Returns the ending chunk associated with an class/struct inheritance * list, if detected during parsing */ Chunk *get_inheritance_end() const; /** * Returns the starting chunk associated with an class/struct inheritance * list, if detected during parsing */ Chunk *get_inheritance_start() const; /** * Returns a numerically-indexed map of all question operators encountered * during parsing */ std::map get_question_operators() const; /** * Returns the end chunk associated with a template parameter list, if * detected during parsing */ Chunk *get_template_end() const; /** * Return the starting chunk associated with a template parameter list, if * detected during parsing */ Chunk *get_template_start() const; /** * Returns a numerically-indexed map of all top-level commas encountered * during parsing */ std::map get_top_level_commas() const; /** * Return the starting chunk associated with a where clause, if * detected during parsing */ Chunk *get_where_end() const; /** * Return the starting chunk associated with a where clause, if * detected during parsing */ Chunk *get_where_start() const; /** * Returns true if an inheritance list associated with a class or struct was * discovered during parsing */ bool inheritance_detected() const; public: /** * Performs object initialization prior to parsing */ void initialize(Chunk *pc); private: /** * Returns true if the chunk under test represents a potential end chunk past * which further parsing is not likely warranted */ bool is_potential_end_chunk(Chunk *pc) const; /** * Returns true if the chunk under test is deemed to be located within a * conditional/ternary statement */ bool is_within_conditional(Chunk *pc) const; /** * Returns true if the chunk under test is deemed to be located within an * inheritance list */ bool is_within_inheritance_list(Chunk *pc) const; /** * Returns true if the chunk under test is deemed to be located within a * where clause */ bool is_within_where_clause(Chunk *pc) const; /** * Marks all base classes that appear as part of an inheritance list */ void mark_base_classes(Chunk *pc); /** * Marks pairs of braces associated with the body of a class/enum/struct/union, * and additionally calls a separate routine to mark any base classes for that * may precede the opening brace */ void mark_braces(Chunk *start); /** * Marks the beginning chunk of an inheritance list */ void mark_class_colon(Chunk *colon); /** * Mark a colon as a conditional */ void mark_conditional_colon(Chunk *colon); /** * Mark any struct/class constructor declarations/definitions */ void mark_constructors(); /** * Marks the beginning chunk of an enumerated integral type specification */ void mark_enum_integral_type(Chunk *colon); /** * Scan chunks outside the definition body and mark lvalues accordingly */ void mark_extracorporeal_lvalues(); /** * Mark nested name specifiers preceding qualified identifiers */ void mark_nested_name_specifiers(Chunk *pc); /** * Marks pointer operators preceding a variable identifier */ void mark_pointer_types(Chunk *pc); /** * Marks the beginning and ending chunks associated with a template * (templates may appear after the identifier type name as part of a class * specialization) */ void mark_template(Chunk *start) const; /** * Marks the arguments within a template argument list bounded by the * starting and ending chunks */ void mark_template_args(Chunk *start, Chunk *end) const; /** * Marks the type identifier associated with the class/enum/struct/union, * if not anonymously defined */ void mark_type(Chunk *pc); /** * Marks all variable identifiers associated with the class/enum/struct/union */ void mark_variable(Chunk *variable, T_PcfFlags flags); /** * Marks all chunks belonging to a c# where clause */ void mark_where_clause(Chunk *where); /** * Marks the beginning of a where clause */ void mark_where_colon(Chunk *colon); public: /** * Parses the class/enum/struct/union and all associated chunks */ void parse(Chunk *pc); private: /** * Parses closing and opening angle brackets */ Chunk *parse_angles(Chunk *angle_open); /** * Parses closing and opening braces */ Chunk *parse_braces(Chunk *brace_open); /** * Parses a single colon, which may precede an inheritance list or * enumerated integral type specification */ void parse_colon(Chunk *colon); /** * Parses a double colon, which may indicate a scope resolution chain */ Chunk *parse_double_colon(Chunk *double_colon); /** * Returns the parsing error status */ bool parse_error_detected() const; /** * Sets the parsing error status */ void parse_error_detected(bool status); /** * Records all question operators encountered during parsing */ void record_question_operator(Chunk *question); /** * Records a comma chunk given one the following conditions are satisfied: * 1) it is encountered at the level of the starting chunk * 2) it is not part of a right-hand side assignment * 3) it is not part of an inheritance list * 4) it is not part of a conditional/ternary expression */ void record_top_level_comma(Chunk *comma); /** * Adjusts the end chunk returned by the try_find_end_chunk() function * for any potential trailing inline variable declarations that may follow * the body of a class/enum/struct/union definition */ Chunk *refine_end_chunk(Chunk *pc); /** * Sets the chunk associated with the end of a class/enum/struct/union * body */ void set_body_end(Chunk *body_end); /** * Sets the chunk associated with the start of a class/enum/struct/union * body */ void set_body_start(Chunk *body_start); /** * Sets the chunk associated with the start of an enumerated integral * base type specification */ void set_enum_base_start(Chunk *enum_base_start); /** * Sets the chunk associated with the start of an inheritance list */ void set_inheritance_start(Chunk *inheritance_start); /** * Sets the chunk associated with the end of a template */ void set_template_end(Chunk *template_end); /** * Sets the chunk associated with the start of a template */ void set_template_start(Chunk *template_start); /** * Return the ending chunk associated with a where clause, if * detected during parsing */ void set_where_end(Chunk *where_end); /** * Return the starting chunk associated with a where clause, if * detected during parsing */ void set_where_start(Chunk *where_start); /** * Returns true if a template was detected during parsing */ bool template_detected() const; /** * Attempts to find the last chunk associated with the class/enum/struct/union */ Chunk *try_find_end_chunk(Chunk *pc); /** * Attempts to identify any function-like macro calls which may precede the * actual type identifier */ void try_post_identify_macro_calls(); /** * Attempts to find the identifier type name (if not anonymously-defined) post * variable identifier interpretation */ void try_post_identify_type(); /** * Attempts to find the identifier type name prior to variable identifier * interpretation */ bool try_pre_identify_type(); /** * Returns true if a corresponding type was identified for the class/enum/struct/union */ bool type_identified() const; /** * Returns true if a where clause was detected during parsing */ bool where_clause_detected() const; /** * Map of token-type, chunk pairs */ std::map > m_chunk_map; /** * Indicates the last chunk associated with the class/enum/struct/union keyword */ Chunk *m_end; /** * Indicates whether or not a parse error has occurred */ bool m_parse_error; /** * Stores a pointer to the class/enum/struct/union keyword chunk with which the * parse() routine was invoked */ Chunk *m_start; /** * Stores a pointer to the type identifier associated with the class/enum/struct/union, * if not anonymously defined */ Chunk *m_type; }; #endif uncrustify-uncrustify-0.76.0/src/ListManager.h000066400000000000000000000104041434072136500214020ustar00rootroot00000000000000/** * @file ListManager.h * Template class that manages items in a double-linked list. * If C++ could do it, this would just be a class that worked on an interface. * * @author Ben Gardner * @license GPL v2+ */ #ifndef LIST_MANAGER_H_INCLUDED #define LIST_MANAGER_H_INCLUDED #include "chunk.h" /** * A simple list manager for a double-linked list of Chunk items. */ class ChunkListManager { protected: Chunk *m_head; // pointer to the head of list Chunk *m_tail; // pointer to tail of list public: ChunkListManager() { m_head = Chunk::NullChunkPtr; m_tail = Chunk::NullChunkPtr; } /** * @return pointer to first element of the linked list */ Chunk *GetHead() const { return(m_head); } /** * @return pointer to last element of the linked list */ Chunk *GetTail() const { return(m_tail); } /** * @brief remove an element from a linked list * @param[in] obj chunk to remove from the list */ void Remove(Chunk *obj) { if (obj != Chunk::NullChunkPtr) { if (m_head == obj) { m_head = obj->m_next; } if (m_tail == obj) { m_tail = obj->m_prev; } if (obj->m_next != Chunk::NullChunkPtr) { obj->m_next->m_prev = obj->m_prev; } if (obj->m_prev != Chunk::NullChunkPtr) { obj->m_prev->m_next = obj->m_next; } obj->m_next = Chunk::NullChunkPtr; obj->m_prev = Chunk::NullChunkPtr; } } //! swap two elements of a list void Swap(Chunk *obj1, Chunk *obj2) { if ( obj1 != Chunk::NullChunkPtr && obj2 != Chunk::NullChunkPtr) { if (obj1->m_prev == obj2) { Remove(obj1); AddBefore(obj1, obj2); } else if (obj2->m_prev == obj1) { Remove(obj2); AddBefore(obj2, obj1); } else { Chunk *m_prev1 = obj1->m_prev; Remove(obj1); Chunk *m_prev2 = obj2->m_prev; Remove(obj2); AddAfter(obj1, m_prev2); AddAfter(obj2, m_prev1); } } } /** * @brief add a new element after a reference position in a list * * @param obj new element to add to list * @param ref chunk after which to insert new object */ void AddAfter(Chunk *obj, Chunk *ref) { if ( obj != Chunk::NullChunkPtr && ref != Chunk::NullChunkPtr) { obj->m_next = ref->m_next; obj->m_prev = ref; if (ref->m_next != Chunk::NullChunkPtr) { ref->m_next->m_prev = obj; } else { m_tail = obj; } ref->m_next = obj; } } /** * @brief add a new element before a reference position in a list * * @param obj new element to add to list * @param ref chunk before to insert new object */ void AddBefore(Chunk *obj, Chunk *ref) { if ( obj != Chunk::NullChunkPtr && ref != Chunk::NullChunkPtr) { Remove(obj); obj->m_next = ref; obj->m_prev = ref->m_prev; if (ref->m_prev != Chunk::NullChunkPtr) { ref->m_prev->m_next = obj; } else { m_head = obj; } ref->m_prev = obj; } } /** * @brief add a new element to the tail of a lis * * @param obj new element to add to the list */ void AddTail(Chunk *obj) { obj->m_next = Chunk::NullChunkPtr; obj->m_prev = m_tail; if (m_tail == Chunk::NullChunkPtr) { m_tail = obj; m_head = obj; } else { m_tail->m_next = obj; } m_tail = obj; } /** * @brief add a new element to the head of a list * * @param obj new element to add to the list */ void AddHead(Chunk *obj) { obj->m_next = m_head; obj->m_prev = Chunk::NullChunkPtr; if (m_head == Chunk::NullChunkPtr) { m_tail = obj; m_head = obj; } else { m_head->m_prev = obj; } m_head = obj; } }; #endif /* LIST_MANAGER_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/ParseFrame.cpp000066400000000000000000000225761434072136500215710ustar00rootroot00000000000000/** * @file ParseFrame.cpp * * Container that holds data needed for indenting and brace parsing * * @author Daniel Chumak * @license GPL v2+ */ #include "ParseFrame.h" #include "chunk.h" #include "uncrustify.h" #include // to get std::logic_error using std::string; using std::to_string; using std::invalid_argument; using ContainerType = paren_stack_entry_t; using Container = std::vector; //! amount of elements for which memory is going to be pre-initialized static constexpr const int CONTAINER_INIT_SIZE = 16; static ContainerType genDummy() { ContainerType tmp_dummy{}; tmp_dummy.indent = 1; tmp_dummy.indent_tmp = 1; tmp_dummy.indent_tab = 1; tmp_dummy.type = CT_EOF; tmp_dummy.pc = Chunk::NullChunkPtr; tmp_dummy.pop_pc = Chunk::NullChunkPtr; return(tmp_dummy); } void ParseFrame::clear() { last_poped = genDummy(); pse = Container{}; pse.reserve(CONTAINER_INIT_SIZE); pse.push_back(genDummy()); ref_no = 0; level = 0; brace_level = 0; pp_level = 0; sparen_count = 0; paren_count = 0; in_ifdef = E_Token::CT_NONE; stmt_count = 0; expr_count = 0; } ParseFrame::ParseFrame() { ParseFrame::clear(); } bool ParseFrame::empty() const { // always at least one (dummy) element inside pse guaranteed return(false); // return(pse.empty()); } ContainerType &ParseFrame::at(size_t idx) { return(pse.at(idx)); } const ContainerType &ParseFrame::at(size_t idx) const { return(pse.at(idx)); } ContainerType &ParseFrame::prev(size_t idx) { LOG_FUNC_ENTRY(); if (idx == 0) { throw invalid_argument(string(__FILE__) + ":" + to_string(__LINE__) + " idx can't be zero"); } if (idx >= pse.size()) { LOG_FMT(LINDPSE, "%s(%d): idx is %zu, size is %zu\n", __func__, __LINE__, idx, pse.size()); throw invalid_argument(string(__FILE__) + ":" + to_string(__LINE__) + " idx can't be >= size()"); } return(*std::prev(std::end(pse), idx + 1)); } const ContainerType &ParseFrame::prev(size_t idx) const { LOG_FUNC_ENTRY(); if ( idx == 0 || idx >= pse.size()) { throw invalid_argument(string(__FILE__) + ":" + to_string(__LINE__) + " idx can't be zero or >= size()"); } return(*std::prev(std::end(pse), idx + 1)); } ContainerType &ParseFrame::top() { // always at least one (dummy) element inside pse guaranteed // if (pse.empty()) // { // throw logic_error(string(__FILE__) + ":" + to_string(__LINE__) // + " called top on an empty stack"); // } return(*std::prev(std::end(pse))); } const ContainerType &ParseFrame::top() const { // always at least one (dummy) element inside pse guaranteed // if (pse.empty()) // { // throw logic_error(string(__FILE__) + ":" + to_string(__LINE__) // + " called top on an empty stack"); // } return(*std::prev(std::end(pse))); } void ParseFrame::push(std::nullptr_t, brace_stage_e stage) { static Chunk dummy; push(&dummy, __func__, __LINE__, stage); top().pc = Chunk::NullChunkPtr; } void ParseFrame::push(Chunk *pc, const char *func, int line, brace_stage_e stage) { LOG_FUNC_ENTRY(); ContainerType new_entry = {}; new_entry.type = pc->GetType(); new_entry.level = pc->GetLevel(); new_entry.open_line = pc->GetOrigLine(); new_entry.open_colu = pc->GetOrigCol(); new_entry.pc = pc; new_entry.indent_tab = top().indent_tab; new_entry.indent_cont = top().indent_cont; new_entry.stage = stage; new_entry.in_preproc = pc->TestFlags(PCF_IN_PREPROC); new_entry.non_vardef = false; new_entry.ip = top().ip; new_entry.pop_pc = Chunk::NullChunkPtr; pse.push_back(new_entry); // uncomment the line below to get the address of the pse // #define DEBUG_PUSH_POP #ifdef DEBUG_PUSH_POP LOG_FMT(LINDPSE, "ParseFrame::push(%s:%d) Add is %4zu: orig line is %4zu, orig col is %4zu, type is %12s, " "brace level is %2zu, level is %2zu, pse_tos: %2zu -> %2zu\n", func, line, (size_t)this, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->GetBraceLevel(), pc->GetLevel(), (pse.size() - 2), (pse.size() - 1)); #else /* DEBUG_PUSH_POP */ LOG_FMT(LINDPSE, "ParseFrame::push(%s:%d): orig line is %4zu, orig col is %4zu, type is %12s, " "brace level is %2zu, level is %2zu, pse_tos: %2zu -> %2zu\n", func, line, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->GetBraceLevel(), pc->GetLevel(), (pse.size() - 2), (pse.size() - 1)); #endif /* DEBUG_PUSH_POP */ } void ParseFrame::pop(const char *func, int line, Chunk *pc) { LOG_FUNC_ENTRY(); // always at least one (dummy) element inside pse guaranteed // if (pse.empty()) // { // throw logic_error(string(__FILE__) + ":" + to_string(__LINE__) // + "the stack index is already zero"); // } if ( pc->GetType() == CT_PAREN_CLOSE || pc->GetType() == CT_BRACE_CLOSE || pc->GetType() == CT_VBRACE_CLOSE || pc->GetType() == CT_FPAREN_CLOSE || pc->GetType() == CT_LPAREN_CLOSE || pc->GetType() == CT_SPAREN_CLOSE || pc->GetType() == CT_TPAREN_CLOSE || pc->GetType() == CT_CLASS_COLON || pc->GetType() == CT_ANGLE_CLOSE || pc->GetType() == CT_SEMICOLON || pc->GetType() == CT_SQUARE_CLOSE) { LOG_FMT(LINDPSE, "ParseFrame::pop (%s:%d): orig line is %4zu, orig col is %4zu, type is %12s, pushed with\n", func, line, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); } else if ( pc->GetType() == CT_ACCESS || pc->GetType() == CT_ASSIGN || pc->GetType() == CT_BRACE_OPEN || pc->GetType() == CT_BOOL || pc->GetType() == CT_CASE || pc->GetType() == CT_COMMA || pc->GetType() == CT_COMMENT || pc->GetType() == CT_COMMENT_CPP || pc->GetType() == CT_COMMENT_MULTI || pc->GetType() == CT_COND_COLON || pc->GetType() == CT_FPAREN_OPEN || pc->GetType() == CT_PAREN_OPEN || pc->GetType() == CT_TPAREN_OPEN || pc->GetType() == CT_MACRO_CLOSE || pc->GetType() == CT_MACRO_OPEN || pc->GetType() == CT_NEWLINE || pc->GetType() == CT_NONE || pc->GetType() == CT_OC_END || pc->GetType() == CT_OC_MSG_NAME || pc->GetType() == CT_OC_SCOPE || pc->GetType() == CT_OC_PROPERTY || pc->GetType() == CT_PREPROC || pc->GetType() == CT_SQUARE_OPEN || pc->GetType() == CT_SQL_END || pc->GetType() == CT_TYPEDEF || pc->GetType() == CT_VSEMICOLON || pc->GetType() == CT_WORD) { LOG_FMT(LINDPSE, "ParseFrame::pop (%s:%d): orig line is %4zu, orig col is %4zu, type is %12s\n", func, line, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); } else { LOG_FMT(LINDPSE, "ParseFrame::pop (%s:%d): orig line is %4zu, orig col is %4zu, type is %12s,\n", func, line, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); LOG_FMT(LINDPSE, "ParseFrame::pop (%s:%d): the type is %s, is not coded. Please make a call.\n", func, line, get_token_name(pc->GetType())); log_flush(true); exit(EX_SOFTWARE); } #ifdef DEBUG_PUSH_POP LOG_FMT(LINDPSE, "ParseFrame::pop (%s:%d) Add is %4zu: open_line is %4zu, clos_col is %4zu, type is %12s, " "cpd.level is %2d, level is %2zu, pse_tos: %2zu -> %2zu\n", func, line, (size_t)this, pse.back().open_line, pse.back().open_colu, get_token_name(pse.back().type), cpd.pp_level, pse.back().level, (pse.size() - 1), (pse.size() - 2)); #else /* DEBUG_PUSH_POP */ LOG_FMT(LINDPSE, "ParseFrame::pop (%s:%d): open_line is %4zu, clos_col is %4zu, type is %12s, " "cpd.level is %2d, level is %2zu, pse_tos: %2zu -> %2zu\n", func, line, pse.back().open_line, pse.back().open_colu, get_token_name(pse.back().type), cpd.pp_level, pse.back().level, (pse.size() - 1), (pse.size() - 2)); #endif /* DEBUG_PUSH_POP */ last_poped = *std::prev(std::end(pse)); if (pse.size() == 1) { *std::begin(pse) = genDummy(); } else { pse.pop_back(); } } // ParseFrame::pop size_t ParseFrame::size() const { // always at least one (dummy) element inside pse guaranteed return(pse.size()); } const paren_stack_entry_t &ParseFrame::poped() const { return(last_poped); } // TODO C++14: see abstract versions: std::rend, std::cend, std::crend ... ParseFrame::iterator ParseFrame::begin() { return(std::begin(pse)); } ParseFrame::const_iterator ParseFrame::begin() const { return(std::begin(pse)); } ParseFrame::reverse_iterator ParseFrame::rbegin() { return(pse.rbegin()); } ParseFrame::const_reverse_iterator ParseFrame::rbegin() const { return(pse.rbegin()); } ParseFrame::iterator ParseFrame::end() { return(std::end(pse)); } ParseFrame::const_iterator ParseFrame::end() const { return(std::end(pse)); } ParseFrame::reverse_iterator ParseFrame::rend() { return(pse.rend()); } ParseFrame::const_reverse_iterator ParseFrame::rend() const { return(pse.rend()); } uncrustify-uncrustify-0.76.0/src/ParseFrame.h000066400000000000000000000061501434072136500212240ustar00rootroot00000000000000/** * @file ParseFrame.h * * Container that holds data needed for indenting and brace parsing * * @author Daniel Chumak * @license GPL v2+ */ #ifndef SRC_PARSEFRAME_H_ #define SRC_PARSEFRAME_H_ #include "uncrustify_types.h" #include //! Structure for counting nested level struct paren_stack_entry_t { E_Token type; //! the type that opened the entry size_t level; //! Level of opening type size_t open_line; //! line that open symbol is on, only for logging purposes size_t open_colu; //! column that open symbol is on, only for logging purposes Chunk *pc; //! Chunk that opened the level, TODO: make const size_t brace_indent; //! indent for braces - may not relate to indent size_t indent; //! indent level (depends on use) size_t indent_tmp; //! temporary indent level (depends on use) size_t indent_tab; //! the 'tab' indent (always <= real column) bool indent_cont; //! indent_continue was applied E_Token parent; //! if, for, function, etc brace_stage_e stage; //! used to check progression of complex statements. bool in_preproc; //! whether this was created in a preprocessor size_t ns_cnt; //! Number of consecutive namespace levels bool non_vardef; //! Hit a non-vardef line T_IndentData ip; Chunk *pop_pc; }; class ParseFrame { private: std::vector pse; paren_stack_entry_t last_poped; void clear(); public: size_t ref_no; size_t level; //! level of parens/square/angle/brace size_t brace_level; //! level of brace/vbrace size_t pp_level; //! level of preproc #if stuff size_t sparen_count; size_t paren_count; E_Token in_ifdef; size_t stmt_count; size_t expr_count; ParseFrame(); virtual ~ParseFrame() = default; bool empty() const; paren_stack_entry_t &at(size_t idx); const paren_stack_entry_t &at(size_t idx) const; paren_stack_entry_t &prev(size_t idx = 1); const paren_stack_entry_t &prev(size_t idx = 1) const; paren_stack_entry_t &top(); const paren_stack_entry_t &top() const; const paren_stack_entry_t &poped() const; void push(Chunk *pc, const char *func, int line, brace_stage_e stage = brace_stage_e::NONE); void push(std::nullptr_t, brace_stage_e stage = brace_stage_e::NONE); void pop(const char *func, int line, Chunk *pc); size_t size() const; using iterator = std::vector::iterator; iterator begin(); iterator end(); using const_iterator = std::vector::const_iterator; const_iterator begin() const; const_iterator end() const; using reverse_iterator = std::vector::reverse_iterator; reverse_iterator rbegin(); reverse_iterator rend(); using const_reverse_iterator = std::vector::const_reverse_iterator; const_reverse_iterator rbegin() const; const_reverse_iterator rend() const; }; #endif /* SRC_PARSEFRAME_H_ */ uncrustify-uncrustify-0.76.0/src/add_space_table.h000066400000000000000000000464771434072136500222710ustar00rootroot00000000000000// *INDENT-OFF* #include "token_enum.h" //! type that stores two chunks between those no space shall occur struct no_space_table_t { E_Token first; //! first chunk E_Token second; //! second chunk }; /** * this table lists out all combos where a space MUST be present * CT_UNKNOWN is a wildcard. * * TODO: some of these are no longer needed. */ const no_space_table_t add_space_table[] = { { CT_ACCESS, CT_TYPE }, { CT_ACCESS, CT_WORD }, { CT_ALIGN, CT_PAREN_OPEN }, { CT_AMP, CT_WORD }, { CT_ANGLE_CLOSE, CT_BRACE_OPEN }, { CT_ANNOTATION, CT_ANNOTATION }, { CT_ANNOTATION, CT_TYPE }, { CT_ASM_COLON, CT_ASM_COLON }, { CT_ASM_COLON, CT_STRING }, { CT_ASM, CT_FUNC_CALL }, { CT_ASM, CT_PAREN_OPEN }, { CT_ASM, CT_QUALIFIER }, { CT_ASSERT, CT_PAREN_OPEN }, { CT_ASSIGN_FUNC_PROTO, CT_DEFAULT }, { CT_ASSIGN_FUNC_PROTO, CT_DELETE }, { CT_ASSIGN_FUNC_PROTO, CT_NUMBER }, { CT_ATTRIBUTE, CT_ATTRIBUTE }, { CT_ATTRIBUTE, CT_BRACE_OPEN }, { CT_ATTRIBUTE, CT_CASE }, { CT_ATTRIBUTE, CT_QUALIFIER }, { CT_ATTRIBUTE, CT_TYPE }, { CT_ATTRIBUTE, CT_WORD }, { CT_AUTORELEASEPOOL, CT_BRACE_OPEN }, { CT_BIT_COLON, CT_NUMBER }, { CT_BIT_COLON, CT_SIZEOF }, { CT_BIT_COLON, CT_TYPE }, { CT_BIT_COLON, CT_WORD }, { CT_BODY, CT_BRACE_OPEN }, { CT_BRACE_CLOSE, CT_BRACE_OPEN }, { CT_BRACE_CLOSE, CT_CLASS }, { CT_BRACE_CLOSE, CT_FUNC_CALL }, { CT_BRACE_CLOSE, CT_GETSET }, { CT_BRACE_CLOSE, CT_IF }, { CT_BRACE_CLOSE, CT_OC_MSG_NAME }, { CT_BRACE_CLOSE, CT_PAREN_OPEN }, { CT_BRACE_CLOSE, CT_QUALIFIER }, { CT_BRACE_CLOSE, CT_RETURN }, { CT_BRACE_CLOSE, CT_TYPE }, { CT_BRACE_CLOSE, CT_WORD }, { CT_BREAK, CT_WORD }, { CT_BYREF, CT_INV }, { CT_CASE_COLON, CT_ATTRIBUTE }, { CT_CASE_COLON, CT_BRACE_OPEN }, { CT_CASE_COLON, CT_BREAK }, { CT_CASE_COLON, CT_RETURN }, { CT_CASE_COLON, CT_WORD }, { CT_CASE, CT_NEG }, { CT_CASE, CT_PAREN_OPEN }, { CT_CASE, CT_STRING }, { CT_CATCH, CT_FUNC_CALL }, { CT_CLASS_COLON, CT_FUNC_CALL }, { CT_CLASS_COLON, CT_QUALIFIER }, { CT_CLASS_COLON, CT_TYPE }, { CT_CLASS_COLON, CT_WORD }, { CT_COLON, CT_COLON }, { CT_COLON, CT_NUMBER }, { CT_COLON, CT_QUALIFIER }, { CT_COLON, CT_STRING }, { CT_COLON, CT_TYPE }, { CT_COLON, CT_WORD }, { CT_COMMENT_EMBED, CT_FUNC_CLASS_PROTO }, { CT_COMMENT_MULTI, CT_ELSE }, { CT_CONCAT, CT_STRING }, { CT_CONCAT, CT_WORD }, { CT_COND_COLON, CT_FUNC_CALL }, { CT_COND_COLON, CT_STRING }, { CT_COND_COLON, CT_WORD }, { CT_CONSTRUCT, CT_TYPE }, { CT_CONTINUE, CT_WORD }, { CT_CS_PROPERTY, CT_BRACE_OPEN }, { CT_DEFAULT, CT_STRING }, { CT_DEFAULT, CT_WORD }, { CT_DELEGATE, CT_BRACE_OPEN }, { CT_D_MODULE, CT_WORD }, { CT_ELLIPSIS, CT_NUMBER }, { CT_ELSE, CT_FOR }, { CT_ELSE, CT_IF }, { CT_ELSE, CT_PAREN_OPEN }, { CT_ELSE, CT_WORD }, { CT_ELSEIF, CT_CONSTEXPR }, { CT_ENUM_CLASS, CT_ATTRIBUTE }, { CT_ENUM_CLASS, CT_TYPE }, { CT_ENUM, CT_ATTRIBUTE }, { CT_ENUM, CT_BIT_COLON }, { CT_ENUM, CT_BRACE_OPEN }, { CT_ENUM, CT_ENUM_CLASS }, { CT_ENUM, CT_FPAREN_OPEN }, { CT_ENUM, CT_FUNCTION }, { CT_ENUM, CT_TYPE }, { CT_ENUM, CT_WORD }, { CT_EXECUTION_CONTEXT, CT_EXECUTION_CONTEXT }, { CT_EXECUTION_CONTEXT, CT_FPAREN_OPEN }, { CT_EXTERN, CT_STRING }, { CT_FPAREN_CLOSE, CT_ASSIGN_FUNC_PROTO }, { CT_FPAREN_CLOSE, CT_ATTRIBUTE }, { CT_FPAREN_CLOSE, CT_CLASS_COLON }, { CT_FPAREN_CLOSE, CT_COND_COLON }, { CT_FPAREN_CLOSE, CT_DEFAULT }, { CT_FPAREN_CLOSE, CT_FUNC_CALL }, { CT_FPAREN_CLOSE, CT_NEG }, { CT_FPAREN_CLOSE, CT_NOT }, { CT_FPAREN_CLOSE, CT_OC_MSG_NAME }, { CT_FPAREN_CLOSE, CT_QUESTION }, { CT_FPAREN_CLOSE, CT_STRING }, { CT_FPAREN_CLOSE, CT_THROW }, { CT_FPAREN_CLOSE, CT_TYPE }, { CT_FPAREN_CLOSE, CT_WHERE_SPEC }, { CT_FPAREN_CLOSE, CT_WORD }, { CT_FRIEND, CT_CLASS }, { CT_FRIEND, CT_STRUCT }, { CT_FRIEND, CT_TYPE }, { CT_FUNCTION, CT_PAREN_OPEN }, { CT_FUNC_VAR, CT_PPAREN_CLOSE }, { CT_GOTO, CT_WORD }, { CT_IF, CT_CONSTEXPR }, { CT_IGNORED, CT_IGNORED }, { CT_IMPORT, CT_WORD }, { CT_INCDEC_AFTER, CT_DEREF }, { CT_IN, CT_TYPE }, { CT_IN, CT_WORD }, { CT_LABEL_COLON, CT_CS_PROPERTY }, { CT_LABEL_COLON, CT_FUNC_CALL }, { CT_LABEL_COLON, CT_NEW }, { CT_LABEL_COLON, CT_PAREN_OPEN }, { CT_LABEL_COLON, CT_RETURN }, { CT_LABEL_COLON, CT_STRING }, { CT_LABEL_COLON, CT_TYPE }, { CT_LABEL_COLON, CT_WORD }, { CT_LOCK, CT_PAREN_OPEN }, { CT_NAMESPACE, CT_BRACE_OPEN }, { CT_NAMESPACE, CT_TYPE }, { CT_NAMESPACE, CT_WORD }, { CT_NATIVE, CT_TAG }, { CT_NUMBER, CT_CHAR }, { CT_NUMBER, CT_COLON }, { CT_NUMBER, CT_ELLIPSIS }, { CT_NUMBER, CT_OC_MSG_NAME }, { CT_NUMBER, CT_PAREN_OPEN }, { CT_NUMBER, CT_WORD }, { CT_NUMBER_FP, CT_NUMBER }, { CT_NUMBER_FP, CT_OC_MSG_NAME }, { CT_NUMBER_FP, CT_WORD }, { CT_OC_CLASS, CT_CLASS_COLON }, { CT_OC_CLASS, CT_PAREN_OPEN }, { CT_OC_DYNAMIC, CT_WORD }, { CT_OC_IMPL, CT_OC_CLASS }, { CT_OC_INTF, CT_OC_CLASS }, { CT_OC_MSG_DECL, CT_BRACE_OPEN }, { CT_OC_PROTOCOL, CT_OC_CLASS }, { CT_PACKAGE, CT_WORD }, { CT_PAREN_CLOSE, CT_ASM_COLON }, { CT_PAREN_CLOSE, CT_COLON }, { CT_PAREN_CLOSE, CT_COND_COLON }, { CT_PAREN_CLOSE, CT_CS_PROPERTY }, { CT_PAREN_CLOSE, CT_DEREF }, { CT_PAREN_CLOSE, CT_NOT }, { CT_PAREN_CLOSE, CT_NUMBER }, { CT_PAREN_CLOSE, CT_OC_MSG_NAME }, { CT_PAREN_CLOSE, CT_POS }, { CT_PAREN_CLOSE, CT_QUALIFIER }, { CT_PAREN_CLOSE, CT_TYPE }, { CT_PP_DEFINE, CT_MACRO }, { CT_PP_DEFINE, CT_MACRO_FUNC }, { CT_PP_DEFINE, CT_NUMBER }, { CT_PP_DEFINE, CT_PP_IGNORE }, { CT_PP_DEFINED, CT_TYPE }, { CT_PP_DEFINED, CT_WORD }, { CT_PP_ELSE, CT_FUNC_CALL }, { CT_PP_ELSE, CT_NOT }, { CT_PP_ELSE, CT_NUMBER }, { CT_PP_ELSE, CT_PAREN_OPEN }, { CT_PP_ELSE, CT_PP_DEFINED }, { CT_PP_ELSE, CT_WORD }, { CT_PP_EMIT, CT_MACRO }, { CT_PP_ENDIF, CT_WORD }, { CT_PP_ENDREGION, CT_PREPROC_BODY }, { CT_PP_IF, CT_CNG_HASINC }, { CT_PP_IF, CT_FUNC_CALL }, { CT_PP_IF, CT_NOT }, { CT_PP_IF, CT_NUMBER }, { CT_PP_IF, CT_PAREN_OPEN }, { CT_PP_IF, CT_PP_ASM }, { CT_PP_IF, CT_PP_DEFINE }, { CT_PP_IF, CT_PP_DEFINED }, { CT_PP_IF, CT_TYPE }, { CT_PP_IF, CT_WORD }, { CT_PP_INCLUDE, CT_STRING }, { CT_PP_INCLUDE, CT_WORD }, { CT_PP_OTHER, CT_PREPROC_BODY }, { CT_PP_PRAGMA, CT_PP_ENDASM }, { CT_PP_PRAGMA, CT_PP_ENDREGION }, { CT_PP_PRAGMA, CT_PP_REGION }, { CT_PP_PROPERTY, CT_WORD }, { CT_PP_REGION, CT_IGNORED }, { CT_PP_REGION, CT_PREPROC_BODY }, { CT_PP_UNDEF, CT_TYPE }, { CT_PP_UNDEF, CT_WORD }, { CT_Q_EMIT, CT_FUNC_CALL }, { CT_Q_FOREVER, CT_BRACE_OPEN }, { CT_QUESTION, CT_FUNC_CALL }, { CT_QUESTION, CT_PAREN_OPEN }, { CT_QUESTION, CT_STRING }, { CT_QUESTION, CT_WORD }, { CT_SBOOL, CT_TYPE }, { CT_SCOMPARE, CT_WORD }, { CT_SPAREN_CLOSE, CT_ATTRIBUTE }, { CT_SPAREN_CLOSE, CT_AUTORELEASEPOOL }, { CT_SPAREN_CLOSE, CT_BRACE_OPEN }, { CT_SPAREN_CLOSE, CT_FUNC_CALL }, { CT_SPAREN_CLOSE, CT_WORD }, { CT_SQL_ASSIGN, CT_FUNC_CALL }, { CT_SQL_ASSIGN, CT_WORD }, { CT_SQL_BEGIN, CT_SQL_WORD }, { CT_SQL_END, CT_SQL_WORD }, { CT_SQL_EXEC, CT_SQL_WORD }, { CT_SQL_WORD, CT_COLON }, { CT_SQL_WORD, CT_PAREN_OPEN }, { CT_SQL_WORD, CT_SQL_WORD }, { CT_SQUARE_CLOSE, CT_ATTRIBUTE }, { CT_SQUARE_CLOSE, CT_BRACE_OPEN }, { CT_SQUARE_CLOSE, CT_COLON }, { CT_SQUARE_CLOSE, CT_EXECUTION_CONTEXT }, { CT_SQUARE_CLOSE, CT_OC_MSG_NAME }, { CT_SQUARE_CLOSE, CT_STRING }, { CT_SQUARE_CLOSE, CT_WORD }, { CT_STATE, CT_TYPE }, { CT_STOCK, CT_QUALIFIER }, { CT_STOCK, CT_TAG }, { CT_STRING, CT_ATTRIBUTE }, { CT_STRING, CT_BRACE_OPEN }, { CT_STRING, CT_COLON }, { CT_STRING, CT_CONCAT }, { CT_STRING, CT_OC_MSG_NAME }, { CT_STRING, CT_PAREN_OPEN }, { CT_STRING, CT_STRING }, { CT_STRING, CT_STRUCT }, { CT_STRING, CT_TYPE }, { CT_STRING, CT_WORD }, { CT_STRUCT, CT_BRACE_OPEN }, { CT_STRUCT, CT_CLASS_COLON }, { CT_STRUCT, CT_MACRO_FUNC_CALL }, { CT_STRUCT, CT_TYPE }, { CT_STRUCT, CT_WORD }, { CT_TEMPLATE, CT_CLASS }, { CT_TEMPLATE, CT_TYPE }, { CT_THIS, CT_OC_MSG_NAME }, { CT_THIS, CT_TYPE }, { CT_TSQUARE, CT_BRACE_OPEN }, { CT_TSQUARE, CT_PAREN_OPEN }, { CT_TSQUARE, CT_WORD }, { CT_TYPEDEF, CT_ENUM }, { CT_TYPEDEF, CT_FUNC_TYPE }, { CT_TYPEDEF, CT_PAREN_OPEN }, { CT_TYPEDEF, CT_QUALIFIER }, { CT_TYPEDEF, CT_STRUCT }, { CT_TYPEDEF, CT_TYPE }, { CT_TYPEDEF, CT_TYPENAME }, { CT_TYPEDEF, CT_UNION }, { CT_TYPENAME, CT_ELLIPSIS }, { CT_TYPENAME, CT_WORD }, { CT_UNION, CT_BRACE_OPEN }, { CT_UNION, CT_TYPE }, { CT_UNION, CT_WORD }, { CT_USING, CT_NAMESPACE }, { CT_USING, CT_TYPE }, { CT_USING, CT_WORD }, { CT_USING_STMT, CT_PAREN_OPEN }, { CT_VOLATILE, CT_BRACE_OPEN }, { CT_WHERE_COLON, CT_CS_PROPERTY }, { CT_WHERE_COLON, CT_NEW }, { CT_WHERE_COLON, CT_TYPE }, { CT_WHERE_COLON, CT_WORD }, { CT_WHERE_SPEC, CT_WORD }, { CT_WORD, CT_ATTRIBUTE }, { CT_WORD, CT_BIT_COLON }, { CT_WORD, CT_BRACE_OPEN }, { CT_WORD, CT_CLASS_COLON }, { CT_WORD, CT_COLON }, { CT_WORD, CT_COMMENT_CPP }, { CT_WORD, CT_CONCAT }, { CT_WORD, CT_ELLIPSIS }, { CT_WORD, CT_IN }, { CT_WORD, CT_NEW }, { CT_WORD, CT_NOT }, { CT_WORD, CT_NUMBER }, { CT_WORD, CT_NUMBER_FP }, { CT_WORD, CT_OPERATOR }, { CT_WORD, CT_QUALIFIER }, { CT_WORD, CT_QUESTION }, { CT_WORD, CT_SCOMPARE }, { CT_WORD, CT_SQL_ASSIGN }, { CT_WORD, CT_STRING }, { CT_WORD, CT_STRUCT }, { CT_WORD, CT_TYPE }, { CT_WORD, CT_TYPE_CAST }, { CT_WORD, CT_TYPEDEF }, { CT_WORD, CT_WHERE_COLON }, { CT_WORD, CT_WHERE_SPEC }, { CT_WORD, CT_WORD }, }; /** * this table lists out all combos where a space should NOT be present * CT_UNKNOWN is a wildcard. * * TODO: some of these are no longer needed. */ const no_space_table_t no_space_table[] = { { CT_OC_AT, CT_UNKNOWN }, { CT_INCDEC_BEFORE, CT_WORD }, { CT_UNKNOWN, CT_INCDEC_AFTER }, { CT_UNKNOWN, CT_LABEL_COLON }, { CT_UNKNOWN, CT_ACCESS_COLON }, { CT_UNKNOWN, CT_SEMICOLON }, { CT_UNKNOWN, CT_D_TEMPLATE }, { CT_D_TEMPLATE, CT_UNKNOWN }, { CT_MACRO_FUNC, CT_FPAREN_OPEN }, { CT_PAREN_OPEN, CT_UNKNOWN }, { CT_UNKNOWN, CT_PAREN_CLOSE }, { CT_FPAREN_OPEN, CT_UNKNOWN }, { CT_UNKNOWN, CT_SPAREN_CLOSE }, { CT_SPAREN_OPEN, CT_UNKNOWN }, { CT_UNKNOWN, CT_FPAREN_CLOSE }, { CT_UNKNOWN, CT_COMMA }, { CT_POS, CT_UNKNOWN }, { CT_STAR, CT_UNKNOWN }, { CT_VBRACE_CLOSE, CT_UNKNOWN }, { CT_VBRACE_OPEN, CT_UNKNOWN }, { CT_UNKNOWN, CT_VBRACE_CLOSE }, { CT_UNKNOWN, CT_VBRACE_OPEN }, { CT_PREPROC, CT_UNKNOWN }, { CT_PREPROC_INDENT, CT_UNKNOWN }, { CT_NEG, CT_UNKNOWN }, { CT_UNKNOWN, CT_SQUARE_OPEN }, { CT_UNKNOWN, CT_SQUARE_CLOSE }, { CT_SQUARE_OPEN, CT_UNKNOWN }, { CT_PAREN_CLOSE, CT_WORD }, { CT_PAREN_CLOSE, CT_FUNC_DEF }, { CT_PAREN_CLOSE, CT_FUNC_CALL }, { CT_PAREN_CLOSE, CT_ADDR }, { CT_PAREN_CLOSE, CT_FPAREN_OPEN }, { CT_OC_SEL_NAME, CT_OC_SEL_NAME }, { CT_TYPENAME, CT_TYPE }, }; // *INDENT-ON* uncrustify-uncrustify-0.76.0/src/align.cpp000066400000000000000000000134461434072136500206320ustar00rootroot00000000000000/** * @file align.cpp * Does all the aligning stuff. * * @author Ben Gardner * @author Guy Maurel since version 0.62 for uncrustify4Qt * October 2015, 2016 * @license GPL v2+ */ #include "align.h" #include "align_asm_colon.h" #include "align_assign.h" #include "align_braced_init_list.h" #include "align_eigen_comma_init.h" #include "align_func_params.h" #include "align_func_proto.h" #include "align_init_brace.h" #include "align_left_shift.h" #include "align_oc_decl_colon.h" #include "align_oc_msg_colons.h" #include "align_oc_msg_spec.h" #include "align_preprocessor.h" #include "align_same_func_call_params.h" #include "align_stack.h" #include "align_struct_initializers.h" #include "align_trailing_comments.h" #include "align_typedefs.h" #include "align_var_def_brace.h" #include "log_rules.h" #include "quick_align_again.h" constexpr static auto LCURRENT = LALIGN; using namespace uncrustify; /* * Here are the items aligned: * * - enum value assignments * enum { * cat = 1, * fred = 2, * }; * * - struct/union variable & bit definitions * struct foo { * char cat; * int id : 5; * int name_len : 6; * int height : 12; * }; * * - variable definitions & assignments in normal code * const char *cat = "feline"; * int id = 4; * a = 5; * bat = 14; * * - simple array initializers * int a[] = { * 1, 2, 3, 4, 5, * 6, 7, 8, 9, 10 * }; * * - c99 array initializers * const char *name[] = { * [FRED] = "fred", * [JOE] = "joe", * [PETER] = "peter", * }; * struct foo b[] = { * { .id = 1, .name = "text 1" }, * { .id = 567, .name = "text 2" }, * }; * struct foo_t bars[] = * { * [0] = { .name = "bar", * .age = 21 }, * [1] = { .name = "barley", * .age = 55 }, * }; * * - compact array initializers * struct foo b[] = { * { 3, "dog" }, { 6, "spider" }, * { 8, "elephant" }, { 3, "cat" }, * }; * * - multiline array initializers (2nd line indented, not aligned) * struct foo b[] = { * { AD_NOT_ALLOWED, "Sorry, you failed to guess the password.", * "Try again?", "Yes", "No" }, * { AD_SW_ERROR, "A software error has occurred.", "Bye!", NULL, NULL }, * }; * * - Trailing comments * * - Back-slash newline groups * * - Function prototypes * int foo(); * void bar(); * * - Preprocessors * #define FOO_VAL 15 * #define MAX_TIMEOUT 60 * #define FOO(x) ((x) * 65) * * - typedefs * typedef uint8_t BYTE; * typedef int32_t INT32; * typedef uint32_t UINT32; */ void align_all() { LOG_FUNC_ENTRY(); log_rule_B("align_typedef_span"); if (options::align_typedef_span() > 0) { align_typedefs(options::align_typedef_span()); } log_rule_B("align_left_shift"); if (options::align_left_shift()) { align_left_shift(); } log_rule_B("align_eigen_comma_init"); if (options::align_eigen_comma_init()) { align_eigen_comma_init(); } log_rule_B("align_oc_msg_colon_span"); if (options::align_oc_msg_colon_span() > 0) { align_oc_msg_colons(); } // Align variable definitions log_rule_B("align_var_def_span"); log_rule_B("align_var_struct_span"); log_rule_B("align_var_class_span"); if ( (options::align_var_def_span() > 0) || (options::align_var_struct_span() > 0) || (options::align_var_class_span() > 0)) { align_var_def_brace(Chunk::GetHead(), options::align_var_def_span(), nullptr); } // Align assignments log_rule_B("align_enum_equ_span"); log_rule_B("align_assign_span"); log_rule_B("align_assign_thresh"); if ( (options::align_enum_equ_span() > 0) || (options::align_assign_span() > 0)) { align_assign(Chunk::GetHead(), options::align_assign_span(), options::align_assign_thresh(), nullptr); } if ( (options::align_braced_init_list_span() > 0) // Issue #750 || (options::align_braced_init_list_thresh() > 0)) { align_braced_init_list(Chunk::GetHead(), options::align_braced_init_list_span(), options::align_braced_init_list_thresh(), nullptr); } // Align structure initializers log_rule_B("align_struct_init_span"); if (options::align_struct_init_span() > 0) { align_struct_initializers(); } // Align function prototypes log_rule_B("align_func_proto_span"); log_rule_B("align_mix_var_proto"); if ( (options::align_func_proto_span() > 0) && !options::align_mix_var_proto()) { align_func_proto(options::align_func_proto_span()); } // Align function prototypes log_rule_B("align_oc_msg_spec_span"); if (options::align_oc_msg_spec_span() > 0) { align_oc_msg_spec(options::align_oc_msg_spec_span()); } // Align OC colons log_rule_B("align_oc_decl_colon"); if (options::align_oc_decl_colon()) { align_oc_decl_colon(); } log_rule_B("align_asm_colon"); if (options::align_asm_colon()) { align_asm_colon(); } // Align variable definitions in function prototypes log_rule_B("align_func_params"); log_rule_B("align_func_params_span"); if ( options::align_func_params() || options::align_func_params_span() > 0) { align_func_params(); } log_rule_B("align_same_func_call_params"); if (options::align_same_func_call_params()) { align_same_func_call_params(); } // Just in case something was aligned out of order... do it again quick_align_again(); } // align_all uncrustify-uncrustify-0.76.0/src/align.h000066400000000000000000000003461434072136500202720ustar00rootroot00000000000000/** * @file align.h * prototypes for align.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_H_INCLUDED #define ALIGN_H_INCLUDED #include "uncrustify_types.h" void align_all(); #endif /* ALIGN_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_add.cpp000066400000000000000000000025621434072136500214370ustar00rootroot00000000000000/** * @file align_add.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_add.h" #include "uncrustify.h" void align_add(ChunkStack &cs, Chunk *pc, size_t &max_col) { LOG_FUNC_ENTRY(); size_t min_col; Chunk *prev = Chunk::NullChunkPtr; if (pc != nullptr) { prev = pc->GetPrev(); } if ( prev->IsNullChunk() || prev->IsNewline()) { min_col = 1; LOG_FMT(LALADD, "%s(%d): pc orig line=%zu, pc->col=%zu max_col=%zu min_col=%zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetColumn(), max_col, min_col); } else { if (prev->Is(CT_COMMENT_MULTI)) { min_col = prev->GetOrigColEnd() + 1; } else { min_col = prev->GetColumn() + prev->Len() + 1; } LOG_FMT(LALADD, "%s(%d): pc orig line=%zu, pc->col=%zu max_col=%zu min_col=%zu multi:%s prev->col=%zu prev->Len()=%zu %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetColumn(), max_col, min_col, (prev->Is(CT_COMMENT_MULTI)) ? "Y" : "N", (prev->Is(CT_COMMENT_MULTI)) ? prev->GetOrigColEnd() : (UINT32)prev->GetColumn(), prev->Len(), get_token_name(prev->GetType())); } if (cs.Empty()) { max_col = 0; } cs.Push_Back(pc); if (min_col > max_col) { max_col = min_col; } } // align_add uncrustify-uncrustify-0.76.0/src/align_add.h000066400000000000000000000005021434072136500210740ustar00rootroot00000000000000/** * @file align_add.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_ADD_H_INCLUDED #define ALIGN_ADD_H_INCLUDED #include "chunk.h" #include "ChunkStack.h" void align_add(ChunkStack &cs, Chunk *pc, size_t &max_col); #endif /* ALIGN_ADD_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_asm_colon.cpp000066400000000000000000000022301434072136500226510ustar00rootroot00000000000000/** * @file align_asm_colon.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_asm_colon.h" #include "align_stack.h" #include "chunk.h" void align_asm_colon() { LOG_FUNC_ENTRY(); bool did_nl; AlignStack cas; // for the colons cas.Start(4); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { if (pc->IsNot(CT_ASM_COLON)) { pc = pc->GetNext(); continue; } cas.Reset(); pc = pc->GetNextNcNnl(E_Scope::PREPROC); size_t level = pc->IsNotNullChunk() ? pc->GetLevel() : 0; did_nl = true; while ( pc->IsNotNullChunk() && pc->GetLevel() >= level) { if (pc->IsNewline()) { cas.NewLines(pc->GetNlCount()); did_nl = true; } else if (pc->Is(CT_ASM_COLON)) { cas.Flush(); did_nl = true; } else if (did_nl) { did_nl = false; cas.Add(pc); } pc = pc->GetNextNc(E_Scope::PREPROC); } cas.End(); } } // align_asm_colon uncrustify-uncrustify-0.76.0/src/align_asm_colon.h000066400000000000000000000006211434072136500223200ustar00rootroot00000000000000/** * @file align_asm_colon.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_ASM_COLON_H_INCLUDED #define ALIGN_ASM_COLON_H_INCLUDED /** * Aligns asm declarations on the colon * asm volatile ( * "xxx" * : "x"(h), * "y"(l), * : "z"(h) * ); */ void align_asm_colon(); #endif /* ALIGN_ASM_COLON_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_assign.cpp000066400000000000000000000230031434072136500221640ustar00rootroot00000000000000/** * @file align_assign.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_assign.h" #include "align_stack.h" #include "log_rules.h" constexpr static auto LCURRENT = LALASS; using namespace uncrustify; Chunk *align_assign(Chunk *first, size_t span, size_t thresh, size_t *p_nl_count) { LOG_FUNC_ENTRY(); if ( first == nullptr || first->IsNullChunk()) { // coveralls will complain here. There are no example for that. // see https://en.wikipedia.org/wiki/Robustness_principle return(nullptr); } size_t my_level = first->GetLevel(); char copy[1000]; LOG_FMT(LALASS, "%s(%d): [my_level is %zu]: start checking with '%s', on orig line %zu, span is %zu, thresh is %zu\n", __func__, __LINE__, my_level, first->ElidedText(copy), first->GetOrigLine(), span, thresh); // If we are aligning on a tabstop, we shouldn't right-align AlignStack as; // regular assigns as.Start(span, thresh); log_rule_B("align_on_tabstop"); as.m_right_align = !options::align_on_tabstop(); AlignStack vdas; // variable def assigns vdas.Start(span, thresh); vdas.m_right_align = as.m_right_align; std::deque fcnDefault(1); fcnDefault.back().Start(span, thresh); fcnDefault.back().m_right_align = as.m_right_align; AlignStack fcnProto; fcnProto.Start(span, thresh); fcnProto.m_right_align = as.m_right_align; size_t var_def_cnt = 0; size_t equ_count = 0; size_t nl_count = 0; size_t fcn_idx = 0; size_t tmp; Chunk *pc = first; Chunk *vdas_pc = nullptr; while (pc->IsNotNullChunk()) { LOG_FMT(LALASS, "%s(%d): orig line is %zu, check pc->Text() is '%s', type is %s, m_parentType is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->ElidedText(copy), get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); if (nl_count != 0) { if (vdas_pc != nullptr) { LOG_FMT(LALASS, "%s(%d): vdas.Add on '%s' on orig line %zu, orig col is %zu\n", __func__, __LINE__, vdas_pc->Text(), vdas_pc->GetOrigLine(), vdas_pc->GetOrigCol()); vdas.Add(vdas_pc); vdas_pc = nullptr; } if (p_nl_count != nullptr) { *p_nl_count += nl_count; } as.NewLines(nl_count); vdas.NewLines(nl_count); fcnProto.NewLines(nl_count); for (auto &fcn : fcnDefault) { fcn.NewLines(nl_count); } fcn_idx = 0; nl_count = 0; var_def_cnt = 0; equ_count = 0; } // Don't check inside SPAREN, PAREN or SQUARE groups if ( pc->Is(CT_SPAREN_OPEN) // || pc->Is(CT_FPAREN_OPEN) Issue #1340 || pc->Is(CT_SQUARE_OPEN) || pc->Is(CT_PAREN_OPEN)) { LOG_FMT(LALASS, "%s(%d): Don't check inside SPAREN, PAREN or SQUARE groups, type is %s\n", __func__, __LINE__, get_token_name(pc->GetType())); tmp = pc->GetOrigLine(); pc = pc->GetClosingParen(); if (pc->IsNotNullChunk()) { nl_count = pc->GetOrigLine() - tmp; } continue; } // Recurse if a brace set is found if ( ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_VBRACE_OPEN)) && !(pc->GetParentType() == CT_BRACED_INIT_LIST)) { size_t myspan; size_t mythresh; if (pc->GetParentType() == CT_ENUM) { log_rule_B("align_enum_equ_span"); myspan = options::align_enum_equ_span(); log_rule_B("align_enum_equ_thresh"); mythresh = options::align_enum_equ_thresh(); } else { log_rule_B("align_assign_span"); myspan = options::align_assign_span(); log_rule_B("align_assign_thresh"); mythresh = options::align_assign_thresh(); } pc = align_assign(pc->GetNext(), myspan, mythresh, &nl_count); continue; } // Done with this brace set? if ( ( pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_VBRACE_CLOSE)) && !(pc->GetParentType() == CT_BRACED_INIT_LIST)) { pc = pc->GetNext(); break; } if (pc->IsNewline()) { nl_count = pc->GetNlCount(); } else if ( pc->TestFlags(PCF_VAR_DEF) && !pc->TestFlags(PCF_IN_CONST_ARGS) // Issue #1717 && !pc->TestFlags(PCF_IN_FCN_DEF) // Issue #1717 && !pc->TestFlags(PCF_IN_FCN_CALL)) // Issue #1717 { // produces much more log output. Use it only debugging purpose //LOG_FMT(LALASS, "%s(%d): log_pcf_flags pc->GetFlags():\n ", __func__, __LINE__); //log_pcf_flags(LALASS, pc->GetFlags()); var_def_cnt++; } else if ( var_def_cnt > 1 && !options::align_assign_on_multi_var_defs()) { // we hit the second variable def and align was not requested - don't look for assigns, don't align LOG_FMT(LALASS, "%s(%d): multiple var defs found and alignment was not requested\n", __func__, __LINE__); vdas_pc = nullptr; } else if ( equ_count == 0 // indent only if first '=' in line && !pc->TestFlags(PCF_IN_TEMPLATE) // and it is not inside a template #999 && ( pc->Is(CT_ASSIGN) || pc->Is(CT_ASSIGN_DEFAULT_ARG) || pc->Is(CT_ASSIGN_FUNC_PROTO))) { if (pc->Is(CT_ASSIGN)) // Issue #2236 { equ_count++; } LOG_FMT(LALASS, "%s(%d): align_assign_decl_func() is %d\n", __func__, __LINE__, options::align_assign_decl_func()); // produces much more log output. Use it only debugging purpose //LOG_FMT(LALASS, "%s(%d): log_pcf_flags pc->GetFlags(): ", __func__, __LINE__); //log_pcf_flags(LALASS, pc->GetFlags()); log_rule_B("align_assign_decl_func"); if ( options::align_assign_decl_func() == 0 // Align with other assignments (default) && ( pc->Is(CT_ASSIGN_DEFAULT_ARG) // Foo( int bar = 777 ); || pc->Is(CT_ASSIGN_FUNC_PROTO))) // Foo( const Foo & ) = delete; { LOG_FMT(LALASS, "%s(%d): fcnDefault[%zu].Add on '%s' on orig line %zu, orig col is %zu\n", __func__, __LINE__, fcn_idx, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); if (++fcn_idx == fcnDefault.size()) { fcnDefault.emplace_back(); fcnDefault.back().Start(span, thresh); fcnDefault.back().m_right_align = as.m_right_align; } fcnDefault[fcn_idx].Add(pc); } else if (options::align_assign_decl_func() == 1) // Align with each other { log_rule_B("align_assign_decl_func"); if (pc->Is(CT_ASSIGN_DEFAULT_ARG)) // Foo( int bar = 777 ); { LOG_FMT(LALASS, "%s(%d): default: fcnDefault[%zu].Add on '%s' on orig line %zu, orig col is %zu\n", __func__, __LINE__, fcn_idx, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); if (++fcn_idx == fcnDefault.size()) { fcnDefault.emplace_back(); fcnDefault.back().Start(span, thresh); fcnDefault.back().m_right_align = as.m_right_align; } fcnDefault[fcn_idx].Add(pc); } else if (pc->Is(CT_ASSIGN_FUNC_PROTO)) // Foo( const Foo & ) = delete; { LOG_FMT(LALASS, "%s(%d): proto: fcnProto.Add on '%s' on orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); fcnProto.Add(pc); } else if (pc->Is(CT_ASSIGN)) // Issue #2197 { vdas_pc = pc; } } else if ( options::align_assign_decl_func() == 2 // Don't align && ( pc->Is(CT_ASSIGN_DEFAULT_ARG) // Foo( int bar = 777 ); || pc->Is(CT_ASSIGN_FUNC_PROTO))) // Foo( const Foo & ) = delete; { log_rule_B("align_assign_decl_func"); LOG_FMT(LALASS, "%s(%d): Don't align\n", // Issue #2236 __func__, __LINE__); } else if (var_def_cnt != 0) { vdas_pc = pc; } else { if (pc->Is(CT_ASSIGN)) { LOG_FMT(LALASS, "%s(%d): as.Add on '%s' on orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); as.Add(pc); } } } pc = pc->GetNext(); } if (vdas_pc != nullptr) { LOG_FMT(LALASS, "%s(%d): vdas.Add on '%s' on orig line %zu, orig col is %zu\n", __func__, __LINE__, vdas_pc->Text(), vdas_pc->GetOrigLine(), vdas_pc->GetOrigCol()); vdas.Add(vdas_pc); vdas_pc = nullptr; } as.End(); vdas.End(); for (auto &fcn : fcnDefault) { fcn.End(); } fcnProto.End(); if (pc->IsNotNullChunk()) { LOG_FMT(LALASS, "%s(%d): done on '%s' on orig line %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); } else { LOG_FMT(LALASS, "%s(%d): done on NULL\n", __func__, __LINE__); } return(pc); } // align_assign uncrustify-uncrustify-0.76.0/src/align_assign.h000066400000000000000000000011501434072136500216300ustar00rootroot00000000000000/** * @file align_assign.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_ASSIGN_H_INCLUDED #define ALIGN_ASSIGN_H_INCLUDED #include "chunk.h" /** * Aligns all assignment operators on the same level as first, starting with * first. * For variable definitions, only consider the '=' for the first variable. * Otherwise, only look at the first '=' on the line. * * @param first chunk pointing to the first assignment */ Chunk *align_assign(Chunk *first, size_t span, size_t thresh, size_t *p_nl_count); #endif /* ALIGN_ASSIGN_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_braced_init_list.cpp000066400000000000000000000120541434072136500242020ustar00rootroot00000000000000/** * @file align_braced_init_list.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "align_braced_init_list.h" #include "align_stack.h" #include "log_rules.h" constexpr static auto LCURRENT = LALASS; using namespace uncrustify; Chunk *align_braced_init_list(Chunk *first, size_t span, size_t thresh, size_t *p_nl_count) { LOG_FUNC_ENTRY(); if ( first == nullptr || first->IsNullChunk()) { // coveralls will complain here. There are no example for that. // see https://en.wikipedia.org/wiki/Robustness_principle return(nullptr); } size_t my_level = first->GetLevel(); char copy[1000]; LOG_FMT(LALASS, "%s(%d): [my_level is %zu]: start checking with '%s', on orig line %zu, span is %zu, thresh is %zu\n", __func__, __LINE__, my_level, first->ElidedText(copy), first->GetOrigLine(), span, thresh); // If we are aligning on a tabstop, we shouldn't right-align AlignStack vdas; // variable def assigns vdas.Start(span, thresh); vdas.m_right_align = !options::align_on_tabstop(); size_t var_def_cnt = 0; size_t equ_count = 0; size_t tmp; Chunk *pc = first; while ( pc != nullptr && pc->IsNotNullChunk()) { LOG_FMT(LALASS, "%s(%d): orig line is %zu, check pc->Text() is '%s', type is %s, parent type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->ElidedText(copy), get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); // Don't check inside SPAREN, PAREN or SQUARE groups if ( pc->Is(CT_SPAREN_OPEN) || pc->Is(CT_SQUARE_OPEN) || pc->Is(CT_PAREN_OPEN)) { LOG_FMT(LALASS, "%s(%d)OK: Don't check inside SPAREN, PAREN or SQUARE groups, type is %s\n", __func__, __LINE__, get_token_name(pc->GetType())); tmp = pc->GetOrigLine(); pc = pc->GetClosingParen(); if (pc->IsNotNullChunk()) { vdas.NewLines(pc->GetOrigLine() - tmp); } continue; } // Recurse if a brace set is found if ( pc->Is(CT_BRACE_OPEN) && !(pc->GetParentType() == CT_BRACED_INIT_LIST)) { size_t myspan; size_t mythresh; size_t sub_nl_count = 0; log_rule_B("align_braced_init_list_span"); myspan = options::align_braced_init_list_span(); log_rule_B("align_braced_init_list_thresh"); mythresh = options::align_braced_init_list_thresh(); pc = align_braced_init_list(pc->GetNextNcNnl(), myspan, mythresh, &sub_nl_count); if (sub_nl_count > 0) { vdas.NewLines(sub_nl_count); if (p_nl_count != nullptr) { *p_nl_count += sub_nl_count; } } continue; } // Done with this brace set? if ( ( pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_VBRACE_CLOSE)) && !(pc->GetParentType() == CT_BRACED_INIT_LIST)) { pc = pc->GetNext(); break; } if (pc->IsNewline()) { vdas.NewLines(pc->GetNlCount()); if (p_nl_count != nullptr) { *p_nl_count += pc->GetNlCount(); } var_def_cnt = 0; equ_count = 0; } else if ( pc->TestFlags(PCF_VAR_DEF) && !pc->TestFlags(PCF_IN_CONST_ARGS) // Issue #1717 && !pc->TestFlags(PCF_IN_FCN_DEF) // Issue #1717 && !pc->TestFlags(PCF_IN_FCN_CALL)) // Issue #1717 { // produces much more log output. Use it only debugging purpose //LOG_FMT(LALASS, "%s(%d): log_pcf_flags pc->GetFlags():\n ", __func__, __LINE__); //log_pcf_flags(LALASS, pc->GetFlags()); var_def_cnt++; } else if (var_def_cnt > 1) { // we hit the second variable def - don't look, don't align vdas.Reset(); } else if ( equ_count == 0 && !pc->TestFlags(PCF_IN_TEMPLATE) && pc->Is(CT_BRACE_OPEN) && (pc->GetParentType() == CT_BRACED_INIT_LIST)) { equ_count++; LOG_FMT(LALASS, "%s(%d)OK: align_braced_init_list_span() is %d\n", __func__, __LINE__, options::align_braced_init_list_span()); // produces much more log output. Use it only debugging purpose //LOG_FMT(LALASS, "%s(%d): log_pcf_flags pc->GetFlags(): ", __func__, __LINE__); //log_pcf_flags(LALASS, pc->GetFlags()); if (var_def_cnt != 0) { LOG_FMT(LALASS, "%s(%d)OK: vdas.Add on '%s' on orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); vdas.Add(pc); } } pc = pc->GetNext(); } vdas.End(); if ( pc != nullptr && pc->IsNotNullChunk()) { LOG_FMT(LALASS, "%s(%d): done on '%s' on orig line %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); } else { LOG_FMT(LALASS, "%s(%d): done on NULL\n", __func__, __LINE__); } return(pc); } // align_braced_init_list uncrustify-uncrustify-0.76.0/src/align_braced_init_list.h000066400000000000000000000007651434072136500236550ustar00rootroot00000000000000/** * @file align_braced_init_list.h * * @author Guy Maurel * @license GPL v2+ */ #ifndef ALIGN_BRACED_INIT_LIST_H_INCLUDED #define ALIGN_BRACED_INIT_LIST_H_INCLUDED #include "chunk.h" /** * Aligns all braced init list operators on the same level as first, starting with * first. * * @param first chunk pointing to the first braced init list */ Chunk *align_braced_init_list(Chunk *first, size_t span, size_t thresh, size_t *p_nl_count); #endif /* ALIGN_BRACED_INIT_LIST_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_eigen_comma_init.cpp000066400000000000000000000054151434072136500241750ustar00rootroot00000000000000/** * @file align_eigen_comma_init.cpp * * @author Matthew Woehlke * copied/adapted from align_left_shift.cpp * @author Guy Maurel * @author Ben Gardner * @license GPL v2+ */ #include "align_eigen_comma_init.h" #include "align_stack.h" #include "indent.h" #include "log_rules.h" constexpr static auto LCURRENT = LALIGN; using namespace uncrustify; void align_eigen_comma_init() { LOG_FUNC_ENTRY(); Chunk *start = Chunk::NullChunkPtr; AlignStack as; as.Start(255); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { LOG_CHUNK(LTOK, pc); if ( start->IsNotNullChunk() && ((pc->GetFlags() & PCF_IN_PREPROC) != (start->GetFlags() & PCF_IN_PREPROC))) { // a change in preproc status restarts the aligning as.Flush(); start = Chunk::NullChunkPtr; } else if (pc->IsNewline()) { as.NewLines(pc->GetNlCount()); } else if ( start->IsNotNullChunk() && pc->GetLevel() < start->GetLevel()) { // A drop in level restarts the aligning as.Flush(); start = Chunk::NullChunkPtr; } else if ( start->IsNotNullChunk() && pc->GetLevel() > start->GetLevel()) { // Ignore any deeper levels when aligning } else if (pc->Is(CT_SEMICOLON)) { // A semicolon at the same level flushes as.Flush(); start = Chunk::NullChunkPtr; } else if ( !pc->TestFlags(PCF_IN_ENUM) && !pc->TestFlags(PCF_IN_TYPEDEF) && pc->IsString("<<")) { if (pc->GetParentType() == CT_OPERATOR) { // Ignore operator<< } else { /* * check if the first one is actually on a blank line and then * indent it. Eg: * * cout * << "something"; */ Chunk *prev = pc->GetPrev(); if ( prev->IsNotNullChunk() && prev->IsNewline()) { log_rule_B("indent_columns"); indent_to_column(pc, pc->GetColumnIndent() + options::indent_columns()); pc->SetColumnIndent(pc->GetColumn()); pc->SetFlagBits(PCF_DONT_INDENT); } // Restart alignment as.Flush(); as.Add(pc->GetNext()); start = pc; } } else if (!as.m_aligned.Empty()) { Chunk *prev = pc->GetPrev(); if ( prev->IsNewline() && pc->GetPrevNcNnl()->Is(CT_COMMA)) { log_rule_B("align_eigen_comma_init"); as.Add(pc); } } pc = pc->GetNext(); } as.End(); } // align_left_shift uncrustify-uncrustify-0.76.0/src/align_eigen_comma_init.h000066400000000000000000000005051434072136500236350ustar00rootroot00000000000000/** * @file align_left_shift.h * * @author Matthew Woehlke * @license GPL v2+ */ #ifndef ALIGN_EIGEN_COMMA_INIT_H_INCLUDED #define ALIGN_EIGEN_COMMA_INIT_H_INCLUDED //! Align comma-separated expressions following left shift operator '<<' void align_eigen_comma_init(); #endif /* ALIGN_EIGEN_COMMA_INIT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_func_params.cpp000066400000000000000000000124471434072136500232100ustar00rootroot00000000000000/** * @file align_func_params.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_func_params.h" #include "align_stack.h" #include "log_rules.h" #include // to get max constexpr static auto LCURRENT = LALIGN; using namespace uncrustify; Chunk *align_func_param(Chunk *start) { LOG_FUNC_ENTRY(); LOG_FMT(LAS, "AlignStack::%s(%d): Candidate is '%s': orig line is %zu, column is %zu, type is %s, level is %zu\n", __func__, __LINE__, start->Text(), start->GetOrigLine(), start->GetColumn(), get_token_name(start->GetType()), start->GetLevel()); // Defaults, if the align_func_params = true size_t myspan = 2; size_t mythresh = 0; size_t mygap = 0; // Override, if the align_func_params_span > 0 log_rule_B("align_func_params_span"); if (options::align_func_params_span() > 0) { myspan = options::align_func_params_span(); log_rule_B("align_func_params_thresh"); mythresh = options::align_func_params_thresh(); log_rule_B("align_func_params_gap"); mygap = options::align_func_params_gap(); } const size_t HOW_MANY_AS = 16; // Issue #2921 AlignStack many_as[HOW_MANY_AS + 1]; size_t max_level_is = 0; log_rule_B("align_var_def_star_style"); log_rule_B("align_var_def_amp_style"); for (size_t idx = 0; idx <= HOW_MANY_AS; idx++) { many_as[idx].Start(myspan, mythresh); many_as[idx].m_gap = mygap; many_as[idx].m_star_style = static_cast(options::align_var_def_star_style()); many_as[idx].m_amp_style = static_cast(options::align_var_def_amp_style()); } size_t comma_count = 0; size_t chunk_count = 0; Chunk *pc = start; while ((pc = pc->GetNext())->IsNotNullChunk()) { chunk_count++; LOG_CHUNK(LTOK, pc); if (pc->Is(CT_FUNC_VAR)) // Issue #2278 { // look after 'protect parenthesis' Chunk *after = pc->GetNextNc(); if (after->Is(CT_PAREN_CLOSE)) { Chunk *before = after->GetPrevType(CT_PAREN_OPEN, after->GetLevel()); if (before->IsNotNullChunk()) { // these are 'protect parenthesis' // change the types and the level before->SetType(CT_PPAREN_OPEN); after->SetType(CT_PPAREN_CLOSE); pc->SetLevel(before->GetLevel()); Chunk *tmp = pc->GetPrevNc(); if (tmp->Is(CT_PTR_TYPE)) { tmp->SetLevel(before->GetLevel()); } } } } if (pc->IsNewline()) { comma_count = 0; chunk_count = 0; many_as[pc->GetLevel()].NewLines(pc->GetNlCount()); } else if (pc->GetLevel() <= start->GetLevel()) { break; } else if (pc->TestFlags(PCF_VAR_DEF)) { if (chunk_count > 1) { if (pc->GetLevel() > HOW_MANY_AS) { fprintf(stderr, "%s(%d): Not enough memory for Stack\n", __func__, __LINE__); fprintf(stderr, "%s(%d): the current maximum is %zu\n", __func__, __LINE__, HOW_MANY_AS); log_flush(true); exit(EX_SOFTWARE); } max_level_is = max(max_level_is, pc->GetLevel()); many_as[pc->GetLevel()].Add(pc); } } else if (comma_count > 0) { if (!pc->IsComment()) { comma_count = 2; break; } } else if (pc->Is(CT_COMMA)) { if (pc->TestFlags(PCF_IN_TEMPLATE)) // Issue #2757 { LOG_FMT(LFLPAREN, "%s(%d): comma is in template\n", __func__, __LINE__); } else { Chunk *tmp_prev = pc->GetPrevNc(); if (!tmp_prev->IsNewline()) // don't count leading commas { comma_count++; LOG_FMT(LFLPAREN, "%s(%d): comma_count is %zu\n", __func__, __LINE__, comma_count); } } } } if (comma_count <= 1) { for (size_t idx = 1; idx <= max_level_is; idx++) { many_as[idx].End(); } } return(pc); } // align_func_param void align_func_params() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); while ((pc = pc->GetNext())->IsNotNullChunk()) { LOG_FMT(LFLPAREN, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s, parent type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); if ( pc->IsNot(CT_FPAREN_OPEN) || ( pc->GetParentType() != CT_FUNC_PROTO && pc->GetParentType() != CT_FUNC_DEF && pc->GetParentType() != CT_FUNC_CLASS_PROTO && pc->GetParentType() != CT_FUNC_CLASS_DEF && pc->GetParentType() != CT_TYPEDEF)) { continue; } // We are on a open parenthesis of a prototype pc = align_func_param(pc); } } // void align_func_params uncrustify-uncrustify-0.76.0/src/align_func_params.h000066400000000000000000000005201434072136500226420ustar00rootroot00000000000000/** * @file align_func_params.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_FUNC_PARAMS_H_INCLUDED #define ALIGN_FUNC_PARAMS_H_INCLUDED #include "chunk.h" void align_func_params(); Chunk *align_func_param(Chunk *start); #endif /* ALIGN_FUNC_PARAMS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_func_proto.cpp000066400000000000000000000166001434072136500230630ustar00rootroot00000000000000/** * @file align_func_proto.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_func_proto.h" #include "align_stack.h" #include "align_tools.h" #include "log_rules.h" #include // to get max constexpr static auto LCURRENT = LALPROTO; using namespace uncrustify; void align_func_proto(size_t span) { LOG_FUNC_ENTRY(); size_t myspan = span; size_t mythresh = 0; log_rule_B("align_func_proto_gap"); size_t mygap = options::align_func_proto_gap(); log_rule_B("align_func_proto_thresh"); mythresh = options::align_func_proto_thresh(); // Issue #2771 // we align token-1 and token-2 if: // token-1->GetLevel() == token-2->GetLevel() // and // token-1->GetBraceLevel() == token-2->GetBraceLevel() // we don't check if token-1 and token-2 are in the same block log_rule_B("align_func_proto_star_style"); size_t mystar_style = options::align_func_proto_star_style(); log_rule_B("align_func_proto_amp_style"); size_t myamp_style = options::align_func_proto_amp_style(); size_t num_of_column = 1; size_t num_of_row = 1; AlignStack *stack_init_value = nullptr; // Issue #2984 vector > many_as; // Issue #2771 vector > many_as_brace; // init the vector ... many_as.resize(num_of_column, vector(num_of_row, stack_init_value)); many_as_brace.resize(num_of_column, vector(num_of_row, stack_init_value)); log_rule_B("align_single_line_brace_gap"); size_t mybr_gap = options::align_single_line_brace_gap(); bool look_bro = false; Chunk *toadd; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { char copy[1000]; LOG_FMT(LAS, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s, level is %zu, brace level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy), get_token_name(pc->GetType()), pc->GetLevel(), pc->GetBraceLevel()); // make the vector larger if necessary if ( pc->GetLevel() >= num_of_column // Issue #2960 || pc->GetBraceLevel() >= num_of_row) { num_of_column = pc->GetLevel() + 1; num_of_row = pc->GetBraceLevel() + 1; many_as.resize(num_of_column); many_as_brace.resize(num_of_column); for (size_t i = 0; i < num_of_column; ++i) { many_as[i].resize(num_of_row); many_as_brace[i].resize(num_of_row); } } if ( pc->IsNewline() && !pc->TestFlags(PCF_IN_FCN_CALL)) // Issue #2831 { look_bro = false; AlignStack *stack_at_l_bl = many_as.at(pc->GetLevel()).at(pc->GetBraceLevel()); if (stack_at_l_bl == nullptr) { // get a Stack stack_at_l_bl = new AlignStack(); // start it stack_at_l_bl->Start(myspan, mythresh); stack_at_l_bl->m_gap = mygap; stack_at_l_bl->m_star_style = static_cast(mystar_style); stack_at_l_bl->m_amp_style = static_cast(myamp_style); // store many_as.at(pc->GetLevel()).at(pc->GetBraceLevel()) = stack_at_l_bl; } stack_at_l_bl->Debug(); for (size_t idx = 0; idx < num_of_column; idx++) { for (size_t idx_brace = 0; idx_brace < num_of_row; idx_brace++) { stack_at_l_bl = many_as.at(idx).at(idx_brace); if (stack_at_l_bl != nullptr) { stack_at_l_bl->NewLines(pc->GetNlCount()); } } } AlignStack *stack_at_l_bl_brace = many_as_brace.at(pc->GetLevel()).at(pc->GetBraceLevel()); if (stack_at_l_bl_brace == nullptr) { // get a Stack stack_at_l_bl_brace = new AlignStack(); // start it stack_at_l_bl_brace->Start(myspan, mythresh); stack_at_l_bl_brace->m_gap = mybr_gap; // store many_as_brace.at(pc->GetLevel()).at(pc->GetBraceLevel()) = stack_at_l_bl_brace; } stack_at_l_bl_brace->Debug(); stack_at_l_bl_brace->NewLines(pc->GetNlCount()); } else if ( pc->Is(CT_FUNC_PROTO) || ( pc->Is(CT_FUNC_DEF) && options::align_single_line_func())) { log_rule_B("align_single_line_func"); log_rule_B("align_on_operator"); if ( pc->GetParentType() == CT_OPERATOR && options::align_on_operator()) { toadd = pc->GetPrevNcNnl(); } else { toadd = pc; } Chunk *tmp = step_back_over_member(toadd); LOG_FMT(LAS, "%s(%d): tmp->Text() is '%s', orig line is %zu, orig col is %zu, level is %zu, brace level is %zu\n", __func__, __LINE__, tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->GetLevel(), tmp->GetBraceLevel()); // test the Stack AlignStack *stack_at_l_bl = many_as.at(pc->GetLevel()).at(pc->GetBraceLevel()); if (stack_at_l_bl == nullptr) { // get a Stack stack_at_l_bl = new AlignStack(); // start it stack_at_l_bl->Start(myspan, mythresh); stack_at_l_bl->m_gap = mygap; stack_at_l_bl->m_star_style = static_cast(mystar_style); stack_at_l_bl->m_amp_style = static_cast(myamp_style); // store many_as.at(pc->GetLevel()).at(pc->GetBraceLevel()) = stack_at_l_bl; } stack_at_l_bl->Add(tmp); log_rule_B("align_single_line_brace"); look_bro = (pc->Is(CT_FUNC_DEF)) && options::align_single_line_brace(); } else if ( look_bro && pc->Is(CT_BRACE_OPEN) && pc->TestFlags(PCF_ONE_LINER)) { AlignStack *stack_at_l_bl_brace = many_as_brace.at(pc->GetLevel()).at(pc->GetBraceLevel()); if (stack_at_l_bl_brace == nullptr) { stack_at_l_bl_brace = new AlignStack(); stack_at_l_bl_brace->Start(myspan, mythresh); stack_at_l_bl_brace->m_gap = mybr_gap; many_as_brace.at(pc->GetLevel()).at(pc->GetBraceLevel()) = stack_at_l_bl_brace; } stack_at_l_bl_brace->Debug(); stack_at_l_bl_brace->Add(pc); look_bro = false; } } LOG_FMT(LAS, "%s(%d): as\n", __func__, __LINE__); // purge for (size_t idx = 0; idx < num_of_column; idx++) { for (size_t idx_brace = 0; idx_brace < num_of_row; idx_brace++) { AlignStack *stack_at_l_bl = many_as.at(idx).at(idx_brace); if (stack_at_l_bl != nullptr) { stack_at_l_bl->End(); delete stack_at_l_bl; stack_at_l_bl = nullptr; } AlignStack *stack_at_l_bl_brace = many_as_brace.at(idx).at(idx_brace); if (stack_at_l_bl_brace != nullptr) { stack_at_l_bl_brace->End(); delete stack_at_l_bl_brace; stack_at_l_bl_brace = nullptr; } } } } // align_func_proto uncrustify-uncrustify-0.76.0/src/align_func_proto.h000066400000000000000000000005361434072136500225310ustar00rootroot00000000000000/** * @file align_func_proto.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_FUNC_PROTO_H_INCLUDED #define ALIGN_FUNC_PROTO_H_INCLUDED #include "chunk.h" //! Aligns all function prototypes in the file. void align_func_proto(size_t span); #endif /* ALIGN_FUNC_PROTO_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_init_brace.cpp000066400000000000000000000144531434072136500230100ustar00rootroot00000000000000/** * @file align_init_brace.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_init_brace.h" #include "align_log_al.h" #include "align_tab_column.h" #include "align_tools.h" #include "indent.h" #include "log_rules.h" constexpr static auto LCURRENT = LALBR; using namespace uncrustify; void align_init_brace(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *num_token = nullptr; cpd.al_cnt = 0; cpd.al_c99_array = false; LOG_FMT(LALBR, "%s(%d): start @ orig line is %zu, orig col is %zu\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol()); Chunk *pc = start->GetNextNcNnl(); Chunk *pcSingle = scan_ib_line(pc); if ( pcSingle == nullptr || ( pcSingle->Is(CT_BRACE_CLOSE) && pcSingle->GetParentType() == CT_ASSIGN)) { // single line - nothing to do LOG_FMT(LALBR, "%s(%d): single line - nothing to do\n", __func__, __LINE__); return; } LOG_FMT(LALBR, "%s(%d): is not a single line\n", __func__, __LINE__); do { pc = scan_ib_line(pc); // debug dump the current frame LOG_FMT(LALBR, "%s(%d): debug dump after, orig line is %zu\n", __func__, __LINE__, pc->GetOrigLine()); align_log_al(LALBR, pc->GetOrigLine()); while (pc->IsNewline()) { pc = pc->GetNext(); } } while ( pc != nullptr && pc->IsNotNullChunk() && pc->GetLevel() > start->GetLevel()); // debug dump the current frame align_log_al(LALBR, start->GetOrigLine()); log_rule_B("align_on_tabstop"); if ( options::align_on_tabstop() && cpd.al_cnt >= 1 && (cpd.al[0].type == CT_ASSIGN)) { cpd.al[0].col = align_tab_column(cpd.al[0].col); } pc = start->GetNext(); size_t idx = 0; do { Chunk *tmp; if ( idx == 0 && ((tmp = skip_c99_array(pc)) != nullptr)) { pc = tmp; LOG_FMT(LALBR, " -%zu- skipped '[] =' to %s\n", pc->GetOrigLine(), get_token_name(pc->GetType())); continue; } Chunk *next = pc; if (idx < cpd.al_cnt) { LOG_FMT(LALBR, "%s(%d): (%zu) check %s vs %s -- ??\n", __func__, __LINE__, idx, get_token_name(pc->GetType()), get_token_name(cpd.al[idx].type)); if (pc->Is(cpd.al[idx].type)) { if ( idx == 0 && cpd.al_c99_array) { Chunk *prev = pc->GetPrev(); if (prev->IsNewline()) { pc->SetFlagBits(PCF_DONT_INDENT); } } LOG_FMT(LALBR, "%s(%d): cpd.al[%zu].col is %zu\n", __func__, __LINE__, idx, cpd.al[idx].col); LOG_FMT(LALBR, "%s(%d): (idx is %zu) check %s vs %s -- [%s] to col %zu\n", __func__, __LINE__, idx, get_token_name(pc->GetType()), get_token_name(cpd.al[idx].type), pc->Text(), cpd.al[idx].col); if (num_token != nullptr) { int col_diff = pc->GetColumn() - num_token->GetColumn(); reindent_line(num_token, cpd.al[idx].col - col_diff); //LOG_FMT(LSYS, "-= %zu =- NUM indent [%s] col=%d diff=%d\n", // num_token->GetOrigLine(), // num_token->Text(), cpd.al[idx - 1].col, col_diff); num_token->SetFlagBits(PCF_WAS_ALIGNED); num_token = nullptr; } // Comma's need to 'fall back' to the previous token if (pc->Is(CT_COMMA)) { next = pc->GetNext(); if (!next->IsNewline()) { //LOG_FMT(LSYS, "-= %zu =- indent [%s] col=%d len=%d\n", // next->GetOrigLine(), // next->Text(), cpd.al[idx].col, cpd.al[idx].len); log_rule_B("align_number_right"); if ( (idx < (cpd.al_cnt - 1)) && options::align_number_right() && ( next->Is(CT_NUMBER_FP) || next->Is(CT_NUMBER) || next->Is(CT_POS) || next->Is(CT_NEG))) { // Need to wait until the next match to indent numbers num_token = next; } else if (idx < (cpd.al_cnt - 1)) { LOG_FMT(LALBR, "%s(%d): idx is %zu, al_cnt is %zu, cpd.al[%zu].col is %zu, cpd.al[%zu].len is %zu\n", __func__, __LINE__, idx, cpd.al_cnt, idx, cpd.al[idx].col, idx, cpd.al[idx].len); reindent_line(next, cpd.al[idx].col + cpd.al[idx].len); next->SetFlagBits(PCF_WAS_ALIGNED); } } } else { // first item on the line LOG_FMT(LALBR, "%s(%d): idx is %zu, cpd.al[%zu].col is %zu\n", __func__, __LINE__, idx, idx, cpd.al[idx].col); reindent_line(pc, cpd.al[idx].col); pc->SetFlagBits(PCF_WAS_ALIGNED); // see if we need to right-align a number log_rule_B("align_number_right"); if ( (idx < (cpd.al_cnt - 1)) && options::align_number_right()) { next = pc->GetNext(); if ( !next->IsNewline() && ( next->Is(CT_NUMBER_FP) || next->Is(CT_NUMBER) || next->Is(CT_POS) || next->Is(CT_NEG))) { // Need to wait until the next match to indent numbers num_token = next; } } } idx++; } else { LOG_FMT(LALBR, "%s(%d): (%zu) check %s vs %s -- no match\n", __func__, __LINE__, idx, get_token_name(pc->GetType()), get_token_name(cpd.al[idx].type)); } } if ( pc->IsNewline() || next->IsNewline()) { idx = 0; } pc = pc->GetNext(); } while ( pc->IsNotNullChunk() && pc->GetLevel() > start->GetLevel()); } // align_init_brace uncrustify-uncrustify-0.76.0/src/align_init_brace.h000066400000000000000000000024121434072136500224450ustar00rootroot00000000000000/** * @file align_init_brace.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_INIT_BRACE_H_INCLUDED #define ALIGN_INIT_BRACE_H_INCLUDED #include "uncrustify_types.h" /** * Generically aligns on '=', '{', '(' and item after ',' * It scans the first line and picks up the location of those tags. * It then scans subsequent lines and adjusts the column. * Finally it does a second pass to align everything. * * Aligns all the '=' signs in structure assignments. * a = { * .a = 1; * .type = fast; * }; * * And aligns on '{', numbers, strings, words. * colors[] = { * {"red", {255, 0, 0}}, {"blue", { 0, 255, 0}}, * {"green", { 0, 0, 255}}, {"purple", {255, 255, 0}}, * }; * * For the C99 indexed array assignment, the leading []= is skipped (no aligning) * struct foo_t bars[] = * { * [0] = { .name = "bar", * .age = 21 }, * [1] = { .name = "barley", * .age = 55 }, * }; * * NOTE: this assumes that spacing is at the minimum correct spacing (ie force) * if it isn't, some extra spaces will be inserted. * * @param start Points to the open brace chunk */ void align_init_brace(Chunk *start); #endif /* ALIGN_INIT_BRACE_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_left_shift.cpp000066400000000000000000000070511434072136500230340ustar00rootroot00000000000000/** * @file align_left_shift.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_left_shift.h" #include "align_stack.h" #include "indent.h" #include "log_rules.h" constexpr static auto LCURRENT = LALIGN; using namespace uncrustify; void align_left_shift() { LOG_FUNC_ENTRY(); Chunk *start = Chunk::NullChunkPtr; AlignStack as; as.Start(255); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { if (pc->IsNewline()) { LOG_FMT(LALIGN, "%s(%d): orig line is %zu, \n", __func__, __LINE__, pc->GetOrigLine()); } else { char copy[1000]; LOG_FMT(LALIGN, "%s(%d): orig line is %zu, orig col is %zu, pc->Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy)); } if ( start->IsNotNullChunk() && ((pc->GetFlags() & PCF_IN_PREPROC) != (start->GetFlags() & PCF_IN_PREPROC))) { // a change in preproc status restarts the aligning as.Flush(); start = Chunk::NullChunkPtr; } else if (pc->IsNewline()) { as.NewLines(pc->GetNlCount()); } else if ( start->IsNotNullChunk() && pc->GetLevel() < start->GetLevel()) { // A drop in level restarts the aligning as.Flush(); start = Chunk::NullChunkPtr; } else if ( start->IsNotNullChunk() && pc->GetLevel() > start->GetLevel()) { // Ignore any deeper levels when aligning } else if (pc->Is(CT_SEMICOLON)) { // A semicolon at the same level flushes as.Flush(); start = Chunk::NullChunkPtr; } else if ( !pc->TestFlags(PCF_IN_ENUM) && !pc->TestFlags(PCF_IN_TYPEDEF) && pc->IsString("<<")) { if (pc->GetParentType() == CT_OPERATOR) { // Ignore operator<< } else if (as.m_aligned.Empty()) { /* * check if the first one is actually on a blank line and then * indent it. Eg: * * cout * << "something"; */ Chunk *prev = pc->GetPrev(); if ( prev->IsNotNullChunk() && prev->IsNewline()) { log_rule_B("indent_columns"); indent_to_column(pc, pc->GetColumnIndent() + options::indent_columns()); pc->SetColumnIndent(pc->GetColumn()); pc->SetFlagBits(PCF_DONT_INDENT); } // first one can be anywhere as.Add(pc); start = pc; } else if (pc->GetPrev()->IsNewline()) { // subsequent ones must be after a newline as.Add(pc); } } else if (!as.m_aligned.Empty()) { /* * check if the given statement is on a line of its own, immediately following << * and then it. Eg: * * cout << * "something"; */ Chunk *prev = pc->GetPrev(); if ( prev->IsNotNullChunk() && prev->IsNewline()) { log_rule_B("indent_columns"); indent_to_column(pc, pc->GetColumnIndent() + options::indent_columns()); pc->SetColumnIndent(pc->GetColumn()); pc->SetFlagBits(PCF_DONT_INDENT); } } pc = pc->GetNext(); } as.End(); } // align_left_shift uncrustify-uncrustify-0.76.0/src/align_left_shift.h000066400000000000000000000004761434072136500225050ustar00rootroot00000000000000/** * @file align_left_shift.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_LEFT_SHIFT_H_INCLUDED #define ALIGN_LEFT_SHIFT_H_INCLUDED //! Align left shift operators '<<' (CT_SHIFT) void align_left_shift(); #endif /* ALIGN_LEFT_SHIFT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_log_al.cpp000066400000000000000000000012761434072136500221450ustar00rootroot00000000000000/** * @file align_log_al.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_log_al.h" #include "uncrustify.h" void align_log_al(log_sev_t sev, size_t line) { if (log_sev_on(sev)) { log_fmt(sev, "%s(%d): line %zu, cpd.al_cnt is %zu\n", __func__, __LINE__, line, cpd.al_cnt); for (size_t idx = 0; idx < cpd.al_cnt; idx++) { log_fmt(sev, " cpd.al[%2.1zu].col is %2.1zu, cpd.al[%2.1zu].len is %zu, type is %s\n", idx, cpd.al[idx].col, idx, cpd.al[idx].len, get_token_name(cpd.al[idx].type)); } log_fmt(sev, "\n"); } } // align_log_al uncrustify-uncrustify-0.76.0/src/align_log_al.h000066400000000000000000000004641434072136500216100ustar00rootroot00000000000000/** * @file align_log_al.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_LOG_AL_H_INCLUDED #define ALIGN_LOG_AL_H_INCLUDED #include "uncrustify_types.h" void align_log_al(log_sev_t sev, size_t line); #endif /* ALIGN_LOG_AL_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_nl_cont.cpp000066400000000000000000000023661434072136500223450ustar00rootroot00000000000000/** * @file align_nl_cont.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_nl_cont.h" #include "align_add.h" #include "uncrustify.h" Chunk *align_nl_cont(Chunk *start) { LOG_FUNC_ENTRY(); LOG_FMT(LALNLC, "%s(%d): start on [%s] on line %zu\n", __func__, __LINE__, get_token_name(start->GetType()), start->GetOrigLine()); // Find the max column ChunkStack cs; size_t max_col = 0; Chunk *pc = start; while ( pc->IsNotNullChunk() && pc->IsNot(CT_NEWLINE) && pc->IsNot(CT_COMMENT_MULTI)) { if (pc->Is(CT_NL_CONT)) { align_add(cs, pc, max_col); } pc = pc->GetNext(); } // NL_CONT is always the last thing on a line Chunk *tmp; while ((tmp = cs.Pop_Back()) != nullptr) { tmp->SetFlagBits(PCF_WAS_ALIGNED); tmp->SetColumn(max_col); } return(pc); } // align_nl_cont void align_backslash_newline() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { if (pc->IsNot(CT_NL_CONT)) { pc = pc->GetNextType(CT_NL_CONT); continue; } pc = align_nl_cont(pc); } } // align_backslash_newline uncrustify-uncrustify-0.76.0/src/align_nl_cont.h000066400000000000000000000012731434072136500220060ustar00rootroot00000000000000/** * @file align_nl_cont.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_NL_COUNT_H_INCLUDED #define ALIGN_NL_COUNT_H_INCLUDED #include "uncrustify_types.h" #include "chunk.h" /** * For a series of lines ending in backslash-newline, align them. * The series ends when a newline or multi-line C comment is encountered. * * @param start Start point * * @return pointer the last item looked at (nullptr/newline/comment) */ Chunk *align_nl_cont(Chunk *start); /** * Aligns all backslash-newline combos in the file. * This should be done LAST. */ void align_backslash_newline(); #endif /* ALIGN_NL_COUNT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_oc_decl_colon.cpp000066400000000000000000000037601434072136500234720ustar00rootroot00000000000000/** * @file align_oc_decl_colon.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_oc_decl_colon.h" #include "align_stack.h" #include "chunk.h" using namespace uncrustify; void align_oc_decl_colon() { LOG_FUNC_ENTRY(); bool did_line; AlignStack cas; // for the colons AlignStack nas; // for the parameter label cas.Start(4); nas.Start(4); nas.m_right_align = !options::align_on_tabstop(); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { if (pc->IsNot(CT_OC_SCOPE)) { pc = pc->GetNext(); continue; } nas.Reset(); cas.Reset(); size_t level = pc->GetLevel(); pc = pc->GetNextNcNnl(E_Scope::PREPROC); did_line = false; while ( pc->IsNotNullChunk() && pc->GetLevel() >= level) { // The declaration ends with an open brace or semicolon if ( pc->Is(CT_BRACE_OPEN) || pc->IsSemicolon()) { break; } if (pc->IsNewline()) { nas.NewLines(pc->GetNlCount()); cas.NewLines(pc->GetNlCount()); did_line = false; } else if ( !did_line && pc->Is(CT_OC_COLON)) { cas.Add(pc); Chunk *tmp = pc->GetPrev(E_Scope::PREPROC); Chunk *tmp2 = tmp->GetPrevNcNnl(E_Scope::PREPROC); // Check for an un-labeled parameter if ( ( tmp->Is(CT_WORD) || tmp->Is(CT_TYPE) || tmp->Is(CT_OC_MSG_DECL) || tmp->Is(CT_OC_MSG_SPEC)) && ( tmp2->Is(CT_WORD) || tmp2->Is(CT_TYPE) || tmp2->Is(CT_PAREN_CLOSE))) { nas.Add(tmp); } did_line = true; } pc = pc->GetNext(E_Scope::PREPROC); } nas.End(); cas.End(); } } // align_oc_decl_colon uncrustify-uncrustify-0.76.0/src/align_oc_decl_colon.h000066400000000000000000000006441434072136500231350ustar00rootroot00000000000000/** * @file align_oc_decl_colon.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_OC_DECL_COLON_H_INCLUDED #define ALIGN_OC_DECL_COLON_H_INCLUDED /** * Aligns OC declarations on the colon * -(void) doSomething: (NSString*) param1 * with: (NSString*) param2 */ void align_oc_decl_colon(); #endif /* ALIGN_OC_DECL_COLON_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_oc_msg_colons.cpp000066400000000000000000000103401434072136500235240ustar00rootroot00000000000000/** * @file align_oc_msg_colons.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "align_oc_msg_colons.h" #include "align_stack.h" #include "log_rules.h" constexpr static auto LCURRENT = LOCMSG; using namespace uncrustify; void align_oc_msg_colon(Chunk *so) { LOG_FUNC_ENTRY(); AlignStack nas; // for the parameter tag nas.Start(1); nas.Reset(); log_rule_B("align_on_tabstop"); nas.m_right_align = !options::align_on_tabstop(); AlignStack cas; // for the colons log_rule_B("align_oc_msg_colon_span"); size_t span = options::align_oc_msg_colon_span(); cas.Start(span); size_t level = so->GetLevel(); Chunk *pc = so->GetNextNcNnl(E_Scope::PREPROC); bool did_line = false; bool has_colon = false; size_t lcnt = 0; // line count with no colon for span bool first_line = true; while ( pc->IsNotNullChunk() && pc->GetLevel() > level) { if (pc->GetLevel() > (level + 1)) { // do nothing } else if (pc->IsNewline()) { if (!has_colon) { ++lcnt; } did_line = false; log_rule_B("align_oc_msg_colon_xcode_like"); if ( options::align_oc_msg_colon_xcode_like() && first_line && !has_colon) { span = 0; } has_colon = !has_colon; first_line = false; } else if ( !did_line && (lcnt < span + 1) && pc->Is(CT_OC_COLON)) { has_colon = true; cas.Add(pc); Chunk *tmp = pc->GetPrev(); if ( tmp->IsNotNullChunk() && ( tmp->Is(CT_OC_MSG_FUNC) || tmp->Is(CT_OC_MSG_NAME))) { nas.Add(tmp); tmp->SetFlagBits(PCF_DONT_INDENT); } did_line = true; } pc = pc->GetNext(E_Scope::PREPROC); } log_rule_B("align_oc_msg_colon_first"); nas.m_skip_first = !options::align_oc_msg_colon_first(); cas.m_skip_first = !options::align_oc_msg_colon_first(); // find the longest args that isn't the first one size_t first_len = 0; size_t mlen = 0; Chunk *longest = nullptr; size_t len = nas.m_aligned.Len(); for (size_t idx = 0; idx < len; idx++) { Chunk *tmp = nas.m_aligned.GetChunk(idx); if (tmp != nullptr) { size_t tlen = tmp->GetStr().size(); if (tlen > mlen) { mlen = tlen; if (idx != 0) { longest = tmp; } } if (idx == 0) { first_len = tlen + 1; } } } // add spaces before the longest arg log_rule_B("indent_oc_msg_colon"); len = options::indent_oc_msg_colon(); size_t len_diff = mlen - first_len; log_rule_B("indent_columns"); size_t indent_size = options::indent_columns(); // Align with first colon if possible by removing spaces log_rule_B("indent_oc_msg_prioritize_first_colon"); if ( longest != nullptr && options::indent_oc_msg_prioritize_first_colon() && len_diff > 0 && ( (longest->GetColumn() >= len_diff) && (longest->GetColumn() - len_diff) > (longest->GetBraceLevel() * indent_size))) { longest->SetColumn(longest->GetColumn() - len_diff); } else if ( longest != nullptr && len > 0) { Chunk chunk; chunk.SetType(CT_SPACE); chunk.SetParentType(CT_NONE); chunk.SetOrigLine(longest->GetOrigLine()); chunk.SetOrigCol(longest->GetOrigCol()); chunk.SetLevel(longest->GetLevel()); chunk.SetBraceLevel(longest->GetBraceLevel()); chunk.SetFlags(longest->GetFlags() & PCF_COPY_FLAGS); // start at one since we already indent for the '[' for (size_t idx = 1; idx < len; idx++) { chunk.Str().append(' '); } chunk.CopyAndAddBefore(longest); } nas.End(); cas.End(); } // align_oc_msg_colon void align_oc_msg_colons() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if ( pc->Is(CT_SQUARE_OPEN) && pc->GetParentType() == CT_OC_MSG) { align_oc_msg_colon(pc); } } } // align_oc_msg_colons uncrustify-uncrustify-0.76.0/src/align_oc_msg_colons.h000066400000000000000000000004651434072136500232000ustar00rootroot00000000000000/** * @file align_oc_msg_colons.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_OC_MSG_COLONS_H_INCLUDED #define ALIGN_OC_MSG_COLONS_H_INCLUDED //! Aligns OC messages void align_oc_msg_colons(); #endif /* ALIGN_OC_MSG_COLONS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_oc_msg_spec.cpp000066400000000000000000000011441434072136500231630ustar00rootroot00000000000000/** * @file align_oc_msg_spec.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_oc_msg_spec.h" #include "align_assign.h" #include "align_stack.h" void align_oc_msg_spec(size_t span) { LOG_FUNC_ENTRY(); AlignStack as; as.Start(span, 0); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->IsNewline()) { as.NewLines(pc->GetNlCount()); } else if (pc->Is(CT_OC_MSG_SPEC)) { as.Add(pc); } } as.End(); } // void align_oc_msg_spec uncrustify-uncrustify-0.76.0/src/align_oc_msg_spec.h000066400000000000000000000005561434072136500226360ustar00rootroot00000000000000/** * @file align_oc_msg_spec.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_OC_MSG_SPEC_H_INCLUDED #define ALIGN_OC_MSG_SPEC_H_INCLUDED #include "uncrustify_types.h" //! Aligns all function prototypes in the file. void align_oc_msg_spec(size_t span); #endif /* ALIGN_OC_MSG_SPEC_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_preprocessor.cpp000066400000000000000000000055461434072136500234420ustar00rootroot00000000000000/** * @file align_preprocessor.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_preprocessor.h" #include "align_stack.h" #include "log_rules.h" constexpr static auto LCURRENT = LALPP; using namespace uncrustify; void align_preprocessor() { LOG_FUNC_ENTRY(); AlignStack as; // value macros log_rule_B("align_pp_define_span"); as.Start(options::align_pp_define_span()); log_rule_B("align_pp_define_gap"); as.m_gap = options::align_pp_define_gap(); AlignStack *cur_as = &as; AlignStack asf; // function macros log_rule_B("align_pp_define_span"); asf.Start(options::align_pp_define_span()); log_rule_B("align_pp_define_gap"); asf.m_gap = options::align_pp_define_gap(); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { // Note: not counting back-slash newline combos if (pc->Is(CT_NEWLINE)) // mind the gap: pc->IsNewline() is NOT the same! { as.NewLines(pc->GetNlCount()); asf.NewLines(pc->GetNlCount()); } // If we aren't on a 'define', then skip to the next non-comment if (pc->IsNot(CT_PP_DEFINE)) { pc = pc->GetNextNc(); continue; } // step past the 'define' pc = pc->GetNextNc(); if (pc->IsNullChunk()) { // coveralls will complain here. There are no example for that. // see https://en.wikipedia.org/wiki/Robustness_principle break; } LOG_FMT(LALPP, "%s(%d): define (%s) on line %zu col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); cur_as = &as; if (pc->Is(CT_MACRO_FUNC)) { log_rule_B("align_pp_define_together"); if (!options::align_pp_define_together()) { cur_as = &asf; } // Skip to the close parenthesis pc = pc->GetNextNc(); // point to open ( pc = pc->GetNextType(CT_FPAREN_CLOSE, pc->GetLevel()); LOG_FMT(LALPP, "%s(%d): jumped to (%s) on line %zu col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); } // step to the value past the close parenthesis or the macro name pc = pc->GetNext(); if (pc->IsNullChunk()) { // coveralls will complain here. There are no example for that. // see https://en.wikipedia.org/wiki/Robustness_principle break; } /* * don't align anything if the first line ends with a newline before * a value is given */ if (!pc->IsNewline()) { LOG_FMT(LALPP, "%s(%d): align on '%s', line %zu col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); cur_as->Add(pc); } } as.End(); asf.End(); } // align_preprocessor uncrustify-uncrustify-0.76.0/src/align_preprocessor.h000066400000000000000000000006071434072136500231000ustar00rootroot00000000000000/** * @file align_preprocessor.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_PREPROCESSOR_H_INCLUDED #define ALIGN_PREPROCESSOR_H_INCLUDED #include "uncrustify_types.h" //! Scans the whole file for #defines. Aligns all within X lines of each other void align_preprocessor(); #endif /* ALIGN_PREPROCESSOR_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_same_func_call_params.cpp000066400000000000000000000176451434072136500252150ustar00rootroot00000000000000/** * @file align_same_func_call_params.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_same_func_call_params.h" #include "align_stack.h" #include "log_rules.h" constexpr static auto LCURRENT = LASFCP; using namespace uncrustify; void align_same_func_call_params() { LOG_FUNC_ENTRY(); Chunk *pc; Chunk *align_root = Chunk::NullChunkPtr; Chunk *align_cur = Chunk::NullChunkPtr; size_t align_len = 0; size_t span = 3; size_t thresh; Chunk *align_fcn; unc_text align_fcn_name; unc_text align_root_name; deque chunks; deque array_of_AlignStack; AlignStack fcn_as; const char *add_str; // Default span is 3 if align_same_func_call_params is true log_rule_B("align_same_func_call_params_span"); if (options::align_same_func_call_params_span() > 0) { span = options::align_same_func_call_params_span(); } log_rule_B("align_same_func_call_params_thresh"); thresh = options::align_same_func_call_params_thresh(); fcn_as.Start(span, thresh); LOG_FMT(LAS, "%s(%d): (3): span is %zu, thresh is %zu\n", __func__, __LINE__, span, thresh); for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->IsNewline()) { LOG_FMT(LAS, "%s(%d): orig line is %zu, \n", __func__, __LINE__, pc->GetOrigLine()); } else { LOG_FMT(LAS, "%s(%d): orig line is %zu, orig col is %zu, pc->Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); } if (pc->IsNot(CT_FUNC_CALL)) { if (pc->IsNewline()) { for (auto &as_v : array_of_AlignStack) { as_v.NewLines(pc->GetNlCount()); } fcn_as.NewLines(pc->GetNlCount()); } else { // if we drop below the brace level that started it, we are done if ( align_root->IsNotNullChunk() && align_root->GetBraceLevel() > pc->GetBraceLevel()) { LOG_FMT(LASFCP, " ++ (drop) Ended with %zu fcns\n", align_len); // Flush it all! fcn_as.Flush(); for (auto &as_v : array_of_AlignStack) { as_v.Flush(); } align_root = Chunk::NullChunkPtr; } } continue; } // Only align function calls that are right after a newline Chunk *prev = pc->GetPrev(); while ( prev->Is(CT_MEMBER) || prev->Is(CT_DC_MEMBER)) { Chunk *tprev = prev->GetPrev(); if (tprev->IsNot(CT_TYPE)) { prev = tprev; break; } prev = tprev->GetPrev(); } if (!prev->IsNewline()) { continue; } prev = prev->GetNext(); align_fcn = prev; align_fcn_name.clear(); LOG_FMT(LASFCP, "%s(%d):\n", __func__, __LINE__); while (prev != pc) { align_fcn_name += prev->GetStr(); prev = prev->GetNext(); } align_fcn_name += pc->GetStr(); LOG_FMT(LASFCP, "%s(%d): Func Call found at orig line is %zu, orig col is %zu, c_str() '%s'\n", __func__, __LINE__, align_fcn->GetOrigLine(), align_fcn->GetOrigCol(), align_fcn_name.c_str()); add_str = nullptr; if (align_root->IsNotNullChunk()) { // Issue # 1395 // can only align functions on the same brace level // and on the same level LOG_FMT(LASFCP, "%s(%d):align_root is not nullptr\n", __func__, __LINE__); if ( align_root->GetBraceLevel() == pc->GetBraceLevel() && align_root->GetLevel() == pc->GetLevel() && align_fcn_name.equals(align_root_name)) { fcn_as.Add(pc); align_cur->AlignmentData().next = pc; align_cur = pc; align_len++; add_str = " Add"; } else { LOG_FMT(LASFCP, " ++ Ended with %zu fcns\n", align_len); // Flush it all! fcn_as.Flush(); for (auto &as_v : array_of_AlignStack) { as_v.Flush(); } align_root = Chunk::NullChunkPtr; } } LOG_FMT(LASFCP, "%s(%d):\n", __func__, __LINE__); if (align_root->IsNullChunk()) { LOG_FMT(LASFCP, "%s(%d):align_root is null chunk, Add pc '%s'\n", __func__, __LINE__, pc->Text()); fcn_as.Add(pc); align_root = align_fcn; align_root_name = align_fcn_name; align_cur = pc; align_len = 1; add_str = "Start"; } LOG_FMT(LASFCP, "%s(%d):\n", __func__, __LINE__); if (add_str != nullptr) { LOG_FMT(LASFCP, "%s(%d): %s with function '%s', on orig line %zu, ", __func__, __LINE__, add_str, align_fcn_name.c_str(), pc->GetOrigLine()); align_params(pc, chunks); LOG_FMT(LASFCP, "%zu items:", chunks.size()); for (size_t idx = 0; idx < chunks.size(); idx++) { // show the chunk(s) LOG_FMT(LASFCP, " [%s]", chunks[idx]->Text()); if (idx < chunks.size() - 1) { LOG_FMT(LASFCP, ","); } } LOG_FMT(LASFCP, "\n"); for (size_t idx = 0; idx < chunks.size(); idx++) { LOG_FMT(LASFCP, "%s(%d): chunks[%zu] is [%s]\n", __func__, __LINE__, idx, chunks[idx]->Text()); // Issue #2368 if (array_of_AlignStack.size() > idx) { // Issue #2368 array_of_AlignStack[idx].m_right_align = false; } if (idx >= array_of_AlignStack.size()) { LOG_FMT(LASFCP, "%s(%d): resize with %zu\n", __func__, __LINE__, idx + 1); array_of_AlignStack.resize(idx + 1); LOG_FMT(LASFCP, "%s(%d): Start for the new\n", __func__, __LINE__); array_of_AlignStack[idx].Start(span, thresh); log_rule_B("align_number_right"); if (!options::align_number_right()) { if ( chunks[idx]->Is(CT_NUMBER_FP) || chunks[idx]->Is(CT_NUMBER) || chunks[idx]->Is(CT_POS) || chunks[idx]->Is(CT_NEG)) { log_rule_B("align_on_tabstop"); array_of_AlignStack[idx].m_right_align = !options::align_on_tabstop(); } } } LOG_FMT(LASFCP, "%s(%d): save the chunk %s\n", __func__, __LINE__, chunks[idx]->Text()); array_of_AlignStack[idx].Add(chunks[idx]); } } } if (align_len > 1) { LOG_FMT(LASFCP, " ++ Ended with %zu fcns\n", align_len); fcn_as.End(); for (auto &as_v : array_of_AlignStack) { as_v.End(); } } } // align_same_func_call_params void align_params(Chunk *start, deque &chunks) { LOG_FUNC_ENTRY(); chunks.clear(); bool hit_comma = true; Chunk *pc = start->GetNextType(CT_FPAREN_OPEN, start->GetLevel()); while ((pc = pc->GetNext())->IsNotNullChunk()) { if ( pc->IsNewline() || pc->Is(CT_SEMICOLON) || ( pc->Is(CT_FPAREN_CLOSE) && pc->GetLevel() == start->GetLevel())) { break; } if (pc->GetLevel() == (start->GetLevel() + 1)) { if (hit_comma) { chunks.push_back(pc); hit_comma = false; } else if (pc->Is(CT_COMMA)) { hit_comma = true; } } } } // void align_params uncrustify-uncrustify-0.76.0/src/align_same_func_call_params.h000066400000000000000000000007001434072136500246420ustar00rootroot00000000000000/** * @file align_same_func_call_params.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_SAME_FUNC_CALL_PARAMS_H_INCLUDED #define ALIGN_SAME_FUNC_CALL_PARAMS_H_INCLUDED #include "ChunkStack.h" #include using namespace std; void align_params(Chunk *start, deque &chunks); void align_same_func_call_params(); #endif /* ALIGN_SAME_FUNC_CALL_PARAMS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_stack.cpp000066400000000000000000000507421434072136500220170ustar00rootroot00000000000000/** * @file align_stack.cpp * Manages an align stack, which is just a pair of chunk stacks. * There can be at most 1 item per line in the stack. * The seqnum is actually a line counter. * * @author Ben Gardner * @license GPL v2+ */ #include "align_stack.h" #include "align_tab_column.h" #include "indent.h" #include "space.h" #include "unc_tools.h" // to get stackID and get_A_Number() constexpr static auto LCURRENT = LAS; using namespace uncrustify; using std::numeric_limits; void AlignStack::Start(size_t span, int thresh) { stackID = get_A_Number(); // for debugging purpose only // produces much more log output. Use it only debugging purpose //WITH_STACKID_DEBUG; //LOG_FMT(LAS, "AlignStack::Start(%d):m_aligned.Reset()\n", __LINE__); m_aligned.Reset(); //LOG_FMT(LAS, "AlignStack::Start(%d):m_skipped.Reset()\n", __LINE__); m_skipped.Reset(); if (thresh > 0) { m_absolute_thresh = false; m_thresh = thresh; } else { m_absolute_thresh = true; m_thresh = -thresh; } m_span = span; m_min_col = numeric_limits::max(); m_max_col = 0; m_nl_seqnum = 0; m_seqnum = 0; m_gap = 0; m_right_align = false; m_star_style = SS_IGNORE; m_amp_style = SS_IGNORE; } void AlignStack::ReAddSkipped() { // produces much more log output. Use it only debugging purpose //WITH_STACKID_DEBUG; if (m_skipped.Empty()) { return; } // Make a copy of the ChunkStack and clear m_skipped m_scratch.Set(m_skipped); //LOG_FMT(LAS, "AlignStack::ReAddSkipped(%d):m_skipped.Reset()\n", __LINE__); m_skipped.Reset(); // Need to add them in order so that m_nl_seqnum is correct for (size_t idx = 0; idx < m_scratch.Len(); idx++) { const ChunkStack::Entry *ce = m_scratch.Get(idx); LOG_FMT(LAS, "AlignStack::ReAddSkipped [%zu] - ", ce->m_seqnum); Add(ce->m_pc, ce->m_seqnum); } NewLines(0); // Check to see if we need to flush right away } void AlignStack::Add(Chunk *start, size_t seqnum) { // produces much more log output. Use it only debugging purpose //WITH_STACKID_DEBUG; LOG_FUNC_ENTRY(); LOG_FMT(LAS, "AlignStack::%s(%d): Candidate is '%s': orig line is %zu, column is %zu, type is %s, level is %zu\n", __func__, __LINE__, start->Text(), start->GetOrigLine(), start->GetColumn(), get_token_name(start->GetType()), start->GetLevel()); LOG_FMT(LAS, "AlignStack::%s(%d): seqnum is %zu\n", __func__, __LINE__, seqnum); // Assign a seqnum if needed if (seqnum == 0) { LOG_FMT(LAS, "AlignStack::%s(%d): m_seqnum is %zu\n", __func__, __LINE__, m_seqnum); seqnum = m_seqnum; LOG_FMT(LAS, "AlignStack::%s(%d): seqnum is %zu\n", __func__, __LINE__, seqnum); } m_last_added = 0; // Threshold check should begin after // tighten down the spacing between ref and start /* * SS_IGNORE: no special handling of '*' or '&', only 'foo' is aligned * void foo; // gap=5, 'foo' is aligned * char * foo; // gap=3, 'foo' is aligned * foomatic foo; // gap=1, 'foo' is aligned * The gap is the columns between 'foo' and the previous token. * [void - foo], ['*' - foo], etc * * SS_INCLUDE: - space between variable and '*' or '&' is eaten * void foo; // gap=5, 'foo' is aligned * char *foo; // gap=5, '*' is aligned * foomatic foo; // gap=1, 'foo' is aligned * The gap is the columns between the first '*' or '&' before foo * and the previous token. [void - foo], [char - '*'], etc * * SS_DANGLE: - space between variable and '*' or '&' is eaten * void foo; // gap=5 * char *bar; // gap=5, as the '*' doesn't count * foomatic foo; // gap=1 * The gap is the columns between 'foo' and the chunk before the first * '*' or '&'. [void - foo], [char - bar], etc * * If the gap < m_gap, then the column is bumped out by the difference. * So, if m_gap is 2, then the above would be: * SS_IGNORE: * void foo; // gap=6 * char * foo; // gap=4 * foomatic foo; // gap=2 * SS_INCLUDE: * void foo; // gap=6 * char *foo; // gap=6 * foomatic foo; // gap=2 * SS_DANGLE: * void foo; // gap=6 * char *bar; // gap=6, as the '*' doesn't count * foomatic foo; // gap=2 * Right aligned numbers: * #define A -1 * #define B 631 * #define C 3 * Left aligned numbers: * #define A -1 * #define B 631 * #define C 3 * * In the code below, pc is set to the item that is aligned. * In the above examples, that is 'foo', '*', '-', or 63. * * Ref is set to the last part of the type. * In the above examples, that is 'void', 'char', 'foomatic', 'A', or 'B'. * * The '*' and '&' can float between the two. * * If align_on_tabstop=true, then SS_DANGLE is changed to SS_INCLUDE. */ log_rule_B("align_on_tabstop"); if ( options::align_on_tabstop() && m_star_style == SS_DANGLE) { m_star_style = SS_INCLUDE; } LOG_FMT(LAS, "AlignStack::%s(%d): m_star_style is %s\n", __func__, __LINE__, get_StarStyle_name(m_star_style)); // Find ref. Back up to the real item that is aligned. Chunk *prev = start; while ( (prev = prev->GetPrev())->IsNotNullChunk() && ( prev->IsPointerOperator() || prev->Is(CT_TPAREN_OPEN))) { // do nothing - we want prev when this exits } if (prev->IsNullChunk()) { return; } Chunk *ref = prev; if (ref->IsNewline()) { ref = ref->GetNext(); } // Find the item that we are going to align. Chunk *ali = Chunk::NullChunkPtr; if (start != nullptr) { ali = start; } if (m_star_style != SS_IGNORE) { // back up to the first '*' or '^' preceding the token Chunk *tmp_prev = ali->GetPrev(); while ( tmp_prev->IsStar() || tmp_prev->IsMsRef()) { ali = tmp_prev; tmp_prev = ali->GetPrev(); } if (tmp_prev->Is(CT_TPAREN_OPEN)) { ali = tmp_prev; tmp_prev = ali->GetPrev(); // this is correct, even Coverity says: // CID 76021 (#1 of 1): Unused value (UNUSED_VALUE)returned_pointer: Assigning value from // ali->GetPrev(nav_e::ALL) to prev here, but that stored value is overwritten before it can be used. } } if (m_amp_style != SS_IGNORE) { // back up to the first '&' preceding the token Chunk *tmp_prev = ali->GetPrev(); while (tmp_prev->IsAddress()) { ali = tmp_prev; tmp_prev = ali->GetPrev(); } } log_rule_B("align_keep_extra_space"); // Tighten down the spacing between ref and start if (!options::align_keep_extra_space()) { size_t tmp_col = ref->GetColumn(); Chunk *tmp = ref; LOG_FMT(LAS, "AlignStack::%s(%d): tmp_col is %zu\n", __func__, __LINE__, tmp_col); while ( tmp->IsNotNullChunk() && tmp != start) { Chunk *next = tmp->GetNext(); if (next->IsNotNullChunk()) { LOG_FMT(LAS, "AlignStack::%s(%d): next orig line is %zu, orig col is %zu, Text() '%s', level is %zu, type is %s\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text(), next->GetLevel(), get_token_name(next->GetType())); tmp_col += space_col_align(tmp, next); LOG_FMT(LAS, "AlignStack::%s(%d): next column is %zu, level is %zu, tmp_col is %zu\n", __func__, __LINE__, next->GetColumn(), next->GetLevel(), tmp_col); if (next->GetColumn() != tmp_col) { LOG_FMT(LAS, "AlignStack::%s(%d): Call align_to_column\n", __func__, __LINE__); align_to_column(next, tmp_col); } } tmp = next; } } // Check threshold limits if ( m_max_col == 0 || m_thresh == 0 || ( ((start->GetColumn() + m_gap) <= (m_thresh + (m_absolute_thresh ? m_min_col : m_max_col))) // don't use subtraction here to prevent underflow && ( (start->GetColumn() + m_gap + m_thresh) >= m_max_col // change the expression to mind negative expression || start->GetColumn() >= m_min_col))) { // we are adding it, so update the newline seqnum if (seqnum > m_nl_seqnum) { m_nl_seqnum = seqnum; } // Set the column adjust and gap size_t col_adj = 0; // Amount the column is shifted for 'dangle' mode size_t gap = 0; if (ref != ali) { gap = ali->GetColumn() - (ref->GetColumn() + ref->Len()); } Chunk *tmp = ali; if (tmp->Is(CT_TPAREN_OPEN)) { tmp = tmp->GetNext(); } if ( ( tmp->IsStar() && m_star_style == SS_DANGLE) || ( tmp->IsAddress() && m_amp_style == SS_DANGLE) || ( tmp->IsNullable() && (m_star_style == SS_DANGLE)) || ( tmp->IsMsRef() && m_star_style == SS_DANGLE)) // TODO: add m_msref_style { col_adj = start->GetColumn() - ali->GetColumn(); gap = start->GetColumn() - (ref->GetColumn() + ref->Len()); } // See if this pushes out the max_col const size_t endcol = ali->GetColumn() + col_adj + (gap < m_gap ? m_gap - gap : 0); ali->AlignmentData().col_adj = col_adj; ali->AlignmentData().ref = ref; ali->AlignmentData().start = start; m_aligned.Push_Back(ali, seqnum); m_last_added = 1; // Issue #2278 if (ali->Is(CT_PTR_TYPE)) { LOG_FMT(LAS, "AlignStack::%s(%d): Add-[%s][%s]: ali orig line is %zu, column is %zu, type is %s, level is %zu\n", __func__, __LINE__, ali->Text(), start->Text(), ali->GetOrigLine(), ali->GetColumn(), get_token_name(ali->GetType()), ali->GetLevel()); } else { LOG_FMT(LAS, "AlignStack::%s(%d): Add-[%s]: ali orig line is %zu, column is %zu, type is %s, level is %zu\n", __func__, __LINE__, ali->Text(), ali->GetOrigLine(), ali->GetColumn(), get_token_name(ali->GetType()), ali->GetLevel()); } LOG_FMT(LAS, "AlignStack::%s(%d): ali alignment col_adj is %d, ref '%s', endcol is %zu\n", __func__, __LINE__, ali->GetAlignmentData().col_adj, ref->Text(), endcol); if (m_min_col > endcol) { m_min_col = endcol; } if (endcol > m_max_col) { LOG_FMT(LAS, "AlignStack::%s(%d): Add-aligned: seqnum is %zu, m_nl_seqnum is %zu, m_seqnum is %zu\n", __func__, __LINE__, seqnum, m_nl_seqnum, m_seqnum); LOG_FMT(LAS, "AlignStack::%s(%d): ali orig line is %zu, column is %zu, max_col old is %zu, new is %zu, m_min_col is %zu\n", __func__, __LINE__, ali->GetOrigLine(), ali->GetColumn(), m_max_col, endcol, m_min_col); m_max_col = endcol; /* * If there were any entries that were skipped, re-add them as they * may now be within the threshold */ if (!m_skipped.Empty()) { ReAddSkipped(); } } else { LOG_FMT(LAS, "AlignStack::%s(%d): Add-aligned: seqnum is %zu, m_nl_seqnum is %zu, m_seqnum is %zu\n", __func__, __LINE__, seqnum, m_nl_seqnum, m_seqnum); LOG_FMT(LAS, "AlignStack::%s(%d): ali orig line is %zu, column is %zu, max_col old is %zu, new is %zu, m_min_col is %zu\n", __func__, __LINE__, ali->GetOrigLine(), ali->GetColumn(), m_max_col, endcol, m_min_col); } } else { // The threshold check failed, so add it to the skipped list m_skipped.Push_Back(start, seqnum); m_last_added = 2; LOG_FMT(LAS, "AlignStack::Add-skipped [%zu/%zu/%zu]: line %zu, col %zu <= %zu + %zu\n", seqnum, m_nl_seqnum, m_seqnum, start->GetOrigLine(), start->GetColumn(), m_max_col, m_thresh); } // produces much more log output. Use it only debugging purpose //WITH_STACKID_DEBUG; } // AlignStack::Add void AlignStack::NewLines(size_t cnt) { // produces much more log output. Use it only debugging purpose //WITH_STACKID_DEBUG; if (m_aligned.Empty()) { //LOG_FMT(LAS, "AlignStack::Newlines(%d): nothing to do, is empty\n", __LINE__); return; } LOG_FMT(LAS, "AlignStack::Newlines(%d): cnt is %zu\n", __LINE__, cnt); m_seqnum += cnt; LOG_FMT(LAS, "AlignStack::Newlines(%d): m_seqnum is %zu, m_nl_seqnum is %zu, m_span is %zu\n", __LINE__, m_seqnum, m_nl_seqnum, m_span); if (m_seqnum > (m_nl_seqnum + m_span)) { LOG_FMT(LAS, "AlignStack::Newlines(%d): cnt is %zu\n", __LINE__, cnt); Flush(); } } void AlignStack::Flush() { // produces much more log output. Use it only debugging purpose //WITH_STACKID_DEBUG; LOG_FMT(LAS, "AlignStack::%s(%d): Len() is %zu\n", __func__, __LINE__, Len()); if (Len() > 0) { LOG_FMT(LAS, " (min is %zu, max is %zu)\n", m_min_col, m_max_col); } if (Len() == 1) { // check if we have *one* typedef in the line Chunk *pc = m_aligned.Get(0)->m_pc; Chunk *temp = pc->GetPrevType(CT_TYPEDEF, pc->GetLevel()); if (temp->IsNotNullChunk()) { if (pc->GetOrigLine() == temp->GetOrigLine()) { // reset the gap only for *this* stack m_gap = 1; } } } m_last_added = 0; m_max_col = 0; // produces much more log output. Use it only debugging purpose //WITH_STACKID_DEBUG; LOG_FMT(LAS, "AlignStack::%s(%d): Debug the stack, Len is %zu\n", __func__, __LINE__, Len()); for (size_t idx = 0; idx < Len(); idx++) { Chunk *pc = m_aligned.Get(idx)->m_pc; LOG_FMT(LAS, "AlignStack::%s(%d): idx is %zu, pc->Text() is '%s', pc alignment col_adj is %d\n", __func__, __LINE__, idx, pc->Text(), pc->GetAlignmentData().col_adj); } // Recalculate the max_col - it may have shifted since the last Add() for (size_t idx = 0; idx < Len(); idx++) { Chunk *pc = m_aligned.Get(idx)->m_pc; // Set the column adjust and gap size_t col_adj = 0; size_t gap = 0; if (pc != pc->GetAlignmentData().ref) { gap = pc->GetColumn() - (pc->GetAlignmentData().ref->GetColumn() + pc->GetAlignmentData().ref->Len()); } if (m_star_style == SS_DANGLE) { Chunk *tmp = (pc->Is(CT_TPAREN_OPEN)) ? pc->GetNext() : pc; if (tmp->IsPointerOperator()) { col_adj = pc->GetAlignmentData().start->GetColumn() - pc->GetColumn(); gap = pc->GetAlignmentData().start->GetColumn() - (pc->GetAlignmentData().ref->GetColumn() + pc->GetAlignmentData().ref->Len()); } } if (m_right_align) { // Adjust the width for signed numbers if (pc->GetAlignmentData().start != nullptr) { size_t start_len = pc->GetAlignmentData().start->Len(); if (pc->GetAlignmentData().start->GetType() == CT_NEG) { Chunk *next = pc->GetAlignmentData().start->GetNext(); if (next->Is(CT_NUMBER)) { start_len += next->Len(); } } col_adj += start_len; } } pc->AlignmentData().col_adj = col_adj; // See if this pushes out the max_col const size_t endcol = pc->GetColumn() + col_adj + (gap < m_gap ? m_gap - gap : 0); if (endcol > m_max_col) { m_max_col = endcol; } } log_rule_B("align_on_tabstop"); if ( options::align_on_tabstop() && Len() > 1) { m_max_col = align_tab_column(m_max_col); } LOG_FMT(LAS, "AlignStack::%s(%d): Len() is %zu\n", __func__, __LINE__, Len()); const ChunkStack::Entry *ce = nullptr; for (size_t idx = 0; idx < Len(); idx++) { ce = m_aligned.Get(idx); LOG_FMT(LAS, "AlignStack::%s(%d): idx is %zu, ce->m_pc->Text() is '%s', orig line is %zu, orig col is %zu, alignment col_adj is %d\n", __func__, __LINE__, idx, ce->m_pc->Text(), ce->m_pc->GetOrigLine(), ce->m_pc->GetOrigCol(), ce->m_pc->GetAlignmentData().col_adj); } for (size_t idx = 0; idx < Len(); idx++) { ce = m_aligned.Get(idx); Chunk *pc = ce->m_pc; const size_t tmp_col = m_max_col - pc->GetAlignmentData().col_adj; if (idx == 0) { if ( m_skip_first && pc->GetColumn() != tmp_col) { LOG_FMT(LAS, "AlignStack::%s(%d): orig line is %zu, orig col is %zu, dropping first item due to skip_first\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); m_skip_first = false; m_aligned.Pop_Front(); Flush(); m_skip_first = true; return; } pc->SetFlagBits(PCF_ALIGN_START); pc->AlignmentData().right_align = m_right_align; pc->AlignmentData().amp_style = m_amp_style; pc->AlignmentData().star_style = m_star_style; } pc->AlignmentData().gap = m_gap; pc->AlignmentData().next = m_aligned.GetChunk(idx + 1); // Indent the token, taking col_adj into account LOG_FMT(LAS, "AlignStack::%s(%d): orig line is %zu, orig col is %zu, Text() '%s', set to col %zu (adj is %d)\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), tmp_col, pc->GetAlignmentData().col_adj); align_to_column(pc, tmp_col); } size_t last_seqnum = 0; if (ce != nullptr) { last_seqnum = ce->m_seqnum; //LOG_FMT(LAS, "AlignStack::Flush(%d):m_aligned.Reset()\n", __LINE__); m_aligned.Reset(); } m_min_col = numeric_limits::max(); // use unrealistic high numbers m_max_col = 0; // as start value if (m_skipped.Empty()) { // Nothing was skipped, sync the sequence numbers m_nl_seqnum = m_seqnum; } else { // Remove all items with seqnum < last_seqnum for (size_t idx = 0; idx < m_skipped.Len(); idx++) { if (m_skipped.Get(idx)->m_seqnum < last_seqnum) { m_skipped.Zap(idx); } } m_skipped.Collapse(); ReAddSkipped(); // Add all items from the skipped list } } // AlignStack::Flush void AlignStack::Reset() { //WITH_STACKID_DEBUG; //LOG_FMT(LAS, "AlignStack::Reset(%d):m_aligned.Reset()\n", __LINE__); m_aligned.Reset(); //LOG_FMT(LAS, "AlignStack::Reset(%d):m_skipped.Reset()\n", __LINE__); m_skipped.Reset(); } void AlignStack::End() { //WITH_STACKID_DEBUG; if (!m_aligned.Empty()) { //LOG_FMT(LAS, "AlignStack::End(%d):\n", __LINE__); Flush(); } //LOG_FMT(LAS, "AlignStack::End(%d):m_aligned.Reset()\n", __LINE__); m_aligned.Reset(); //LOG_FMT(LAS, "AlignStack::End(%d):m_skipped.Reset()\n", __LINE__); m_skipped.Reset(); } size_t AlignStack::Len() { return(m_aligned.Len()); } void AlignStack::Debug() { //WITH_STACKID_DEBUG; size_t length = Len(); if (length > 0) { LOG_FMT(LAS, "AlignStack::%s(%d): Debug the stack, Len is %zu\n", __func__, __LINE__, Len()); for (size_t idx = 0; idx < length; idx++) { Chunk *pc = m_aligned.Get(idx)->m_pc; if (pc->Is(CT_PTR_TYPE)) { LOG_FMT(LAS, "AlignStack::%s(%d): idx is %zu, [%s][%s]: orig line is %zu, orig col is %zu, type is %s, level is %zu, brace level is %zu\n", __func__, __LINE__, idx, pc->Text(), pc->GetNext()->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->GetLevel(), pc->GetBraceLevel()); } else { LOG_FMT(LAS, "AlignStack::%s(%d): idx is %zu, [%s]: orig line is %zu, orig col is %zu, type is %s, level is %zu, brace level is %zu\n", __func__, __LINE__, idx, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->GetLevel(), pc->GetBraceLevel()); } } } } const char *AlignStack::get_StarStyle_name(StarStyle star_style) { switch (star_style) { case StarStyle::SS_IGNORE: return("SS_IGNORE"); case StarStyle::SS_INCLUDE: return("SS_INCLUDE"); case StarStyle::SS_DANGLE: return("SS_DANGLE"); } return("?????"); } // get_StarStyle_name uncrustify-uncrustify-0.76.0/src/align_stack.h000066400000000000000000000104421434072136500214550ustar00rootroot00000000000000/** * @file align_stack.h * Manages an align stack, which is just a pair of chunk stacks with a few * fancy functions. * * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_STACK_H_INCLUDED #define ALIGN_STACK_H_INCLUDED #include "ChunkStack.h" #include class AlignStack { public: enum StarStyle { SS_IGNORE, //! don't look for prev stars SS_INCLUDE, //! include prev * before add SS_DANGLE //! include prev * after add }; ChunkStack m_aligned; //! contains the tokens that are aligned ChunkStack m_skipped; //! contains the tokens sent to Add() size_t m_max_col; size_t m_min_col; size_t m_span; size_t m_thresh; size_t m_seqnum; size_t m_nl_seqnum; size_t m_gap; bool m_right_align; bool m_absolute_thresh; StarStyle m_star_style; StarStyle m_amp_style; bool m_skip_first; //! do not include the first item if it causes it to be indented size_t stackID; //! for debugging purposes only AlignStack() : m_max_col(0) , m_min_col(0) , m_span(0) , m_thresh(0) , m_seqnum(0) , m_nl_seqnum(0) , m_gap(0) , m_right_align(false) , m_absolute_thresh(false) , m_star_style(SS_IGNORE) , m_amp_style(SS_IGNORE) , m_skip_first(false) , stackID(std::numeric_limits::max()) // under linux 64 bits: 18446744073709551615 , m_last_added(0) { } AlignStack(const AlignStack &ref) : m_aligned(ref.m_aligned) , m_skipped(ref.m_skipped) , m_max_col(ref.m_max_col) , m_min_col(ref.m_min_col) , m_span(ref.m_span) , m_thresh(ref.m_thresh) , m_seqnum(ref.m_seqnum) , m_nl_seqnum(ref.m_nl_seqnum) , m_gap(ref.m_gap) , m_right_align(ref.m_right_align) , m_absolute_thresh(ref.m_absolute_thresh) , m_star_style(ref.m_star_style) , m_amp_style(ref.m_amp_style) , m_skip_first(ref.m_skip_first) , m_last_added(ref.m_last_added) { } ~AlignStack() { } /** * Resets the two ChunkLists and zeroes local vars. * * @param span The row span limit * @param threshold The column threshold */ void Start(size_t span, int threshold = 0); /** * Adds an entry to the appropriate stack. * * @param pc the chunk * @param seqnum optional sequence number (0=assign one) */ void Add(Chunk *pc, size_t seqnum = 0); //! Adds some newline and calls Flush() if needed void NewLines(size_t cnt); /** * Aligns all the stuff in m_aligned. * Re-adds 'newer' items in m_skipped. */ void Flush(); //! Resets the stack, discarding anything that was previously added void Reset(); //! Aligns everything else and resets the lists. void End(); //! the size of the lists. size_t Len(); //! for debugging purpose only void Debug(); const char *get_StarStyle_name(StarStyle star_style); protected: size_t m_last_added; //! 0=none, 1=aligned, 2=skipped ChunkStack m_scratch; //! used in ReAddSkipped() //! Calls Add on all the skipped items void ReAddSkipped(); }; #define WITH_STACKID_DEBUG \ if (stackID == std::numeric_limits::max()) \ { \ fprintf(stderr, "AlignStack::%s(%d): the stack is not ready, Start is missed\n", __func__, __LINE__); \ log_flush(true); \ exit(EX_SOFTWARE); \ } \ else \ { \ LOG_FMT(LAS, "AlignStack::%s(%d): stackID is %zu\n", __func__, __LINE__, stackID); \ } #endif /* ALIGN_STACK_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_struct_initializers.cpp000066400000000000000000000012521434072136500250140ustar00rootroot00000000000000/** * @file align_struct_initializers.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_struct_initializers.h" #include "align_init_brace.h" #include "chunk.h" void align_struct_initializers() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { Chunk *prev = pc->GetPrevNcNnl(); if ( prev->Is(CT_ASSIGN) && ( pc->Is(CT_BRACE_OPEN) || ( language_is_set(LANG_D) && pc->Is(CT_SQUARE_OPEN)))) { align_init_brace(pc); } pc = pc->GetNextType(CT_BRACE_OPEN); } } // align_struct_initializers uncrustify-uncrustify-0.76.0/src/align_struct_initializers.h000066400000000000000000000006261434072136500244650ustar00rootroot00000000000000/** * @file align_struct_initializers.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_STRUCT_INITIALIZERS_H_INCLUDED #define ALIGN_STRUCT_INITIALIZERS_H_INCLUDED #include "uncrustify_types.h" //! Aligns stuff inside a multi-line "= { ... }" sequence. void align_struct_initializers(); #endif /* ALIGN_STRUCT_INITIALIZERS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_tab_column.cpp000066400000000000000000000012221434072136500230220ustar00rootroot00000000000000/** * @file align_tab_column.cpp * * @author Guy Maurel * split from prototypes.h * @author Ben Gardner * @license GPL v2+ */ #include "align_tab_column.h" #include "prototypes.h" constexpr static auto LCURRENT = LALIGN; using namespace uncrustify; /** * Advances to the next tab stop if not currently on one. * * @param col The current column * @return the next tabstop column */ size_t align_tab_column(size_t col) { //if (col <= 0) if (col == 0) { col = 1; } log_rule_B("output_tab_size"); if ((col % uncrustify::options::output_tab_size()) != 1) { col = next_tab_column(col); } return(col); } uncrustify-uncrustify-0.76.0/src/align_tab_column.h000066400000000000000000000007071434072136500224760ustar00rootroot00000000000000/** * @file align_tab_column.h * * @author Guy Maurel * split from prototypes.h * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_TAB_COLUMN_H_INCLUDED #define ALIGN_TAB_COLUMN_H_INCLUDED #include "uncrustify_types.h" /** * Advances to the next tab stop if not currently on one. * * @param col The current column * @return the next tabstop column */ size_t align_tab_column(size_t col); #endif /* ALIGN_TAB_COLUMN_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_tools.cpp000066400000000000000000000134031434072136500220430ustar00rootroot00000000000000/** * @file align_tools.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_tools.h" #include "space.h" #include "uncrustify.h" Chunk *skip_c99_array(Chunk *sq_open) { if (sq_open->Is(CT_SQUARE_OPEN)) { Chunk *tmp = sq_open->GetClosingParen()->GetNextNc(); if (tmp->Is(CT_ASSIGN)) { return(tmp->GetNextNc()); } } return(nullptr); } // skip_c99_array Chunk *scan_ib_line(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *prev_match = nullptr; size_t idx = 0; // Skip past C99 "[xx] =" stuff Chunk *tmp = skip_c99_array(start); if (tmp != nullptr) { start->SetParentType(CT_TSQUARE); start = tmp; cpd.al_c99_array = true; } Chunk *pc = start; if (pc != nullptr) { LOG_FMT(LSIB, "%s(%d): start: orig line is %zu, orig col is %zu, column is %zu, type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetColumn(), get_token_name(pc->GetType())); } else { pc = Chunk::NullChunkPtr; } while ( pc->IsNotNullChunk() && !pc->IsNewline() && pc->GetLevel() >= start->GetLevel()) { //LOG_FMT(LSIB, "%s: '%s' col %d/%d line %zu\n", __func__, // pc->Text(), pc->GetColumn(), pc->GetOrigCol(), pc->GetOrigLine()); Chunk *next = pc->GetNext(); if ( next->IsNullChunk() || next->IsComment()) { // do nothing } else if ( pc->Is(CT_ASSIGN) || pc->Is(CT_BRACE_OPEN) || pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_COMMA)) { size_t token_width = space_col_align(pc, next); // TODO: need to handle missing structure defs? ie NULL vs { ... } ?? // Is this a new entry? if (idx >= cpd.al_cnt) { if (idx == 0) { LOG_FMT(LSIB, "%s(%d): Prepare the 'idx's\n", __func__, __LINE__); } LOG_FMT(LSIB, "%s(%d): New idx is %2.1zu, pc->GetColumn() is %2.1zu, Text() '%s', token_width is %zu, type is %s\n", __func__, __LINE__, idx, pc->GetColumn(), pc->Text(), token_width, get_token_name(pc->GetType())); cpd.al[cpd.al_cnt].type = pc->GetType(); cpd.al[cpd.al_cnt].col = pc->GetColumn(); cpd.al[cpd.al_cnt].len = token_width; cpd.al[cpd.al_cnt].ref = pc; // Issue #3786 cpd.al_cnt++; if (cpd.al_cnt == uncrustify::limits::AL_SIZE) { fprintf(stderr, "Number of 'entry' to be aligned is too big for the current value %d,\n", uncrustify::limits::AL_SIZE); fprintf(stderr, "at line %zu, column %zu.\n", pc->GetOrigLine(), pc->GetOrigCol()); fprintf(stderr, "Please make a report.\n"); log_flush(true); exit(EX_SOFTWARE); } idx++; } else { // expect to match stuff if (cpd.al[idx].type == pc->GetType()) { LOG_FMT(LSIB, "%s(%d): Match? idx is %2.1zu, orig line is %2.1zu, column is %2.1zu, token_width is %zu, type is %s\n", __func__, __LINE__, idx, pc->GetOrigLine(), pc->GetColumn(), token_width, get_token_name(pc->GetType())); // Shift out based on column if (prev_match == nullptr) { if (pc->GetColumn() > cpd.al[idx].col) { LOG_FMT(LSIB, "%s(%d): [ pc column (%zu) > cpd.al[%zu].col(%zu) ] \n", __func__, __LINE__, pc->GetColumn(), idx, cpd.al[idx].col); ib_shift_out(idx, pc->GetColumn() - cpd.al[idx].col); cpd.al[idx].col = pc->GetColumn(); } } else if (idx > 0) { LOG_FMT(LSIB, "%s(%d): prev_match '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, prev_match->Text(), prev_match->GetOrigLine(), prev_match->GetOrigCol()); int min_col_diff = pc->GetColumn() - prev_match->GetColumn(); int cur_col_diff = cpd.al[idx].col - cpd.al[idx - 1].col; if (cur_col_diff < min_col_diff) { LOG_FMT(LSIB, "%s(%d): pc orig line is %zu\n", __func__, __LINE__, pc->GetOrigLine()); ib_shift_out(idx, min_col_diff - cur_col_diff); } } LOG_FMT(LSIB, "%s(%d): at ende of the loop: now is col %zu, len is %zu\n", __func__, __LINE__, cpd.al[idx].col, cpd.al[idx].len); idx++; } } prev_match = pc; } pc = pc->GetNextNc(); } return(pc); } // scan_ib_line void ib_shift_out(size_t idx, size_t num) { while (idx < cpd.al_cnt) { bool is_empty = false; // Issue #3786 Chunk *tmp = cpd.al[idx].ref; if (tmp->Is(CT_BRACE_CLOSE)) { Chunk *pre = tmp->GetPrev(); if (pre->Is(CT_COMMA)) { is_empty = true; } } if (!is_empty) { cpd.al[idx].col += num; } idx++; } } // ib_shift_out Chunk *step_back_over_member(Chunk *pc) { if (pc == nullptr) { pc = Chunk::NullChunkPtr; } Chunk *tmp = pc->GetPrevNcNnl(); // Skip over any class stuff: bool CFoo::bar() while ( tmp->IsNotNullChunk() && tmp->Is(CT_DC_MEMBER)) { pc = tmp->GetPrevNcNnl(); tmp = pc->GetPrevNcNnl(); } return(pc); } // step_back_over_member uncrustify-uncrustify-0.76.0/src/align_tools.h000066400000000000000000000022111434072136500215030ustar00rootroot00000000000000/** * @file align_tools.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_TOOLS_H_INCLUDED #define ALIGN_TOOLS_H_INCLUDED #include "chunk.h" #include "uncrustify_types.h" /** * @brief return the chunk the follows after a C array * * The provided chunk is considered an array if it is an opening square * (CT_SQUARE_OPEN) and the matching close is followed by an equal sign '=' * * Example: array[25] = 12; * /|\ /|\ * | | * provided chunk has to point to [ | * returned chunk points to 12 * * @param chunk chunk to operate on * * @return the chunk after the '=' if the check succeeds * @return nullptr in all other cases */ Chunk *skip_c99_array(Chunk *sq_open); /** * Scans a line for stuff to align on. * * We trigger on BRACE_OPEN, FPAREN_OPEN, ASSIGN, and COMMA. * We want to align the NEXT item. */ Chunk *scan_ib_line(Chunk *start); void ib_shift_out(size_t idx, size_t num); Chunk *step_back_over_member(Chunk *pc); #endif /* ALIGN_TOOLS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_trailing_comments.cpp000066400000000000000000000141571434072136500244300ustar00rootroot00000000000000/** * @file align_trailing_comments.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_trailing_comments.h" #include "align_add.h" #include "align_tab_column.h" #include "indent.h" #include "log_rules.h" constexpr static auto LCURRENT = LALTC; using namespace uncrustify; void align_stack(ChunkStack &cs, size_t col, bool align_single, log_sev_t sev) { LOG_FUNC_ENTRY(); log_rule_B("align_on_tabstop"); if (options::align_on_tabstop()) { col = align_tab_column(col); } if ( (cs.Len() > 1) || ( align_single && (cs.Len() == 1))) { LOG_FMT(sev, "%s(%d): max_col=%zu\n", __func__, __LINE__, col); Chunk *pc; while ((pc = cs.Pop_Back()) != nullptr) { align_to_column(pc, col); pc->SetFlagBits(PCF_WAS_ALIGNED); LOG_FMT(sev, "%s(%d): indented [%s] on line %zu to %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetColumn()); } } cs.Reset(); } // align_stack Chunk *align_trailing_comments(Chunk *start) { LOG_FUNC_ENTRY(); size_t min_col = 0; size_t min_orig = 0; Chunk *pc = start; const size_t lvl = start->GetBraceLevel(); size_t nl_count = 0; ChunkStack cs; size_t col; log_rule_B("align_right_cmt_at_col"); size_t intended_col = options::align_right_cmt_at_col(); log_rule_B("align_right_cmt_same_level"); const bool same_level = options::align_right_cmt_same_level(); comment_align_e cmt_type_cur; comment_align_e cmt_type_start = get_comment_align_type(pc); LOG_FMT(LALADD, "%s(%d): start on line=%zu\n", __func__, __LINE__, pc->GetOrigLine()); // Find the max column log_rule_B("align_right_cmt_span"); while ( pc->IsNotNullChunk() && (nl_count < options::align_right_cmt_span())) { if ( pc->TestFlags(PCF_RIGHT_COMMENT) && pc->GetColumn() > 1) { if ( same_level && pc->GetBraceLevel() != lvl) { pc = pc->GetPrev(); break; } cmt_type_cur = get_comment_align_type(pc); if (cmt_type_cur == cmt_type_start) { LOG_FMT(LALADD, "%s(%d): line=%zu min_col=%zu pc->col=%zu pc->len=%zu %s\n", __func__, __LINE__, pc->GetOrigLine(), min_col, pc->GetColumn(), pc->Len(), get_token_name(pc->GetType())); if ( min_orig == 0 || min_orig > pc->GetColumn()) { min_orig = pc->GetColumn(); } align_add(cs, pc, min_col); // (intended_col < col)); nl_count = 0; } } if (pc->IsNewline()) { nl_count += pc->GetNlCount(); } pc = pc->GetNext(); } // Start with the minimum original column col = min_orig; // fall back to the intended column if ( intended_col > 0 && col > intended_col) { col = intended_col; } // if less than allowed, bump it out if (col < min_col) { col = min_col; } // bump out to the intended column if (col < intended_col) { col = intended_col; } LOG_FMT(LALADD, "%s(%d): -- min_orig=%zu intended_col=%zu min_allowed=%zu ==> col=%zu\n", __func__, __LINE__, min_orig, intended_col, min_col, col); if ( cpd.frag_cols > 0 && cpd.frag_cols <= col) { col -= cpd.frag_cols; } align_stack(cs, col, (intended_col != 0), LALTC); return(pc->GetNext()); } // align_trailing_comments comment_align_e get_comment_align_type(Chunk *cmt) { Chunk *prev; comment_align_e cmt_type = comment_align_e::REGULAR; log_rule_B("align_right_cmt_mix"); if ( !options::align_right_cmt_mix() && cmt != nullptr && ((prev = cmt->GetPrev())->IsNotNullChunk())) { if ( prev->Is(CT_PP_ENDIF) || prev->Is(CT_PP_ELSE) || prev->Is(CT_ELSE) || prev->Is(CT_BRACE_CLOSE)) { // TODO: make the magic 3 configurable if ((cmt->GetColumn() - (prev->GetColumn() + prev->Len())) < 3) { cmt_type = (prev->Is(CT_PP_ENDIF)) ? comment_align_e::ENDIF : comment_align_e::BRACE; } } } return(cmt_type); } // get_comment_align_type void align_right_comments() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if ( pc->Is(CT_COMMENT) || pc->Is(CT_COMMENT_CPP) || pc->Is(CT_COMMENT_MULTI)) { if (pc->GetParentType() == CT_COMMENT_END) { log_rule_B("align_right_cmt_gap"); if (pc->GetOrigPrevSp() < options::align_right_cmt_gap()) { LOG_FMT(LALTC, "NOT changing END comment on line %zu (%zu < %u)\n", pc->GetOrigLine(), pc->GetOrigPrevSp(), options::align_right_cmt_gap()); } else { LOG_FMT(LALTC, "Changing END comment on line %zu into a RIGHT-comment\n", pc->GetOrigLine()); pc->SetFlagBits(PCF_RIGHT_COMMENT); } } // Change certain WHOLE comments into RIGHT-alignable comments if (pc->GetParentType() == CT_COMMENT_WHOLE) { log_rule_B("input_tab_size"); size_t max_col = pc->GetColumnIndent() + options::input_tab_size(); // If the comment is further right than the brace level... if (pc->GetColumn() >= max_col) { LOG_FMT(LALTC, "Changing WHOLE comment on line %zu into a RIGHT-comment (col=%zu col_ind=%zu max_col=%zu)\n", pc->GetOrigLine(), pc->GetColumn(), pc->GetColumnIndent(), max_col); pc->SetFlagBits(PCF_RIGHT_COMMENT); } } } } Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { if (pc->TestFlags(PCF_RIGHT_COMMENT)) { pc = align_trailing_comments(pc); } else { pc = pc->GetNext(); } } } // align_right_comments uncrustify-uncrustify-0.76.0/src/align_trailing_comments.h000066400000000000000000000020241434072136500240630ustar00rootroot00000000000000/** * @file align_trailing_comments.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_TRAILING_COMMENTS_H_INCLUDED #define ALIGN_TRAILING_COMMENTS_H_INCLUDED #include "chunk.h" #include "ChunkStack.h" enum class comment_align_e : unsigned int { REGULAR, BRACE, ENDIF, }; /** * For a series of lines ending in a comment, align them. * The series ends when more than align_right_cmt_span newlines are found. * * Interesting info: * - least physically allowed column * - intended column * - least original cmt column * * min_col is the minimum allowed column (based on prev token col/size) * cmt_col less than * * @param start Start point * @return pointer the last item looked at */ Chunk *align_trailing_comments(Chunk *start); comment_align_e get_comment_align_type(Chunk *cmt); void align_stack(ChunkStack &cs, size_t col, bool align_single, log_sev_t sev); void align_right_comments(); #endif /* ALIGN_TRAILING_COMMENTS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_typedefs.cpp000066400000000000000000000030511434072136500225240ustar00rootroot00000000000000/** * @file align_typedefs.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_typedefs.h" #include "align_stack.h" #include "log_rules.h" constexpr static auto LCURRENT = LALTD; using namespace uncrustify; void align_typedefs(size_t span) { LOG_FUNC_ENTRY(); AlignStack as; as.Start(span); log_rule_B("align_typedef_gap"); as.m_gap = options::align_typedef_gap(); log_rule_B("align_typedef_star_style"); as.m_star_style = static_cast(options::align_typedef_star_style()); log_rule_B("align_typedef_amp_style"); as.m_amp_style = static_cast(options::align_typedef_amp_style()); Chunk *c_typedef = Chunk::NullChunkPtr; Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { if (pc->IsNewline()) { as.NewLines(pc->GetNlCount()); c_typedef = Chunk::NullChunkPtr; } else if (c_typedef->IsNotNullChunk()) { if (pc->TestFlags(PCF_ANCHOR)) { as.Add(pc); LOG_FMT(LALTD, "%s(%d): typedef @ %zu:%zu, tag '%s' @ %zu:%zu\n", __func__, __LINE__, c_typedef->GetOrigLine(), c_typedef->GetOrigCol(), pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); c_typedef = Chunk::NullChunkPtr; } } else { if (pc->Is(CT_TYPEDEF)) { c_typedef = pc; } } pc = pc->GetNext(); } as.End(); } // align_typedefs uncrustify-uncrustify-0.76.0/src/align_typedefs.h000066400000000000000000000010331434072136500221670ustar00rootroot00000000000000/** * @file align_typedefs.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_TYPEDEFS_H_INCLUDED #define ALIGN_TYPEDEFS_H_INCLUDED #include "uncrustify_types.h" /** * Aligns simple typedefs that are contained on a single line each. * This should be called after the typedef target is marked as a type. * * typedef int foo_t; * typedef char bar_t; * typedef const char cc_t; */ void align_typedefs(size_t span); #endif /* ALIGN_TYPEDEFS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/align_var_def_brace.cpp000066400000000000000000000276441434072136500234610ustar00rootroot00000000000000/** * @file align_var_def_brace.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "align_var_def_brace.h" #include "align_stack.h" #include "align_tools.h" #include "log_rules.h" constexpr static auto LCURRENT = LAVDB; using namespace uncrustify; Chunk *align_var_def_brace(Chunk *start, size_t span, size_t *p_nl_count) { LOG_FUNC_ENTRY(); if (start->IsNullChunk()) { return(nullptr); } Chunk *next; size_t myspan = span; size_t mythresh = 0; size_t mygap = 0; // Override the span, if this is a struct/union if ( start->GetParentType() == CT_STRUCT || start->GetParentType() == CT_UNION) { log_rule_B("align_var_struct_span"); myspan = options::align_var_struct_span(); log_rule_B("align_var_struct_thresh"); mythresh = options::align_var_struct_thresh(); log_rule_B("align_var_struct_gap"); mygap = options::align_var_struct_gap(); } else if (start->GetParentType() == CT_CLASS) { log_rule_B("align_var_class_span"); myspan = options::align_var_class_span(); log_rule_B("align_var_class_thresh"); mythresh = options::align_var_class_thresh(); log_rule_B("align_var_class_gap"); mygap = options::align_var_class_gap(); } else { log_rule_B("align_var_def_thresh"); mythresh = options::align_var_def_thresh(); log_rule_B("align_var_def_gap"); mygap = options::align_var_def_gap(); } // can't be any variable definitions in a "= {" block Chunk *prev = start->GetPrevNcNnl(); if (prev->Is(CT_ASSIGN)) { LOG_FMT(LAVDB, "%s(%d): start->Text() '%s', type is %s, on orig line %zu (abort due to assign)\n", __func__, __LINE__, start->Text(), get_token_name(start->GetType()), start->GetOrigLine()); Chunk *pc = start->GetNextType(CT_BRACE_CLOSE, start->GetLevel()); return(pc->GetNextNcNnl()); } char copy[1000]; LOG_FMT(LAVDB, "%s(%d): start->Text() '%s', type is %s, on orig line %zu\n", __func__, __LINE__, start->ElidedText(copy), get_token_name(start->GetType()), start->GetOrigLine()); log_rule_B("align_var_def_inline"); auto const align_mask = PCF_IN_FCN_DEF | PCF_VAR_1ST | (options::align_var_def_inline() ? PCF_NONE : PCF_VAR_INLINE); // Set up the variable/prototype/definition aligner AlignStack as; as.Start(myspan, mythresh); as.m_gap = mygap; log_rule_B("align_var_def_star_style"); as.m_star_style = static_cast(options::align_var_def_star_style()); log_rule_B("align_var_def_amp_style"); as.m_amp_style = static_cast(options::align_var_def_amp_style()); // Set up the bit colon aligner AlignStack as_bc; as_bc.Start(myspan, 0); log_rule_B("align_var_def_colon_gap"); as_bc.m_gap = options::align_var_def_colon_gap(); AlignStack as_at; // attribute as_at.Start(myspan, 0); // Set up the brace open aligner AlignStack as_br; as_br.Start(myspan, mythresh); log_rule_B("align_single_line_brace_gap"); as_br.m_gap = options::align_single_line_brace_gap(); bool fp_look_bro = false; bool did_this_line = false; log_rule_B("align_mix_var_proto"); bool fp_active = options::align_mix_var_proto(); Chunk *pc = start->GetNext(); LOG_FMT(LAVDB, "%s(%d): start->Text() is '%s', level is %zu, brace level is %zu\n", __func__, __LINE__, start->IsNewline() ? "Newline" : start->Text(), start->GetLevel(), start->GetBraceLevel()); while (pc->IsNotNullChunk()) { LOG_CHUNK(LAVDB, pc); if ( pc->GetLevel() < start->GetLevel() && pc->GetLevel() != 0 && !pc->IsPreproc()) { LOG_FMT(LAVDB, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s, PRE is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType()), pc->IsPreproc() ? "true" : "false"); break; } if (pc->IsComment()) { if (pc->GetNlCount() > 0) { as.NewLines(pc->GetNlCount()); as_bc.NewLines(pc->GetNlCount()); as_at.NewLines(pc->GetNlCount()); as_br.NewLines(pc->GetNlCount()); } pc = pc->GetNext(); LOG_FMT(LAVDB, "%s(%d): pc->Text() is '%s', level is %zu, brace level is %zu\n", __func__, __LINE__, pc->IsNewline() ? "Newline" : pc->Text(), pc->GetLevel(), pc->GetBraceLevel()); continue; } if ( fp_active && !pc->TestFlags(PCF_IN_CLASS_BASE)) { // WARNING: Duplicate from the align_func_proto() log_rule_B("align_single_line_func"); if ( pc->Is(CT_FUNC_PROTO) || ( pc->Is(CT_FUNC_DEF) && options::align_single_line_func())) { LOG_FMT(LAVDB, "%s(%d): add = '%s', orig line is %zu, orig col is %zu, level is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); Chunk *toadd; log_rule_B("align_on_operator"); if ( pc->GetParentType() == CT_OPERATOR && options::align_on_operator()) { toadd = pc->GetPrevNcNnl(); } else { toadd = pc; } as.Add(step_back_over_member(toadd)); log_rule_B("align_single_line_brace"); fp_look_bro = (pc->Is(CT_FUNC_DEF)) && options::align_single_line_brace(); } else if ( fp_look_bro && pc->Is(CT_BRACE_OPEN) && pc->TestFlags(PCF_ONE_LINER)) { as_br.Add(pc); fp_look_bro = false; } } // process nested braces if (pc->Is(CT_BRACE_OPEN)) { size_t sub_nl_count = 0; pc = align_var_def_brace(pc, span, &sub_nl_count); if (sub_nl_count > 0) { fp_look_bro = false; did_this_line = false; as.NewLines(sub_nl_count); as_bc.NewLines(sub_nl_count); as_at.NewLines(sub_nl_count); as_br.NewLines(sub_nl_count); if (p_nl_count != nullptr) { *p_nl_count += sub_nl_count; } } continue; } // Done with this brace set? if (pc->Is(CT_BRACE_CLOSE)) { pc = pc->GetNext(); LOG_FMT(LAVDB, "%s(%d): pc->Text() is '%s', level is %zu, brace level is %zu\n", __func__, __LINE__, pc->IsNewline() ? "Newline" : pc->Text(), pc->GetLevel(), pc->GetBraceLevel()); break; } if (pc->IsNewline()) { fp_look_bro = false; did_this_line = false; as.NewLines(pc->GetNlCount()); as_bc.NewLines(pc->GetNlCount()); as_at.NewLines(pc->GetNlCount()); as_br.NewLines(pc->GetNlCount()); if (p_nl_count != nullptr) { *p_nl_count += pc->GetNlCount(); } } LOG_FMT(LAVDB, "%s(%d): pc->Text() is '%s', level is %zu, brace level is %zu\n", __func__, __LINE__, pc->IsNewline() ? "Newline" : pc->Text(), pc->GetLevel(), pc->GetBraceLevel()); if (!pc->IsNewline()) { LOG_FMT(LAVDB, "%s(%d): pc orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); if (pc->IsNot(CT_IGNORED)) { LOG_FMT(LAVDB, " "); log_pcf_flags(LAVDB, pc->GetFlags()); } } // don't align stuff inside parenthesis/squares/angles if (pc->GetLevel() > pc->GetBraceLevel()) { pc = pc->GetNext(); LOG_FMT(LAVDB, "%s(%d): pc->Text() is '%s', level is %zu, brace level is %zu\n", __func__, __LINE__, pc->IsNewline() ? "Newline" : pc->Text(), pc->GetLevel(), pc->GetBraceLevel()); continue; } // If this is a variable def, update the max_col if ( !pc->TestFlags(PCF_IN_CLASS_BASE) && pc->IsNot(CT_FUNC_CLASS_DEF) && pc->IsNot(CT_FUNC_CLASS_PROTO) && ((pc->GetFlags() & align_mask) == PCF_VAR_1ST) && pc->IsNot(CT_FUNC_DEF) // Issue 1452 && ( (pc->GetLevel() == (start->GetLevel() + 1)) || pc->GetLevel() == 0) && pc->GetPrev()->IsNot(CT_MEMBER)) { LOG_FMT(LAVDB, "%s(%d): a-did_this_line is %s\n", __func__, __LINE__, did_this_line ? "TRUE" : "FALSE"); LOG_FMT(LAVDB, "%s(%d): Text() is '%s', orig line is %zu, orig col is %zu, level is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); if (!did_this_line) { if ( start->GetParentType() == CT_STRUCT && (as.m_star_style == AlignStack::SS_INCLUDE)) { // we must look after the previous token Chunk *prev_local = pc->GetPrev(); while ( prev_local->Is(CT_PTR_TYPE) || prev_local->Is(CT_ADDR)) { LOG_FMT(LAVDB, "%s(%d): prev_local '%s', prev_local->GetType() %s\n", __func__, __LINE__, prev_local->Text(), get_token_name(prev_local->GetType())); prev_local = prev_local->GetPrev(); } pc = prev_local->GetNext(); LOG_FMT(LAVDB, "%s(%d): pc->Text() is '%s', level is %zu, brace level is %zu\n", __func__, __LINE__, pc->IsNewline() ? "Newline" : pc->Text(), pc->GetLevel(), pc->GetBraceLevel()); } // we must look after the previous token Chunk *prev_local = pc->GetPrev(); if (prev_local->IsNot(CT_DEREF)) // Issue #2971 { LOG_FMT(LAVDB, "%s(%d): add = '%s', orig line is %zu, orig col is %zu, level is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); as.Add(step_back_over_member(pc)); } log_rule_B("align_var_def_colon"); if (options::align_var_def_colon()) { next = pc->GetNextNc(); LOG_FMT(LAVDB, "%s(%d): pc->Text() is '%s', level is %zu, brace level is %zu\n", __func__, __LINE__, pc->IsNewline() ? "Newline" : pc->Text(), pc->GetLevel(), pc->GetBraceLevel()); if (next->Is(CT_BIT_COLON)) { as_bc.Add(next); } } log_rule_B("align_var_def_attribute"); if (options::align_var_def_attribute()) { next = pc; while ((next = next->GetNextNc())->IsNotNullChunk()) { if (next->Is(CT_ATTRIBUTE)) { as_at.Add(next); break; } if ( next->Is(CT_SEMICOLON) || next->IsNewline()) { break; } } } } did_this_line = true; } else if (pc->Is(CT_BIT_COLON)) { if (!did_this_line) { as_bc.Add(pc); did_this_line = true; } } else { LOG_FMT(LAVDB, "%s(%d): b-did_this_line is %s\n", __func__, __LINE__, did_this_line ? "TRUE" : "FALSE"); } pc = pc->GetNext(); LOG_FMT(LAVDB, "%s(%d): pc->Text() is '%s', level is %zu, brace level is %zu\n", __func__, __LINE__, pc->IsNewline() ? "Newline" : pc->Text(), pc->GetLevel(), pc->GetBraceLevel()); } as.End(); as_bc.End(); as_at.End(); as_br.End(); return(pc); } // align_var_def_brace uncrustify-uncrustify-0.76.0/src/align_var_def_brace.h000066400000000000000000000010751434072136500231140ustar00rootroot00000000000000/** * @file align_var_def_brace.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef ALIGN_VAR_DEF_BRACE_H_INCLUDED #define ALIGN_VAR_DEF_BRACE_H_INCLUDED #include "chunk.h" /** * Scan everything at the current level until the close brace and find the * variable def align column. Also aligns bit-colons, but that assumes that * bit-types are the same! But that should always be the case... */ Chunk *align_var_def_brace(Chunk *pc, size_t span, size_t *nl_count); #endif /* ALIGN_VAR_DEF_BRACE_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/args.cpp000066400000000000000000000101001434072136500204540ustar00rootroot00000000000000/** * @file args.cpp * Parses command line arguments. * * @author Ben Gardner * @license GPL v2+ */ #include "args.h" #include "unc_ctype.h" #include Args::Args(int argc, char **argv) { m_count = argc; m_values = argv; size_t len = (argc >> 3) + 1; m_used = new UINT8[len]; if (m_used != nullptr) { memset(m_used, 0, len); } } Args::~Args() { if (m_used != nullptr) { delete[] m_used; m_used = nullptr; } m_count = 0; } bool Args::Present(const char *token) { if (token != nullptr) { for (size_t idx = 0; idx < m_count; idx++) { if (strcmp(token, m_values[idx]) == 0) { SetUsed(idx); return(true); } } } return(false); } const char *Args::Param(const char *token) { size_t idx = 0; return(Params(token, idx)); } const char *Args::Params(const char *token, size_t &index) { if (token == nullptr) { // coveralls will complain // can only occur with a call such as: arg.Param(nullptr) return(nullptr); } size_t token_len = strlen(token); for (size_t idx = index; idx < m_count; idx++) { size_t arg_len = strlen(m_values[idx]); if ( arg_len >= token_len && (memcmp(token, m_values[idx], token_len) == 0)) { SetUsed(idx); if (arg_len > token_len) { if (m_values[idx][token_len] == '=') { token_len++; } index = idx + 1; return(&m_values[idx][token_len]); } idx++; index = idx + 1; if (idx < m_count) { SetUsed(idx); return(m_values[idx]); } return(nullptr); } } return(nullptr); } // Args::Params bool Args::GetUsed(size_t idx) { if ( m_used != nullptr && idx > 0 && idx < m_count) { return((m_used[idx >> 3] & (1 << (idx & 0x07))) != 0); } return(false); } void Args::SetUsed(size_t idx) { if ( m_used != nullptr && idx > 0 && idx < m_count) { m_used[idx >> 3] |= (1 << (idx & 0x07)); } } const char *Args::Unused(size_t &index) { if (m_used == nullptr) { return(nullptr); } for (size_t idx = index; idx < m_count; idx++) { if (!GetUsed(idx)) { index = idx + 1; return(m_values[idx]); } } index = m_count; return(nullptr); } size_t Args::SplitLine(char *text, char *args[], size_t num_args) { if ( text == nullptr || num_args == 0) { return(0); } char cur_quote = 0; bool in_backslash = false; bool in_arg = false; size_t argc = 0; char *dest = text; while ( argc <= num_args // maximal number of arguments not reached yet && *text != 0) // end of string not reached yet { // Detect the start of an arg if ( !in_arg && !unc_isspace(*text)) { in_arg = true; args[argc] = dest; argc++; } if (in_arg) { if (in_backslash) { in_backslash = false; *dest = *text; dest++; } else if (*text == '\\') { in_backslash = true; } else if (*text == cur_quote) { cur_quote = 0; } else if ( (*text == '\'') || (*text == '"') || (*text == '`')) { cur_quote = *text; } else if (cur_quote != 0) { *dest = *text; dest++; } else if (unc_isspace(*text)) { *dest = 0; dest++; in_arg = false; if (argc == num_args) { break; // all arguments found, we can stop } } else { *dest = *text; dest++; } } text++; // go on with next character } *dest = 0; return(argc); } // Args::SplitLine uncrustify-uncrustify-0.76.0/src/args.h000066400000000000000000000066121434072136500201360ustar00rootroot00000000000000/** * @file args.h * Parses command line arguments. * * This differs from the GNU/getopt way in that: * - parameters cannot mixed "-e -f" is not the same as "-ef" * - knowledge of the complete set of parameters is not required * - this means you can handle args in multiple spots * - it is more portable * * @author Ben Gardner * @license GPL v2+ */ #ifndef ARGS_H_INCLUDED #define ARGS_H_INCLUDED #include "base_types.h" class Args { protected: size_t m_count; //! number of command line arguments char **m_values; //! pointer array to each argument UINT8 *m_used; //! bit array with one flag per argument public: /** * Initializes the argument library. * Store the values and allocates enough memory for the 'used' flags. * This keeps a reference to argv, so don't change it. * * @param argc number of command line parameter passed to main() * @param argv pointer array to command line parameters */ Args(int argc, char **argv); //! Standard destructor ~Args(); /** * Checks to see if an arg w/o a value is present. * Scans the args looking for an exact match. * * "-c" matches "-c", but not "-call" or "-ec" * * @param token The token string to match * * @return true/false -- Whether the argument was present */ bool Present(const char *token); /** * Calls Args::Params() with index 0 * * @param token The token string to match * * @return nullptr or the pointer to the string */ const char *Param(const char *token); /** * Check for an arg with a value. * Returns only the first match. * * Assuming the token "-c"... * "-call" returns "all" * "-c=all" returns "all" * "-c", "all" returns "all" * "-c=", "all" returns "" * * @param token the token string to match * @param[in, out] index search start position, in case that something is * found, it will get the succeeding position number * assigned * * @return nullptr or the pointer to the string */ const char *Params(const char *token, size_t &index); /** * Marks an argument as being used. * * @param idx The index of the argument */ void SetUsed(size_t idx); /** * Gets whether an argument has been used, by index. * * @param idx The index of the argument */ bool GetUsed(size_t idx); /** * This function retrieves all unused parameters. * You must set the index before the first call. * Set the index to 1 to skip argv[0]. * * @param idx Pointer to the index * * @return nullptr (done) or the pointer to the string */ const char *Unused(size_t &idx); /** * Takes text and splits it into arguments. * args is an array of char pointers that will get populated. * num_args is the maximum number of args split off. * If there are more than num_args, the remaining text is ignored. * Note that text is modified (zeroes are inserted) * * @param text the text to split (modified) * @param[out] args array of pointers to be populated * @param num_args number of items in input string * * @return The number of arguments parsed (always <= num_args) */ static size_t SplitLine(char *text, char *args[], size_t num_args); }; #endif /* ARGS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/backup.cpp000066400000000000000000000102171434072136500207760ustar00rootroot00000000000000/** * @file backup.cpp * Make a backup of a source file * The current plans are to use two files. * * - A '.unc-backup~' file that contains the original contents * - A '.unc-backup-md5~' file that contains the MD5 over the last output * that uncrustify generated * * The logic goes like this: * 1. If there isn't a .backup-md5 or the md5 over the input file doesn't * match what is in .backup-md5, then copy the source file to .backup. * * 2. Create the output file. * * 3. Calculate the md5 over the output file. * Create the .backup-md5 file. * * This will let you run uncrustify multiple times over the same file without * losing the original file. If you edit the file, then a new backup is made. * * @author Ben Gardner * @license GPL v2+ */ #include "prototypes.h" #include "backup.h" #include "md5.h" #include "unc_ctype.h" #include using namespace std; int backup_copy_file(const char *filename, const vector &data) { char newpath[1024]; char md5_str_in[33]; char md5_str[34]; UINT8 dig[16]; md5_str_in[0] = 0; MD5::Calc(data.data(), data.size(), dig); snprintf(md5_str, sizeof(md5_str), "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", dig[0], dig[1], dig[2], dig[3], dig[4], dig[5], dig[6], dig[7], dig[8], dig[9], dig[10], dig[11], dig[12], dig[13], dig[14], dig[15]); // Create the backup-md5 filename, open it and read the md5 snprintf(newpath, sizeof(newpath), "%s%s", filename, UNC_BACKUP_MD5_SUFFIX); FILE *thefile = fopen(newpath, "rb"); if (thefile != nullptr) { char buffer[128]; if (fgets(buffer, sizeof(buffer), thefile) != nullptr) { for (int i = 0; buffer[i] != 0; i++) { if (unc_isxdigit(buffer[i])) { md5_str_in[i] = unc_tolower(buffer[i]); } else { md5_str_in[i] = 0; break; } } } fclose(thefile); } // if the MD5s match, then there is no need to back up the file if (memcmp(md5_str, md5_str_in, 32) == 0) { LOG_FMT(LNOTE, "%s: MD5 match for %s\n", __func__, filename); return(EX_OK); } LOG_FMT(LNOTE, "%s: MD5 mismatch - backing up %s\n", __func__, filename); // Create the backup file snprintf(newpath, sizeof(newpath), "%s%s", filename, UNC_BACKUP_SUFFIX); thefile = fopen(newpath, "wb"); if (thefile != nullptr) { size_t retval = fwrite(data.data(), data.size(), 1, thefile); int my_errno = errno; fclose(thefile); if ( retval == 1 || data.empty()) { return(EX_OK); } LOG_FMT(LERR, "fwrite(%s) failed: %s (%d)\n", newpath, strerror(my_errno), my_errno); exit(EX_SOFTWARE); } else { LOG_FMT(LERR, "fopen(%s) failed: %s (%d)\n", newpath, strerror(errno), errno); exit(EX_SOFTWARE); } return(EX_IOERR); } // backup_copy_file void backup_create_md5_file(const char *filename) { UINT8 dig[16]; MD5 md5; FILE *thefile; UINT8 buf[4096]; size_t len; char newpath[1024]; md5.Init(); thefile = fopen(filename, "rb"); if (thefile == nullptr) { LOG_FMT(LERR, "%s: fopen(%s) failed: %s (%d)\n", __func__, filename, strerror(errno), errno); exit(EX_SOFTWARE); } // read file chunk by chunk and calculate its MD5 checksum while ((len = fread(buf, 1, sizeof(buf), thefile)) > 0) { md5.Update(buf, len); } fclose(thefile); md5.Final(dig); snprintf(newpath, sizeof(newpath), "%s%s", filename, UNC_BACKUP_MD5_SUFFIX); thefile = fopen(newpath, "wb"); if (thefile != nullptr) { fprintf(thefile, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x %s\n", dig[0], dig[1], dig[2], dig[3], dig[4], dig[5], dig[6], dig[7], dig[8], dig[9], dig[10], dig[11], dig[12], dig[13], dig[14], dig[15], path_basename(filename)); fclose(thefile); } } // backup_create_md5_file uncrustify-uncrustify-0.76.0/src/backup.h000066400000000000000000000036261434072136500204510ustar00rootroot00000000000000/** * @file backup.h * Handles backing up file data. * * It works like this: * * 1. Read in the file data * * 2. Call backup_copy_file() to create a backup of the input, if needed * * 3. Do the uncrustify magic and write the output file * * 4. Call backup_create_md5_file() * * This will let you run uncrustify multiple times over the same file without * losing the original file. If you edit the file, then a new backup is made. * * @author Ben Gardner * @license GPL v2+ */ #ifndef BACKUP_H_INCLUDED #define BACKUP_H_INCLUDED #include "base_types.h" #include #define UNC_BACKUP_SUFFIX ".unc-backup~" #define UNC_BACKUP_MD5_SUFFIX ".unc-backup.md5~" /** * @brief Check the backup-md5 file and copy the input file to a backup if needed. * * If there isn't a FILENAME+UNC_BACKUP_MD5_SUFFIX or the md5 over the data * doesn't match what is in FILENAME+UNC_BACKUP_MD5_SUFFIX, then write the * data to FILENAME+UNC_BACKUP_SUFFIX. * * Note that if this fails, we shouldn't overwrite to original file with the * output. * * @param filename The file that was read (full path) * @param file_data The file data * @param file_len The file length * * @retval EX_OK successfully created backup file * @retval EX_IOERR could not create backup file */ int backup_copy_file(const char *filename, const std::vector &data); /** * This calculates the MD5 over the file and writes the MD5 to * FILENAME+UNC_BACKUP_MD5_SUFFIX.* * This should be called after the file was written to disk. * We really don't care if it fails, as the MD5 just prevents us from backing * up a file that uncrustify created. * * This should be called after the file was written to disk. * It will be read back and an md5 will be calculated over it. * * @param filename The file that was written (full path) */ void backup_create_md5_file(const char *filename); #endif /* BACKUP_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/base_types.h000066400000000000000000000015751434072136500213430ustar00rootroot00000000000000/** * @file base_types.h * * Defines some base types, includes config.h * * @author Ben Gardner * @license GPL v2+ */ #ifndef BASE_TYPES_H_INCLUDED #define BASE_TYPES_H_INCLUDED #include "error_types.h" #ifdef WIN32 #include "windows_compat.h" #else // not WIN32 #include "config.h" #define PATH_SEP '/' #define __STDC_FORMAT_MACROS #if defined HAVE_INTTYPES_H #include #else #error "Don't know where int8_t is defined" #endif // some of my favorite aliases typedef char CHAR; typedef int8_t INT8; typedef int16_t INT16; typedef int32_t INT32; typedef uint8_t UINT8; typedef uint16_t UINT16; typedef uint32_t UINT32; typedef uint64_t UINT64; #endif /* ifdef WIN32 */ // and the ever-so-important array size macro #ifndef ARRAY_SIZE #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) #endif #endif /* BASE_TYPES_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/brace_cleanup.cpp000066400000000000000000001320451434072136500223200ustar00rootroot00000000000000/** * @file brace_cleanup.cpp * Determines the brace level and paren level. * Inserts virtual braces as needed. * Handles all that preprocessor stuff. * * @author Ben Gardner * @license GPL v2+ */ #include "brace_cleanup.h" #include "flag_parens.h" #include "frame_list.h" #include "keywords.h" #include "lang_pawn.h" #include "prototypes.h" #include // to get std::invalid_argument constexpr static auto LCURRENT = LBC; using namespace uncrustify; using std::invalid_argument; using std::string; using std::to_string; using std::stringstream; /* * abbreviations used: * - sparen = tbd * - PS = Parenthesis Stack * - pse = Parenthesis Stack */ struct BraceState { std::vector frames = {}; E_Token in_preproc = CT_NONE; int pp_level = 0; bool consumed = false; }; /** * Called when a statement was just closed and the pse_tos was just * decremented. * * - if the TOS is now VBRACE, insert a CT_VBRACE_CLOSE and recurse. * - if the TOS is a complex statement, call handle_complex_close() * * @retval true done with this chunk * @retval false keep processing */ static bool close_statement(ParseFrame &frm, Chunk *pc, const BraceState &braceState); static size_t preproc_start(BraceState &braceState, ParseFrame &frm, Chunk *pc); static void print_stack(log_sev_t logsev, const char *str, const ParseFrame &frm); /** * pc is a CT_WHILE. * Scan backwards to see if we find a brace/vbrace with the parent set to CT_DO */ static bool maybe_while_of_do(Chunk *pc); /** * @param after determines: true - insert_vbrace_close_after(pc, frm) * false - insert_vbrace_open_before(pc, frm) */ static Chunk *insert_vbrace(Chunk *pc, bool after, const ParseFrame &frm); #define insert_vbrace_close_after(pc, frm) insert_vbrace(pc, true, frm) #define insert_vbrace_open_before(pc, frm) insert_vbrace(pc, false, frm) static void parse_cleanup(BraceState &braceState, ParseFrame &frm, Chunk *pc); /** * Checks the progression of complex statements. * - checks for else after if * - checks for if after else * - checks for while after do * - checks for open brace in BRACE2 and BRACE_DO stages, inserts open VBRACE * - checks for open paren in PAREN1 and BRACE2 stages, complains * * @param frm The parse frame * @param pc The current chunk * * @return true - done with this chunk, false - keep processing */ static bool check_complex_statements(ParseFrame &frm, Chunk *pc, const BraceState &braceState); /** * Handles a close paren or brace - just progress the stage, if the end * of the statement is hit, call close_statement() * * @param frm The parse frame * @param pc The current chunk * * @return true - done with this chunk, false - keep processing */ static bool handle_complex_close(ParseFrame &frm, Chunk *pc, const BraceState &braceState); //! We're on a 'namespace' skip the word and then set the parent of the braces. static void mark_namespace(Chunk *pns); static size_t preproc_start(BraceState &braceState, ParseFrame &frm, Chunk *pc) { LOG_FUNC_ENTRY(); const size_t pp_level = braceState.pp_level; Chunk *next = pc->GetNextNcNnl(); if (next->IsNullChunk()) { return(pp_level); } // Get the type of preprocessor and handle it braceState.in_preproc = next->GetType(); // If we are not in a define, check for #if, #else, #endif, etc if (braceState.in_preproc != CT_PP_DEFINE) { int pp_indent = fl_check(braceState.frames, frm, braceState.pp_level, pc); return(pp_indent); } // else push the frame stack fl_push(braceState.frames, frm); // a preproc body starts a new, blank frame frm = {}; frm.level = 1; frm.brace_level = 1; // TODO: not sure about the next 3 lines frm.push(nullptr); frm.top().type = CT_PP_DEFINE; return(pp_level); } static void print_stack(log_sev_t logsev, const char *str, const ParseFrame &frm) { LOG_FUNC_ENTRY(); if (!log_sev_on(logsev)) { return; } log_fmt(logsev, "%s(%d): str is '%s'", __func__, __LINE__, str); for (size_t idx = 1; idx < frm.size(); idx++) { if (frm.at(idx).stage != brace_stage_e::NONE) { LOG_FMT(logsev, " [%s - %u]", get_token_name(frm.at(idx).type), (unsigned int)frm.at(idx).stage); } else { LOG_FMT(logsev, " [%s]", get_token_name(frm.at(idx).type)); } } log_fmt(logsev, "\n"); } //TODO: This can be cleaned up and simplified - we can look both forward and backward! void brace_cleanup() { LOG_FUNC_ENTRY(); BraceState braceState; ParseFrame frm{}; Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { LOG_CHUNK(LTOK, pc); // Check for leaving a #define body if ( braceState.in_preproc != CT_NONE && !pc->TestFlags(PCF_IN_PREPROC)) { if (braceState.in_preproc == CT_PP_DEFINE) { // out of the #define body, restore the frame size_t brace_level = frm.brace_level; if ( options::pp_warn_unbalanced_if() && brace_level != 1) { LOG_FMT(LWARN, "%s(%d): orig line is %zu, unbalanced #define block braces, out-level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), brace_level); } fl_pop(braceState.frames, frm); } braceState.in_preproc = CT_NONE; } // Check for a preprocessor start size_t pp_level; if (pc->Is(CT_PREPROC)) { pp_level = preproc_start(braceState, frm, pc); } else { pp_level = braceState.pp_level; } LOG_FMT(LTOK, "%s(%d): pp level is %zu\n", __func__, __LINE__, pp_level); // Do before assigning stuff from the frame if ( language_is_set(LANG_PAWN) && frm.top().type == CT_VBRACE_OPEN && pc->Is(CT_NEWLINE)) { pc = pawn_check_vsemicolon(pc); if (pc == nullptr) { return; } } // Issue #1813 if (pc->Is(CT_NAMESPACE)) { mark_namespace(pc); } // Assume the level won't change pc->SetLevel(frm.level); pc->SetBraceLevel(frm.brace_level); pc->SetPpLevel(pp_level); /* * #define bodies get the full formatting treatment * Also need to pass in the initial '#' to close out any virtual braces. */ if ( !pc->IsCommentOrNewline() && !pc->Is(CT_ATTRIBUTE) && !pc->Is(CT_IGNORED) // Issue #2279 && ( braceState.in_preproc == CT_PP_DEFINE || braceState.in_preproc == CT_NONE)) { braceState.consumed = false; parse_cleanup(braceState, frm, pc); print_stack(LBCSAFTER, (pc->Is(CT_VBRACE_CLOSE)) ? "Virt-}\n" : pc->GetStr().c_str(), frm); } pc = pc->GetNext(); } } // brace_cleanup static bool maybe_while_of_do(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *prev = pc->GetPrevNcNnl(); if ( prev->IsNullChunk() || !prev->TestFlags(PCF_IN_PREPROC)) { return(false); } // Find the chunk before the preprocessor while ( prev->IsNullChunk() && prev->TestFlags(PCF_IN_PREPROC)) { prev = prev->GetPrevNcNnl(); } if ( ( prev->Is(CT_VBRACE_CLOSE) || prev->Is(CT_BRACE_CLOSE)) && prev->GetParentType() == CT_DO) { return(true); } return(false); } /** * At the heart of this algorithm are two stacks. * There is the Paren Stack (PS) and the Frame stack. * * The PS (pse in the code) keeps track of braces, parens, * if/else/switch/do/while/etc items -- anything that is nestable. * Complex statements go through stages. * Take this simple if statement as an example: * if ( x ) { x--; } * * The stack would change like so: 'token' stack afterwards * 'if' [IF - 1] * '(' [IF - 1] [PAREN OPEN] * 'x' [IF - 1] [PAREN OPEN] * ')' [IF - 2] <- note that the state was incremented * '{' [IF - 2] [BRACE OPEN] * 'x' [IF - 2] [BRACE OPEN] * '--' [IF - 2] [BRACE OPEN] * ';' [IF - 2] [BRACE OPEN] * '}' [IF - 3] * <- lack of else kills the IF, closes statement * * Virtual braces example: * if ( x ) x--; else x++; * * 'if' [IF - 1] * '(' [IF - 1] [PAREN OPEN] * 'x' [IF - 1] [PAREN OPEN] * ')' [IF - 2] * 'x' [IF - 2] [VBRACE OPEN] <- VBrace open inserted before because '{' was not next * '--' [IF - 2] [VBRACE OPEN] * ';' [IF - 3] <- VBrace close inserted after semicolon * 'else' [ELSE - 0] <- IF changed into ELSE * 'x' [ELSE - 0] [VBRACE OPEN] <- lack of '{' -> VBrace * '++' [ELSE - 0] [VBRACE OPEN] * ';' [ELSE - 0] <- VBrace close inserted after semicolon * <- ELSE removed after statement close * * The pse stack is kept on a frame stack. * The frame stack is need for languages that support preprocessors (C, C++, C#) * that can arbitrarily change code flow. It also isolates #define macros so * that they are indented independently and do not affect the rest of the program. * * When an #if is hit, a copy of the current frame is push on the frame stack. * When an #else/#elif is hit, a copy of the current stack is pushed under the * #if frame and the original (pre-#if) frame is copied to the current frame. * When #endif is hit, the top frame is popped. * This has the following effects: * - a simple #if / #endif does not affect program flow * - #if / #else /#endif - continues from the #if clause * * When a #define is entered, the current frame is pushed and cleared. * When a #define is exited, the frame is popped. */ static void parse_cleanup(BraceState &braceState, ParseFrame &frm, Chunk *pc) { LOG_FUNC_ENTRY(); LOG_FMT(LTOK, "%s(%d): orig line is %zu, orig col is %zu, type is %s, tos is %zu, TOS.type is %s, TOS.stage is %s, ", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), frm.size() - 1, get_token_name(frm.top().type), get_brace_stage_name(frm.top().stage)); log_pcf_flags(LTOK, pc->GetFlags()); // Mark statement starts LOG_FMT(LTOK, "%s(%d): orig line is %zu, type is %s, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetType()), pc->Text()); LOG_FMT(LTOK, "%s(%d): frm.stmt_count is %zu, frm.expr_count is %zu\n", __func__, __LINE__, frm.stmt_count, frm.expr_count); if ( ( frm.stmt_count == 0 || frm.expr_count == 0) && !pc->IsSemicolon() && pc->IsNot(CT_BRACE_CLOSE) && pc->IsNot(CT_VBRACE_CLOSE) && !pc->IsString(")") && !pc->IsString("]")) { pc->SetFlagBits(PCF_EXPR_START | ((frm.stmt_count == 0) ? PCF_STMT_START : PCF_NONE)); LOG_FMT(LSTMT, "%s(%d): orig line is %zu, 1.marked '%s' as %s, start stmt_count is %zu, expr_count is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->Text(), pc->TestFlags(PCF_STMT_START) ? "stmt" : "expr", frm.stmt_count, frm.expr_count); } frm.stmt_count++; frm.expr_count++; LOG_FMT(LTOK, "%s(%d): frm.stmt_count is %zu, frm.expr_count is %zu\n", __func__, __LINE__, frm.stmt_count, frm.expr_count); if (frm.sparen_count > 0) { pc->SetFlagBits(PCF_IN_SPAREN); // Mark everything in the for statement for (int tmp = static_cast(frm.size()) - 2; tmp >= 0; tmp--) { if (frm.at(tmp).type == CT_FOR) { pc->SetFlagBits(PCF_IN_FOR); break; } } // Mark the parent on semicolons in for() statements if ( pc->Is(CT_SEMICOLON) && frm.size() > 2 && frm.prev().type == CT_FOR) { pc->SetParentType(CT_FOR); } } // Check the progression of complex statements if ( frm.top().stage != brace_stage_e::NONE && !pc->Is(CT_AUTORELEASEPOOL) && check_complex_statements(frm, pc, braceState)) { return; } /* * Check for a virtual brace statement close due to a semicolon. * The virtual brace will get handled the next time through. * The semicolon isn't handled at all. * TODO: may need to float VBRACE past comments until newline? */ if (frm.top().type == CT_VBRACE_OPEN) { if (pc->IsSemicolon()) { braceState.consumed = true; close_statement(frm, pc, braceState); } else if ( language_is_set(LANG_PAWN) && pc->Is(CT_BRACE_CLOSE)) { close_statement(frm, pc, braceState); } else if ( language_is_set(LANG_D) && pc->Is(CT_BRACE_CLOSE)) { close_statement(frm, pc, braceState); } } // Handle close parenthesis, vbrace, brace, and square if ( pc->Is(CT_PAREN_CLOSE) || pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_VBRACE_CLOSE) || pc->Is(CT_ANGLE_CLOSE) || pc->Is(CT_MACRO_CLOSE) || pc->Is(CT_SQUARE_CLOSE)) { // Change CT_PAREN_CLOSE into CT_SPAREN_CLOSE or CT_FPAREN_CLOSE if ( pc->Is(CT_PAREN_CLOSE) && ( (frm.top().type == CT_FPAREN_OPEN) || (frm.top().type == CT_SPAREN_OPEN))) { // TODO: fix enum hack pc->SetType(static_cast(frm.top().type + 1)); if (pc->Is(CT_SPAREN_CLOSE)) { frm.sparen_count--; pc->ResetFlagBits(PCF_IN_SPAREN); } } // Make sure the open / close match if (pc->IsNot((E_Token)(frm.top().type + 1))) { if (pc->TestFlags(PCF_IN_PREPROC)) // Issue #3113, #3283 { // do nothing } else { LOG_FMT(LWARN, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); paren_stack_entry_t AA = frm.top(); // Issue #3055 if (AA.type != CT_EOF) { LOG_FMT(LWARN, "%s(%d): (frm.top().type + 1) is %s\n", __func__, __LINE__, get_token_name((E_Token)(frm.top().type + 1))); } if ( frm.top().type != CT_EOF && frm.top().type != CT_PP_DEFINE) { LOG_FMT(LWARN, "%s(%d): File: %s, orig line is %zu, orig col is %zu, Error: Unexpected '%s' for '%s', which was on line %zu\n", __func__, __LINE__, cpd.filename.c_str(), pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(frm.top().pc->GetType()), frm.top().pc->GetOrigLine()); print_stack(LBCSPOP, "=Error ", frm); exit(EXIT_FAILURE); } } } else { braceState.consumed = true; // Copy the parent, update the parenthesis/brace levels pc->SetParentType(frm.top().parent); frm.level--; if ( pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_VBRACE_CLOSE) || pc->Is(CT_MACRO_CLOSE)) { frm.brace_level--; LOG_FMT(LBCSPOP, "%s(%d): frm.brace_level decreased to %zu", __func__, __LINE__, frm.brace_level); log_pcf_flags(LBCSPOP, pc->GetFlags()); } pc->SetLevel(frm.level); pc->SetBraceLevel(frm.brace_level); // Pop the entry LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-Close ", frm); if ( frm.top().stage == brace_stage_e::NONE && ( pc->Is(CT_VBRACE_CLOSE) || pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_SEMICOLON)) && frm.top().pc->Is(CT_VBRACE_OPEN)) { // frames for functions are not created as they are for an if // this here is a hackish solution to close a vbrace of a block that // contains the function frm.push(nullptr); // <- dummy frame for the function frm.top().stage = brace_stage_e::BRACE2; } // See if we are in a complex statement if (frm.top().stage != brace_stage_e::NONE) { handle_complex_close(frm, pc, braceState); } } } /* * In this state, we expect a semicolon, but we'll also hit the closing * sparen, so we need to check braceState.consumed to see if the close sparen * was already handled. */ if (frm.top().stage == brace_stage_e::WOD_SEMI) { if (braceState.consumed) { /* * If consumed, then we are on the close sparen. * PAWN: Check the next chunk for a semicolon. If it isn't, then * add a virtual semicolon, which will get handled on the next pass. */ if (language_is_set(LANG_PAWN)) { Chunk *tmp = pc->GetNextNcNnl(); if (!tmp->IsSemicolon()) { pawn_add_vsemi_after(pc); } } } else { // Complain if this ISN'T a semicolon, but close out WHILE_OF_DO anyway if (pc->IsSemicolon()) { braceState.consumed = true; pc->SetParentType(CT_WHILE_OF_DO); } else { LOG_FMT(LWARN, "%s: %s(%d): %zu: Error: Expected a semicolon for WHILE_OF_DO, but got '%s'\n", cpd.filename.c_str(), __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetType())); exit(EX_SOFTWARE); } handle_complex_close(frm, pc, braceState); } } // Get the parent type for brace and parenthesis open E_Token parentType = pc->GetParentType(); if ( pc->Is(CT_PAREN_OPEN) || pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_SPAREN_OPEN) || pc->Is(CT_BRACE_OPEN)) { Chunk *prev = pc->GetPrevNcNnl(); if (prev->IsNotNullChunk()) { if ( pc->Is(CT_PAREN_OPEN) || pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_SPAREN_OPEN)) { // Set the parent for parenthesis and change parenthesis type if ( prev->Is(CT_IF) || prev->Is(CT_CONSTEXPR) || prev->Is(CT_ELSEIF) || prev->Is(CT_WHILE) || prev->Is(CT_WHILE_OF_DO) || prev->Is(CT_DO) || prev->Is(CT_FOR) || prev->Is(CT_SWITCH) || prev->Is(CT_CATCH) || prev->Is(CT_SYNCHRONIZED) || prev->Is(CT_D_VERSION) || prev->Is(CT_D_VERSION_IF) || prev->Is(CT_D_SCOPE) || prev->Is(CT_D_SCOPE_IF)) { pc->SetType(CT_SPAREN_OPEN); parentType = frm.top().type; frm.sparen_count++; } else if (prev->Is(CT_FUNCTION)) { pc->SetType(CT_FPAREN_OPEN); parentType = CT_FUNCTION; } // NS_ENUM and NS_OPTIONS are followed by a (type, name) pair else if ( prev->Is(CT_ENUM) && language_is_set(LANG_OC)) { // Treat both as CT_ENUM since the syntax is identical pc->SetType(CT_FPAREN_OPEN); parentType = CT_ENUM; } else if (prev->Is(CT_DECLSPEC)) // Issue 1289 { parentType = CT_DECLSPEC; } // else: no need to set parent } else // must be CT_BRACE_OPEN { // Set the parent for open braces if (frm.top().stage != brace_stage_e::NONE) { parentType = frm.top().type; } else if ( prev->Is(CT_ASSIGN) && (prev->GetStr()[0] == '=')) { parentType = CT_ASSIGN; } else if ( prev->Is(CT_RETURN) && language_is_set(LANG_CPP)) { parentType = CT_RETURN; } // Carry through CT_ENUM parent in NS_ENUM (type, name) { // only to help the vim command } else if ( prev->Is(CT_FPAREN_CLOSE) && language_is_set(LANG_OC) && prev->GetParentType() == CT_ENUM) { parentType = CT_ENUM; } else if (prev->Is(CT_FPAREN_CLOSE)) { parentType = CT_FUNCTION; } // else: no need to set parent } } } /* * Adjust the level for opens & create a stack entry * Note that CT_VBRACE_OPEN has already been handled. */ if ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_PAREN_OPEN) || pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_SPAREN_OPEN) || pc->Is(CT_ANGLE_OPEN) || pc->Is(CT_MACRO_OPEN) || pc->Is(CT_SQUARE_OPEN)) { frm.level++; if ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_MACRO_OPEN)) { // Issue #1813 bool single = false; if (pc->GetParentType() == CT_NAMESPACE) { LOG_FMT(LBCSPOP, "%s(%d): parent type is NAMESPACE\n", __func__, __LINE__); Chunk *tmp = frm.top().pc; if ( tmp != nullptr && tmp->GetParentType() == CT_NAMESPACE) { LOG_FMT(LBCSPOP, "%s(%d): tmp->GetParentType() is NAMESPACE\n", __func__, __LINE__); log_rule_B("indent_namespace"); log_rule_B("indent_namespace_single_indent"); if ( options::indent_namespace() && options::indent_namespace_single_indent()) { LOG_FMT(LBCSPOP, "%s(%d): Options are SINGLE\n", __func__, __LINE__); single = true; } } } LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s, parent type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); if (!single) { frm.brace_level++; LOG_FMT(LBCSPOP, "%s(%d): frm.brace_level increased to %zu\n", __func__, __LINE__, frm.brace_level); } } frm.push(pc, __func__, __LINE__); frm.top().parent = parentType; pc->SetParentType(parentType); } // Issue #2281 if ( pc->Is(CT_BRACE_OPEN) && pc->GetParentType() == CT_SWITCH) { size_t idx = frm.size(); LOG_FMT(LBCSPOP, "%s(%d): idx is %zu\n", __func__, __LINE__, idx); Chunk *saved = frm.at(idx - 2).pc; if (saved != nullptr) { // set parent member pc->SetParent(saved); } } if ( pc->Is(CT_CASE) || pc->Is(CT_DEFAULT)) { Chunk *prev = pc->GetPrevNcNnl(); // Issue #3176 if ( pc->Is(CT_CASE) || ( pc->Is(CT_DEFAULT) && prev->IsNot(CT_ASSIGN))) { // it is a CT_DEFAULT from a switch LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); pc->SetParentType(CT_SWITCH); size_t idx = frm.size(); LOG_FMT(LBCSPOP, "%s(%d): idx is %zu\n", __func__, __LINE__, idx); Chunk *saved = frm.at(idx - 2).pc; if (saved != nullptr) { // set parent member pc->SetParent(saved); } } } if (pc->Is(CT_BREAK)) { LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); size_t idx = frm.size(); LOG_FMT(LBCSPOP, "%s(%d): idx is %zu\n", __func__, __LINE__, idx); Chunk *saved = frm.at(idx - 2).pc; if (saved != nullptr) { // set parent member pc->SetParent(saved); } } const pattern_class_e patcls = get_token_pattern_class(pc->GetType()); /* * Create a stack entry for complex statements: * if, elseif, switch, for, while, synchronized, using, lock, with, * version, CT_D_SCOPE_IF */ if (patcls == pattern_class_e::BRACED) { frm.push(pc, __func__, __LINE__, (pc->Is(CT_DO) ? brace_stage_e::BRACE_DO : brace_stage_e::BRACE2)); // "+ComplexBraced" } else if (patcls == pattern_class_e::PBRACED) { brace_stage_e bs = brace_stage_e::PAREN1; if ( pc->Is(CT_WHILE) && maybe_while_of_do(pc)) { pc->SetType(CT_WHILE_OF_DO); bs = brace_stage_e::WOD_PAREN; } frm.push(pc, __func__, __LINE__, bs); // "+ComplexParenBraced" } else if (patcls == pattern_class_e::OPBRACED) { frm.push(pc, __func__, __LINE__, brace_stage_e::OP_PAREN1); // "+ComplexOpParenBraced"); } else if (patcls == pattern_class_e::ELSE) { frm.push(pc, __func__, __LINE__, brace_stage_e::ELSEIF); // "+ComplexElse"); } /* * Mark simple statement/expression starts * - after { or } * - after ';', but not if the paren stack top is a paren * - after '(' that has a parent type of CT_FOR */ if ( pc->Is(CT_SQUARE_OPEN) || ( pc->Is(CT_BRACE_OPEN) && pc->GetParentType() != CT_ASSIGN) || pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_VBRACE_CLOSE) || ( pc->Is(CT_SPAREN_OPEN) && pc->GetParentType() == CT_FOR) || pc->Is(CT_COLON) || pc->Is(CT_OC_END) || ( pc->IsSemicolon() && frm.top().type != CT_PAREN_OPEN && frm.top().type != CT_FPAREN_OPEN && frm.top().type != CT_SPAREN_OPEN) || pc->Is(CT_MACRO)) // Issue #2742 { LOG_FMT(LSTMT, "%s(%d): orig line is %zu, reset1 stmt on '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->Text()); frm.stmt_count = 0; frm.expr_count = 0; LOG_FMT(LTOK, "%s(%d): frm.stmt_count is %zu, frm.expr_count is %zu\n", __func__, __LINE__, frm.stmt_count, frm.expr_count); } // Mark expression starts LOG_FMT(LSTMT, "%s(%d): Mark expression starts: orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); Chunk *tmp = pc->GetNextNcNnl(); if ( pc->Is(CT_ARITH) || pc->Is(CT_SHIFT) || pc->Is(CT_ASSIGN) || pc->Is(CT_CASE) || pc->Is(CT_COMPARE) || ( pc->Is(CT_STAR) && tmp->IsNot(CT_STAR)) || pc->Is(CT_BOOL) || pc->Is(CT_MINUS) || pc->Is(CT_PLUS) || pc->Is(CT_CARET) || pc->Is(CT_ANGLE_OPEN) || pc->Is(CT_ANGLE_CLOSE) || pc->Is(CT_RETURN) || pc->Is(CT_THROW) || pc->Is(CT_GOTO) || pc->Is(CT_CONTINUE) || pc->Is(CT_PAREN_OPEN) || pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_SPAREN_OPEN) || pc->Is(CT_BRACE_OPEN) || pc->IsSemicolon() || pc->Is(CT_COMMA) || pc->Is(CT_NOT) || pc->Is(CT_INV) || pc->Is(CT_COLON) || pc->Is(CT_QUESTION)) { frm.expr_count = 0; LOG_FMT(LSTMT, "%s(%d): orig line is %zu, orig col is %zu, reset expr on '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); } } // parse_cleanup static bool check_complex_statements(ParseFrame &frm, Chunk *pc, const BraceState &braceState) { LOG_FUNC_ENTRY(); brace_stage_e atest = frm.top().stage; LOG_FMT(LBCSPOP, "%s(%d): atest is %s\n", __func__, __LINE__, get_brace_stage_name(atest)); // Turn an optional parenthesis into either a real parenthesis or a brace if (frm.top().stage == brace_stage_e::OP_PAREN1) { frm.top().stage = (pc->IsNot(CT_PAREN_OPEN)) ? brace_stage_e::BRACE2 : brace_stage_e::PAREN1; LOG_FMT(LBCSPOP, "%s(%d): frm.top().stage is now %s\n", __func__, __LINE__, get_brace_stage_name(frm.top().stage)); } // Check for CT_ELSE after CT_IF while (frm.top().stage == brace_stage_e::ELSE) { if (pc->Is(CT_ELSE)) { // Replace CT_IF with CT_ELSE on the stack & we are done frm.top().type = CT_ELSE; frm.top().stage = brace_stage_e::ELSEIF; print_stack(LBCSSWAP, "=Swap ", frm); return(true); } // Remove the CT_IF and close the statement LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-IF-CCS ", frm); if (close_statement(frm, pc, braceState)) { return(true); } } // Check for CT_IF after CT_ELSE if (frm.top().stage == brace_stage_e::ELSEIF) { log_rule_B("indent_else_if"); if ( pc->Is(CT_IF) && ( !options::indent_else_if() || !pc->GetPrevNc()->IsNewline())) { // Replace CT_ELSE with CT_IF pc->SetType(CT_ELSEIF); frm.top().type = CT_ELSEIF; frm.top().stage = brace_stage_e::PAREN1; return(true); } // Jump to the 'expecting brace' stage frm.top().stage = brace_stage_e::BRACE2; } // Check for CT_CATCH or CT_FINALLY after CT_TRY or CT_CATCH while (frm.top().stage == brace_stage_e::CATCH) { if ( pc->Is(CT_CATCH) || pc->Is(CT_FINALLY)) { // Replace CT_TRY with CT_CATCH or CT_FINALLY on the stack & we are done frm.top().type = pc->GetType(); if (language_is_set(LANG_CS)) { frm.top().stage = (pc->Is(CT_CATCH)) ? brace_stage_e::CATCH_WHEN : brace_stage_e::BRACE2; } else { // historically this used OP_PAREN1; however, to my knowledge the expression after a catch clause // is only optional for C# which has been handled above; therefore, this should now always expect // a parenthetical expression after the catch keyword and brace after the finally keyword frm.top().stage = (pc->Is(CT_CATCH)) ? brace_stage_e::PAREN1 : brace_stage_e::BRACE2; } print_stack(LBCSSWAP, "=Swap ", frm); return(true); } // Remove the CT_TRY and close the statement LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-TRY-CCS ", frm); if (close_statement(frm, pc, braceState)) { return(true); } } // Check for optional parenthesis and optional CT_WHEN after CT_CATCH if (frm.top().stage == brace_stage_e::CATCH_WHEN) { if (pc->Is(CT_PAREN_OPEN)) // this is for the paren after "catch" { // Replace CT_PAREN_OPEN with CT_SPAREN_OPEN pc->SetType(CT_SPAREN_OPEN); frm.top().type = pc->GetType(); frm.top().stage = brace_stage_e::PAREN1; return(false); } if (pc->Is(CT_WHEN)) { frm.top().type = pc->GetType(); frm.top().stage = brace_stage_e::OP_PAREN1; return(true); } if (pc->Is(CT_BRACE_OPEN)) { frm.top().stage = brace_stage_e::BRACE2; return(false); } } // Check for CT_WHILE after the CT_DO if (frm.top().stage == brace_stage_e::WHILE) { if (pc->Is(CT_WHILE)) { pc->SetType(CT_WHILE_OF_DO); frm.top().type = CT_WHILE_OF_DO; //CT_WHILE; frm.top().stage = brace_stage_e::WOD_PAREN; return(true); } LOG_FMT(LWARN, "%s(%d): %s, orig line is %zu, Error: Expected 'while', got '%s'\n", __func__, __LINE__, cpd.filename.c_str(), pc->GetOrigLine(), pc->Text()); LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-Error ", frm); exit(EX_SOFTWARE); } // Insert a CT_VBRACE_OPEN, if needed // but not in a preprocessor atest = frm.top().stage; if ( pc->IsNot(CT_BRACE_OPEN) && !pc->TestFlags(PCF_IN_PREPROC) && ( (frm.top().stage == brace_stage_e::BRACE2) || (frm.top().stage == brace_stage_e::BRACE_DO))) { log_rule_B("indent_using_block"); if ( language_is_set(LANG_CS) && pc->Is(CT_USING_STMT) && (!options::indent_using_block())) { // don't indent the using block } else { const E_Token parentType = frm.top().type; Chunk *vbrace = insert_vbrace_open_before(pc, frm); vbrace->SetParentType(parentType); frm.level++; frm.brace_level++; LOG_FMT(LBCSPOP, "%s(%d): frm.brace_level increased to %zu\n", __func__, __LINE__, frm.brace_level); log_pcf_flags(LBCSPOP, pc->GetFlags()); frm.push(vbrace, __func__, __LINE__, brace_stage_e::NONE); // "+VBrace"); frm.top().parent = parentType; // update the level of pc pc->SetLevel(frm.level); pc->SetBraceLevel(frm.brace_level); // Mark as a start of a statement frm.stmt_count = 0; frm.expr_count = 0; LOG_FMT(LTOK, "%s(%d): frm.stmt_count is %zu, frm.expr_count is %zu\n", __func__, __LINE__, frm.stmt_count, frm.expr_count); pc->SetFlagBits(PCF_STMT_START | PCF_EXPR_START); frm.stmt_count = 1; frm.expr_count = 1; LOG_FMT(LSTMT, "%s(%d): orig line is %zu, 2.marked '%s' as stmt start\n", __func__, __LINE__, pc->GetOrigLine(), pc->Text()); } } // Check for "constexpr" after CT_IF or CT_ELSEIF if ( frm.top().stage == brace_stage_e::PAREN1 && ( frm.top().type == CT_IF || frm.top().type == CT_ELSEIF) && pc->Is(CT_CONSTEXPR)) { return(false); } // Verify open parenthesis in complex statement if ( pc->IsNot(CT_PAREN_OPEN) && ( (frm.top().stage == brace_stage_e::PAREN1) || (frm.top().stage == brace_stage_e::WOD_PAREN))) { LOG_FMT(LWARN, "%s(%d): %s, orig line is %zu, Error: Expected '(', got '%s' for '%s'\n", __func__, __LINE__, cpd.filename.c_str(), pc->GetOrigLine(), pc->Text(), get_token_name(frm.top().type)); // Throw out the complex statement LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-Error ", frm); exit(EX_SOFTWARE); } return(false); } // check_complex_statements static bool handle_complex_close(ParseFrame &frm, Chunk *pc, const BraceState &braceState) { LOG_FUNC_ENTRY(); if (frm.top().stage == brace_stage_e::PAREN1) { if (pc->GetNext()->GetType() == CT_WHEN) { frm.top().type = pc->GetType(); frm.top().stage = brace_stage_e::CATCH_WHEN; return(true); } // PAREN1 always => BRACE2 frm.top().stage = brace_stage_e::BRACE2; } else if (frm.top().stage == brace_stage_e::BRACE2) { // BRACE2: IF => ELSE, anything else => close if ( (frm.top().type == CT_IF) || (frm.top().type == CT_ELSEIF)) { frm.top().stage = brace_stage_e::ELSE; // If the next chunk isn't CT_ELSE, close the statement Chunk *next = pc->GetNextNcNnl(); if ( next->IsNullChunk() || next->IsNot(CT_ELSE)) { LOG_FMT(LBCSPOP, "%s(%d): no CT_ELSE, pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-IF-HCS ", frm); return(close_statement(frm, pc, braceState)); } } else if ( (frm.top().type == CT_TRY) || (frm.top().type == CT_CATCH)) { frm.top().stage = brace_stage_e::CATCH; // If the next chunk isn't CT_CATCH or CT_FINALLY, close the statement Chunk *next = pc->GetNextNcNnl(); if ( next->IsNot(CT_CATCH) && next->IsNot(CT_FINALLY)) { LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-TRY-HCS ", frm); return(close_statement(frm, pc, braceState)); } } else { LOG_FMT(LNOTE, "%s(%d): close_statement on %s brace_stage_e::BRACE2\n", __func__, __LINE__, get_token_name(frm.top().type)); LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-HCC B2 ", frm); return(close_statement(frm, pc, braceState)); } } else if (frm.top().stage == brace_stage_e::BRACE_DO) { frm.top().stage = brace_stage_e::WHILE; } else if (frm.top().stage == brace_stage_e::WOD_PAREN) { LOG_FMT(LNOTE, "%s(%d): close_statement on %s brace_stage_e::WOD_PAREN\n", __func__, __LINE__, get_token_name(frm.top().type)); frm.top().stage = brace_stage_e::WOD_SEMI; print_stack(LBCSPOP, "-HCC WoDP ", frm); } else if (frm.top().stage == brace_stage_e::WOD_SEMI) { LOG_FMT(LNOTE, "%s(%d): close_statement on %s brace_stage_e::WOD_SEMI\n", __func__, __LINE__, get_token_name(frm.top().type)); LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); print_stack(LBCSPOP, "-HCC WoDS ", frm); return(close_statement(frm, pc, braceState)); } else { // PROBLEM LOG_FMT(LWARN, "%s(%d): %s:%zu Error: TOS.type='%s' TOS.stage=%u\n", __func__, __LINE__, cpd.filename.c_str(), pc->GetOrigLine(), get_token_name(frm.top().type), (unsigned int)frm.top().stage); exit(EX_SOFTWARE); } return(false); } // handle_complex_close static void mark_namespace(Chunk *pns) { LOG_FUNC_ENTRY(); // Issue #1813 Chunk *br_close; bool is_using = false; Chunk *pc = pns->GetPrevNcNnl(); if (pc->Is(CT_USING)) { is_using = true; pns->SetParentType(CT_USING); } pc = pns->GetNextNcNnl(); while (pc->IsNotNullChunk()) { pc->SetParentType(CT_NAMESPACE); if (pc->IsNot(CT_BRACE_OPEN)) { if (pc->Is(CT_SEMICOLON)) { if (is_using) { pc->SetParentType(CT_USING); } return; } pc = pc->GetNextNcNnl(); continue; } log_rule_B("indent_namespace_limit"); if ( (options::indent_namespace_limit() > 0) && ((br_close = pc->GetClosingParen())->IsNotNullChunk())) { // br_close->GetOrigLine() is always >= pc->GetOrigLine(); size_t numberOfLines = br_close->GetOrigLine() - pc->GetOrigLine() - 1; // Issue #2345 LOG_FMT(LTOK, "%s(%d): br_close orig line is %zu, pc orig line is %zu\n", __func__, __LINE__, br_close->GetOrigLine(), pc->GetOrigLine()); LOG_FMT(LTOK, "%s(%d): numberOfLines is %zu, indent_namespace_limit() is %d\n", __func__, __LINE__, numberOfLines, options::indent_namespace_limit()); log_rule_B("indent_namespace_limit"); if (numberOfLines > options::indent_namespace_limit()) { LOG_FMT(LTOK, "%s(%d): PCF_LONG_BLOCK is set\n", __func__, __LINE__); pc->SetFlagBits(PCF_LONG_BLOCK); br_close->SetFlagBits(PCF_LONG_BLOCK); } } flag_parens(pc, PCF_IN_NAMESPACE, CT_NONE, CT_NAMESPACE, false); return; } } // mark_namespace static Chunk *insert_vbrace(Chunk *pc, bool after, const ParseFrame &frm) { LOG_FUNC_ENTRY(); Chunk chunk; chunk.SetParentType(frm.top().type); chunk.SetOrigLine(pc->GetOrigLine()); chunk.SetLevel(frm.level); chunk.SetPpLevel(frm.pp_level); chunk.SetBraceLevel(frm.brace_level); chunk.SetFlags(pc->GetFlags() & PCF_COPY_FLAGS); chunk.Str() = ""; if (after) { chunk.SetOrigCol(pc->GetOrigCol()); chunk.SetType(CT_VBRACE_CLOSE); return(chunk.CopyAndAddAfter(pc)); } Chunk *ref = pc->GetPrev(); if (ref->IsNullChunk()) { return(nullptr); } if (!ref->TestFlags(PCF_IN_PREPROC)) { chunk.ResetFlagBits(PCF_IN_PREPROC); } bool ref_is_comment = ref->IsComment(); // Issue #3351 while (ref->IsCommentOrNewline()) { ref->SetLevel(ref->GetLevel() + 1); ref->SetBraceLevel(ref->GetBraceLevel() + 1); ref = ref->GetPrev(); } if (ref->IsNullChunk()) { return(nullptr); } // Don't back into a preprocessor if ( !pc->TestFlags(PCF_IN_PREPROC) && ref->TestFlags(PCF_IN_PREPROC)) { if (ref->Is(CT_PREPROC_BODY)) { while ( ref->IsNotNullChunk() && ref->TestFlags(PCF_IN_PREPROC)) { ref = ref->GetPrev(); } } else { ref = ref->GetNext(); if (ref->Is(CT_COMMENT)) // Issue #3034 { ref = ref->GetNextNc(); } } } if (ref_is_comment) // Issue #3351 { ref = ref->GetNext(); } if (ref->IsNullChunk()) { return(nullptr); } chunk.SetOrigLine(ref->GetOrigLine()); chunk.SetOrigCol(ref->GetOrigCol()); chunk.SetColumn(ref->GetColumn() + ref->Len() + 1); chunk.SetPpLevel(ref->GetPpLevel()); // Issue #3055 chunk.SetType(CT_VBRACE_OPEN); return(chunk.CopyAndAddAfter(ref)); } // insert_vbrace bool close_statement(ParseFrame &frm, Chunk *pc, const BraceState &braceState) { LOG_FUNC_ENTRY(); if ( pc == nullptr || pc->IsNullChunk()) { throw invalid_argument(string(__func__) + ":" + to_string(__LINE__) + "args cannot be nullptr"); } LOG_FMT(LTOK, "%s(%d): orig line is %zu, type is %s, '%s' type is %s, stage is %u\n", __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetType()), pc->Text(), get_token_name(frm.top().type), (unsigned int)frm.top().stage); if (braceState.consumed) { frm.stmt_count = 0; frm.expr_count = 0; LOG_FMT(LSTMT, "%s(%d): orig line is %zu> reset2 stmt on '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->Text()); } /* * Insert a CT_VBRACE_CLOSE, if needed: * If we are in a virtual brace and we are not ON a CT_VBRACE_CLOSE add one */ Chunk *vbc = pc; if (frm.top().type == CT_VBRACE_OPEN) { // If the current token has already been consumed, then add after it if (braceState.consumed) { insert_vbrace_close_after(pc, frm); } else { // otherwise, add before it and consume the vbrace vbc = pc->GetPrevNcNnl(); frm.level--; frm.brace_level--; vbc = insert_vbrace_close_after(vbc, frm); vbc->SetParentType(frm.top().parent); LOG_FMT(LBCSPOP, "%s(%d): frm.brace_level decreased to %zu\n", __func__, __LINE__, frm.brace_level); log_pcf_flags(LBCSPOP, pc->GetFlags()); LOG_FMT(LBCSPOP, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); // Update the token level pc->SetLevel(frm.level); pc->SetBraceLevel(frm.brace_level); print_stack(LBCSPOP, "-CS VB ", frm); // And repeat the close close_statement(frm, pc, braceState); return(true); } } // See if we are done with a complex statement if (frm.top().stage != brace_stage_e::NONE) { if (handle_complex_close(frm, vbc, braceState)) { return(true); } } return(false); } // close_statement uncrustify-uncrustify-0.76.0/src/brace_cleanup.h000066400000000000000000000006621434072136500217640ustar00rootroot00000000000000/** * @file brace_cleanup.h * prototypes for brace_cleanup.cpp * * @author Ben Gardner * @license GPL v2+ */ #ifndef BRACE_CLEANUP_H_INCLUDED #define BRACE_CLEANUP_H_INCLUDED #include "uncrustify_types.h" // necessary to not sort #include "ParseFrame.h" /** * Scans through the whole list and does stuff. * It has to do some tricks to parse preprocessors. */ void brace_cleanup(); #endif /* BRACE_CLEANUP_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/braces.cpp000066400000000000000000001421361434072136500207760ustar00rootroot00000000000000/** * @file braces.cpp * Adds or removes braces. * * @author Ben Gardner * @license GPL v2+ */ #include "braces.h" #include "calculate_closing_brace_position.h" #include "combine_tools.h" #include "newlines.h" #include "prototypes.h" constexpr static auto LCURRENT = LBR; using namespace uncrustify; using std::vector; //! Converts a single brace into a virtual brace static void convert_brace(Chunk *br); //! Converts a single virtual brace into a real brace static void convert_vbrace(Chunk *br); static void convert_vbrace_to_brace(); //! Go backwards to honor brace newline removal limits static void examine_braces(); /** * Step forward and count the number of semi colons at the current level. * Abort if more than 1 or if we enter a preprocessor */ static void examine_brace(Chunk *bopen); static void move_case_break(); static void move_case_return(); static void mod_case_brace(); static void mod_full_brace_if_chain(); /** * Checks to see if the braces can be removed. * - less than a certain length * - doesn't mess up if/else stuff */ static bool can_remove_braces(Chunk *bopen); /** * Checks to see if the virtual braces should be converted to real braces. * - over a certain length * * @param vbopen Virtual Brace Open chunk * * @return true (convert to real braces) or false (leave alone) */ static bool should_add_braces(Chunk *vbopen); /** * Collect the text into txt that contains the full tag name. * Mainly for collecting namespace 'a.b.c' or function 'foo::bar()' names. */ static void append_tag_name(unc_text &txt, Chunk *pc); //! Remove the case brace, if allowable. static Chunk *mod_case_brace_remove(Chunk *br_open); //! Add the case brace, if allowable. static Chunk *mod_case_brace_add(Chunk *cl_colon); /** * Traverse the if chain and see if all can be removed * * @param br_start chunk pointing to opening brace of if clause */ static void process_if_chain(Chunk *br_start); /** * Check if parenthesis pair that comes before a brace spans multiple lines * * * @param brace the brace chunk whose predecessing parenthesis will be checked * * @pre the brace chunk cannot be a nullptr, * it needs to be of type CT_BRACE_OPEN or CT_BRACE_CLOSE, * its parent type needs to be one of this types: * CT_IF, CT_ELSEIF, CT_FOR, CT_USING_STMT, CT_WHILE, * CT_FUNC_CLASS_DEF, CT_FUNC_DEF * * @return false: if preconditions are not met, * if an error occurs while counting the newline between the * parenthesis or * when no newlines are found between the parenthesis */ static bool paren_multiline_before_brace(Chunk *brace) { if ( brace == nullptr || ( brace->IsNot(CT_BRACE_OPEN) && brace->IsNot(CT_BRACE_CLOSE)) || ( brace->GetParentType() != CT_IF && brace->GetParentType() != CT_ELSEIF && brace->GetParentType() != CT_FOR && brace->GetParentType() != CT_USING_STMT && brace->GetParentType() != CT_WHILE && brace->GetParentType() != CT_FUNC_CLASS_DEF && brace->GetParentType() != CT_FUNC_DEF)) { return(false); } const auto paren_t = CT_SPAREN_CLOSE; // find parenthesis pair of the if/for/while/... auto paren_close = brace->GetPrevType(paren_t, brace->GetLevel(), E_Scope::ALL); auto paren_open = paren_close->GetOpeningParen(); if ( paren_close->IsNullChunk() || paren_open->IsNullChunk() || paren_close == brace || paren_open == paren_close) { return(false); } // determine number of lines in the parenthesis pair spans auto nl_count = size_t{}; const auto ret_flag = newlines_between(paren_open, paren_close, nl_count); if (!ret_flag) { LOG_FMT(LERR, "%s(%d): newlines_between error\n", __func__, __LINE__); return(false); } // nl_count = 0 -> 1 line return(nl_count > 0); } void do_braces() { LOG_FUNC_ENTRY(); // Mark one-liners // Issue #2232 put this at the beginning Chunk *pc = Chunk::GetHead()->GetNextNcNnl(); while (pc->IsNotNullChunk()) { if ( pc->IsNot(CT_BRACE_OPEN) && pc->IsNot(CT_VBRACE_OPEN)) { pc = pc->GetNextNcNnl(); continue; } Chunk *br_open = pc; const E_Token brc_type = E_Token(pc->GetType() + 1); // corresponds to closing type // Detect empty bodies Chunk *tmp = pc->GetNextNcNnl(); if (tmp->Is(brc_type)) { br_open->SetFlagBits(PCF_EMPTY_BODY); tmp->SetFlagBits(PCF_EMPTY_BODY); } // Scan for the brace close or a newline tmp = br_open->GetNextNc(); while (tmp->IsNotNullChunk()) { if (tmp->IsNewline()) { break; } if ( tmp->Is(brc_type) && br_open->GetLevel() == tmp->GetLevel()) { flag_series(br_open, tmp, PCF_ONE_LINER); break; } tmp = tmp->GetNextNc(); } pc = pc->GetNextNcNnl(); } log_rule_B("mod_full_brace_if_chain"); log_rule_B("mod_full_brace_if_chain_only"); if ( options::mod_full_brace_if_chain() || options::mod_full_brace_if_chain_only()) { mod_full_brace_if_chain(); } log_rule_B("mod_full_brace_if"); log_rule_B("mod_full_brace_do"); log_rule_B("mod_full_brace_for"); log_rule_B("mod_full_brace_using"); log_rule_B("mod_full_brace_while"); if ((options::mod_full_brace_if() | options::mod_full_brace_do() | options::mod_full_brace_for() | options::mod_full_brace_using() | options::mod_full_brace_while()) & IARF_REMOVE) { examine_braces(); } // convert vbraces if needed log_rule_B("mod_full_brace_if"); log_rule_B("mod_full_brace_do"); log_rule_B("mod_full_brace_for"); log_rule_B("mod_full_brace_function"); log_rule_B("mod_full_brace_using"); log_rule_B("mod_full_brace_while"); if ((options::mod_full_brace_if() | options::mod_full_brace_do() | options::mod_full_brace_for() | options::mod_full_brace_function() | options::mod_full_brace_using() | options::mod_full_brace_while()) & IARF_ADD) { convert_vbrace_to_brace(); } log_rule_B("mod_case_brace"); if (options::mod_case_brace() != IARF_IGNORE) { mod_case_brace(); } log_rule_B("mod_move_case_break"); if (options::mod_move_case_break()) { move_case_break(); } log_rule_B("mod_move_case_return"); if (options::mod_move_case_return()) { move_case_return(); } } // do_braces static void examine_braces() { LOG_FUNC_ENTRY(); log_rule_B("mod_full_brace_nl_block_rem_mlcond"); const auto multiline_block = options::mod_full_brace_nl_block_rem_mlcond(); log_rule_B("mod_full_brace_if"); log_rule_B("mod_full_brace_do"); log_rule_B("mod_full_brace_for"); log_rule_B("mod_full_brace_using"); log_rule_B("mod_full_brace_while"); for (Chunk *pc = Chunk::GetTail(); pc->IsNotNullChunk();) { Chunk *prev = pc->GetPrevType(CT_BRACE_OPEN); if ( pc->Is(CT_BRACE_OPEN) && !pc->TestFlags(PCF_IN_PREPROC) && ( ( ( pc->GetParentType() == CT_IF || pc->GetParentType() == CT_ELSE || pc->GetParentType() == CT_ELSEIF) && options::mod_full_brace_if() == IARF_REMOVE) || ( pc->GetParentType() == CT_DO && options::mod_full_brace_do() == IARF_REMOVE) || ( pc->GetParentType() == CT_FOR && options::mod_full_brace_for() == IARF_REMOVE) || ( pc->GetParentType() == CT_USING_STMT && options::mod_full_brace_using() == IARF_REMOVE) || ( pc->GetParentType() == CT_WHILE && options::mod_full_brace_while() == IARF_REMOVE))) { if ( multiline_block && paren_multiline_before_brace(pc)) { pc = prev; continue; } examine_brace(pc); } pc = prev; } } // examine_braces static bool should_add_braces(Chunk *vbopen) { LOG_FUNC_ENTRY(); log_rule_B("mod_full_brace_nl"); const size_t nl_max = options::mod_full_brace_nl(); if (nl_max == 0) { return(false); } LOG_FMT(LBRDEL, "%s(%d): start on %zu:\n", __func__, __LINE__, vbopen->GetOrigLine()); size_t nl_count = 0; Chunk *pc = Chunk::NullChunkPtr; for (pc = vbopen->GetNextNc(E_Scope::PREPROC); (pc->IsNotNullChunk() && pc->GetLevel() > vbopen->GetLevel()); pc = pc->GetNextNc(E_Scope::PREPROC)) { if (pc->IsNewline()) { nl_count += pc->GetNlCount(); } } if ( pc->IsNotNullChunk() && nl_count > nl_max && vbopen->GetPpLevel() == pc->GetPpLevel()) { LOG_FMT(LBRDEL, "%s(%d): exceeded %zu newlines\n", __func__, __LINE__, nl_max); return(true); } return(false); } static bool can_remove_braces(Chunk *bopen) { LOG_FUNC_ENTRY(); LOG_FMT(LBRDEL, "%s(%d): start on line %zu:\n", __func__, __LINE__, bopen->GetOrigLine()); // Cannot remove braces inside a preprocessor if (bopen->TestFlags(PCF_IN_PREPROC)) { return(false); } Chunk *pc = bopen->GetNextNcNnl(E_Scope::PREPROC); if (pc->Is(CT_BRACE_CLOSE)) { // Can't remove empty statement return(false); } const size_t level = bopen->GetLevel() + 1; log_rule_B("mod_full_brace_nl"); const size_t nl_max = options::mod_full_brace_nl(); Chunk *prev = Chunk::NullChunkPtr; size_t semi_count = 0; bool hit_semi = false; size_t nl_count = 0; size_t if_count = 0; int br_count = 0; pc = bopen->GetNextNc(E_Scope::ALL); LOG_FMT(LBRDEL, "%s(%d): - begin with token '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); while ( pc->IsNotNullChunk() && pc->GetLevel() >= level) { LOG_FMT(LBRDEL, "%s(%d): test token '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); if (pc->TestFlags(PCF_IN_PREPROC)) { // Cannot remove braces that contain a preprocessor return(false); } if (pc->IsNewline()) { nl_count += pc->GetNlCount(); if ( nl_max > 0 && nl_count > nl_max) { LOG_FMT(LBRDEL, "%s(%d): exceeded %zu newlines\n", __func__, __LINE__, nl_max); return(false); } } else { if (pc->Is(CT_BRACE_OPEN)) { br_count++; } else if (pc->Is(CT_BRACE_CLOSE)) { if (br_count == 0) { fprintf(stderr, "%s(%d): br_count is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } br_count--; if (pc->GetLevel() == level) { // mean a statement in a braces { stmt; } // as a statement with a semicolon { stmt; }; ++semi_count; hit_semi = true; } } else if ( ( pc->Is(CT_IF) || pc->Is(CT_ELSEIF)) && br_count == 0) { if_count++; } if (pc->GetLevel() == level) { if ( semi_count > 0 && hit_semi) { // should have bailed due to close brace level drop LOG_FMT(LBRDEL, "%s(%d): no close brace\n", __func__, __LINE__); return(false); } LOG_FMT(LBRDEL, "%s(%d): Text() '%s', orig line is %zu, semi_count is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), semi_count); if (pc->Is(CT_ELSE)) { LOG_FMT(LBRDEL, "%s(%d): bailed on '%s' on line %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); return(false); } if ( pc->IsSemicolon() || pc->Is(CT_IF) || pc->Is(CT_ELSEIF) || pc->Is(CT_FOR) || pc->Is(CT_DO) || pc->Is(CT_WHILE) || pc->Is(CT_USING_STMT) || ( pc->Is(CT_BRACE_OPEN) && prev->Is(CT_FPAREN_CLOSE))) { hit_semi |= pc->IsSemicolon(); if (++semi_count > 1) { LOG_FMT(LBRDEL, "%s(%d): bailed on %zu because of '%s' on line %zu\n", __func__, __LINE__, bopen->GetOrigLine(), pc->Text(), pc->GetOrigLine()); return(false); } } } } prev = pc; pc = pc->GetNextNc(); } if (pc->IsNullChunk()) { LOG_FMT(LBRDEL, "%s(%d): pc is null chunk\n", __func__, __LINE__); return(false); } if ( pc->Is(CT_BRACE_CLOSE) && pc->GetParentType() == CT_IF) { Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); Chunk *tmp_prev = pc->GetPrevNcNnl(E_Scope::PREPROC); if ( next->Is(CT_ELSE) && tmp_prev->IsBraceClose() && tmp_prev->GetParentType() == CT_IF) { LOG_FMT(LBRDEL, "%s(%d): - bailed on '%s'[%s] on line %zu due to 'if' and 'else' sequence\n", __func__, __LINE__, get_token_name(pc->GetType()), get_token_name(pc->GetParentType()), pc->GetOrigLine()); return(false); } } LOG_FMT(LBRDEL, "%s(%d): - end on '%s' on line %zu. if_count is %zu semi_count is %zu\n", __func__, __LINE__, get_token_name(pc->GetType()), pc->GetOrigLine(), if_count, semi_count); return( pc->Is(CT_BRACE_CLOSE) && pc->GetPpLevel() == bopen->GetPpLevel()); } // can_remove_braces static void examine_brace(Chunk *bopen) { LOG_FUNC_ENTRY(); LOG_FMT(LBRDEL, "%s(%d): start on orig line %zu, bopen->GetLevel() is %zu\n", __func__, __LINE__, bopen->GetOrigLine(), bopen->GetLevel()); const size_t level = bopen->GetLevel() + 1; log_rule_B("mod_full_brace_nl"); const size_t nl_max = options::mod_full_brace_nl(); Chunk *prev = Chunk::NullChunkPtr; size_t semi_count = 0; bool hit_semi = false; size_t nl_count = 0; size_t if_count = 0; int br_count = 0; Chunk *pc = bopen->GetNextNc(); while ( pc->IsNotNullChunk() && pc->GetLevel() >= level) { if (pc->Is(CT_NEWLINE)) { LOG_FMT(LBRDEL, "%s(%d): orig line is %zu, orig col is %zu, \n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); } else { LOG_FMT(LBRDEL, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); } if (pc->TestFlags(PCF_IN_PREPROC)) { // Cannot remove braces that contain a preprocessor LOG_FMT(LBRDEL, "%s(%d): PREPROC\n", __func__, __LINE__); return; } if (pc->IsNewline()) { nl_count += pc->GetNlCount(); if ( nl_max > 0 && nl_count > nl_max) { LOG_FMT(LBRDEL, "%s(%d): exceeded %zu newlines\n", __func__, __LINE__, nl_max); return; } } else { LOG_FMT(LBRDEL, "%s(%d): for pc->Text() '%s', pc->GetLevel() is %zu, bopen->GetLevel() is %zu\n", __func__, __LINE__, pc->Text(), pc->GetLevel(), bopen->GetLevel()); if ( pc->Is(CT_BRACE_OPEN) && pc->GetLevel() == bopen->GetLevel()) { br_count++; LOG_FMT(LBRDEL, "%s(%d): br_count is now %d, pc->GetLevel() is %zu, bopen->GetLevel() is %zu\n", __func__, __LINE__, br_count, pc->GetLevel(), bopen->GetLevel()); } else if ( pc->Is(CT_BRACE_CLOSE) && pc->GetLevel() == bopen->GetLevel()) { if (br_count == 0) { fprintf(stderr, "%s(%d): br_count is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } br_count--; LOG_FMT(LBRDEL, "%s(%d): br_count is now %d, pc->GetLevel() is %zu, bopen->GetLevel() is %zu\n", __func__, __LINE__, br_count, pc->GetLevel(), bopen->GetLevel()); if (br_count == 0) { Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); if ( next->IsNullChunk() || next->IsNot(CT_BRACE_CLOSE)) { LOG_FMT(LBRDEL, "%s(%d): junk after close brace\n", __func__, __LINE__); return; } } } else if ( ( pc->Is(CT_IF) || pc->Is(CT_ELSEIF)) && br_count == 0) { if_count++; } LOG_FMT(LBRDEL, "%s(%d): pc->GetLevel() is %zu, level is %zu\n", __func__, __LINE__, pc->GetLevel(), level); if (pc->GetLevel() == level) { if ( semi_count > 0 && hit_semi) { // should have bailed due to close brace level drop LOG_FMT(LBRDEL, "%s(%d): no close brace\n", __func__, __LINE__); return; } LOG_FMT(LBRDEL, "%s(%d): Text() '%s', orig line is %zu, semi_count is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), semi_count); if (pc->Is(CT_ELSE)) { LOG_FMT(LBRDEL, "%s(%d): bailed on '%s' on line %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); return; } if (prev->IsNotNullChunk()) { LOG_FMT(LBRDEL, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', prev->Text '%s', prev->GetType() %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), prev->Text(), get_token_name(prev->GetType())); } else { LOG_FMT(LBRDEL, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', prev is a null chunk\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); } LOG_FMT(LBRDEL, "%s(%d): for pc->Text() '%s', pc->GetLevel() is %zu, bopen->GetLevel() is %zu\n", __func__, __LINE__, pc->Text(), pc->GetLevel(), bopen->GetLevel()); if ( pc->IsSemicolon() || pc->Is(CT_IF) || pc->Is(CT_ELSEIF) || pc->Is(CT_FOR) || pc->Is(CT_DO) || pc->Is(CT_WHILE) || pc->Is(CT_SWITCH) || pc->Is(CT_USING_STMT) || ( pc->Is(CT_BRACE_OPEN) && pc->GetLevel() == bopen->GetLevel())) // Issue #1758 { LOG_FMT(LBRDEL, "%s(%d): pc->Text() '%s', orig line is %zu, orig col is %zu, level is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); hit_semi |= pc->IsSemicolon(); semi_count++; LOG_FMT(LBRDEL, "%s(%d): semi_count is %zu\n", __func__, __LINE__, semi_count); if (semi_count > 1) { LOG_FMT(LBRDEL, "%s(%d): bailed on %zu because of '%s' on line %zu\n", __func__, __LINE__, bopen->GetOrigLine(), pc->Text(), pc->GetOrigLine()); return; } } } } prev = pc; pc = pc->GetNext(); // Issue #1907 } if (pc->IsNullChunk()) { LOG_FMT(LBRDEL, "%s(%d): pc is nullptr\n", __func__, __LINE__); return; } LOG_FMT(LBRDEL, "%s(%d): - end on '%s' on line %zu. if_count is %zu, semi_count is %zu\n", __func__, __LINE__, get_token_name(pc->GetType()), pc->GetOrigLine(), if_count, semi_count); if (pc->Is(CT_BRACE_CLOSE)) { Chunk *next = pc->GetNextNcNnl(); if (next->IsNotNullChunk()) { while (next->Is(CT_VBRACE_CLOSE)) { next = next->GetNextNcNnl(); } if (next->IsNotNullChunk()) { LOG_FMT(LBRDEL, "%s(%d): orig line is %zu, orig col is %zu, next is '%s'\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), get_token_name(next->GetType())); } if ( if_count > 0 && ( next->Is(CT_ELSE) || next->Is(CT_ELSEIF))) { LOG_FMT(LBRDEL, "%s(%d): bailed on because 'else' is next and %zu ifs\n", __func__, __LINE__, if_count); return; } } LOG_FMT(LBRDEL, "%s(%d): semi_count is %zu\n", __func__, __LINE__, semi_count); if (semi_count > 0) { LOG_FMT(LBRDEL, "%s(%d): bopen->GetParentType() is %s\n", __func__, __LINE__, get_token_name(bopen->GetParentType())); if (bopen->GetParentType() == CT_ELSE) { Chunk *tmp_next = bopen->GetNextNcNnl(); if (tmp_next->Is(CT_IF)) { Chunk *tmp_prev = bopen->GetPrevNcNnl(); LOG_FMT(LBRDEL, "%s(%d): else-if removing braces on line %zu and %zu\n", __func__, __LINE__, bopen->GetOrigLine(), pc->GetOrigLine()); Chunk::Delete(bopen); Chunk::Delete(pc); newline_del_between(tmp_prev, tmp_next); log_rule_B("nl_else_if"); if (options::nl_else_if() & IARF_ADD) { newline_add_between(tmp_prev, tmp_next); } return; } } // we have a pair of braces with only 1 statement inside LOG_FMT(LBRDEL, "%s(%d): we have a pair of braces with only 1 statement inside\n", __func__, __LINE__); LOG_FMT(LBRDEL, "%s(%d): removing braces on line %zu and %zu\n", __func__, __LINE__, bopen->GetOrigLine(), pc->GetOrigLine()); convert_brace(bopen); convert_brace(pc); } else { LOG_FMT(LBRDEL, "%s(%d): empty statement\n", __func__, __LINE__); } } else { LOG_FMT(LBRDEL, "%s(%d): not a close brace? - '%s'\n", __func__, __LINE__, pc->Text()); } } // examine_brace static void convert_brace(Chunk *br) { LOG_FUNC_ENTRY(); if ( br == nullptr || br->TestFlags(PCF_KEEP_BRACE)) { return; } Chunk *tmp; if (br->Is(CT_BRACE_OPEN)) { br->SetType(CT_VBRACE_OPEN); br->Str().clear(); tmp = br->GetPrev(); if (tmp->IsNullChunk()) { return; } } else if (br->Is(CT_BRACE_CLOSE)) { br->SetType(CT_VBRACE_CLOSE); br->Str().clear(); tmp = br->GetNext(); if (tmp->IsNullChunk()) { return; } } else { return; } if (tmp->IsNewline()) { if (tmp->GetNlCount() > 1) { if (!br->TestFlags(PCF_ONE_LINER)) // Issue #2232 { tmp->SetNlCount(tmp->GetNlCount() - 1); LOG_FMT(LBRDEL, "%s(%d): tmp new line count is %zu\n", __func__, __LINE__, tmp->GetNlCount()); } } else { // Issue #2219 // look for opening brace Chunk *brace = Chunk::NullChunkPtr; if (br->Is(CT_VBRACE_OPEN)) { brace = tmp; } else if (br->Is(CT_VBRACE_CLOSE)) { brace = br->GetOpeningParen(); if (brace->IsNullChunk()) { brace = br->GetPrevType(CT_BRACE_OPEN, br->GetLevel()); } } if ( br->Is(CT_VBRACE_OPEN) || ( br->Is(CT_VBRACE_CLOSE) && brace->GetOrigLine() < tmp->GetOrigLine())) { if (tmp->SafeToDeleteNl()) { Chunk::Delete(tmp); } } } } } // convert_brace static void convert_vbrace(Chunk *vbr) { LOG_FUNC_ENTRY(); if (vbr == nullptr) { return; } if (vbr->Is(CT_VBRACE_OPEN)) { vbr->SetType(CT_BRACE_OPEN); vbr->Str() = "{"; /* * If the next chunk is a preprocessor, then move the open brace after the * preprocessor. */ Chunk *tmp = vbr->GetNext(); if (tmp->Is(CT_PREPROC)) { tmp = vbr->GetNext(E_Scope::PREPROC); vbr->MoveAfter(tmp); newline_add_after(vbr); } } else if (vbr->Is(CT_VBRACE_CLOSE)) { vbr->SetType(CT_BRACE_CLOSE); vbr->Str() = "}"; /* * If the next chunk is a comment, followed by a newline, then * move the brace after the newline and add another newline after * the close brace, unless we're keeping a one-liner. */ Chunk *tmp = vbr->GetNext(); if ( tmp->IsComment() && ( !vbr->TestFlags(PCF_ONE_LINER) || !options::nl_if_leave_one_liners())) { tmp = tmp->GetNext(); if (tmp->IsNewline()) { vbr->MoveAfter(tmp); newline_add_after(vbr); } } } } // convert_vbrace static void convert_vbrace_to_brace() { LOG_FUNC_ENTRY(); // Find every vbrace open log_rule_B("mod_full_brace_if"); log_rule_B("mod_full_brace_if_chain"); log_rule_B("mod_full_brace_for"); log_rule_B("mod_full_brace_do"); log_rule_B("mod_full_brace_while"); log_rule_B("mod_full_brace_using"); log_rule_B("mod_full_brace_function"); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if (pc->IsNot(CT_VBRACE_OPEN)) { continue; } auto const in_preproc = pc->TestFlags(PCF_IN_PREPROC); if ( ( ( pc->GetParentType() == CT_IF || pc->GetParentType() == CT_ELSE || pc->GetParentType() == CT_ELSEIF) && (options::mod_full_brace_if() & IARF_ADD) && !options::mod_full_brace_if_chain()) || ( pc->GetParentType() == CT_FOR && (options::mod_full_brace_for() & IARF_ADD)) || ( pc->GetParentType() == CT_DO && (options::mod_full_brace_do() & IARF_ADD)) || ( pc->GetParentType() == CT_WHILE && (options::mod_full_brace_while() & IARF_ADD)) || ( pc->GetParentType() == CT_USING_STMT && (options::mod_full_brace_using() & IARF_ADD)) || ( pc->GetParentType() == CT_FUNC_DEF && (options::mod_full_brace_function() & IARF_ADD))) { // Find the matching vbrace close Chunk *vbc = Chunk::NullChunkPtr; Chunk *tmp = pc->GetNext(); while (tmp->IsNotNullChunk()) { if ( in_preproc && !tmp->TestFlags(PCF_IN_PREPROC)) { // Can't leave a preprocessor break; } if ( pc->GetBraceLevel() == tmp->GetBraceLevel() && tmp->Is(CT_VBRACE_CLOSE) && pc->GetParentType() == tmp->GetParentType() && ((tmp->GetFlags() & PCF_IN_PREPROC) == (pc->GetFlags() & PCF_IN_PREPROC))) { vbc = tmp; break; } tmp = tmp->GetNext(); } if (vbc->IsNullChunk()) { continue; } // if we found a corresponding virtual closing brace convert_vbrace(pc); // convert both the opening convert_vbrace(vbc); // and closing brace } } } // convert_vbrace_to_brace Chunk *insert_comment_after(Chunk *ref, E_Token cmt_type, const unc_text &cmt_text) { LOG_FUNC_ENTRY(); Chunk new_cmt = *ref; new_cmt.SetFlags(ref->GetFlags() & PCF_COPY_FLAGS); new_cmt.SetType(cmt_type); new_cmt.Str().clear(); if (cmt_type == CT_COMMENT_CPP) { new_cmt.Str().append("// "); new_cmt.Str().append(cmt_text); } else { if (ref->Is(CT_PP_ELSE)) { // make test c/ 02501 stable new_cmt.Str().append(" "); } new_cmt.Str().append("/* "); new_cmt.Str().append(cmt_text); new_cmt.Str().append(" */"); } // TODO: expand comment type to cover other comment styles? new_cmt.SetColumn(ref->GetColumn() + ref->Len() + 1); new_cmt.SetOrigCol(new_cmt.GetColumn()); return(new_cmt.CopyAndAddAfter(ref)); } static void append_tag_name(unc_text &txt, Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *tmp = pc->GetPrevNcNnl(); LOG_FMT(LMCB, "%s(%d): txt is '%s'\n", __func__, __LINE__, txt.c_str()); // step backwards over all a::b stuff while (tmp->IsNotNullChunk()) { if ( tmp->IsNot(CT_DC_MEMBER) && tmp->IsNot(CT_MEMBER)) { break; } tmp = tmp->GetPrevNcNnl(); pc = tmp; if (!tmp->IsWord()) { break; } } txt += pc->GetStr(); LOG_FMT(LMCB, "%s(%d): txt is '%s'\n", __func__, __LINE__, txt.c_str()); pc = pc->GetNextNcNnl(); while (pc->IsNotNullChunk()) { if ( pc->IsNot(CT_DC_MEMBER) && pc->IsNot(CT_MEMBER)) { break; } txt += pc->GetStr(); LOG_FMT(LMCB, "%s(%d): txt is '%s'\n", __func__, __LINE__, txt.c_str()); pc = pc->GetNextNcNnl(); if (pc->IsNotNullChunk()) { txt += pc->GetStr(); LOG_FMT(LMCB, "%s(%d): txt is '%s'\n", __func__, __LINE__, txt.c_str()); } pc = pc->GetNextNcNnl(); } } // append_tag_name void add_long_closebrace_comment() { LOG_FUNC_ENTRY(); Chunk *fcn_pc = Chunk::NullChunkPtr; Chunk *sw_pc = Chunk::NullChunkPtr; Chunk *ns_pc = Chunk::NullChunkPtr; Chunk *cl_pc = Chunk::NullChunkPtr; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if ( pc->Is(CT_FUNC_DEF) || pc->Is(CT_OC_MSG_DECL)) { fcn_pc = pc; } else if (pc->Is(CT_SWITCH)) { // pointless, since it always has the text "switch" sw_pc = pc; } else if (pc->Is(CT_NAMESPACE)) { ns_pc = pc; } else if (pc->Is(CT_CLASS)) { cl_pc = pc; } if ( pc->IsNot(CT_BRACE_OPEN) || pc->TestFlags(PCF_IN_PREPROC)) { continue; } Chunk *br_open = pc; size_t nl_count = 0; Chunk *tmp = pc; while ((tmp = tmp->GetNext(E_Scope::PREPROC))->IsNotNullChunk()) { if (tmp->IsNewline()) { nl_count += tmp->GetNlCount(); continue; } // handle only matching closing braces, skip other chunks if ( tmp->GetLevel() != br_open->GetLevel() || tmp->IsNot(CT_BRACE_CLOSE)) { continue; } Chunk *br_close = tmp; tmp = tmp->GetNext(); // check for a possible end semicolon if (tmp->Is(CT_SEMICOLON)) { // set br_close to the semi token, // as br_close is used to add the comment after it br_close = tmp; tmp = tmp->GetNext(); } // make sure a newline follows in order to not overwrite an already // existring comment if ( tmp->IsNotNullChunk() && !tmp->IsNewline()) { break; } size_t nl_min = 0; Chunk *tag_pc = Chunk::NullChunkPtr; unc_text xstr; if ( br_open->GetParentType() == CT_FUNC_DEF || br_open->GetParentType() == CT_OC_MSG_DECL) { log_rule_B("mod_add_long_function_closebrace_comment"); nl_min = options::mod_add_long_function_closebrace_comment(); tag_pc = fcn_pc; if (tag_pc->IsNotNullChunk()) { append_tag_name(xstr, tag_pc); LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); } } else if ( br_open->GetParentType() == CT_SWITCH && sw_pc != nullptr) { log_rule_B("mod_add_long_switch_closebrace_comment"); nl_min = options::mod_add_long_switch_closebrace_comment(); tag_pc = sw_pc; xstr = sw_pc->GetStr(); LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); } else if ( br_open->GetParentType() == CT_NAMESPACE && ns_pc != nullptr) { log_rule_B("mod_add_long_namespace_closebrace_comment"); nl_min = options::mod_add_long_namespace_closebrace_comment(); tag_pc = ns_pc; xstr = tag_pc->GetStr(); // add 'namespace' to the string LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); // next chunk, normally is going to be the namespace name // append it with a space to generate "namespace xyz" Chunk *tmp_next = tag_pc->GetNextNcNnl(); if (tmp_next->IsNot(CT_BRACE_OPEN)) // anonymous namespace -> ignore { xstr.append(" "); LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); append_tag_name(xstr, tmp_next); LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); } } else if ( br_open->GetParentType() == CT_CLASS && cl_pc->IsNotNullChunk() && ( !language_is_set(LANG_CPP) // proceed if not C++ || br_close->Is(CT_SEMICOLON))) // else a C++ class needs to end with a semicolon { log_rule_B("mod_add_long_class_closebrace_comment"); nl_min = options::mod_add_long_class_closebrace_comment(); tag_pc = cl_pc; xstr = tag_pc->GetStr(); LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); Chunk *tmp_next = cl_pc->GetNext(); if (tag_pc->IsNotNullChunk()) { xstr.append(" "); LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); append_tag_name(xstr, tmp_next); LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); } } if ( nl_min > 0 && nl_count >= nl_min && tag_pc->IsNotNullChunk()) { // use the comment style that fits to the selected language const E_Token style = language_is_set(LANG_CPP | LANG_CS) ? CT_COMMENT_CPP : CT_COMMENT; // Add a comment after the close brace LOG_FMT(LMCB, "%s(%d): xstr is '%s'\n", __func__, __LINE__, xstr.c_str()); insert_comment_after(br_close, style, xstr); } break; } } } // add_long_closebrace_comment static void move_case_break() { LOG_FUNC_ENTRY(); Chunk *prev = Chunk::NullChunkPtr; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if ( pc->Is(CT_BREAK) && prev->Is(CT_BRACE_CLOSE) && prev->GetParentType() == CT_CASE && pc->GetPrev()->IsNewline() && prev->GetPrev()->IsNewline()) { prev->SwapLines(pc); } prev = pc; } } static void move_case_return() { LOG_FUNC_ENTRY(); Chunk *prev = Chunk::NullChunkPtr; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if ( pc->Is(CT_RETURN) && prev->Is(CT_BRACE_CLOSE) && prev->GetParentType() == CT_CASE && pc->GetPrev()->IsNewline() && prev->GetPrev()->IsNewline()) { // Find the end of the return statement while (pc->IsNot(CT_SEMICOLON)) { if ( pc->Is(CT_CASE) || pc->Is(CT_BRACE_CLOSE)) { // This may indicate a semicolon was missing in the code to format. // Avoid moving the return statement to prevent potential unwanted errors. pc = Chunk::NullChunkPtr; break; } pc = pc->GetNext(); } pc = pc->GetNextNl(); pc = pc->GetNextNcNnl(); if (pc->IsNotNullChunk()) { // Swap all lines between brace close and current token LOG_FMT(LMCB, "%s(%d): move line %zu before line %zu\n", __func__, __LINE__, prev->GetOrigLine(), pc->GetOrigLine()); Chunk *curr = prev->GetNextNcNnl(); while (curr != pc) { prev->SwapLines(curr); curr = prev->GetNextNcNnl(); } } } prev = pc; } } // move_case_return static Chunk *mod_case_brace_remove(Chunk *br_open) { LOG_FUNC_ENTRY(); LOG_FMT(LMCB, "%s(%d): line %zu", __func__, __LINE__, br_open->GetOrigLine()); // Find the matching brace close Chunk *next = br_open->GetNextNcNnl(E_Scope::PREPROC); Chunk *br_close = br_open->GetNextType(CT_BRACE_CLOSE, br_open->GetLevel(), E_Scope::PREPROC); if (br_close->IsNullChunk()) { LOG_FMT(LMCB, "%s(%d): - no close\n", __func__, __LINE__); return(next); } // Make sure 'break', 'return', 'goto', 'case' or '}' is after the close brace Chunk *pc = br_close->GetNextNcNnl(E_Scope::PREPROC); if ( pc->IsNullChunk() || ( pc->IsNot(CT_BREAK) && pc->IsNot(CT_RETURN) && pc->IsNot(CT_CASE) && pc->IsNot(CT_GOTO) && pc->IsNot(CT_BRACE_CLOSE))) { LOG_FMT(LMCB, "%s(%d): - after '%s'\n", __func__, __LINE__, (pc == nullptr) ? "" : get_token_name(pc->GetType())); return(next); } // scan to make sure there are no definitions at brace level between braces for (Chunk *tmp_pc = br_open; tmp_pc != br_close; tmp_pc = tmp_pc->GetNextNcNnl(E_Scope::PREPROC)) { if ( tmp_pc->GetLevel() == (br_open->GetLevel() + 1) && tmp_pc->TestFlags(PCF_VAR_DEF)) { LOG_FMT(LMCB, "%s(%d): - vardef on line %zu: '%s'\n", __func__, __LINE__, tmp_pc->GetOrigLine(), pc->Text()); return(next); } } LOG_FMT(LMCB, "%s(%d): - removing braces on lines %zu and %zu\n", __func__, __LINE__, br_open->GetOrigLine(), br_close->GetOrigLine()); for (Chunk *tmp_pc = br_open; tmp_pc != br_close; tmp_pc = tmp_pc->GetNextNcNnl(E_Scope::PREPROC)) { if (tmp_pc->GetBraceLevel() == 0) { fprintf(stderr, "%s(%d): brace level is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, tmp_pc->GetOrigLine(), tmp_pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } tmp_pc->SetBraceLevel(tmp_pc->GetBraceLevel() - 1); if (tmp_pc->GetLevel() == 0) { fprintf(stderr, "%s(%d): tmp_pc->GetLevel() is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, tmp_pc->GetOrigLine(), tmp_pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } tmp_pc->SetLevel(tmp_pc->GetLevel() - 1); } next = br_open->GetPrev(E_Scope::PREPROC); Chunk::Delete(br_open); Chunk::Delete(br_close); return(next->GetNext(E_Scope::PREPROC)); } // mod_case_brace_remove static Chunk *mod_case_brace_add(Chunk *cl_colon) { LOG_FUNC_ENTRY(); LOG_FMT(LMCB, "%s(%d): orig line %zu, orig col is %zu\n", __func__, __LINE__, cl_colon->GetOrigLine(), cl_colon->GetOrigCol()); Chunk *pc = cl_colon; Chunk *last = Chunk::NullChunkPtr; // look for the case token to the colon Chunk *cas_ = cl_colon->GetPrevType(CT_CASE, cl_colon->GetLevel()); // look for the parent Chunk *swit = cas_->GetParent(); // look for the opening brace of the switch Chunk *open = swit->GetNextType(CT_BRACE_OPEN, swit->GetLevel()); // look for the closing brace of the switch Chunk *clos = open->GetClosingParen(); // find the end of the case-block pc = pc->GetNextNcNnl(E_Scope::PREPROC); while (pc->IsNotNullChunk()) { LOG_FMT(LMCB, "%s(%d): Text() is '%s', orig line %zu, orig col is %zu, pp level is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetPpLevel()); if (pc->GetLevel() == cl_colon->GetLevel()) { if (pc->Is(CT_CASE)) { LOG_FMT(LMCB, "%s(%d): Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); last = calculate_closing_brace_position(cl_colon, pc); break; } } else if (pc->GetLevel() == cl_colon->GetLevel() - 1) { if (pc == clos) { LOG_FMT(LMCB, "%s(%d): Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); // end of switch is reached last = calculate_closing_brace_position(cl_colon, pc); LOG_FMT(LMCB, "%s(%d): last->Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, last->Text(), last->GetOrigLine(), last->GetOrigCol()); break; } } pc = pc->GetNextNcNnl(E_Scope::PREPROC); } if (last->IsNullChunk()) { LOG_FMT(LMCB, "%s(%d): - last is null chunk\n", __func__, __LINE__); Chunk *next = cl_colon->GetNextNcNnl(E_Scope::PREPROC); return(next); } LOG_FMT(LMCB, "%s(%d): last->Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, last->Text(), last->GetOrigLine(), last->GetOrigCol()); LOG_FMT(LMCB, "%s(%d): adding braces after '%s' on line %zu\n", __func__, __LINE__, cl_colon->Text(), cl_colon->GetOrigLine()); Chunk chunk; chunk.SetType(CT_BRACE_OPEN); chunk.SetParentType(CT_CASE); chunk.SetOrigLine(cl_colon->GetOrigLine()); chunk.SetOrigCol(cl_colon->GetOrigCol()); chunk.SetLevel(cl_colon->GetLevel()); chunk.SetPpLevel(cl_colon->GetPpLevel()); chunk.SetBraceLevel(cl_colon->GetBraceLevel()); chunk.SetFlags(pc->GetFlags() & PCF_COPY_FLAGS); chunk.Str() = "{"; Chunk *br_open = chunk.CopyAndAddAfter(cl_colon); chunk.SetType(CT_BRACE_CLOSE); chunk.SetOrigLine(last->GetOrigLine()); chunk.SetOrigCol(last->GetOrigCol()); chunk.Str() = "}"; Chunk *br_close = chunk.CopyAndAddAfter(last); for (pc = br_open->GetNext(E_Scope::PREPROC); pc != br_close; pc = pc->GetNext(E_Scope::PREPROC)) { pc->SetLevel(pc->GetLevel() + 1); pc->SetBraceLevel(pc->GetBraceLevel() + 1); } return(br_open); } // mod_case_brace_add static void mod_case_brace() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); // Make sure to start outside of a preprocessor line (see issue #3366) if (pc->IsPreproc()) { pc = pc->GetNextNcNnlNpp(); } while ( pc != nullptr && pc->IsNotNullChunk()) { Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); if (next->IsNullChunk()) { return; } log_rule_B("mod_case_brace"); if ( options::mod_case_brace() == IARF_REMOVE && pc->Is(CT_BRACE_OPEN) && pc->GetParentType() == CT_CASE) { log_rule_B("mod_case_brace - add"); pc = mod_case_brace_remove(pc); } else if ( (options::mod_case_brace() & IARF_ADD) && pc->Is(CT_CASE_COLON) && next->IsNot(CT_BRACE_OPEN) && next->IsNot(CT_BRACE_CLOSE) && next->IsNot(CT_CASE)) { log_rule_B("mod_case_brace - remove"); pc = mod_case_brace_add(pc); } else { pc = pc->GetNextNcNnl(E_Scope::PREPROC); } } } // mod_case_brace static void process_if_chain(Chunk *br_start) { LOG_FUNC_ENTRY(); LOG_FMT(LBRCH, "%s(%d): if starts on line %zu, orig col is %zu.\n", __func__, __LINE__, br_start->GetOrigLine(), br_start->GetOrigCol()); vector braces; braces.reserve(16); bool must_have_braces = false; bool has_unbraced_block = false; Chunk *pc = br_start; while ( pc != nullptr && pc->IsNotNullChunk()) { LOG_CHUNK(LTOK, pc); if (pc->Is(CT_BRACE_OPEN)) { const bool tmp = can_remove_braces(pc); LOG_FMT(LBRCH, "%s(%d): braces.size() is %zu, line is %zu, - can%s remove %s\n", __func__, __LINE__, braces.size(), pc->GetOrigLine(), tmp ? "" : "not", get_token_name(pc->GetType())); if ( !tmp || options::mod_full_brace_if_chain() == 2) { must_have_braces = true; } } else { const bool tmp = should_add_braces(pc); if (tmp) { must_have_braces = true; } LOG_FMT(LBRCH, "%s(%d): braces.size() is %zu, line is %zu, - %s %s\n", __func__, __LINE__, braces.size(), pc->GetOrigLine(), tmp ? "should add" : "ignore", get_token_name(pc->GetType())); has_unbraced_block = true; } if ( options::mod_full_brace_if_chain() == 3 && !has_unbraced_block) { must_have_braces = true; } braces.push_back(pc); Chunk *br_close = pc->GetClosingParen(E_Scope::PREPROC); if (br_close->IsNullChunk()) { break; } braces.push_back(br_close); pc = br_close->GetNextNcNnl(E_Scope::PREPROC); if ( pc->IsNullChunk() || pc->IsNot(CT_ELSE)) { break; } log_rule_B("mod_full_brace_if_chain_only"); if (options::mod_full_brace_if_chain_only()) { // There is an 'else' - we want full braces. must_have_braces = true; } pc = pc->GetNextNcNnl(E_Scope::PREPROC); if (pc->Is(CT_ELSEIF)) { while ( pc->IsNot(CT_VBRACE_OPEN) && pc->IsNot(CT_BRACE_OPEN)) { pc = pc->GetNextNcNnl(E_Scope::PREPROC); } } if (pc->IsNullChunk()) { break; } if ( pc->IsNot(CT_BRACE_OPEN) && pc->IsNot(CT_VBRACE_OPEN)) { break; } } if (must_have_braces) { LOG_FMT(LBRCH, "%s(%d): add braces on lines[%zu]:", __func__, __LINE__, braces.size()); const auto ite = braces.rend(); for (auto itc = braces.rbegin(); itc != ite; ++itc) { const auto brace = *itc; brace->SetFlagBits(PCF_KEEP_BRACE); if (brace->IsVBrace()) { LOG_FMT(LBRCH, "%s(%d): %zu", __func__, __LINE__, brace->GetOrigLine()); convert_vbrace(brace); } else { LOG_FMT(LBRCH, "%s(%d): {%zu}", __func__, __LINE__, brace->GetOrigLine()); } } LOG_FMT(LBRCH, "\n"); } else if (options::mod_full_brace_if_chain()) { log_rule_B("mod_full_brace_if_chain"); LOG_FMT(LBRCH, "%s(%d): remove braces on lines[%zu]:\n", __func__, __LINE__, braces.size()); /* * This might run because either * mod_full_brace_if_chain or mod_full_brace_if_chain_only * is used. * We only want to remove braces if the first one is active. */ log_rule_B("mod_full_brace_nl_block_rem_mlcond"); const auto multiline_block = options::mod_full_brace_nl_block_rem_mlcond(); LOG_FMT(LBRCH, "%s(%d): remove braces on lines:\n", __func__, __LINE__); // Issue #2229 const auto ite = braces.end(); for (auto itc = braces.begin(); itc != ite; ++itc) { const auto brace = *itc; if ( ( brace->Is(CT_BRACE_OPEN) || brace->Is(CT_BRACE_CLOSE)) && (brace->GetParentType() != CT_BRACED_INIT_LIST) && (multiline_block ? !paren_multiline_before_brace(brace) : true)) { LOG_FMT(LBRCH, "%s(%d): brace orig line is %zu, orig col is %zu\n", __func__, __LINE__, brace->GetOrigLine(), brace->GetOrigCol()); convert_brace(brace); } else { LOG_FMT(LBRCH, "%s(%d): brace orig line is %zu, orig col is %zu\n", __func__, __LINE__, brace->GetOrigLine(), brace->GetOrigCol()); } } } } // process_if_chain static void mod_full_brace_if_chain() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if ( pc->IsBraceOpen() && pc->GetParentType() == CT_IF) { process_if_chain(pc); } } } uncrustify-uncrustify-0.76.0/src/braces.h000066400000000000000000000011351434072136500204340ustar00rootroot00000000000000/** * @file braces.h * prototypes for braces.cpp * * @author Ben Gardner * @license GPL v2+ */ #ifndef BRACES_H_INCLUDED #define BRACES_H_INCLUDED #include "uncrustify_types.h" //! Change virtual braces into real braces void do_braces(); /** * See the preprocessor counterpart: * add_long_preprocessor_conditional_block_comment * in output.cpp */ void add_long_closebrace_comment(); /** * Adds a comment after the ref chunk * Returns the added chunk or nullptr */ Chunk *insert_comment_after(Chunk *ref, E_Token cmt_type, const unc_text &cmt_text); #endif /* BRACES_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/calculate_closing_brace_position.cpp000066400000000000000000000140631434072136500262670ustar00rootroot00000000000000/** * @file calculate_closing_brace_position.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "calculate_closing_brace_position.h" #include "chunk.h" using namespace uncrustify; Chunk *calculate_closing_brace_position(const Chunk *cl_colon, Chunk *pc) { LOG_FMT(LMCB, "%s(%d): cl_colon->Text() is '%s', orig line %zu, orig col is %zu, level is %zu\n", __func__, __LINE__, cl_colon->Text(), cl_colon->GetOrigLine(), cl_colon->GetOrigCol(), cl_colon->GetLevel()); LOG_FMT(LMCB, "%s(%d): pc->Text() is '%s', orig line %zu, orig col is %zu, level is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); // end of block is reached // look back over newline, preprocessor BUT NOT #endif // Issue #3058 // examine going back the tokens: look for a "brace closing" or a "semi colon" until the colon // look back over comment, newline, preprocessor BUT NOT #endif size_t check_level = 0; if (pc->Is(CT_BRACE_CLOSE)) { check_level = pc->GetLevel() + 1; } else { check_level = pc->GetLevel(); } size_t erst_found = 0; Chunk *is_brace_close = Chunk::NullChunkPtr; Chunk *is_semicolon = Chunk::NullChunkPtr; Chunk *is_comment = Chunk::NullChunkPtr; Chunk *back = pc->GetPrevNnl(); while (back->IsNotNullChunk()) { if (back == cl_colon) { break; } if (erst_found != 0) { break; } if (back->GetLevel() == check_level) { if (back->IsBraceClose()) { // brace_close found is_brace_close = back; LOG_FMT(LMCB, "%s(%d): BRACE_CLOSE: line is %zu, col is %zu, level is %zu\n", __func__, __LINE__, is_brace_close->GetOrigLine(), is_brace_close->GetOrigCol(), is_brace_close->GetLevel()); erst_found = 3; } if (back->Is(CT_SEMICOLON)) { // semicolon found is_semicolon = back; LOG_FMT(LMCB, "%s(%d): SEMICOLON: line is %zu, col is %zu, level is %zu\n", __func__, __LINE__, is_semicolon->GetOrigLine(), is_semicolon->GetOrigCol(), is_semicolon->GetLevel()); erst_found = 4; } if (back->IsComment()) { // comment found is_comment = back; LOG_FMT(LMCB, "%s(%d): COMMENT: line is %zu, col is %zu, level is %zu\n", __func__, __LINE__, back->GetOrigLine(), back->GetOrigCol(), back->GetLevel()); } } back = back->GetPrev(); } LOG_FMT(LMCB, "%s(%d): erst_found is %zu\n", __func__, __LINE__, erst_found); Chunk *last = Chunk::NullChunkPtr; if ( erst_found == 3 || erst_found == 4) { if (is_comment->IsNotNullChunk()) { Chunk *second = Chunk::NullChunkPtr; if (erst_found == 3) { second = is_brace_close; } else { // erst_found == 4 second = is_semicolon; } if (second->IsNotNullChunk()) { if (is_comment->GetOrigLine() == second->GetOrigLine()) { last = is_comment; if (cl_colon->GetOrigLine() == is_comment->GetOrigLine()) { last = is_comment->GetNext(); } } else { last = pc->GetPrevNcNnl(); } } else { LOG_FMT(LMCB, "\n\n%s(%d):\n", __func__, __LINE__); fprintf(stderr, "FATAL: second is nullptr\n"); fprintf(stderr, "Please make a report.\n"); exit(EX_SOFTWARE); } } else { last = pc->GetPrevNcNnl(); } } else { LOG_FMT(LMCB, "\n\n%s(%d):\n", __func__, __LINE__); fprintf(stderr, "FATAL: erst_found is not 3 or 4\n"); fprintf(stderr, "Please make a report.\n"); exit(EX_SOFTWARE); } if (last->Is(CT_COMMENT_CPP)) // Issue #3058 { last = last->GetNext(); } LOG_FMT(LMCB, "%s(%d): last->Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, last->Text(), last->GetOrigLine(), last->GetOrigCol()); if (last->IsPreproc()) { // we have a preprocessor token while (last->IsNotNullChunk()) { LOG_FMT(LMCB, "%s(%d): Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, last->Text(), last->GetOrigLine(), last->GetOrigCol()); if (last->Is(CT_PP_ENDIF)) { // look for the parent and compare the positions Chunk *parent_last = last->GetParent(); int comp = parent_last->ComparePosition(cl_colon); LOG_FMT(LMCB, "%s(%d): comp is %d\n", __func__, __LINE__, comp); if (comp == -1) { // cl_colon is after parent_last ==> // the closing brace will be set before #endif Chunk *pp_start = last->GetPpStart(); last = pp_start->GetPrevNnl(); LOG_FMT(LMCB, "%s(%d): Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, last->Text(), last->GetOrigLine(), last->GetOrigCol()); } else if (comp == 1) { // cl_colon is before parent_last ==> // the closing brace will be set after #endif LOG_FMT(LMCB, "%s(%d): Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, last->Text(), last->GetOrigLine(), last->GetOrigCol()); } break; } last = last->GetPrevNcNnl(); LOG_FMT(LMCB, "%s(%d): Text() is '%s', orig line %zu, orig col is %zu\n", __func__, __LINE__, last->Text(), last->GetOrigLine(), last->GetOrigCol()); if (!last->IsPreproc()) { break; } } } return(last); } // calculate_closing_brace_position uncrustify-uncrustify-0.76.0/src/calculate_closing_brace_position.h000066400000000000000000000006501434072136500257310ustar00rootroot00000000000000/** * @file calculate_closing_brace_position.h * prototype for calculate_closing_brace_position.cpp * * @author Guy Maurel * @license GPL v2+ */ #ifndef CALCULATE_CLOSING_BRACE_POSITION_H_INCLUDED #define CALCULATE_CLOSING_BRACE_POSITION_H_INCLUDED #include "uncrustify_types.h" Chunk *calculate_closing_brace_position(const Chunk *cl_colon, Chunk *pc); #endif /* CALCULATE_CLOSING_BRACE_POSITION_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/change_int_types.cpp000066400000000000000000000121001434072136500230450ustar00rootroot00000000000000/** * @file change_int_types.cpp * * @author Alex Henrie * @license GPL v2+ */ #include "change_int_types.h" #include "chunk.h" #include "uncrustify.h" using namespace uncrustify; static bool is_storage_keyword(const Chunk *pc) { return( strcmp(pc->Text(), "auto") == 0 || strcmp(pc->Text(), "const") == 0 || strcmp(pc->Text(), "extern") == 0 || strcmp(pc->Text(), "mutable") == 0 || strcmp(pc->Text(), "register") == 0 || strcmp(pc->Text(), "static") == 0 || strcmp(pc->Text(), "thread_local") == 0 || strcmp(pc->Text(), "typedef") == 0 || strcmp(pc->Text(), "volatile") == 0 || strcmp(pc->Text(), "_Atomic") == 0 || strcmp(pc->Text(), "_Thread_local") == 0); } static bool is_non_integer(const Chunk *pc) { return( strcmp(pc->Text(), "char") == 0 || strcmp(pc->Text(), "double") == 0); } static bool find_non_storage_siblings(const Chunk *pc, Chunk * &prev, Chunk * &next) { prev = pc->GetPrevNcNnl(); next = pc->GetNextNcNnl(); // Find the last token that was not a storage keyword while (is_storage_keyword(prev)) { prev = prev->GetPrevNcNnl(); } // Return false if the last token indicates that this is not an integer type if (is_non_integer(prev)) { return(false); } // Find the next token that is not a storage keyword while (is_storage_keyword(next)) { next = next->GetNextNcNnl(); } // Return false if the next token indicates that this is not an integer type if (is_non_integer(next)) { return(false); } // Return true if this is indeed an integer type return(true); } static void add_or_remove_int_keyword(Chunk *pc, Chunk *sibling, iarf_e action, E_Direction dir, Chunk * &int_keyword) { if (strcmp(sibling->Text(), "int") == 0) { if (action == IARF_REMOVE) { if (sibling == int_keyword) { int_keyword = nullptr; } Chunk::Delete(sibling); } else if ( int_keyword != nullptr && int_keyword != sibling) { // We added an int keyword, but now we see that there already was one. // Keep one or the other but not both. if (options::mod_int_prefer_int_on_left()) { Chunk::Delete(sibling); } else { Chunk::Delete(int_keyword); int_keyword = sibling; } } else { int_keyword = sibling; } } else { if ( action == IARF_ADD || action == IARF_FORCE) { if (int_keyword) { // There was already an int keyword. Either keep it and don't add a // new one or delete it to make way for the new one. if (options::mod_int_prefer_int_on_left()) { return; } else { Chunk::Delete(int_keyword); } } if (dir == E_Direction::BACKWARD) { int_keyword = pc->CopyAndAddBefore(pc); } else { int_keyword = pc->CopyAndAddAfter(pc); } int_keyword->Str() = "int"; } } } // add_or_remove_int_keyword void change_int_types() { LOG_FUNC_ENTRY(); Chunk *prev; Chunk *next; Chunk *int_keyword = nullptr; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if (strcmp(pc->Text(), "short") == 0) { if (find_non_storage_siblings(pc, prev, next)) { add_or_remove_int_keyword(pc, prev, options::mod_int_short(), E_Direction::BACKWARD, int_keyword); add_or_remove_int_keyword(pc, next, options::mod_short_int(), E_Direction::FORWARD, int_keyword); } } else if (strcmp(pc->Text(), "long") == 0) { if (find_non_storage_siblings(pc, prev, next)) { add_or_remove_int_keyword(pc, prev, options::mod_int_long(), E_Direction::BACKWARD, int_keyword); add_or_remove_int_keyword(pc, next, options::mod_long_int(), E_Direction::FORWARD, int_keyword); } } else if (strcmp(pc->Text(), "signed") == 0) { if (find_non_storage_siblings(pc, prev, next)) { add_or_remove_int_keyword(pc, prev, options::mod_int_signed(), E_Direction::BACKWARD, int_keyword); add_or_remove_int_keyword(pc, next, options::mod_signed_int(), E_Direction::FORWARD, int_keyword); } } else if (strcmp(pc->Text(), "unsigned") == 0) { if (find_non_storage_siblings(pc, prev, next)) { add_or_remove_int_keyword(pc, prev, options::mod_int_unsigned(), E_Direction::BACKWARD, int_keyword); add_or_remove_int_keyword(pc, next, options::mod_unsigned_int(), E_Direction::FORWARD, int_keyword); } } else if ( strcmp(pc->Text(), "int") != 0 && !is_storage_keyword(pc)) { int_keyword = nullptr; // We are no longer in a variable declaration } } } // change_int_types uncrustify-uncrustify-0.76.0/src/change_int_types.h000066400000000000000000000005221434072136500225170ustar00rootroot00000000000000/** * @file change_int_types.h * prototypes for change_int_types.cpp * * @author Alex Henrie * @license GPL v2+ */ #ifndef CHANGE_INT_TYPES_H_INCLUDED #define CHANGE_INT_TYPES_H_INCLUDED /** * @brief Add or remove redundant 'int' keyword of integer types */ void change_int_types(); #endif /* CHANGE_INT_TYPES_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/char_table.h000066400000000000000000000046711434072136500212710ustar00rootroot00000000000000/** * @file char_table.h * A simple table to help tokenize stuff. * Used to parse strings (paired char) and words. * * @author Ben Gardner * @license GPL v2+ */ #ifndef CHAR_TABLE_H_INCLUDED #define CHAR_TABLE_H_INCLUDED #include "base_types.h" #include /** * bit0-7 = paired char * bit8 = OK for keyword 1st char * bit9 = OK for keyword 2+ char */ struct CharTable { static size_t chars[128]; enum { KW1 = 0x0100, KW2 = 0x0200, }; static inline size_t Get(size_t ch) { if (ch < ARRAY_SIZE(chars)) { return(chars[ch]); } /* * HACK: If the top bit is set, then we are likely dealing with UTF-8, * and since that is only allowed in identifiers, then assume that is * what this is. This only prevents corruption, it does not properly * handle UTF-8 because the byte length and screen size are assumed to be * the same. */ return(KW1 | KW2); } static inline bool IsKw1(size_t ch) { return((Get(ch) & KW1) != 0); } static inline bool IsKw2(size_t ch) { return((Get(ch) & KW2) != 0); } }; #ifdef DEFINE_CHAR_TABLE size_t CharTable::chars[128] = { 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, // [........] 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, // [........] 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, // [........] 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, // [........] 0x000, 0x000, 0x022, 0x000, 0x300, 0x000, 0x000, 0x027, // [ !"#$%&'] 0x029, 0x028, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, // [()*+,-./] 0x200, 0x200, 0x200, 0x200, 0x200, 0x200, 0x200, 0x200, // [01234567] 0x200, 0x200, 0x000, 0x000, 0x03e, 0x000, 0x03c, 0x000, // [89:;<=>?] 0x200, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, // [@ABCDEFG] 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, // [HIJKLMNO] 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, // [PQRSTUVW] 0x300, 0x300, 0x300, 0x05d, 0x000, 0x05b, 0x000, 0x300, // [XYZ[\]^_] 0x060, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, // [`abcdefg] 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, // [hijklmno] 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, 0x300, // [pqrstuvw] 0x300, 0x300, 0x300, 0x07d, 0x000, 0x07b, 0x000, 0x000, // [xyz{|}~.] }; #endif /* DEFINE_CHAR_TABLE */ #endif /* CHAR_TABLE_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/chunk.cpp000066400000000000000000000506111434072136500206430ustar00rootroot00000000000000/** * @file chunk.cpp * Manages and navigates the list of chunks. * * @author Ben Gardner * @license GPL v2+ */ #include "chunk.h" #include "ListManager.h" #include "prototypes.h" #include "space.h" static ChunkListManager gChunkList; // global chunk list /* * Chunk class methods */ // Null Chunk Chunk Chunk::NullChunk(true); Chunk *const Chunk::NullChunkPtr(&Chunk::NullChunk); void Chunk::CopyFrom(const Chunk &o) { m_type = o.m_type; m_parentType = o.m_parentType; m_origLine = o.m_origLine; m_origCol = o.m_origCol; m_origColEnd = o.m_origColEnd; m_origPrevSp = o.m_origPrevSp; m_column = o.m_column; m_columnIndent = o.m_columnIndent; m_nlCount = o.m_nlCount; m_nlColumn = o.m_nlColumn; m_level = o.m_level; m_braceLevel = o.m_braceLevel; m_ppLevel = o.m_ppLevel; m_afterTab = o.m_afterTab; m_flags = o.m_flags; m_alignmentData = o.m_alignmentData; m_indentData = o.m_indentData; m_next = Chunk::NullChunkPtr; m_prev = Chunk::NullChunkPtr; m_parent = Chunk::NullChunkPtr; m_str = o.m_str; m_trackingData = o.m_trackingData; } void Chunk::Reset() { m_type = CT_NONE; m_parentType = CT_NONE; m_origLine = 0; m_origCol = 0; m_origColEnd = 0; m_origPrevSp = 0; m_column = 0; m_columnIndent = 0; m_nlCount = 0; m_nlColumn = 0; m_level = 0; m_braceLevel = 0; m_ppLevel = 999; // use a big value to find some errors m_afterTab = false; m_flags = PCF_NONE; memset(&m_alignmentData, 0, sizeof(m_alignmentData)); memset(&m_indentData, 0, sizeof(m_indentData)); m_next = Chunk::NullChunkPtr; m_prev = Chunk::NullChunkPtr; m_parent = Chunk::NullChunkPtr; // for debugging purpose only m_str.clear(); m_trackingData = nullptr; } const char *Chunk::ElidedText(char *for_the_copy) const { const char *test_it = Text(); size_t test_it_length = strlen(test_it); size_t truncate_value = uncrustify::options::debug_truncate(); if (truncate_value != 0) { if (test_it_length > truncate_value) { memset(for_the_copy, 0, 1000); if (test_it_length < truncate_value + 30) { strncpy(for_the_copy, test_it, truncate_value - 30); for_the_copy[truncate_value - 30] = 0; } else { strncpy(for_the_copy, test_it, truncate_value); for_the_copy[truncate_value] = 0; } char *message = strcat(for_the_copy, " ... "); return(message); } else { return(test_it); } } return(test_it); } Chunk *Chunk::GetNext(const E_Scope scope) const { if (scope == E_Scope::ALL) { return(m_next); } Chunk *pc = m_next; if (TestFlags(PCF_IN_PREPROC)) { // If in a preproc, return a null chunk if trying to leave if (!pc->TestFlags(PCF_IN_PREPROC)) { return(NullChunkPtr); } return(pc); } // Not in a preproc, skip any preproc while ( pc->IsNotNullChunk() && pc->TestFlags(PCF_IN_PREPROC)) { pc = pc->m_next; } return(pc); } // Chunk::GetNext Chunk *Chunk::GetPrev(const E_Scope scope) const { if (scope == E_Scope::ALL) { return(m_prev); } Chunk *pc = m_prev; if (TestFlags(PCF_IN_PREPROC)) { // If in a preproc, return a null chunk if trying to leave if (!pc->TestFlags(PCF_IN_PREPROC)) { return(NullChunkPtr); } return(pc); } // Not in a preproc, skip any preproc while ( pc->IsNotNullChunk() && pc->TestFlags(PCF_IN_PREPROC)) { pc = pc->m_prev; } return(pc); } // Chunk::GetPrev static void chunk_log(Chunk *pc, const char *text); Chunk *Chunk::GetHead() { return(gChunkList.GetHead()); } Chunk *Chunk::GetTail() { return(gChunkList.GetTail()); } Chunk::T_SearchFnPtr Chunk::GetSearchFn(const E_Direction dir) { return((dir == E_Direction::FORWARD) ? &Chunk::GetNext : &Chunk::GetPrev); } Chunk *Chunk::Search(const T_CheckFnPtr checkFn, const E_Scope scope, const E_Direction dir, const bool cond) const { T_SearchFnPtr searchFnPtr = GetSearchFn(dir); Chunk *pc = const_cast(this); do // loop over the chunk list { pc = (pc->*searchFnPtr)(scope); // in either direction while } while ( pc->IsNotNullChunk() // the end of the list was not reached yet && ((pc->*checkFn)() != cond)); // and the demanded chunk was not found either return(pc); // the latest chunk is the searched one } bool Chunk::IsOnSameLine(const Chunk *end) const { if (IsNullChunk()) { return(false); } Chunk *tmp = GetNext(); while ( tmp->IsNotNullChunk() && tmp != end) { if (tmp->Is(CT_NEWLINE)) { return(false); } tmp = tmp->GetNext(); } return(true); } Chunk *Chunk::SearchTypeLevel(const E_Token type, const E_Scope scope, const E_Direction dir, const int level) const { T_SearchFnPtr searchFnPtr = GetSearchFn(dir); Chunk *pc = const_cast(this); do // loop over the chunk list { pc = (pc->*searchFnPtr)(scope); // in either direction while } while ( pc->IsNotNullChunk() // the end of the list was not reached yet && (!pc->IsTypeAndLevel(type, level))); // and the chunk was not found either return(pc); // the latest chunk is the searched one } Chunk *Chunk::SearchStringLevel(const char *cStr, const size_t len, int level, const E_Scope scope, const E_Direction dir) const { T_SearchFnPtr searchFnPtr = GetSearchFn(dir); Chunk *pc = const_cast(this); do // loop over the chunk list { pc = (pc->*searchFnPtr)(scope); // in either direction while } while ( pc->IsNotNullChunk() // the end of the list was not reached yet && !pc->IsStringAndLevel(cStr, len, true, level)); // and the demanded chunk was not found either return(pc); // the latest chunk is the searched one } Chunk *Chunk::SearchPpa(const T_CheckFnPtr checkFn, const bool cond) const { if (!TestFlags(PCF_IN_PREPROC)) { // if not in preprocessor, do a regular search return(Search(checkFn, E_Scope::ALL, E_Direction::FORWARD, cond)); } Chunk *pc = GetNext(); while (pc->IsNotNullChunk()) { if (!pc->TestFlags(PCF_IN_PREPROC)) { // Bail if we run off the end of the preprocessor directive, but return // the token because the caller may need to know where the search ended assert(pc->Is(CT_NEWLINE)); return(pc); } if (pc->Is(CT_NL_CONT)) { // Skip line continuation pc = pc->GetNext(); continue; } if ((pc->*checkFn)() == cond) { // Requested token was found return(pc); } pc = pc->GetNext(); } // Ran out of tokens return(Chunk::NullChunkPtr); } static void chunk_log_msg(Chunk *chunk, const log_sev_t log, const char *str) { LOG_FMT(log, "%s orig line is %zu, orig col is %zu, ", str, chunk->GetOrigLine(), chunk->GetOrigCol()); if (chunk->Is(CT_NEWLINE)) { LOG_FMT(log, ",\n"); } else if (chunk->Is(CT_VBRACE_OPEN)) { LOG_FMT(log, ",\n"); } else if (chunk->Is(CT_VBRACE_CLOSE)) { LOG_FMT(log, ",\n"); } else { LOG_FMT(log, "Text() is '%s', type is %s,\n", chunk->Text(), get_token_name(chunk->GetType())); } } static void chunk_log(Chunk *pc, const char *text) { if ( pc != nullptr && pc->IsNotNullChunk() && (cpd.unc_stage != unc_stage_e::TOKENIZE) && (cpd.unc_stage != unc_stage_e::CLEANUP)) { const log_sev_t log = LCHUNK; Chunk *prev = pc->GetPrev(); Chunk *next = pc->GetNext(); chunk_log_msg(pc, log, text); if ( prev->IsNotNullChunk() && next->IsNotNullChunk()) { chunk_log_msg(prev, log, " @ between"); chunk_log_msg(next, log, " and"); } else if (next->IsNotNullChunk()) { chunk_log_msg(next, log, " @ before"); } else if (prev->IsNotNullChunk()) { chunk_log_msg(prev, log, " @ after"); } LOG_FMT(log, " stage is %s", // Issue #3034 get_unc_stage_name(cpd.unc_stage)); log_func_stack_inline(log); } } void Chunk::Delete(Chunk * &pc) { gChunkList.Remove(pc); delete pc; pc = Chunk::NullChunkPtr; } void Chunk::MoveAfter(Chunk *ref) { LOG_FUNC_ENTRY(); if (ref == this) { return; } gChunkList.Remove(this); gChunkList.AddAfter(this, ref); // Adjust the original column m_column = ref->m_column + space_col_align(ref, this); m_origCol = m_column; m_origColEnd = m_origCol + Len(); } void Chunk::Swap(Chunk *other) { gChunkList.Swap(this, other); } bool Chunk::IsAddress() const { if ( IsNotNullChunk() && ( Is(CT_BYREF) || ( Len() == 1 && m_str[0] == '&' && IsNot(CT_OPERATOR_VAL)))) { Chunk *prevc = GetPrev(); if ( TestFlags(PCF_IN_TEMPLATE) && ( prevc->Is(CT_COMMA) || prevc->Is(CT_ANGLE_OPEN))) { return(false); } return(true); } return(false); } Chunk *Chunk::GetFirstChunkOnLine() const { Chunk *pc = const_cast(this); Chunk *first = pc; pc = pc->GetPrev(); while ( pc->IsNotNullChunk() && !pc->IsNewline()) { first = pc; pc = pc->GetPrev(); } return(first); } bool Chunk::IsLastChunkOnLine() const { if (this == Chunk::GetTail()) { return(true); } // if the next chunk is a newline then pc is the last chunk on its line if (GetNext()->Is(CT_NEWLINE)) { return(true); } return(false); } void Chunk::SwapLines(Chunk *other) { // to swap lines we need to find the first chunk of the lines Chunk *pc1 = GetFirstChunkOnLine(); Chunk *pc2 = other->GetFirstChunkOnLine(); if ( pc1->IsNullChunk() || pc2->IsNullChunk() || pc1 == pc2) { return; } /* * Example start: * ? - start1 - a1 - b1 - nl1 - ? - ref2 - start2 - a2 - b2 - nl2 - ? * ^- pc1 ^- pc2 */ Chunk *ref2 = pc2->GetPrev(); // Move the line started at pc2 before pc1 while ( pc2->IsNotNullChunk() && !pc2->IsNewline()) { Chunk *tmp = pc2->GetNext(); gChunkList.Remove(pc2); gChunkList.AddBefore(pc2, pc1); pc2 = tmp; } /* * Should now be: * ? - start2 - a2 - b2 - start1 - a1 - b1 - nl1 - ? - ref2 - nl2 - ? * ^- pc1 ^- pc2 */ // Now move the line started at pc1 after ref2 while ( pc1->IsNotNullChunk() && !pc1->IsNewline()) { Chunk *tmp = pc1->GetNext(); gChunkList.Remove(pc1); if (ref2->IsNotNullChunk()) { gChunkList.AddAfter(pc1, ref2); } else { gChunkList.AddHead(pc1); } ref2 = pc1; pc1 = tmp; } /* * Should now be: * ? - start2 - a2 - b2 - nl1 - ? - ref2 - start1 - a1 - b1 - nl2 - ? * ^- pc1 ^- pc2 */ /* * pc1 and pc2 should be the newlines for their lines. * swap the chunks and the new line count so that the spacing remains the same. */ if ( pc1->IsNotNullChunk() && pc2->IsNotNullChunk()) { size_t nlCount = pc1->GetNlCount(); pc1->SetNlCount(pc2->GetNlCount()); pc2->SetNlCount(nlCount); pc1->Swap(pc2); } } // Chunk::SwapLines void Chunk::SetResetFlags(T_PcfFlags resetBits, T_PcfFlags setBits) { if (IsNotNullChunk()) { LOG_FUNC_ENTRY(); const T_PcfFlags newFlags = (m_flags & ~resetBits) | setBits; if (m_flags != newFlags) { LOG_FMT(LSETFLG, "%s(%d): %016llx^%016llx=%016llx\n" "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s,", __func__, __LINE__, static_cast(m_flags), static_cast(m_flags ^ newFlags), static_cast(newFlags), __func__, __LINE__, m_origLine, m_origCol, Text(), get_token_name(m_type)); LOG_FMT(LSETFLG, " parent type is %s,\n", get_token_name(m_parentType)); log_func_stack_inline(LSETFLG); LOG_FMT(LSETFLG, " before: "); log_pcf_flags(LSETFLG, m_flags); LOG_FMT(LSETFLG, " after: "); log_pcf_flags(LSETFLG, newFlags); m_flags = newFlags; } } } void Chunk::SetTypeReal(const E_Token token, const char *func, const int line) { LOG_FUNC_ENTRY(); if ( IsNullChunk() || m_type == token) { return; } LOG_FMT(LSETTYP, "%s(%d): orig line is %zu, orig col is %zu, Text() is ", func, line, m_origLine, m_origCol); if (token == CT_NEWLINE) { LOG_FMT(LSETTYP, "\n"); } else { LOG_FMT(LSETTYP, "'%s'\n", Text()); } LOG_FMT(LSETTYP, " type is %s, parent type is %s => new type is %s\n", get_token_name(m_type), get_token_name(m_parentType), get_token_name(token)); m_type = token; } void Chunk::SetParentTypeReal(const E_Token token, const char *func, const int line) { LOG_FUNC_ENTRY(); if ( IsNullChunk() || m_parentType == token) { return; } LOG_FMT(LSETPAR, "%s(%d): orig line is %zu, orig col is %zu, Text() is ", func, line, m_origLine, m_origCol); if (token == CT_NEWLINE) { LOG_FMT(LSETPAR, "\n"); } else { LOG_FMT(LSETPAR, "'%s'\n", Text()); } LOG_FMT(LSETPAR, " type is %s, parent type is %s => new parent type is %s\n", get_token_name(m_type), get_token_name(m_parentType), get_token_name(token)); m_parentType = token; } Chunk *Chunk::CopyAndAdd(Chunk *pos, const E_Direction dir) const { #ifdef DEBUG // test if this chunk is properly set if (m_ppLevel == 999) { fprintf(stderr, "%s(%d): pp level is not set\n", __func__, __LINE__); log_func_stack_inline(LSETFLG); log_flush(true); exit(EX_SOFTWARE); } if (m_origLine == 0) { fprintf(stderr, "%s(%d): no line number\n", __func__, __LINE__); log_func_stack_inline(LSETFLG); log_flush(true); exit(EX_SOFTWARE); } if (m_origCol == 0) { fprintf(stderr, "%s(%d): no column number\n", __func__, __LINE__); log_func_stack_inline(LSETFLG); log_flush(true); exit(EX_SOFTWARE); } #endif /* DEBUG */ Chunk *pc = new Chunk(*this); if ( pos != nullptr && pos->IsNotNullChunk()) { (dir == E_Direction::FORWARD) ? gChunkList.AddAfter(pc, pos) : gChunkList.AddBefore(pc, pos); } else { (dir == E_Direction::FORWARD) ? gChunkList.AddHead(pc) : gChunkList.AddTail(pc); } chunk_log(pc, "CopyAndAdd(A):"); return(pc); } // Chunk::CopyAndAdd Chunk *Chunk::GetNextNbsb() const { Chunk *pc = const_cast(this); while ( pc->Is(CT_TSQUARE) || pc->Is(CT_SQUARE_OPEN)) { if (pc->Is(CT_SQUARE_OPEN)) { pc = pc->GetClosingParen(); } pc = pc->GetNextNcNnl(); } return(pc); } Chunk *Chunk::GetPrevNbsb() const { Chunk *pc = const_cast(this); while ( pc->Is(CT_TSQUARE) || pc->Is(CT_SQUARE_CLOSE)) { if (pc->Is(CT_SQUARE_CLOSE)) { pc = pc->GetOpeningParen(); } pc = pc->GetPrevNcNnl(); } return(pc); } Chunk *Chunk::GetPpStart() const { if (!IsPreproc()) { return(Chunk::NullChunkPtr); } Chunk *pc = const_cast(this); while (pc->IsNot(CT_PREPROC)) { pc = pc->GetPrev(E_Scope::PREPROC); } return(pc); } Chunk *Chunk::SkipDcMember() const { LOG_FUNC_ENTRY(); Chunk *pc = const_cast(this); Chunk *nxt = pc->Is(CT_DC_MEMBER) ? pc : pc->GetNextNcNnl(E_Scope::ALL); while (nxt->Is(CT_DC_MEMBER)) { pc = nxt->GetNextNcNnl(E_Scope::ALL); if (pc->IsNullChunk()) { return(Chunk::NullChunkPtr); } nxt = pc->GetNextNcNnl(E_Scope::ALL); } return(pc); } int Chunk::ComparePosition(const Chunk *other) const { if (m_origLine < other->m_origLine) { return(-1); } else if (m_origLine == other->m_origLine) { if (m_origCol < other->m_origCol) { return(-1); } else if (m_origCol == other->m_origCol) { return(0); } } return(1); } bool Chunk::IsOCForinOpenParen() const { if ( language_is_set(LANG_OC) && Is(CT_SPAREN_OPEN) && GetPrevNcNnl()->Is(CT_FOR)) { Chunk *nxt = const_cast(this); while ( nxt->IsNotNullChunk() && nxt->IsNot(CT_SPAREN_CLOSE) && nxt->IsNot(CT_IN)) { nxt = nxt->GetNextNcNnl(); } if (nxt->Is(CT_IN)) { return(true); } } return(false); } bool Chunk::IsStringAndLevel(const char *cStr, const size_t len, bool caseSensitive, const int level) const { return( ( level < 0 || m_level == static_cast(level)) && Len() == len // the length is as expected && ( ( caseSensitive && memcmp(Text(), cStr, len) == 0) || ( !caseSensitive && strncasecmp(Text(), cStr, len) == 0))); // the strings are equal } Chunk *Chunk::GetClosingParen(E_Scope scope) const { if ( Is(CT_PAREN_OPEN) || Is(CT_SPAREN_OPEN) || Is(CT_FPAREN_OPEN) || Is(CT_TPAREN_OPEN) || Is(CT_BRACE_OPEN) || Is(CT_VBRACE_OPEN) || Is(CT_ANGLE_OPEN) || Is(CT_SQUARE_OPEN)) { return(GetNextType((E_Token)(m_type + 1), m_level, scope)); } return(const_cast(this)); } Chunk *Chunk::GetOpeningParen(E_Scope scope) const { if ( Is(CT_PAREN_CLOSE) || Is(CT_SPAREN_CLOSE) || Is(CT_FPAREN_CLOSE) || Is(CT_TPAREN_CLOSE) || Is(CT_BRACE_CLOSE) || Is(CT_VBRACE_CLOSE) || Is(CT_ANGLE_CLOSE) || Is(CT_SQUARE_CLOSE)) { return(GetPrevType((E_Token)(m_type - 1), m_level, scope)); } return(const_cast(this)); } bool Chunk::IsCppInheritanceAccessSpecifier() const { return( language_is_set(LANG_CPP) && ( Is(CT_ACCESS) || Is(CT_QUALIFIER)) && ( IsString("private") || IsString("protected") || IsString("public"))); } bool Chunk::IsColon() const { return( Is(CT_ACCESS_COLON) || Is(CT_ASM_COLON) || Is(CT_BIT_COLON) || Is(CT_CASE_COLON) || Is(CT_CLASS_COLON) || Is(CT_COLON) || Is(CT_COND_COLON) || Is(CT_CONSTR_COLON) || Is(CT_CS_SQ_COLON) || Is(CT_D_ARRAY_COLON) || Is(CT_FOR_COLON) || Is(CT_LABEL_COLON) || Is(CT_OC_COLON) || Is(CT_OC_DICT_COLON) || Is(CT_TAG_COLON) || Is(CT_WHERE_COLON)); } bool Chunk::IsDoxygenComment() const { if (!IsComment()) { return(false); } if (Len() < 3) { return(false); } // check the third character const char *sComment = Text(); return( (sComment[2] == '/') || (sComment[2] == '!') || (sComment[2] == '@')); } bool Chunk::IsTypeDefinition() const { return( Is(CT_TYPE) || Is(CT_PTR_TYPE) || Is(CT_BYREF) || Is(CT_DC_MEMBER) || Is(CT_QUALIFIER) || Is(CT_STRUCT) || Is(CT_ENUM) || Is(CT_UNION)); } bool Chunk::IsNewlineBetween(const Chunk *other) const { Chunk *pc = const_cast(this); while (pc != other) { if (pc->IsNewline()) { return(true); } pc = pc->GetNext(); } return(false); } uncrustify-uncrustify-0.76.0/src/chunk.h000066400000000000000000001366611434072136500203220ustar00rootroot00000000000000/** * @file chunk.h * Manages and navigates the list of chunks. * * @author Ben Gardner * @license GPL v2+ */ #ifndef CHUNK_LIST_H_INCLUDED #define CHUNK_LIST_H_INCLUDED #include "uncrustify_types.h" // necessary to not sort it #include "char_table.h" #include "language_tools.h" static constexpr int ANY_LEVEL = -1; /** * Specifies which chunks should/should not be found. * ALL (default) * - return the true next/prev * * PREPROC * - If not in a preprocessor, skip over any encountered preprocessor stuff * - If in a preprocessor, fail to leave (return Chunk::NullChunkPtr) */ enum class E_Scope : unsigned int { ALL, //! search in all kind of chunks PREPROC, //! search only in preprocessor chunks }; /** * Specifies which direction or location an operation shall be performed. */ enum class E_Direction : unsigned int { FORWARD, BACKWARD }; class ChunkListManager; // This is the main type of this program class Chunk { friend ChunkListManager; public: //! constructors Chunk(bool null_c = false); // default Chunk(const Chunk &o); // !!! partial copy: chunk is not linked to others Chunk &operator=(const Chunk &o); // !!! partial copy: chunk is not linked to others //! whether this is a null Chunk or not bool IsNullChunk() const { return(null_chunk); } bool IsNotNullChunk() const { return(!null_chunk); } //! sets all elements of the struct to their default value void Reset(); // --------- Access methods /** * @brief returns the type of the chunk */ E_Token GetType() const; /** * @brief Sets the chunk type * @param token the type to set * @param func the name of the function from where this method is called (for log purposes) * @param line the line number from where this method is called (for log purposes) */ void SetTypeReal(const E_Token token, const char *func, const int line); /** * @brief Returns the parent type of the chunk */ E_Token GetParentType() const; /** * @brief Sets the type of the parent chunk * @param token the type to set * @param func the name of the function from where this method is called (for log purposes) * @param line the line number from where this method is called (for log purposes) */ void SetParentTypeReal(const E_Token token, const char *func, const int line); /** * @brief Returns the parent of the chunk */ Chunk *GetParent() const; /** * @brief Sets the parent of the chunk * @param parent the parent chunk to set */ void SetParent(Chunk *parent); /** * @brief Returns the alignment data of the chunk as a const reference */ const T_AlignData &GetAlignmentData() const; /** * @brief Returns the alignment data of the chunk as a modifiable reference */ T_AlignData &AlignmentData(); /** * @brief Returns the indentation data of the chunk as a const reference */ const T_IndentData &GetIndentData() const; /** * @brief Returns the indentation data of the chunk as a modifiable reference */ T_IndentData &IndentData(); /** * @brief Returns the text data of the chunk as a const reference */ const unc_text &GetStr() const; /** * @brief Returns the text data of the chunk as a modifiable reference */ unc_text &Str(); /** * @brief returns the number of characters in the chunk text string */ size_t Len() const; /** * @brief returns the content of the chunk text as C string */ const char *Text() const; /** * Returns a filled up (if necessary) copy of the first chars of the Text() string */ const char *ElidedText(char *for_the_copy) const; /** * @brief Returns the tracking data of the chunk as a const reference */ const track_list *GetTrackingData() const; /** * @brief Returns the tracking data of the chunk as a modifiable reference */ track_list * &TrackingData(); /** * @brief Returns the type of the parent chunk */ E_Token GetTypeOfParent() const; /** * @brief Returns the chunk flags */ T_PcfFlags GetFlags() const; /** * @brief Sets the chunk flags * @param flags the new chunk flags */ void SetFlags(T_PcfFlags flags); /** * @brief Tests if some chunk flags are set * @param flags the flag bits to test * @return true if the specified bits are set, false otherwise */ bool TestFlags(T_PcfFlags flags) const; /** * @brief Resets some of the chunk flag bits * @param resetBits the flag bits to reset */ void ResetFlagBits(T_PcfFlags resetBits); /** * @brief Sets some of the chunk flag bits * @param setBits the flag bits to set */ void SetFlagBits(T_PcfFlags setBits); /** * @brief Sets and reset some of the chunk flag bits * @param resetBits the flag bits to reset * @param setBits the flag bits to set */ void UpdateFlagBits(T_PcfFlags resetBits, T_PcfFlags setBits); /** * @brief Returns the line number of the chunk in the input file */ size_t GetOrigLine() const; /** * @brief Sets the line number of the chunk in the input file * @param line the line number of the chunk */ void SetOrigLine(size_t line); /** * @brief Returns the column number of the chunk in the input file */ size_t GetOrigCol() const; /** * @brief Sets the column number of the chunk in the input file * @param col the column number of the chunk */ void SetOrigCol(size_t col); /** * @brief Returns the end column number of the chunk in the input file */ size_t GetOrigColEnd() const; /** * @brief Sets the end column number of the chunk in the input file * @param col the end column number of the chunk */ void SetOrigColEnd(size_t col); /** * @brief Returns the position of the whitespace before this chunk */ size_t GetOrigPrevSp() const; /** * @brief Sets the position of the whitespace before this chunk * @param col the end column number of the chunk in the input file */ void SetOrigPrevSp(size_t col); /** * @brief Returns the column of the chunk */ size_t GetColumn() const; /** * @brief Sets the column of the chunk * @param col the column of the chunk */ void SetColumn(size_t col); /** * @brief Returns the column indentation of the chunk */ size_t GetColumnIndent() const; /** * @brief Sets the column indentation of the chunk * @param col the column indentation of the chunk */ void SetColumnIndent(size_t col); /** * @brief Returns the number of newlines in a CT_NEWLINE chunk */ size_t GetNlCount() const; /** * @brief Sets the number of newlines in a CT_NEWLINE chunk * @param cnt the number of newlines */ void SetNlCount(size_t cnt); /** * @brief Returns the column of the newline entries */ size_t GetNlColumn() const; /** * @brief Sets the column of the newline entries * @param col the number of the column */ void SetNlColumn(size_t col); /** * @brief Returns the level of the chunk */ size_t GetLevel() const; /** * @brief Sets the level of the chunk * @param col the level of the chunk */ void SetLevel(size_t level); /** * @brief Returns the brace level of the chunk */ size_t GetBraceLevel() const; /** * @brief Sets the brace level of the chunk * @param level the brace level of the chunk */ void SetBraceLevel(size_t lvl); /** * @brief Returns the preprocessor level of the chunk */ size_t GetPpLevel() const; /** * @brief Sets the preprocessor level of the chunk * @param level the preprocessor level of the chunk */ void SetPpLevel(size_t lvl); /** * @brief Returns the after tab property of the chunk */ bool GetAfterTab() const; /** * @brief Sets the after tab property of the chunk * @param afterTab the after tab property of the chunk */ void SetAfterTab(bool afterTab); // --------- Get* chunk functions /** * @brief returns the head of the chunk list * @return pointer to the first chunk */ static Chunk *GetHead(); /** * @brief returns the tail of the chunk list * @return pointer to the last chunk */ static Chunk *GetTail(); /** * @brief returns the next chunk in a list of chunks * @param scope code region to search in * @return pointer to next chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNext(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the previous chunk in a list of chunks * @param scope code region to search in * @return pointer to previous chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrev(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next newline chunk * @param scope code region to search in * @return pointer to next newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNl(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev newline chunk * @param scope code region to search in * @return pointer to prev newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNl(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next non-newline chunk * @param scope code region to search in * @return pointer to next non-newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNnl(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev non-newline chunk * @param scope code region to search in * @return pointer to prev non-newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNnl(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next non-comment chunk * @param scope code region to search in * @return pointer to next non-comment chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNc(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev non-comment chunk * @param scope code region to search in * @return pointer to prev non-comment chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNc(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next non-comment and non-newline chunk * @param scope code region to search in * @return pointer to next non-comment and non-newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNcNnl(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev non-comment and non-newline chunk * @param scope code region to search in * @return pointer to prev non-comment and non-newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNcNnl(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next non-comment, non-newline, non-preprocessor chunk * @param scope code region to search in * @return pointer to next non-comment, non-newline, non-preprocessor chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNcNnlNpp(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev non-comment, non-newline, non-preprocessor chunk * @param scope code region to search in * @return pointer to prev non-comment, non-newline, non-preprocessor chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNcNnlNpp(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next non-preprocessor or non-comment, non-newline chunk * @param scope code region to search in * @return pointer to next non-preprocessor or non-comment, non-newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNppOrNcNnl(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev non-preprocessor or non-comment, non-newline chunk * @param scope code region to search in * @return pointer to prev non-preprocessor or non-comment, non-newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNppOrNcNnl(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next preprocessor aware non-comment and non-newline chunk * Unlike Chunk::GetNextNcNnl, this will also ignore a line continuation if * the starting chunk is in a preprocessor directive, and may return a newline * if the search reaches the end of a preprocessor directive. * @return pointer to next preprocessor aware non-comment and non-newline chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *PpaGetNextNcNnl() const; /** * @brief returns the next non-comment, non-newline, non-empty text chunk * @param scope code region to search in * @return pointer to next non-comment, non-newline, non-empty text chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNcNnlNet(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev non-comment, non-newline, non-empty text chunk * @param scope code region to search in * @return pointer to prev non-comment, non-newline, non-empty text chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNcNnlNet(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev non-comment, non-newline, non-ignored chunk * @param scope code region to search in * @return pointer to prev non-comment, non-newline, non-ignored chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNcNnlNi(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next chunk not in or part of balanced square * brackets. This handles stacked [] instances to accommodate * multi-dimensional array declarations * @param scope code region to search in * @return nullptr or the next chunk not in or part of square brackets */ Chunk *GetNextNisq(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next non-virtual brace chunk * @param scope code region to search in * @return pointer to next non-virtual brace chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNvb(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev non-virtual brace chunk * @param scope code region to search in * @return pointer to prev non-virtual brace chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNvb(const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next chunk of the given type at the level. * @param type the type to look for * @param level the level to match or ANY_LEVEL * @param scope code region to search in * @return pointer to the next matching chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextType(const E_Token type, const int level = ANY_LEVEL, const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev chunk of the given type at the level. * @param type the type to look for * @param level the level to match or ANY_LEVEL * @param scope code region to search in * @return pointer to the prev matching chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevType(const E_Token type, int level = ANY_LEVEL, E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next chunk that holds a given string at a given level. * @param cStr string to search for * @param len length of string * @param level the level to match or ANY_LEVEL * @param scope code region to search in * @return pointer to the next matching chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextString(const char *cStr, const size_t len, const int level, const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the prev chunk that holds a given string at a given level. * @param cStr string to search for * @param len length of string * @param level the level to match or ANY_LEVEL * @param scope code region to search in * @return pointer to the prev matching chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevString(const char *cStr, const size_t len, const int level, const E_Scope scope = E_Scope::ALL) const; /** * @brief returns the next chunk that is not part of balanced square brackets. * This handles stacked[] instances to accommodate multidimensional arrays. * @return pointer to the next matching chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetNextNbsb() const; /** * @brief returns the prev chunk that is not part of balanced square brackets. * This handles stacked[] instances to accommodate multidimensional arrays. * @return pointer to the prev matching chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPrevNbsb() const; /** * @brief returns the corresponding start chunk if the given chunk is within a * preprocessor directive, or Chunk::NullChunkPtr otherwise. * @return start chunk of the preprocessor directive or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetPpStart() const; /** * @brief Finds the first chunk on the line the current chunk is on. * This just backs up until a newline or nullptr is hit. * * given: [ a - b - c - n1 - d - e - n2 ] * input: [ a | b | c | n1 ] => a * input: [ d | e | n2 ] => d * * @return pointer to the first chunk on the line the current chunk is on. */ Chunk *GetFirstChunkOnLine() const; // --------- Search functions /** * @brief defines a member function pointer for a function of type * Chunk *Chunk::function(const E_Scope scope) * that will search for a new chunk */ typedef Chunk *(Chunk::*T_SearchFnPtr)(const E_Scope scope) const; /** * @brief defines a member function pointer for a function of type * bool Chunk::function() const; * that checks whether a chunk satisty a specific condition */ typedef bool (Chunk::*T_CheckFnPtr)() const; /** * @brief determines the search direction to use and returns a pointer * to the corresponding search function. * @param dir search direction * @return pointer to search function */ static T_SearchFnPtr GetSearchFn(const E_Direction dir = E_Direction::FORWARD); /** * @brief search for a chunk that satisfies a condition in a chunk list * * A generic function that traverses a chunks list either * in forward or reverse direction. The traversal continues until a * chunk satisfies the condition defined by the compare function. * Depending on the parameter cond the condition will either be * checked to be true or false. * * @param checkFn compare function * @param scope code parts to consider for search * @param dir search direction (forward or backward) * @param cond success condition * @return pointer to the found chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *Search(const T_CheckFnPtr checkFn, const E_Scope scope = E_Scope::ALL, const E_Direction dir = E_Direction::FORWARD, const bool cond = true) const; /** * @brief search for a chunk that satisfies a condition in a chunk list, * but being aware of preprocessor chucks. * * This function is similar to Search, except that it is tweaked to * handle searches inside of preprocessor directives. Specifically, if the * starting token is inside a preprocessor directive, it will ignore a line * continuation, and will abort the search if it reaches the end of the * directive. This function only searches forward. * * @param checkFn compare function * @param cond success condition * @return pointer to the found chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *SearchPpa(const T_CheckFnPtr checkFn, const bool cond = true) const; /** * @brief search a chunk of a given type and level. Traverses a chunk list in the * specified direction until a chunk of a given type and level is found. * * This function is a specialization of Chunk::Search. * * @param type category to search for * @param scope code parts to consider for search * @param dir search direction * @param level nesting level to match or ANY_LEVEL * @return pointer to the found chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *SearchTypeLevel(const E_Token type, const E_Scope scope = E_Scope::ALL, const E_Direction dir = E_Direction::FORWARD, const int level = ANY_LEVEL) const; /** * @brief searches a chunk that holds a specific string * * Traverses a chunk list either in forward or backward direction until a chunk * with the provided string was found. Additionally a nesting level can be * provided to narrow down the search. * * @param cStr string that searched chunk needs to have * @param len length of the string * @param level nesting level of the searched chunk, ignored when negative * @param scope code parts to consider for search * @param dir search direction * @return pointer to the found chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *SearchStringLevel(const char *cStr, const size_t len, const int level, const E_Scope scope = E_Scope::ALL, const E_Direction dir = E_Direction::FORWARD) const; /** * @brief returns the closing match for the current paren/brace/square. * @param scope chunk section to consider * @return pointer to the next matching chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetClosingParen(E_Scope scope = E_Scope::ALL) const; /** * @brief returns the opening match for the current paren/brace/square. * @param scope chunk section to consider * @return pointer to the prev matching chunk or Chunk::NullChunkPtr if no chunk was found */ Chunk *GetOpeningParen(E_Scope scope = E_Scope::ALL) const; // --------- Is* functions /** * @brief checks whether the chunk is a specific token * @token the token to check for * @return true if the chunk type matches the specified token, false otherwise */ bool Is(E_Token token) const; /** * @brief checks whether the chunk token name is a specific string * @param cStr string to compare token name with * @param caseSensitive whether to do a case sensitive or insensitive comparison * @return true if the chunk token name matches the specified string, false otherwise */ bool IsString(const char *cStr, bool caseSensitive = true) const; /** * @brief checks whether the chunk is not a specific token * @token the token to check for * @return true if the chunk type does not matches the specified token, false otherwise */ bool IsNot(E_Token token) const; /** * @brief checks whether the chunk is a newline * @return true if the chunk is a newline, false otherwise */ bool IsNewline() const; /** * @brief checks whether the chunk is a comment * This means any kind of: * - single line comment * - multiline comment * - C comment * - C++ comment */ bool IsComment() const; /** * @brief checks whether the chunk is valid and has an empty text * @return true if the chunk is valid and has an empty text */ bool IsEmptyText() const; /** * @brief checks whether the chunk is a preprocessor * @return true if the chunk is a preprocessor, false otherwise */ bool IsPreproc() const; /** * @brief checks whether the other chunk has the same preproc flags * @return true if the other chunk has the same preproc flags */ bool IsSamePreproc(const Chunk *other) const; /** * @brief checks whether the chunk is either a comment or a newline * @return true if the chunk is either a comment or a newline, false otherwise */ bool IsCommentOrNewline() const; /** * @brief checks whether the chunk is either a comment, a newline or ignored * @return true if the chunk is either a comment, a newline or ignored, false otherwise */ bool IsCommentNewlineOrIgnored() const; /** * @brief checks whether the chunk is a comment, a newline or a preprocessor * @return true if the chunk is a comment, a newline or a preprocessor, false otherwise */ bool IsCommentNewlineOrPreproc() const; /** * @brief checks whether the chunk is a preprocessor and either a comment or a newline * @return true if the chunk is a preprocessor and either a comment or a newline, false otherwise */ bool IsCommentOrNewlineInPreproc() const; /** * @brief checks whether the chunk is a comment, a newline or has an empty text * @return true if the chunk is a comment, a newline or has an empty text */ bool IsCommentNewlineOrEmptyText() const; /** * @brief checks whether the chunk is a single line comment * @return true if the chunk is a single line comment */ bool IsSingleLineComment() const; /** * @brief checks whether the chunk is a Doxygen comment * @return true if the chunk is a Doxygen comment */ bool IsDoxygenComment() const; /** * @brief checks whether the chunk is a square bracket * @return true if the chunk is a square bracket */ bool IsSquareBracket() const; /** * @brief checks whether the chunk is a virtual brace * @return true if the chunk is a virtual brace */ bool IsVBrace() const; /** * @brief checks whether the chunk matches a given type and level * @param type category to search for * @param level nesting level to match * @return true if the chunk matches a given type and level */ bool IsTypeAndLevel(const E_Token type, const int level) const; /** * @brief checks whether the chunk matches a given string and level * @param cStr the expected string * @param len length of the string * @param caseSensitive whether to do a case sensitive or insensitive comparison * @param level nesting level of the searched chunk, ignored when negative * @return true if the chunk matches a given string and level */ bool IsStringAndLevel(const char *cStr, const size_t len, bool caseSensitive, const int level) const; /** * @brief checks whether the chunk is a star/asterisk * @return true if the chunk is a star/asterisk */ bool IsStar() const; /** * @brief checks whether the chunk is a colon * @return true if the chunk is a colon */ bool IsColon() const; /** * @brief checks whether the chunk is a semicolon * @return true if the chunk is a semicolon */ bool IsSemicolon() const; /** * @brief checks whether the chunk is a pointer operator * @return true if the chunk is a pointer operator */ bool IsPointerOperator() const; /** * @brief checks whether the chunk is a pointer or a reference * @return true if the chunk is a pointer or a reference */ bool IsPointerOrReference() const; /** * @brief checks whether the chunk is an inheritance access specifier * @return true if the chunk is an inheritance access specifier */ bool IsCppInheritanceAccessSpecifier() const; /** * @brief checks whether the chunk is a pointer, reference or a qualifier * @return true if the chunk is a pointer, reference or a qualifier */ bool IsPointerReferenceOrQualifier() const; /** * @brief checks whether the chunk is an address * @return true if the chunk is an address */ bool IsAddress() const; /** * @brief checks whether the chunk is a MS reference * @return true if the chunk is a MS reference * NOTE: MS compilers for C++/CLI and WinRT use '^' instead of '*' * for marking up reference types vs pointer types */ bool IsMsRef() const; /** * @brief checks whether the chunk is nullable * @return true if the chunk is nullable */ bool IsNullable() const; /** * @brief Checks if a given chunk is the last on its line * @return true or false depending on whether a given chunk is the last on its line */ bool IsLastChunkOnLine() const; /** * @brief checks whether the current chunk is on same line of the given 'end' chunk. * The current chunk must be before the 'end' chunk * @param end the end chunk * @return true if there is no newline between the current chunk and end chunk */ bool IsOnSameLine(const Chunk *end) const; /** * @brief checks whether the chunk is an opening brace * @return true if the chunk is an opening brace */ bool IsBraceOpen() const; /** * @brief checks whether the chunk is a closing brace * @return true if the chunk is a closing brace */ bool IsBraceClose() const; /** * @brief checks whether the chunk is an opening parenthesis * @return true if the chunk is an opening parenthesis */ bool IsParenOpen() const; /** * @brief checks whether the chunk is a closing parenthesis * @return true if the chunk is a closing parenthesis */ bool IsParenClose() const; /** * @brief checks if a chunk points to the opening parentheses of a * for (...in...) loop in Objective-C. * @return true if the chunk is the opening parentheses of a for-in loop */ bool IsOCForinOpenParen() const; /** * @brief checks whether the chunk is a type defining token * @return true if the chunk is a type defining token */ bool IsTypeDefinition() const; /** * @brief checks whether the chunk is a word * @return true if the chunk is a word */ bool IsWord() const; /** * @brief checks whether the chunk is an enum or an enum class * @return true if the chunk is an enum or an enum class */ bool IsEnum() const; /** * @brief checks whether the chunk is a class or a struct * @return true if the chunk is a class or a struct */ bool IsClassOrStruct() const; /** * @brief checks whether the chunk is a class, struct or union * @return true if the chunk is a class, struct or union */ bool IsClassStructOrUnion() const; /** * @brief checks whether the chunk is a class, enum, struct or union * @return true if the chunk is a class, enum, struct or union */ bool IsClassEnumStructOrUnion() const; /** * @brief checks whether there is a newline between this chunk and the other * @return true if there is a newline between this chunk and the other */ bool IsNewlineBetween(const Chunk *other) const; // --------- Util functions /** * @brief delete the chunk from the chunk list * @param pc the chunk to remove from the list */ static void Delete(Chunk * &pc); /** * @brief add a copy of this chunk after the given position in a chunk list. * @note If pos is NullChunk, add at the tail of the chunk list * @param pos insert position in list * @return pointer to the newly added chunk */ Chunk *CopyAndAddAfter(Chunk *pos) const; /** * @brief add a copy of this chunk before the given position in a chunk list. * @note If pos is NullChunk, add at the head of the chunk list * @param pos insert position in list * @return pointer to the newly added chunk */ Chunk *CopyAndAddBefore(Chunk *pos) const; /** * @brief move the chunk after the reference position in the chunk list * @param ref chunk after which to move the current chunk */ void MoveAfter(Chunk *ref); /** * @brief swaps the place of this chunk with the given one * @param other the other chunk */ void Swap(Chunk *other); /** * @brief swaps the two lines that are started by the current chunk and the other chunk * @param other the other chunk */ void SwapLines(Chunk *other); //! /** * @brief skips to the final word/type in a :: chain * @return pointer to the chunk after the final word/type in a :: chain */ Chunk *SkipDcMember() const; /** * @brief compare the positions of the chunk with another one * @param other the other chunk * @return returns -1 if this chunk comes first, +1 if it comes after, or 0. */ int ComparePosition(const Chunk *other) const; /** * Returns true if it is safe to delete the newline token. * The prev and next chunks must have the same PCF_IN_PREPROC flag AND * the newline can't be after a C++ comment. */ bool SafeToDeleteNl() const; protected: // --------- Protected util functions /** * @brief copy the values from another chunk. * @NOTE: this is a partial copy only: the chunk is not linked to others * @param o the chunk to copy from */ void CopyFrom(const Chunk &o); /** * @brief add a copy of this chunk before/after the given position in a chunk list. * @note If pos is NullChunk, add the new chuck either at the head or tail of the * list based on the specified direction. * @param pos insert position in list * @param dir insert before or after the given position chunk * @return pointer to the newly added chunk */ Chunk *CopyAndAdd(Chunk *pos, const E_Direction dir = E_Direction::FORWARD) const; /** * @brief set and/or clear the chunk flags * @param setBits the flag bits to set * @param resetBits the flag bits to reset */ void SetResetFlags(T_PcfFlags resetBits, T_PcfFlags setBits); // --------- Data members E_Token m_type; //! type of the chunk itself E_Token m_parentType; //! type of the parent chunk usually CT_NONE size_t m_origLine; //! line number of chunk in input file size_t m_origCol; //! column where chunk started in the input file, is always > 0 size_t m_origColEnd; //! column where chunk ended in the input file, is always > 1 size_t m_origPrevSp; //! whitespace before this token size_t m_column; //! column of the chunk size_t m_columnIndent; //! if 1st chunk on a line, set to the 'indent' column, which may //! be less than the real column used to indent with tabs size_t m_nlCount; //! number of newlines in CT_NEWLINE size_t m_nlColumn; //! column of the subsequent newline entries(all of them should have the same column) size_t m_level; //! nest level in {, (, or [. Only to help vim command } size_t m_braceLevel; //! nest level in braces only size_t m_ppLevel; //! nest level in preprocessor bool m_afterTab; //! whether this token was after a tab T_PcfFlags m_flags; //! see PCF_xxx T_AlignData m_alignmentData; //! alignment data of the chunk T_IndentData m_indentData; //! indentation data of the chunk Chunk *m_next; //! pointer to next chunk in list Chunk *m_prev; //! pointer to previous chunk in list Chunk *m_parent; //! pointer to parent chunk (not always set) unc_text m_str; //! the token text track_list *m_trackingData; //! for debugging purpose only private: const bool null_chunk; //! true for null chunks public: static Chunk NullChunk; //! Null Chunk static Chunk *const NullChunkPtr; //! Pointer to the Null Chunk }; inline Chunk::Chunk(bool null_c) : null_chunk(null_c) { Reset(); } inline Chunk::Chunk(const Chunk &o) : null_chunk(o.null_chunk) { CopyFrom(o); } inline Chunk &Chunk::operator=(const Chunk &o) { if (this != &o) { CopyFrom(o); } return(*this); } inline size_t Chunk::Len() const { return(m_str.size()); } inline const char *Chunk::Text() const { return(m_str.c_str()); } inline Chunk *Chunk::GetParent() const { return(m_parent); } inline void Chunk::SetParent(Chunk *parent) { if (this != parent) { m_parent = parent; } } inline const T_AlignData &Chunk::GetAlignmentData() const { return(m_alignmentData); } inline T_AlignData &Chunk::AlignmentData() { return(m_alignmentData); } inline const T_IndentData &Chunk::GetIndentData() const { return(m_indentData); } inline T_IndentData &Chunk::IndentData() { return(m_indentData); } inline const unc_text &Chunk::GetStr() const { return(m_str); } inline unc_text &Chunk::Str() { return(m_str); } inline const track_list *Chunk::GetTrackingData() const { return(m_trackingData); } inline track_list * &Chunk::TrackingData() { return(m_trackingData); } inline E_Token Chunk::GetType() const { return(m_type); } inline E_Token Chunk::GetParentType() const { return(m_parentType); } inline E_Token Chunk::GetTypeOfParent() const { if (GetParent()->IsNullChunk()) { return(CT_PARENT_NOT_SET); } return(GetParent()->GetType()); } inline T_PcfFlags Chunk::GetFlags() const { return(m_flags); } inline void Chunk::SetFlags(T_PcfFlags flags) { m_flags = flags; } inline bool Chunk::TestFlags(T_PcfFlags flags) const { return(m_flags.test(flags)); } inline void Chunk::ResetFlagBits(T_PcfFlags resetBits) { SetResetFlags(resetBits, PCF_NONE); } inline void Chunk::SetFlagBits(T_PcfFlags setBits) { SetResetFlags(PCF_NONE, setBits); } inline void Chunk::UpdateFlagBits(T_PcfFlags resetBits, T_PcfFlags setBits) { SetResetFlags(resetBits, setBits); } inline size_t Chunk::GetOrigLine() const { return(m_origLine); } inline void Chunk::SetOrigLine(size_t line) { m_origLine = line; } inline size_t Chunk::GetOrigCol() const { return(m_origCol); } inline void Chunk::SetOrigCol(size_t col) { m_origCol = col; } inline size_t Chunk::GetOrigColEnd() const { return(m_origColEnd); } inline void Chunk::SetOrigColEnd(size_t col) { m_origColEnd = col; } inline size_t Chunk::GetOrigPrevSp() const { return(m_origPrevSp); } inline void Chunk::SetOrigPrevSp(size_t col) { m_origPrevSp = col; } inline size_t Chunk::GetColumn() const { return(m_column); } inline void Chunk::SetColumn(size_t col) { m_column = col; } inline size_t Chunk::GetColumnIndent() const { return(m_columnIndent); } inline void Chunk::SetColumnIndent(size_t col) { m_columnIndent = col; } inline size_t Chunk::GetNlCount() const { return(m_nlCount); } inline void Chunk::SetNlCount(size_t cnt) { m_nlCount = cnt; } inline size_t Chunk::GetNlColumn() const { return(m_nlColumn); } inline void Chunk::SetNlColumn(size_t col) { m_nlColumn = col; } inline size_t Chunk::GetLevel() const { return(m_level); } inline void Chunk::SetLevel(size_t level) { m_level = level; } inline size_t Chunk::GetBraceLevel() const { return(m_braceLevel); } inline void Chunk::SetBraceLevel(size_t lvl) { m_braceLevel = lvl; } inline size_t Chunk::GetPpLevel() const { return(m_ppLevel); } inline void Chunk::SetPpLevel(size_t lvl) { m_ppLevel = lvl; } inline bool Chunk::GetAfterTab() const { return(m_afterTab); } inline void Chunk::SetAfterTab(bool afterTab) { m_afterTab = afterTab; } inline Chunk *Chunk::GetNextNl(const E_Scope scope) const { return(Search(&Chunk::IsNewline, scope, E_Direction::FORWARD, true)); } inline Chunk *Chunk::GetPrevNl(const E_Scope scope) const { return(Search(&Chunk::IsNewline, scope, E_Direction::BACKWARD, true)); } inline Chunk *Chunk::GetNextNnl(const E_Scope scope) const { return(Search(&Chunk::IsNewline, scope, E_Direction::FORWARD, false)); } inline Chunk *Chunk::GetPrevNnl(const E_Scope scope) const { return(Search(&Chunk::IsNewline, scope, E_Direction::BACKWARD, false)); } inline Chunk *Chunk::GetNextNc(const E_Scope scope) const { return(Search(&Chunk::IsComment, scope, E_Direction::FORWARD, false)); } inline Chunk *Chunk::GetPrevNc(const E_Scope scope) const { return(Search(&Chunk::IsComment, scope, E_Direction::BACKWARD, false)); } inline Chunk *Chunk::GetNextNcNnl(const E_Scope scope) const { return(Search(&Chunk::IsCommentOrNewline, scope, E_Direction::FORWARD, false)); } inline Chunk *Chunk::GetPrevNcNnl(const E_Scope scope) const { return(Search(&Chunk::IsCommentOrNewline, scope, E_Direction::BACKWARD, false)); } inline Chunk *Chunk::GetNextNcNnlNpp(const E_Scope scope) const { return(Search(&Chunk::IsCommentNewlineOrPreproc, scope, E_Direction::FORWARD, false)); } inline Chunk *Chunk::GetPrevNcNnlNpp(const E_Scope scope) const { return(Search(&Chunk::IsCommentNewlineOrPreproc, scope, E_Direction::BACKWARD, false)); } inline Chunk *Chunk::GetNextNppOrNcNnl(const E_Scope scope) const { return(Search(&Chunk::IsCommentOrNewlineInPreproc, scope, E_Direction::FORWARD, false)); } inline Chunk *Chunk::GetPrevNppOrNcNnl(const E_Scope scope) const { return(Search(&Chunk::IsCommentOrNewlineInPreproc, scope, E_Direction::BACKWARD, false)); } inline Chunk *Chunk::PpaGetNextNcNnl() const { return(SearchPpa(&Chunk::IsCommentOrNewline, false)); } inline Chunk *Chunk::GetNextNcNnlNet(const E_Scope scope) const { return(Search(&Chunk::IsCommentNewlineOrEmptyText, scope, E_Direction::FORWARD, false)); } inline Chunk *Chunk::GetPrevNcNnlNet(const E_Scope scope) const { return(Search(&Chunk::IsCommentNewlineOrEmptyText, scope, E_Direction::BACKWARD, false)); } inline Chunk *Chunk::GetPrevNcNnlNi(const E_Scope scope) const { return(Search(&Chunk::IsCommentNewlineOrIgnored, scope, E_Direction::BACKWARD, false)); } inline Chunk *Chunk::GetNextNisq(const E_Scope scope) const { return(Search(&Chunk::IsSquareBracket, scope, E_Direction::FORWARD, false)); } inline Chunk *Chunk::GetNextType(const E_Token type, const int level, const E_Scope scope) const { return(SearchTypeLevel(type, scope, E_Direction::FORWARD, level)); } inline Chunk *Chunk::GetPrevType(const E_Token type, const int level, const E_Scope scope) const { return(SearchTypeLevel(type, scope, E_Direction::BACKWARD, level)); } inline Chunk *Chunk::GetNextString(const char *cStr, const size_t len, const int level, const E_Scope scope) const { return(SearchStringLevel(cStr, len, level, scope, E_Direction::FORWARD)); } inline Chunk *Chunk::GetPrevString(const char *cStr, const size_t len, const int level, const E_Scope scope) const { return(SearchStringLevel(cStr, len, level, scope, E_Direction::BACKWARD)); } inline Chunk *Chunk::GetNextNvb(const E_Scope scope) const { return(Search(&Chunk::IsVBrace, scope, E_Direction::FORWARD, false)); } inline Chunk *Chunk::GetPrevNvb(const E_Scope scope) const { return(Search(&Chunk::IsVBrace, scope, E_Direction::BACKWARD, false)); } inline bool Chunk::IsTypeAndLevel(const E_Token type, const int level) const { return( ( level < 0 || m_level == static_cast(level)) && m_type == type); } inline bool Chunk::Is(E_Token token) const { return( IsNotNullChunk() && m_type == token); } inline bool Chunk::IsString(const char *cStr, bool caseSensitive) const { return(IsStringAndLevel(cStr, strlen(cStr), caseSensitive, ANY_LEVEL)); } inline bool Chunk::IsNot(E_Token token) const { return(!Is(token)); } inline bool Chunk::IsNewline() const { return( Is(CT_NEWLINE) || Is(CT_NL_CONT)); } inline bool Chunk::IsComment() const { return( Is(CT_COMMENT) || Is(CT_COMMENT_MULTI) || Is(CT_COMMENT_CPP)); } inline bool Chunk::IsEmptyText() const { return( IsNotNullChunk() && Len() == 0); } inline bool Chunk::IsPreproc() const { return( IsNotNullChunk() && TestFlags(PCF_IN_PREPROC)); } inline bool Chunk::IsCommentOrNewline() const { return( IsComment() || IsNewline()); } inline bool Chunk::IsCommentNewlineOrPreproc() const { return( IsComment() || IsNewline() || IsPreproc()); } inline bool Chunk::IsCommentOrNewlineInPreproc() const { return( IsPreproc() && ( IsComment() || IsNewline())); } inline bool Chunk::IsCommentNewlineOrEmptyText() const { return( IsComment() || IsNewline() || IsEmptyText()); } inline bool Chunk::IsCommentNewlineOrIgnored() const { return( IsComment() || IsNewline() || Is(CT_IGNORED)); } inline bool Chunk::IsSingleLineComment() const { return( Is(CT_COMMENT) || Is(CT_COMMENT_CPP)); } inline bool Chunk::IsSquareBracket() const { return( Is(CT_SQUARE_OPEN) || Is(CT_TSQUARE) || Is(CT_SQUARE_CLOSE)); } inline bool Chunk::IsVBrace() const { return( Is(CT_VBRACE_OPEN) || Is(CT_VBRACE_CLOSE)); } inline bool Chunk::IsStar() const { return( Len() == 1 && m_str[0] == '*' && IsNot(CT_OPERATOR_VAL)); } inline bool Chunk::IsSemicolon() const { return( Is(CT_SEMICOLON) || Is(CT_VSEMICOLON)); } inline bool Chunk::IsWord() const { return( Len() >= 1 && CharTable::IsKw1(m_str[0])); } inline bool Chunk::IsNullable() const { return( language_is_set(LANG_CS | LANG_VALA) && Len() == 1 && m_str[0] == '?'); } inline bool Chunk::IsMsRef() const { return( language_is_set(LANG_CPP) && Len() == 1 && m_str[0] == '^' && IsNot(CT_OPERATOR_VAL)); } inline bool Chunk::IsPointerOperator() const { return( IsStar() || IsAddress() || IsMsRef() || IsNullable()); } inline bool Chunk::IsPointerOrReference() const { return( IsPointerOperator() || Is(CT_BYREF)); } inline bool Chunk::IsBraceOpen() const { return( Is(CT_BRACE_OPEN) || Is(CT_VBRACE_OPEN)); } inline bool Chunk::IsBraceClose() const { return( Is(CT_BRACE_CLOSE) || Is(CT_VBRACE_CLOSE)); } inline bool Chunk::IsParenOpen() const { return( Is(CT_PAREN_OPEN) || Is(CT_SPAREN_OPEN) || Is(CT_PPAREN_OPEN) || Is(CT_TPAREN_OPEN) || Is(CT_FPAREN_OPEN) || Is(CT_LPAREN_OPEN)); } inline bool Chunk::IsParenClose() const { return( Is(CT_PAREN_CLOSE) || Is(CT_SPAREN_CLOSE) || Is(CT_PPAREN_CLOSE) || Is(CT_TPAREN_CLOSE) || Is(CT_FPAREN_CLOSE) || Is(CT_LPAREN_CLOSE)); } inline bool Chunk::IsSamePreproc(const Chunk *other) const { return( IsNotNullChunk() && other->IsNotNullChunk() && (TestFlags(PCF_IN_PREPROC) == other->TestFlags(PCF_IN_PREPROC))); } inline bool Chunk::SafeToDeleteNl() const { Chunk *tmp = GetPrev(); if (tmp->Is(CT_COMMENT_CPP)) { return(false); } return(tmp->IsSamePreproc(GetNext())); } inline bool Chunk::IsEnum() const { return( Is(CT_ENUM) || Is(CT_ENUM_CLASS)); } inline bool Chunk::IsClassOrStruct() const { return( Is(CT_CLASS) || Is(CT_STRUCT)); } inline bool Chunk::IsClassStructOrUnion() const { return( IsClassOrStruct() || Is(CT_UNION)); } inline bool Chunk::IsClassEnumStructOrUnion() const { return( IsClassStructOrUnion() || IsEnum()); } inline Chunk *Chunk::CopyAndAddAfter(Chunk *ref) const { return(CopyAndAdd(ref, E_Direction::FORWARD)); } inline Chunk *Chunk::CopyAndAddBefore(Chunk *ref) const { return(CopyAndAdd(ref, E_Direction::BACKWARD)); } #define SetType(tt) SetTypeReal((tt), __unqualified_func__, __LINE__) #define SetParentType(tt) SetParentTypeReal((tt), __unqualified_func__, __LINE__) #endif /* CHUNK_LIST_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/combine.cpp000066400000000000000000003313141434072136500211510ustar00rootroot00000000000000/** * @file combine.cpp * Labels the chunks as needed. * * @author Ben Gardner * @author Guy Maurel * @license GPL v2+ */ #include "combine.h" #include "combine_fix_mark.h" #include "combine_skip.h" #include "combine_tools.h" #include "EnumStructUnionParser.h" #include "flag_braced_init_list.h" #include "flag_parens.h" #include "lang_pawn.h" #include "mark_question_colon.h" #include "newlines.h" #include "prototypes.h" #include "tokenize_cleanup.h" #include "unc_tools.h" #include constexpr static auto LCURRENT = LCOMBINE; using namespace std; using namespace uncrustify; /** * Mark the parens and colons in: * asm volatile ( "xx" : "xx" (l), "yy"(h) : ... ); * * @param pc the CT_ASM item */ static void flag_asm(Chunk *pc); /** * Combines two tokens into {{ and }} if inside parens and nothing is between * either pair. */ static void check_double_brace_init(Chunk *bo1); static void process_returns_and_throws(); /** * Processes a 'return' or 'throw' statement, labeling the parens and marking * the parent. May remove or add parens around the return/throw statement. * * @param pc Pointer to the return or throw chunk */ static Chunk *process_return_or_throw(Chunk *pc); /** * Process an ObjC 'class' * pc is the chunk after '@implementation' or '@interface' or '@protocol'. * Change colons, etc. Processes stuff until '@end'. * Skips anything in braces. */ static void handle_oc_class(Chunk *pc); /** * Mark Objective-C blocks (aka lambdas or closures) * The syntax and usage is exactly like C function pointers * but instead of an asterisk they have a caret as pointer symbol. * Although it may look expensive this functions is only triggered * on appearance of an OC_BLOCK_CARET for LANG_OC. * repeat(10, ^{ putc('0'+d); }); * typedef void (^workBlk_t)(void); * * @param pc points to the '^' */ static void handle_oc_block_literal(Chunk *pc); /** * Mark Objective-C block types. * The syntax and usage is exactly like C function pointers * but instead of an asterisk they have a caret as pointer symbol. * typedef void (^workBlk_t)(void); * const char * (^workVar)(void); * -(void)Foo:(void(^)())blk { } * * This is triggered when the sequence '(' '^' is found. * * @param pc points to the '^' */ static void handle_oc_block_type(Chunk *pc); /** * Process an ObjC message spec/dec * * Specs: * -(void) foo ARGS; * * Declaration: * -(void) foo ARGS { } * * LABEL : (ARGTYPE) ARGNAME * * ARGS is ': (ARGTYPE) ARGNAME [MOREARGS...]' * MOREARGS is ' [ LABEL] : (ARGTYPE) ARGNAME ' * -(void) foo: (int) arg: { } * -(void) foo: (int) arg: { } * -(void) insertObject:(id)anObject atIndex:(int)index */ static void handle_oc_message_decl(Chunk *pc); /** * Process an ObjC message send statement: * [ class func: val1 name2: val2 name3: val3] ; // named params * [ class func: val1 : val2 : val3] ; // unnamed params * [ class self method ] ; // with protocol * [[NSMutableString alloc] initWithString: @"" ] // class from msg * [func(a,b,c) lastObject ] // class from func * * Mainly find the matching ']' and ';' and mark the colons. * * @param pc points to the open square '[' */ static void handle_oc_message_send(Chunk *pc); //! Process @Property values and re-arrange them if necessary static void handle_oc_property_decl(Chunk *pc); //! Process @available annotation static void handle_oc_available(Chunk *pc); /** * Process a type that is enclosed in parens in message declarations. * TODO: handle block types, which get special formatting * * @param pc points to the open paren * * @return the chunk after the type */ static Chunk *handle_oc_md_type(Chunk *paren_open, E_Token ptype, T_PcfFlags flags, bool &did_it); /** * Process an C# [] thingy: * [assembly: xxx] * [AttributeUsage()] * [@X] * * Set the next chunk to a statement start after the close ']' * * @param pc points to the open square '[' */ static void handle_cs_square_stmt(Chunk *pc); /** * We are on a brace open that is preceded by a word or square close. * Set the brace parent to CT_CS_PROPERTY and find the first item in the * property and set its parent, too. */ static void handle_cs_property(Chunk *pc); /** * We hit a ']' followed by a WORD. This may be a multidimensional array type. * Example: int[,,] x; * If there is nothing but commas between the open and close, then mark it. */ static void handle_cs_array_type(Chunk *pc); /** * We are on the C++ 'template' keyword. * What follows should be the following: * * template function_declaration; * template function_declaration; * template class class_declaration; * template class class_declaration; * * Change the 'class' inside the <> to CT_TYPE. * Set the parent to the class after the <> to CT_TEMPLATE. * Set the parent of the semicolon to CT_TEMPLATE. */ static void handle_cpp_template(Chunk *pc); /** * Verify and then mark C++ lambda expressions. * The expected format is '[...](...){...}' or '[...](...) -> type {...}' * sq_o is '[' CT_SQUARE_OPEN or '[]' CT_TSQUARE * Split the '[]' so we can control the space */ static void handle_cpp_lambda(Chunk *pc); /** * We are on the D 'template' keyword. * What follows should be the following: * * template NAME ( TYPELIST ) { BODY } * * Set the parent of NAME to template, change NAME to CT_TYPE. * Set the parent of the parens and braces to CT_TEMPLATE. * Scan the body for each type in TYPELIST and change the type to CT_TYPE. */ static void handle_d_template(Chunk *pc); /** * A func wrap chunk and what follows should be treated as a function name. * Create new text for the chunk and call it a CT_FUNCTION. * * A type wrap chunk and what follows should be treated as a simple type. * Create new text for the chunk and call it a CT_TYPE. */ static void handle_wrap(Chunk *pc); /** * A proto wrap chunk and what follows should be treated as a function proto. * * RETTYPE PROTO_WRAP( NAME, PARAMS ); or RETTYPE PROTO_WRAP( NAME, (PARAMS) ); * RETTYPE gets changed with make_type(). * PROTO_WRAP is marked as CT_FUNC_PROTO or CT_FUNC_DEF. * NAME is marked as CT_WORD. * PARAMS is all marked as prototype parameters. */ static void handle_proto_wrap(Chunk *pc); static bool is_oc_block(Chunk *pc); /** * Java assert statements are: "assert EXP1 [: EXP2] ;" * Mark the parent of the colon and semicolon */ static void handle_java_assert(Chunk *pc); static void flag_asm(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *tmp = pc->GetNextNcNnl(E_Scope::PREPROC); if (tmp->IsNot(CT_QUALIFIER)) { return; } Chunk *po = tmp->GetNextNcNnl(E_Scope::PREPROC); if (!po->IsParenOpen()) { return; } Chunk *end = po->GetClosingParen(E_Scope::PREPROC); if (end->IsNullChunk()) { return; } po->SetParentType(CT_ASM); end->SetParentType(CT_ASM); for ( tmp = po->GetNextNcNnl(E_Scope::PREPROC); tmp->IsNotNullChunk() && tmp != end; tmp = tmp->GetNextNcNnl(E_Scope::PREPROC)) { if (tmp->Is(CT_COLON)) { tmp->SetType(CT_ASM_COLON); } else if (tmp->Is(CT_DC_MEMBER)) { // if there is a string on both sides, then this is two ASM_COLONs if ( tmp->GetNextNcNnl(E_Scope::PREPROC)->Is(CT_STRING) && tmp->GetPrevNcNnlNi(E_Scope::PREPROC)->Is(CT_STRING)) // Issue #2279 { Chunk nc; nc = *tmp; tmp->Str().resize(1); tmp->SetOrigColEnd(tmp->GetOrigCol() + 1); tmp->SetType(CT_ASM_COLON); nc.SetType(tmp->GetType()); nc.Str().pop_front(); nc.SetOrigCol(nc.GetOrigCol() + 1); nc.SetColumn(nc.GetColumn() + 1); nc.CopyAndAddAfter(tmp); } } } tmp = end->GetNextNcNnl(E_Scope::PREPROC); if (tmp->IsNullChunk()) { return; } if (tmp->Is(CT_SEMICOLON)) { tmp->SetParentType(CT_ASM); } } // flag_asm void do_symbol_check(Chunk *prev, Chunk *pc, Chunk *next) { LOG_FUNC_ENTRY(); LOG_FMT(LFCNR, "%s(%d): prev is '%s' %s\n", __func__, __LINE__, prev->Text(), get_token_name(prev->GetType())); log_pcf_flags(LFCNR, prev->GetFlags()); LOG_FMT(LFCNR, "%s(%d): pc is '%s' %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); log_pcf_flags(LFCNR, pc->GetFlags()); LOG_FMT(LFCNR, "%s(%d): next is '%s' %s\n", __func__, __LINE__, next->Text(), get_token_name(next->GetType())); log_pcf_flags(LFCNR, next->GetFlags()); if ( pc->Is(CT_NOEXCEPT) // Issue #3284 && next->Is(CT_ASSIGN)) // skip over noexcept { LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc = next; next = pc->GetNext(); } // separate the uses of CT_ASSIGN sign '=' // into CT_ASSIGN_DEFAULT_ARG, CT_ASSIGN_FUNC_PROTO if ( pc->Is(CT_ASSIGN) && pc->GetParentType() == CT_FUNC_PROTO && ( pc->TestFlags(PCF_IN_FCN_DEF) // Issue #2236 || pc->TestFlags(PCF_IN_CONST_ARGS))) { LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); log_pcf_flags(LFCNR, pc->GetFlags()); pc->SetType(CT_ASSIGN_DEFAULT_ARG); return; } if ( ( prev->Is(CT_FPAREN_CLOSE) || ( ( prev->IsString("const") || prev->IsString("override")) && prev->GetPrev()->Is(CT_FPAREN_CLOSE))) && pc->Is(CT_ASSIGN) && ( next->Is(CT_DEFAULT) || next->Is(CT_DELETE) || next->IsString("0"))) { pc->SetType(CT_ASSIGN_FUNC_PROTO); return; // cpp 30031 } if (pc->Is(CT_OC_AT)) { if ( next->Is(CT_PAREN_OPEN) || next->Is(CT_BRACE_OPEN) || next->Is(CT_SQUARE_OPEN)) { flag_parens(next, PCF_OC_BOXED, next->GetType(), CT_OC_AT, false); } else { next->SetParentType(CT_OC_AT); return; // objective-c_50095 } } // D stuff if ( language_is_set(LANG_D) && pc->Is(CT_QUALIFIER) && pc->IsString("const") && next->Is(CT_PAREN_OPEN)) { pc->SetType(CT_D_CAST); set_paren_parent(next, pc->GetType()); return; // d_40061 } if ( next->Is(CT_PAREN_OPEN) && ( pc->Is(CT_D_CAST) || pc->Is(CT_DELEGATE) || pc->Is(CT_ALIGN))) { // mark the parenthesis parent Chunk *tmp = set_paren_parent(next, pc->GetType()); // For a D cast - convert the next item if ( pc->Is(CT_D_CAST) && tmp != nullptr) { if (tmp->Is(CT_STAR)) { tmp->SetType(CT_DEREF); return; // d_40006 } else if (tmp->Is(CT_AMP)) { tmp->SetType(CT_ADDR); return; // d_40060 } else if (tmp->Is(CT_MINUS)) { tmp->SetType(CT_NEG); return; // d_40060 } else if (tmp->Is(CT_PLUS)) { tmp->SetType(CT_POS); return; // d_40060 } } /* * For a delegate, mark previous words as types and the item after the * close paren as a variable def */ if (pc->Is(CT_DELEGATE)) { if (tmp != nullptr) { tmp->SetParentType(CT_DELEGATE); if (tmp->GetLevel() == tmp->GetBraceLevel()) { tmp->SetFlagBits(PCF_VAR_1ST_DEF); } } for (tmp = pc->GetPrevNcNnlNi(); tmp->IsNotNullChunk(); tmp = tmp->GetPrevNcNnlNi()) // Issue #2279 { if ( tmp->IsSemicolon() || tmp->Is(CT_BRACE_OPEN) || tmp->Is(CT_VBRACE_OPEN)) { break; } make_type(tmp); } return; // c-sharp_10160 } if ( pc->Is(CT_ALIGN) && tmp != nullptr) { if (tmp->Is(CT_BRACE_OPEN)) { set_paren_parent(tmp, pc->GetType()); return; // d_40024 } else if (tmp->Is(CT_COLON)) { tmp->SetParentType(pc->GetType()); return; // d_40024 } } } // paren open + cast/align/delegate if (pc->Is(CT_INVARIANT)) { if (next->Is(CT_PAREN_OPEN)) { next->SetParentType(pc->GetType()); Chunk *tmp = next->GetNext(); if (tmp == nullptr) { tmp = Chunk::NullChunkPtr; } while (tmp->IsNotNullChunk()) { if (tmp->Is(CT_PAREN_CLOSE)) { tmp->SetParentType(pc->GetType()); break; } make_type(tmp); tmp = tmp->GetNext(); } return; // d_40100 } else { pc->SetType(CT_QUALIFIER); return; } } if ( prev->Is(CT_BRACE_OPEN) && prev->GetParentType() != CT_CS_PROPERTY && ( pc->Is(CT_GETSET) || pc->Is(CT_GETSET_EMPTY))) { flag_parens(prev, PCF_NONE, CT_NONE, CT_GETSET, false); return; } if (pc->Is(CT_ASM)) { flag_asm(pc); return; } // clang stuff - A new derived type is introduced to C and, by extension, Objective-C, C++, and Objective-C++ if (language_is_set(LANG_C | LANG_CPP | LANG_OC)) { if (pc->Is(CT_CARET)) { if ( pc->TestFlags(PCF_EXPR_START) || pc->TestFlags(PCF_IN_PREPROC)) { handle_oc_block_literal(pc); return; } } } // Objective C stuff if (language_is_set(LANG_OC)) { // Check for message declarations if (pc->TestFlags(PCF_STMT_START)) { if ( ( pc->IsString("-") || pc->IsString("+")) && next->IsString("(")) { handle_oc_message_decl(pc); return; } } if ( pc->TestFlags(PCF_EXPR_START) || pc->TestFlags(PCF_IN_PREPROC)) { if (pc->Is(CT_SQUARE_OPEN)) { handle_oc_message_send(pc); // Only return early if the '[' was determined to be an OC MSG // Otherwise, it could have been a lambda capture list (ie '[&]') if (pc->GetParentType() == CT_OC_MSG) { return; // objective-c_50003 } } } if (pc->Is(CT_OC_PROPERTY)) { handle_oc_property_decl(pc); return; } if (pc->Is(CT_OC_AVAILABLE)) { handle_oc_available(pc); return; } } // C# and Vala stuff if (language_is_set(LANG_CS | LANG_VALA)) { // '[assembly: xxx]' stuff if ( language_is_set(LANG_CS) && pc->TestFlags(PCF_EXPR_START) && pc->Is(CT_SQUARE_OPEN)) { handle_cs_square_stmt(pc); return; } if ( language_is_set(LANG_CS) && next->Is(CT_BRACE_OPEN) && next->GetParentType() == CT_NONE && ( pc->Is(CT_SQUARE_CLOSE) || pc->Is(CT_ANGLE_CLOSE) || pc->Is(CT_WORD))) { handle_cs_property(next); return; } if ( pc->Is(CT_SQUARE_CLOSE) && next->Is(CT_WORD)) { handle_cs_array_type(pc); return; } if ( ( pc->Is(CT_LAMBDA) || pc->Is(CT_DELEGATE)) && next->Is(CT_BRACE_OPEN)) { set_paren_parent(next, pc->GetType()); return; } if ( language_is_set(LANG_CS) && pc->Is(CT_WHEN) && pc->GetNext()->IsNotNullChunk() && pc->GetNext()->IsNot(CT_SPAREN_OPEN)) { pc->SetType(CT_WORD); return; } } if ( language_is_set(LANG_JAVA) && pc->Is(CT_LAMBDA) && next->Is(CT_BRACE_OPEN)) { set_paren_parent(next, pc->GetType()); return; } if (pc->Is(CT_NEW)) { Chunk *ts = nullptr; Chunk *tmp = next; if (tmp->Is(CT_TSQUARE)) { ts = tmp; tmp = tmp->GetNextNcNnl(); } if ( tmp->Is(CT_BRACE_OPEN) || tmp->Is(CT_PAREN_OPEN)) { set_paren_parent(tmp, pc->GetType()); if (ts != nullptr) { ts->SetParentType(pc->GetType()); } } return; } // C++11 Lambda stuff if ( language_is_set(LANG_CPP) && ( pc->Is(CT_SQUARE_OPEN) || pc->Is(CT_TSQUARE))) { handle_cpp_lambda(pc); } // FIXME: which language does this apply to? // Issue #2432 if (!language_is_set(LANG_OC)) { if ( pc->Is(CT_ASSIGN) && next->Is(CT_SQUARE_OPEN)) { set_paren_parent(next, CT_ASSIGN); // Mark one-liner assignment Chunk *tmp = next; while ((tmp = tmp->GetNextNc())->IsNotNullChunk()) { if (tmp->IsNewline()) { break; } if ( tmp->Is(CT_SQUARE_CLOSE) && next->GetLevel() == tmp->GetLevel()) { tmp->SetFlagBits(PCF_ONE_LINER); next->SetFlagBits(PCF_ONE_LINER); break; } } return; } } if (pc->Is(CT_ASSERT)) { handle_java_assert(pc); return; } if (pc->Is(CT_ANNOTATION)) { Chunk *tmp = pc->GetNextNcNnl(); if (tmp->IsParenOpen()) { set_paren_parent(tmp, CT_ANNOTATION); } return; } if ( pc->Is(CT_SIZEOF) && language_is_set(LANG_ALLC)) { Chunk *tmp = pc->GetNextNcNnl(); if (tmp->Is(CT_ELLIPSIS)) { tmp->SetParentType(CT_SIZEOF); } return; } if ( pc->Is(CT_DECLTYPE) && pc->GetParentType() != CT_FUNC_DEF) { Chunk *tmp = pc->GetNextNcNnl(); if (tmp->IsParenOpen()) { // decltype may be followed by a braced-init-list tmp = set_paren_parent(tmp, CT_DECLTYPE); if (tmp->IsBraceOpen() && !pc->TestFlags(PCF_IN_LAMBDA)) { tmp = set_paren_parent(tmp, CT_BRACED_INIT_LIST); if ( tmp != nullptr && tmp->IsNotNullChunk()) { tmp->ResetFlagBits(PCF_EXPR_START | PCF_STMT_START); } } else { if ( tmp != nullptr && tmp->Is(CT_WORD)) { tmp->SetFlagBits(PCF_VAR_1ST_DEF); } } } return; } // A [] in C#, D and Vala only follows a type if ( pc->Is(CT_TSQUARE) && language_is_set(LANG_D | LANG_CS | LANG_VALA)) { if (prev->Is(CT_WORD)) { prev->SetType(CT_TYPE); } if (next->Is(CT_WORD)) { next->SetFlagBits(PCF_VAR_1ST_DEF); } return; } if ( pc->Is(CT_SQL_EXEC) || pc->Is(CT_SQL_BEGIN) || pc->Is(CT_SQL_END)) { mark_exec_sql(pc); return; } if (pc->Is(CT_PROTO_WRAP)) { handle_proto_wrap(pc); return; } // Handle the typedef if (pc->Is(CT_TYPEDEF)) { fix_typedef(pc); return; } if ( pc->IsClassEnumStructOrUnion() && prev->IsNot(CT_TYPEDEF)) { // Issue #3811 // Sometimes the enum chunk can exist in a parameter (ie. `void foo(enum EnumType param)`) // In this case we don't need to run the parser since we are not declaring an enum. if (pc->IsEnum()) { const size_t level = pc->GetLevel(); Chunk *tmp = pc; while (tmp->GetLevel() == level && tmp->IsNotNullChunk()) { tmp = tmp->GetNextNcNnl(); } if (tmp->GetLevel() < level) { return; } } EnumStructUnionParser parser; parser.parse(pc); return; } if (pc->Is(CT_EXTERN)) { if (next->IsParenOpen()) { Chunk *tmp = flag_parens(next, PCF_NONE, CT_NONE, CT_EXTERN, true); if ( tmp != nullptr && tmp->Is(CT_BRACE_OPEN)) { set_paren_parent(tmp, CT_EXTERN); } } else { // next likely is a string (see tokenize_cleanup.cpp) next->SetParentType(CT_EXTERN); Chunk *tmp = next->GetNextNcNnl(); if (tmp->Is(CT_BRACE_OPEN)) { set_paren_parent(tmp, CT_EXTERN); } } return; } if (pc->Is(CT_TEMPLATE)) { if (language_is_set(LANG_D)) { handle_d_template(pc); } else { handle_cpp_template(pc); } return; } if ( pc->Is(CT_WORD) && next->Is(CT_ANGLE_OPEN) && next->GetParentType() == CT_TEMPLATE) { mark_template_func(pc, next); return; } if ( pc->Is(CT_SQUARE_CLOSE) && next->Is(CT_PAREN_OPEN)) { flag_parens(next, PCF_NONE, CT_FPAREN_OPEN, CT_NONE, false); return; } if (pc->Is(CT_TYPE_CAST)) { fix_type_cast(pc); return; } if ( pc->GetParentType() == CT_ASSIGN && ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_SQUARE_OPEN))) { // Mark everything in here as in assign flag_parens(pc, PCF_IN_ARRAY_ASSIGN, pc->GetType(), CT_NONE, false); return; } if (pc->Is(CT_D_TEMPLATE)) { set_paren_parent(next, pc->GetType()); return; } /* * A word before an open paren is a function call or definition. * CT_WORD => CT_FUNC_CALL or CT_FUNC_DEF */ if (next->Is(CT_PAREN_OPEN)) { Chunk *tmp = next->GetNextNcNnl(); if ( language_is_set(LANG_C | LANG_CPP | LANG_OC) && tmp->Is(CT_CARET)) { handle_oc_block_type(tmp); // This is the case where a block literal is passed as the first argument of a C-style method invocation. if ( ( tmp->Is(CT_OC_BLOCK_CARET) || tmp->Is(CT_CARET)) && pc->Is(CT_WORD)) { LOG_FMT(LFCN, "%s(%d): (1) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); } } else if ( pc->Is(CT_WORD) || pc->Is(CT_OPERATOR_VAL)) { pc->SetType(CT_FUNCTION); } else if (pc->Is(CT_FIXED)) { pc->SetType(CT_FUNCTION); pc->SetParentType(CT_FIXED); } else if (pc->Is(CT_TYPE)) { /* * If we are on a type, then we are either on a C++ style cast, an * array reference, a function or we are on a function type. * The only way to tell for sure is to find the close paren and see * if it is followed by an open paren. * "int(5.6)" * "int()" * "int(foo)(void)" * * FIXME: this check can be done better... */ LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); bool is_byref_array = false; if (language_is_set(LANG_CPP)) { // If the open paren is followed by an ampersand, an optional word, // a close parenthesis, and an open square bracket, then it is an // array being passed by reference, not a cast tmp = next->GetNextNcNnl(); if (tmp->Is(CT_AMP)) { auto tmp2 = tmp->GetNextNcNnl(); if (tmp2->Is(CT_WORD)) { tmp2 = tmp2->GetNextNcNnl(); } if (tmp2->Is(CT_PAREN_CLOSE)) { tmp2 = tmp2->GetNextNcNnl(); if (tmp2->Is(CT_SQUARE_OPEN)) { is_byref_array = true; tmp->SetType(CT_BYREF); } } } } if (!is_byref_array) { tmp = next->GetNextType(CT_PAREN_CLOSE, next->GetLevel()); if (tmp->IsNotNullChunk()) { tmp = tmp->GetNext(); if (tmp->Is(CT_PAREN_OPEN)) { pc->SetType(CT_FUNCTION); } else { if ( pc->GetParentType() == CT_NONE && !pc->TestFlags(PCF_IN_TYPEDEF)) { tmp = next->GetNextNcNnl(); if (tmp->Is(CT_PAREN_CLOSE)) { // we have TYPE() pc->SetType(CT_FUNCTION); } else { // we have TYPE(...) pc->SetType(CT_CPP_CAST); set_paren_parent(next, CT_CPP_CAST); } } } } } } } if (language_is_set(LANG_PAWN)) { if ( pc->Is(CT_FUNCTION) && pc->GetBraceLevel() > 0) { LOG_FMT(LFCN, "%s(%d): (2) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); } if ( pc->Is(CT_STATE) && next->Is(CT_PAREN_OPEN)) { set_paren_parent(next, pc->GetType()); } } else { if ( ( pc->Is(CT_FUNCTION) || pc->Is(CT_FUNC_DEF)) && ( (pc->GetParentType() == CT_OC_BLOCK_EXPR) || !is_oc_block(pc))) { mark_function(pc); } } // Detect C99 member stuff if ( pc->Is(CT_MEMBER) && ( prev->Is(CT_COMMA) || prev->Is(CT_BRACE_OPEN))) { pc->SetType(CT_C99_MEMBER); next->SetParentType(CT_C99_MEMBER); return; } // Mark function parens and braces if ( pc->Is(CT_FUNC_DEF) || pc->Is(CT_FUNC_CALL) || pc->Is(CT_FUNC_CALL_USER) || pc->Is(CT_FUNC_PROTO)) { Chunk *tmp = next; if (tmp->Is(CT_SQUARE_OPEN)) { tmp = set_paren_parent(tmp, pc->GetType()); } else if ( tmp->Is(CT_TSQUARE) || tmp->GetParentType() == CT_OPERATOR) { tmp = tmp->GetNextNcNnl(); } if ( tmp != nullptr && tmp->IsNotNullChunk()) { if (tmp->IsParenOpen()) { tmp = flag_parens(tmp, PCF_NONE, CT_FPAREN_OPEN, pc->GetType(), false); if ( tmp != nullptr && tmp->IsNotNullChunk()) { if (tmp->Is(CT_BRACE_OPEN)) { if ( tmp->GetParentType() != CT_DOUBLE_BRACE && !pc->TestFlags(PCF_IN_CONST_ARGS)) { set_paren_parent(tmp, pc->GetType()); } } else if ( tmp->IsSemicolon() && pc->Is(CT_FUNC_PROTO)) { tmp->SetParentType(pc->GetType()); } } } } return; } // Mark the parameters in catch() if ( pc->Is(CT_CATCH) && next->Is(CT_SPAREN_OPEN)) { fix_fcn_def_params(next); return; } if ( pc->Is(CT_THROW) && prev->Is(CT_FPAREN_CLOSE)) { pc->SetParentType(prev->GetParentType()); if (next->Is(CT_PAREN_OPEN)) { set_paren_parent(next, CT_THROW); } return; } // Mark the braces in: "for_each_entry(xxx) { }" if ( pc->Is(CT_BRACE_OPEN) && pc->GetParentType() != CT_DOUBLE_BRACE && prev->Is(CT_FPAREN_CLOSE) && ( prev->GetParentType() == CT_FUNC_CALL || prev->GetParentType() == CT_FUNC_CALL_USER) && !pc->TestFlags(PCF_IN_CONST_ARGS)) { LOG_FMT(LFCN, "%s(%d): (3) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); set_paren_parent(pc, CT_FUNC_CALL); return; } /* * Check for a close parenthesis followed by an open parenthesis, * which means that we are on a function type declaration (C/C++ only?). * Note that typedefs are already taken care of. */ if ( !pc->TestFlags(PCF_IN_TEMPLATE) // Issue #3252 && pc->GetParentType() != CT_CPP_CAST && pc->GetParentType() != CT_C_CAST && !pc->TestFlags(PCF_IN_PREPROC) && !is_oc_block(pc) && pc->GetParentType() != CT_OC_MSG_DECL && pc->GetParentType() != CT_OC_MSG_SPEC && pc->IsString(")") && next->IsString("(")) { if (language_is_set(LANG_D)) { flag_parens(next, PCF_NONE, CT_FPAREN_OPEN, CT_FUNC_CALL, false); } else { mark_function_type(pc); } return; } if (pc->Is(CT_OC_CLASS)) { handle_oc_class(pc); return; } // TODO: Check for stuff that can only occur at the start of an statement if (!language_is_set(LANG_D)) { /* * Check a parenthesis pair to see if it is a cast. * Note that SPAREN and FPAREN have already been marked. */ if ( pc->Is(CT_PAREN_OPEN) && ( pc->GetParentType() == CT_NONE || pc->GetParentType() == CT_OC_MSG || pc->GetParentType() == CT_OC_BLOCK_EXPR || pc->GetParentType() == CT_CS_SQ_STMT) // Issue # 1256 && ( next->Is(CT_WORD) || next->Is(CT_TYPE) || next->Is(CT_STRUCT) || next->Is(CT_QUALIFIER) || next->Is(CT_MEMBER) || next->Is(CT_DC_MEMBER) || next->Is(CT_ENUM) || next->Is(CT_UNION)) && prev->IsNot(CT_DECLTYPE) && prev->IsNot(CT_SIZEOF) && prev->GetParentType() != CT_SIZEOF && prev->GetParentType() != CT_OPERATOR && !pc->TestFlags(PCF_IN_TYPEDEF)) { fix_casts(pc); return; } } if (language_is_set(LANG_CPP)) { Chunk *nnext = next->GetNextNcNnl(); // handle parent_type of assigns in special functions (ro5 + pure virtual) if ( pc->GetFlags().test_any(PCF_IN_STRUCT | PCF_IN_CLASS) && pc->Is(CT_ASSIGN) && nnext->Is(CT_SEMICOLON) && ( next->Is(CT_DEFAULT) || next->Is(CT_DELETE) || ( next->Is(CT_NUMBER) && next->IsString("0")))) { const size_t level = pc->GetLevel(); bool found_status = false; Chunk *pprev = pc->GetPrev(); for ( ; ( pprev->IsNotNullChunk() && pprev->GetLevel() >= level && pprev->IsNot(CT_SEMICOLON) && pprev->IsNot(CT_ACCESS_COLON)) ; pprev = pprev->GetPrev()) { if (pprev->GetLevel() != level) { continue; } if (next->Is(CT_NUMBER)) { if ( pprev->Is(CT_QUALIFIER) && pprev->IsString("virtual")) { found_status = true; break; } } else { if ( pprev->Is(CT_FUNC_CLASS_PROTO) // ctor/dtor || pprev->Is(CT_FUNC_PROTO)) // normal function { found_status = true; break; } } } if (found_status) { pc->SetParentType(pprev->GetType()); } } if (detect_cpp_braced_init_list(pc, next)) { flag_cpp_braced_init_list(pc, next); } } // Check for stuff that can only occur at the start of an expression if ( pc->TestFlags(PCF_EXPR_START) || ( prev->TestFlags(PCF_EXPR_START) && pc->GetParentType() == CT_OC_AT)) { // Change STAR, MINUS, and PLUS in the easy cases if (pc->Is(CT_STAR)) { // issue #596 // [0x100062020:IN_SPAREN,IN_FOR,STMT_START,EXPR_START,PUNCTUATOR] // prev->GetType() is CT_COLON ==> CT_DEREF if (prev->Is(CT_ANGLE_CLOSE)) { pc->SetType(CT_PTR_TYPE); } else if (prev->Is(CT_COLON)) { pc->SetType(CT_DEREF); } else { pc->SetType(CT_DEREF); } } if ( language_is_set(LANG_CPP) && pc->Is(CT_CARET) && prev->Is(CT_ANGLE_CLOSE)) { pc->SetType(CT_PTR_TYPE); } if ( language_is_set(LANG_CS | LANG_VALA) && pc->Is(CT_QUESTION) && prev->Is(CT_ANGLE_CLOSE)) { pc->SetType(CT_PTR_TYPE); } else if (pc->Is(CT_MINUS)) { pc->SetType(CT_NEG); } else if (pc->Is(CT_PLUS)) { pc->SetType(CT_POS); } else if (pc->Is(CT_INCDEC_AFTER)) { pc->SetType(CT_INCDEC_BEFORE); } else if (pc->Is(CT_AMP)) { if (prev->Is(CT_ANGLE_CLOSE)) // Issue #2324 { pc->SetType(CT_BYREF); } else { pc->SetType(CT_ADDR); } } else if (pc->Is(CT_CARET)) { if (language_is_set(LANG_C | LANG_CPP | LANG_OC)) { // This is likely the start of a block literal handle_oc_block_literal(pc); } } } /* * Change the parenthesis pair after a function/macro-function * CT_PAREN_OPEN => CT_FPAREN_OPEN */ if (pc->Is(CT_MACRO_FUNC)) { flag_parens(next, PCF_IN_FCN_CALL, CT_FPAREN_OPEN, CT_MACRO_FUNC, false); } if ( pc->Is(CT_MACRO_OPEN) || pc->Is(CT_MACRO_ELSE) || pc->Is(CT_MACRO_CLOSE)) { if (next->Is(CT_PAREN_OPEN)) { flag_parens(next, PCF_NONE, CT_FPAREN_OPEN, pc->GetType(), false); } } if ( pc->Is(CT_DELETE) && next->Is(CT_TSQUARE)) { next->SetParentType(CT_DELETE); } // Change CT_STAR to CT_PTR_TYPE or CT_ARITH or CT_DEREF if ( pc->Is(CT_STAR) || ( language_is_set(LANG_CPP) && pc->Is(CT_CARET))) { if ( next->IsParenClose() || next->Is(CT_COMMA)) { pc->SetType(CT_PTR_TYPE); } else if ( language_is_set(LANG_OC) && next->Is(CT_STAR)) { /* * Change pointer-to-pointer types in OC_MSG_DECLs * from ARITH <===> DEREF to PTR_TYPE <===> PTR_TYPE */ pc->SetType(CT_PTR_TYPE); pc->SetParentType(prev->GetParentType()); next->SetType(CT_PTR_TYPE); next->SetParentType(pc->GetParentType()); } else if ( pc->Is(CT_STAR) && ( prev->Is(CT_DECLTYPE) || prev->Is(CT_SIZEOF) || prev->Is(CT_DELETE) || pc->GetParentType() == CT_SIZEOF)) { pc->SetType(CT_DEREF); } else if ( ( prev->Is(CT_WORD) && chunk_ends_type(prev) && !prev->TestFlags(PCF_IN_FCN_CTOR) && !prev->TestFlags(PCF_IN_ARRAY_ASSIGN)) // Issue #3345 || prev->Is(CT_DC_MEMBER) || prev->Is(CT_PTR_TYPE)) { LOG_FMT(LFCNR, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n ", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); log_pcf_flags(LFCNR, pc->GetFlags()); pc->SetType(CT_PTR_TYPE); } else if ( next->Is(CT_SQUARE_OPEN) && !language_is_set(LANG_OC)) // Issue #408 { pc->SetType(CT_PTR_TYPE); } else if (pc->Is(CT_STAR)) { // Add check for CT_DC_MEMBER CT_WORD CT_STAR sequence // to convert CT_WORD into CT_TYPE // and CT_STAR into CT_PTR_TYPE // look for an assign backward, function call, return to distinguish between // double result = Constants::PI * factor; // and // ::some::name * foo; if ( prev->Is(CT_WORD) && prev->GetPrev()->Is(CT_DC_MEMBER) && language_is_set(LANG_CPP)) { // Issue 1402 bool is_multiplication = false; Chunk *tmp = pc; while (tmp->IsNotNullChunk()) { if ( tmp->Is(CT_SEMICOLON) || tmp->GetParentType() == CT_CLASS) { break; } else if ( tmp->Is(CT_ASSIGN) || tmp->Is(CT_FUNC_CALL) || tmp->Is(CT_RETURN)) { is_multiplication = true; break; } tmp = tmp->GetPrevNcNnlNi(); // Issue #2279 } if (is_multiplication) { // double result = Constants::PI * factor; pc->SetType(CT_ARITH); } else { // ::some::name * foo; prev->SetType(CT_TYPE); pc->SetType(CT_PTR_TYPE); } } /* * A star can have three meanings * 1. CT_DEREF = pointer dereferencing * 2. CT_PTR_TYPE = pointer definition * 3. CT_ARITH = arithmetic multiplication * * most PCF_PUNCTUATOR chunks except a paren close would make this * a deref. A paren close may end a cast or may be part of a macro fcn. */ if (prev->Is(CT_TYPE)) { pc->SetType(CT_PTR_TYPE); } else if ( pc->GetNext()->Is(CT_SEMICOLON) // Issue #2319 || ( pc->GetNext()->Is(CT_STAR) && pc->GetNext()->GetNext()->Is(CT_SEMICOLON))) { // example: // using AbstractLinkPtr = AbstractLink*; // using AbstractLinkPtrPtr = AbstractLink**; pc->SetType(CT_PTR_TYPE); } else if ( ( pc->GetParentType() == CT_FUNC_DEF && ( next->IsBraceOpen() || pc->GetNext()->IsStar())) || next->Is(CT_QUALIFIER)) // Issue #2648 { // example: // auto getComponent(Color *color) -> Component * { // auto getComponent(Color *color) -> Component ** { // auto getComponent(Color *color) -> Component * _Nonnull // only to help the vim command }} pc->SetType(CT_PTR_TYPE); } else if ( pc->GetNext()->Is(CT_SEMICOLON) // Issue #2319 || ( pc->GetNext()->Is(CT_STAR) && pc->GetNext()->GetNext()->Is(CT_STAR))) { // more pointers are NOT yet possible fprintf(stderr, "Too many pointers: the maximum level of pointer indirection is 3 (i.e., ***p)\n"); fprintf(stderr, "at line %zu, column %zu.\n", pc->GetOrigLine(), pc->GetOrigCol()); fprintf(stderr, "Please make a report.\n"); log_flush(true); exit(EX_SOFTWARE); } else if ( !prev->TestFlags(PCF_PUNCTUATOR) || prev->Is(CT_INCDEC_AFTER) || prev->Is(CT_SQUARE_CLOSE) || prev->Is(CT_DC_MEMBER)) // Issue 1402 { pc->SetType(CT_ARITH); } else if ( !prev->IsParenClose() || prev->Is(CT_SPAREN_CLOSE) || prev->GetParentType() == CT_MACRO_FUNC) { pc->SetType(CT_DEREF); } else { pc->SetType(CT_ARITH); } if (pc->TestFlags(PCF_IN_TYPEDEF)) // Issue #1255/#633 { Chunk *tmp = pc; while (tmp->IsNotNullChunk()) { if ( tmp->Is(CT_SEMICOLON) || tmp->Is(CT_BRACE_OPEN) || tmp->Is(CT_SQUARE_OPEN)) // Issue #3342 { break; } else if (tmp->Is(CT_TYPEDEF)) { pc->SetType(CT_PTR_TYPE); } tmp = tmp->GetPrevNcNnlNi(); // Issue #2279 } } } } if (pc->Is(CT_AMP)) { if (prev->Is(CT_DELETE)) { pc->SetType(CT_ADDR); } else if ( prev->Is(CT_TYPE) || prev->Is(CT_QUALIFIER)) { pc->SetType(CT_BYREF); } else if ( prev->Is(CT_WORD) // Issue #3204 && next->Is(CT_OPERATOR)) { pc->SetType(CT_BYREF); } else if ( next->Is(CT_FPAREN_CLOSE) || next->Is(CT_COMMA)) { // fix the bug #654 // connect(&mapper, SIGNAL(mapped(QString &)), this, SLOT(onSomeEvent(QString &))); pc->SetType(CT_BYREF); } else if (pc->GetParentType() == CT_USING_ALIAS) { // fix the Issue # 1689 // using reference = value_type &; pc->GetPrev()->SetType(CT_TYPE); pc->SetType(CT_BYREF); } else { // Issue # 1398 if ( pc->TestFlags(PCF_IN_FCN_DEF) && prev->Is(CT_WORD) && pc->Is(CT_AMP) && next->Is(CT_WORD)) { /* * Change CT_WORD before CT_AMP before CT_WORD to CT_TYPE */ prev->SetType(CT_TYPE); } else if ( pc->TestFlags(PCF_IN_PREPROC) // Issue #3559 && pc->Is(CT_AMP) && next->Is(CT_WORD)) { //LOG_FMT(LGUY, " ++++++++++ pc->GetFlags(): "); //log_pcf_flags(LGUY, pc->GetFlags()); pc->SetType(CT_ADDR); } else { pc->SetType(CT_ARITH); if ( prev->Is(CT_WORD) && !next->Is(CT_NUMBER)) // Issue #3407 { Chunk *tmp = prev->GetPrevNcNnlNi(); // Issue #2279 if (tmp->IsNotNullChunk()) { if ( tmp->IsSemicolon() || tmp->Is(CT_BRACE_OPEN) || tmp->Is(CT_QUALIFIER)) { pc->SetType(CT_BYREF); prev->SetType(CT_TYPE); if (!( next->Is(CT_OPERATOR) || next->Is(CT_TYPE) || next->Is(CT_DC_MEMBER))) { LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', set PCF_VAR_1ST\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); next->SetFlagBits(PCF_VAR_1ST); } } else if (tmp->Is(CT_DC_MEMBER)) { prev->SetType(CT_TYPE); } } } } } } if ( pc->Is(CT_MINUS) || pc->Is(CT_PLUS)) { if ( prev->Is(CT_POS) || prev->Is(CT_NEG) || prev->Is(CT_ARITH) || prev->Is(CT_SHIFT)) { pc->SetType(pc->Is(CT_MINUS) ? CT_NEG : CT_POS); } else if (prev->Is(CT_OC_CLASS)) { pc->SetType((pc->Is(CT_MINUS)) ? CT_NEG : CT_POS); } else { pc->SetType(CT_ARITH); } } /* * Bug # 634 * Check for extern "C" NSString* i; * NSString is a type * change CT_WORD => CT_TYPE for pc * change CT_STAR => CT_PTR_TYPE for pc-next */ if (pc->Is(CT_WORD)) // here NSString { Chunk *pcNext = pc->GetNext(); Chunk *pcPrev = pc->GetPrev(); if (pcNext->Is(CT_STAR)) // here * { // compare text with "C" to find extern "C" instructions if (pcPrev->Is(CT_STRING)) { if (unc_text::compare(pcPrev->Text(), "\"C\"") == 0) { if (pcPrev->GetPrev()->Is(CT_EXTERN)) { pc->SetType(CT_TYPE); // change CT_WORD => CT_TYPE pcNext->SetType(CT_PTR_TYPE); // change CT_STAR => CT_PTR_TYPE } } } // Issue #322 STDMETHOD(GetValues)(BSTR bsName, REFDATA** pData); Chunk *nnext = pcNext->GetNext(); if ( nnext->Is(CT_STAR) && pc->TestFlags(PCF_IN_CONST_ARGS)) { // change CT_STAR => CT_PTR_TYPE pcNext->SetType(CT_PTR_TYPE); nnext->SetType(CT_PTR_TYPE); } // Issue #222 whatever3 *(func_ptr)( whatever4 *foo2, ... if ( nnext->Is(CT_WORD) && pc->TestFlags(PCF_IN_FCN_DEF)) { // look for the opening parenthesis // Issue 1403 Chunk *tmp = pc->GetPrevType(CT_FPAREN_OPEN, pc->GetLevel() - 1); if ( tmp->IsNotNullChunk() && tmp->GetParentType() != CT_FUNC_CTOR_VAR) { pcNext->SetType(CT_PTR_TYPE); } } } } /* * Bug # 634 * Check for __attribute__((visibility ("default"))) NSString* i; * NSString is a type * change CT_WORD => CT_TYPE for pc * change CT_STAR => CT_PTR_TYPE for pc-next */ if (pc->Is(CT_WORD)) // here NSString { Chunk *pcNext = pc->GetNext(); if (pcNext->Is(CT_STAR)) // here * { Chunk *tmp = pc; while (tmp->IsNotNullChunk()) { if (tmp->Is(CT_ATTRIBUTE)) { LOG_FMT(LFCNR, "%s(%d): ATTRIBUTE found, type is %s, Text() '%s'\n", __func__, __LINE__, get_token_name(tmp->GetType()), tmp->Text()); LOG_FMT(LFCNR, "for token, type is %s, Text() '%s'\n", get_token_name(pc->GetType()), pc->Text()); // change CT_WORD => CT_TYPE pc->SetType(CT_TYPE); // change CT_STAR => CT_PTR_TYPE pcNext->SetType(CT_PTR_TYPE); } if (tmp->TestFlags(PCF_STMT_START)) { // we are at beginning of the line break; } tmp = tmp->GetPrev(); } } } /* * Issue # 1689 * Check for using reference = value_type&; * is it a Type alias, alias template? */ if (pc->Is(CT_USING)) { // look for CT_ASSIGN before CT_SEMICOLON at the end of the statement bool is_preproc = pc->TestFlags(PCF_IN_PREPROC); auto const search_assign = [&pc, &is_preproc]() { for (Chunk *temp = pc; temp->IsNotNullChunk(); temp = temp->GetNextNcNnl()) { LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, temp->GetOrigLine(), temp->GetOrigCol(), temp->Text(), get_token_name(temp->GetType())); if (temp->Is(CT_ASSIGN)) { return(true); } if ( temp->Is(CT_SEMICOLON) || ( is_preproc && ( !temp->TestFlags(PCF_IN_PREPROC) || temp->Is(CT_PREPROC)))) { return(false); } } return(false); }; const bool assign_found = language_is_set(LANG_D) || search_assign(); if (assign_found) { // it is a Type alias, alias template for (Chunk *temp = pc; temp->IsNotNullChunk(); temp = temp->GetNextNcNnl()) { if (temp->GetParentType() == CT_NONE) { temp->SetParentType(CT_USING_ALIAS); } if ( temp->Is(CT_SEMICOLON) || ( is_preproc && ( !temp->TestFlags(PCF_IN_PREPROC) || temp->Is(CT_PREPROC)))) { break; } } } } // Issue #548: inline T && someFunc(foo * *p, bar && q) { } if ( pc->Is(CT_BOOL) && !pc->TestFlags(PCF_IN_PREPROC) && pc->IsString("&&") && chunk_ends_type(pc->GetPrev())) { Chunk *tmp = pc->GetPrev(); // Issue #2688 LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text(), get_token_name(tmp->GetType())); log_pcf_flags(LFCNR, tmp->GetFlags()); // look for a type if (tmp->Is(CT_TYPE)) { LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); log_pcf_flags(LFCNR, pc->GetFlags()); pc->SetType(CT_BYREF); } // look next, is there a "assign" before the ";" Chunk *semi = pc->GetNextType(CT_SEMICOLON, pc->GetLevel()); // Issue #2688 if (semi->IsNotNullChunk()) { LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, semi->GetOrigLine(), semi->GetOrigCol(), semi->Text(), get_token_name(semi->GetType())); for (Chunk *test_it = pc; test_it != semi; test_it = test_it->GetNext()) { LOG_FMT(LFCNR, "%s(%d): test_it orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, test_it->GetOrigLine(), test_it->GetOrigCol(), test_it->Text(), get_token_name(test_it->GetType())); if (test_it->Is(CT_ASSIGN)) { // the statement is an assignment // && is before assign pc->SetType(CT_BYREF); break; } } } } // Issue #1704 if ( pc->Is(CT_INCDEC_AFTER) && pc->TestFlags(PCF_IN_PREPROC)) { Chunk *tmp_2 = pc->GetNext(); LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); log_pcf_flags(LFTYPE, pc->GetFlags()); if (tmp_2->Is(CT_WORD)) { pc->SetType(CT_INCDEC_BEFORE); } } } // do_symbol_check static void check_double_brace_init(Chunk *bo1) { LOG_FUNC_ENTRY(); LOG_FMT(LJDBI, "%s(%d): orig line is %zu, orig col is %zu", __func__, __LINE__, bo1->GetOrigLine(), bo1->GetOrigCol()); Chunk *pc = bo1->GetPrevNcNnlNi(); // Issue #2279 if (pc->IsNullChunk()) { return; } if (pc->IsParenClose()) { Chunk *bo2 = bo1->GetNext(); if (bo2->IsNullChunk()) { return; } if (bo2->Is(CT_BRACE_OPEN)) { // found a potential double brace Chunk *bc2 = bo2->GetClosingParen(); if (bc2->IsNullChunk()) { return; } Chunk *bc1 = bc2->GetNext(); if (bc1->IsNullChunk()) { return; } if (bc1->Is(CT_BRACE_CLOSE)) { LOG_FMT(LJDBI, " - end, orig line is %zu, orig col is %zu\n", bc2->GetOrigLine(), bc2->GetOrigCol()); // delete bo2 and bc1 bo1->Str() += bo2->GetStr(); bo1->SetOrigColEnd(bo2->GetOrigColEnd()); Chunk::Delete(bo2); bo1->SetParentType(CT_DOUBLE_BRACE); bc2->Str() += bc1->GetStr(); bc2->SetOrigColEnd(bc1->GetOrigColEnd()); Chunk::Delete(bc1); bc2->SetParentType(CT_DOUBLE_BRACE); return; } } } LOG_FMT(LJDBI, " - no\n"); } // check_double_brace_init void fix_symbols() { LOG_FUNC_ENTRY(); Chunk *pc; cpd.unc_stage = unc_stage_e::FIX_SYMBOLS; mark_define_expressions(); bool is_cpp = language_is_set(LANG_CPP); bool is_java = language_is_set(LANG_JAVA); for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { LOG_FMT(LFCNR, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); if ( pc->Is(CT_FUNC_WRAP) || pc->Is(CT_TYPE_WRAP)) { handle_wrap(pc); } if (pc->Is(CT_ASSIGN)) { mark_lvalue(pc); } // a brace immediately preceded by word in C++11 is an initializer list though it may also // by a type casting initializer list if the word is really a type; sadly uncrustify knows // only built-in types and knows nothing of user-defined types Chunk *prev = pc->GetPrevNcNnlNi(); // Issue #2279 if ( is_cpp && pc->Is(CT_BRACE_OPEN) && ( prev->Is(CT_WORD) || prev->Is(CT_TYPE))) { mark_lvalue(pc); } if ( is_java && pc->Is(CT_BRACE_OPEN)) { check_double_brace_init(pc); } if (pc->Is(CT_ATTRIBUTE)) { Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); if ( next->IsNotNullChunk() && next->Is(CT_PAREN_OPEN)) { flag_parens(next, PCF_NONE, CT_FPAREN_OPEN, CT_ATTRIBUTE, false); } } } pc = Chunk::GetHead(); if (pc->IsCommentOrNewline()) { pc = pc->GetNextNcNnl(); } while (pc->IsNotNullChunk()) { if (pc->Is(CT_IGNORED)) { pc = pc->GetNextNcNnl(); continue; } LOG_FMT(LFCNR, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); Chunk *prev = pc->GetPrevNcNnlNi(E_Scope::PREPROC); // Issue #2279 if (prev->Is(CT_QUALIFIER)) { prev = prev->GetPrevNcNnlNi(E_Scope::PREPROC); // Issue #3513 } if (prev->IsNullChunk()) { LOG_FMT(LFCNR, "%s(%d): WARNING: prev is NOT defined\n", __func__, __LINE__); } else { // Issue #2279 LOG_FMT(LFCNR, "%s(%d): prev(ni) orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), prev->Text(), get_token_name(prev->GetType())); } Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); if (next->IsNullChunk()) { LOG_FMT(LFCNR, "%s(%d): WARNING: next is NOT defined\n", __func__, __LINE__); } else { // Issue #2279 LOG_FMT(LFCNR, "%s(%d): next orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text(), get_token_name(next->GetType())); } LOG_FMT(LFCNR, "%s(%d): do_symbol_check(%s, %s, %s)\n", __func__, __LINE__, prev->Text(), pc->Text(), next->Text()); do_symbol_check(prev, pc, next); pc = pc->GetNextNcNnl(); } pawn_add_virtual_semicolons(); process_returns_and_throws(); /* * 2nd pass - handle variable definitions * REVISIT: We need function params marked to do this (?) */ pc = Chunk::GetHead(); int square_level = -1; while ( pc != nullptr && pc->IsNotNullChunk()) { char copy[1000]; LOG_FMT(LFCNR, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s, parent type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy), get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); // Can't have a variable definition inside [ ] if (square_level < 0) { if (pc->Is(CT_SQUARE_OPEN)) { square_level = pc->GetLevel(); } } else { if (pc->GetLevel() <= static_cast(square_level)) { square_level = -1; } } if ( pc->Is(CT_EXTERN) && language_is_set(LANG_ALLC)) { Chunk *next = pc->GetNextNcNnl(); if (next->Is(CT_STRING)) { Chunk *tmp = next->GetNextNcNnl(); while (tmp->IsNotNullChunk()) { if ( tmp->Is(CT_TYPE) || tmp->Is(CT_BRACE_OPEN) || tmp->Is(CT_ATTRIBUTE)) { break; } if (tmp->Is(CT_WORD)) { tmp->SetFlagBits(PCF_STMT_START | PCF_EXPR_START); break; } tmp = tmp->GetNextNcNnl(); } } } if ( pc->Is(CT_ATTRIBUTE) && language_is_set(LANG_ALLC)) { Chunk *tmp = skip_attribute_next(pc); if (tmp->Is(CT_WORD)) { tmp->SetFlagBits(PCF_STMT_START | PCF_EXPR_START); } } if ( pc->Is(CT_BRACE_OPEN) // Issue #2332 && pc->GetParentType() == CT_BRACED_INIT_LIST) { LOG_FMT(LFCNR, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', look for CT_BRACE_OPEN\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc = pc->GetNextType(CT_BRACE_CLOSE, pc->GetLevel()); } /* * A variable definition is possible after at the start of a statement * that starts with: DC_MEMBER, QUALIFIER, TYPE, or WORD */ // Issue #2279 // Issue #2478 LOG_FMT(LFCNR, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s, parent type is %s\n ", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy), get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); log_pcf_flags(LFCNR, pc->GetFlags()); if ( (square_level < 0) && pc->TestFlags(PCF_STMT_START) && ( pc->Is(CT_QUALIFIER) || pc->Is(CT_TYPE) || pc->Is(CT_TYPENAME) || pc->Is(CT_DC_MEMBER) // Issue #2478 || ( pc->Is(CT_WORD) && !pc->TestFlags(PCF_IN_CONDITIONAL) // Issue #3558 // && language_is_set(LANG_CPP) ) ) && pc->GetParentType() != CT_BIT_COLON && pc->GetParentType() != CT_ENUM && !pc->TestFlags(PCF_IN_CLASS_BASE) && !pc->TestFlags(PCF_IN_ENUM)) { pc = fix_variable_definition(pc); } else { pc = pc->GetNextNcNnl(); } } } // fix_symbols static void process_returns_and_throws() { LOG_FUNC_ENTRY(); Chunk *pc; pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { if ( pc->Is(CT_RETURN) || pc->Is(CT_THROW)) { pc = process_return_or_throw(pc); } else { pc = pc->GetNext(); } } } static Chunk *process_return_or_throw(Chunk *pc) { LOG_FUNC_ENTRY(); const char *nl_expr_name; iarf_e nl_expr_value; const char *mod_paren_name; iarf_e mod_paren_value; if (pc->Is(CT_RETURN)) { nl_expr_name = "nl_return_expr"; nl_expr_value = options::nl_return_expr(); mod_paren_name = "mod_paren_on_return"; mod_paren_value = options::mod_paren_on_return(); } else if (pc->Is(CT_THROW)) { nl_expr_name = "nl_throw_expr"; nl_expr_value = options::nl_throw_expr(); mod_paren_name = "mod_paren_on_throw"; mod_paren_value = options::mod_paren_on_throw(); } else // should never happen { return(pc->GetNext()); } Chunk *next; Chunk *temp; Chunk *semi; Chunk *cpar; Chunk chunk; // grab next and bail if it is a semicolon next = pc->PpaGetNextNcNnl(); if ( next->IsNullChunk() || next->IsSemicolon() || next->Is(CT_NEWLINE)) { return(next); } log_rule_B(nl_expr_name); if ( nl_expr_value != IARF_IGNORE && !pc->TestFlags(PCF_IN_PREPROC)) { newline_iarf(pc, nl_expr_value); } if (next->Is(CT_PAREN_OPEN)) { // See if the return/throw is fully paren'd cpar = next->GetNextType(CT_PAREN_CLOSE, next->GetLevel()); if (cpar->IsNullChunk()) { return(Chunk::NullChunkPtr); } semi = cpar->PpaGetNextNcNnl(); if (semi->IsNullChunk()) { return(Chunk::NullChunkPtr); } if ( semi->Is(CT_NEWLINE) || semi->IsSemicolon()) { log_rule_B(mod_paren_name); if (mod_paren_value == IARF_REMOVE) { LOG_FMT(LRETURN, "%s(%d): removing parens on orig line %zu\n", __func__, __LINE__, pc->GetOrigLine()); // lower the level of everything for (temp = next; temp != cpar; temp = temp->GetNext()) { if (temp->GetLevel() == 0) { fprintf(stderr, "%s(%d): temp->GetLevel() is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, temp->GetOrigLine(), temp->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } temp->SetLevel(temp->GetLevel() - 1); } // delete the parenthesis Chunk::Delete(next); Chunk::Delete(cpar); // back up following chunks temp = semi; while ( temp->IsNotNullChunk() && temp->IsNot(CT_NEWLINE)) { temp->SetColumn(temp->GetColumn() - 2); temp->SetOrigCol(temp->GetOrigCol() - 2); temp->SetOrigColEnd(temp->GetOrigColEnd() - 2); temp = temp->GetNext(); } } else { LOG_FMT(LRETURN, "%s(%d): keeping parens on orig line %zu\n", __func__, __LINE__, pc->GetOrigLine()); // mark & keep them next->SetParentType(pc->GetType()); cpar->SetParentType(pc->GetType()); } return(semi); } } // We don't have a fully paren'd return/throw. Should we add some? log_rule_B(mod_paren_name); if (!(mod_paren_value & IARF_ADD)) { return(next); } // Issue #1917 // Never add parens to a braced init list; that breaks the code // return {args...}; // C++11 type elision; okay // return ({args...}); // ill-formed if ( language_is_set(LANG_CPP) && next->Is(CT_BRACE_OPEN) && next->GetParentType() == CT_BRACED_INIT_LIST) { LOG_FMT(LRETURN, "%s(%d): not adding parens around braced initializer" " on orig line %zd\n", __func__, __LINE__, pc->GetOrigLine()); return(next); } // find the next semicolon on the same level semi = next; if (pc->TestFlags(PCF_IN_PREPROC)) { while ((semi = semi->GetNext())->IsNotNullChunk()) { if (!semi->TestFlags(PCF_IN_PREPROC)) { break; } if (semi->GetLevel() < pc->GetLevel()) { return(semi); } if ( semi->IsSemicolon() && pc->GetLevel() == semi->GetLevel()) { break; } } } else { while ((semi = semi->GetNext())->IsNotNullChunk()) { if (semi->GetLevel() < pc->GetLevel()) { return(semi); } if ( semi->IsSemicolon() && pc->GetLevel() == semi->GetLevel()) { break; } } } if (semi) { // add the parenthesis chunk.SetType(CT_PAREN_OPEN); chunk.SetParentType(pc->GetType()); chunk.Str() = "("; chunk.SetLevel(pc->GetLevel()); chunk.SetPpLevel(pc->GetPpLevel()); chunk.SetBraceLevel(pc->GetBraceLevel()); chunk.SetOrigLine(pc->GetOrigLine()); chunk.SetOrigCol(next->GetOrigCol() - 1); chunk.SetFlags(pc->GetFlags() & PCF_COPY_FLAGS); chunk.CopyAndAddBefore(next); chunk.SetType(CT_PAREN_CLOSE); chunk.Str() = ")"; chunk.SetOrigLine(semi->GetOrigLine()); chunk.SetOrigCol(semi->GetOrigCol() - 1); cpar = chunk.CopyAndAddBefore(semi); LOG_FMT(LRETURN, "%s(%d): added parens on orig line %zu\n", __func__, __LINE__, pc->GetOrigLine()); for (temp = next; temp != cpar; temp = temp->GetNext()) { temp->SetLevel(temp->GetLevel() + 1); } } return(semi); } // process_return_or_throw static bool is_oc_block(Chunk *pc) { return( pc != nullptr && ( pc->GetParentType() == CT_OC_BLOCK_TYPE || pc->GetParentType() == CT_OC_BLOCK_EXPR || pc->GetParentType() == CT_OC_BLOCK_ARG || pc->GetParentType() == CT_OC_BLOCK || pc->Is(CT_OC_BLOCK_CARET) || pc->GetNext()->Is(CT_OC_BLOCK_CARET) || pc->GetPrev()->Is(CT_OC_BLOCK_CARET))); } void mark_comments() { LOG_FUNC_ENTRY(); cpd.unc_stage = unc_stage_e::MARK_COMMENTS; bool prev_nl = true; Chunk *cur = Chunk::GetHead(); while (cur->IsNotNullChunk()) { Chunk *next = cur->GetNextNvb(); bool next_nl = next->IsNullChunk() || next->IsNewline(); if (cur->IsComment()) { if ( next_nl && prev_nl) { cur->SetParentType(CT_COMMENT_WHOLE); } else if (next_nl) { cur->SetParentType(CT_COMMENT_END); } else if (prev_nl) { cur->SetParentType(CT_COMMENT_START); } else { cur->SetParentType(CT_COMMENT_EMBED); } } prev_nl = cur->IsNewline(); cur = next; } } static void handle_cpp_template(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *tmp = pc->GetNextNcNnl(); if (tmp->IsNot(CT_ANGLE_OPEN)) { return; } tmp->SetParentType(CT_TEMPLATE); size_t level = tmp->GetLevel(); tmp = tmp->GetNext(); while (tmp->IsNotNullChunk()) { if ( tmp->Is(CT_CLASS) || tmp->Is(CT_STRUCT)) { tmp->SetType(CT_TYPE); } else if ( tmp->Is(CT_ANGLE_CLOSE) && tmp->GetLevel() == level) { tmp->SetParentType(CT_TEMPLATE); break; } tmp = tmp->GetNext(); } if (tmp->IsNotNullChunk()) { tmp = tmp->GetNextNcNnl(); if (tmp->Is(CT_FRIEND)) { // Account for a template friend declaration tmp->SetParentType(CT_TEMPLATE); tmp = tmp->GetNextNcNnl(); } if (tmp->IsClassOrStruct()) { tmp->SetParentType(CT_TEMPLATE); // REVISIT: This may be a bit risky - might need to track the { }; tmp = tmp->GetNextType(CT_SEMICOLON, tmp->GetLevel()); if (tmp->IsNotNullChunk()) { tmp->SetParentType(CT_TEMPLATE); } } } } // handle_cpp_template static void handle_cpp_lambda(Chunk *sq_o) { LOG_FUNC_ENTRY(); Chunk *ret = Chunk::NullChunkPtr; // abort if type of the previous token is not contained in this whitelist Chunk *prev = sq_o->GetPrevNcNnlNi(); // Issue #2279 if (prev->IsNullChunk()) { LOG_FMT(LFCNR, "%s(%d): prev is nullptr\n", __func__, __LINE__); } if ( prev->IsNullChunk() || ( prev->IsNot(CT_ASSIGN) && prev->IsNot(CT_COMMA) && prev->IsNot(CT_PAREN_OPEN) // allow Js like self invoking lambda syntax: ([](){})(); && prev->IsNot(CT_FPAREN_OPEN) && prev->IsNot(CT_SQUARE_OPEN) && prev->IsNot(CT_BRACE_OPEN) && prev->IsNot(CT_SEMICOLON) && prev->IsNot(CT_RETURN))) { LOG_FMT(LFCNR, "%s(%d): return\n", __func__, __LINE__); return; } Chunk *sq_c = sq_o; // assuming '[]' if (sq_o->Is(CT_SQUARE_OPEN)) { // make sure there is a ']' sq_c = sq_o->GetClosingParen(); if (sq_c->IsNullChunk()) { LOG_FMT(LFCNR, "%s(%d): return\n", __func__, __LINE__); return; } } Chunk *pa_o = sq_c->GetNextNcNnl(); // check to see if there is a lambda-specifier in the pa_o chunk; // assuming chunk is CT_EXECUTION_CONTEXT, ignore lambda-specifier while (pa_o->Is(CT_EXECUTION_CONTEXT)) { // set pa_o to next chunk after this specifier pa_o = pa_o->GetNextNcNnl(); } if (pa_o->IsNullChunk()) { LOG_FMT(LFCNR, "%s(%d): return\n", __func__, __LINE__); return; } Chunk *pa_c = Chunk::NullChunkPtr; // lambda-declarator '( params )' is optional if (pa_o->Is(CT_PAREN_OPEN)) { // and now find the ')' pa_c = pa_o->GetClosingParen(); if (pa_c->IsNullChunk()) { LOG_FMT(LFCNR, "%s(%d): return\n", __func__, __LINE__); return; } } // Check for 'mutable' keyword: '[]() mutable {}' or []() mutable -> ret {} Chunk *br_o = pa_c->IsNotNullChunk() ? pa_c->GetNextNcNnl() : pa_o; if (br_o->IsString("mutable")) { br_o = br_o->GetNextNcNnl(); } //TODO: also check for exception and attribute between [] ... {} // skip possible arrow syntax: '-> ret' if (br_o->IsString("->")) { ret = br_o; // REVISIT: really should check the stuff we are skipping br_o = br_o->GetNextType(CT_BRACE_OPEN, br_o->GetLevel()); } // skip possible CT_NOEXCEPT if (br_o->Is(CT_NOEXCEPT)) // Issue #3321 { ret = br_o; // REVISIT: really should check the stuff we are skipping br_o = br_o->GetNextType(CT_BRACE_OPEN, br_o->GetLevel()); } if (br_o->IsNullChunk()) { LOG_FMT(LFCNR, "%s(%d): br_o is null. Return\n", __func__, __LINE__); return; } if (br_o->IsNot(CT_BRACE_OPEN)) { LOG_FMT(LFCNR, "%s(%d): br_o is '%s'/%s\n", __func__, __LINE__, br_o->Text(), get_token_name(br_o->GetType())); LOG_FMT(LFCNR, "%s(%d): return\n", __func__, __LINE__); return; } // and now find the '}' Chunk *br_c = br_o->GetClosingParen(); if (br_c->IsNullChunk()) { LOG_FMT(LFCNR, "%s(%d): return\n", __func__, __LINE__); return; } // This looks like a lambda expression if (sq_o->Is(CT_TSQUARE)) { // split into two chunks Chunk nc; nc = *sq_o; sq_o->SetType(CT_SQUARE_OPEN); sq_o->Str().resize(1); /* * bug # 664 * * The original m_origCol of CT_SQUARE_CLOSE is stored at m_origColEnd * of CT_TSQUARE. CT_SQUARE_CLOSE m_origCol and m_origColEnd values * are calculate from m_origColEnd of CT_TSQUARE. */ nc.SetOrigCol(sq_o->GetOrigColEnd() - 1); nc.SetColumn(nc.GetOrigCol()); nc.SetOrigColEnd(sq_o->GetOrigColEnd()); sq_o->SetOrigColEnd(sq_o->GetOrigCol() + 1); nc.SetType(CT_SQUARE_CLOSE); nc.Str().pop_front(); sq_c = nc.CopyAndAddAfter(sq_o); } sq_o->SetParentType(CT_CPP_LAMBDA); sq_c->SetParentType(CT_CPP_LAMBDA); if (pa_c->IsNotNullChunk()) { pa_o->SetType(CT_LPAREN_OPEN); // Issue #3054 pa_o->SetParentType(CT_CPP_LAMBDA); pa_o->SetParent(sq_o); br_o->SetParent(sq_o); pa_c->SetType(CT_LPAREN_CLOSE); pa_c->SetParentType(CT_CPP_LAMBDA); pa_c->SetParent(sq_o); br_c->SetParent(sq_o); } br_o->SetParentType(CT_CPP_LAMBDA); br_c->SetParentType(CT_CPP_LAMBDA); if (ret->IsNotNullChunk()) { ret->SetType(CT_CPP_LAMBDA_RET); ret = ret->GetNextNcNnl(); while (ret != br_o) { make_type(ret); ret = ret->GetNextNcNnl(); } } if (pa_c->IsNotNullChunk()) { fix_fcn_def_params(pa_o); } //handle self calling lambda paren Chunk *call_pa_o = br_c->GetNextNcNnl(); if (call_pa_o->Is(CT_PAREN_OPEN)) { Chunk *call_pa_c = call_pa_o->GetClosingParen(); if (call_pa_c->IsNotNullChunk()) { call_pa_o->SetType(CT_FPAREN_OPEN); call_pa_o->SetParentType(CT_FUNC_CALL); call_pa_c->SetType(CT_FPAREN_CLOSE); call_pa_c->SetParentType(CT_FUNC_CALL); } } mark_cpp_lambda(sq_o); } // handle_cpp_lambda static void handle_d_template(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *name = pc->GetNextNcNnl(); Chunk *po = name->GetNextNcNnl(); if ( name->IsNullChunk() || name->IsNot(CT_WORD)) { // TODO: log an error, expected NAME return; } if ( po->IsNullChunk() || po->IsNot(CT_PAREN_OPEN)) { // TODO: log an error, expected '(' return; } name->SetType(CT_TYPE); name->SetParentType(CT_TEMPLATE); po->SetParentType(CT_TEMPLATE); ChunkStack cs; Chunk *tmp = get_d_template_types(cs, po); if ( tmp == nullptr || tmp->IsNot(CT_PAREN_CLOSE)) { // TODO: log an error, expected ')' return; } tmp->SetParentType(CT_TEMPLATE); tmp = tmp->GetNextNcNnl(); if (tmp->IsNot(CT_BRACE_OPEN)) { // TODO: log an error, expected '{' return; } tmp->SetParentType(CT_TEMPLATE); po = tmp; tmp = tmp->GetNextNcNnl(); while ( tmp->IsNotNullChunk() && tmp->GetLevel() > po->GetLevel()) { if ( tmp->Is(CT_WORD) && chunkstack_match(cs, tmp)) { tmp->SetType(CT_TYPE); } tmp = tmp->GetNextNcNnl(); } // if (!tmp->Is(CT_BRACE_CLOSE)) // { // // TODO: log an error, expected '}' // } tmp->SetParentType(CT_TEMPLATE); } // handle_d_template Chunk *skip_template_next(Chunk *ang_open) { if (ang_open == nullptr) { return(Chunk::NullChunkPtr); } if (ang_open->Is(CT_ANGLE_OPEN)) { Chunk *pc = ang_open->GetNextType(CT_ANGLE_CLOSE, ang_open->GetLevel()); if (pc->IsNullChunk()) { return(Chunk::NullChunkPtr); } return(pc->GetNextNcNnl()); } return(ang_open); } static void handle_oc_class(Chunk *pc) { enum class angle_state_e : unsigned int { NONE = 0, OPEN = 1, // '<' found CLOSE = 2, // '>' found }; LOG_FUNC_ENTRY(); Chunk *tmp; bool hit_scope = false; bool passed_name = false; // Did we pass the name of the class and now there can be only protocols, not generics int generic_level = 0; // level of depth of generic angle_state_e as = angle_state_e::NONE; LOG_FMT(LOCCLASS, "%s(%d): start [%s] [%s] line %zu\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetParentType()), pc->GetOrigLine()); if (pc->GetParentType() == CT_OC_PROTOCOL) { tmp = pc->GetNextNcNnl(); if (tmp->IsSemicolon()) { tmp->SetParentType(pc->GetParentType()); LOG_FMT(LOCCLASS, "%s(%d): bail on semicolon\n", __func__, __LINE__); return; } } tmp = pc; while ( (tmp = tmp->GetNextNnl()) != nullptr && tmp->IsNotNullChunk()) { LOG_FMT(LOCCLASS, "%s(%d): orig line is %zu, [%s]\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->Text()); if (tmp->Is(CT_OC_END)) { break; } if (tmp->Is(CT_PAREN_OPEN)) { passed_name = true; } if (tmp->IsString("<")) { tmp->SetType(CT_ANGLE_OPEN); if (passed_name) { tmp->SetParentType(CT_OC_PROTO_LIST); } else { tmp->SetParentType(CT_OC_GENERIC_SPEC); generic_level++; } as = angle_state_e::OPEN; } if (tmp->IsString(">")) { tmp->SetType(CT_ANGLE_CLOSE); if (passed_name) { tmp->SetParentType(CT_OC_PROTO_LIST); as = angle_state_e::CLOSE; } else { tmp->SetParentType(CT_OC_GENERIC_SPEC); if (generic_level == 0) { fprintf(stderr, "%s(%d): generic_level is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } generic_level--; if (generic_level == 0) { as = angle_state_e::CLOSE; } } } if (tmp->IsString(">>")) { tmp->SetType(CT_ANGLE_CLOSE); tmp->SetParentType(CT_OC_GENERIC_SPEC); split_off_angle_close(tmp); generic_level -= 1; if (generic_level == 0) { as = angle_state_e::CLOSE; } } if ( tmp->Is(CT_BRACE_OPEN) && tmp->GetParentType() != CT_ASSIGN) { as = angle_state_e::CLOSE; tmp->SetParentType(CT_OC_CLASS); tmp = tmp->GetNextType(CT_BRACE_CLOSE, tmp->GetLevel()); if ( tmp->IsNotNullChunk() && tmp->GetParentType() != CT_ASSIGN) { tmp->SetParentType(CT_OC_CLASS); } } else if (tmp->Is(CT_COLON)) { if (as != angle_state_e::OPEN) { passed_name = true; } tmp->SetType(hit_scope ? CT_OC_COLON : CT_CLASS_COLON); if (tmp->Is(CT_CLASS_COLON)) { tmp->SetParentType(CT_OC_CLASS); } } else if ( tmp->IsString("-") || tmp->IsString("+")) { as = angle_state_e::CLOSE; if (tmp->GetPrev()->IsNewline()) { tmp->SetType(CT_OC_SCOPE); tmp->SetFlagBits(PCF_STMT_START); hit_scope = true; } } if (as == angle_state_e::OPEN) { if (passed_name) { tmp->SetParentType(CT_OC_PROTO_LIST); } else { tmp->SetParentType(CT_OC_GENERIC_SPEC); } } } if (tmp->Is(CT_BRACE_OPEN)) { tmp = tmp->GetNextType(CT_BRACE_CLOSE, tmp->GetLevel()); if (tmp->IsNotNullChunk()) { tmp->SetParentType(CT_OC_CLASS); } } } // handle_oc_class static void handle_oc_block_literal(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc == nullptr) { return; // let's be paranoid } Chunk *prev = pc->GetPrevNcNnlNi(); // Issue #2279 Chunk *next = pc->GetNextNcNnl(); if ( prev->IsNullChunk() || next->IsNullChunk()) { return; // let's be paranoid } /* * block literal: '^ RTYPE ( ARGS ) { }' * RTYPE and ARGS are optional */ LOG_FMT(LOCBLK, "%s(%d): block literal @ orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); Chunk *apo = Chunk::NullChunkPtr; // arg paren open Chunk *bbo = Chunk::NullChunkPtr; // block brace open Chunk *bbc; // block brace close LOG_FMT(LOCBLK, "%s(%d): + scan", __func__, __LINE__); Chunk *tmp; for (tmp = next; tmp->IsNotNullChunk(); tmp = tmp->GetNextNcNnl()) { /* handle '< protocol >' */ if (tmp->IsString("<")) { Chunk *ao = tmp; Chunk *ac = ao->GetNextString(">", 1, ao->GetLevel()); if (ac->IsNotNullChunk()) { ao->SetType(CT_ANGLE_OPEN); ao->SetParentType(CT_OC_PROTO_LIST); ac->SetType(CT_ANGLE_CLOSE); ac->SetParentType(CT_OC_PROTO_LIST); for (tmp = ao->GetNext(); tmp != ac; tmp = tmp->GetNext()) { tmp->SetLevel(tmp->GetLevel() + 1); tmp->SetParentType(CT_OC_PROTO_LIST); } tmp = ac->GetNextNcNnl(); } else { tmp = Chunk::NullChunkPtr; } } LOG_FMT(LOCBLK, " '%s'", tmp->Text()); if ( tmp->GetLevel() < pc->GetLevel() || tmp->Is(CT_SEMICOLON)) { LOG_FMT(LOCBLK, "[DONE]"); break; } if (tmp->GetLevel() == pc->GetLevel()) { if (tmp->IsParenOpen()) { apo = tmp; LOG_FMT(LOCBLK, "[PAREN]"); } if (tmp->Is(CT_BRACE_OPEN)) { LOG_FMT(LOCBLK, "[BRACE]"); bbo = tmp; break; } } } // make sure we have braces bbc = bbo->GetClosingParen(); if ( bbo->IsNullChunk() || bbc->IsNullChunk()) { LOG_FMT(LOCBLK, " -- no braces found\n"); return; } LOG_FMT(LOCBLK, "\n"); // we are on a block literal for sure pc->SetType(CT_OC_BLOCK_CARET); pc->SetParentType(CT_OC_BLOCK_EXPR); // handle the optional args Chunk *lbp; // last before paren - end of return type, if any if (apo->IsNotNullChunk()) { Chunk *apc = apo->GetClosingParen(); // arg parenthesis close if (apc->IsParenClose()) { LOG_FMT(LOCBLK, " -- marking parens @ apo orig line is %zu, orig col is %zu and apc orig line is %zu, orig col is %zu\n", apo->GetOrigLine(), apo->GetOrigCol(), apc->GetOrigLine(), apc->GetOrigCol()); flag_parens(apo, PCF_OC_ATYPE, CT_FPAREN_OPEN, CT_OC_BLOCK_EXPR, true); fix_fcn_def_params(apo); } lbp = apo->GetPrevNcNnlNi(); // Issue #2279 } else { lbp = bbo->GetPrevNcNnlNi(); // Issue #2279 } // mark the return type, if any while (lbp != pc) { LOG_FMT(LOCBLK, " -- lbp %s[%s]\n", lbp->Text(), get_token_name(lbp->GetType())); make_type(lbp); lbp->SetFlagBits(PCF_OC_RTYPE); lbp->SetParentType(CT_OC_BLOCK_EXPR); lbp = lbp->GetPrevNcNnlNi(); // Issue #2279 } // mark the braces bbo->SetParentType(CT_OC_BLOCK_EXPR); bbc->SetParentType(CT_OC_BLOCK_EXPR); // mark the OC_BLOCK for (Chunk *tmp1 = bbo; tmp1 != bbc; tmp1 = tmp1->GetNextNcNnl()) { tmp1->SetFlagBits(PCF_OC_IN_BLOCK); } } // handle_oc_block_literal static void handle_oc_block_type(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc == nullptr) { return; } if (pc->TestFlags(PCF_IN_TYPEDEF)) { LOG_FMT(LOCBLK, "%s(%d): skip block type @ orig line is %zu, orig col is %zu, -- in typedef\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); return; } // make sure we have '( ^' Chunk *tpo = pc->GetPrevNcNnlNi(); // type paren open Issue #2279 if (tpo->IsParenOpen()) { /* * block type: 'RTYPE (^LABEL)(ARGS)' * LABEL is optional. */ Chunk *tpc = tpo->GetClosingParen(); // type close paren (after '^') Chunk *nam = tpc->GetPrevNcNnlNi(); // name (if any) or '^' Issue #2279 Chunk *apo = tpc->GetNextNcNnl(); // arg open paren Chunk *apc = apo->GetClosingParen(); // arg close paren /* * If this is a block literal instead of a block type, 'nam' * will actually be the closing bracket of the block. We run into * this situation if a block literal is enclosed in parentheses. */ if (nam->IsBraceClose()) { return(handle_oc_block_literal(pc)); } // Check apo is '(' or else this might be a block literal. Issue 2643. if (!apo->IsParenOpen()) { return(handle_oc_block_literal(pc)); } if (apc->IsParenClose()) { Chunk *aft = apc->GetNextNcNnl(); E_Token pt; if (nam->IsString("^")) { nam->SetType(CT_PTR_TYPE); pt = CT_FUNC_TYPE; } else if ( aft->Is(CT_ASSIGN) || aft->Is(CT_SEMICOLON)) { nam->SetType(CT_FUNC_VAR); pt = CT_FUNC_VAR; } else { nam->SetType(CT_FUNC_TYPE); pt = CT_FUNC_TYPE; } LOG_FMT(LOCBLK, "%s(%d): block type @ orig line is %zu, orig col is %zu, Text() '%s'[%s]\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), nam->Text(), get_token_name(nam->GetType())); pc->SetType(CT_PTR_TYPE); pc->SetParentType(pt); //CT_OC_BLOCK_TYPE; tpo->SetType(CT_TPAREN_OPEN); tpo->SetParentType(pt); //CT_OC_BLOCK_TYPE; tpc->SetType(CT_TPAREN_CLOSE); tpc->SetParentType(pt); //CT_OC_BLOCK_TYPE; apo->SetType(CT_FPAREN_OPEN); apo->SetParentType(CT_FUNC_PROTO); apc->SetType(CT_FPAREN_CLOSE); apc->SetParentType(CT_FUNC_PROTO); fix_fcn_def_params(apo); mark_function_return_type(nam, tpo->GetPrevNcNnlNi(), pt); // Issue #2279 } } } // handle_oc_block_type static Chunk *handle_oc_md_type(Chunk *paren_open, E_Token ptype, T_PcfFlags flags, bool &did_it) { Chunk *paren_close; if ( !paren_open->IsParenOpen() || ((paren_close = paren_open->GetClosingParen())->IsNullChunk())) { did_it = false; return(paren_open); } did_it = true; paren_open->SetParentType(ptype); paren_open->SetFlagBits(flags); paren_close->SetParentType(ptype); paren_close->SetFlagBits(flags); for (Chunk *cur = paren_open->GetNextNcNnl(); cur != paren_close; cur = cur->GetNextNcNnl()) { LOG_FMT(LOCMSGD, " <%s|%s>", cur->Text(), get_token_name(cur->GetType())); cur->SetFlagBits(flags); make_type(cur); } // returning the chunk after the paren close return(paren_close->GetNextNcNnl()); } static void handle_oc_message_decl(Chunk *pc) { LOG_FUNC_ENTRY(); bool did_it; //bool in_paren = false; //int paren_cnt = 0; //int arg_cnt = 0; // Figure out if this is a spec or decl Chunk *tmp = pc; if (tmp == nullptr) { tmp = Chunk::NullChunkPtr; } while ((tmp = tmp->GetNext())->IsNotNullChunk()) { if (tmp->GetLevel() < pc->GetLevel()) { // should not happen return; } if ( tmp->Is(CT_SEMICOLON) || tmp->Is(CT_BRACE_OPEN)) { break; } } if (tmp == nullptr) { return; } E_Token pt = tmp->Is(CT_SEMICOLON) ? CT_OC_MSG_SPEC : CT_OC_MSG_DECL; pc->SetType(CT_OC_SCOPE); pc->SetParentType(pt); LOG_FMT(LOCMSGD, "%s(%d): %s @ orig line is %zu, orig col is %zu -", __func__, __LINE__, get_token_name(pt), pc->GetOrigLine(), pc->GetOrigCol()); // format: -(TYPE) NAME [: (TYPE)NAME // handle the return type tmp = handle_oc_md_type(pc->GetNextNcNnl(), pt, PCF_OC_RTYPE, did_it); if (!did_it) { LOG_FMT(LOCMSGD, " -- missing type parens\n"); return; } // expect the method name/label if (tmp->IsNot(CT_WORD)) { LOG_FMT(LOCMSGD, " -- missing method name\n"); return; } // expect the method name/label Chunk *label = tmp; tmp->SetType(pt); tmp->SetParentType(pt); pc = tmp->GetNextNcNnl(); LOG_FMT(LOCMSGD, " [%s]%s", pc->Text(), get_token_name(pc->GetType())); // if we have a colon next, we have args if ( pc->Is(CT_COLON) || pc->Is(CT_OC_COLON)) { pc = label; while (true) { // skip optional label if ( pc->Is(CT_WORD) || pc->Is(pt)) { pc->SetParentType(pt); pc = pc->GetNextNcNnl(); } // a colon must be next if (!pc->IsString(":")) { break; } pc->SetType(CT_OC_COLON); pc->SetParentType(pt); pc = pc->GetNextNcNnl(); // next is the type in parens LOG_FMT(LOCMSGD, " (%s)", pc->Text()); tmp = handle_oc_md_type(pc, pt, PCF_OC_ATYPE, did_it); if (!did_it) { LOG_FMT(LWARN, "%s(%d): orig line is %zu, orig col is %zu expected type\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); break; } // attributes for a method parameter sit between the parameter type and the parameter name pc = skip_attribute_next(tmp); // we should now be on the arg name pc->SetFlagBits(PCF_VAR_DEF); LOG_FMT(LOCMSGD, " arg[%s]", pc->Text()); pc = pc->GetNextNcNnl(); } } LOG_FMT(LOCMSGD, " end[%s]", pc->Text()); if (pc->Is(CT_BRACE_OPEN)) { pc->SetParentType(pt); pc = pc->GetClosingParen(); if (pc->IsNotNullChunk()) { pc->SetParentType(pt); } } else if (pc->Is(CT_SEMICOLON)) { pc->SetParentType(pt); } LOG_FMT(LOCMSGD, "\n"); } // handle_oc_message_decl static void handle_oc_message_send(Chunk *os) { LOG_FUNC_ENTRY(); Chunk *cs = Chunk::NullChunkPtr; if (os != nullptr) { cs = os->GetNext(); } while ( cs->IsNotNullChunk() && cs->GetLevel() > os->GetLevel()) { cs = cs->GetNext(); } if ( cs->IsNullChunk() || cs->IsNot(CT_SQUARE_CLOSE)) { return; } LOG_FMT(LOCMSG, "%s(%d): orig line is %zu, orig col is %zu\n", __func__, __LINE__, os->GetOrigLine(), os->GetOrigCol()); Chunk *tmp = cs->GetNextNcNnl(); if (tmp->IsSemicolon()) { tmp->SetParentType(CT_OC_MSG); } // expect a word first thing or [...] tmp = Chunk::NullChunkPtr; if (os != nullptr) { tmp = os->GetNextNcNnl(); } if ( tmp->Is(CT_SQUARE_OPEN) || tmp->Is(CT_PAREN_OPEN) || tmp->Is(CT_OC_AT)) { Chunk *tt = tmp->GetNextNcNnl(); if ( tmp->Is(CT_OC_AT) && tt->IsNotNullChunk()) { if ( tt->Is(CT_PAREN_OPEN) || tt->Is(CT_BRACE_OPEN) || tt->Is(CT_SQUARE_OPEN)) { tmp = tt; } else { LOG_FMT(LOCMSG, "%s(%d): tmp orig line is %zu, orig col is %zu, expected identifier, not '%s' [%s]\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text(), get_token_name(tmp->GetType())); return; } } tmp = tmp->GetClosingParen(); } else if ( tmp->IsNot(CT_WORD) && tmp->IsNot(CT_TYPE) && tmp->IsNot(CT_THIS) && tmp->IsNot(CT_STAR) && tmp->IsNot(CT_STRING)) { LOG_FMT(LOCMSG, "%s(%d): orig line is %zu, orig col is %zu, expected identifier, not '%s' [%s]\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text(), get_token_name(tmp->GetType())); return; } else { if (tmp->IsStar()) // Issue #2722 { tmp->SetType(CT_PTR_TYPE); tmp = tmp->GetNextNcNnl(); } Chunk *tt = tmp->GetNextNcNnl(); if (tt->IsParenOpen()) { LOG_FMT(LFCN, "%s(%d): (18) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text()); tmp->SetType(CT_FUNC_CALL); tmp = set_paren_parent(tt, CT_FUNC_CALL)->GetPrevNcNnlNi(); // Issue #2279 } else { tmp->SetType(CT_OC_MSG_CLASS); } } os->SetParentType(CT_OC_MSG); os->SetFlagBits(PCF_IN_OC_MSG); cs->SetParentType(CT_OC_MSG); cs->SetFlagBits(PCF_IN_OC_MSG); // handle '< protocol >' tmp = tmp->GetNextNcNnl(); if (tmp->IsString("<")) { Chunk *ao = tmp; Chunk *ac = ao->GetNextString(">", 1, ao->GetLevel()); if (ac->IsNotNullChunk()) { ao->SetType(CT_ANGLE_OPEN); ao->SetParentType(CT_OC_PROTO_LIST); ac->SetType(CT_ANGLE_CLOSE); ac->SetParentType(CT_OC_PROTO_LIST); for (tmp = ao->GetNext(); tmp != ac; tmp = tmp->GetNext()) { tmp->SetLevel(tmp->GetLevel() + 1); tmp->SetParentType(CT_OC_PROTO_LIST); } tmp = ac->GetNextNcNnl(); } else { tmp = Chunk::NullChunkPtr; } } // handle 'object.property' and 'collection[index]' else { while (tmp->IsNotNullChunk()) { if (tmp->Is(CT_MEMBER)) // move past [object.prop1.prop2 { Chunk *typ = tmp->GetNextNcNnl(); if ( typ->Is(CT_WORD) || typ->Is(CT_TYPE)) { tmp = typ->GetNextNcNnl(); } else { break; } } else if (tmp->Is(CT_SQUARE_OPEN)) // move past [collection[index] { Chunk *tcs = tmp->GetNextNcNnl(); while ( tcs->IsNotNullChunk() && tcs->GetLevel() > tmp->GetLevel()) { tcs = tcs->GetNextNcNnl(); } if (tcs->Is(CT_SQUARE_CLOSE)) { tmp = tcs->GetNextNcNnl(); } else { break; } } else { break; } } } // [(self.foo.bar) method] if (tmp->IsParenOpen()) { tmp = tmp->GetClosingParen()->GetNextNcNnl(); } if ( tmp->Is(CT_WORD) || tmp->Is(CT_ACCESS) || tmp->Is(CT_TYPE)) { tmp->SetType(CT_OC_MSG_FUNC); } Chunk *prev = Chunk::NullChunkPtr; for (tmp = os->GetNext(); tmp != cs; tmp = tmp->GetNext()) { tmp->SetFlagBits(PCF_IN_OC_MSG); if (tmp->GetLevel() == cs->GetLevel() + 1) { if ( tmp->Is(CT_COLON) || tmp->Is(CT_ACCESS_COLON)) { tmp->SetType(CT_OC_COLON); if ( prev->Is(CT_WORD) || prev->Is(CT_ACCESS) || prev->Is(CT_TYPE)) { // Might be a named param, check previous block Chunk *pp = prev->GetPrev(); if ( pp->IsNotNullChunk() && pp->IsNot(CT_OC_COLON) && pp->IsNot(CT_ARITH) && pp->IsNot(CT_SHIFT) && pp->IsNot(CT_CARET)) { prev->SetType(CT_OC_MSG_NAME); tmp->SetParentType(CT_OC_MSG_NAME); } } } } prev = tmp; } } // handle_oc_message_send static void handle_oc_available(Chunk *os) { if (os != nullptr) { os = os->GetNext(); } else { os = Chunk::NullChunkPtr; } while (os->IsNotNullChunk()) { E_Token origType = os->GetType(); os->SetType(CT_OC_AVAILABLE_VALUE); if (origType == CT_PAREN_CLOSE) { break; } os = os->GetNext(); } } static void handle_oc_property_decl(Chunk *os) { log_rule_B("mod_sort_oc_properties"); if (options::mod_sort_oc_properties()) { typedef std::vector ChunkGroup; Chunk *next = Chunk::NullChunkPtr; if (os != nullptr) { next = os->GetNext(); } Chunk *open_paren = nullptr; std::vector class_chunks; // class std::vector thread_chunks; // atomic, nonatomic std::vector readwrite_chunks; // readwrite, readonly std::vector ref_chunks; // retain, copy, assign, weak, strong, unsafe_unretained std::vector getter_chunks; // getter std::vector setter_chunks; // setter std::vector nullability_chunks; // nonnull, nullable, null_unspecified, null_resettable std::vector other_chunks; // any words other than above if (next->Is(CT_PAREN_OPEN)) { open_paren = next; next = next->GetNext(); /* * Determine location of the property attributes * NOTE: Did not do this in the combine.cpp do_symbol_check as * I was not sure what the ramifications of adding a new type * for each of the below types would be. It did break some items * when I attempted to add them so this is my hack for now. */ while ( next->IsNotNullChunk() && next->IsNot(CT_PAREN_CLOSE)) { if (next->Is(CT_OC_PROPERTY_ATTR)) { if ( next->IsString("atomic") || next->IsString("nonatomic")) { ChunkGroup chunkGroup; chunkGroup.push_back(next); thread_chunks.push_back(chunkGroup); } else if ( next->IsString("readonly") || next->IsString("readwrite")) { ChunkGroup chunkGroup; chunkGroup.push_back(next); readwrite_chunks.push_back(chunkGroup); } else if ( next->IsString("assign") || next->IsString("retain") || next->IsString("copy") || next->IsString("strong") || next->IsString("weak") || next->IsString("unsafe_unretained")) { ChunkGroup chunkGroup; chunkGroup.push_back(next); ref_chunks.push_back(chunkGroup); } else if (next->IsString("getter")) { ChunkGroup chunkGroup; do { chunkGroup.push_back(next); next = next->GetNext(); } while ( next->IsNotNullChunk() && next->IsNot(CT_COMMA) && next->IsNot(CT_PAREN_CLOSE)); next = next->GetPrev(); // coverity CID 160946 if (next->IsNullChunk()) { break; } getter_chunks.push_back(chunkGroup); } else if (next->IsString("setter")) { ChunkGroup chunkGroup; do { chunkGroup.push_back(next); next = next->GetNext(); } while ( next->IsNotNullChunk() && next->IsNot(CT_COMMA) && next->IsNot(CT_PAREN_CLOSE)); if (next->IsNotNullChunk()) { next = next->GetPrev(); } if (next->IsNullChunk()) { break; } setter_chunks.push_back(chunkGroup); } else if ( next->IsString("nullable") || next->IsString("nonnull") || next->IsString("null_resettable") || next->IsString("null_unspecified")) { ChunkGroup chunkGroup; chunkGroup.push_back(next); nullability_chunks.push_back(chunkGroup); } else if (next->IsString("class")) { ChunkGroup chunkGroup; chunkGroup.push_back(next); class_chunks.push_back(chunkGroup); } else { ChunkGroup chunkGroup; chunkGroup.push_back(next); other_chunks.push_back(chunkGroup); } } else if (next->IsWord()) { if (next->IsString("class")) { ChunkGroup chunkGroup; chunkGroup.push_back(next); class_chunks.push_back(chunkGroup); } else { ChunkGroup chunkGroup; chunkGroup.push_back(next); other_chunks.push_back(chunkGroup); } } next = next->GetNext(); } log_rule_B("mod_sort_oc_property_class_weight"); int class_w = options::mod_sort_oc_property_class_weight(); log_rule_B("mod_sort_oc_property_thread_safe_weight"); int thread_w = options::mod_sort_oc_property_thread_safe_weight(); log_rule_B("mod_sort_oc_property_readwrite_weight"); int readwrite_w = options::mod_sort_oc_property_readwrite_weight(); log_rule_B("mod_sort_oc_property_reference_weight"); int ref_w = options::mod_sort_oc_property_reference_weight(); log_rule_B("mod_sort_oc_property_getter_weight"); int getter_w = options::mod_sort_oc_property_getter_weight(); log_rule_B("mod_sort_oc_property_setter_weight"); int setter_w = options::mod_sort_oc_property_setter_weight(); log_rule_B("mod_sort_oc_property_nullability_weight"); int nullability_w = options::mod_sort_oc_property_nullability_weight(); // std::multimap > sorted_chunk_map; sorted_chunk_map.insert(pair >(class_w, class_chunks)); sorted_chunk_map.insert(pair >(thread_w, thread_chunks)); sorted_chunk_map.insert(pair >(readwrite_w, readwrite_chunks)); sorted_chunk_map.insert(pair >(ref_w, ref_chunks)); sorted_chunk_map.insert(pair >(getter_w, getter_chunks)); sorted_chunk_map.insert(pair >(setter_w, setter_chunks)); sorted_chunk_map.insert(pair >(nullability_w, nullability_chunks)); sorted_chunk_map.insert(pair >(std::numeric_limits::min(), other_chunks)); Chunk *curr_chunk = open_paren; for (multimap >::reverse_iterator it = sorted_chunk_map.rbegin(); it != sorted_chunk_map.rend(); ++it) { std::vector chunk_groups = (*it).second; for (auto chunk_group : chunk_groups) { for (auto chunk : chunk_group) { chunk->SetOrigPrevSp(0); if (chunk != curr_chunk) { chunk->MoveAfter(curr_chunk); curr_chunk = chunk; } else { curr_chunk = curr_chunk->GetNext(); } } // add the parenthesis Chunk endchunk; endchunk.SetType(CT_COMMA); endchunk.SetParentType(curr_chunk->GetParentType()); endchunk.Str() = ","; endchunk.SetLevel(curr_chunk->GetLevel()); endchunk.SetPpLevel(curr_chunk->GetPpLevel()); endchunk.SetBraceLevel(curr_chunk->GetBraceLevel()); endchunk.SetOrigLine(curr_chunk->GetOrigLine()); endchunk.SetOrigCol(curr_chunk->GetOrigCol()); endchunk.SetColumn(curr_chunk->GetOrigColEnd() + 1); endchunk.SetFlags(curr_chunk->GetFlags() & PCF_COPY_FLAGS); endchunk.CopyAndAddAfter(curr_chunk); curr_chunk = curr_chunk->GetNext(); } } // Remove the extra comma's that we did not move while ( curr_chunk != nullptr && curr_chunk->IsNotNullChunk() && curr_chunk->IsNot(CT_PAREN_CLOSE)) { Chunk *rm_chunk = curr_chunk; curr_chunk = curr_chunk->GetNext(); Chunk::Delete(rm_chunk); } } } Chunk *tmp = Chunk::NullChunkPtr; if (os != nullptr) { tmp = os->GetNextNcNnl(); } if (tmp->IsParenOpen()) { tmp = tmp->GetClosingParen()->GetNextNcNnl(); } fix_variable_definition(tmp); } // handle_oc_property_decl static void handle_cs_square_stmt(Chunk *os) { LOG_FUNC_ENTRY(); if (os == nullptr) { os = Chunk::NullChunkPtr; } Chunk *cs = os->GetNext(); while ( cs->IsNotNullChunk() && cs->GetLevel() > os->GetLevel()) { cs = cs->GetNext(); } if ( cs->IsNullChunk() || cs->IsNot(CT_SQUARE_CLOSE)) { return; } os->SetParentType(CT_CS_SQ_STMT); cs->SetParentType(CT_CS_SQ_STMT); Chunk *tmp; for (tmp = os->GetNext(); tmp != cs; tmp = tmp->GetNext()) { tmp->SetParentType(CT_CS_SQ_STMT); if (tmp->Is(CT_COLON)) { tmp->SetType(CT_CS_SQ_COLON); } } tmp = cs->GetNextNcNnl(); if (tmp->IsNotNullChunk()) { tmp->SetFlagBits(PCF_STMT_START | PCF_EXPR_START); } } // handle_cs_square_stmt static void handle_cs_property(Chunk *bro) { LOG_FUNC_ENTRY(); set_paren_parent(bro, CT_CS_PROPERTY); bool did_prop = false; Chunk *pc = bro; while ((pc = pc->GetPrevNcNnlNi())->IsNotNullChunk()) // Issue #2279 { if (pc->GetLevel() == bro->GetLevel()) { //prevent scanning back past 'new' in expressions like new List {1,2,3} // Issue # 1620, UNI-24090.cs if (pc->Is(CT_NEW)) { break; } if ( !did_prop && ( pc->Is(CT_WORD) || pc->Is(CT_THIS))) { pc->SetType(CT_CS_PROPERTY); did_prop = true; } else { pc->SetParentType(CT_CS_PROPERTY); make_type(pc); } if (pc->TestFlags(PCF_STMT_START)) { break; } } } } static void handle_cs_array_type(Chunk *pc) { if ( pc == nullptr || pc->IsNullChunk()) { return; } Chunk *prev = pc->GetPrev(); for ( ; prev->Is(CT_COMMA); prev = prev->GetPrev()) { // empty } if (prev->Is(CT_SQUARE_OPEN)) { while (pc != prev) { pc->SetParentType(CT_TYPE); pc = pc->GetPrev(); } prev->SetParentType(CT_TYPE); } } static void handle_wrap(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *opp = Chunk::NullChunkPtr; if (pc != nullptr) { opp = pc->GetNext(); } Chunk *name = opp->GetNext(); Chunk *clp = name->GetNext(); log_rule_B("sp_func_call_paren"); log_rule_B("sp_cpp_cast_paren"); iarf_e pav = pc->Is(CT_FUNC_WRAP) ? options::sp_func_call_paren() : options::sp_cpp_cast_paren(); log_rule_B("sp_inside_fparen"); log_rule_B("sp_inside_paren_cast"); iarf_e av = pc->Is(CT_FUNC_WRAP) ? options::sp_inside_fparen() : options::sp_inside_paren_cast(); if ( clp->Is(CT_PAREN_CLOSE) && opp->Is(CT_PAREN_OPEN) && ( name->Is(CT_WORD) || name->Is(CT_TYPE))) { const char *psp = (pav & IARF_ADD) ? " " : ""; const char *fsp = (av & IARF_ADD) ? " " : ""; pc->Str().append(psp); pc->Str().append("("); pc->Str().append(fsp); pc->Str().append(name->GetStr()); pc->Str().append(fsp); pc->Str().append(")"); pc->SetType(pc->Is(CT_FUNC_WRAP) ? CT_FUNCTION : CT_TYPE); pc->SetOrigColEnd(pc->GetOrigCol() + pc->Len()); Chunk::Delete(opp); Chunk::Delete(name); Chunk::Delete(clp); } } // handle_wrap static void handle_proto_wrap(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *opp = pc->GetNextNcNnl(); Chunk *name = opp->GetNextNcNnl(); Chunk *tmp = name->GetNextNcNnl()->GetNextNcNnl(); Chunk *clp = opp->GetClosingParen(); Chunk *cma = clp->GetNextNcNnl(); if ( opp->IsNullChunk() || name->IsNullChunk() || tmp->IsNullChunk() || clp == nullptr || cma->IsNullChunk() || ( name->IsNot(CT_WORD) && name->IsNot(CT_TYPE)) || opp->IsNot(CT_PAREN_OPEN)) { return; } if (cma->Is(CT_SEMICOLON)) { pc->SetType(CT_FUNC_PROTO); } else if (cma->Is(CT_BRACE_OPEN)) { LOG_FMT(LFCN, "%s(%d): (19) SET TO CT_FUNC_DEF: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_DEF); } else { return; } opp->SetParentType(pc->GetType()); clp->SetParentType(pc->GetType()); tmp->SetParentType(CT_PROTO_WRAP); if (tmp->Is(CT_PAREN_OPEN)) { fix_fcn_def_params(tmp); } else { fix_fcn_def_params(opp); name->SetType(CT_WORD); } tmp = tmp->GetClosingParen(); if (tmp->IsNotNullChunk()) { tmp->SetParentType(CT_PROTO_WRAP); } // Mark return type (TODO: move to own function) tmp = pc; while ((tmp = tmp->GetPrevNcNnlNi())->IsNotNullChunk()) // Issue #2279 { if ( !tmp->IsTypeDefinition() && tmp->IsNot(CT_OPERATOR) && tmp->IsNot(CT_WORD) && tmp->IsNot(CT_ADDR)) { break; } tmp->SetParentType(pc->GetType()); make_type(tmp); } } // handle_proto_wrap /** * Java assert statements are: "assert EXP1 [: EXP2] ;" * Mark the parent of the colon and semicolon */ static void handle_java_assert(Chunk *pc) { LOG_FUNC_ENTRY(); bool did_colon = false; Chunk *tmp = pc; if (tmp == nullptr) { tmp = Chunk::NullChunkPtr; } while ((tmp = tmp->GetNext())->IsNotNullChunk()) { if (tmp->GetLevel() == pc->GetLevel()) { if ( !did_colon && tmp->Is(CT_COLON)) { did_colon = true; tmp->SetParentType(pc->GetType()); } if (tmp->Is(CT_SEMICOLON)) { tmp->SetParentType(pc->GetType()); break; } } } } // handle_java_assert uncrustify-uncrustify-0.76.0/src/combine.h000066400000000000000000000035021434072136500206110ustar00rootroot00000000000000/** * @file combine.h * prototypes for combine.cpp * * @author Ben Gardner * @license GPL v2+ */ #ifndef COMBINE_H_INCLUDED #define COMBINE_H_INCLUDED #include "chunk.h" #include "uncrustify_types.h" void mark_question_colon(); /** * Change CT_INCDEC_AFTER + WORD to CT_INCDEC_BEFORE * Change number/word + CT_ADDR to CT_ARITH * Change number/word + CT_STAR to CT_ARITH * Change number/word + CT_NEG to CT_ARITH * Change word + ( to a CT_FUNCTION * Change struct/union/enum + CT_WORD => CT_TYPE * Force parens on return. * * TODO: This could be done earlier. * * Patterns detected: * STRUCT/ENUM/UNION + WORD :: WORD => TYPE * WORD + '(' :: WORD => FUNCTION */ void fix_symbols(); /** * Examines the whole file and changes CT_COLON to * CT_Q_COLON, CT_LABEL_COLON, or CT_CASE_COLON. * It also changes the CT_WORD before CT_LABEL_COLON into CT_LABEL. */ void combine_labels(); //! help function for mark_variable_definition... bool go_on(Chunk *pc, Chunk *start); //! Sets the parent for comments. void mark_comments(); void make_type(Chunk *pc); /** * Sets the parent of the open paren/brace/square/angle and the closing. * Note - it is assumed that pc really does point to an open item and the * close must be open + 1. * * @param start The open paren * @param parent The type to assign as the parent * * @return The chunk after the close paren */ Chunk *set_paren_parent(Chunk *start, E_Token parent); /** * This is called on every chunk. * First on all non-preprocessor chunks and then on each preprocessor chunk. * It does all the detection and classifying. * This is only called by fix_symbols. * The three parameters never get the value nullptr. * it is not necessary to test. */ void do_symbol_check(Chunk *prev, Chunk *pc, Chunk *next); #endif /* COMBINE_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/combine_fix_mark.cpp000066400000000000000000002343041434072136500230320ustar00rootroot00000000000000/** * @file combine_fix_mark.cpp * * @author Guy Maurel * @license GPL v2+ * extract fom combine.cpp */ #include "combine_fix_mark.h" #include "combine_skip.h" #include "combine_tools.h" #include "flag_parens.h" #include "log_rules.h" constexpr static auto LCURRENT = LCOMBINE; void fix_casts(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *pc; Chunk *prev; Chunk *first; Chunk *after; Chunk *last = Chunk::NullChunkPtr; Chunk *paren_close; const char *verb = "likely"; const char *detail = ""; size_t count = 0; int word_count = 0; bool nope; bool doubtful_cast = false; LOG_FMT(LCASTS, "%s(%d): start->Text() is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, start->Text(), start->GetOrigLine(), start->GetOrigCol()); prev = start->GetPrevNcNnlNi(); // Issue #2279 if (prev->IsNullChunk()) { return; } if (prev->Is(CT_PP_DEFINED)) { LOG_FMT(LCASTS, "%s(%d): -- not a cast - after defined\n", __func__, __LINE__); return; } if (prev->Is(CT_ANGLE_CLOSE)) { LOG_FMT(LCASTS, "%s(%d): -- not a cast - after > (template)\n", __func__, __LINE__); return; } // Make sure there is only WORD, TYPE, and '*' or '^' before the close paren pc = start->GetNextNcNnl(); first = pc; while ( pc->IsNotNullChunk() && ( pc->IsTypeDefinition() || pc->Is(CT_WORD) || pc->Is(CT_QUALIFIER) || pc->Is(CT_DC_MEMBER) || pc->Is(CT_PP) || pc->Is(CT_STAR) || pc->Is(CT_QUESTION) || pc->Is(CT_CARET) || pc->Is(CT_TSQUARE) || ( ( pc->Is(CT_ANGLE_OPEN) || pc->Is(CT_ANGLE_CLOSE)) && language_is_set(LANG_OC | LANG_JAVA | LANG_CS | LANG_VALA | LANG_CPP)) || ( ( pc->Is(CT_QUESTION) || pc->Is(CT_COMMA) || pc->Is(CT_MEMBER)) && language_is_set(LANG_JAVA | LANG_CS | LANG_VALA)) || ( pc->Is(CT_COMMA) && language_is_set(LANG_CPP)) || pc->Is(CT_AMP))) { LOG_FMT(LCASTS, "%s(%d): pc->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); if ( pc->Is(CT_WORD) || ( last->Is(CT_ANGLE_CLOSE) && pc->Is(CT_DC_MEMBER))) { word_count++; } else if ( pc->Is(CT_DC_MEMBER) || pc->Is(CT_MEMBER) || pc->Is(CT_PP)) { // might be negative, such as with: // a = val + (CFoo::bar_t)7; word_count--; } last = pc; pc = pc->GetNextNcNnl(); count++; } if ( pc->IsNullChunk() || pc->IsNot(CT_PAREN_CLOSE) || prev->Is(CT_OC_CLASS)) { LOG_FMT(LCASTS, "%s(%d): -- not a cast, hit type is %s\n", __func__, __LINE__, pc->IsNullChunk() ? "Null chunk" : get_token_name(pc->GetType())); return; } if (word_count > 1) { LOG_FMT(LCASTS, "%s(%d): -- too many words: %d\n", __func__, __LINE__, word_count); return; } paren_close = pc; // If last is a type or star/caret, we have a cast for sure if ( last->Is(CT_STAR) || last->Is(CT_CARET) || last->Is(CT_PTR_TYPE) || last->Is(CT_TYPE) || ( last->Is(CT_ANGLE_CLOSE) && language_is_set(LANG_OC | LANG_JAVA | LANG_CS | LANG_VALA | LANG_CPP))) { verb = "for sure"; } else if (count == 1) { /* * We are on a potential cast of the form "(word)". * We don't know if the word is a type. So lets guess based on some * simple rules: * - if all caps, likely a type * - if it ends in _t, likely a type * - if it's objective-c and the type is id, likely valid */ verb = "guessed"; if ( (last->Len() > 3) && (last->GetStr()[last->Len() - 2] == '_') && (last->GetStr()[last->Len() - 1] == 't')) { detail = " -- '_t'"; } else if (is_ucase_str(last->Text(), last->Len())) { detail = " -- upper case"; } else if ( language_is_set(LANG_OC) && last->IsString("id")) { detail = " -- Objective-C id"; } else { // If we can't tell for sure whether this is a cast, decide against it detail = " -- mixed case"; doubtful_cast = true; } /* * If the next item is a * or &, the next item after that can't be a * number or string. * * If the next item is a +, the next item has to be a number. * * If the next item is a -, the next item can't be a string. * * For this to be a cast, the close paren must be followed by: * - constant (number or string) * - paren open * - word * * Find the next non-open paren item. */ pc = paren_close->GetNextNcNnl(); after = pc; do { after = after->GetNextNcNnl(); } while (after->Is(CT_PAREN_OPEN)); if (after->IsNullChunk()) { LOG_FMT(LCASTS, "%s(%d): -- not a cast - hit null chunk\n", __func__, __LINE__); return; } nope = false; if (pc->IsPointerOperator()) { // star (*) and address (&) are ambiguous if ( after->Is(CT_NUMBER_FP) || after->Is(CT_NUMBER) || after->Is(CT_STRING) || doubtful_cast) { nope = true; } } else if (pc->Is(CT_MINUS)) { // (UINT8)-1 or (foo)-1 or (FOO)-'a' if ( after->Is(CT_STRING) || doubtful_cast) { nope = true; } } else if (pc->Is(CT_PLUS)) { // (UINT8)+1 or (foo)+1 if ( ( after->IsNot(CT_NUMBER) && after->IsNot(CT_NUMBER_FP)) || doubtful_cast) { nope = true; } } else if ( pc->IsNot(CT_NUMBER_FP) && pc->IsNot(CT_NUMBER) && pc->IsNot(CT_WORD) && pc->IsNot(CT_THIS) && pc->IsNot(CT_TYPE) && pc->IsNot(CT_PAREN_OPEN) && pc->IsNot(CT_STRING) && pc->IsNot(CT_DECLTYPE) && pc->IsNot(CT_SIZEOF) && pc->GetParentType() != CT_SIZEOF && pc->IsNot(CT_FUNC_CALL) && pc->IsNot(CT_FUNC_CALL_USER) && pc->IsNot(CT_FUNCTION) && pc->IsNot(CT_BRACE_OPEN) && (!( pc->Is(CT_SQUARE_OPEN) && language_is_set(LANG_OC)))) { LOG_FMT(LCASTS, "%s(%d): -- not a cast - followed by Text() '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); return; } if (nope) { LOG_FMT(LCASTS, "%s(%d): -- not a cast - Text() '%s' followed by type %s\n", __func__, __LINE__, pc->Text(), get_token_name(after->GetType())); return; } } // if the 'cast' is followed by a semicolon, comma, bool or close parenthesis, it isn't pc = paren_close->GetNextNcNnl(); if (pc->IsNullChunk()) { return; } if ( pc->IsSemicolon() || pc->Is(CT_COMMA) || pc->Is(CT_BOOL) // Issue #2151 || pc->IsParenClose()) { LOG_FMT(LCASTS, "%s(%d): -- not a cast - followed by type %s\n", __func__, __LINE__, get_token_name(pc->GetType())); return; } start->SetParentType(CT_C_CAST); paren_close->SetParentType(CT_C_CAST); LOG_FMT(LCASTS, "%s(%d): -- %s c-cast: (", __func__, __LINE__, verb); for (pc = first; pc->IsNotNullChunk() && pc != paren_close; pc = pc->GetNextNcNnl()) { pc->SetParentType(CT_C_CAST); make_type(pc); LOG_FMT(LCASTS, " %s", pc->Text()); } LOG_FMT(LCASTS, " )%s\n", detail); // Mark the next item as an expression start pc = paren_close->GetNextNcNnl(); if (pc->IsNotNullChunk()) { pc->SetFlagBits(PCF_EXPR_START); if (pc->IsBraceOpen()) { set_paren_parent(pc, start->GetParentType()); } } } // fix_casts void fix_fcn_def_params(Chunk *start) { LOG_FUNC_ENTRY(); if (start == nullptr) { return; } LOG_FMT(LFCNP, "%s(%d): Text() '%s', type is %s, on orig line %zu, level is %zu\n", __func__, __LINE__, start->Text(), get_token_name(start->GetType()), start->GetOrigLine(), start->GetLevel()); while ( start->IsNotNullChunk() && !start->IsParenOpen()) { start = start->GetNextNcNnl(); } if (start->IsNullChunk()) // Coverity CID 76003, 1100782 { return; } // ensure start chunk holds a single '(' character assert( (start->Len() == 1) && (start->GetStr()[0] == '(')); ChunkStack cs; size_t level = start->GetLevel() + 1; Chunk *pc = start->GetNextNcNnl(); while (pc->IsNotNullChunk()) { if ( ( (start->Len() == 1) && (start->GetStr()[0] == ')')) || pc->GetLevel() < level) { LOG_FMT(LFCNP, "%s(%d): bailed on Text() '%s', on orig line %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); break; } LOG_FMT(LFCNP, "%s(%d): %s, Text() '%s' on orig line %zu, level %zu\n", __func__, __LINE__, (pc->GetLevel() > level) ? "skipping" : "looking at", pc->Text(), pc->GetOrigLine(), pc->GetLevel()); if (pc->GetLevel() > level) { pc = pc->GetNextNcNnl(); continue; } if ( pc->IsStar() || pc->IsMsRef() || pc->IsNullable()) { pc->SetType(CT_PTR_TYPE); cs.Push_Back(pc); } else if ( language_is_set(LANG_CPP) // Issue #3662 && ( pc->Is(CT_AMP) || pc->IsString("&&"))) { pc->SetType(CT_BYREF); cs.Push_Back(pc); } else if (pc->Is(CT_TYPE_WRAP)) { cs.Push_Back(pc); } else if ( pc->Is(CT_WORD) || pc->Is(CT_TYPE)) { cs.Push_Back(pc); } else if ( pc->Is(CT_COMMA) || pc->Is(CT_ASSIGN)) { mark_variable_stack(cs, LFCNP); if (pc->Is(CT_ASSIGN)) { // Mark assignment for default param spacing pc->SetParentType(CT_FUNC_PROTO); } } pc = pc->GetNextNcNnl(); } mark_variable_stack(cs, LFCNP); } // fix_fcn_def_params void fix_type_cast(Chunk *start) { LOG_FUNC_ENTRY(); if (start == nullptr) { return; } Chunk *pc = start->GetNextNcNnl(); if ( pc->IsNullChunk() || pc->IsNot(CT_ANGLE_OPEN)) { return; } pc = pc->GetNextNcNnl(); while ( pc->IsNotNullChunk() && pc->GetLevel() >= start->GetLevel()) { if ( pc->GetLevel() == start->GetLevel() && pc->Is(CT_ANGLE_CLOSE)) { pc = pc->GetNextNcNnl(); if (pc->IsNullChunk()) { return; } if (pc->IsString("(")) { set_paren_parent(pc, CT_TYPE_CAST); } return; } make_type(pc); pc = pc->GetNextNcNnl(); } } // fix_type_cast void fix_typedef(Chunk *start) { LOG_FUNC_ENTRY(); if (start == nullptr) { return; } LOG_FMT(LTYPEDEF, "%s(%d): typedef @ orig line %zu, orig col %zu\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol()); Chunk *the_type = Chunk::NullChunkPtr; Chunk *last_op = Chunk::NullChunkPtr; /* * Mark everything in the typedef and scan for ")(", which makes it a * function type */ for (Chunk *next = start->GetNextNcNnl(E_Scope::PREPROC) ; next->IsNotNullChunk() && next->GetLevel() >= start->GetLevel() ; next = next->GetNextNcNnl(E_Scope::PREPROC)) { next->SetFlagBits(PCF_IN_TYPEDEF); if (start->GetLevel() == next->GetLevel()) { if (next->IsSemicolon()) { next->SetParentType(CT_TYPEDEF); break; } if (next->Is(CT_ATTRIBUTE)) { break; } if ( language_is_set(LANG_D) && next->Is(CT_ASSIGN)) { next->SetParentType(CT_TYPEDEF); break; } make_type(next); if (next->Is(CT_TYPE)) { the_type = next; } next->ResetFlagBits(PCF_VAR_1ST_DEF); if (*next->GetStr().c_str() == '(') { last_op = next; } } } // avoid interpreting typedef NS_ENUM (NSInteger, MyEnum) as a function def if ( last_op->IsNotNullChunk() && !( language_is_set(LANG_OC) && last_op->GetParentType() == CT_ENUM)) { flag_parens(last_op, PCF_NONE, CT_FPAREN_OPEN, CT_TYPEDEF, false); fix_fcn_def_params(last_op); the_type = last_op->GetPrevNcNnlNi(E_Scope::PREPROC); // Issue #2279 if (the_type->IsNullChunk()) { return; } Chunk *open_paren = Chunk::NullChunkPtr; if (the_type->IsParenClose()) { open_paren = the_type->GetOpeningParen(); mark_function_type(the_type); the_type = the_type->GetPrevNcNnlNi(E_Scope::PREPROC); // Issue #2279 if (the_type->IsNullChunk()) { return; } } else { // must be: "typedef func(params);" the_type->SetType(CT_FUNC_TYPE); } the_type->SetParentType(CT_TYPEDEF); LOG_FMT(LTYPEDEF, "%s(%d): fcn typedef Text() '%s', on orig line %zu\n", __func__, __LINE__, the_type->Text(), the_type->GetOrigLine()); // If we are aligning on the open parenthesis, grab that instead log_rule_B("align_typedef_func"); if ( open_paren->IsNotNullChunk() && options::align_typedef_func() == 1) { the_type = open_paren; } log_rule_B("align_typedef_func"); if (options::align_typedef_func() != 0) { LOG_FMT(LTYPEDEF, "%s(%d): -- align anchor on Text() %s, @ orig line %zu, orig col %zu\n", __func__, __LINE__, the_type->Text(), the_type->GetOrigLine(), the_type->GetOrigCol()); the_type->SetFlagBits(PCF_ANCHOR); } // already did everything we need to do return; } /* * Skip over enum/struct/union stuff, as we know it isn't a return type * for a function type */ Chunk *after = start->GetNextNcNnl(E_Scope::PREPROC); if (after->IsNullChunk()) { return; } if ( after->IsNot(CT_ENUM) && after->IsNot(CT_STRUCT) && after->IsNot(CT_UNION)) { if ( the_type != nullptr && the_type->IsNotNullChunk()) { // We have just a regular typedef LOG_FMT(LTYPEDEF, "%s(%d): regular typedef Text() %s, on orig line %zu\n", __func__, __LINE__, the_type->Text(), the_type->GetOrigLine()); the_type->SetFlagBits(PCF_ANCHOR); } return; } // We have a struct/union/enum, next should be either a type or { Chunk *next = after->GetNextNcNnl(E_Scope::PREPROC); if (next->IsNullChunk()) { return; } if (next->Is(CT_TYPE)) { next = next->GetNextNcNnl(E_Scope::PREPROC); if (next->IsNullChunk()) { return; } } if (next->Is(CT_BRACE_OPEN)) { // Skip to the closing brace Chunk *br_c = next->GetNextType(CT_BRACE_CLOSE, next->GetLevel(), E_Scope::PREPROC); if (br_c->IsNotNullChunk()) { const E_Token tag = after->GetType(); next->SetParentType(tag); br_c->SetParentType(tag); if (tag == CT_ENUM) { flag_series(after, br_c, PCF_IN_ENUM); } else if (tag == CT_STRUCT) { flag_series(after, br_c, PCF_IN_STRUCT); } } } if ( the_type != nullptr && the_type->IsNotNullChunk()) { LOG_FMT(LTYPEDEF, "%s(%d): %s typedef Text() %s, on orig line %zu\n", __func__, __LINE__, get_token_name(after->GetType()), the_type->Text(), the_type->GetOrigLine()); the_type->SetFlagBits(PCF_ANCHOR); } } // fix_typedef Chunk *fix_variable_definition(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *pc = start; Chunk *end; Chunk *tmp_pc; ChunkStack cs; int idx; int ref_idx; LOG_FMT(LFVD, "%s(%d): start at pc orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_pcf_flags(LFCNR, pc->GetFlags()); // Scan for words and types and stars oh my! while ( pc->Is(CT_TYPE) || pc->Is(CT_WORD) || pc->Is(CT_QUALIFIER) || pc->Is(CT_TYPENAME) || pc->Is(CT_DC_MEMBER) || pc->Is(CT_MEMBER) || pc->Is(CT_PP) // Issue #3169 || pc->IsPointerOperator()) { LOG_FMT(LFVD, "%s(%d): 1:pc->Text() '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); cs.Push_Back(pc); pc = pc->GetNextNcNnl(); if (pc->IsNullChunk()) { LOG_FMT(LFVD, "%s(%d): pc is null chunk\n", __func__, __LINE__); return(Chunk::NullChunkPtr); } LOG_FMT(LFVD, "%s(%d): 2:pc->Text() '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); // Skip templates and attributes pc = skip_template_next(pc); if (pc->IsNullChunk()) { LOG_FMT(LFVD, "%s(%d): pc is null chunk\n", __func__, __LINE__); return(Chunk::NullChunkPtr); } LOG_FMT(LFVD, "%s(%d): 3:pc->Text() '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); pc = skip_attribute_next(pc); if (pc->IsNullChunk()) { LOG_FMT(LFVD, "%s(%d): pc is null chunk\n", __func__, __LINE__); return(Chunk::NullChunkPtr); } LOG_FMT(LFVD, "%s(%d): 4:pc->Text() '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); if (language_is_set(LANG_JAVA)) { pc = skip_tsquare_next(pc); if (pc->IsNotNullChunk()) { LOG_FMT(LFVD, "%s(%d): 5:pc->Text() '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); } else { pc = Chunk::NullChunkPtr; } } } end = pc; if (end->IsNullChunk()) { LOG_FMT(LFVD, "%s(%d): end is null chunk\n", __func__, __LINE__); return(nullptr); } LOG_FMT(LFVD, "%s(%d): end->GetType() is %s\n", __func__, __LINE__, get_token_name(end->GetType())); if (end->Is(CT_FUNC_CTOR_VAR)) // Issue #3010 { return(end); } if ( cs.Len() == 1 && end->Is(CT_BRACE_OPEN) && end->GetParentType() == CT_BRACED_INIT_LIST) { cs.Get(0)->m_pc->SetType(CT_TYPE); } // Function defs are handled elsewhere if ( (cs.Len() <= 1) || end->Is(CT_FUNC_DEF) || end->Is(CT_FUNC_PROTO) || end->Is(CT_FUNC_CLASS_DEF) || end->Is(CT_FUNC_CLASS_PROTO) || end->Is(CT_OPERATOR)) { return(skip_to_next_statement(end)); } // ref_idx points to the alignable part of the variable definition ref_idx = cs.Len() - 1; // Check for the '::' stuff: "char *Engine::name" if ( (cs.Len() >= 3) && ( (cs.Get(cs.Len() - 2)->m_pc->GetType() == CT_MEMBER) || (cs.Get(cs.Len() - 2)->m_pc->GetType() == CT_DC_MEMBER))) { idx = cs.Len() - 2; while (idx > 0) { tmp_pc = cs.Get(idx)->m_pc; if ( tmp_pc->IsNot(CT_DC_MEMBER) && tmp_pc->IsNot(CT_MEMBER)) { break; } idx--; tmp_pc = cs.Get(idx)->m_pc; if ( tmp_pc->IsNot(CT_WORD) && tmp_pc->IsNot(CT_TYPE)) { break; } make_type(tmp_pc); idx--; } ref_idx = idx + 1; } tmp_pc = cs.Get(ref_idx)->m_pc; LOG_FMT(LFVD, "%s(%d): ref_idx(%d) is '%s'\n", __func__, __LINE__, ref_idx, tmp_pc->Text()); // No type part found! if (ref_idx <= 0) { return(skip_to_next_statement(end)); } LOG_FMT(LFVD2, "%s(%d): orig line is %zu, TYPE : ", __func__, __LINE__, start->GetOrigLine()); for (size_t idxForCs = 0; idxForCs < cs.Len() - 1; idxForCs++) { tmp_pc = cs.Get(idxForCs)->m_pc; make_type(tmp_pc); tmp_pc->SetFlagBits(PCF_VAR_TYPE); LOG_FMT(LFVD2, " Text() is '%s', type is %s", tmp_pc->Text(), get_token_name(tmp_pc->GetType())); } LOG_FMT(LFVD2, "\n"); // OK we have two or more items, mark types up to the end. LOG_FMT(LFVD, "%s(%d): pc orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); mark_variable_definition(cs.Get(cs.Len() - 1)->m_pc); if (end->Is(CT_COMMA)) { return(end->GetNextNcNnl()); } return(skip_to_next_statement(end)); } // fix_variable_definition void mark_cpp_constructor(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *paren_open; Chunk *tmp; Chunk *after; Chunk *var; bool is_destr = false; tmp = pc->GetPrevNcNnlNi(); // Issue #2279 if ( tmp->Is(CT_INV) || tmp->Is(CT_DESTRUCTOR)) { tmp->SetType(CT_DESTRUCTOR); pc->SetParentType(CT_DESTRUCTOR); is_destr = true; } LOG_FMT(LFTOR, "%s(%d): orig line is %zu, orig col is %zu, FOUND %sSTRUCTOR for '%s'[%s] prev '%s'[%s]\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), is_destr ? "DE" : "CON", pc->Text(), get_token_name(pc->GetType()), tmp->Text(), get_token_name(tmp->GetType())); paren_open = skip_template_next(pc->GetNextNcNnl()); if (!paren_open->IsString("(")) { LOG_FMT(LWARN, "%s:%zu Expected '(', got: [%s]\n", cpd.filename.c_str(), paren_open->GetOrigLine(), paren_open->Text()); return; } // Mark parameters fix_fcn_def_params(paren_open); after = flag_parens(paren_open, PCF_IN_FCN_CALL, CT_FPAREN_OPEN, CT_FUNC_CLASS_PROTO, false); LOG_FMT(LFTOR, "%s(%d): Text() '%s'\n", __func__, __LINE__, after->Text()); // Scan until the brace open, mark everything tmp = paren_open; bool hit_colon = false; while ( tmp->IsNotNullChunk() && ( tmp->IsNot(CT_BRACE_OPEN) || tmp->GetLevel() != paren_open->GetLevel()) && !tmp->IsSemicolon()) { LOG_FMT(LFTOR, "%s(%d): tmp is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol()); tmp->SetFlagBits(PCF_IN_CONST_ARGS); tmp = tmp->GetNextNcNnl(); if ( tmp->IsString(":") && tmp->GetLevel() == paren_open->GetLevel()) { tmp->SetType(CT_CONSTR_COLON); hit_colon = true; } if ( hit_colon && ( tmp->IsParenOpen() || tmp->IsBraceOpen()) && tmp->GetLevel() == paren_open->GetLevel()) { var = skip_template_prev(tmp->GetPrevNcNnlNi()); // Issue #2279 if ( var->Is(CT_TYPE) || var->Is(CT_WORD)) { var->SetType(CT_FUNC_CTOR_VAR); flag_parens(tmp, PCF_IN_FCN_CALL, CT_FPAREN_OPEN, CT_FUNC_CTOR_VAR, false); } } } if (tmp->Is(CT_BRACE_OPEN)) { set_paren_parent(paren_open, CT_FUNC_CLASS_DEF); set_paren_parent(tmp, CT_FUNC_CLASS_DEF); LOG_FMT(LFCN, "%s(%d): Marked '%s' as FUNC_CLASS_DEF on orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); } else { tmp->SetParentType(CT_FUNC_CLASS_PROTO); pc->SetType(CT_FUNC_CLASS_PROTO); LOG_FMT(LFCN, "%s(%d): Marked '%s' as FUNC_CLASS_PROTO on orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); } tmp = pc->GetPrevNcNnlNi(); // Issue #2907 if (tmp->Is(CT_DESTRUCTOR)) { tmp->SetParentType(pc->GetType()); tmp = tmp->GetPrevNcNnlNi(); } while (tmp->Is(CT_QUALIFIER)) { tmp->SetParentType(pc->GetType()); tmp = tmp->GetPrevNcNnlNi(); } } // mark_cpp_constructor void mark_cpp_lambda(Chunk *square_open) { if ( square_open->Is(CT_SQUARE_OPEN) && square_open->GetParentType() == CT_CPP_LAMBDA) { auto *brace_close = square_open->GetNextType(CT_BRACE_CLOSE, square_open->GetLevel()); if (brace_close->GetParentType() == CT_CPP_LAMBDA) { for (auto *pc = square_open; pc != brace_close; pc = pc->GetNextNcNnl()) { pc->SetFlagBits(PCF_IN_LAMBDA); } } } } // mark_cpp_lambda void mark_define_expressions() { LOG_FUNC_ENTRY(); bool in_define = false; bool first = true; Chunk *pc = Chunk::GetHead(); Chunk *prev = pc; while (pc->IsNotNullChunk()) { if (!in_define) { if ( pc->Is(CT_PP_DEFINE) || pc->Is(CT_PP_IF) || pc->Is(CT_PP_ELSE)) { in_define = true; first = true; } } else { if ( !pc->TestFlags(PCF_IN_PREPROC) || pc->Is(CT_PREPROC)) { in_define = false; } else { if ( pc->IsNot(CT_MACRO) && ( first || prev->Is(CT_PAREN_OPEN) || prev->Is(CT_ARITH) || prev->Is(CT_SHIFT) || prev->Is(CT_CARET) || prev->Is(CT_ASSIGN) || prev->Is(CT_COMPARE) || prev->Is(CT_RETURN) || prev->Is(CT_GOTO) || prev->Is(CT_CONTINUE) || prev->Is(CT_FPAREN_OPEN) || prev->Is(CT_SPAREN_OPEN) || prev->Is(CT_BRACE_OPEN) || prev->IsSemicolon() || prev->Is(CT_COMMA) || prev->Is(CT_COLON) || prev->Is(CT_QUESTION))) { pc->SetFlagBits(PCF_EXPR_START); first = false; } } } prev = pc; pc = pc->GetNext(); } } // mark_define_expressions void mark_exec_sql(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *tmp; // Change CT_WORD to CT_SQL_WORD for (tmp = pc->GetNext(); tmp->IsNotNullChunk(); tmp = tmp->GetNext()) { tmp->SetParentType(pc->GetType()); if (tmp->Is(CT_WORD)) { tmp->SetType(CT_SQL_WORD); } if (tmp->Is(CT_SEMICOLON)) { break; } } if ( pc->IsNot(CT_SQL_BEGIN) || tmp->IsNullChunk() || tmp->IsNot(CT_SEMICOLON)) { return; } for (tmp = tmp->GetNext(); tmp->IsNotNullChunk() && tmp->IsNot(CT_SQL_END); tmp = tmp->GetNext()) { tmp->SetLevel(tmp->GetLevel() + 1); } } // mark_exec_sql void mark_function_return_type(Chunk *fname, Chunk *start, E_Token parent_type) { LOG_FUNC_ENTRY(); Chunk *pc = start; if ( pc != nullptr && pc->IsNotNullChunk()) { // Step backwards from pc and mark the parent of the return type LOG_FMT(LFCNR, "%s(%d): (backwards) return type for '%s' @ orig line is %zu, orig col is %zu\n", __func__, __LINE__, fname->Text(), fname->GetOrigLine(), fname->GetOrigCol()); Chunk *first = pc; while (pc->IsNotNullChunk()) { LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s, ", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); log_pcf_flags(LFCNR, pc->GetFlags()); if (pc->Is(CT_ANGLE_CLOSE)) { pc = skip_template_prev(pc); if ( pc->IsNullChunk() || pc->Is(CT_TEMPLATE)) { //either expression is not complete or this is smth like 'template void func()' // - we are not interested in 'template' part break; } else { //this is smth like 'vector func()' and 'pc' is currently on 'vector' - just proceed } } if ( ( !pc->IsTypeDefinition() && pc->IsNot(CT_OPERATOR) && pc->IsNot(CT_WORD) && pc->IsNot(CT_ADDR)) || pc->TestFlags(PCF_IN_PREPROC)) { break; } if (!pc->IsPointerOperator()) { first = pc; } pc = pc->GetPrevNcNnlNi(); // Issue #2279 } LOG_FMT(LFCNR, "%s(%d): marking returns...", __func__, __LINE__); // Changing words to types into tuple return types in CS. bool is_return_tuple = false; if ( pc->Is(CT_PAREN_CLOSE) && !pc->TestFlags(PCF_IN_PREPROC)) { first = pc->GetOpeningParen(); is_return_tuple = true; } pc = first; while (pc->IsNotNullChunk()) { LOG_CHUNK(LTOK, pc); if (parent_type != CT_NONE) { pc->SetParentType(parent_type); } Chunk *prev = pc->GetPrevNcNnlNi(); // Issue #2279 if ( !is_return_tuple || pc->IsNot(CT_WORD) || ( prev->IsNullChunk() && prev->IsNot(CT_TYPE))) { make_type(pc); } if (pc == start) { break; } pc = pc->GetNextNcNnl(); //template angles should keep parent type CT_TEMPLATE if (pc->Is(CT_ANGLE_OPEN)) { pc = pc->GetNextType(CT_ANGLE_CLOSE, pc->GetLevel()); if (pc == start) { break; } pc = pc->GetNextNcNnl(); } } LOG_FMT(LFCNR, "\n"); // Back up and mark parent type on friend declarations if ( parent_type != CT_NONE && first && first->TestFlags(PCF_IN_CLASS)) { pc = first->GetPrevNcNnlNi(); // Issue #2279 if (pc->Is(CT_FRIEND)) { LOG_FMT(LFCNR, "%s(%d): marking friend\n", __func__, __LINE__); pc->SetParentType(parent_type); // A friend might be preceded by a template specification, as in: // template <...> friend type func(...); // If so, we need to mark that also pc = pc->GetPrevNcNnlNi(); // Issue #2279 if (pc->Is(CT_ANGLE_CLOSE)) { pc = skip_template_prev(pc); if (pc->Is(CT_TEMPLATE)) { LOG_FMT(LFCNR, "%s(%d): marking friend template\n", __func__, __LINE__); pc->SetParentType(parent_type); } } } } } } // mark_function_return_type void mark_function(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc == nullptr) { return; } LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); Chunk *prev = pc->GetPrevNcNnlNi(); // Issue #2279 Chunk *next = pc->GetNextNppOrNcNnl(); if (next->IsNullChunk()) { return; } Chunk *tmp; Chunk *semi = nullptr; Chunk *paren_open; Chunk *paren_close; // Find out what is before the operator if (pc->GetParentType() == CT_OPERATOR) { LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); log_pcf_flags(LGUY, pc->GetFlags()); Chunk *pc_op = pc->GetPrevType(CT_OPERATOR, pc->GetLevel()); if ( pc_op->IsNotNullChunk() && pc_op->TestFlags(PCF_EXPR_START)) { LOG_FMT(LFCN, "%s(%d): (4) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); } if (language_is_set(LANG_CPP)) { tmp = pc; while ((tmp = tmp->GetPrevNcNnlNi())->IsNotNullChunk()) // Issue #2279 { if ( tmp->Is(CT_BRACE_CLOSE) || tmp->Is(CT_BRACE_OPEN) // Issue 575 || tmp->Is(CT_SEMICOLON)) { break; } if ( tmp->IsParenOpen() && !pc->TestFlags(PCF_IN_PREPROC)) // Issue #2703 { LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text()); LOG_FMT(LFCN, "%s(%d): (5) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); break; } if (tmp->Is(CT_ASSIGN)) { LOG_FMT(LFCN, "%s(%d): (6) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); break; } if (tmp->Is(CT_TEMPLATE)) { LOG_FMT(LFCN, "%s(%d): (7) SET TO CT_FUNC_DEF: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_DEF); break; } if (tmp->Is(CT_BRACE_OPEN)) { if (tmp->GetParentType() == CT_FUNC_DEF) { LOG_FMT(LFCN, "%s(%d): (8) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); } if ( tmp->GetParentType() == CT_CLASS || tmp->GetParentType() == CT_STRUCT) { LOG_FMT(LFCN, "%s(%d): (9) SET TO CT_FUNC_DEF: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_DEF); } break; } } if ( tmp != nullptr && pc->IsNot(CT_FUNC_CALL)) { // Mark the return type tmp = tmp->GetNextNcNnl(); while ( tmp != pc && tmp->IsNotNullChunk()) { make_type(tmp); // Mark the return type tmp = tmp->GetNextNcNnl(); } } } } if ( next->IsPointerOperator() || next->IsNewline()) { next = next->GetNextNppOrNcNnl(); if (next->IsNullChunk()) { return; } } LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s, type is %s, parent type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); LOG_FMT(LFCN, " level is %zu, brace level is %zu, next->Text() '%s', next->GetType() is %s, next->GetLevel() is %zu\n", pc->GetLevel(), pc->GetBraceLevel(), next->Text(), get_token_name(next->GetType()), next->GetLevel()); if (pc->TestFlags(PCF_IN_CONST_ARGS)) { pc->SetType(CT_FUNC_CTOR_VAR); LOG_FMT(LFCN, "%s(%d): 1) Marked [%s] as FUNC_CTOR_VAR on line %zu col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); next = skip_template_next(next); if (next == nullptr) { return; } flag_parens(next, PCF_NONE, CT_FPAREN_OPEN, pc->GetType(), true); return; } // Skip over any template and attribute madness next = skip_template_next(next); if (next == nullptr) { return; } next = skip_attribute_next(next); if (next == nullptr) { return; } // Find the open and close parenthesis paren_open = pc->GetNextString("(", 1, pc->GetLevel()); paren_close = paren_open->GetNextString(")", 1, pc->GetLevel()); if ( paren_open->IsNullChunk() || paren_close->IsNullChunk()) { LOG_FMT(LFCN, "%s(%d): No parens found for [%s] on orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); return; } /* * This part detects either chained function calls or a function ptr definition. * MYTYPE (*func)(void); * MYTYPE (*func(param))(void); * MYTYPE (*func(param_call1)(param_call2))(void); * mWriter( "class Clst_"c )( somestr.getText() )( " : Cluster {"c ).newline; * * For it to be a function variable def, there must be a '*' followed by a * single word or by a sequence of one or more expressions each within brackets. * * Otherwise, it must be chained function calls. */ tmp = paren_close->GetNextNcNnl(); if ( tmp->IsNotNullChunk() && tmp->IsString("(")) { Chunk *tmp1; Chunk *tmp2; Chunk *tmp3; // skip over any leading class/namespace in: "T(F::*A)();" tmp1 = next->GetNextNcNnl(); while (tmp1->IsNotNullChunk()) { tmp2 = tmp1->GetNextNcNnl(); if ( !tmp1->IsWord() || tmp2->IsNot(CT_DC_MEMBER)) { break; } tmp1 = tmp2->GetNextNcNnl(); } tmp2 = tmp1->GetNextNcNnl(); if (tmp2->IsString(")")) { tmp3 = tmp2; tmp2 = Chunk::NullChunkPtr; } else { tmp3 = tmp2->GetNextNcNnl(); } tmp3 = tmp3->GetNextNbsb(); // Issue #3852 while (tmp3->IsString("(")) { tmp3 = tmp3->GetClosingParen(); tmp3 = tmp3->GetNextNcNnl(); } if ( tmp3->IsString(")") && ( tmp1->IsStar() || tmp1->IsMsRef() || ( language_is_set(LANG_OC) && tmp1->Is(CT_CARET))) && ( tmp2->IsNullChunk() || tmp2->Is(CT_WORD))) { if (tmp2->IsNotNullChunk()) { LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu, function variable '%s', changing '%s' into a type\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), tmp2->Text(), pc->Text()); tmp2->SetType(CT_FUNC_VAR); flag_parens(paren_open, PCF_NONE, CT_PAREN_OPEN, CT_FUNC_VAR, false); LOG_FMT(LFCN, "%s(%d): paren open @ orig line %zu, orig col %zu\n", __func__, __LINE__, paren_open->GetOrigLine(), paren_open->GetOrigCol()); } else { LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu, function type, changing '%s' into a type\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); if (tmp2) { tmp2->SetType(CT_FUNC_TYPE); } flag_parens(paren_open, PCF_NONE, CT_PAREN_OPEN, CT_FUNC_TYPE, false); } pc->SetType(CT_TYPE); tmp1->SetType(CT_PTR_TYPE); pc->ResetFlagBits(PCF_VAR_1ST_DEF); if (tmp2->IsNotNullChunk()) { tmp2->SetFlagBits(PCF_VAR_1ST_DEF); } flag_parens(tmp, PCF_NONE, CT_FPAREN_OPEN, CT_FUNC_PROTO, false); fix_fcn_def_params(tmp); return; } LOG_FMT(LFCN, "%s(%d): chained function calls? Text() is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); } // Assume it is a function call if not already labeled if (pc->Is(CT_FUNCTION)) { LOG_FMT(LFCN, "%s(%d): examine: Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); // look for an assignment. Issue #575 Chunk *temp = pc->GetNextType(CT_ASSIGN, pc->GetLevel()); if (temp->IsNotNullChunk()) { LOG_FMT(LFCN, "%s(%d): assignment found, orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, temp->GetOrigLine(), temp->GetOrigCol(), temp->Text()); LOG_FMT(LFCN, "%s(%d): (10) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); } else { LOG_FMT(LFCN, "%s(%d): (11) SET TO %s: orig line is %zu, orig col is %zu, Text() '%s'", __func__, __LINE__, (pc->GetParentType() == CT_OPERATOR) ? "CT_FUNC_DEF" : "CT_FUNC_CALL", pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType((pc->GetParentType() == CT_OPERATOR) ? CT_FUNC_DEF : CT_FUNC_CALL); } } LOG_FMT(LFCN, "%s(%d): Check for C++ function def, Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); if ( prev != nullptr && prev->IsNotNullChunk()) { LOG_FMT(LFCN, "%s(%d): prev->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol(), get_token_name(prev->GetType())); } else { prev = Chunk::NullChunkPtr; } // Check for C++ function def if ( pc->Is(CT_FUNC_CLASS_DEF) || ( prev->IsNotNullChunk() && ( prev->Is(CT_INV) || prev->Is(CT_DC_MEMBER)))) { Chunk *destr = Chunk::NullChunkPtr; if (prev->Is(CT_INV)) { // TODO: do we care that this is the destructor? prev->SetType(CT_DESTRUCTOR); pc->SetType(CT_FUNC_CLASS_DEF); pc->SetParentType(CT_DESTRUCTOR); destr = prev; // Point to the item previous to the class name prev = prev->GetPrevNcNnlNpp(); } if (prev->Is(CT_DC_MEMBER)) { prev = prev->GetPrevNcNnlNpp(); if (prev->IsNotNullChunk()) { LOG_FMT(LFCN, "%s(%d): prev->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol(), get_token_name(prev->GetType())); prev = skip_template_prev(prev); LOG_FMT(LFCN, "%s(%d): prev->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol(), get_token_name(prev->GetType())); prev = skip_attribute_prev(prev); LOG_FMT(LFCN, "%s(%d): prev->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol(), get_token_name(prev->GetType())); } if ( prev->Is(CT_WORD) || prev->Is(CT_TYPE)) { if (pc->GetStr().equals(prev->GetStr())) { LOG_FMT(LFCN, "%s(%d): pc->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(prev->GetType())); pc->SetType(CT_FUNC_CLASS_DEF); LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu - FOUND %sSTRUCTOR for '%s', type is %s\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), (destr->IsNotNullChunk()) ? "DE" : "CON", prev->Text(), get_token_name(prev->GetType())); mark_cpp_constructor(pc); return; } // Point to the item previous to the class name prev = prev->GetPrevNcNnlNpp(); } } } /* * Determine if this is a function call or a function def/proto * We check for level==1 to allow the case that a function prototype is * wrapped in a macro: "MACRO(void foo(void));" */ if ( pc->Is(CT_FUNC_CALL) && ( pc->GetLevel() == pc->GetBraceLevel() || pc->GetLevel() == 1) && !pc->TestFlags(PCF_IN_ARRAY_ASSIGN)) { bool isa_def = false; bool hit_star = false; LOG_FMT(LFCN, "%s(%d): pc->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); if (prev->IsNullChunk()) { LOG_FMT(LFCN, "%s(%d): Checking func call: prev is null chunk\n", __func__, __LINE__); } else { LOG_FMT(LFCN, "%s(%d): Checking func call: prev->Text() '%s', prev->GetType() is %s\n", __func__, __LINE__, prev->Text(), get_token_name(prev->GetType())); } // if (!chunk_ends_type(prev)) // { // goto bad_ret_type; // } /* * REVISIT: * a function def can only occur at brace level, but not inside an * assignment, structure, enum, or union. * The close paren must be followed by an open brace, with an optional * qualifier (const) in between. * There can be all sorts of template stuff and/or '[]' in the type. * This hack mostly checks that. * * Examples: * foo->bar(maid); -- fcn call * FOO * bar(); -- fcn proto or class variable * FOO foo(); -- fcn proto or class variable * FOO foo(1); -- class variable * a = FOO * bar(); -- fcn call * a.y = foo() * bar(); -- fcn call * static const char * const fizz(); -- fcn def */ while (prev->IsNotNullChunk()) { LOG_FMT(LFCN, "%s(%d): next step with: prev orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), prev->Text()); if (pc->GetParentType() == CT_FIXED) { isa_def = true; } if (prev->TestFlags(PCF_IN_PREPROC)) { prev = prev->GetPrevNcNnlNpp(); continue; } // Some code slips an attribute between the type and function if ( prev->Is(CT_FPAREN_CLOSE) && prev->GetParentType() == CT_ATTRIBUTE) { prev = skip_attribute_prev(prev); continue; } // skip const(TYPE) if ( prev->Is(CT_PAREN_CLOSE) && prev->GetParentType() == CT_D_CAST) { LOG_FMT(LFCN, "%s(%d): --> For sure a prototype or definition\n", __func__, __LINE__); isa_def = true; break; } if (prev->GetParentType() == CT_DECLSPEC) // Issue 1289 { prev = prev->GetOpeningParen(); if (prev->IsNotNullChunk()) { prev = prev->GetPrev(); } if (prev->Is(CT_DECLSPEC)) { if (prev->IsNotNullChunk()) { prev = prev->GetPrev(); } } } // if it was determined that this could be a function definition // but one of the preceding tokens is a CT_MEMBER than this is not a // fcn def, issue #1466 if ( isa_def && prev->Is(CT_MEMBER)) { isa_def = false; } // get first chunk before: A::B::pc | this.B.pc | this->B->pc if ( prev->Is(CT_DC_MEMBER) || prev->Is(CT_MEMBER)) { while ( prev->Is(CT_DC_MEMBER) || prev->Is(CT_MEMBER)) { prev = prev->GetPrevNcNnlNpp(); if ( prev->IsNullChunk() || ( prev->IsNot(CT_WORD) && prev->IsNot(CT_TYPE) && prev->IsNot(CT_THIS))) { LOG_FMT(LFCN, "%s(%d): --? skipped MEMBER and landed on %s\n", __func__, __LINE__, (prev->IsNullChunk()) ? "" : get_token_name(prev->GetType())); break; } LOG_FMT(LFCN, "%s(%d): '%s'\n", __func__, __LINE__, prev->Text()); // Issue #1112 // clarification: this will skip the CT_WORD, CT_TYPE or CT_THIS landing on either // another CT_DC_MEMBER or CT_MEMBER or a token that indicates the context of the // token in question; therefore, exit loop when not a CT_DC_MEMBER or CT_MEMBER prev = prev->GetPrevNcNnlNpp(); if (prev->IsNullChunk()) { LOG_FMT(LFCN, "%s(%d): prev is null chunk\n", __func__, __LINE__); } else { LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), prev->Text()); } } if (prev->IsNullChunk()) { break; } } // If we are on a TYPE or WORD, then this could be a proto or def if ( prev->Is(CT_TYPE) || prev->Is(CT_WORD)) { if (!hit_star) { LOG_FMT(LFCN, "%s(%d): --> For sure a prototype or definition\n", __func__, __LINE__); isa_def = true; break; } Chunk *prev_prev = prev->GetPrevNcNnlNpp(); if (!prev_prev->Is(CT_QUESTION)) // Issue #1753 { LOG_FMT(LFCN, "%s(%d): --> maybe a proto/def\n", __func__, __LINE__); LOG_FMT(LFCN, "%s(%d): prev is '%s', orig line is %zu, orig col is %zu, type is %s, parent type is %s\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol(), get_token_name(prev->GetType()), get_token_name(prev->GetParentType())); log_pcf_flags(LFCN, pc->GetFlags()); isa_def = true; } } if (prev->IsPointerOperator()) { hit_star = true; } if ( prev->IsNot(CT_OPERATOR) && prev->IsNot(CT_TSQUARE) && prev->IsNot(CT_ANGLE_CLOSE) && prev->IsNot(CT_QUALIFIER) && prev->IsNot(CT_TYPE) && prev->IsNot(CT_WORD) && !prev->IsPointerOperator()) { LOG_FMT(LFCN, "%s(%d): --> Stopping on prev is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol(), get_token_name(prev->GetType())); // certain tokens are unlikely to precede a prototype or definition if ( prev->Is(CT_ARITH) || prev->Is(CT_SHIFT) || prev->Is(CT_ASSIGN) || prev->Is(CT_COMMA) || ( prev->Is(CT_STRING) && prev->GetParentType() != CT_EXTERN) // fixes issue 1259 || prev->Is(CT_STRING_MULTI) || prev->Is(CT_NUMBER) || prev->Is(CT_NUMBER_FP) || prev->Is(CT_FPAREN_OPEN)) // issue #1464 { isa_def = false; } break; } // Skip over template and attribute stuff if (prev->Is(CT_ANGLE_CLOSE)) { prev = skip_template_prev(prev); } else { prev = prev->GetPrevNcNnlNpp(); } } //LOG_FMT(LFCN, " -- stopped on %s [%s]\n", // prev->Text(), get_token_name(prev->GetType())); // Fixes issue #1634 if (prev->IsParenClose()) { Chunk *preproc = prev->GetNextNcNnl(); if (preproc->Is(CT_PREPROC)) { size_t pp_level = preproc->GetPpLevel(); if (preproc->GetNextNcNnl()->Is(CT_PP_ELSE)) { do { preproc = preproc->GetPrevNcNnlNi(); // Issue #2279 if (preproc->Is(CT_PP_IF)) { preproc = preproc->GetPrevNcNnlNi(); // Issue #2279 if (preproc->GetPpLevel() == pp_level) { prev = preproc->GetPrevNcNnlNpp(); break; } } } while (preproc->IsNotNullChunk()); } } } if ( isa_def && prev != nullptr && prev->IsNotNullChunk() && ( ( prev->IsParenClose() && prev->GetParentType() != CT_D_CAST && prev->GetParentType() != CT_MACRO_OPEN // Issue #2726 && prev->GetParentType() != CT_MACRO_CLOSE) || prev->Is(CT_ASSIGN) || prev->Is(CT_RETURN))) { LOG_FMT(LFCN, "%s(%d): -- overriding DEF due to prev is '%s', type is %s\n", __func__, __LINE__, prev->Text(), get_token_name(prev->GetType())); isa_def = false; } // Fixes issue #1266, identification of a tuple return type in CS. if ( !isa_def && prev->Is(CT_PAREN_CLOSE) && prev->GetNextNcNnl() == pc) { tmp = prev->GetOpeningParen(); while ( tmp->IsNotNullChunk() // Issue #2315 && tmp != prev) { if ( tmp->Is(CT_COMMA) && tmp->GetLevel() == prev->GetLevel() + 1) { LOG_FMT(LFCN, "%s(%d): -- overriding call due to tuple return type -- prev is '%s', type is %s\n", __func__, __LINE__, prev->Text(), get_token_name(prev->GetType())); isa_def = true; break; } tmp = tmp->GetNextNcNnl(); } } if (isa_def) { LOG_FMT(LFCN, "%s(%d): pc is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType())); LOG_FMT(LFCN, "%s(%d): (12) SET TO CT_FUNC_DEF: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_DEF); if ( prev == nullptr || prev->IsNullChunk()) { prev = Chunk::GetHead(); } for (tmp = prev; tmp->IsNotNullChunk() && tmp != pc; tmp = tmp->GetNextNcNnlNpp()) { LOG_FMT(LFCN, "%s(%d): Text() is '%s', type is %s\n", __func__, __LINE__, tmp->Text(), get_token_name(tmp->GetType())); make_type(tmp); } } } if (pc->IsNot(CT_FUNC_DEF)) { LOG_FMT(LFCN, "%s(%d): Detected type %s, Text() is '%s', on orig line %zu, orig col %zu\n", __func__, __LINE__, get_token_name(pc->GetType()), pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); tmp = flag_parens(next, PCF_IN_FCN_CALL, CT_FPAREN_OPEN, CT_FUNC_CALL, false); if ( tmp != nullptr && tmp->Is(CT_BRACE_OPEN) && tmp->GetParentType() != CT_DOUBLE_BRACE) { set_paren_parent(tmp, pc->GetType()); } return; } /* * We have a function definition or prototype * Look for a semicolon or a brace open after the close parenthesis to figure * out whether this is a prototype or definition */ // See if this is a prototype or implementation // FIXME: this doesn't take the old K&R parameter definitions into account // Scan tokens until we hit a brace open (def) or semicolon (proto) tmp = paren_close->GetNextNcNnl(); while (tmp->IsNotNullChunk()) { // Only care about brace or semicolon on the same level if (tmp->GetLevel() < pc->GetLevel()) { // No semicolon - guess that it is a prototype pc->ResetFlagBits(PCF_VAR_1ST_DEF); pc->SetType(CT_FUNC_PROTO); break; } else if (tmp->GetLevel() == pc->GetLevel()) { if (tmp->Is(CT_BRACE_OPEN)) { // its a function def for sure break; } else if (tmp->IsSemicolon()) { // Set the parent for the semicolon for later semi = tmp; pc->ResetFlagBits(PCF_VAR_1ST_DEF); pc->SetType(CT_FUNC_PROTO); LOG_FMT(LFCN, "%s(%d): 2) Marked Text() is '%s', as FUNC_PROTO on orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); break; } else if (pc->Is(CT_COMMA)) { pc->SetType(CT_FUNC_CTOR_VAR); LOG_FMT(LFCN, "%s(%d): 2) Marked Text() is '%s', as FUNC_CTOR_VAR on orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); break; } } tmp = tmp->GetNextNcNnl(); } /* * C++ syntax is wacky. We need to check to see if a prototype is really a * variable definition with parameters passed into the constructor. * Unfortunately, without being able to accurately determine if an * identifier is a type (which would require us to more or less be a full * compiler), the only mostly reliable way to do so is to guess that it is * a constructor variable if inside a function body and scan the 'parameter * list' for items that are not allowed in a prototype. We search backwards * and checking the parent of the containing open braces. If the parent is a * class or namespace, then it probably is a prototype. */ if ( language_is_set(LANG_CPP) && pc->Is(CT_FUNC_PROTO) && pc->GetParentType() != CT_OPERATOR) { LOG_FMT(LFPARAM, "%s(%d):", __func__, __LINE__); LOG_FMT(LFPARAM, " checking '%s' for constructor variable %s %s\n", pc->Text(), get_token_name(paren_open->GetType()), get_token_name(paren_close->GetType())); /* * Check the token at the start of the statement. If it's 'extern', we * definitely have a function prototype. */ tmp = pc; while ( tmp->IsNotNullChunk() && !tmp->TestFlags(PCF_STMT_START)) { tmp = tmp->GetPrevNcNnlNi(); // Issue #2279 } const bool is_extern = ( tmp->IsNotNullChunk() && tmp->GetStr().equals("extern")); /* * Scan the parameters looking for: * - constant strings * - numbers * - non-type fields * - function calls */ Chunk *ref = paren_open->GetNextNcNnl(); Chunk *tmp2; bool is_param = true; tmp = ref; while (tmp != paren_close) { tmp2 = tmp->GetNextNcNnl(); if ( tmp->Is(CT_COMMA) && (tmp->GetLevel() == (paren_open->GetLevel() + 1))) { if (!can_be_full_param(ref, tmp)) { is_param = false; break; } ref = tmp2; } tmp = tmp2; } if ( !is_extern && is_param && ref != tmp) { if (!can_be_full_param(ref, tmp)) { is_param = false; } } if ( !is_extern && !is_param) { pc->SetType(CT_FUNC_CTOR_VAR); LOG_FMT(LFCN, "%s(%d): 3) Marked Text() '%s' as FUNC_CTOR_VAR on orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); } else if (pc->GetBraceLevel() > 0) { Chunk *br_open = pc->GetPrevType(CT_BRACE_OPEN, pc->GetBraceLevel() - 1); if ( br_open->IsNotNullChunk() && br_open->GetParentType() != CT_EXTERN && br_open->GetParentType() != CT_NAMESPACE) { // Do a check to see if the level is right prev = pc->GetPrevNcNnlNi(); // Issue #2279 if ( !prev->IsString("*") && !prev->IsString("&")) { Chunk *p_op = pc->GetPrevType(CT_BRACE_OPEN, pc->GetBraceLevel() - 1); if ( p_op->IsNotNullChunk() && p_op->GetParentType() != CT_CLASS && p_op->GetParentType() != CT_STRUCT && p_op->GetParentType() != CT_NAMESPACE) { pc->SetType(CT_FUNC_CTOR_VAR); LOG_FMT(LFCN, "%s(%d): 4) Marked Text() is'%s', as FUNC_CTOR_VAR on orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); } } } } } if ( semi != nullptr && semi->IsNotNullChunk()) { semi->SetParentType(pc->GetType()); } // Issue # 1403, 2152 if (paren_open->GetPrev()->Is(CT_FUNC_CTOR_VAR)) { flag_parens(paren_open, PCF_IN_FCN_CTOR, CT_FPAREN_OPEN, pc->GetType(), false); } else { flag_parens(paren_open, PCF_IN_FCN_DEF, CT_FPAREN_OPEN, pc->GetType(), false); } //flag_parens(paren_open, PCF_IN_FCN_DEF, CT_FPAREN_OPEN, pc->GetType(), true); if (pc->Is(CT_FUNC_CTOR_VAR)) { pc->SetFlagBits(PCF_VAR_1ST_DEF); return; } if (next->Is(CT_TSQUARE)) { next = next->GetNextNcNnl(); if (next->IsNullChunk()) { return; } } // Mark parameters and return type fix_fcn_def_params(next); mark_function_return_type(pc, pc->GetPrevNcNnlNi(), pc->GetType()); // Issue #2279 /* mark C# where chunk */ if ( language_is_set(LANG_CS) && ( (pc->Is(CT_FUNC_DEF)) || (pc->Is(CT_FUNC_PROTO)))) { tmp = paren_close->GetNextNcNnl(); T_PcfFlags in_where_spec_flags = PCF_NONE; while ( tmp->IsNotNullChunk() && tmp->IsNot(CT_BRACE_OPEN) && tmp->IsNot(CT_SEMICOLON)) { mark_where_chunk(tmp, pc->GetType(), tmp->GetFlags() | in_where_spec_flags); in_where_spec_flags = tmp->GetFlags() & PCF_IN_WHERE_SPEC; tmp = tmp->GetNextNcNnl(); } } // Find the brace pair and set the parent if (pc->Is(CT_FUNC_DEF)) { tmp = paren_close->GetNextNcNnl(); while ( tmp->IsNotNullChunk() && tmp->IsNot(CT_BRACE_OPEN)) { LOG_FMT(LFCN, "%s(%d): (13) SET TO CT_FUNC_DEF: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text()); tmp->SetParentType(CT_FUNC_DEF); if (!tmp->IsSemicolon()) { tmp->SetFlagBits(PCF_OLD_FCN_PARAMS); } tmp = tmp->GetNextNcNnl(); } if (tmp->Is(CT_BRACE_OPEN)) { LOG_FMT(LFCN, "%s(%d): (14) SET TO CT_FUNC_DEF: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text()); tmp->SetParentType(CT_FUNC_DEF); tmp = tmp->GetClosingParen(); if (tmp->IsNotNullChunk()) { LOG_FMT(LFCN, "%s(%d): (15) SET TO CT_FUNC_DEF: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text()); tmp->SetParentType(CT_FUNC_DEF); } } } } // mark_function bool mark_function_type(Chunk *pc) { LOG_FUNC_ENTRY(); LOG_FMT(LFTYPE, "%s(%d): type is %s, Text() '%s' @ orig line is %zu, orig col is %zu\n", __func__, __LINE__, get_token_name(pc->GetType()), pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); size_t star_count = 0; size_t word_count = 0; Chunk *ptrcnk = nullptr; Chunk *tmp; Chunk *apo; Chunk *apc; Chunk *aft; bool anon = false; E_Token pt, ptp; // Scan backwards across the name, which can only be a word and single star Chunk *varcnk = pc->GetPrevNcNnlNi(); // Issue #2279 varcnk = varcnk->GetPrevNbsb(); if ( varcnk->IsNotNullChunk() && !varcnk->IsWord()) { if ( language_is_set(LANG_OC) && varcnk->IsString("^") && varcnk->GetPrevNcNnlNi()->IsParenOpen()) // Issue #2279 { // anonymous ObjC block type -- RTYPE (^)(ARGS) anon = true; } else { LOG_FMT(LFTYPE, "%s(%d): not a word: Text() '%s', type is %s, @ orig line is %zu:, orig col is %zu\n", __func__, __LINE__, varcnk->Text(), get_token_name(varcnk->GetType()), varcnk->GetOrigLine(), varcnk->GetOrigCol()); goto nogo_exit; } } apo = pc->GetNextNcNnl(); if (apo->IsNullChunk()) { return(false); } apc = apo->GetClosingParen(); if ( apc->IsNotNullChunk() && ( !apo->IsParenOpen() || ((apc = apo->GetClosingParen())->IsNullChunk()))) { LOG_FMT(LFTYPE, "%s(%d): not followed by parens\n", __func__, __LINE__); goto nogo_exit; } aft = apc->GetNextNcNnl(); if (aft->Is(CT_BRACE_OPEN)) { pt = CT_FUNC_DEF; } else if ( aft->Is(CT_SEMICOLON) || aft->Is(CT_ASSIGN)) { pt = CT_FUNC_PROTO; } else { LOG_FMT(LFTYPE, "%s(%d): not followed by '{' or ';'\n", __func__, __LINE__); goto nogo_exit; } ptp = pc->TestFlags(PCF_IN_TYPEDEF) ? CT_FUNC_TYPE : CT_FUNC_VAR; tmp = pc; while ((tmp = tmp->GetPrevNcNnlNi())->IsNotNullChunk()) // Issue #2279 { tmp = tmp->GetPrevNbsb(); LOG_FMT(LFTYPE, " -- type is %s, %s on orig line %zu, orig col is %zu", get_token_name(tmp->GetType()), tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol()); if ( tmp->IsStar() || tmp->Is(CT_PTR_TYPE) || tmp->Is(CT_CARET)) { star_count++; ptrcnk = tmp; LOG_FMT(LFTYPE, " -- PTR_TYPE\n"); } else if ( tmp->IsWord() || tmp->Is(CT_WORD) || tmp->Is(CT_TYPE)) { word_count++; LOG_FMT(LFTYPE, " -- TYPE(%s)\n", tmp->Text()); } else if (tmp->Is(CT_DC_MEMBER)) { word_count = 0; LOG_FMT(LFTYPE, " -- :: reset word_count\n"); } else if (tmp->IsString("(")) { LOG_FMT(LFTYPE, " -- open paren (break)\n"); break; } else { LOG_FMT(LFTYPE, " -- unexpected token: type is %s, Text() '%s', on orig line %zu, orig col %zu\n", get_token_name(tmp->GetType()), tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol()); goto nogo_exit; } } // Fixes #issue 1577 // Allow word count 2 in case of function pointer declaration. // Ex: bool (__stdcall* funcptr)(int, int); if ( star_count > 1 || ( word_count > 1 && !( word_count == 2 && ptp == CT_FUNC_VAR)) || ((star_count + word_count) == 0)) { LOG_FMT(LFTYPE, "%s(%d): bad counts word: %zu, star: %zu\n", __func__, __LINE__, word_count, star_count); goto nogo_exit; } // make sure what appears before the first open paren can be a return type if (!chunk_ends_type(tmp->GetPrevNcNnlNi())) // Issue #2279 { goto nogo_exit; } if (ptrcnk) { ptrcnk->SetType(CT_PTR_TYPE); } if (!anon) { if (pc->TestFlags(PCF_IN_TYPEDEF)) { varcnk->SetType(CT_FUNC_TYPE); // Issue #3402 } else { varcnk->SetType(CT_FUNC_VAR); varcnk->SetFlagBits(PCF_VAR_1ST_DEF); } } pc->SetType(CT_TPAREN_CLOSE); pc->SetParentType(ptp); apo->SetType(CT_FPAREN_OPEN); apo->SetParentType(pt); apc->SetType(CT_FPAREN_CLOSE); apc->SetParentType(pt); fix_fcn_def_params(apo); if (aft->IsSemicolon()) { aft->SetParentType(aft->TestFlags(PCF_IN_TYPEDEF) ? CT_TYPEDEF : CT_FUNC_VAR); } else if (aft->Is(CT_BRACE_OPEN)) { flag_parens(aft, PCF_NONE, CT_NONE, pt, false); } // Step backwards to the previous open paren and mark everything a tmp = pc; while ((tmp = tmp->GetPrevNcNnlNi())->IsNotNullChunk()) // Issue #2279 { LOG_FMT(LFTYPE, " ++ type is %s, Text() '%s', on orig line %zu, orig col %zu\n", get_token_name(tmp->GetType()), tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol()); if (*tmp->GetStr().c_str() == '(') { if (!pc->TestFlags(PCF_IN_TYPEDEF)) { tmp->SetFlagBits(PCF_VAR_1ST_DEF); } tmp->SetType(CT_TPAREN_OPEN); tmp->SetParentType(ptp); tmp = tmp->GetPrevNcNnlNi(); // Issue #2279 if ( tmp->Is(CT_FUNCTION) || tmp->Is(CT_FUNC_CALL) || tmp->Is(CT_FUNC_CALL_USER) || tmp->Is(CT_FUNC_DEF) || tmp->Is(CT_FUNC_PROTO)) { tmp->SetType(CT_TYPE); tmp->ResetFlagBits(PCF_VAR_1ST_DEF); } mark_function_return_type(varcnk, tmp, ptp); break; } } return(true); nogo_exit: tmp = pc->GetNextNcNnl(); if (tmp->IsParenOpen()) { LOG_FMT(LFTYPE, "%s(%d): setting FUNC_CALL on orig line is %zu, orig col is %zu\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol()); flag_parens(tmp, PCF_NONE, CT_FPAREN_OPEN, CT_FUNC_CALL, false); } return(false); } // mark_function_type void mark_lvalue(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc->TestFlags(PCF_IN_PREPROC)) { return; } for (Chunk *prev = pc->GetPrevNcNnlNi(); // Issue #2279 prev->IsNotNullChunk(); prev = prev->GetPrevNcNnlNi()) // Issue #2279 { if ( prev->GetLevel() < pc->GetLevel() || prev->Is(CT_ACCESS_COLON) || prev->Is(CT_ASSIGN) || prev->Is(CT_BOOL) || prev->Is(CT_COMMA) || prev->IsCppInheritanceAccessSpecifier() || prev->IsSemicolon() || prev->IsString("(") || prev->IsString("{") || prev->IsString("[") || prev->TestFlags(PCF_IN_PREPROC) || prev->GetParentType() == CT_NAMESPACE || prev->GetParentType() == CT_TEMPLATE) { break; } prev->SetFlagBits(PCF_LVALUE); if ( prev->GetLevel() == pc->GetLevel() && prev->IsString("&")) { make_type(prev); } } } // mark_lvalue void mark_struct_union_body(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *pc = start; while ( pc->IsNotNullChunk() && pc->GetLevel() >= start->GetLevel() && !( pc->GetLevel() == start->GetLevel() && pc->Is(CT_BRACE_CLOSE))) { if ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_SEMICOLON)) { pc = pc->GetNextNcNnl(); if (pc->IsNullChunk()) { break; } } if (pc->Is(CT_ALIGN)) { pc = skip_align(pc); // "align(x)" or "align(x):" if (pc->IsNullChunk()) { break; } } else if (pc->Is(CT_AMP)) { pc = skip_expression(pc); } else { pc = fix_variable_definition(pc); if (pc->IsNullChunk()) { break; } } } } // mark_struct_union_body void mark_template_func(Chunk *pc, Chunk *pc_next) { LOG_FUNC_ENTRY(); // We know angle_close must be there... Chunk *angle_close = pc_next->GetNextType(CT_ANGLE_CLOSE, pc->GetLevel()); Chunk *after = angle_close->GetNextNcNnl(); if (after->IsNotNullChunk()) { if (after->IsString("(")) { if (angle_close->TestFlags(PCF_IN_FCN_CALL)) { LOG_FMT(LTEMPFUNC, "%s(%d): marking '%s' in line %zu as a FUNC_CALL\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); LOG_FMT(LFCN, "%s(%d): (16) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); flag_parens(after, PCF_IN_FCN_CALL, CT_FPAREN_OPEN, CT_FUNC_CALL, false); } else { /* * Might be a function def. Must check what is before the template: * Func call: * BTree.Insert(std::pair(*it, double(*it) + 1.0)); * a = Test(j); * std::pair(*it, double(*it) + 1.0)); */ LOG_FMT(LTEMPFUNC, "%s(%d): marking '%s' in line %zu as a FUNC_CALL 2\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); // its a function!!! LOG_FMT(LFCN, "%s(%d): (17) SET TO CT_FUNC_CALL: orig line is %zu, orig col is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); pc->SetType(CT_FUNC_CALL); mark_function(pc); } } else if (after->Is(CT_WORD)) { // its a type! pc->SetType(CT_TYPE); pc->SetFlagBits(PCF_VAR_TYPE); after->SetFlagBits(PCF_VAR_DEF); } } } // mark_template_func Chunk *mark_variable_definition(Chunk *start) { LOG_FUNC_ENTRY(); if (start == nullptr) { return(nullptr); } Chunk *pc = start; T_PcfFlags flags = PCF_VAR_1ST_DEF; LOG_FMT(LVARDEF, "%s(%d): orig line %zu, orig col %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); // Issue #596 bool bit_field_colon_is_present = false; while (go_on(pc, start)) { if ( pc->Is(CT_WORD) || pc->Is(CT_FUNC_CTOR_VAR)) { auto const orig_flags = pc->GetFlags(); if (!pc->TestFlags(PCF_IN_ENUM)) { pc->SetFlagBits(flags); } flags &= ~PCF_VAR_1ST; LOG_FMT(LVARDEF, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', set PCF_VAR_1ST\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); LOG_FMT(LVARDEF, "%s(%d): orig line is %zu, marked Text() '%s'[%s]\n" " in orig col %zu, flags: %s -> %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->Text(), get_token_name(pc->GetType()), pc->GetOrigCol(), pcf_flags_str(orig_flags).c_str(), pcf_flags_str(pc->GetFlags()).c_str()); } else if ( !bit_field_colon_is_present // Issue #2689 && ( pc->IsStar() || pc->IsMsRef())) { pc->SetType(CT_PTR_TYPE); } else if (pc->IsAddress()) { pc->SetType(CT_BYREF); } else if ( pc->Is(CT_SQUARE_OPEN) || pc->Is(CT_ASSIGN)) { pc = skip_expression(pc); continue; } else if (pc->Is(CT_COLON)) { bit_field_colon_is_present = true; // Issue #2689 } pc = pc->GetNextNcNnl(); } return(pc); } // mark_variable_definition void mark_variable_stack(ChunkStack &cs, log_sev_t sev) { UNUSED(sev); LOG_FUNC_ENTRY(); // throw out the last word and mark the rest Chunk *var_name = cs.Pop_Back(); if ( var_name != nullptr && var_name->GetPrev()->IsNotNullChunk() && var_name->GetPrev()->GetType() == CT_DC_MEMBER) { cs.Push_Back(var_name); } if (var_name != nullptr) { LOG_FMT(LFCNP, "%s(%d): parameter on orig line %zu, orig col %zu:\n", __func__, __LINE__, var_name->GetOrigLine(), var_name->GetOrigCol()); size_t word_cnt = 0; Chunk *word_type; while ((word_type = cs.Pop_Back()) != nullptr) { if ( word_type->Is(CT_WORD) || word_type->Is(CT_TYPE)) { LOG_FMT(LFCNP, "%s(%d): parameter on orig line %zu, orig col %zu: <%s> as TYPE\n", __func__, __LINE__, var_name->GetOrigLine(), var_name->GetOrigCol(), word_type->Text()); word_type->SetType(CT_TYPE); word_type->SetFlagBits(PCF_VAR_TYPE); } word_cnt++; } if (var_name->Is(CT_WORD)) { if (word_cnt > 0) { LOG_FMT(LFCNP, "%s(%d): parameter on orig line %zu, orig col %zu: <%s> as VAR\n", __func__, __LINE__, var_name->GetOrigLine(), var_name->GetOrigCol(), var_name->Text()); var_name->SetFlagBits(PCF_VAR_DEF); } else { LOG_FMT(LFCNP, "%s(%d): parameter on orig line %zu, orig col %zu: <%s> as TYPE\n", __func__, __LINE__, var_name->GetOrigLine(), var_name->GetOrigCol(), var_name->Text()); var_name->SetType(CT_TYPE); var_name->SetFlagBits(PCF_VAR_TYPE); } } } } // mark_variable_stack T_PcfFlags mark_where_chunk(Chunk *pc, E_Token parent_type, T_PcfFlags flags) { /* TODO: should have options to control spacing around the ':' as well as newline ability for the * constraint clauses (should it break up a 'where A : B where C : D' on the same line? wrap? etc.) */ if (pc->Is(CT_WHERE)) { pc->SetType(CT_WHERE_SPEC); pc->SetParentType(parent_type); flags |= PCF_IN_WHERE_SPEC; LOG_FMT(LFTOR, "%s: where-spec on line %zu\n", __func__, pc->GetOrigLine()); } else if (flags.test(PCF_IN_WHERE_SPEC)) { if (pc->IsString(":")) { pc->SetType(CT_WHERE_COLON); LOG_FMT(LFTOR, "%s: where-spec colon on line %zu\n", __func__, pc->GetOrigLine()); } else if (pc->IsClassOrStruct()) { /* class/struct inside of a where-clause confuses parser for indentation; set it as a word so it looks like the rest */ pc->SetType(CT_WORD); } } if (flags.test(PCF_IN_WHERE_SPEC)) { pc->SetFlagBits(PCF_IN_WHERE_SPEC); } return(flags); } // mark_where_chunk uncrustify-uncrustify-0.76.0/src/combine_fix_mark.h000066400000000000000000000127651434072136500225040ustar00rootroot00000000000000/** * @file combine_fix_mark.h * * @author Guy Maurel * @license GPL v2+ * extract from combine.cpp */ #ifndef COMBINE_FIX_MARK_H_INCLUDED #define COMBINE_FIX_MARK_H_INCLUDED #include "ChunkStack.h" /** * Checks to see if the current paren is part of a cast. * We already verified that this doesn't follow function, TYPE, IF, FOR, * SWITCH, or WHILE and is followed by WORD, TYPE, STRUCT, ENUM, or UNION. * * @param start Pointer to the open paren */ void fix_casts(Chunk *start); /** * Simply change any STAR to PTR_TYPE and WORD to TYPE * * @param start points to the open paren */ void fix_fcn_def_params(Chunk *start); /** * CT_TYPE_CAST follows this pattern: * dynamic_cast<...>(...) * * Mark everything between the <> as a type and set the paren parent */ void fix_type_cast(Chunk *start); /** * We are on a typedef. * If the next word is not enum/union/struct, then the last word before the * next ',' or ';' or '__attribute__' is a type. * * typedef [type...] [*] type [, [*]type] ; * typedef ([*]func)(); * typedef ([*]func)(params); * typedef (__stdcall *func)(); Bug # 633 MS-specific extension * include the config-file "test/config/MS-calling_conventions.cfg" * typedef func(params); * typedef [type] [*] type [, [*]type] ; * typedef [type] { ... } [*] type [, [*]type] ; */ void fix_typedef(Chunk *start); /** * We are on the start of a sequence that could be a variable definition * - FPAREN_OPEN (parent == CT_FOR) * - BRACE_OPEN * - SEMICOLON */ Chunk *fix_variable_definition(Chunk *start); void mark_cpp_constructor(Chunk *pc); /** * Mark all chunks belonging to a C++ lambda expression * * @param square_open points to a chunk of type CT_SQUARE_OPEN, and the parent type is * assumed to have already been assigned the value CT_CPP_LAMBDA; * under this assumption, the function marks all chunks as PCF_IN_LAMBDA * until the corresponding closing CT_BRACE_CLOSE (with parent type * CT_CPP_LAMBDA) is encountered */ void mark_cpp_lambda(Chunk *square_open); /** * Marks statement starts in a macro body. * REVISIT: this may already be done */ void mark_define_expressions(); /** * Just mark every CT_WORD until a semicolon as CT_SQL_WORD. * Adjust the levels if pc is CT_SQL_BEGIN */ void mark_exec_sql(Chunk *pc); /** * Changes the return type to type and set the parent. * * @param pc the last chunk of the return type * @param parent_type CT_NONE (no change) or the new parent type */ void mark_function_return_type(Chunk *fname, Chunk *start, E_Token parent_type); /** * We are on a function word. we need to: * - find out if this is a call or prototype or implementation * - mark return type * - mark parameter types * - mark brace pair * * REVISIT: * This whole function is a mess. * It needs to be reworked to eliminate duplicate logic and determine the * function type more directly. * 1. Skip to the close paren and see what is after. * a. semicolon - function call or function proto * b. open brace - function call (ie, list_for_each) or function def * c. open paren - function type or chained function call * d. qualifier - function def or proto, continue to semicolon or open brace * 2. Examine the 'parameters' to see if it can be a proto/def * 3. Examine what is before the function name to see if it is a proto or call * Constructor/destructor detection should have already been done when the * 'class' token was encountered (see mark_class_ctor). */ void mark_function(Chunk *pc); /** * Process a function type that is not in a typedef. * pc points to the first close paren. * * void (*func)(params); * const char * (*func)(params); * const char * (^func)(params); -- Objective C * * @param pc Points to the first closing paren * * @return whether a function type was processed */ bool mark_function_type(Chunk *pc); /** * Just hit an assign. Go backwards until we hit an open brace/paren/square or * semicolon (TODO: other limiter?) and mark as a LValue. */ void mark_lvalue(Chunk *pc); /** * Examines the stuff between braces { }. * There should only be variable definitions and methods. * Skip the methods, as they will get handled elsewhere. */ void mark_struct_union_body(Chunk *start); /** * We are on a word followed by a angle open which is part of a template. * If the angle close is followed by a open paren, then we are on a template * function def or a template function call: * Vector2(...) [: ...[, ...]] { ... } * Or we could be on a variable def if it's followed by a word: * Renderer rend; */ void mark_template_func(Chunk *pc, Chunk *pc_next); /** * We are on the first word of a variable definition. * Mark all the variable names with PCF_VAR_1ST and PCF_VAR_DEF as appropriate. * Also mark any '*' encountered as a CT_PTR_TYPE. * Skip over []. Go until a ';' is hit. * * Example input: * int a = 3, b, c = 2; ## called with 'a' * foo_t f = {1, 2, 3}, g = {5, 6, 7}; ## called with 'f' * struct {...} *a, *b; ## called with 'a' or '*' * myclass a(4); */ Chunk *mark_variable_definition(Chunk *start); void mark_variable_stack(ChunkStack &cs, log_sev_t sev); /** * TODO: add doc cmt * */ T_PcfFlags mark_where_chunk(Chunk *pc, E_Token parent_type, T_PcfFlags flags); #endif /* COMBINE_FIX_MARK_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/combine_labels.cpp000066400000000000000000000337501434072136500224760ustar00rootroot00000000000000/** * @file combine_labels.cpp * * @author Guy Maurel * @license GPL v2+ * extract from combine.h */ #include "combine_labels.h" #include "chunk.h" #include "cs_top_is_question.h" #include "unc_tools.h" #include "uncrustify.h" Chunk *chunk_get_next_local(Chunk *pc, E_Scope scope = E_Scope::ALL) { Chunk *tmp = pc; if (tmp == nullptr) { tmp = Chunk::NullChunkPtr; } do { tmp = tmp->GetNext(scope); } while ( tmp->IsNotNullChunk() && ( tmp->IsComment() || tmp->Is(CT_NOEXCEPT))); return(tmp); } Chunk *chunk_get_prev_local(Chunk *pc, E_Scope scope = E_Scope::ALL) { Chunk *tmp = pc; if (tmp == nullptr) { tmp = Chunk::NullChunkPtr; } do { tmp = tmp->GetPrev(scope); } while ( tmp->IsNotNullChunk() && ( tmp->IsCommentOrNewline() || tmp->Is(CT_NOEXCEPT))); return(tmp); } void combine_labels() { LOG_FUNC_ENTRY(); bool hit_case = false; bool hit_class = false; cpd.unc_stage = unc_stage_e::COMBINE_LABELS; // stack to handle nesting inside of OC messages, which reset the scope ChunkStack cs; Chunk *prev = Chunk::GetHead(); if (prev->IsNullChunk()) { return; } Chunk *cur = prev->GetNextNc(); if (cur->IsNullChunk()) { return; } Chunk *next = cur->GetNextNc(); // unlikely that the file will start with a label... // prev cur next while ( next != nullptr && next->IsNotNullChunk()) { if (next->Is(CT_NEWLINE)) { LOG_FMT(LFCN, "%s(%d): next orig line is %zu, orig col is %zu, , nl is %zu\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->GetNlCount()); } else if (next->Is(CT_VBRACE_OPEN)) { LOG_FMT(LFCN, "%s(%d): next orig line is %zu, orig col is %zu, VBRACE_OPEN\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol()); } else if (next->Is(CT_VBRACE_CLOSE)) { LOG_FMT(LFCN, "%s(%d): next orig line is %zu, orig col is %zu, VBRACE_CLOSE\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol()); } else { LOG_FMT(LFCN, "%s(%d): next orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text(), get_token_name(next->GetType())); } if ( !next->TestFlags(PCF_IN_OC_MSG) // filter OC case of [self class] msg send && ( next->Is(CT_CLASS) || next->Is(CT_OC_CLASS) || next->Is(CT_TEMPLATE))) { hit_class = true; } if ( next->IsSemicolon() || next->Is(CT_BRACE_OPEN)) { hit_class = false; } if ( prev->Is(CT_SQUARE_OPEN) && prev->GetParentType() == CT_OC_MSG) { cs.Push_Back(prev); } else if ( next->Is(CT_SQUARE_CLOSE) && next->GetParentType() == CT_OC_MSG) { // pop until we hit '[' while (!cs.Empty()) { Chunk *t2 = cs.Top()->m_pc; cs.Pop_Back(); if (t2->Is(CT_SQUARE_OPEN)) { break; } } } if ( next->Is(CT_QUESTION) && !next->TestFlags(PCF_IN_TEMPLATE)) { cs.Push_Back(next); } else if (next->Is(CT_CASE)) { if (cur->Is(CT_GOTO)) { // handle "goto case x;" next->SetType(CT_QUALIFIER); } else { hit_case = true; } } else if ( next->Is(CT_COLON) || ( next->Is(CT_OC_COLON) && cs_top_is_question(cs, next->GetLevel()))) { if (cur->Is(CT_DEFAULT)) { cur->SetType(CT_CASE); hit_case = true; } if ( cs_top_is_question(cs, next->GetLevel()) && !cur->Is(CT_OC_MSG_NAME) && next->TestFlags(PCF_IN_CONDITIONAL)) // Issue #3558 { //log_pcf_flags(LGUY, next->GetFlags()); next->SetType(CT_COND_COLON); cs.Pop_Back(); } else if (hit_case) { hit_case = false; next->SetType(CT_CASE_COLON); Chunk *tmp = next->GetNextNcNnlNpp(); // Issue #2150 if (tmp->Is(CT_BRACE_OPEN)) { tmp->SetParentType(CT_CASE); tmp = tmp->GetNextType(CT_BRACE_CLOSE, tmp->GetLevel()); if (tmp->IsNotNullChunk()) { tmp->SetParentType(CT_CASE); } } if ( cur->Is(CT_NUMBER) && prev->Is(CT_ELLIPSIS)) { Chunk *pre_elipsis = prev->GetPrevNcNnlNpp(); if (pre_elipsis->Is(CT_NUMBER)) { prev->SetType(CT_CASE_ELLIPSIS); } } } else if (cur->TestFlags(PCF_IN_WHERE_SPEC)) { /* leave colons in where-constraint clauses alone */ } else { LOG_FMT(LFCN, "%s(%d): prev->Text() is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol()); LOG_FMT(LFCN, "%s(%d): cur->Text() is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, cur->Text(), cur->GetOrigLine(), cur->GetOrigCol()); LOG_FMT(LFCN, "%s(%d): next->Text() is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, next->Text(), next->GetOrigLine(), next->GetOrigCol()); Chunk *nextprev = chunk_get_prev_local(next); // Issue #2279 if (nextprev == nullptr) { return; } if (language_is_set(LANG_PAWN)) { if ( cur->Is(CT_WORD) || cur->Is(CT_BRACE_CLOSE)) { E_Token new_type = CT_TAG; Chunk *tmp = next->GetNextNc(); if (tmp->IsNullChunk()) { return; } if ( prev->IsNewline() && tmp->IsNewline()) { new_type = CT_LABEL; next->SetType(CT_LABEL_COLON); } else { next->SetType(CT_TAG_COLON); } if (cur->Is(CT_WORD)) { cur->SetType(new_type); } } } else if (next->TestFlags(PCF_IN_ARRAY_ASSIGN)) { next->SetType(CT_D_ARRAY_COLON); } else if (next->TestFlags(PCF_IN_FOR)) { next->SetType(CT_FOR_COLON); } else if (next->TestFlags(PCF_OC_BOXED)) { next->SetType(CT_OC_DICT_COLON); } else if (cur->Is(CT_WORD)) { Chunk *tmp = next->GetNextNc(E_Scope::PREPROC); // Issue #1187 if (tmp->IsNullChunk()) { return; } LOG_FMT(LFCN, "%s(%d): orig line is %zu, orig col is %zu, tmp '%s': ", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), (tmp->Is(CT_NEWLINE)) ? "" : tmp->Text()); log_pcf_flags(LGUY, tmp->GetFlags()); if (next->TestFlags(PCF_IN_FCN_CALL)) { // Must be a macro thingy, assume some sort of label next->SetType(CT_LABEL_COLON); } else if ( tmp->IsNullChunk() || ( tmp->IsNot(CT_NUMBER) && tmp->IsNot(CT_DECLTYPE) && tmp->IsNot(CT_SIZEOF) && tmp->GetParentType() != CT_SIZEOF && !tmp->GetFlags().test_any(PCF_IN_STRUCT | PCF_IN_CLASS)) || tmp->Is(CT_NEWLINE)) { /* * the CT_SIZEOF isn't great - test 31720 happens to use a sizeof expr, * but this really should be able to handle any constant expr */ // Fix for #1242 // For MIDL_INTERFACE classes class name is tokenized as Label. // Corrected the identification of Label in c style languages. if ( language_is_set(LANG_C | LANG_CPP | LANG_CS) && (!language_is_set(LANG_OC))) { Chunk *labelPrev = prev; if (labelPrev->Is(CT_NEWLINE)) { labelPrev = prev->GetPrevNcNnlNi(); // Issue #2279 } if ( labelPrev->IsNotNullChunk() && labelPrev->IsNot(CT_FPAREN_CLOSE)) { cur->SetType(CT_LABEL); next->SetType(CT_LABEL_COLON); } } else { cur->SetType(CT_LABEL); next->SetType(CT_LABEL_COLON); } } else if (next->GetFlags().test_any(PCF_IN_STRUCT | PCF_IN_CLASS | PCF_IN_TYPEDEF)) { next->SetType(CT_BIT_COLON); Chunk *nnext = next->GetNext(); if (nnext->IsNullChunk()) { return; } while ((nnext = nnext->GetNext())->IsNotNullChunk()) { if (nnext->Is(CT_SEMICOLON)) { break; } if (nnext->Is(CT_COLON)) { nnext->SetType(CT_BIT_COLON); } } } } else if (nextprev->Is(CT_FPAREN_CLOSE)) { LOG_FMT(LFCN, "%s(%d): nextprev->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, nextprev->Text(), nextprev->GetOrigLine(), nextprev->GetOrigCol(), get_token_name(nextprev->GetType())); LOG_FMT(LFCN, "%s(%d): next->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, next->Text(), next->GetOrigLine(), next->GetOrigCol(), get_token_name(next->GetType())); // Issue #2172 if (next->GetParentType() == CT_FUNC_DEF) { LOG_FMT(LFCN, "%s(%d): it's a construct colon\n", __func__, __LINE__); // it's a construct colon next->SetType(CT_CONSTR_COLON); } else { LOG_FMT(LFCN, "%s(%d): it's a class colon\n", __func__, __LINE__); // it's a class colon next->SetType(CT_CLASS_COLON); } } else if (next->GetLevel() > next->GetBraceLevel()) { // ignore it, as it is inside a paren } else if ( cur->Is(CT_TYPE) || cur->Is(CT_ENUM) // Issue #2584 || nextprev->Is(CT_TYPE) || nextprev->Is(CT_ENUM)) // Issue #2584 { next->SetType(CT_BIT_COLON); } else if ( cur->Is(CT_ENUM) || cur->Is(CT_ACCESS) || cur->Is(CT_QUALIFIER) || cur->GetParentType() == CT_ALIGN) { // ignore it - bit field, align or public/private, etc } else if ( cur->Is(CT_ANGLE_CLOSE) || hit_class) { // ignore it - template thingy } else if (cur->GetParentType() == CT_SQL_EXEC) { // ignore it - SQL variable name } else if (next->GetParentType() == CT_ASSERT) { // ignore it - Java assert thing } else if (next->GetParentType() == CT_STRUCT) { // ignore it } else { Chunk *tmp = next->GetNextNcNnl(); //tmp = chunk_get_next_local(next); if (tmp->IsNotNullChunk()) { LOG_FMT(LFCN, "%s(%d): tmp->Text() is '%s', orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol(), get_token_name(tmp->GetType())); if ( tmp->Is(CT_BASE) || tmp->Is(CT_THIS)) { // ignore it, as it is a C# base thingy } else if (language_is_set(LANG_CS | LANG_D)) { // there should be a better solution for that } else { LOG_FMT(LWARN, "%s(%d): %s:%zu unexpected colon in col %zu n-parent=%s c-parent=%s l=%zu bl=%zu\n", __func__, __LINE__, cpd.filename.c_str(), next->GetOrigLine(), next->GetOrigCol(), get_token_name(next->GetParentType()), get_token_name(cur->GetParentType()), next->GetLevel(), next->GetBraceLevel()); exit(EX_SOFTWARE); } } } } } prev = cur; cur = next; next = chunk_get_next_local(next); } } // combine_labels uncrustify-uncrustify-0.76.0/src/combine_labels.h000066400000000000000000000006411434072136500221340ustar00rootroot00000000000000/** * @file combine_labels.h * * @author Guy Maurel * @license GPL v2+ * extract from combine.h */ #ifndef COMBINE_LABELS_H_INCLUDED #define COMBINE_LABELS_H_INCLUDED /** * Examines the whole file and changes CT_COLON to * CT_Q_COLON, CT_LABEL_COLON, or CT_CASE_COLON. * It also changes the CT_WORD before CT_LABEL_COLON into CT_LABEL. */ void combine_labels(); #endif /* COMBINE_LABELS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/combine_skip.cpp000066400000000000000000000106431434072136500221760ustar00rootroot00000000000000/** * @file combine_skip.cpp * * @author Guy Maurel * @license GPL v2+ * extract from combine.cpp */ #include "combine_skip.h" #include "combine_tools.h" Chunk *skip_align(Chunk *start) { Chunk *pc = start; if (pc->Is(CT_ALIGN)) { pc = pc->GetNextNcNnl(); if (pc->Is(CT_PAREN_OPEN)) { pc = pc->GetNextType(CT_PAREN_CLOSE, pc->GetLevel()); if (pc->IsNotNullChunk()) { pc = pc->GetNextNcNnl(); } if (pc->Is(CT_COLON)) { pc = pc->GetNextNcNnl(); } } } return(pc); } Chunk *skip_expression(Chunk *pc) { return(skip_to_expression_end(pc)->GetNextNcNnl()); } Chunk *skip_expression_rev(Chunk *pc) { return(skip_to_expression_start(pc)->GetPrevNcNnlNi()); } static Chunk *skip_to_expression_edge(Chunk *pc, Chunk *(Chunk::*GetNextFn)(E_Scope scope)const) { Chunk *prev = pc; if (prev == nullptr) { prev = Chunk::NullChunkPtr; } if (prev->IsNotNullChunk()) { std::size_t level = prev->GetLevel(); Chunk *next = prev; std::size_t template_nest = get_cpp_template_angle_nest_level(prev); while ( next->IsNotNullChunk() && next->GetLevel() >= level) { /** * if we encounter a comma or semicolon at the level of the starting chunk, * return the current chunk */ if ( next->GetLevel() == level && ( next->Is(CT_COMMA) || next->IsSemicolon())) { break; } /** * check the template nest level; if the current chunk's nest level * is less than that of the starting chunk, return the current chunk */ auto next_template_nest = get_cpp_template_angle_nest_level(next); if (template_nest > next_template_nest) { break; } prev = next; next = (next->*GetNextFn)(E_Scope::PREPROC); } } return(prev); } Chunk *skip_to_expression_end(Chunk *pc) { return(skip_to_expression_edge(pc, &Chunk::GetNextNcNnl)); } Chunk *skip_to_expression_start(Chunk *pc) { return(skip_to_expression_edge(pc, &Chunk::GetPrevNcNnlNi)); } Chunk *skip_to_next_statement(Chunk *pc) { if (pc == nullptr) { pc = Chunk::NullChunkPtr; } while ( pc->IsNotNullChunk() && !pc->IsSemicolon() && pc->IsNot(CT_BRACE_OPEN) && pc->IsNot(CT_BRACE_CLOSE)) { pc = pc->GetNextNcNnl(); } return(pc); } Chunk *skip_template_prev(Chunk *ang_close) { if (ang_close->Is(CT_ANGLE_CLOSE)) { Chunk *pc = ang_close->GetPrevType(CT_ANGLE_OPEN, ang_close->GetLevel()); return(pc->GetPrevNcNnlNi()); // Issue #2279 } return(ang_close); } Chunk *skip_tsquare_next(Chunk *ary_def) { if (ary_def == nullptr) { return(Chunk::NullChunkPtr); } if ( ary_def->Is(CT_SQUARE_OPEN) || ary_def->Is(CT_TSQUARE)) { return(ary_def->GetNextNisq()); } return(ary_def); } Chunk *skip_attribute(Chunk *attr) { Chunk *pc = attr; while (pc->Is(CT_ATTRIBUTE)) { pc = pc->GetNextNcNnl(); if (pc->Is(CT_FPAREN_OPEN)) { pc = pc->GetNextType(CT_FPAREN_CLOSE, pc->GetLevel()); } } return(pc); } Chunk *skip_attribute_next(Chunk *attr) { Chunk *next = skip_attribute(attr); if ( next != attr && next->Is(CT_FPAREN_CLOSE)) { attr = next->GetNextNcNnl(); } if (attr == nullptr) { return(Chunk::NullChunkPtr); } return(attr); } Chunk *skip_attribute_prev(Chunk *fp_close) { Chunk *pc = fp_close; while (true) { if ( pc->Is(CT_FPAREN_CLOSE) && pc->GetParentType() == CT_ATTRIBUTE) { pc = pc->GetPrevType(CT_ATTRIBUTE, pc->GetLevel()); } else if (pc->IsNot(CT_ATTRIBUTE)) { break; } pc = pc->GetPrevNcNnlNi(); // Issue #2279 if (pc->IsNullChunk()) // Issue #3356 { break; } } return(pc); } Chunk *skip_declspec(Chunk *pc) { if (pc->Is(CT_DECLSPEC)) { pc = pc->GetNextNcNnl(); if (pc->Is(CT_PAREN_OPEN)) { pc = pc->GetClosingParen(); } } return(pc); } Chunk *skip_declspec_next(Chunk *pc) { Chunk *next = skip_declspec(pc); if ( next != pc && next->Is(CT_PAREN_CLOSE)) { pc = next->GetNextNcNnl(); } return(pc); } uncrustify-uncrustify-0.76.0/src/combine_skip.h000066400000000000000000000076771434072136500216600ustar00rootroot00000000000000/** * @file combine_skip.h * * @author Guy Maurel * @license GPL v2+ * extract from combine.cpp */ #ifndef COMBINE_SKIP_H_INCLUDED #define COMBINE_SKIP_H_INCLUDED #include "chunk.h" /** * Skips the D 'align()' statement and the colon, if present. * align(2) int foo; -- returns 'int' * align(4): -- returns 'int' * int bar; */ Chunk *skip_align(Chunk *start); /** * Skips chunks in the forward direction and attempts to find the * chunk associated with the end of the current expression; returns * the first chunk to satisfy one of the following: * 1) Chunk is a comma or semicolon at the level of the starting chunk * 2) Preceding chunk is at higher template nest level relative to the * current chunk under test */ Chunk *skip_expression(Chunk *pc); /** * Skips chunks in the reverse direction and attempts to find the * chunk associated with the start of the current expression; returns * the first chunk to satisfy one of the following: * 1) Chunk is a comma or semicolon at the level of the starting chunk * 2) Preceding chunk is at lower template nest level relative to the * current chunk under test */ Chunk *skip_expression_rev(Chunk *pc); /** * Skips chunks in the forward direction and attempts to find the * chunk associated with the end of the current expression; specifically, * the function returns that which immediately precedes a chunk * satisfying one of the following: * 1) Next chunk is a comma or semicolon at the level of the starting chunk * 2) Preceding chunk is at a higher template nest level relative to the * subsequent chunk */ Chunk *skip_to_expression_end(Chunk *pc); /** * Skips chunks in the reverse direction and attempts to find the chunk * associated with the start of the current expression; specifically, * the function returns that which immediately follows a chunk * satisfying one of the following: * 1) Prior chunk is a comma or semicolon at the level of the starting chunk * 2) Preceding chunk is at a lower template nest level relative to the * subsequent chunk */ Chunk *skip_to_expression_start(Chunk *pc); /** * Skips over the rest of the template if ang_open is indeed a CT_ANGLE_OPEN. * Points to the chunk after the CT_ANGLE_CLOSE. * If the chunk isn't an CT_ANGLE_OPEN, then it is returned. */ Chunk *skip_template_next(Chunk *ang_open); /** * Skips over the rest of the template if ang_close is indeed a CT_ANGLE_CLOSE. * Points to the chunk before the CT_ANGLE_OPEN * If the chunk isn't an CT_ANGLE_CLOSE, then it is returned. */ Chunk *skip_template_prev(Chunk *ang_close); //! Skips to the start of the next statement. Chunk *skip_to_next_statement(Chunk *pc); /** * Skips the rest of the array definitions if ary_def is indeed a * CT_TSQUARE or CT_SQUARE_OPEN */ Chunk *skip_tsquare_next(Chunk *ary_def); /** * If pc is CT_ATTRIBUTE, then skip it and everything preceding the closing * paren; return the chunk marked CT_FPAREN_CLOSE * If the chunk isn't a CT_ATTRIBUTE, then it is returned. */ Chunk *skip_attribute(Chunk *attr); /** * If attr is CT_ATTRIBUTE, then skip it and the parens and return the chunk * after the CT_FPAREN_CLOSE. * If the chunk isn't an CT_ATTRIBUTE, then it is returned. */ Chunk *skip_attribute_next(Chunk *attr); /** * If fp_close is a CT_FPAREN_CLOSE with a parent of CT_ATTRIBUTE, then skip it * and the '__attribute__' thingy and return the chunk before CT_ATTRIBUTE. * Otherwise return fp_close. */ Chunk *skip_attribute_prev(Chunk *fp_close); /** * If pc is CT_DECLSPEC, then skip it and everything preceding the closing * paren; return the chunk marked CT_FPAREN_CLOSE * If the chunk isn't a CT_DECLSPEC, then it is returned. */ Chunk *skip_declspec(Chunk *pc); /** * If pc is CT_DECLSPEC, then skip it and the parens and return the chunk * after the CT_FPAREN_CLOSE. * If the chunk isn't a CT_DECLSPEC, then it is returned. */ Chunk *skip_declspec_next(Chunk *pc); #endif /* COMBINE_SKIP_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/combine_tools.cpp000066400000000000000000000372151434072136500223740ustar00rootroot00000000000000/** * @file combine_tools.cpp * * @author Guy Maurel * @license GPL v2+ * extract from combine.cpp */ #include "combine_tools.h" #include "unc_ctype.h" #include "uncrustify.h" bool can_be_full_param(Chunk *start, Chunk *end) { LOG_FUNC_ENTRY(); LOG_FMT(LFPARAM, "%s(%d): start->Text() is '%s', type is %s\n", __func__, __LINE__, start->Text(), get_token_name(start->GetType())); LOG_FMT(LFPARAM, "%s(%d): end->Text() is '%s', type is %s\n", __func__, __LINE__, end->Text(), get_token_name(end->GetType())); int word_count = 0; int type_count = 0; Chunk *pc = nullptr; Chunk *first_word = nullptr; bool first_word_set = false; for (pc = start; pc != nullptr && pc->IsNotNullChunk() && pc != end; pc = pc->GetNextNcNnl(E_Scope::PREPROC)) { LOG_FMT(LFPARAM, "%s(%d): pc->Text() is '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); if ( pc->Is(CT_QUALIFIER) || pc->Is(CT_STRUCT) || pc->Is(CT_ENUM) || pc->Is(CT_UNION) || pc->Is(CT_TYPENAME)) { LOG_FMT(LFPARAM, "%s(%d): <== %s! (yes)\n", __func__, __LINE__, get_token_name(pc->GetType())); return(true); } if ( pc->Is(CT_WORD) || pc->Is(CT_TYPE)) { ++word_count; if (!first_word_set) { first_word = pc; first_word_set = true; } if (pc->Is(CT_TYPE)) { ++type_count; } } else if ( pc->Is(CT_MEMBER) || pc->Is(CT_DC_MEMBER)) { if (word_count > 0) { --word_count; } } else if ( pc != start && pc->IsPointerOperator()) { // chunk is OK } else if (pc->Is(CT_ASSIGN)) { // chunk is OK (default values) break; } else if (pc->Is(CT_ANGLE_OPEN)) { LOG_FMT(LFPARAM, "%s(%d): <== template\n", __func__, __LINE__); return(true); } else if (pc->Is(CT_ELLIPSIS)) { LOG_FMT(LFPARAM, "%s(%d): <== ellipsis\n", __func__, __LINE__); return(true); } else if ( word_count == 0 && pc->Is(CT_PAREN_OPEN)) { // Check for old-school func proto param '(type)' Chunk *tmp1 = pc->GetClosingParen(E_Scope::PREPROC); if (tmp1->IsNullChunk()) { return(false); } Chunk *tmp2 = tmp1->GetNextNcNnl(E_Scope::PREPROC); if (tmp2->IsNullChunk()) { return(false); } if ( tmp2->Is(CT_COMMA) || tmp2->IsParenClose()) { do { pc = pc->GetNextNcNnl(E_Scope::PREPROC); if (pc->IsNullChunk()) { return(false); } LOG_FMT(LFPARAM, "%s(%d): pc->Text() is '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); } while (pc != tmp1); // reset some vars to allow [] after parens word_count = 1; type_count = 1; } else { LOG_FMT(LFPARAM, "%s(%d): <== '%s' not fcn type!\n", __func__, __LINE__, get_token_name(pc->GetType())); return(false); } } else if ( ( word_count == 1 || (word_count == type_count)) && pc->Is(CT_PAREN_OPEN)) { // Check for func proto param 'void (*name)' or 'void (*name)(params)' or 'void (^name)(params)' // can be optional Chunk *tmp1 = pc->GetNextNcNnl(E_Scope::PREPROC); if (tmp1->IsNullChunk()) { return(false); } Chunk *tmp2 = tmp1->GetNextNcNnl(E_Scope::PREPROC); if (tmp2->Is(CT_QUALIFIER)) { // tmp2 is the "nullable" qualifier in this case: // void (^nullable name)(params) // skip the qualifier tmp2 = tmp2->GetNextNcNnl(E_Scope::PREPROC); } if (tmp2->IsNullChunk()) { return(false); } Chunk *tmp3 = (tmp2->IsString(")")) ? tmp2 : tmp2->GetNextNcNnl(E_Scope::PREPROC); if (tmp3->IsNullChunk()) { return(false); } if ( !tmp3->IsString(")") || !( tmp1->IsString("*") || tmp1->IsString("^")) // Issue #2656 || !( tmp2->GetType() == CT_WORD || tmp2->IsString(")"))) { LOG_FMT(LFPARAM, "%s(%d): <== '%s' not fcn type!\n", __func__, __LINE__, get_token_name(pc->GetType())); return(false); } LOG_FMT(LFPARAM, "%s(%d): \n", __func__, __LINE__); tmp1 = tmp3->GetNextNcNnl(E_Scope::PREPROC); if (tmp1->IsNullChunk()) { return(false); } if (tmp1->IsString("(")) { tmp3 = tmp1->GetClosingParen(E_Scope::PREPROC); } pc = tmp3; LOG_FMT(LFPARAM, "%s(%d): pc->Text() is '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); // reset some vars to allow [] after parens word_count = 1; type_count = 1; } else if (pc->Is(CT_TSQUARE)) { // ignore it } else if ( word_count == 1 && pc->Is(CT_SQUARE_OPEN)) { // skip over any array stuff pc = pc->GetClosingParen(E_Scope::PREPROC); LOG_FMT(LFPARAM, "%s(%d): pc->Text() is '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); } else if ( word_count == 2 && pc->Is(CT_SQUARE_OPEN)) { // Bug #671: is it such as: bool foo[FOO_MAX] pc = pc->GetClosingParen(E_Scope::PREPROC); LOG_FMT(LFPARAM, "%s(%d): pc->Text() is '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); } else if ( word_count == 1 && language_is_set(LANG_CPP) && pc->IsString("&&")) { // ignore possible 'move' operator } else { LOG_FMT(LFPARAM, "%s(%d): <== type is %s, no way!, type count is %d, word count is %d\n", __func__, __LINE__, get_token_name(pc->GetType()), type_count, word_count); return(false); } LOG_FMT(LFPARAM, "%s(%d): pc->Text() is '%s', type is %s\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType())); } Chunk *last = pc->GetPrevNcNnlNi(); // Issue #2279 LOG_FMT(LFPARAM, "%s(%d): last->Text() is '%s', type is %s\n", __func__, __LINE__, last->Text(), get_token_name(last->GetType())); if (last->IsPointerOperator()) { LOG_FMT(LFPARAM, "%s(%d): <== type is %s, sure!\n", __func__, __LINE__, get_token_name(last->GetType())); return(true); } if ( word_count < 2 && type_count < 1 && start->GetBraceLevel() > 0) { LOG_FMT(LFPARAM, "%s(%d): !MVP!\n", __func__, __LINE__); // Oh, joy, we are in Most Vexing Parse territory Chunk *brace = start->GetPrevType(CT_BRACE_OPEN, start->GetBraceLevel() - 1); if (brace->IsNotNullChunk()) { LOG_FMT(LFPARAM, "%s(%d): (matching %s brace at orig line %zu, orig col is %zu)", __func__, __LINE__, get_token_name(brace->GetParentType()), brace->GetOrigLine(), brace->GetOrigCol()); } if ( brace->IsNotNullChunk() && ( brace->GetParentType() == CT_CLASS || brace->GetParentType() == CT_STRUCT)) { // A Most Vexing Parse variable declaration cannot occur in the body // of a struct/class, so we probably have a function prototype LOG_FMT(LFPARAM, "%s(%d): <== type is %s, Likely!\n", __func__, __LINE__, (pc == nullptr ? "nullptr" : get_token_name(pc->GetType()))); return(true); } } LOG_FMT(LFPARAM, "%s(%d): pc->Text() is '%s', word_count is %d, type_count is %d\n", __func__, __LINE__, pc->Text(), word_count, type_count); if ( first_word != nullptr && first_word->IsNotNullChunk()) { LOG_FMT(LFPARAM, "%s(%d): first_word->Text() is '%s'\n", __func__, __LINE__, first_word->Text()); } bool ret = ( word_count >= 2 || ( word_count == 1 && type_count == 1)); LOG_FMT(LFPARAM, "%s(%d): ret is %s\n", __func__, __LINE__, ret ? "TRUE" : "FALSE"); LOG_FMT(LFPARAM, "%s(%d): pc->Text() is '%s', ", __func__, __LINE__, pc->Text()); LOG_FMT(LFPARAM, "<== type is %s, ", (pc == nullptr ? "nullptr" : get_token_name(pc->GetType()))); if (ret) { LOG_FMT(LFPARAM, "Yup!\n"); } else { LOG_FMT(LFPARAM, "Unlikely!\n"); } return(ret); } // can_be_full_param bool chunk_ends_type(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *pc = start; bool ret = false; size_t cnt = 0; bool last_expr = false; bool last_lval = false; bool a = pc->TestFlags(PCF_IN_FCN_CTOR); if (a) { return(false); } for ( ; pc->IsNotNullChunk(); pc = pc->GetPrevNcNnlNi()) // Issue #2279 { LOG_FMT(LFTYPE, "%s(%d): type is %s, Text() '%s', orig line %zu, orig col %zu\n ", __func__, __LINE__, get_token_name(pc->GetType()), pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); log_pcf_flags(LFTYPE, pc->GetFlags()); if ( pc->Is(CT_WORD) || pc->Is(CT_TYPE) || pc->Is(CT_PTR_TYPE) || pc->Is(CT_STAR) || pc->Is(CT_STRUCT) || pc->Is(CT_DC_MEMBER) || pc->Is(CT_PP) || pc->Is(CT_QUALIFIER) || ( language_is_set(LANG_CPP | LANG_OC) // Issue #2727 && pc->GetParentType() == CT_TEMPLATE && ( pc->Is(CT_ANGLE_OPEN) || pc->Is(CT_ANGLE_CLOSE))) || ( language_is_set(LANG_CS | LANG_VALA) && (pc->Is(CT_MEMBER)))) { cnt++; last_expr = pc->TestFlags(PCF_EXPR_START) && !pc->TestFlags(PCF_IN_FCN_CALL); last_lval = pc->TestFlags(PCF_LVALUE); continue; } /* If a comma is encountered within a template, it must be * considered within the context of its immediate parent * template (i.e. argument list nest level) */ if ( ( pc->IsSemicolon() && !pc->TestFlags(PCF_IN_FOR)) || pc->Is(CT_TYPEDEF) || pc->Is(CT_BRACE_OPEN) || pc->IsBraceClose() || pc->Is(CT_FPAREN_CLOSE) || pc->IsOCForinOpenParen() || pc->Is(CT_MACRO) || pc->Is(CT_PP_IF) || pc->Is(CT_PP_ELSE) || pc->Is(CT_PP_ENDIF) || pc->GetParentType() == CT_PP_INCLUDE // Issue #3233 || ( ( pc->Is(CT_COMMA) && !pc->TestFlags(PCF_IN_FCN_CALL) && get_cpp_template_angle_nest_level(start) == get_cpp_template_angle_nest_level(pc)) && last_expr) || ( pc->Is(CT_SPAREN_OPEN) && last_lval)) { ret = cnt > 0; } break; } if (pc->IsNullChunk()) { // first token ret = true; } LOG_FMT(LFTYPE, "%s(%d): first token verdict: %s\n", __func__, __LINE__, ret ? "yes" : "no"); return(ret); } // chunk_ends_type bool chunkstack_match(ChunkStack &cs, Chunk *pc) { for (size_t idx = 0; idx < cs.Len(); idx++) { Chunk *tmp = cs.GetChunk(idx); if (pc->GetStr().equals(tmp->GetStr())) { return(true); } } return(false); } // chunkstack_match void flag_series(Chunk *start, Chunk *end, T_PcfFlags set_flags, T_PcfFlags clr_flags, E_Scope nav) { LOG_FUNC_ENTRY(); while ( start != nullptr && start->IsNotNullChunk() && start != end) { start->UpdateFlagBits(clr_flags, set_flags); log_pcf_flags(LGUY, start->GetFlags()); start = start->GetNext(nav); if (start->IsNullChunk()) { return; } } if ( end != nullptr && end->IsNotNullChunk()) { end->UpdateFlagBits(clr_flags, set_flags); log_pcf_flags(LGUY, end->GetFlags()); } } // flag_series size_t get_cpp_template_angle_nest_level(Chunk *pc) { LOG_FUNC_ENTRY(); int nestLevel = 0; if (pc == nullptr) { pc = Chunk::NullChunkPtr; } while ( pc->IsNotNullChunk() && pc->TestFlags(PCF_IN_TEMPLATE)) { if ( pc->Is(CT_ANGLE_CLOSE) && pc->GetParentType() == CT_TEMPLATE) { --nestLevel; } else if ( pc->Is(CT_ANGLE_OPEN) && pc->GetParentType() == CT_TEMPLATE) { ++nestLevel; } pc = pc->GetPrevNcNnlNi(); } return(nestLevel <= 0 ? 0 : size_t(nestLevel)); } Chunk *get_d_template_types(ChunkStack &cs, Chunk *open_paren) { LOG_FUNC_ENTRY(); Chunk *tmp = open_paren->GetNextNcNnl(); bool maybe_type = true; while ( tmp->IsNullChunk() && tmp->GetLevel() > open_paren->GetLevel()) { if ( tmp->Is(CT_TYPE) || tmp->Is(CT_WORD)) { if (maybe_type) { make_type(tmp); cs.Push_Back(tmp); } maybe_type = false; } else if (tmp->Is(CT_COMMA)) { maybe_type = true; } tmp = tmp->GetNextNcNnl(); } return(tmp); } // get_d_template_types bool go_on(Chunk *pc, Chunk *start) { if ( pc == nullptr || pc->IsNullChunk() || pc->GetLevel() != start->GetLevel()) { return(false); } if (pc->TestFlags(PCF_IN_FOR)) { return( (!pc->IsSemicolon()) && (!(pc->Is(CT_COLON)))); } return(!pc->IsSemicolon()); } // go_on bool is_ucase_str(const char *str, size_t len) { while (len-- > 0) { if (unc_toupper(*str) != *str) { return(false); } str++; } return(true); } // is_ucase_str void make_type(Chunk *pc) { LOG_FUNC_ENTRY(); if ( pc != nullptr && pc->IsNotNullChunk()) { if (pc->Is(CT_WORD)) { pc->SetType(CT_TYPE); } else if ( ( pc->IsStar() || pc->IsMsRef() || pc->IsNullable()) && pc->GetPrev()->IsTypeDefinition()) // Issue # 2640 { pc->SetType(CT_PTR_TYPE); } else if ( pc->IsAddress() && pc->GetPrev()->IsNot(CT_SQUARE_OPEN)) // Issue # 2166 { pc->SetType(CT_BYREF); } } } // make_type Chunk *set_paren_parent(Chunk *start, E_Token parent_type) { LOG_FUNC_ENTRY(); Chunk *end; end = start->GetClosingParen(E_Scope::PREPROC); if (end->IsNotNullChunk()) { LOG_FMT(LFLPAREN, "%s(%d): %zu:%zu '%s' and %zu:%zu '%s' type is %s, parent type is %s", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol(), start->Text(), end->GetOrigLine(), end->GetOrigCol(), end->Text(), get_token_name(start->GetType()), get_token_name(parent_type)); log_func_stack_inline(LFLPAREN); start->SetParentType(parent_type); end->SetParentType(parent_type); LOG_FMT(LFLPAREN, "%s(%d):\n", __func__, __LINE__); return(end->GetNextNcNnl(E_Scope::PREPROC)); } LOG_FMT(LFLPAREN, "%s(%d):\n", __func__, __LINE__); return(nullptr); } // set_paren_parent uncrustify-uncrustify-0.76.0/src/combine_tools.h000066400000000000000000000037531434072136500220410ustar00rootroot00000000000000/** * @file combine_tools.h * * @author Guy Maurel * @license GPL v2+ * extract from combine.cpp */ #ifndef COMBINE_TOOLS_H_INCLUDED #define COMBINE_TOOLS_H_INCLUDED #include "chunk.h" #include "ChunkStack.h" /** * Checks to see if a series of chunks could be a C++ parameter * FOO foo(5, &val); * * WORD means CT_WORD or CT_TYPE * * "WORD WORD" ==> true * "QUALIFIER ??" ==> true * "TYPE" ==> true * "WORD" ==> true * "WORD.WORD" ==> true * "WORD::WORD" ==> true * "WORD * WORD" ==> true * "WORD & WORD" ==> true * "NUMBER" ==> false * "STRING" ==> false * "OPEN PAREN" ==> false * * @param start the first chunk to look at * @param end the chunk after the last one to look at */ bool can_be_full_param(Chunk *start, Chunk *end); //! Scan backwards to see if we might be on a type declaration bool chunk_ends_type(Chunk *start); bool chunkstack_match(ChunkStack &cs, Chunk *pc); ///** // * Simply change any STAR to PTR_TYPE and WORD to TYPE // * // * @param start points to the open paren // */ void fix_fcn_def_params(Chunk *pc); void flag_series(Chunk *start, Chunk *end, T_PcfFlags set_flags, T_PcfFlags clr_flags = {}, E_Scope nav = E_Scope::ALL); /* * Checks whether or not a given chunk has a parent cpp template, * and if so returns the associated angle bracket nest level * with respect to the root parent template; returns 0 if * the chunk is not part of a template parameter list */ size_t get_cpp_template_angle_nest_level(Chunk *pc); /** * Parse off the types in the D template args, adds to cs * returns the close_paren */ Chunk *get_d_template_types(ChunkStack &cs, Chunk *open_paren); //! help function for mark_variable_definition... bool go_on(Chunk *pc, Chunk *start); bool is_ucase_str(const char *str, size_t len); void make_type(Chunk *pc); Chunk *set_paren_parent(Chunk *start, E_Token parent); #endif /* COMBINE_TOOLS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/compat.h000066400000000000000000000007021434072136500204570ustar00rootroot00000000000000/** * @file compat.h * prototypes for compat_xxx.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef COMPAT_H_INCLUDED #define COMPAT_H_INCLUDED #include "uncrustify_types.h" bool unc_getenv(const char *name, std::string &str); bool unc_homedir(std::string &home); /* * even if we prefer the format %zu, we have to change to %lu * to be runable under Windows */ void convert_log_zu2lu(char *buf); #endif /* COMPAT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/compat_posix.cpp000066400000000000000000000010201434072136500222260ustar00rootroot00000000000000/** * @file compat_posix.cpp * Compatibility functions for POSIX * * @author Ben Gardner * @license GPL v2+ */ #ifndef WIN32 #include "uncrustify_types.h" bool unc_getenv(const char *name, std::string &str) { const char *val = getenv(name); if (val != nullptr) { str = val; return(true); } return(false); } bool unc_homedir(std::string &home) { return(unc_getenv("HOME", home)); } void convert_log_zu2lu(char *fmt) { UNUSED(fmt); // nothing to do } #endif /* ifndef WIN32 */ uncrustify-uncrustify-0.76.0/src/compat_win32.cpp000066400000000000000000000025261434072136500220420ustar00rootroot00000000000000/** * @file compat_win32.cpp * Compatibility functions for win32 * * @author Ben Gardner * @license GPL v2+ */ #if defined (_WIN32) \ && !defined (__CYGWIN__) #include "windows_compat.h" #include #include bool unc_getenv(const char *name, std::string &str) { DWORD len = GetEnvironmentVariableA(name, NULL, 0); char *buf; if (len == 0) { if (GetLastError() == ERROR_ENVVAR_NOT_FOUND) { return(false); } } buf = (char *)malloc(len); if (buf) { len = GetEnvironmentVariableA(name, buf, len); } buf[len] = 0; str = buf; //printf("%s: name=%s len=%zu value=%s\n", __func__, name, len, str.c_str()); free(buf); return(true); } bool unc_homedir(std::string &home) { if (unc_getenv("HOME", home)) { return(true); } if (unc_getenv("USERPROFILE", home)) { return(true); } std::string hd, hp; if ( unc_getenv("HOMEDRIVE", hd) && unc_getenv("HOMEPATH", hp)) { home = hd + hp; return(true); } return(false); } void convert_log_zu2lu(char *fmt) { for (size_t i = 0; i < strlen(fmt); i++) { if ( (fmt[i] == '%') && (fmt[i + 1] == 'z') && (fmt[i + 2] == 'u')) { fmt[i + 1] = 'l'; } } } #endif /* if defined(_WIN32) && !defined(__CYGWIN__) */ uncrustify-uncrustify-0.76.0/src/config.h.in000066400000000000000000000053501434072136500210520ustar00rootroot00000000000000// Used by CMake to generate config.h. // Define to 1 if you have the header file. #cmakedefine HAVE_INTTYPES_H 1 // Define to 1 if you have the header file. #cmakedefine HAVE_MEMORY_H 1 // Define to 1 if you have the `memset' function. #cmakedefine HAVE_MEMSET 1 // Define to 1 if stdbool.h conforms to C99. #cmakedefine HAVE_STDBOOL_H 1 // Define to 1 if you have the header file. #cmakedefine HAVE_STDINT_H 1 // Define to 1 if you have the header file. #cmakedefine HAVE_STDLIB_H 1 // Define to 1 if you have the `strcasecmp' function. #cmakedefine HAVE_STRCASECMP 1 // Define to 1 if you have the `strchr' function. #cmakedefine HAVE_STRCHR 1 // Define to 1 if you have the `strdup' function. #cmakedefine HAVE_STRDUP 1 // Define to 1 if you have the `strerror' function. #cmakedefine HAVE_STRERROR 1 // Define to 1 if you have the header file. #cmakedefine HAVE_STRINGS_H 1 // Define to 1 if you have the header file. #cmakedefine HAVE_STRING_H 1 // Define to 1 if you have the `strtol' function. #cmakedefine HAVE_STRTOL 1 // Define to 1 if you have the `strtoul' function. #cmakedefine HAVE_STRTOUL 1 // Define to 1 if you have the header file. #cmakedefine HAVE_SYS_STAT_H 1 // Define to 1 if you have the header file. #cmakedefine HAVE_SYS_TYPES_H 1 // Define to 1 if you have the header file. #cmakedefine HAVE_UNISTD_H 1 // Define to 1 if you have the header file. #cmakedefine HAVE_UTIME_H 1 // Define to 1 if the system has the type `_Bool'. #cmakedefine HAVE__BOOL 1 // Name of package #cmakedefine PACKAGE "@PACKAGE@" // Define to the address where bug reports for this package should be sent. #cmakedefine PACKAGE_BUGREPORT "@PACKAGE_BUGREPORT@" // Define to the full name of this package. #cmakedefine PACKAGE_NAME "@PACKAGE_NAME@" // Define to the full name and version of this package. #cmakedefine PACKAGE_STRING "@PACKAGE_STRING@" // Define to the one symbol short name of this package. #cmakedefine PACKAGE_TARNAME "@PACKAGE_TARNAME@" // Define to the home page for this package. #cmakedefine PACKAGE_URL "@PACKAGE_URL@" // Define to the version of this package. #cmakedefine PACKAGE_VERSION "@PACKAGE_VERSION@" // Define to 1 if you have the ANSI C header files. #cmakedefine STDC_HEADERS 1 // Version number of package #cmakedefine VERSION "@VERSION@" /* Define to appropriate substitute if compiler doesn't have __func__ */ /* #undef __func__ */ /* Define to empty if `const' does not conform to ANSI C. */ /* #undef const */ /* Define to `__inline__' or `__inline' if that's what the C compiler * calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef __cplusplus /* #undef inline */ #endif uncrustify-uncrustify-0.76.0/src/cs_top_is_question.cpp000066400000000000000000000005541434072136500234450ustar00rootroot00000000000000/** * @file cs_top_is_question.cpp * * @author Guy Maurel * @license GPL v2+ * extract from combine.cpp */ #include "cs_top_is_question.h" #include "chunk.h" bool cs_top_is_question(ChunkStack &cs, size_t level) { Chunk *pc = cs.Empty() ? Chunk::NullChunkPtr : cs.Top()->m_pc; return( pc->Is(CT_QUESTION) && pc->GetLevel() == level); } uncrustify-uncrustify-0.76.0/src/cs_top_is_question.h000066400000000000000000000004741434072136500231130ustar00rootroot00000000000000/** * @file cs_top_is_question.h * * @author Guy Maurel * @license GPL v2+ * extract from combine.cpp */ #ifndef CS_TOP_IS_QUESTION_H_INCLUDED #define CS_TOP_IS_QUESTION_H_INCLUDED #include "ChunkStack.h" bool cs_top_is_question(ChunkStack &cs, size_t level); #endif /* CS_TOP_IS_QUESTION_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/detect.cpp000066400000000000000000000235461434072136500210120ustar00rootroot00000000000000/** * @file detect.cpp * Scans the parsed file and tries to determine options. * * @author Ben Gardner * @license GPL v2+ */ #include "detect.h" #include "prototypes.h" using namespace uncrustify; //! Detect spacing options static void detect_space_options(); class sp_votes { protected: size_t m_add = 0; size_t m_remove = 0; size_t m_force = 0; Option &m_option; public: sp_votes(Option &opt) : m_option(opt) {} //! Figure out the result of the vote and maybe update *m_av ~sp_votes(); void vote(Chunk *first, Chunk *second); }; void sp_votes::vote(Chunk *first, Chunk *second) { if ( first == nullptr || first->IsNewline() || second == nullptr || second->IsNewline()) { return; } int col_dif = second->GetColumn() - (first->GetColumn() + first->Len()); if (col_dif == 0) { m_remove++; } else if (col_dif == 1) { m_force++; } else { m_add++; } } //! Figure out the result of the vote and maybe update *m_av sp_votes::~sp_votes() { // no change if no items were added if ( m_remove == 0 && m_add == 0 && m_force == 0) { return; } if (m_remove == 0) { m_option = (m_force > m_add) ? IARF_FORCE : IARF_ADD; } else if ( m_force == 0 && m_add == 0) { m_option = IARF_REMOVE; } else { // nothing conclusive. do not alter. } } // generates "vote_sp_xxx" variable name from uncrustify option name "UO_xxx" #define SP_VOTE_VAR(x) sp_votes vote_ ## x(options::x) static void detect_space_options() { SP_VOTE_VAR(sp_arith); SP_VOTE_VAR(sp_before_assign); SP_VOTE_VAR(sp_after_assign); SP_VOTE_VAR(sp_enum_before_assign); SP_VOTE_VAR(sp_enum_after_assign); SP_VOTE_VAR(sp_bool); SP_VOTE_VAR(sp_compare); SP_VOTE_VAR(sp_inside_paren); SP_VOTE_VAR(sp_paren_paren); SP_VOTE_VAR(sp_paren_brace); SP_VOTE_VAR(sp_before_ptr_star); SP_VOTE_VAR(sp_before_unnamed_ptr_star); SP_VOTE_VAR(sp_between_ptr_star); SP_VOTE_VAR(sp_after_ptr_star); SP_VOTE_VAR(sp_after_byref); SP_VOTE_VAR(sp_before_byref); SP_VOTE_VAR(sp_before_unnamed_byref); SP_VOTE_VAR(sp_after_type); SP_VOTE_VAR(sp_template_angle); SP_VOTE_VAR(sp_before_angle); SP_VOTE_VAR(sp_inside_angle); SP_VOTE_VAR(sp_after_angle); SP_VOTE_VAR(sp_angle_paren); SP_VOTE_VAR(sp_angle_word); SP_VOTE_VAR(sp_before_square); SP_VOTE_VAR(sp_before_squares); SP_VOTE_VAR(sp_inside_square); SP_VOTE_VAR(sp_before_sparen); SP_VOTE_VAR(sp_inside_sparen); SP_VOTE_VAR(sp_after_sparen); SP_VOTE_VAR(sp_sparen_brace); SP_VOTE_VAR(sp_special_semi); SP_VOTE_VAR(sp_before_semi); SP_VOTE_VAR(sp_before_semi_for); SP_VOTE_VAR(sp_before_semi_for_empty); SP_VOTE_VAR(sp_after_semi_for_empty); SP_VOTE_VAR(sp_after_comma); SP_VOTE_VAR(sp_before_comma); SP_VOTE_VAR(sp_after_class_colon); SP_VOTE_VAR(sp_before_class_colon); SP_VOTE_VAR(sp_inside_braces); SP_VOTE_VAR(sp_inside_braces_empty); SP_VOTE_VAR(sp_else_brace); SP_VOTE_VAR(sp_brace_else); SP_VOTE_VAR(sp_catch_brace); SP_VOTE_VAR(sp_brace_catch); SP_VOTE_VAR(sp_finally_brace); SP_VOTE_VAR(sp_brace_finally); SP_VOTE_VAR(sp_try_brace); SP_VOTE_VAR(sp_getset_brace); Chunk *prev = Chunk::GetHead(); Chunk *pc = prev->GetNext(); Chunk *next; while (pc->IsNotNullChunk()) { next = pc->GetNext(); if (next->IsNullChunk()) { break; } if ( pc->Is(CT_ARITH) || pc->Is(CT_SHIFT)) { vote_sp_arith.vote(pc, next); vote_sp_arith.vote(prev, pc); } if (pc->Is(CT_ASSIGN)) { if (!pc->TestFlags(PCF_IN_ENUM)) { vote_sp_before_assign.vote(prev, pc); vote_sp_after_assign.vote(pc, next); } else { vote_sp_enum_before_assign.vote(prev, pc); vote_sp_enum_after_assign.vote(pc, next); } } if (pc->Is(CT_SQUARE_OPEN)) { vote_sp_before_square.vote(prev, pc); vote_sp_inside_square.vote(pc, next); } if (pc->Is(CT_SQUARE_CLOSE)) { vote_sp_inside_square.vote(prev, pc); } if (pc->Is(CT_TSQUARE)) { vote_sp_before_squares.vote(prev, pc); } if (pc->Is(CT_BOOL)) { vote_sp_bool.vote(prev, pc); vote_sp_bool.vote(pc, next); } if (pc->Is(CT_COMPARE)) { vote_sp_compare.vote(prev, pc); vote_sp_compare.vote(pc, next); } if (pc->Is(CT_PAREN_CLOSE)) { vote_sp_inside_paren.vote(prev, pc); } if (pc->Is(CT_PAREN_OPEN)) { vote_sp_inside_paren.vote(pc, next); } if ( ( pc->IsParenOpen() && next->IsParenOpen()) || ( pc->IsParenClose() && next->IsParenClose())) { vote_sp_paren_paren.vote(pc, next); } if ( pc->IsParenClose() && next->Is(CT_BRACE_OPEN)) { vote_sp_paren_brace.vote(pc, next); } if (pc->Is(CT_PTR_TYPE)) { if (prev->Is(CT_PTR_TYPE)) { vote_sp_between_ptr_star.vote(prev, pc); } else if (next->IsNot(CT_WORD)) { vote_sp_before_unnamed_ptr_star.vote(prev, pc); } else { vote_sp_before_ptr_star.vote(prev, pc); } if (CharTable::IsKw1(next->GetStr()[0])) { vote_sp_after_ptr_star.vote(pc, next); } } if (pc->Is(CT_BYREF)) { if (next->IsNot(CT_WORD)) { vote_sp_before_unnamed_byref.vote(prev, pc); } else { vote_sp_before_byref.vote(prev, pc); } vote_sp_after_byref.vote(pc, next); } if ( pc->IsNot(CT_PTR_TYPE) && ( prev->Is(CT_QUALIFIER) || prev->Is(CT_TYPE))) { vote_sp_after_type.vote(prev, pc); } if (pc->Is(CT_ANGLE_OPEN)) { vote_sp_inside_angle.vote(pc, next); if (prev->Is(CT_TEMPLATE)) { vote_sp_template_angle.vote(prev, pc); } else { vote_sp_before_angle.vote(prev, pc); } } if (pc->Is(CT_ANGLE_CLOSE)) { vote_sp_inside_angle.vote(prev, pc); if (next->IsParenOpen()) { vote_sp_angle_paren.vote(prev, pc); } else if ( next->Is(CT_WORD) || CharTable::IsKw1(next->GetStr()[0])) { vote_sp_angle_word.vote(prev, pc); } else { vote_sp_after_angle.vote(pc, next); } } if (pc->Is(CT_SPAREN_OPEN)) { vote_sp_before_sparen.vote(prev, pc); vote_sp_inside_sparen.vote(pc, next); } if (pc->Is(CT_SPAREN_CLOSE)) { vote_sp_inside_sparen.vote(prev, pc); if (next->Is(CT_BRACE_OPEN)) { vote_sp_sparen_brace.vote(pc, next); } else { vote_sp_after_sparen.vote(pc, next); } } if (pc->Is(CT_SEMICOLON)) { if (pc->GetParentType() == CT_FOR) { if (prev->Is(CT_SPAREN_OPEN)) { // empty, ie for (;;) // ^ is prev // ^ is pc vote_sp_before_semi_for_empty.vote(prev, pc); } else if (next->Is(CT_SPAREN_CLOSE)) { // empty, ie for (;;) // ^ is pc // ^ is next vote_sp_after_semi_for_empty.vote(pc, next); } else if (prev->IsNot(CT_SEMICOLON)) { // empty, ie for (; i < 8;) // ^ is pc // or // ^ is prev vote_sp_before_semi_for.vote(prev, pc); } } else if (prev->Is(CT_VBRACE_OPEN)) { vote_sp_special_semi.vote(prev->GetPrev(), pc); } else { vote_sp_before_semi.vote(prev, pc); } } if (pc->Is(CT_COMMA)) { vote_sp_before_comma.vote(prev, pc); vote_sp_after_comma.vote(pc, next); } if (pc->Is(CT_CLASS_COLON)) { vote_sp_before_class_colon.vote(prev, pc); vote_sp_after_class_colon.vote(pc, next); } if (pc->Is(CT_BRACE_OPEN)) { if (prev->Is(CT_ELSE)) { vote_sp_else_brace.vote(prev, pc); } else if (prev->Is(CT_CATCH)) { vote_sp_catch_brace.vote(prev, pc); } else if (prev->Is(CT_FINALLY)) { vote_sp_catch_brace.vote(prev, pc); } else if (prev->Is(CT_TRY)) { vote_sp_catch_brace.vote(prev, pc); } else if (prev->Is(CT_GETSET)) { vote_sp_catch_brace.vote(prev, pc); } if (next->Is(CT_BRACE_CLOSE)) { vote_sp_inside_braces_empty.vote(pc, next); } else { vote_sp_inside_braces.vote(pc, next); } } if (pc->Is(CT_BRACE_CLOSE)) { vote_sp_inside_braces.vote(prev, pc); if (next->Is(CT_ELSE)) { vote_sp_brace_else.vote(pc, next); } else if (next->Is(CT_CATCH)) { vote_sp_brace_catch.vote(pc, next); } else if (next->Is(CT_FINALLY)) { vote_sp_brace_finally.vote(pc, next); } } prev = pc; pc = next; } } // detect_space_options void detect_options() { detect_space_options(); } uncrustify-uncrustify-0.76.0/src/detect.h000066400000000000000000000003731434072136500204500ustar00rootroot00000000000000/** * @file detect.h * prototypes for detect.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef DETECT_H_INCLUDED #define DETECT_H_INCLUDED //! Call all the detect_xxxx() functions void detect_options(); #endif /* DETECT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/enum_cleanup.cpp000066400000000000000000000051741434072136500222120ustar00rootroot00000000000000/** * @file enum_cleanup.cpp * works on the last comma within enum * * @author Guy Maurel Juli 2018 * @license GPL v2+ */ #include "enum_cleanup.h" #include "log_rules.h" constexpr static auto LCURRENT = LTOK; using namespace uncrustify; void enum_cleanup() { LOG_FUNC_ENTRY(); log_rule_B("mod_enum_last_comma"); if (options::mod_enum_last_comma() == IARF_IGNORE) { // nothing to do return; } Chunk *pc = Chunk::GetHead(); // Issue #858 while (pc->IsNotNullChunk()) { if ( pc->GetParentType() == CT_ENUM && pc->Is(CT_BRACE_CLOSE)) { LOG_FMT(LTOK, "%s(%d): orig line is %zu, type is %s\n", __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetType())); Chunk *prev = pc->GetPrevNcNnl(); // Issue #3604 if ( prev != nullptr && prev->IsNotNullChunk()) { if (prev->Is(CT_COMMA)) { log_rule_B("mod_enum_last_comma"); if (options::mod_enum_last_comma() == IARF_REMOVE) { Chunk::Delete(prev); } } else { if (prev->Is(CT_BRACE_OPEN)) // Issue #2902 { // nothing between CT_BRACE_OPEN and CT_BRACE_CLOSE } else { log_rule_B("mod_enum_last_comma"); if ( options::mod_enum_last_comma() == IARF_ADD || options::mod_enum_last_comma() == IARF_FORCE) { // create a comma Chunk comma; comma.SetType(CT_COMMA); comma.SetOrigLine(prev->GetOrigLine()); comma.SetOrigCol(prev->GetOrigCol() + 1); comma.SetNlCount(0); comma.SetPpLevel(0); comma.SetFlags(PCF_NONE); comma.Str() = ","; if (prev->Is(CT_PP_ENDIF)) // Issue #3604 { prev = prev->GetPrevNcNnlNpp(); } if (prev->Is(CT_COMMA)) // Issue #3604 { // nothing to do } else { comma.CopyAndAddAfter(prev); } pc = pc->GetNext(); } } } } } pc = pc->GetNext(); } } // enum_cleanup uncrustify-uncrustify-0.76.0/src/enum_cleanup.h000066400000000000000000000004631434072136500216530ustar00rootroot00000000000000/** * @file enum_cleanup.h * * @author Guy Maurel Juli 2018 * @license GPL v2+ */ #ifndef ENUM_CLEANUP_H_INCLUDED #define ENUM_CLEANUP_H_INCLUDED /** * Scans through the whole list and does stuff. * works on the last comma within enum */ void enum_cleanup(); #endif /* ENUM_CLEANUP_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/enum_flags.h000066400000000000000000000074171434072136500213260ustar00rootroot00000000000000/** * @file enum_flags.h * Operators for working with bit-flag enumerators. * * @author Matthew Woehlke (but mostly "borrowed" from Qt) * @license GPL v2+ */ #ifndef ENUM_FLAGS_H_INCLUDED #define ENUM_FLAGS_H_INCLUDED #include #if __GNUC__ == 4 && !defined (__clang__) #pragma GCC diagnostic push #if __GNUC_MINOR__ < 9 || __GNUC_PATCHLEVEL__ < 2 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59624 #pragma GCC diagnostic ignored "-Wunused-but-set-parameter" #endif #endif #define UNC_DECLARE_FLAGS(flag_type, enum_type) \ using flag_type = ::uncrustify::flags #define UNC_DECLARE_OPERATORS_FOR_FLAGS(flag_type) \ inline flag_type operator&(flag_type::enum_t f1, flag_type::enum_t f2) \ { return(flag_type{ f1 } &f2); } \ inline flag_type operator|(flag_type::enum_t f1, flag_type::enum_t f2) \ { return(flag_type{ f1 } | f2); } \ inline flag_type operator|(flag_type::enum_t f1, flag_type f2) \ { return(f2 | f1); } \ inline void operator|(flag_type::enum_t f1, int f2) = delete namespace uncrustify { //----------------------------------------------------------------------------- template class flags { public: using enum_t = Enum; using int_t = typename std::underlying_type::type; template using integral = typename std::enable_if::value, bool>::type; inline flags() = default; inline flags(Enum flag) : m_i{static_cast(flag)} {} inline bool operator==(Enum const &other) { return(m_i == static_cast(other)); } inline bool operator==(flags const &other) { return(m_i == other.m_i); } inline bool operator!=(Enum const &other) { return(m_i != static_cast(other)); } inline bool operator!=(flags const &other) { return(m_i != other.m_i); } template = true> inline flags &operator&=(T mask) { m_i &= static_cast(mask); return(*this); } inline flags &operator|=(flags f) { m_i |= f.m_i; return(*this); } inline flags &operator|=(Enum f) { m_i |= f; return(*this); } inline flags &operator^=(flags f) { m_i ^= f.m_i; return(*this); } inline flags &operator^=(Enum f) { m_i ^= f; return(*this); } inline operator int_t() const { return(m_i); } inline operator enum_t() const { return(static_cast(m_i)); } inline flags operator&(Enum f) const { flags g; g.m_i = m_i & static_cast(f); return(g); } inline flags operator&(flags f) const { flags g; g.m_i = m_i & static_cast(f); return(g); } template = true> inline flags operator&(T mask) const { flags g; g.m_i = m_i & static_cast(mask); return(g); } inline flags operator|(flags f) const { flags g; g.m_i = m_i | f.m_i; return(g); } inline flags operator|(Enum f) const { flags g; g.m_i = m_i | static_cast(f); return(g); } inline flags operator^(flags f) const { flags g; g.m_i = m_i ^ f.m_i; return(g); } inline flags operator^(Enum f) const { flags g; g.m_i = m_i ^ static_cast(f); return(g); } inline int_t operator~() const { return(~m_i); } inline operator bool() const { return(!!m_i); } inline bool operator!() const { return(!m_i); } inline bool test(flags f) const { return((*this & f) == f); } inline bool test(Enum f) const { return((*this & f) == f); } inline bool test_any() const { return(m_i != 0); } inline bool test_any(flags f) const { return((*this & f).test_any()); } protected: int_t m_i = 0; }; } // namespace uncrustify #if __GNUC__ == 4 && !defined (__clang__) #pragma GCC diagnostic pop #endif #endif uncrustify-uncrustify-0.76.0/src/error_types.h000066400000000000000000000036671434072136500215660ustar00rootroot00000000000000/** * @file error_types.h * * Defines the error codes that are used throughout uncrustify * * @license GPL v2+ */ #ifndef ERROR_TYPES_H_INCLUDED #define ERROR_TYPES_H_INCLUDED #if 1 #include // provides EXIT_SUCCESS and EXIT FAILURE // TODO: if we decided to only use EX_OK and EX_xxx we can avoid including stdlib.h here #else // TODO: I left this to show my modifications remove it after the PR was reviewed // the good old SUCCESS/FAILURE #define SUCCESS 0 //! same as EX_OK */ #define FAILURE -1 //! incompatible to EXIT_FAILURE #endif #if defined (WIN32) || defined (__QNXNTO__) // Windows does not know sysexists.h. Thus define the error codes #define EX_OK 0 //! successful termination #define EX__BASE 64 //! base value for error messages #define EX_USAGE 64 //! command line usage error #define EX_DATAERR 65 //! data format error #define EX_NOINPUT 66 //! cannot open input #define EX_NOUSER 67 //! addressee unknown #define EX_NOHOST 68 //! host name unknown #define EX_UNAVAILABLE 69 //! service unavailable #define EX_SOFTWARE 70 //! internal software error #define EX_OSERR 71 //! system error (e.g., can't fork) #define EX_OSFILE 72 //! critical OS file missing #define EX_CANTCREAT 73 //! can't create (user) output file #define EX_IOERR 74 //! input/output error #define EX_TEMPFAIL 75 //! temp failure; user is invited to retry #define EX_PROTOCOL 76 //! remote error in protocol #define EX_NOPERM 77 //! permission denied #define EX_CONFIG 78 //! configuration error #define EX__MAX 78 //! maximum listed value #else // not WIN32 or not __QNXNTO__ // TODO: do all non windows systems know sysexits.h? // Linux knows: /usr/include/sysexits.h #include "sysexits.h" // comes from BSD #endif #endif /* ERROR_TYPES_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/flag_braced_init_list.cpp000066400000000000000000000062671434072136500240320ustar00rootroot00000000000000/** * @file flag_braced_init_list.cpp * * @license GPL v2+ */ #include "chunk.h" #include "flag_braced_init_list.h" #include "uncrustify.h" bool detect_cpp_braced_init_list(Chunk *pc, Chunk *next) { LOG_FUNC_ENTRY(); // Issue #2332 bool we_have_a_case_before = false; if (pc->Is(CT_COLON)) { // check if we have a case before Chunk *switch_before = pc->GetPrevType(CT_CASE, pc->GetLevel()); if (switch_before->IsNotNullChunk()) { LOG_FMT(LFCNR, "%s(%d): switch_before orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, switch_before->GetOrigLine(), switch_before->GetOrigCol(), switch_before->Text(), get_token_name(switch_before->GetType())); we_have_a_case_before = true; } } // Detect a braced-init-list if ( pc->Is(CT_WORD) || pc->Is(CT_TYPE) || pc->Is(CT_ASSIGN) || pc->Is(CT_RETURN) || pc->Is(CT_COMMA) || pc->Is(CT_ANGLE_CLOSE) || pc->Is(CT_SQUARE_CLOSE) || pc->Is(CT_TSQUARE) || pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_QUESTION) || ( pc->Is(CT_COLON) && !we_have_a_case_before) || ( pc->Is(CT_BRACE_OPEN) && ( pc->GetParentType() == CT_NONE || pc->GetParentType() == CT_BRACED_INIT_LIST))) { LOG_FMT(LFCNR, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n ", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); log_pcf_flags(LFCNR, pc->GetFlags()); auto brace_open = pc->GetNextNcNnl(); if ( brace_open->Is(CT_BRACE_OPEN) && ( brace_open->GetParentType() == CT_NONE || brace_open->GetParentType() == CT_ASSIGN || brace_open->GetParentType() == CT_RETURN || brace_open->GetParentType() == CT_BRACED_INIT_LIST)) { log_pcf_flags(LFCNR, brace_open->GetFlags()); auto brace_close = next->GetClosingParen(); if (brace_close->Is(CT_BRACE_CLOSE)) { return(true); } } } return(false); } // detect_cpp_braced_init_list void flag_cpp_braced_init_list(Chunk *pc, Chunk *next) { Chunk *brace_open = pc->GetNextNcNnl(); Chunk *brace_close = next->GetClosingParen(); brace_open->SetParentType(CT_BRACED_INIT_LIST); brace_close->SetParentType(CT_BRACED_INIT_LIST); Chunk *tmp = brace_close->GetNextNcNnl(); if (tmp->IsNotNullChunk()) { tmp->ResetFlagBits(PCF_EXPR_START | PCF_STMT_START); // Flag call operator if (tmp->Is(CT_PAREN_OPEN)) { Chunk *c = tmp->GetClosingParen(); if (c->IsNotNullChunk()) { tmp->SetType(CT_FPAREN_OPEN); tmp->SetParentType(CT_FUNC_CALL); c->SetType(CT_FPAREN_CLOSE); c->SetParentType(CT_FUNC_CALL); } } } // TODO: Change pc->GetType() CT_WORD -> CT_TYPE // for the case CT_ASSIGN (and others). // TODO: Move this block to the fix_fcn_call_args function. if ( pc->Is(CT_WORD) && pc->TestFlags(PCF_IN_FCN_CALL)) { pc->SetType(CT_TYPE); } } // flag_cpp_braced_init_list uncrustify-uncrustify-0.76.0/src/flag_braced_init_list.h000066400000000000000000000010321434072136500234600ustar00rootroot00000000000000/** * @file flag_braced_init_list.h * * @license GPL v2+ */ #ifndef FLAG_BRACED_INIT_LIST_INCLUDED #define FLAG_BRACED_INIT_LIST_INCLUDED #include "chunk.h" /** * Detect a cpp braced init list */ bool detect_cpp_braced_init_list(Chunk *pc, Chunk *next); /** * Flags the opening and closing braces of an expression deemed to be * a cpp braced initializer list; a call to detect_cpp_braced_init_list() * should first be made prior to calling this function */ void flag_cpp_braced_init_list(Chunk *pc, Chunk *next); #endif uncrustify-uncrustify-0.76.0/src/flag_decltype.cpp000066400000000000000000000024231434072136500223330ustar00rootroot00000000000000/** * @file flag_decltype.cpp * * @license GPL v2+ */ #include "chunk.h" bool flag_cpp_decltype(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc->Is(CT_DECLTYPE)) { auto paren_open = pc->GetNextNcNnl(); if (paren_open->Is(CT_PAREN_OPEN)) { // We would like to simply call Chunk::SkipToMatch(), but it finds // a match based on level, and the level is 0 for all chunks in some // cases, like the following example. // // template // decltype(std::declval().put(foo), std::true_type()) // has_something(Tag<2>); // // This means that IN_DECLTYPE is only set for tokens through the // closing parenthesis right before ".put" in the above example. // // So, we will manually look for the matching closing parenthesis. paren_open->SetFlagBits(PCF_IN_DECLTYPE); pc = paren_open->GetNextNcNnl(); for (int level = 1; pc->IsNotNullChunk() && level > 0; pc = pc->GetNextNcNnl()) { level += pc->Is(CT_PAREN_OPEN); level -= pc->Is(CT_PAREN_CLOSE); pc->SetFlagBits(PCF_IN_DECLTYPE); } return(pc->IsNotNullChunk()); } } return(false); } // mark_cpp_decltype uncrustify-uncrustify-0.76.0/src/flag_decltype.h000066400000000000000000000005541434072136500220030ustar00rootroot00000000000000/** * @file flag_decltype.h * * @license GPL v2+ */ #ifndef FLAG_DECLTYPE_INCLUDED #define FLAG_DECLTYPE_INCLUDED #include "chunk.h" /** * Flags all chunks within a cpp decltype expression from the opening * brace to the closing brace * * @return Returns true if expression is a valid decltype expression */ bool flag_cpp_decltype(Chunk *pc); #endif uncrustify-uncrustify-0.76.0/src/flag_parens.cpp000066400000000000000000000040261434072136500220130ustar00rootroot00000000000000/** * @file flag_parens.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "flag_parens.h" #include "uncrustify.h" Chunk *flag_parens(Chunk *po, T_PcfFlags flags, E_Token opentype, E_Token parent_type, bool parent_all) { LOG_FUNC_ENTRY(); Chunk *paren_close; paren_close = po->GetClosingParen(E_Scope::PREPROC); if (paren_close->IsNullChunk()) { LOG_FMT(LERR, "%s(%d): no match for '%s' at [%zu:%zu]", __func__, __LINE__, po->Text(), po->GetOrigLine(), po->GetOrigCol()); log_func_stack_inline(LERR); exit(EX_SOFTWARE); } LOG_FMT(LFLPAREN, "%s(%d): between po is '%s', orig line is %zu, orig col is %zu, and\n", __func__, __LINE__, po->Text(), po->GetOrigLine(), po->GetOrigCol()); LOG_FMT(LFLPAREN, "%s(%d): paren_close is '%s', orig line is %zu, orig col is %zu, type is %s, parent type is %s\n", __func__, __LINE__, paren_close->Text(), paren_close->GetOrigLine(), paren_close->GetOrigCol(), get_token_name(opentype), get_token_name(parent_type)); log_func_stack_inline(LFLPAREN); // the last chunk must be also modified. Issue #2149 Chunk *after_paren_close = paren_close->GetNext(); if (po != paren_close) { if ( flags != PCF_NONE || ( parent_all && parent_type != CT_NONE)) { Chunk *pc; for (pc = po->GetNext(E_Scope::PREPROC); pc != nullptr && pc->IsNotNullChunk() && pc != after_paren_close; pc = pc->GetNext(E_Scope::PREPROC)) { pc->SetFlagBits(flags); if (parent_all) { pc->SetParentType(parent_type); } } } if (opentype != CT_NONE) { po->SetType(opentype); paren_close->SetType((E_Token)(opentype + 1)); } if (parent_type != CT_NONE) { po->SetParentType(parent_type); paren_close->SetParentType(parent_type); } } return(paren_close->GetNextNcNnl(E_Scope::PREPROC)); } // flag_parens uncrustify-uncrustify-0.76.0/src/flag_parens.h000066400000000000000000000010731434072136500214570ustar00rootroot00000000000000/** * @file flag_parens.h * * @author Guy Maurel * @license GPL v2+ */ #ifndef FLAG_PARENS_H_INCLUDED #define FLAG_PARENS_H_INCLUDED #include "chunk.h" /** * Flags everything from the open paren to the close paren. * * @param po Pointer to the open parenthesis * @param flags flags to add * @param opentype * @param parenttype * @param parent_all * * @return The token after the close paren */ Chunk *flag_parens(Chunk *po, T_PcfFlags flags, E_Token opentype, E_Token parenttype, bool parent_all); #endif /* FLAG_PARENS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/frame_list.cpp000066400000000000000000000241631434072136500216630ustar00rootroot00000000000000/** * @file frame_list.cpp * mainly used to handle preprocessor stuff * * @author Ben Gardner * @license GPL v2+ */ #include "frame_list.h" #include "prototypes.h" namespace { void fl_log_frms(log_sev_t logsev, const char *txt, const ParseFrame &frm, const std::vector &frames); //! Logs the entire parse frame stack void fl_log_all(log_sev_t logsev, const std::vector &frames); /** * Copy the top element of the frame list into the ParseFrame. * * If the frame list is empty nothing happens. * * This is called on #else and #elif. */ void fl_copy_tos(ParseFrame &pf, const std::vector &frames); /** * Copy the 2nd top element off the list into the ParseFrame. * This is called on #else and #elif. * The stack contains [...] [base] [if] at this point. * We want to copy [base]. */ void fl_copy_2nd_tos(ParseFrame &pf, const std::vector &frames); //! Deletes the top element from the list. void fl_trash_tos(std::vector &frames); //! Logs one parse frame void fl_log(log_sev_t logsev, const ParseFrame &frm) { LOG_FMT(logsev, "[%s] BrLevel=%zu Level=%zu PseTos=%zu\n", get_token_name(frm.in_ifdef), frm.brace_level, frm.level, frm.size() - 1); LOG_FMT(logsev, " *"); for (size_t idx = 1; idx < frm.size(); idx++) { LOG_FMT(logsev, " [%s-%s]", get_token_name(frm.at(idx).type), get_brace_stage_name(frm.at(idx).stage)); } LOG_FMT(logsev, "\n"); } void fl_log_frms(log_sev_t logsev, const char *txt, const ParseFrame &frm, const std::vector &frames) { LOG_FMT(logsev, "%s Parse Frames(%zu):", txt, frames.size()); for (const auto &frame : frames) { LOG_FMT(logsev, " [%s-%zu]", get_token_name(frame.in_ifdef), frame.ref_no); } LOG_FMT(logsev, "-[%s-%zu]\n", get_token_name(frm.in_ifdef), frm.ref_no); } void fl_log_all(log_sev_t logsev, const std::vector &frames) { LOG_FMT(logsev, "##=- Parse Frame : %zu entries\n", frames.size()); for (size_t idx = 0; idx < frames.size(); idx++) { LOG_FMT(logsev, "## idx is %zu, ", idx); fl_log(logsev, frames.at(idx)); } LOG_FMT(logsev, "##=-\n"); } void fl_copy_tos(ParseFrame &pf, const std::vector &frames) { if (!frames.empty()) { pf = *std::prev(std::end(frames)); } LOG_FMT(LPF, "%s(%d): frame_count is %zu\n", __func__, __LINE__, frames.size()); } void fl_copy_2nd_tos(ParseFrame &pf, const std::vector &frames) { if (frames.size() > 1) { pf = *std::prev(std::end(frames), 2); } LOG_FMT(LPF, "%s(%d): frame_count is %zu\n", __func__, __LINE__, frames.size()); } void fl_trash_tos(std::vector &frames) { if (!frames.empty()) { frames.pop_back(); } LOG_FMT(LPF, "%s(%d): frame_count is %zu\n", __func__, __LINE__, frames.size()); } } // namespace void fl_push(std::vector &frames, ParseFrame &frm) { static int ref_no = 1; frames.push_back(frm); frm.ref_no = ref_no++; LOG_FMT(LPF, "%s(%d): frame_count is %zu\n", __func__, __LINE__, frames.size()); } void fl_pop(std::vector &frames, ParseFrame &pf) { if (frames.empty()) { return; } fl_copy_tos(pf, frames); fl_trash_tos(frames); } int fl_check(std::vector &frames, ParseFrame &frm, int &pp_level, Chunk *pc) { if (pc->IsNot(CT_PREPROC)) { return(pp_level); } Chunk *next = pc->GetNext(); if (next->IsNullChunk()) { return(pp_level); } if (pc->GetParentType() != next->GetType()) { LOG_FMT(LNOTE, "%s(%d): Preproc parent not set correctly on orig line %zu: got %s expected %s\n", __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetParentType()), get_token_name(next->GetType())); pc->SetParentType(next->GetType()); } LOG_FMT(LPFCHK, "%s(%d): orig line is %zu, %s\n", __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetParentType())); fl_log_frms(LPFCHK, "TOP", frm, frames); int out_pp_level = pp_level; const E_Token in_ifdef = frm.in_ifdef; const size_t b4_cnt = frames.size(); const char *txt = nullptr; if (pc->TestFlags(PCF_IN_PREPROC)) { LOG_FMT(LPF, " "); fl_log(LPF, frm); if (pc->GetParentType() == CT_PP_IF) { // An #if pushes a copy of the current frame on the stack pp_level++; fl_push(frames, frm); frm.in_ifdef = CT_PP_IF; txt = "if-push"; } else if (pc->GetParentType() == CT_PP_ELSE) { if (out_pp_level == 0) { fprintf(stderr, "%s(%d): pp level is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } out_pp_level--; /* * For #else of #elif, we want to keep the #if part and throw out the * else parts. * We check to see what the top type is to see if we just push or * pop and then push. * We need to use the copy right before the if. */ bool if_block = false; if (frm.in_ifdef == CT_PP_IF) { // we have [...] [base]-[if], so push an [else] fl_push(frames, frm); frm.in_ifdef = CT_PP_ELSE; if_block = true; } size_t brace_level = frm.brace_level; // we have [...] [base] [if]-[else], copy [base] over [else] fl_copy_2nd_tos(frm, frames); frm.in_ifdef = CT_PP_ELSE; if (if_block) { // check if #if block was unbalanced size_t base_brace_level = frames[frames.size() - 2].brace_level; if ( options::pp_warn_unbalanced_if() && brace_level != base_brace_level) { LOG_FMT(LWARN, "%s(%d): orig line is %zu, unbalanced #if block braces (1), in-level is %zu, out-level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), base_brace_level, brace_level); } } else { // check if previous #else block has a different indentation than the corresponding #if block size_t if_brace_level = frames[frames.size() - 1].brace_level; if ( options::pp_warn_unbalanced_if() && brace_level != if_brace_level) { LOG_FMT(LWARN, "%s(%d): orig line is %zu, unbalanced #if-#else block braces (1), #else out-level is %zu, #if out-level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), brace_level, if_brace_level); } } txt = "else-push"; } else if (pc->GetParentType() == CT_PP_ENDIF) { /* * we may have [...] [base] [if]-[else] or [...] [base]-[if]. * Throw out the [else]. */ if (pp_level == 0) { // cpd.pp_level is ZERO, cannot be decremented. fprintf(stderr, "%s(%d): #endif found, at line %zu, column %zu, without corresponding #if\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } pp_level--; if (out_pp_level == 0) { fprintf(stderr, "%s(%d): pp level is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } out_pp_level--; if (frm.in_ifdef == CT_PP_ELSE) { size_t brace_level = frm.brace_level; // brace level or current #else block /* * We have: [...] [base] [if]-[else] * We want: [...]-[if] */ fl_copy_tos(frm, frames); // [...] [base] [if]-[if] if ( options::pp_warn_unbalanced_if() && brace_level != frm.brace_level) { LOG_FMT(LWARN, "%s(%d): orig line is %zu, unbalanced #if-#else block braces (2), #else out-level is %zu, #if out-level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), brace_level, frm.brace_level); } if (frames.size() < 2) { fprintf(stderr, "Number of 'frame' is too small.\n"); fprintf(stderr, "Please make a report.\n"); log_flush(true); exit(EX_SOFTWARE); } frm.in_ifdef = frames[frames.size() - 2].in_ifdef; fl_trash_tos(frames); // [...] [base]-[if] fl_trash_tos(frames); // [...]-[if] txt = "endif-trash/pop"; } else if (frm.in_ifdef == CT_PP_IF) { /* * We have: [...] [base] [if] * We want: [...] [base] */ // check if #if block was unbalanced size_t brace_level = frm.brace_level; fl_pop(frames, frm); if ( options::pp_warn_unbalanced_if() && brace_level != frm.brace_level) { LOG_FMT(LWARN, "%s(%d): orig line is %zu, unbalanced #if block braces (2), in-level is %zu, out-level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), frm.brace_level, brace_level); } txt = "endif-pop"; } else { txt = "???"; } } } if (txt != nullptr) { LOG_FMT(LPF, "%s(%d): orig line is %zu, type is %s: %s in_ifdef is %s/%s, counts is %zu, frame_count is %zu\n", __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetParentType()), txt, get_token_name(in_ifdef), get_token_name(frm.in_ifdef), b4_cnt, frames.size()); fl_log_all(LPF, frames); LOG_FMT(LPF, " "); fl_log(LPF, frm); } fl_log_frms(LPFCHK, "END", frm, frames); return(out_pp_level); } // fl_check uncrustify-uncrustify-0.76.0/src/frame_list.h000066400000000000000000000016441434072136500213270ustar00rootroot00000000000000/** * @file frame_list.h * mainly used to handle preprocessor stuff * * @author Ben Gardner * @license GPL v2+ */ #ifndef PARSE_FRAME_H_INCLUDED #define PARSE_FRAME_H_INCLUDED #include "ParseFrame.h" #include "uncrustify_types.h" /** * Push a copy of a ParseFrame onto the frames list. * This is called on #if and #ifdef. */ void fl_push(std::vector &frames, ParseFrame &frm); /** * Pop the top element off the frame list and copy it into the ParseFrame. * * Does nothing if the frame list is empty. * * This is called on #endif */ void fl_pop(std::vector &frames, ParseFrame &pf); // TODO: this name is dumb: // - what is it checking? // - why does is much more than simple checks, it allters kinds of stuff //! Returns the pp_indent to use for this line int fl_check(std::vector &frames, ParseFrame &frm, int &pp_level, Chunk *pc); #endif /* PARSE_FRAME_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/indent.cpp000066400000000000000000005316111434072136500210200ustar00rootroot00000000000000/** * @file indent.cpp * Does all the indenting stuff. * * @author Ben Gardner * @author Guy Maurel October 2015- 2021 * @license GPL v2+ */ #include "indent.h" #include "align.h" #include "frame_list.h" #include "options.h" #include "options_for_QT.h" #include "prototypes.h" #include "quick_align_again.h" #include "space.h" #ifdef WIN32 #include // to get max #endif // ifdef WIN32 #ifdef IGNORE // WinBase.h #undef IGNORE #endif constexpr static auto LCURRENT = LINDENT; using namespace std; using namespace uncrustify; /** * General indenting approach: * Indenting levels are put into a stack. * * The stack entries contain: * - opening type * - brace column * - continuation column * * Items that start a new stack item: * - preprocessor (new parse frame) * - Brace Open (Virtual brace also) * - Paren, Square, Angle open * - Assignments * - C++ '<<' operator (ie, cout << "blah") * - case * - class colon * - return * - types * - any other continued statement * * Note that the column of items marked 'PCF_WAS_ALIGNED' is not changed. * * For an open brace: * - indent increases by indent_columns * - if part of if/else/do/while/switch/etc, an extra indent may be applied * - if in a paren, then cont-col is set to column + 1, ie "({ some code })" * * Open paren/square/angle: * cont-col is set to the column of the item after the open paren, unless * followed by a newline, then it is set to (brace-col + indent_columns). * Examples: * a_really_long_function_name( * param1, param2); * a_really_long_function_name(param1, * param2); * * Assignments: * Assignments are continued aligned with the first item after the assignment, * unless the assign is followed by a newline. * Examples: * some.variable = asdf + asdf + * asdf; * some.variable = * asdf + asdf + asdf; * * C++ << operator: * Handled the same as assignment. * Examples: * cout << "this is test number: " * << test_number; * * case: * Started with case or default. * Terminated with close brace at level or another case or default. * Special indenting according to various rules. * - indent of case label * - indent of case body * - how to handle optional braces * Examples: * { * case x: { * a++; * break; * } * case y: * b--; * break; * default: * c++; * break; * } * * Class colon: * Indent continuation by indent_columns: * class my_class : * baseclass1, * baseclass2 * { * * Return: same as assignments * If the return statement is not fully paren'd, then the indent continues at * the column of the item after the return. If it is paren'd, then the paren * rules apply. * return somevalue + * othervalue; * * Type: pretty much the same as assignments * Examples: * int foo, * bar, * baz; * * Any other continued item: * There shouldn't be anything not covered by the above cases, but any other * continued item is indented by indent_columns: * Example: * somereallycrazylongname.with[lotsoflongstuff]. * thatreallyannoysme.whenIhavetomaintain[thecode] = 3; */ /** * REVISIT: This needs to be re-checked, maybe cleaned up * * Indents comments in a (hopefully) smart manner. * * There are two type of comments that get indented: * - stand alone (ie, no tokens on the line before the comment) * - trailing comments (last token on the line apart from a linefeed) * + note that a stand-alone comment is a special case of a trailing * * The stand alone comments will get indented in one of three ways: * - column 1: * + There is an empty line before the comment AND the indent level is 0 * + The comment was originally in column 1 * * - Same column as trailing comment on previous line (ie, aligned) * + if originally within TBD (3) columns of the previous comment * * - syntax indent level * + doesn't fit in the previous categories * * Options modify this behavior: * - keep original column (don't move the comment, if possible) * - keep relative column (move out the same amount as first item on line) * - fix trailing comment in column TBD * * @param pc The comment, which is the first item on a line * @param col The column if this is to be put at indent level */ static void indent_comment(Chunk *pc, size_t col); static size_t token_indent(E_Token type); static size_t calc_indent_continue(const ParseFrame &frm, size_t pse_tos); /** * Get candidate chunk first on line to which OC blocks can be indented against. */ static Chunk *candidate_chunk_first_on_line(Chunk *pc); /** * We are on a '{' that has parent = OC_BLOCK_EXPR * find the column of the param tag */ static Chunk *oc_msg_block_indent(Chunk *pc, bool from_brace, bool from_caret, bool from_colon, bool from_keyword); /** * returns true if forward or reverse scan reveals only single newlines or comments * stops when hits code * false if next thing hit is a closing brace, also if 2 newlines in a row */ static bool single_line_comment_indent_rule_applies(Chunk *start, bool forward); /** * returns true if semicolon on the same level ends any assign operations * false if next thing hit is not the end of an assign operation */ static bool is_end_of_assignment(Chunk *pc, const ParseFrame &frm); void indent_to_column(Chunk *pc, size_t column) { LOG_FUNC_ENTRY(); if (column < pc->GetColumn()) { column = pc->GetColumn(); } reindent_line(pc, column); } enum class align_mode_e : unsigned int { SHIFT, //! shift relative to the current column KEEP_ABS, //! try to keep the original absolute column KEEP_REL, //! try to keep the original gap }; enum class indent_mode_e : int { INDENT = 0, //! indent by one level ALIGN = 1, //! align under the open brace/parenthesis IGNORE = -1, //! preserve original indentation }; void align_to_column(Chunk *pc, size_t column) { LOG_FUNC_ENTRY(); if ( pc == nullptr || column == pc->GetColumn()) { return; } LOG_FMT(LINDLINE, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s => column is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetColumn(), pc->Text(), get_token_name(pc->GetType()), column); const int col_delta = column - pc->GetColumn(); size_t min_col = column; pc->SetColumn(column); do { auto *next = pc->GetNext(); if (next->IsNullChunk()) { break; } const size_t min_delta = space_col_align(pc, next); min_col += min_delta; const auto *prev = pc; pc = next; auto almod = align_mode_e::SHIFT; if ( pc->IsComment() && pc->GetParentType() != CT_COMMENT_EMBED) { log_rule_B("indent_relative_single_line_comments"); almod = ( pc->IsSingleLineComment() && options::indent_relative_single_line_comments()) ? align_mode_e::KEEP_REL : align_mode_e::KEEP_ABS; } if (almod == align_mode_e::KEEP_ABS) { // Keep same absolute column pc->SetColumn(max(pc->GetOrigCol(), min_col)); } else if (almod == align_mode_e::KEEP_REL) { // Keep same relative column size_t orig_delta = pc->GetOrigPrevSp() + prev->Len(); orig_delta = max(orig_delta, min_delta); // keeps orig_delta positive pc->SetColumn(prev->GetColumn() + orig_delta); } else // SHIFT { // Shift by the same amount, keep above negative values pc->SetColumn(( col_delta >= 0 || (size_t)(abs(col_delta)) < pc->GetColumn()) ? pc->GetColumn() + col_delta : 0); pc->SetColumn(max(pc->GetColumn(), min_col)); } LOG_FMT(LINDLINED, "%s(%d): %s set column of '%s', type is %s, orig line is %zu, to col %zu (orig col was %zu)\n", __func__, __LINE__, (almod == align_mode_e::KEEP_ABS) ? "abs" : (almod == align_mode_e::KEEP_REL) ? "rel" : "sft", pc->Text(), get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetColumn(), pc->GetOrigCol()); } while ( pc->IsNotNullChunk() && pc->GetNlCount() == 0); } // align_to_column void reindent_line(Chunk *pc, size_t column) { LOG_FUNC_ENTRY(); char copy[1000]; LOG_FMT(LINDLINE, "%s(%d): orig line is %zu, orig col is %zu, on '%s' [%s/%s] => %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy), get_token_name(pc->GetType()), get_token_name(pc->GetParentType()), column); log_func_stack_inline(LINDLINE); if (column == pc->GetColumn()) { return; } int col_delta = column - pc->GetColumn(); size_t min_col = column; pc->SetColumn(column); do { if (QT_SIGNAL_SLOT_found) { // fix the bug #654 // connect(&mapper, SIGNAL(mapped(QString &)), this, SLOT(onSomeEvent(QString &))); // look for end of SIGNAL/SLOT block if (!pc->TestFlags(PCF_IN_QT_MACRO)) { LOG_FMT(LINDLINE, "FLAGS is NOT set: PCF_IN_QT_MACRO\n"); restore_options_for_QT(); } } else { // look for begin of SIGNAL/SLOT block if (pc->TestFlags(PCF_IN_QT_MACRO)) { LOG_FMT(LINDLINE, "FLAGS is set: PCF_IN_QT_MACRO\n"); save_set_options_for_QT(pc->GetLevel()); } } Chunk *next = pc->GetNext(); if (next->IsNullChunk()) { break; } if (pc->GetNlCount()) { min_col = 0; col_delta = 0; } min_col += space_col_align(pc, next); pc = next; const bool is_comment = pc->IsComment(); log_rule_B("indent_relative_single_line_comments"); const bool keep = ( is_comment && pc->IsSingleLineComment() && options::indent_relative_single_line_comments()); if ( is_comment && pc->GetParentType() != CT_COMMENT_EMBED && !keep) { pc->SetColumn(max(pc->GetOrigCol(), min_col)); LOG_FMT(LINDLINE, "%s(%d): set comment on line %zu to col %zu (orig %zu)\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetColumn(), pc->GetOrigCol()); } else { pc->SetColumn(max(pc->GetColumn() + col_delta, min_col)); LOG_FMT(LINDLINED, "%s(%d): set column of ", __func__, __LINE__); if (pc->Is(CT_NEWLINE)) { LOG_FMT(LINDLINED, ""); } else { LOG_FMT(LINDLINED, "'%s'", pc->Text()); } LOG_FMT(LINDLINED, " to %zu (orig %zu)\n", pc->GetColumn(), pc->GetOrigCol()); } } while ( pc->IsNotNullChunk() && pc->GetNlCount() == 0); } // reindent_line static size_t token_indent(E_Token type) { switch (type) { case CT_IF: case CT_DO: return(3); case CT_FOR: case CT_ELSE: // wacky, but that's what is wanted return(4); case CT_WHILE: case CT_USING_STMT: return(6); case CT_SWITCH: return(7); case CT_ELSEIF: return(8); case CT_SYNCHRONIZED: return(13); default: return(0); } } #define indent_column_set(X) \ do { \ LOG_FMT(LINDENT2, "%s(%d): orig line is %zu, indent_column changed from %zu to %zu\n", \ __func__, __LINE__, pc->GetOrigLine(), indent_column, (size_t)X); \ indent_column = (X); \ } while (false) static size_t get_indent_first_continue(Chunk *pc) { log_rule_B("indent_ignore_first_continue"); Chunk *continuation = pc->GetNextType(CT_NEWLINE, pc->GetLevel()); if (continuation->IsNotNullChunk()) { continuation = continuation->GetNext(); if (continuation->IsNotNullChunk()) { return(continuation->GetOrigCol()); } } return(0); } static size_t calc_indent_continue(const ParseFrame &frm, size_t pse_tos) { log_rule_B("indent_continue"); const int ic = options::indent_continue(); if ( ic < 0 && frm.at(pse_tos).indent_cont) { return(frm.at(pse_tos).indent); } return(frm.at(pse_tos).indent + abs(ic)); } static size_t calc_indent_continue(const ParseFrame &frm) { return(calc_indent_continue(frm, frm.size() - 1)); } static Chunk *candidate_chunk_first_on_line(Chunk *pc) { Chunk *first = pc->GetFirstChunkOnLine(); log_rule_B("indent_inside_ternary_operator"); if ( options::indent_inside_ternary_operator() && ( first->Is(CT_QUESTION) || first->Is(CT_COND_COLON))) { return(first->GetNextNcNnl()); } else { return(first); } } static Chunk *oc_msg_block_indent(Chunk *pc, bool from_brace, bool from_caret, bool from_colon, bool from_keyword) { LOG_FUNC_ENTRY(); Chunk *tmp = Chunk::NullChunkPtr; if (pc != nullptr) { tmp = pc->GetPrevNc(); } if (from_brace) { return(pc); } // Skip to open paren in ':^TYPE *(ARGS) {' if (tmp->IsParenClose()) { tmp = tmp->GetOpeningParen()->GetPrevNc(); } // // Check for star in ':^TYPE *(ARGS) {'. Issue 2477 if (tmp->Is(CT_PTR_TYPE)) { tmp = tmp->GetPrevNc(); } // Check for type in ':^TYPE *(ARGS) {'. Issue 2482 if (tmp->Is(CT_TYPE)) { tmp = tmp->GetPrevNc(); } // Check for caret in ':^TYPE *(ARGS) {' // Store the caret position Chunk *caret_tmp = Chunk::NullChunkPtr; if ( tmp->IsNotNullChunk() && tmp->GetType() == CT_OC_BLOCK_CARET) { caret_tmp = tmp; } else { caret_tmp = tmp->GetPrevType(CT_OC_BLOCK_CARET); tmp = caret_tmp; } // If we still cannot find caret then return first chunk on the line if ( tmp->IsNullChunk() || tmp->IsNot(CT_OC_BLOCK_CARET)) { return(candidate_chunk_first_on_line(pc)); } if (from_caret) { return(tmp); } tmp = tmp->GetPrevNc(); // Check for colon in ':^TYPE *(ARGS) {' if (from_colon) { if ( tmp->IsNullChunk() || tmp->IsNot(CT_OC_COLON)) { return(candidate_chunk_first_on_line(pc)); } else { return(tmp); } } tmp = tmp->GetPrevNc(); if (from_keyword) { if ( tmp->IsNullChunk() || ( tmp->IsNot(CT_OC_MSG_NAME) && tmp->IsNot(CT_OC_MSG_FUNC))) { return(candidate_chunk_first_on_line(pc)); } else { return(tmp); } } // In almost all the cases, its better to return the first chunk on the line than not indenting at all. tmp = candidate_chunk_first_on_line(pc); return(tmp); } // oc_msg_block_indent #define log_indent() \ do { _log_indent(__func__, __LINE__, frm); \ } while (false) static void _log_indent(const char *func, const uint32_t line, const ParseFrame &frm) { LOG_FMT(LINDLINE, "%s(%d): frm.pse_tos is %zu, ...indent is %zu\n", func, line, frm.size() - 1, frm.top().indent); } #define log_prev_indent() \ do { _log_prev_indent(__func__, __LINE__, frm); \ } while (false) static void _log_prev_indent(const char *func, const uint32_t line, const ParseFrame &frm) { LOG_FMT(LINDLINE, "%s(%d): frm.pse_tos is %zu, prev....indent is %zu\n", func, line, frm.size() - 1, frm.prev().indent); } #define log_indent_tmp() \ do { _log_indent_tmp(__func__, __LINE__, frm); \ } while (false) static void _log_indent_tmp(const char *func, const uint32_t line, const ParseFrame &frm) { LOG_FMT(LINDLINE, "%s(%d): frm.pse_tos is %zu, ...indent_tmp is %zu\n", func, line, frm.size() - 1, frm.top().indent_tmp); } static void quick_indent_again() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->GetIndentData().ref == nullptr) { continue; } Chunk *tmp = pc->GetPrev(); if (!tmp->IsNewline()) { continue; } const size_t col = pc->GetIndentData().ref->GetColumn() + pc->GetIndentData().delta; indent_to_column(pc, col); LOG_FMT(LINDENTAG, "%s(%d): [%zu] indent [%s] to %zu based on [%s] @ %zu:%zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->Text(), col, pc->GetIndentData().ref->Text(), pc->GetIndentData().ref->GetOrigLine(), pc->GetIndentData().ref->GetColumn()); } } void indent_text() { LOG_FUNC_ENTRY(); bool did_newline = true; size_t vardefcol = 0; log_rule_B("indent_columns"); const size_t indent_size = options::indent_columns(); size_t indent_column = 0; int xml_indent = 0; size_t sql_col = 0; size_t sql_orig_col = 0; bool in_func_def = false; std::vector frames; ParseFrame frm{}; Chunk *pc = Chunk::GetHead(); bool classFound = false; // Issue #672 while ( pc != nullptr && pc->IsNotNullChunk()) { LOG_CHUNK(LINDLINE, pc); // forces string literal to column-1 [Fix for 1246] log_rule_B("indent_col1_multi_string_literal"); if ( (pc->GetType() == CT_STRING_MULTI) && !(cpd.lang_flags & LANG_OC) // Issue #1795 && options::indent_col1_multi_string_literal()) { string str = pc->Text(); if ( (str[0] == '@') && (pc->GetPrev()->GetType() == CT_NEWLINE)) { indent_column_set(1); reindent_line(pc, indent_column); pc = pc->GetNext(); did_newline = false; } } if (pc->Is(CT_NEWLINE)) { LOG_FMT(LINDLINE, "%s(%d): orig line is %zu, \n", __func__, __LINE__, pc->GetOrigLine()); } else if (pc->Is(CT_NL_CONT)) { LOG_FMT(LINDLINE, "%s(%d): orig line is %zu, CT_NL_CONT\n", __func__, __LINE__, pc->GetOrigLine()); } else { char copy[1000]; LOG_FMT(LINDLINE, "%s(%d): orig line is %zu, orig col is %zu, column is %zu, for '%s'\n ", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetColumn(), pc->ElidedText(copy)); log_pcf_flags(LINDLINE, pc->GetFlags()); } log_rule_B("use_options_overriding_for_qt_macros"); if ( options::use_options_overriding_for_qt_macros() && ( strcmp(pc->Text(), "SIGNAL") == 0 || strcmp(pc->Text(), "SLOT") == 0)) { LOG_FMT(LINDLINE, "%s(%d): orig line=%zu: type %s SIGNAL/SLOT found\n", __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetType())); } // Handle preprocessor transitions log_rule_B("indent_brace_parent"); const size_t parent_token_indent = (options::indent_brace_parent()) ? token_indent(pc->GetParentType()) : 0; // Handle "force indentation of function definition to start in column 1" log_rule_B("indent_func_def_force_col1"); if (options::indent_func_def_force_col1()) { if (!in_func_def) { Chunk *next = pc->GetNextNcNnl(); if ( pc->GetParentType() == CT_FUNC_DEF || ( pc->Is(CT_COMMENT) && next->IsNotNullChunk() && next->GetParentType() == CT_FUNC_DEF)) { in_func_def = true; frm.push(pc, __func__, __LINE__); frm.top().indent_tmp = 1; frm.top().indent = 1; frm.top().indent_tab = 1; } } else { Chunk *prev = pc->GetPrev(); if ( prev->Is(CT_BRACE_CLOSE) && prev->GetParentType() == CT_FUNC_DEF) { in_func_def = false; LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } } } // Clean up after a #define, etc const bool in_preproc = pc->TestFlags(PCF_IN_PREPROC); if (!in_preproc) { while ( !frm.empty() && frm.top().in_preproc) { const E_Token type = frm.top().type; LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); /* * If we just removed an #endregion, then check to see if a * PP_REGION_INDENT entry is right below it */ if ( type == CT_PP_ENDREGION && frm.top().type == CT_PP_REGION_INDENT) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } } } else if (pc->Is(CT_PREPROC)) // # { // Close out PP_IF_INDENT before playing with the parse frames if ( frm.top().type == CT_PP_IF_INDENT && ( pc->GetParentType() == CT_PP_ENDIF || pc->GetParentType() == CT_PP_ELSE)) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } ParseFrame frmbkup = frm; fl_check(frames, frm, cpd.pp_level, pc); // Indent the body of a #region here log_rule_B("pp_region_indent_code"); if ( options::pp_region_indent_code() && pc->GetParentType() == CT_PP_REGION) { Chunk *next = pc->GetNext(); if (next->IsNullChunk()) { break; } // Hack to get the logs to look right next->SetType(CT_PP_REGION_INDENT); frm.push(next, __func__, __LINE__); next->SetType(CT_PP_REGION); // Indent one level frm.top().indent = frm.prev().indent + indent_size; log_indent(); frm.top().indent_tab = frm.prev().indent_tab + indent_size; frm.top().indent_tmp = frm.top().indent; frm.top().in_preproc = false; log_indent_tmp(); } // If option set, remove indent inside switch statement log_rule_B("indent_switch_pp"); if ( frm.top().type == CT_CASE && !options::indent_switch_pp()) { frm.push(pc, __func__, __LINE__); LOG_FMT(LINDPC, "%s(%d): frm.top().indent is %zu, indent_size is %zu\n", __func__, __LINE__, frm.top().indent, indent_size); if (frm.top().indent >= indent_size) { frm.prev().indent = frm.top().indent - indent_size; } log_prev_indent(); } // Indent the body of a #if here log_rule_B("pp_if_indent_code"); if ( options::pp_if_indent_code() && ( pc->GetParentType() == CT_PP_IF || pc->GetParentType() == CT_PP_ELSE)) { Chunk *next = pc->GetNext(); if (next->IsNullChunk()) { break; } int should_indent_preproc = true; int should_ignore_preproc = false; Chunk *preproc_next = pc->GetNextNl(); preproc_next = preproc_next->GetNextNcNnlNet(); /* Look ahead at what's on the line after the #if */ log_rule_B("pp_indent_brace"); log_rule_B("pp_indent_func_def"); log_rule_B("pp_indent_case"); log_rule_B("pp_indent_extern"); while ( preproc_next->IsNotNullChunk() && preproc_next->IsNot(CT_NEWLINE)) { if ( (preproc_next->Is(CT_BRACE_OPEN)) || (preproc_next->Is(CT_BRACE_CLOSE))) { if (options::pp_indent_brace() == 0) { should_indent_preproc = false; break; } else if (options::pp_indent_brace() == -1) { should_ignore_preproc = true; break; } } else if ( ( preproc_next->Is(CT_FUNC_DEF) && !options::pp_indent_func_def()) || ( preproc_next->Is(CT_CASE) && !options::pp_indent_case()) || ( preproc_next->Is(CT_EXTERN) && !options::pp_indent_extern())) { should_indent_preproc = false; break; } preproc_next = preproc_next->GetNext(); } if (should_indent_preproc) { // Hack to get the logs to look right const E_Token memtype = next->GetType(); next->SetType(CT_PP_IF_INDENT); frm.push(next, __func__, __LINE__); next->SetType(memtype); if (should_ignore_preproc) { // Preserve original indentation frm.top().indent = pc->GetNextNl()->GetNext()->GetOrigCol(); log_indent(); } else { // Indent one level except if the #if is a #include guard size_t extra = ( pc->GetPpLevel() == 0 && ifdef_over_whole_file()) ? 0 : indent_size; frm.top().indent = frm.prev().indent + extra; log_indent(); frm.top().indent_tab = frm.prev().indent_tab + extra; } frm.top().indent_tmp = frm.top().indent; frm.top().in_preproc = false; log_indent_tmp(); } } log_rule_B("indent_member_single"); if (options::indent_member_single()) { if (pc->GetParentType() == CT_PP_IF) { // do nothing } else if (pc->GetParentType() == CT_PP_ELSE) { if ( frm.top().type == CT_MEMBER && frm.top().pop_pc->IsNotNullChunk() && frm.top().pc != frmbkup.top().pc) { Chunk *tmp = pc->GetNextNcNnlNpp(); if (tmp->IsNotNullChunk()) { if ( tmp->Is(CT_WORD) || tmp->Is(CT_TYPE)) { tmp = pc->GetNextNcNnlNpp(); } else if ( tmp->Is(CT_FUNC_CALL) || tmp->Is(CT_FPAREN_OPEN)) { tmp = tmp->GetNextType(CT_FPAREN_CLOSE, tmp->GetLevel()); if (tmp->IsNotNullChunk()) { tmp = pc->GetNextNcNnlNpp(); } } if (tmp->IsNotNullChunk()) { frm.top().pop_pc = tmp; } } } } else if (pc->GetParentType() == CT_PP_ENDIF) { if ( frmbkup.top().type == CT_MEMBER && frm.top().type == CT_MEMBER) { frm.top().pop_pc = frmbkup.top().pop_pc; } } } // Transition into a preproc by creating a dummy indent Chunk *pp_next = pc->GetNext(); if (pp_next->IsNullChunk()) { return; } frm.push(pp_next, __func__, __LINE__); if ( pc->GetParentType() == CT_PP_DEFINE || pc->GetParentType() == CT_PP_UNDEF) { log_rule_B("pp_define_at_level"); frm.top().indent_tmp = options::pp_define_at_level() ? frm.prev().indent_tmp : 1; log_rule_B("pp_multiline_define_body_indent"); if (options::pp_multiline_define_body_indent() < 0) { frm.top().indent = -options::pp_multiline_define_body_indent(); } else { frm.top().indent = pc->GetColumn() + options::pp_multiline_define_body_indent(); } log_indent(); frm.top().indent_tab = frm.top().indent; log_indent_tmp(); } else if ( ( pc->GetParentType() == CT_PP_PRAGMA || pc->GetParentType() == CT_PP_OTHER) && options::pp_define_at_level()) { log_rule_B("pp_define_at_level"); frm.top().indent_tmp = frm.prev().indent_tmp; frm.top().indent = frm.top().indent_tmp + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; log_indent_tmp(); } else if ( pc->GetParentType() == CT_PP_INCLUDE && options::pp_include_at_level()) { log_rule_B("pp_include_at_level"); frm.top().indent_tmp = frm.prev().indent_tmp; frm.top().indent = frm.top().indent_tmp + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; log_indent_tmp(); } else { if ( (frm.prev().type == CT_PP_REGION_INDENT) || ( (frm.prev().type == CT_PP_IF_INDENT) && (frm.top().type != CT_PP_ENDIF))) { frm.top().indent = frm.prev(2).indent; log_indent(); } else { frm.top().indent = frm.prev().indent; log_indent(); } log_indent(); int val = 0; if ( pc->GetParentType() == CT_PP_REGION || pc->GetParentType() == CT_PP_ENDREGION) { log_rule_B("pp_indent_region"); val = options::pp_indent_region(); log_indent(); } else if ( pc->GetParentType() == CT_PP_IF || pc->GetParentType() == CT_PP_ELSE || pc->GetParentType() == CT_PP_ENDIF) { log_rule_B("pp_indent_if"); val = options::pp_indent_if(); log_indent(); } if (val != 0) { size_t &indent = frm.top().indent; indent = (val > 0) ? val // reassign if positive val, : ((size_t)(abs(val)) < indent) // else if no underflow ? (indent + val) : 0; // reduce, else 0 } frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } } // Check for close XML tags " 0) { if (pc->Is(CT_STRING)) { if ( pc->Len() > 4 && xml_indent > 0 && pc->GetStr()[1] == '<' && pc->GetStr()[2] == '/') { log_rule_B("indent_xml_string"); xml_indent -= options::indent_xml_string(); } } else if (!pc->IsCommentOrNewline()) { xml_indent = 0; } } // Handle non-brace closures log_indent_tmp(); bool token_used = false; size_t old_frm_size; do { old_frm_size = frm.size(); // End anything that drops a level if ( !pc->IsCommentOrNewline() && frm.top().level > pc->GetLevel()) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } if (frm.top().level >= pc->GetLevel()) { // process virtual braces closes (no text output) if ( pc->Is(CT_VBRACE_CLOSE) && frm.top().type == CT_VBRACE_OPEN) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); pc = pc->GetNext(); LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); if (pc->IsNullChunk()) { // need to break out of both the do and while loops goto null_pc; } } if ( pc->Is(CT_BRACE_CLOSE) && pc->GetParentType() == CT_ENUM) { Chunk *prev_ncnl = pc->GetPrevNcNnl(); LOG_FMT(LINDLINE, "%s(%d): prev_ncnl is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, prev_ncnl->Text(), prev_ncnl->GetOrigLine(), prev_ncnl->GetOrigCol()); if (prev_ncnl->Is(CT_COMMA)) { LOG_FMT(LINDLINE, "%s(%d): prev_ncnl is comma\n", __func__, __LINE__); } else { LOG_FMT(LINDLINE, "%s(%d): prev_ncnl is NOT comma\n", __func__, __LINE__); } } // End any assign operations with a semicolon on the same level if (is_end_of_assignment(pc, frm)) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // Pop Colon from stack in ternary operator // a // ? b // : e/*top*/;/*pc*/ log_rule_B("indent_inside_ternary_operator"); if ( options::indent_inside_ternary_operator() && (frm.top().type == CT_COND_COLON) && ( pc->IsSemicolon() || pc->Is(CT_COMMA) || pc->Is(CT_OC_MSG_NAME) || pc->Is(CT_SPAREN_CLOSE))) // Issue #1130, #1715 { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // End any assign operations with a semicolon on the same level if ( pc->IsSemicolon() && ( (frm.top().type == CT_IMPORT) || (frm.top().type == CT_USING))) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // End any custom macro-based open/closes if ( !token_used && (frm.top().type == CT_MACRO_OPEN) && pc->Is(CT_MACRO_CLOSE)) { token_used = true; LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // End any CPP/ObjC class colon stuff if ( ( (frm.top().type == CT_CLASS_COLON) || (frm.top().type == CT_CONSTR_COLON)) && ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_OC_END) || pc->Is(CT_OC_SCOPE) || pc->Is(CT_OC_PROPERTY) || pc->Is(CT_TYPEDEF) // Issue #2675 || pc->Is(CT_MACRO_OPEN) || pc->Is(CT_MACRO_CLOSE) || ( language_is_set(LANG_OC) && pc->IsComment() && pc->GetParentType() == CT_COMMENT_WHOLE) // Issue #2675 || pc->IsSemicolon())) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // End ObjC class colon stuff inside of generic definition (like Test>) if ( (frm.top().type == CT_CLASS_COLON) && pc->Is(CT_ANGLE_CLOSE) && pc->GetParentType() == CT_OC_GENERIC_SPEC) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // End Objc nested message and boxed array // TODO: ideally formatting would know which opens occurred on a line and group closes in the same manor if ( language_is_set(LANG_OC) && pc->Is(CT_SQUARE_CLOSE) && pc->GetParentType() == CT_OC_AT && frm.top().level >= pc->GetLevel()) { size_t count = 1; Chunk *next = pc->GetNextNc(); while ( next->IsNotNullChunk() && ( ( next->Is(CT_BRACE_CLOSE) && next->GetParentType() == CT_OC_AT) || ( next->Is(CT_SQUARE_CLOSE) && next->GetParentType() == CT_OC_AT) || ( next->Is(CT_SQUARE_CLOSE) && next->GetParentType() == CT_OC_MSG))) { count++; next = next->GetNextNc(); } count = std::min(count, frm.size()); if (count > 0) { while (count-- > 0) { if (frm.top().type == CT_SQUARE_OPEN) { if (frm.paren_count == 0) { fprintf(stderr, "%s(%d): frm.paren_count is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } frm.paren_count--; } LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } if (next) { // End any assign operations with a semicolon on the same level if (is_end_of_assignment(next, frm)) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } } // Indent the brace to match outer most brace/square indent_column_set(frm.top().indent_tmp); continue; } } // a case is ended with another case or a close brace if ( (frm.top().type == CT_CASE) && ( pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_CASE))) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } if (frm.top().pop_pc->IsNotNullChunk()) { LOG_FMT(LINDLINE, "%s(%d): pop_pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, frm.top().pop_pc->GetOrigLine(), frm.top().pop_pc->GetOrigCol(), frm.top().pop_pc->Text(), get_token_name(frm.top().pop_pc->GetType())); } LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); if ( (frm.top().type == CT_MEMBER) && frm.top().pop_pc == pc) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } if ( (frm.top().type == CT_LAMBDA) && ( pc->Is(CT_SEMICOLON) || pc->Is(CT_COMMA) || pc->Is(CT_BRACE_OPEN))) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // a class scope is ended with another class scope or a close brace log_rule_B("indent_access_spec_body"); if ( options::indent_access_spec_body() && (frm.top().type == CT_ACCESS) && ( pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_ACCESS))) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // return & throw are ended with a semicolon if ( pc->IsSemicolon() && ( (frm.top().type == CT_RETURN) || (frm.top().type == CT_THROW))) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // an OC SCOPE ('-' or '+') ends with a semicolon or brace open if ( (frm.top().type == CT_OC_SCOPE) && ( pc->IsSemicolon() || pc->Is(CT_BRACE_OPEN))) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } /* * a typedef and an OC SCOPE ('-' or '+') ends with a semicolon or * brace open */ if ( (frm.top().type == CT_TYPEDEF) && ( pc->IsSemicolon() || pc->IsParenOpen() || pc->Is(CT_BRACE_OPEN))) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // an SQL EXEC is ended with a semicolon if ( (frm.top().type == CT_SQL_EXEC) && pc->IsSemicolon()) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // an CLASS is ended with a semicolon or brace open if ( (frm.top().type == CT_CLASS) && ( pc->Is(CT_CLASS_COLON) || pc->Is(CT_BRACE_OPEN) || pc->IsSemicolon())) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } log_rule_B("indent_oc_inside_msg_sel"); // Pop OC msg selector stack if ( options::indent_oc_inside_msg_sel() && (frm.top().type != CT_SQUARE_OPEN) && frm.top().level >= pc->GetLevel() && ( pc->Is(CT_OC_MSG_FUNC) || pc->Is(CT_OC_MSG_NAME))) // Issue #2658 { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // Close out parenthesis and squares if ( (frm.top().type == (pc->GetType() - 1)) && ( pc->Is(CT_PAREN_CLOSE) || pc->Is(CT_LPAREN_CLOSE) // Issue #3054 || pc->Is(CT_SPAREN_CLOSE) || pc->Is(CT_FPAREN_CLOSE) || pc->Is(CT_SQUARE_CLOSE) || pc->Is(CT_ANGLE_CLOSE))) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); if (frm.paren_count == 0) { fprintf(stderr, "%s(%d): frm.paren_count is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } frm.paren_count--; } } } while (old_frm_size > frm.size()); // Grab a copy of the current indent indent_column_set(frm.top().indent_tmp); // Issue #3294 log_indent_tmp(); log_rule_B("indent_single_newlines"); if ( pc->Is(CT_NEWLINE) && options::indent_single_newlines()) { pc->SetNlColumn(indent_column); } if ( !pc->IsCommentOrNewline() && log_sev_on(LINDPC)) { LOG_FMT(LINDPC, "%s(%d):\n", __func__, __LINE__); LOG_FMT(LINDPC, " -=[ pc orig line is %zu, orig col is %zu, Text() is '%s' ]=-, frm.size() is %zu\n", pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), frm.size()); for (size_t ttidx = frm.size() - 1; ttidx > 0; ttidx--) { LOG_FMT(LINDPC, " [%zu %zu:%zu '%s' %s/%s tmp=%zu indent=%zu brace_indent=%zu indent_tab=%zu indent_cont=%d level=%zu pc brace level=%zu]\n", ttidx, frm.at(ttidx).pc->GetOrigLine(), frm.at(ttidx).pc->GetOrigCol(), frm.at(ttidx).pc->Text(), get_token_name(frm.at(ttidx).type), get_token_name(frm.at(ttidx).pc->GetParentType()), frm.at(ttidx).indent_tmp, frm.at(ttidx).indent, frm.at(ttidx).brace_indent, frm.at(ttidx).indent_tab, frm.at(ttidx).indent_cont, frm.at(ttidx).level, frm.at(ttidx).pc->GetBraceLevel()); } } char copy[1000]; LOG_FMT(LINDENT2, "%s(%d): orig line is %zu, orig col is %zu, column is %zu, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetColumn(), pc->ElidedText(copy)); // Issue #672 if ( pc->Is(CT_BRACE_OPEN) && classFound) { LOG_FMT(LINDENT, "%s(%d): CT_BRACE_OPEN found, CLOSE IT\n", __func__, __LINE__); LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); classFound = false; } /* * Handle stuff that can affect the current indent: * - brace close * - vbrace open * - brace open * - case (immediate) * - labels (immediate) * - class colons (immediate) * * And some stuff that can't * - open paren * - open square * - assignment * - return */ log_rule_B("indent_braces"); log_rule_B("indent_braces_no_func"); log_rule_B("indent_braces_no_class"); log_rule_B("indent_braces_no_struct"); const bool brace_indent = ( ( pc->Is(CT_BRACE_CLOSE) || pc->Is(CT_BRACE_OPEN)) && options::indent_braces() && ( !options::indent_braces_no_func() || pc->GetParentType() != CT_FUNC_DEF) && ( !options::indent_braces_no_func() || pc->GetParentType() != CT_FUNC_CLASS_DEF) && ( !options::indent_braces_no_class() || pc->GetParentType() != CT_CLASS) && ( !options::indent_braces_no_struct() || pc->GetParentType() != CT_STRUCT)); LOG_FMT(LINDENT, "%s(%d): brace_indent is %s\n", __func__, __LINE__, brace_indent ? "true" : "false"); if (pc->Is(CT_BRACE_CLOSE)) { if (language_is_set(LANG_OC)) { if ( frm.top().type == CT_BRACE_OPEN && frm.top().level >= pc->GetLevel()) { size_t count = 1; Chunk *next = pc->GetNextNc(); while ( next->IsNotNullChunk() && ( ( next->Is(CT_BRACE_CLOSE) && next->GetParentType() == CT_OC_AT) || ( next->Is(CT_SQUARE_CLOSE) && next->GetParentType() == CT_OC_AT))) { count++; next = next->GetNextNc(); } count = std::min(count, frm.size()); // End Objc nested boxed dictionary // TODO: ideally formatting would know which opens occurred on a line and group closes in the same manor if ( count > 0 && pc->Is(CT_BRACE_CLOSE) && pc->GetParentType() == CT_OC_AT) { if (frm.top().ip.ref) { pc->IndentData().ref = frm.top().ip.ref; pc->IndentData().delta = 0; } while (count-- > 0) { LOG_CHUNK(LINDLINE, pc); frm.pop(__func__, __LINE__, pc); } if (next) { // End any assign operations with a semicolon on the same level if (is_end_of_assignment(next, frm)) { LOG_CHUNK(LINDLINE, pc); frm.pop(__func__, __LINE__, pc); } } // Indent the brace to match outer most brace/square if (frm.top().indent_cont) { indent_column_set(frm.top().indent_tmp - indent_size); } else { indent_column_set(frm.top().indent_tmp); } } else { // Indent the brace to match the open brace indent_column_set(frm.top().brace_indent); if (frm.top().ip.ref) { pc->IndentData().ref = frm.top().ip.ref; pc->IndentData().delta = 0; } LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } } } else if (frm.top().brace_indent) // Issue #3421 { // Indent the brace to match the open brace indent_column_set(frm.top().brace_indent); if (frm.top().ip.ref) { pc->IndentData().ref = frm.top().ip.ref; pc->IndentData().delta = 0; } LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } } else if (pc->Is(CT_VBRACE_OPEN)) { frm.push(pc, __func__, __LINE__); log_rule_B("indent_min_vbrace_open"); size_t iMinIndent = options::indent_min_vbrace_open(); if (indent_size > iMinIndent) { iMinIndent = indent_size; } size_t iNewIndent = frm.prev().indent + iMinIndent; log_rule_B("indent_vbrace_open_on_tabstop"); if (options::indent_vbrace_open_on_tabstop()) { iNewIndent = next_tab_column(iNewIndent); } frm.top().indent = iNewIndent; log_indent(); frm.top().indent_tmp = frm.top().indent; frm.top().indent_tab = frm.top().indent; log_indent_tmp(); // Always indent on virtual braces indent_column_set(frm.top().indent_tmp); } else if ( pc->Is(CT_BRACE_OPEN) && pc->GetNext()->IsNot(CT_NAMESPACE)) { LOG_FMT(LINDENT2, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); frm.push(pc, __func__, __LINE__); log_rule_B("indent_macro_brace"); if ( !options::indent_macro_brace() && frm.prev().type == CT_PP_DEFINE && frm.prev().open_line == frm.top().open_line) { LOG_FMT(LINDENT2, "%s(%d): indent_macro_brace\n", __func__, __LINE__); } else if ( options::indent_cpp_lambda_body() && pc->GetParentType() == CT_CPP_LAMBDA) { log_rule_B("indent_cpp_lambda_body"); frm.top().brace_indent = frm.prev().indent; Chunk *head = frm.top().pc->GetPrevNcNnlNpp(); Chunk *tail = Chunk::NullChunkPtr; Chunk *frm_prev = frm.prev().pc; bool enclosure = ( frm_prev->GetParentType() != CT_FUNC_DEF // Issue #3407 && frm_prev != frm_prev->GetClosingParen()); bool linematch = true; for (auto it = frm.rbegin(); it != frm.rend() && tail->IsNullChunk(); ++it) { if (it->pc && it->pc != frm.top().pc) { linematch &= it->pc->IsOnSameLine(head); } Chunk *match = it->pc->GetClosingParen(); if (match->IsNullChunk()) { continue; } Chunk *target = match->GetNextNcNnlNpp(); while ( tail->IsNullChunk() && target->IsNotNullChunk()) { if ( target->IsSemicolon() && target->GetLevel() == match->GetLevel()) { tail = target; } else if (target->GetLevel() < match->GetLevel()) { break; } else { target = target->GetNextNcNnlNpp(); } } } bool toplevel = true; for (auto it = frm.rbegin(); it != frm.rend() && tail->IsNotNullChunk(); ++it) { if (!it->pc->Is(CT_FPAREN_OPEN)) { continue; } if (it->pc->GetLevel() < tail->GetLevel()) { toplevel = false; break; } } // A few things to check: // 1. The matching brace is on the same line as the ending semicolon // 2a. If it's an assignment, check that both sides of the assignment operator are on the same line // 2b. If it's inside some closure, check that all the frames are on the same line, // and it is in the top level closure, and indent_continue is non-zero bool sameLine = frm.top().pc->GetClosingParen()->IsOnSameLine(tail); bool isAssignSameLine = !enclosure && options::align_assign_span() == 0 && !options::indent_align_assign() && frm.prev().pc->GetPrevNcNnlNpp()->IsOnSameLine(frm.prev().pc) && frm.prev().pc->IsOnSameLine(frm.prev().pc->GetNextNcNnlNpp()); bool closureSameLineTopLevel = (options::indent_continue() > 0) && enclosure && linematch && toplevel && frm.top().pc->GetClosingParen()->IsOnSameLine(frm.top().pc); if (sameLine && ((isAssignSameLine) || (closureSameLineTopLevel))) { if (indent_size > frm.top().brace_indent) // if options::indent_indent_columns() is too big { frm.top().brace_indent = 1; } else { frm.top().brace_indent -= indent_size; } } indent_column_set(frm.top().brace_indent); frm.top().indent = indent_column + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); frm.prev().indent_tmp = frm.top().indent_tmp; log_indent_tmp(); } else if ( language_is_set(LANG_CPP) && options::indent_cpp_lambda_only_once() && (pc->GetParentType() == CT_CPP_LAMBDA)) { // test example cpp:30756 log_rule_B("indent_cpp_lambda_only_once"); size_t namespace_indent_to_ignore = 0; // Issue #1813 log_rule_B("indent_namespace"); if (!options::indent_namespace()) { for (auto i = frm.rbegin(); i != frm.rend(); ++i) { if (i->ns_cnt) { namespace_indent_to_ignore = i->ns_cnt; break; } } } // Issue # 1296 frm.top().brace_indent = 1 + ((pc->GetBraceLevel() - namespace_indent_to_ignore) * indent_size); indent_column_set(frm.top().brace_indent); frm.top().indent = indent_column + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); frm.prev().indent_tmp = frm.top().indent_tmp; log_indent_tmp(); } else if ( language_is_set(LANG_CS | LANG_JAVA) && options::indent_cs_delegate_brace() && ( pc->GetParentType() == CT_LAMBDA || pc->GetParentType() == CT_DELEGATE)) { log_rule_B("indent_cs_delegate_brace"); frm.top().brace_indent = 1 + ((pc->GetBraceLevel() + 1) * indent_size); indent_column_set(frm.top().brace_indent); frm.top().indent = indent_column + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); frm.prev().indent_tmp = frm.top().indent_tmp; log_indent_tmp(); } else if ( language_is_set(LANG_CS | LANG_JAVA) && !options::indent_cs_delegate_brace() && !options::indent_align_paren() && ( pc->GetParentType() == CT_LAMBDA || pc->GetParentType() == CT_DELEGATE)) { log_rule_B("indent_cs_delegate_brace"); log_rule_B("indent_align_paren"); frm.top().brace_indent = frm.prev().indent; // Issue # 1620, UNI-24090.cs if (frm.prev().pc->IsOnSameLine(frm.top().pc->GetPrevNcNnlNpp())) { frm.top().brace_indent -= indent_size; } indent_column_set(frm.top().brace_indent); frm.top().indent = indent_column + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); frm.prev().indent_tmp = frm.top().indent_tmp; log_indent_tmp(); } else if ( !options::indent_paren_open_brace() && !language_is_set(LANG_CS) && pc->GetParentType() == CT_CPP_LAMBDA && ( pc->TestFlags(PCF_IN_FCN_DEF) || pc->TestFlags(PCF_IN_FCN_CTOR)) // Issue #2152 && pc->GetNextNc()->IsNewline()) { log_rule_B("indent_paren_open_brace"); // Issue #1165 LOG_FMT(LINDENT2, "%s(%d): orig line is %zu, brace level is %zu, for '%s', pc->GetLevel() is %zu, pc(-1)->GetLevel() is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetBraceLevel(), pc->Text(), pc->GetLevel(), frm.prev().pc->GetLevel()); frm.top().brace_indent = 1 + ((pc->GetBraceLevel() + 1) * indent_size); indent_column_set(frm.top().brace_indent); frm.top().indent = frm.prev().indent_tmp; log_indent(); frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } // any '{' that is inside of a '(' overrides the '(' indent // only to help the vim command } else if ( !options::indent_paren_open_brace() && frm.prev().pc->IsParenOpen() && pc->GetNextNc()->IsNewline()) { log_rule_B("indent_paren_open_brace"); LOG_FMT(LINDENT2, "%s(%d): orig line is %zu, brace level is %zu, for '%s', pc->GetLevel() is %zu, pc(-1)->GetLevel() is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetBraceLevel(), pc->Text(), pc->GetLevel(), frm.prev().pc->GetLevel()); // FIXME: I don't know how much of this is necessary, but it seems to work frm.top().brace_indent = 1 + (pc->GetBraceLevel() * indent_size); indent_column_set(frm.top().brace_indent); frm.top().indent = indent_column + indent_size; log_indent(); if ( (pc->GetParentType() == CT_OC_BLOCK_EXPR) && pc->TestFlags(PCF_IN_OC_MSG)) { frm.top().indent = frm.prev().indent_tmp + indent_size; log_indent(); frm.top().brace_indent = frm.prev().indent_tmp; indent_column_set(frm.top().brace_indent); } frm.top().indent_tab = frm.top().indent; frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); frm.prev().indent_tmp = frm.top().indent_tmp; } else if ( frm.paren_count != 0 && !pc->TestFlags(PCF_IN_LAMBDA)) // Issue #3761 { if (frm.top().pc->GetParentType() == CT_OC_BLOCK_EXPR) { log_rule_B("indent_oc_block_msg"); if ( pc->TestFlags(PCF_IN_OC_MSG) && options::indent_oc_block_msg()) { frm.top().ip.ref = oc_msg_block_indent(pc, false, false, false, true); log_rule_B("indent_oc_block_msg"); frm.top().ip.delta = options::indent_oc_block_msg(); } log_rule_B("indent_oc_block"); log_rule_B("indent_oc_block_msg_xcode_style"); if ( options::indent_oc_block() || options::indent_oc_block_msg_xcode_style()) { bool in_oc_msg = pc->TestFlags(PCF_IN_OC_MSG); log_rule_B("indent_oc_block_msg_from_keyword"); bool indent_from_keyword = options::indent_oc_block_msg_from_keyword() && in_oc_msg; log_rule_B("indent_oc_block_msg_from_colon"); bool indent_from_colon = options::indent_oc_block_msg_from_colon() && in_oc_msg; log_rule_B("indent_oc_block_msg_from_caret"); bool indent_from_caret = options::indent_oc_block_msg_from_caret() && in_oc_msg; log_rule_B("indent_oc_block_msg_from_brace"); bool indent_from_brace = options::indent_oc_block_msg_from_brace() && in_oc_msg; /* * In "Xcode indent mode", we want to indent: * - if the colon is aligned (namely, if a newline has been * added before it), indent_from_brace * - otherwise, indent from previous block (the "else" statement here) */ log_rule_B("indent_oc_block_msg_xcode_style"); if (options::indent_oc_block_msg_xcode_style()) { Chunk *bbc = pc->GetClosingParen(); // block brace close '}' Chunk *bbc_next_ncnl = bbc->GetNextNcNnl(); if ( bbc_next_ncnl->GetType() == CT_OC_MSG_NAME || bbc_next_ncnl->GetType() == CT_OC_MSG_FUNC) { indent_from_brace = false; indent_from_colon = false; indent_from_caret = false; indent_from_keyword = true; } else { indent_from_brace = false; indent_from_colon = false; indent_from_caret = false; indent_from_keyword = false; } } Chunk *ref = oc_msg_block_indent(pc, indent_from_brace, indent_from_caret, indent_from_colon, indent_from_keyword); if (ref) { frm.top().indent = indent_size + ref->GetColumn(); } else { frm.top().indent = 1 + ((pc->GetBraceLevel() + 1) * indent_size); } log_indent(); indent_column_set(frm.top().indent - indent_size); } else { frm.top().indent = frm.prev().indent_tmp + indent_size; log_indent(); } } else if ( frm.top().pc->GetType() == CT_BRACE_OPEN && frm.top().pc->GetParentType() == CT_OC_AT) { // We are inside @{ ... } -- indent one tab from the paren if (frm.prev().indent_cont) { frm.top().indent = frm.prev().indent_tmp; } else { frm.top().indent = frm.prev().indent_tmp + indent_size; } log_indent(); } // Issue # 1620, UNI-24090.cs else if ( frm.prev().pc->IsOnSameLine(frm.top().pc) && !options::indent_align_paren() && frm.prev().pc->IsParenOpen() && !pc->TestFlags(PCF_ONE_LINER)) { log_rule_B("indent_align_paren"); // We are inside ({ ... }) -- where { and ( are on the same line, avoiding double indentations. // only to help the vim command } frm.top().brace_indent = frm.prev().indent - indent_size; indent_column_set(frm.top().brace_indent); frm.top().indent = frm.prev().indent_tmp; log_indent(); } else if ( frm.prev().pc->IsOnSameLine(frm.top().pc->GetPrevNcNnlNpp()) && !options::indent_align_paren() && frm.prev().pc->IsParenOpen() && !pc->TestFlags(PCF_ONE_LINER)) { log_rule_B("indent_align_paren"); // We are inside ({ ... }) -- where { and ( are on adjacent lines, avoiding indentation of brace. // only to help the vim command } frm.top().brace_indent = frm.prev().indent - indent_size; indent_column_set(frm.top().brace_indent); frm.top().indent = frm.prev().indent_tmp; log_indent(); } else if ( options::indent_oc_inside_msg_sel() && ( frm.prev().type == CT_OC_MSG_FUNC || frm.prev().type == CT_OC_MSG_NAME)) // Issue #2658 { log_rule_B("indent_oc_inside_msg_sel"); // [Class Message:{ frm.top().indent = frm.prev().pc->GetColumn() + indent_size; log_indent(); indent_column_set(frm.prev().pc->GetColumn()); } // Issue #3813 else if (pc->TestFlags(PCF_OC_IN_BLOCK) && pc->GetParentType() == CT_SWITCH) { frm.top().indent = frm.prev().indent_tmp; } else { // We are inside ({ ... }) -- indent one tab from the paren frm.top().indent = frm.prev().indent_tmp + indent_size; if (!frm.prev().pc->IsParenOpen()) { frm.top().indent_tab = frm.top().indent; } log_indent(); } } else if ( frm.top().pc->GetType() == CT_BRACE_OPEN && frm.top().pc->GetParentType() == CT_OC_AT) { // We are inside @{ ... } -- indent one tab from the paren if (frm.prev().indent_cont) { frm.top().indent = frm.prev().indent_tmp; } else { frm.top().indent = frm.prev().indent_tmp + indent_size; frm.top().indent_tab = frm.top().indent; } log_indent(); } else if ( ( pc->GetParentType() == CT_BRACED_INIT_LIST || ( !options::indent_compound_literal_return() && pc->GetParentType() == CT_C_CAST)) && frm.prev().type == CT_RETURN) { log_rule_B("indent_compound_literal_return"); // we're returning either a c compound literal (CT_C_CAST) or a // C++11 initialization list (CT_BRACED_INIT_LIST), use indent from the return. if (frm.prev().indent_cont) { frm.top().indent = frm.prev().indent_tmp; } else { frm.top().indent = frm.prev().indent_tmp + indent_size; } log_indent(); } else { // Use the prev indent level + indent_size. if (pc->GetParentType() == CT_SWITCH) { frm.top().indent = frm.prev().indent + options::indent_switch_body(); } else { frm.top().indent = frm.prev().indent + indent_size; } LOG_FMT(LINDLINE, "%s(%d): frm.pse_tos is %zu, ... indent is %zu\n", __func__, __LINE__, frm.size() - 1, frm.top().indent); LOG_FMT(LINDLINE, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', parent type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetParentType())); // If this brace is part of a statement, bump it out by indent_brace if ( pc->GetParentType() == CT_IF || pc->GetParentType() == CT_ELSE || pc->GetParentType() == CT_ELSEIF || pc->GetParentType() == CT_TRY || pc->GetParentType() == CT_CATCH || pc->GetParentType() == CT_DO || pc->GetParentType() == CT_WHILE || pc->GetParentType() == CT_USING_STMT || pc->GetParentType() == CT_SWITCH || pc->GetParentType() == CT_SYNCHRONIZED || pc->GetParentType() == CT_FOR) { if (parent_token_indent != 0) { frm.top().indent += parent_token_indent - indent_size; log_indent(); } else { log_rule_B("indent_brace"); frm.top().indent += options::indent_brace(); log_indent(); indent_column_set(indent_column + options::indent_brace()); } } else if (pc->GetParentType() == CT_CASE) { if (options::indent_ignore_case_brace()) { log_rule_B("indent_ignore_case_brace"); indent_column_set(pc->GetOrigCol()); } else { log_rule_B("indent_case_brace"); const auto tmp_indent = static_cast(frm.prev().indent) - static_cast(indent_size) + options::indent_case_brace(); /* * An open brace with the parent of case does not indent by default * UO_indent_case_brace can be used to indent the brace. * So we need to take the CASE indent, subtract off the * indent_size that was added above and then add indent_case_brace. * may take negative value */ indent_column_set(max(tmp_indent, 0)); } // Stuff inside the brace still needs to be indented frm.top().indent = indent_column + indent_size; log_indent(); frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } else if ( pc->GetParentType() == CT_CLASS && !options::indent_class()) { log_rule_B("indent_class"); LOG_FMT(LINDENT, "%s(%d): orig line is %zu, orig col is %zu, text is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); frm.top().indent -= indent_size; log_indent(); } else if (pc->GetParentType() == CT_NAMESPACE) { frm.top().ns_cnt = frm.prev().ns_cnt + 1; log_rule_B("indent_namespace"); log_rule_B("indent_namespace_single_indent"); if ( options::indent_namespace() && options::indent_namespace_single_indent()) { if (frm.top().ns_cnt >= 2) { // undo indent on all except the first namespace frm.top().indent -= indent_size; log_indent(); } indent_column_set(frm.prev(frm.top().ns_cnt).indent); } else if ( options::indent_namespace() && options::indent_namespace_inner_only()) { if (frm.top().ns_cnt == 1) { // undo indent on first namespace only frm.top().indent -= indent_size; log_indent(); } } else if ( pc->TestFlags(PCF_LONG_BLOCK) || !options::indent_namespace()) { log_rule_B("indent_namespace"); // don't indent long blocks frm.top().indent -= indent_size; log_indent(); } else // indenting 'short' namespace { log_rule_B("indent_namespace_level"); if (options::indent_namespace_level() > 0) { frm.top().indent -= indent_size; log_indent(); frm.top().indent += options::indent_namespace_level(); log_indent(); } } } else if ( pc->GetParentType() == CT_EXTERN && !options::indent_extern()) { log_rule_B("indent_extern"); frm.top().indent -= indent_size; log_indent(); } frm.top().indent_tab = frm.top().indent; } if (pc->TestFlags(PCF_DONT_INDENT)) { frm.top().indent = pc->GetColumn(); log_indent(); indent_column_set(pc->GetColumn()); } else { /* * If there isn't a newline between the open brace and the next * item, just indent to wherever the next token is. * This covers this sort of stuff: * { a++; * b--; }; */ Chunk *next = pc->GetNextNcNnl(); if (next->IsNullChunk()) { break; } Chunk *prev = pc->GetPrev(); if ( pc->GetParentType() == CT_BRACED_INIT_LIST && prev->Is(CT_BRACE_OPEN) && prev->GetParentType() == CT_BRACED_INIT_LIST) { indent_column = frm.prev().brace_indent; frm.top().indent = frm.prev().indent; log_indent(); } else if ( !pc->IsNewlineBetween(next) && next->GetParentType() != CT_BRACED_INIT_LIST && options::indent_token_after_brace() && !pc->TestFlags(PCF_ONE_LINER)) // Issue #1108 { log_rule_B("indent_token_after_brace"); frm.top().indent = next->GetColumn(); log_indent(); } frm.top().indent_tmp = frm.top().indent; frm.top().open_line = pc->GetOrigLine(); log_indent_tmp(); log_rule_B("Update the indent_column"); // Update the indent_column if needed if ( brace_indent || parent_token_indent != 0) { indent_column_set(frm.top().indent_tmp); log_indent_tmp(); } } // Save the brace indent frm.top().brace_indent = indent_column; } else if (pc->Is(CT_SQL_END)) { if (frm.top().type == CT_SQL_BEGIN) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); indent_column_set(frm.top().indent_tmp); log_indent_tmp(); } } else if ( pc->Is(CT_SQL_BEGIN) || pc->Is(CT_MACRO_OPEN) || ( pc->Is(CT_CLASS) && language_is_set(LANG_CS))) // Issue #3536 { frm.push(pc, __func__, __LINE__); frm.top().indent = frm.prev().indent + indent_size; log_indent(); frm.top().indent_tmp = frm.top().indent; frm.top().indent_tab = frm.top().indent; log_indent_tmp(); } else if (pc->Is(CT_SQL_EXEC)) { frm.push(pc, __func__, __LINE__); frm.top().indent = frm.prev().indent + indent_size; log_indent(); frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } else if (pc->Is(CT_MACRO_ELSE)) { if (frm.top().type == CT_MACRO_OPEN) { indent_column_set(frm.prev().indent); } } else if (pc->Is(CT_CASE)) { // Start a case - indent UO_indent_switch_case from the switch level log_rule_B("indent_switch_case"); const size_t tmp = frm.top().indent + indent_size - options::indent_switch_body() + options::indent_switch_case(); frm.push(pc, __func__, __LINE__); frm.top().indent = tmp; log_indent(); log_rule_B("indent_case_shift"); frm.top().indent_tmp = tmp - indent_size + options::indent_case_shift(); frm.top().indent_tab = tmp; log_indent_tmp(); // Always set on case statements indent_column_set(frm.top().indent_tmp); if (options::indent_case_comment()) { // comments before 'case' need to be aligned with the 'case' Chunk *pct = pc; while ( ((pct = pct->GetPrevNnl())->IsNotNullChunk()) && pct->IsComment()) { Chunk *t2 = pct->GetPrev(); if (t2->IsNewline()) { pct->SetColumn(frm.top().indent_tmp); pct->SetColumnIndent(pct->GetColumn()); } } } } else if (pc->Is(CT_BREAK)) { Chunk *prev = pc->GetPrevNcNnl(); if ( prev->Is(CT_BRACE_CLOSE) && prev->GetParentType() == CT_CASE) { // issue #663 + issue #1366 Chunk *prev_prev_newline = pc->GetPrevNl()->GetPrevNl(); if (prev_prev_newline->IsNotNullChunk()) { // This only affects the 'break', so no need for a stack entry indent_column_set(prev_prev_newline->GetNext()->GetColumn()); } } } else if (pc->Is(CT_LABEL)) { if (options::indent_ignore_label()) { log_rule_B("indent_ignore_label"); indent_column_set(pc->GetOrigCol()); } else { log_rule_B("indent_label"); const int val = options::indent_label(); size_t pse_indent = frm.top().indent; // Labels get sent to the left or backed up if (val > 0) { indent_column_set(val); Chunk *next = pc->GetNext()->GetNext(); // colon + possible statement if ( next->IsNotNullChunk() && !next->IsNewline() // label (+ 2, because there is colon and space after it) must fit into indent && (val + pc->Len() + 2 <= pse_indent)) { reindent_line(next, pse_indent); } } else { bool no_underflow = (size_t)(abs(val)) < pse_indent; indent_column_set((no_underflow ? (pse_indent + val) : 0)); } } } else if (pc->Is(CT_ACCESS)) { log_rule_B("indent_access_spec_body"); if (options::indent_access_spec_body()) { const size_t tmp = frm.top().indent + indent_size; frm.push(pc, __func__, __LINE__); frm.top().indent = tmp; log_indent(); frm.top().indent_tmp = tmp - indent_size; frm.top().indent_tab = tmp; log_indent_tmp(); /* * If we are indenting the body, then we must leave the access spec * indented at brace level */ indent_column_set(frm.top().indent_tmp); // Issues 1161 + 2704 // comments before 'access specifier' need to be aligned with the 'access specifier' // unless it is a Doxygen comment Chunk *pct = pc; while ( ((pct = pct->GetPrevNnl())->IsNotNullChunk()) && pct->IsComment() && !pct->IsDoxygenComment()) { Chunk *t2 = pct->GetPrev(); if (t2->IsNewline()) { pct->SetColumn(frm.top().indent_tmp); pct->SetColumnIndent(pct->GetColumn()); } } } else { // Access spec labels get sent to the left or backed up log_rule_B("indent_access_spec"); int val = options::indent_access_spec(); if (val > 0) { indent_column_set(val); } else { size_t pse_indent = frm.top().indent; bool no_underflow = (size_t)(abs(val)) < pse_indent; indent_column_set(no_underflow ? (pse_indent + val) : 0); } } } else if ( pc->Is(CT_CLASS_COLON) || pc->Is(CT_CONSTR_COLON)) { // just indent one level frm.push(pc, __func__, __LINE__); frm.top().indent = frm.prev().indent_tmp + indent_size; log_indent(); frm.top().indent_tmp = frm.top().indent; frm.top().indent_tab = frm.top().indent; log_indent_tmp(); if (pc->Is(CT_CLASS_COLON)) { if (options::indent_ignore_before_class_colon()) { log_rule_B("indent_ignore_before_class_colon"); frm.top().indent_tmp = pc->GetOrigCol(); log_indent_tmp(); } else if (options::indent_before_class_colon() != 0) { log_rule_B("indent_before_class_colon"); frm.top().indent_tmp = std::max(frm.top().indent_tmp + options::indent_before_class_colon(), 0); log_indent_tmp(); } } indent_column_set(frm.top().indent_tmp); log_rule_B("indent_class_colon"); if ( options::indent_class_colon() && pc->Is(CT_CLASS_COLON)) { log_rule_B("indent_class_on_colon"); if (options::indent_class_on_colon()) { frm.top().indent = pc->GetColumn(); log_indent(); } else { Chunk *next = pc->GetNext(); if ( next->IsNotNullChunk() && !next->IsNewline()) { frm.top().indent = next->GetColumn(); log_indent(); } } } else if (pc->Is(CT_CONSTR_COLON)) { if (options::indent_ignore_before_constr_colon()) { log_rule_B("indent_ignore_before_constr_colon"); frm.top().indent_tmp = pc->GetOrigCol(); indent_column_set(frm.top().indent_tmp); } if (options::indent_constr_colon()) { log_rule_B("indent_constr_colon"); Chunk *prev = pc->GetPrev(); if (prev->IsNewline()) { log_rule_B("indent_ctor_init_following"); frm.top().indent += options::indent_ctor_init_following(); log_indent(); } // TODO: Create a dedicated indent_constr_on_colon? log_rule_B("indent_class_on_colon"); if (options::indent_ctor_init() != 0) { log_rule_B("indent_ctor_init"); /* * If the std::max() calls were specialized with size_t (the type of the underlying variable), * they would never actually do their job, because size_t is unsigned and therefore even * a "negative" result would be always greater than zero. * Using ptrdiff_t (a standard signed type of the same size as size_t) in order to avoid that. */ frm.top().indent = std::max(frm.top().indent + options::indent_ctor_init(), 0); log_indent(); frm.top().indent_tmp = std::max(frm.top().indent_tmp + options::indent_ctor_init(), 0); frm.top().indent_tab = std::max(frm.top().indent_tab + options::indent_ctor_init(), 0); log_indent_tmp(); indent_column_set(frm.top().indent_tmp); } else if (options::indent_class_on_colon()) { frm.top().indent = pc->GetColumn(); log_indent(); } else { Chunk *next = pc->GetNext(); if ( next->IsNotNullChunk() && !next->IsNewline()) { frm.top().indent = next->GetColumn(); log_indent(); } } } } } else if ( pc->Is(CT_PAREN_OPEN) && ( pc->GetParentType() == CT_ASM || ( pc->GetPrevNcNnl()->IsNotNullChunk() && pc->GetPrevNcNnl()->GetType() == CT_ASM)) && options::indent_ignore_asm_block()) { log_rule_B("indent_ignore_asm_block"); Chunk *tmp = pc->GetClosingParen(); int move = 0; if ( pc->GetPrev()->IsNewline() && pc->GetColumn() != indent_column) { move = indent_column - pc->GetColumn(); } else { move = pc->GetColumn() - pc->GetOrigCol(); } do { if (!pc->TestFlags(PCF_IN_PREPROC)) { pc->SetColumn(pc->GetOrigCol() + move); } pc = pc->GetNext(); } while (pc != tmp); reindent_line(pc, indent_column); } else if ( pc->Is(CT_PAREN_OPEN) || pc->Is(CT_LPAREN_OPEN) // Issue #3054 || pc->Is(CT_SPAREN_OPEN) || pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_SQUARE_OPEN) || pc->Is(CT_ANGLE_OPEN)) { /* * Open parenthesis and squares - never update indent_column, * unless right after a newline. */ frm.push(pc, __func__, __LINE__); if ( pc->GetPrev()->IsNewline() && pc->GetColumn() != indent_column && !pc->TestFlags(PCF_DONT_INDENT)) { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, indent => %zu, text is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } frm.top().indent = pc->GetColumn() + pc->Len(); log_indent(); if ( pc->Is(CT_SQUARE_OPEN) && language_is_set(LANG_D)) { frm.top().indent_tab = frm.top().indent; } bool skipped = false; log_rule_B("indent_inside_ternary_operator"); log_rule_B("indent_align_paren"); if ( options::indent_inside_ternary_operator() && ( pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_PAREN_OPEN)) && frm.size() > 2 && ( frm.prev().type == CT_QUESTION || frm.prev().type == CT_COND_COLON) && !options::indent_align_paren()) { frm.top().indent = frm.prev().indent_tmp + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } else if ( ( pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_ANGLE_OPEN)) && ( ( options::indent_func_call_param() && ( pc->GetParentType() == CT_FUNC_CALL || pc->GetParentType() == CT_FUNC_CALL_USER)) || ( options::indent_func_proto_param() && pc->GetParentType() == CT_FUNC_PROTO) || ( options::indent_func_class_param() && ( pc->GetParentType() == CT_FUNC_CLASS_DEF || pc->GetParentType() == CT_FUNC_CLASS_PROTO)) || ( options::indent_template_param() && pc->GetParentType() == CT_TEMPLATE) || ( options::indent_func_ctor_var_param() && pc->GetParentType() == CT_FUNC_CTOR_VAR) || ( options::indent_func_def_param() && pc->GetParentType() == CT_FUNC_DEF) || ( !options::indent_func_def_param() // Issue #931 && pc->GetParentType() == CT_FUNC_DEF && options::indent_func_def_param_paren_pos_threshold() > 0 && pc->GetOrigCol() > options::indent_func_def_param_paren_pos_threshold()))) { log_rule_B("indent_func_call_param"); log_rule_B("indent_func_proto_param"); log_rule_B("indent_func_class_param"); log_rule_B("indent_template_param"); log_rule_B("indent_func_ctor_var_param"); log_rule_B("indent_func_def_param"); log_rule_B("indent_func_def_param_paren_pos_threshold"); // Skip any continuation indents size_t idx = (!frm.empty()) ? frm.size() - 2 : 0; while ( ( ( idx > 0 && frm.at(idx).type != CT_BRACE_OPEN && frm.at(idx).type != CT_VBRACE_OPEN && frm.at(idx).type != CT_PAREN_OPEN && frm.at(idx).type != CT_FPAREN_OPEN && frm.at(idx).type != CT_SPAREN_OPEN && frm.at(idx).type != CT_SQUARE_OPEN && frm.at(idx).type != CT_ANGLE_OPEN && frm.at(idx).type != CT_CASE && frm.at(idx).type != CT_MEMBER && frm.at(idx).type != CT_QUESTION && frm.at(idx).type != CT_COND_COLON && frm.at(idx).type != CT_LAMBDA && frm.at(idx).type != CT_ASSIGN_NL) || frm.at(idx).pc->IsOnSameLine(frm.top().pc)) && ( frm.at(idx).type != CT_CLASS_COLON && frm.at(idx).type != CT_CONSTR_COLON && !( frm.at(idx).type == CT_LAMBDA && frm.at(idx).pc->GetPrevNc()->GetType() == CT_NEWLINE))) { if (idx == 0) { fprintf(stderr, "%s(%d): idx is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } idx--; skipped = true; } // PR#381 log_rule_B("indent_param"); if (options::indent_param() != 0) { frm.top().indent = frm.at(idx).indent + options::indent_param(); log_indent(); } else { frm.top().indent = frm.at(idx).indent + indent_size; log_indent(); } log_rule_B("indent_func_param_double"); if (options::indent_func_param_double()) { // double is: Use both values of the options indent_columns and indent_param frm.top().indent += indent_size; log_indent(); } frm.top().indent_tab = frm.top().indent; } else if ( options::indent_oc_inside_msg_sel() && pc->Is(CT_PAREN_OPEN) && frm.size() > 2 && ( frm.prev().type == CT_OC_MSG_FUNC || frm.prev().type == CT_OC_MSG_NAME) && !options::indent_align_paren()) // Issue #2658 { log_rule_B("indent_oc_inside_msg_sel"); log_rule_B("indent_align_paren"); // When parens are inside OC messages, push on the parse frame stack // [Class Message:( frm.top().indent = frm.prev().pc->GetColumn() + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } else if ( pc->Is(CT_PAREN_OPEN) && !pc->GetNext()->IsNewline() && !options::indent_align_paren() && !pc->TestFlags(PCF_IN_SPAREN)) { log_rule_B("indent_align_paren"); size_t idx = frm.size() - 2; while ( idx > 0 && frm.at(idx).pc->IsOnSameLine(frm.top().pc)) { idx--; skipped = true; } frm.top().indent = frm.at(idx).indent + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; skipped = true; } else if ( ( pc->IsString("(") && !options::indent_paren_nl()) || ( pc->IsString("<") && !options::indent_paren_nl()) // TODO: add indent_angle_nl? || ( pc->IsString("[") && !options::indent_square_nl())) { log_rule_B("indent_paren_nl"); log_rule_B("indent_square_nl"); Chunk *next = pc->GetNextNc(); if (next->IsNullChunk()) { break; } log_rule_B("indent_paren_after_func_def"); log_rule_B("indent_paren_after_func_decl"); log_rule_B("indent_paren_after_func_call"); if ( next->IsNewline() && !options::indent_paren_after_func_def() && !options::indent_paren_after_func_decl() && !options::indent_paren_after_func_call()) { size_t sub = 2; if ( (frm.prev().type == CT_ASSIGN) || (frm.prev().type == CT_RETURN)) { sub = 3; } sub = frm.size() - sub; log_rule_B("indent_align_paren"); if (!options::indent_align_paren()) { sub = frm.size() - 2; while ( sub > 0 && frm.at(sub).pc->IsOnSameLine(frm.top().pc)) { sub--; skipped = true; } if ( ( frm.at(sub + 1).type == CT_CLASS_COLON || frm.at(sub + 1).type == CT_CONSTR_COLON) && (frm.at(sub + 1).pc->GetPrev()->Is(CT_NEWLINE))) { sub = sub + 1; } } frm.top().indent = frm.at(sub).indent + indent_size; log_indent(); frm.top().indent_tab = frm.top().indent; skipped = true; } else { if ( next->IsNotNullChunk() && !next->IsComment()) { if (next->Is(CT_SPACE)) { next = next->GetNextNc(); if (next->IsNullChunk()) { break; } } if (next->GetPrev()->IsComment()) { // Issue #2099 frm.top().indent = next->GetPrev()->GetColumn(); } else { frm.top().indent = next->GetColumn(); } log_indent(); } } } log_rule_B("use_indent_continue_only_once"); log_rule_B("indent_paren_after_func_decl"); log_rule_B("indent_paren_after_func_def"); log_rule_B("indent_paren_after_func_call"); if ( ( ( !frm.top().indent_cont // Issue #3567 && vardefcol == 0) || ( !options::use_indent_continue_only_once() // Issue #1160 && !options::indent_ignore_first_continue())) // Issue #3561 && ( pc->Is(CT_FPAREN_OPEN) && pc->GetPrev()->IsNewline()) && ( ( ( pc->GetParentType() == CT_FUNC_PROTO || pc->GetParentType() == CT_FUNC_CLASS_PROTO) && options::indent_paren_after_func_decl()) || ( ( pc->GetParentType() == CT_FUNC_DEF || pc->GetParentType() == CT_FUNC_CLASS_DEF) && options::indent_paren_after_func_def()) || ( ( pc->GetParentType() == CT_FUNC_CALL || pc->GetParentType() == CT_FUNC_CALL_USER) && options::indent_paren_after_func_call()) || !pc->GetNext()->IsNewline())) { frm.top().indent = frm.prev().indent + indent_size; log_indent(); indent_column_set(frm.top().indent); } log_rule_B("indent_continue"); if ( pc->GetParentType() != CT_OC_AT && ( options::indent_ignore_first_continue() || options::indent_continue() != 0) && !skipped) { if (options::indent_ignore_first_continue()) { frm.top().indent = get_indent_first_continue(pc->GetNext()); } else { frm.top().indent = frm.prev().indent; } log_indent(); if ( pc->GetLevel() == pc->GetBraceLevel() && !options::indent_ignore_first_continue() && ( pc->Is(CT_FPAREN_OPEN) || pc->Is(CT_SPAREN_OPEN) || ( pc->Is(CT_SQUARE_OPEN) && pc->GetParentType() != CT_OC_MSG) || pc->Is(CT_ANGLE_OPEN))) // Issue #1170 { //log_rule_B("indent_continue"); //frm.top().indent += abs(options::indent_continue()); // frm.top().indent = calc_indent_continue(frm); // frm.top().indent_cont = true; log_rule_B("use_indent_continue_only_once"); if ( (options::use_indent_continue_only_once()) && (frm.top().indent_cont) && vardefcol != 0) { /* * The value of the indentation for a continuation line is calculate * differently if the line is: * a declaration :your case with QString fileName ... * an assignment :your case with pSettings = new QSettings( ... * At the second case the option value might be used twice: * at the assignment * at the function call (if present) * If you want to prevent the double use of the option value * you may use the new option : * use_indent_continue_only_once * with the value "true". * use/don't use indent_continue once Guy 2016-05-16 */ // if vardefcol isn't zero, use it frm.top().indent = vardefcol; log_indent(); } else { frm.top().indent = calc_indent_continue(frm); log_indent(); frm.top().indent_cont = true; log_rule_B("indent_sparen_extra"); if ( pc->Is(CT_SPAREN_OPEN) && options::indent_sparen_extra() != 0) { frm.top().indent += options::indent_sparen_extra(); log_indent(); } } } } frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); frm.paren_count++; } else if ( options::indent_member_single() && pc->Is(CT_MEMBER) && (strcmp(pc->Text(), ".") == 0) && language_is_set(LANG_CS | LANG_CPP)) { log_rule_B("indent_member_single"); if (frm.top().type != CT_MEMBER) { frm.push(pc, __func__, __LINE__); Chunk *tmp = frm.top().pc->GetPrevNcNnlNpp(); if (frm.prev().pc->IsOnSameLine(tmp)) { frm.top().indent = frm.prev().indent; } else { frm.top().indent = frm.prev().indent + indent_size; } log_indent(); frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } if (pc->GetPrev()->IsNewline()) { if ( pc->Is(CT_MEMBER) // Issue #2890 && language_is_set(LANG_CPP)) { // will be done at another place // look at the comment: XXXXXXXXXXXXXXXXXXXXXXXXXX } else { indent_column_set(frm.top().indent); reindent_line(pc, indent_column); did_newline = false; } } //check for the series of CT_member chunks else pop it. Chunk *tmp = pc->GetNextNcNnlNpp(); if (tmp->IsNotNullChunk()) { if (tmp->Is(CT_FUNC_CALL)) { tmp = tmp->GetNextType(CT_FPAREN_CLOSE, tmp->GetLevel()); tmp = tmp->GetNextNcNnlNpp(); } else if ( tmp->Is(CT_WORD) || tmp->Is(CT_TYPE)) { tmp = tmp->GetNextNcNnlNpp(); } } if ( tmp->IsNotNullChunk() && ( (strcmp(tmp->Text(), ".") != 0) || tmp->IsNot(CT_MEMBER))) { if (tmp->IsParenClose()) { tmp = tmp->GetPrevNcNnlNpp(); } Chunk *local_prev = tmp->GetPrev(); // Issue #3294 if (local_prev->IsComment()) { tmp = tmp->GetPrev(); // Issue #3294 } if ( tmp->IsNotNullChunk() && tmp->GetPrev()->IsNewline()) { tmp = tmp->GetPrevNcNnlNpp()->GetNextNl(); } if (tmp->IsNotNullChunk()) { frm.top().pop_pc = tmp; } } } else if ( pc->Is(CT_ASSIGN) || pc->Is(CT_IMPORT) || ( pc->Is(CT_USING) && language_is_set(LANG_CS))) { /* * if there is a newline after the '=' or the line starts with a '=', * just indent one level, * otherwise align on the '='. */ if ( pc->Is(CT_ASSIGN) && pc->GetPrev()->IsNewline()) { if (frm.top().type == CT_ASSIGN_NL) { frm.top().indent_tmp = frm.top().indent; } else { frm.top().indent_tmp = frm.top().indent + indent_size; } log_indent_tmp(); indent_column_set(frm.top().indent_tmp); LOG_FMT(LINDENT, "%s(%d): %zu] assign => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, frm.top().indent_tmp); } Chunk *next = pc->GetNext(); if (next->IsNotNullChunk()) { /* * fixes 1260 , 1268 , 1277 (Extra indentation after line with multiple assignments) * For multiple consecutive assignments in single line , the indent of all these * assignments should be same and one more than this line's indent. * so popping the previous assign and pushing the new one */ if ( frm.top().type == CT_ASSIGN && pc->Is(CT_ASSIGN)) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } frm.push(pc, __func__, __LINE__); if ( pc->Is(CT_ASSIGN) && pc->GetPrev()->IsNewline()) { frm.top().type = CT_ASSIGN_NL; } log_rule_B("indent_continue"); if (options::indent_ignore_first_continue()) { frm.top().indent = get_indent_first_continue(pc); log_indent(); frm.top().indent_cont = true; // Issue #3567 } else if (options::indent_continue() != 0) { frm.top().indent = frm.prev().indent; log_indent(); if ( pc->GetLevel() == pc->GetBraceLevel() && ( pc->IsNot(CT_ASSIGN) || ( pc->GetParentType() != CT_FUNC_PROTO && pc->GetParentType() != CT_FUNC_DEF))) { log_rule_B("use_indent_continue_only_once"); if ( (options::use_indent_continue_only_once()) && (frm.top().indent_cont) && vardefcol != 0) { // if vardefcol isn't zero, use it frm.top().indent = vardefcol; log_indent(); } else { frm.top().indent = calc_indent_continue(frm); log_indent(); vardefcol = frm.top().indent; // use the same variable for the next line frm.top().indent_cont = true; } } } else if ( next->IsNewline() || !options::indent_align_assign()) { log_rule_B("indent_align_assign"); log_rule_B("indent_off_after_assign"); if (options::indent_off_after_assign()) // Issue #2591 { frm.top().indent = frm.prev().indent_tmp; } else { frm.top().indent = frm.prev().indent_tmp + indent_size; } log_indent(); if ( pc->Is(CT_ASSIGN) && next->IsNewline()) { frm.top().type = CT_ASSIGN_NL; frm.top().indent_tab = frm.top().indent; } } else { frm.top().indent = pc->GetColumn() + pc->Len() + 1; log_indent(); } frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } } else if ( pc->Is(CT_RETURN) || ( pc->Is(CT_THROW) && pc->GetParentType() == CT_NONE)) { // don't count returns inside a () or [] if ( pc->GetLevel() == pc->GetBraceLevel() || pc->TestFlags(PCF_IN_LAMBDA)) { Chunk *next = pc->GetNext(); // Avoid indentation on return token set by the option. log_rule_B("indent_off_after_return"); // Avoid indentation on return token if the next token is a new token // to properly indent object initializers returned by functions. log_rule_B("indent_off_after_return_new"); bool indent_after_return = ( next->IsNotNullChunk() && next->GetType() == CT_NEW) ? !options::indent_off_after_return_new() : !options::indent_off_after_return(); if ( indent_after_return || next->IsNullChunk()) { frm.push(pc, __func__, __LINE__); log_rule_B("indent_single_after_return"); if ( next->IsNewline() || ( pc->Is(CT_RETURN) && options::indent_single_after_return())) { // apply normal single indentation frm.top().indent = frm.prev().indent + indent_size; } else { // indent after the return token frm.top().indent = frm.prev().indent + pc->Len() + 1; } log_indent(); frm.top().indent_tmp = frm.prev().indent; log_indent_tmp(); } log_indent(); } } else if ( pc->Is(CT_OC_SCOPE) || pc->Is(CT_TYPEDEF)) { frm.push(pc, __func__, __LINE__); // Issue #405 frm.top().indent = frm.prev().indent; log_indent(); frm.top().indent_tmp = frm.top().indent; LOG_FMT(LINDLINE, "%s(%d): .indent is %zu, .indent_tmp is %zu\n", __func__, __LINE__, frm.top().indent, frm.top().indent_tmp); log_rule_B("indent_continue"); if (options::indent_ignore_first_continue()) { frm.top().indent = get_indent_first_continue(pc); log_indent(); } else if (options::indent_continue() != 0) { frm.top().indent = calc_indent_continue(frm, frm.size() - 2); log_indent(); frm.top().indent_cont = true; } else { frm.top().indent = frm.prev().indent + indent_size; log_indent(); } } else if (pc->Is(CT_C99_MEMBER)) { // nothing to do } else if (pc->Is(CT_WHERE_SPEC)) { /* class indentation is ok already, just need to adjust func */ /* TODO: make this configurable, obviously.. */ if ( pc->GetParentType() == CT_FUNC_DEF || pc->GetParentType() == CT_FUNC_PROTO || ( pc->GetParentType() == CT_STRUCT && frm.top().type != CT_CLASS_COLON)) { indent_column_set(frm.top().indent + 4); } } else if ( options::indent_inside_ternary_operator() && ( pc->Is(CT_QUESTION) || pc->Is(CT_COND_COLON))) // Issue #1130, #1715 { log_rule_B("indent_inside_ternary_operator"); // Pop any colons before because they should already be processed while ( pc->Is(CT_COND_COLON) && frm.top().type == CT_COND_COLON) { frm.pop(__func__, __LINE__, pc); } log_rule_B("indent_inside_ternary_operator"); // Pop Question from stack in ternary operator if ( options::indent_inside_ternary_operator() && pc->Is(CT_COND_COLON) && frm.top().type == CT_QUESTION) { LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); indent_column_set(frm.top().indent_tmp); } frm.push(pc, __func__, __LINE__); frm.top().indent = frm.prev().indent + indent_size; frm.top().indent_tab = frm.top().indent; log_indent(); frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } else if ( pc->Is(CT_LAMBDA) && (language_is_set(LANG_CS | LANG_JAVA)) && pc->GetNextNcNnlNpp()->IsNot(CT_BRACE_OPEN) && options::indent_cs_delegate_body()) { log_rule_B("indent_cs_delegate_body"); frm.push(pc, __func__, __LINE__); frm.top().indent = frm.prev().indent; log_indent(); if ( pc->GetPrevNc()->IsNewline() && !frm.prev().pc->IsOnSameLine(pc->GetPrevNcNnl())) { frm.top().indent = frm.prev().indent + indent_size; log_indent(); reindent_line(pc, (frm.prev().indent + indent_size)); did_newline = false; } else if ( pc->GetNextNc()->IsNewline() && !frm.prev().pc->IsOnSameLine(frm.top().pc)) { frm.top().indent = frm.prev().indent + indent_size; } log_indent(); frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); } else if ( options::indent_oc_inside_msg_sel() && ( pc->Is(CT_OC_MSG_FUNC) || pc->Is(CT_OC_MSG_NAME)) && pc->GetNextNcNnl()->Is(CT_OC_COLON)) // Issue #2658 { log_rule_B("indent_oc_inside_msg_sel"); // Pop the OC msg name that is on the top of the stack // [Class Message: frm.push(pc, __func__, __LINE__); frm.top().indent = frm.prev().indent; frm.top().indent_tab = frm.prev().indent_tab; log_indent(); frm.top().indent_tmp = frm.prev().indent_tmp; log_indent_tmp(); } else if (pc->IsComment()) { // Issue #3294 Chunk *next = pc->GetNext(); if (next->Is(CT_COND_COLON)) { LOG_FMT(LINDLINE, "%s(%d): Comment and COND_COLON: pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); frm.pop(__func__, __LINE__, pc); } // uncomment the line below to get debug info // #define ANYTHING_ELSE #ifdef ANYTHING_ELSE else { // anything else? // Issue #3294 LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); LOG_FMT(LSPACE, "\n\n%s(%d): WARNING: unrecognize indent_text:\n", __func__, __LINE__); } #endif /* ANYTHING_ELSE */ } else { // anything else? #ifdef ANYTHING_ELSE LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); LOG_FMT(LSPACE, "\n\n%s(%d): WARNING: unrecognize indent_text:\n", __func__, __LINE__); #endif /* ANYTHING_ELSE */ } // Handle shift expression continuation indenting size_t shiftcontcol = 0; log_rule_B("indent_shift"); if ( options::indent_shift() == 1 && !pc->TestFlags(PCF_IN_ENUM) && pc->GetParentType() != CT_OPERATOR && !pc->IsComment() && pc->IsNot(CT_BRACE_OPEN) && pc->GetLevel() > 0 && !pc->IsEmptyText()) { bool in_shift = false; bool is_operator = false; // Are we in such an expression? Go both forwards and backwards. Chunk *tmp = pc; do { if (tmp->Is(CT_SHIFT)) { in_shift = true; LOG_FMT(LINDENT2, "%s(%d): in_shift set to TRUE\n", __func__, __LINE__); tmp = tmp->GetPrevNcNnl(); if (tmp->Is(CT_OPERATOR)) { is_operator = true; } break; } tmp = tmp->GetPrevNcNnl(); } while ( !in_shift && tmp->IsNotNullChunk() && tmp->IsNot(CT_SEMICOLON) && tmp->IsNot(CT_BRACE_OPEN) && tmp->IsNot(CT_BRACE_CLOSE) && tmp->IsNot(CT_COMMA) && tmp->IsNot(CT_SPAREN_OPEN) && tmp->IsNot(CT_SPAREN_CLOSE)); tmp = pc; do { tmp = tmp->GetNextNcNnl(); if ( tmp->IsNotNullChunk() && tmp->Is(CT_SHIFT)) { in_shift = true; LOG_FMT(LINDENT2, "%s(%d): in_shift set to TRUE\n", __func__, __LINE__); tmp = tmp->GetPrevNcNnl(); if (tmp->Is(CT_OPERATOR)) { is_operator = true; } break; } } while ( !in_shift && tmp->IsNotNullChunk() && tmp->IsNot(CT_SEMICOLON) && tmp->IsNot(CT_BRACE_OPEN) && tmp->IsNot(CT_BRACE_CLOSE) && tmp->IsNot(CT_COMMA) && tmp->IsNot(CT_SPAREN_OPEN) && tmp->IsNot(CT_SPAREN_CLOSE)); LOG_FMT(LINDENT2, "%s(%d): in_shift is %s\n", __func__, __LINE__, in_shift ? "TRUE" : "FALSE"); Chunk *prev_nonl = pc->GetPrevNcNnl(); Chunk *prev2 = pc->GetPrevNc(); if (( prev_nonl->IsSemicolon() || prev_nonl->IsBraceOpen() || prev_nonl->IsBraceClose() || prev_nonl->Is(CT_CASE_COLON) || ( prev_nonl->IsNotNullChunk() && prev_nonl->TestFlags(PCF_IN_PREPROC)) != pc->TestFlags(PCF_IN_PREPROC) || prev_nonl->Is(CT_COMMA) || is_operator)) { in_shift = false; } LOG_FMT(LINDENT2, "%s(%d): in_shift is %s\n", __func__, __LINE__, in_shift ? "TRUE" : "FALSE"); if ( prev2->Is(CT_NEWLINE) && in_shift) { shiftcontcol = calc_indent_continue(frm); // Setting frm.top().indent_cont = true in the top context when the indent is not also set // just leads to complications when succeeding statements try to indent based on being // embedded in a continuation. In other words setting frm.top().indent_cont = true // should only be set if frm.top().indent is also set. // Work around the doubly increased indent in RETURNs and assignments bool need_workaround = false; size_t sub = 0; for (int i = frm.size() - 1; i >= 0; i--) { if ( frm.at(i).type == CT_RETURN || frm.at(i).type == CT_ASSIGN) { need_workaround = true; sub = frm.size() - i; break; } } if (need_workaround) { shiftcontcol = calc_indent_continue(frm, frm.size() - 1 - sub); } } } // Handle variable definition continuation indenting if ( vardefcol == 0 && ( pc->Is(CT_WORD) || pc->Is(CT_FUNC_CTOR_VAR)) && !pc->TestFlags(PCF_IN_FCN_DEF) && pc->TestFlags(PCF_VAR_1ST_DEF)) { log_rule_B("indent_continue"); if (options::indent_ignore_first_continue()) { vardefcol = get_indent_first_continue(pc); } else if (options::indent_continue() != 0) { vardefcol = calc_indent_continue(frm); // Setting frm.top().indent_cont = true in the top context when the indent is not also set // just leads to complications when succeeding statements try to indent based on being // embedded in a continuation. In other words setting frm.top().indent_cont = true // should only be set if frm.top().indent is also set. } else if ( options::indent_var_def_cont() || pc->GetPrev()->IsNewline()) { log_rule_B("indent_var_def_cont"); vardefcol = frm.top().indent + indent_size; } else { // Issue #3010 vardefcol = pc->GetColumn(); // BUT, we need to skip backward over any '*' Chunk *tmp = pc->GetPrevNc(); while (tmp->Is(CT_PTR_TYPE)) { vardefcol = tmp->GetColumn(); tmp = tmp->GetPrevNc(); } // BUT, we need to skip backward over any '::' or TYPE //tmp = pc->GetPrevNc(); //if (tmp->Is(CT_DC_MEMBER)) //{ // // look for a type // Chunk *tmp2 = tmp->GetPrevNc(); // if (tmp2->Is(CT_TYPE)) // { // // we have something like "SomeLongNamespaceName::Foo()" // vardefcol = tmp2->GetColumn(); // LOG_FMT(LINDENT, "%s(%d): orig line is %zu, vardefcol is %zu\n", // __func__, __LINE__, pc->GetOrigLine(), vardefcol); // } //} } } if ( pc->IsSemicolon() || ( pc->Is(CT_BRACE_OPEN) && ( pc->GetParentType() == CT_FUNCTION || pc->GetParentType() == CT_CLASS))) //Issue #3576 { vardefcol = 0; } // Indent the line if needed if ( did_newline && !pc->IsNewline() && (pc->Len() != 0)) { pc->SetColumnIndent(frm.top().indent_tab); if (frm.top().ip.ref) { pc->IndentData().ref = frm.top().ip.ref; pc->IndentData().delta = frm.top().ip.delta; } LOG_FMT(LINDENT2, "%s(%d): orig line is %zu, pc->GetColumn() indent is %zu, indent_column is %zu, for '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetColumnIndent(), indent_column, pc->ElidedText(copy)); /* * Check for special continuations. * Note that some of these could be done as a stack item like * everything else */ Chunk *prev = pc->GetPrevNcNnl(); Chunk *prevv = prev->GetPrevNcNnl(); Chunk *next = pc->GetNextNcNnl(); bool do_vardefcol = false; if ( vardefcol > 0 && pc->GetLevel() == pc->GetBraceLevel() && ( prev->Is(CT_COMMA) || prev->Is(CT_TYPE) || prev->Is(CT_PTR_TYPE) || prev->Is(CT_WORD))) { Chunk *tmp = pc; while (tmp->Is(CT_PTR_TYPE)) { tmp = tmp->GetNextNcNnl(); } LOG_FMT(LINDENT2, "%s(%d): orig line is %zu, for '%s'", __func__, __LINE__, tmp->GetOrigLine(), tmp->Text()); LOG_FMT(LINDENT2, " tmp->GetFlags(): "); log_pcf_flags(LINDENT2, tmp->GetFlags()); // Issue #2332 if ( tmp->TestFlags(PCF_VAR_DEF) && ( tmp->Is(CT_WORD) || tmp->Is(CT_FUNC_CTOR_VAR))) { do_vardefcol = true; } } //LOG_FMT(LINDENT2, "%s(%d): GUY 2:\n", __func__, __LINE__); if (pc->TestFlags(PCF_DONT_INDENT)) { // no change } else if ( pc->GetParentType() == CT_SQL_EXEC && options::indent_preserve_sql()) { log_rule_B("indent_preserve_sql"); reindent_line(pc, sql_col + (pc->GetOrigCol() - sql_orig_col)); LOG_FMT(LINDENT, "Indent SQL: [%s] to %zu (%zu/%zu)\n", pc->Text(), pc->GetColumn(), sql_col, sql_orig_col); } else if ( !options::indent_member_single() && !pc->TestFlags(PCF_STMT_START) && ( pc->Is(CT_MEMBER) || ( pc->Is(CT_DC_MEMBER) && prev->Is(CT_TYPE)) || ( prev->Is(CT_MEMBER) || ( prev->Is(CT_DC_MEMBER) && prevv->Is(CT_TYPE))))) { log_rule_B("indent_member_single"); log_rule_B("indent_member"); size_t tmp = options::indent_member() + indent_column; LOG_FMT(LINDENT, "%s(%d): orig line is %zu, member => %zu\n", __func__, __LINE__, pc->GetOrigLine(), tmp); reindent_line(pc, tmp); } else if (do_vardefcol) { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, vardefcol is %zu\n", __func__, __LINE__, pc->GetOrigLine(), vardefcol); reindent_line(pc, vardefcol); } else if (shiftcontcol > 0) { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, shiftcontcol is %zu\n", __func__, __LINE__, pc->GetOrigLine(), shiftcontcol); reindent_line(pc, shiftcontcol); } else if ( pc->Is(CT_NAMESPACE) && options::indent_namespace() && options::indent_namespace_single_indent() && frm.top().ns_cnt) { log_rule_B("indent_namespace"); log_rule_B("indent_namespace_single_indent"); LOG_FMT(LINDENT, "%s(%d): orig line is %zu, Namespace => %zu\n", __func__, __LINE__, pc->GetOrigLine(), frm.top().brace_indent); reindent_line(pc, frm.top().brace_indent); } else if ( pc->Is(CT_STRING) && prev->Is(CT_STRING) && options::indent_align_string()) { log_rule_B("indent_align_string"); const int tmp = (xml_indent != 0) ? xml_indent : prev->GetColumn(); LOG_FMT(LINDENT, "%s(%d): orig line is %zu, String => %d\n", __func__, __LINE__, pc->GetOrigLine(), tmp); reindent_line(pc, tmp); } else if (pc->IsComment()) { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, comment => %zu\n", __func__, __LINE__, pc->GetOrigLine(), frm.top().indent_tmp); indent_comment(pc, frm.top().indent_tmp); } else if (pc->Is(CT_PREPROC)) { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, pp-indent => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else if ( pc->IsParenClose() || pc->Is(CT_ANGLE_CLOSE)) { /* * This is a big hack. We assume that since we hit a paren close, * that we just removed a paren open */ LOG_FMT(LINDLINE, "%s(%d): indent_column is %zu\n", __func__, __LINE__, indent_column); if (frm.poped().type == E_Token(pc->GetType() - 1)) { // Issue # 405 LOG_FMT(LINDLINE, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); Chunk *ck1 = frm.poped().pc; LOG_FMT(LINDLINE, "%s(%d): ck1 orig line is %zu, orig col is %zu, Text() is '%s', GetType() is %s\n", __func__, __LINE__, ck1->GetOrigLine(), ck1->GetOrigCol(), ck1->Text(), get_token_name(ck1->GetType())); Chunk *ck2 = ck1->GetPrev(); LOG_FMT(LINDLINE, "%s(%d): ck2 orig line is %zu, orig col is %zu, Text() is '%s', GetType() is %s\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol(), ck2->Text(), get_token_name(ck2->GetType())); log_rule_B("indent_paren_close"); if (options::indent_paren_close() == -1) { LOG_FMT(LINDLINE, "%s(%d): [%zu:%zu] indent_paren_close is -1\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol()); indent_column_set(pc->GetOrigCol()); LOG_FMT(LINDLINE, "%s(%d): [%zu:%zu] indent_column set to %zu\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol(), indent_column); } else if ( ck2->IsNewline() || (options::indent_paren_close() == 1)) { /* * If the open parenthesis was the first thing on the line or we * are doing mode 1, then put the close parenthesis in the same * column */ LOG_FMT(LINDLINE, "%s(%d): [%zu:%zu] indent_paren_close is 1\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol()); indent_column_set(ck1->GetColumn()); LOG_FMT(LINDLINE, "%s(%d): [%zu:%zu] indent_column set to %zu\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol(), indent_column); } else { if (options::indent_paren_close() != 2) { // indent_paren_close is 0 or 1 LOG_FMT(LINDLINE, "%s(%d): [%zu:%zu] indent_paren_close is 0 or 1\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol()); indent_column_set(frm.poped().indent_tmp); LOG_FMT(LINDLINE, "%s(%d): [%zu:%zu] indent_column set to %zu\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol(), indent_column); pc->SetColumnIndent(frm.poped().indent_tab); log_rule_B("indent_paren_close"); if (options::indent_paren_close() == 1) { LOG_FMT(LINDLINE, "%s(%d): [%zu:%zu] indent_paren_close is 1\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol()); if (indent_column == 0) { fprintf(stderr, "%s(%d): indent_column is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } indent_column--; LOG_FMT(LINDLINE, "%s(%d): [%zu:%zu] indent_column set to %zu\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol(), indent_column); } } else { // indent_paren_close is 2: Indent to the brace level LOG_FMT(LINDLINE, "%s(%d): indent_paren_close is 2\n", __func__, __LINE__); LOG_FMT(LINDLINE, "%s(%d): ck2 orig line is %zu, orig col is %zu, ck2->Text() is '%s'\n", __func__, __LINE__, ck2->GetOrigLine(), ck2->GetOrigCol(), ck2->Text()); if (pc->GetPrev()->GetType() == CT_NEWLINE) { LOG_FMT(LINDLINE, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); LOG_FMT(LINDLINE, "%s(%d): prev is \n", __func__, __LINE__); Chunk *search = pc; while (search->GetNext()->IsParenClose()) { search = search->GetNext(); } Chunk *searchNext = search->GetNext(); // Issue #3407 - Skip over a possible 'noexcept' keyword before going forward. if (searchNext->GetType() == CT_NOEXCEPT) { searchNext = searchNext->GetNext(); } if ( searchNext->GetType() == CT_SEMICOLON || searchNext->GetType() == CT_MEMBER // Issue #2582 || searchNext->GetType() == CT_NEWLINE) { LOG_FMT(LINDLINE, "%s(%d):\n", __func__, __LINE__); search = search->GetOpeningParen(); if ( options::indent_oc_inside_msg_sel() && search->GetPrevNcNnl()->Is(CT_OC_COLON) && ( frm.top().type == CT_OC_MSG_FUNC || frm.top().type == CT_OC_MSG_NAME)) // Issue #2658 { log_rule_B("indent_oc_inside_msg_sel"); // [Class Message:(...) indent_column_set(frm.top().pc->GetColumn()); } else if ( options::indent_inside_ternary_operator() && ( frm.top().type == CT_QUESTION || frm.top().type == CT_COND_COLON)) // Issue #1130, #1715 { log_rule_B("indent_inside_ternary_operator"); indent_column_set(frm.top().indent); } else { search = search->GetPrevNl()->GetNext(); if (search->IsNullChunk()) { search = Chunk::GetHead(); } indent_column_set(search->GetColumn()); } } } } } } size_t indent_value = 0; LOG_FMT(LINDENT, "%s(%d): orig line is %zu, closing parenthesis => %zu, text is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); LOG_FMT(LINDENT, "%s(%d): [%s/%s]\n", __func__, __LINE__, get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); Chunk *prev2 = pc->GetPrev(); // Issue #2930 LOG_FMT(LINDENT, "%s(%d): prev2 is orig line is %zu, text is '%s'\n", __func__, __LINE__, prev2->GetOrigLine(), prev2->Text()); Chunk *next2 = pc->GetNext(); LOG_FMT(LINDENT, "%s(%d): next2 is orig line is %zu, text is '%s'\n", __func__, __LINE__, next2->GetOrigLine(), next2->Text()); if ( pc->GetParentType() == CT_FUNC_DEF && prev2->IsNewline() && next2->IsNewline()) { if (options::donot_indent_func_def_close_paren()) { indent_value = 1; } else { reindent_line(pc, indent_column); indent_value = indent_column; } } else { indent_value = indent_column; } reindent_line(pc, indent_value); } else if (pc->Is(CT_COMMA)) { bool indent_align = false; bool indent_ignore = false; if (frm.top().pc->IsParenOpen()) { log_rule_B("indent_comma_paren"); indent_align = options::indent_comma_paren() == (int)indent_mode_e::ALIGN; indent_ignore = options::indent_comma_paren() == (int)indent_mode_e::IGNORE; } else if (frm.top().pc->IsBraceOpen()) { log_rule_B("indent_comma_brace"); indent_align = options::indent_comma_brace() == (int)indent_mode_e::ALIGN; indent_ignore = options::indent_comma_brace() == (int)indent_mode_e::IGNORE; } if (indent_ignore) { indent_column_set(pc->GetOrigCol()); } else if (indent_align) { indent_column_set(frm.top().pc->GetColumn()); } LOG_FMT(LINDENT, "%s(%d): %zu] comma => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else if ( options::indent_func_const() && pc->Is(CT_QUALIFIER) && strncasecmp(pc->Text(), "const", pc->Len()) == 0 && ( next == nullptr || next->Is(CT_BRACED) || next->IsBraceOpen() || next->Is(CT_NEWLINE) || next->Is(CT_SEMICOLON) || next->Is(CT_THROW))) { // indent const - void GetFoo(void)\n const\n { return (m_Foo); } log_rule_B("indent_func_const"); indent_column_set(frm.top().indent + options::indent_func_const()); LOG_FMT(LINDENT, "%s(%d): %zu] const => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else if ( options::indent_func_throw() && pc->Is(CT_THROW) && pc->GetParentType() != CT_NONE) { // indent throw - void GetFoo(void)\n throw()\n { return (m_Foo); } log_rule_B("indent_func_throw"); indent_column_set(options::indent_func_throw()); LOG_FMT(LINDENT, "%s(%d): %zu] throw => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else if (pc->Is(CT_SEMICOLON)) { if ( pc->TestFlags(PCF_IN_FOR) && options::indent_semicolon_for_paren()) { log_rule_B("indent_semicolon_for_paren"); indent_column_set(frm.top().pc->GetColumn()); log_rule_B("indent_first_for_expr"); if (options::indent_first_for_expr()) { reindent_line(frm.top().pc->GetNext(), indent_column + pc->Len() + 1); } LOG_FMT(LINDENT, "%s(%d): %zu] SEMICOLON => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else { log_rule_B("indent_ignore_semicolon"); if (options::indent_ignore_semicolon()) { indent_column_set(pc->GetOrigCol()); } LOG_FMT(LINDENT, "%s(%d): %zu] semicolon => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } } else if (pc->Is(CT_BOOL)) { if (frm.top().pc->IsParenOpen()) { log_rule_B("indent_bool_paren"); if (options::indent_bool_paren() == (int)indent_mode_e::IGNORE) { indent_column_set(pc->GetOrigCol()); } else if (options::indent_bool_paren() == (int)indent_mode_e::ALIGN) { indent_column_set(frm.top().pc->GetColumn()); log_rule_B("indent_first_bool_expr"); if (options::indent_first_bool_expr()) { reindent_line(frm.top().pc->GetNext(), indent_column + pc->Len() + 1); } } } else { log_rule_B("indent_ignore_bool"); if (options::indent_ignore_bool()) { indent_column_set(pc->GetOrigCol()); } } LOG_FMT(LINDENT, "%s(%d): %zu] bool => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else if ( pc->Is(CT_ARITH) || pc->Is(CT_CARET)) { log_rule_B("indent_ignore_arith"); if (options::indent_ignore_arith()) { indent_column_set(pc->GetOrigCol()); } LOG_FMT(LINDENT, "%s(%d): %zu] arith => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else if (pc->Is(CT_SHIFT)) { log_rule_B("indent_shift"); if (options::indent_shift() == -1) { indent_column_set(pc->GetOrigCol()); } LOG_FMT(LINDENT, "%s(%d): %zu] shift => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else if (pc->Is(CT_ASSIGN)) { log_rule_B("indent_ignore_assign"); if (options::indent_ignore_assign()) { indent_column_set(pc->GetOrigCol()); } LOG_FMT(LINDENT, "%s(%d): %zu] assign => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } else if ( options::indent_ternary_operator() == 1 && prev->Is(CT_COND_COLON)) { log_rule_B("indent_ternary_operator"); Chunk *tmp = prev->GetPrevType(CT_QUESTION); if (tmp->IsNotNullChunk()) { tmp = tmp->GetNextNcNnl(); if (tmp->IsNotNullChunk()) { LOG_FMT(LINDENT, "%s: %zu] ternarydefcol => %zu [%s]\n", __func__, pc->GetOrigLine(), tmp->GetColumn(), pc->Text()); reindent_line(pc, tmp->GetColumn()); } } } else if ( options::indent_ternary_operator() == 2 && pc->Is(CT_COND_COLON)) { log_rule_B("indent_ternary_operator"); Chunk *tmp = pc->GetPrevType(CT_QUESTION); if (tmp->IsNotNullChunk()) { LOG_FMT(LINDENT, "%s: %zu] ternarydefcol => %zu [%s]\n", __func__, pc->GetOrigLine(), tmp->GetColumn(), pc->Text()); reindent_line(pc, tmp->GetColumn()); } } else if ( options::indent_oc_inside_msg_sel() && ( pc->Is(CT_OC_MSG_FUNC) || pc->Is(CT_OC_MSG_NAME))) // Issue #2658 { log_rule_B("indent_oc_inside_msg_sel"); reindent_line(pc, frm.top().indent); } else { bool use_indent = true; const size_t ttidx = frm.size() - 1; if (ttidx > 0) { LOG_FMT(LINDPC, "%s(%d): (frm.at(ttidx).pc)->GetParentType() is %s\n", __func__, __LINE__, get_token_name((frm.at(ttidx).pc)->GetParentType())); if ((frm.at(ttidx).pc)->GetParentType() == CT_FUNC_CALL) { LOG_FMT(LINDPC, "FUNC_CALL OK [%d]\n", __LINE__); log_rule_B("use_indent_func_call_param"); if (options::use_indent_func_call_param()) { LOG_FMT(LINDPC, "use is true [%d]\n", __LINE__); } else { LOG_FMT(LINDPC, "use is false [%d]\n", __LINE__); use_indent = false; } } } LOG_FMT(LINDENT, "%s(%d): pc->line is %zu, pc->GetColumn() is %zu, pc->Text() is '%s, indent_column is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetColumn(), pc->Text(), indent_column); if ( use_indent && pc->IsNot(CT_PP_IGNORE)) // Leave indentation alone for PP_IGNORE tokens { log_rule_B("pos_conditional"); if ( ( pc->Is(CT_QUESTION) // Issue #2101 || pc->Is(CT_COND_COLON)) // Issue #2101 && options::pos_conditional() == TP_IGNORE) { // do not indent this line LOG_FMT(LINDENT, "%s(%d): %zu] don't indent this line\n", __func__, __LINE__, pc->GetOrigLine()); } else if (pc->Is(CT_BREAK)) { // Issue #1692 log_rule_B("indent_switch_break_with_case"); // Issue #2281 if ( options::indent_switch_break_with_case() && pc->GetTypeOfParent() == CT_SWITCH) { // look for a case before Issue #2735 Chunk *whereIsCase = pc->GetPrevType(CT_CASE, pc->GetLevel()); if (whereIsCase->IsNotNullChunk()) { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, whereIsCase->GetOrigLine(), whereIsCase->GetOrigCol(), whereIsCase->Text()); LOG_FMT(LINDENT, "%s(%d): column is %zu\n", __func__, __LINE__, whereIsCase->GetColumn()); reindent_line(pc, whereIsCase->GetColumn()); } } else { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, indent_column set to %zu, for '%s'\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } } else if ( pc->Is(CT_MEMBER) // Issue #2890 && language_is_set(LANG_CPP)) { // comment name: XXXXXXXXXXXXXXXXXXXXXXXXXX LOG_FMT(LINDENT, "%s(%d): orig line is %zu, indent_column set to %zu, for '%s'\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); const size_t frm_size = frm.size(); LOG_FMT(LINDPC, "%s(%d): frm_size is %zu\n", __func__, __LINE__, frm_size); // get pc LOG_FMT(LINDPC, "%s(%d): Text() is '%s', (frm.at(frm_size - 1).pc)->GetType() is %s\n", __func__, __LINE__, (frm.at(frm_size - 1).pc)->Text(), get_token_name((frm.at(frm_size - 1).pc)->GetType())); // get the token before const size_t temp_ttidx = frm_size - 2; if (temp_ttidx == 0) { indent_column = 1 + indent_size; reindent_line(pc, indent_column); } else { Chunk *token_before = frm.at(temp_ttidx).pc; LOG_FMT(LINDPC, "%s(%d): Text() is '%s', token_before->GetType() is %s\n", __func__, __LINE__, token_before->Text(), get_token_name(token_before->GetType())); size_t vor_col = 0; if (token_before->Is(CT_ASSIGN)) { Chunk *before_Assign = frm.at(temp_ttidx - 1).pc; if (before_Assign->IsNullChunk()) { indent_column = 1 + indent_size; } else { vor_col = before_Assign->GetColumn(); LOG_FMT(LINDPC, "%s(%d): Text() is '%s', before_Assign->GetType() is %s, column is %zu\n", __func__, __LINE__, before_Assign->Text(), get_token_name(before_Assign->GetType()), vor_col); indent_column = vor_col + 2 * indent_size; } } else if (token_before->Is(CT_BRACE_OPEN)) { vor_col = token_before->GetColumn(); LOG_FMT(LINDPC, "%s(%d): Text() is '%s', token_before->GetType() is %s, column is %zu\n", __func__, __LINE__, token_before->Text(), get_token_name(token_before->GetType()), vor_col); indent_column = vor_col + 2 * indent_size; } else if (token_before->Is(CT_RETURN)) { Chunk *before_Return = frm.at(temp_ttidx - 1).pc; vor_col = before_Return->GetColumn(); LOG_FMT(LINDPC, "%s(%d): Text() is '%s', before_Return->GetType() is %s, column is %zu\n", __func__, __LINE__, before_Return->Text(), get_token_name(before_Return->GetType()), vor_col); indent_column = vor_col + 2 * indent_size; } else { // TO DO } reindent_line(pc, indent_column); } reindent_line(pc, indent_column); } else { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, indent_column set to %zu, for '%s'\n", __func__, __LINE__, pc->GetOrigLine(), indent_column, pc->Text()); reindent_line(pc, indent_column); } } else { // do not indent this line LOG_FMT(LINDENT, "%s(%d): %zu] don't indent this line\n", __func__, __LINE__, pc->GetOrigLine()); } } did_newline = false; if ( pc->Is(CT_SQL_EXEC) || pc->Is(CT_SQL_BEGIN) || pc->Is(CT_SQL_END)) { sql_col = pc->GetColumn(); sql_orig_col = pc->GetOrigCol(); } // Handle indent for variable defs at the top of a block of code if (pc->TestFlags(PCF_VAR_TYPE)) { if ( !frm.top().non_vardef && (frm.top().type == CT_BRACE_OPEN)) { log_rule_B("indent_var_def_blk"); int val = options::indent_var_def_blk(); if (val != 0) { size_t indent = indent_column; indent = (val > 0) ? val // reassign if positive val, : ((size_t)(abs(val)) < indent) // else if no underflow ? (indent + val) : 0; // reduce, else 0 LOG_FMT(LINDENT, "%s(%d): %zu] var_type indent => %zu [%s]\n", __func__, __LINE__, pc->GetOrigLine(), indent, pc->Text()); reindent_line(pc, indent); } } } else if (pc != frm.top().pc) { frm.top().non_vardef = true; } } // if we hit a newline, reset indent_tmp if ( pc->IsNewline() || pc->Is(CT_COMMENT_MULTI) || pc->Is(CT_COMMENT_CPP)) { log_indent(); frm.top().indent_tmp = frm.top().indent; log_indent_tmp(); /* * Handle the case of a multi-line #define w/o anything on the * first line (indent_tmp will be 1 or 0) */ if ( pc->Is(CT_NL_CONT) && frm.top().indent_tmp <= indent_size && frm.top().type != CT_PP_DEFINE) { frm.top().indent_tmp = indent_size + 1; log_indent_tmp(); } // Get ready to indent the next item did_newline = true; } // Check for open XML tags " 0 && pc->Is(CT_STRING) && pc->Len() > 4 && pc->GetStr()[1] == '<' && pc->GetStr()[2] != '/' && pc->GetStr()[pc->Len() - 3] != '/') { if (xml_indent <= 0) { xml_indent = pc->GetColumn(); } log_rule_B("indent_xml_string"); xml_indent += options::indent_xml_string(); } // Issue #672 log_rule_B("indent_continue_class_head"); if ( pc->Is(CT_CLASS) && language_is_set(LANG_CPP | LANG_JAVA) && ( options::indent_ignore_first_continue() || options::indent_continue_class_head() != 0) && !classFound) { LOG_FMT(LINDENT, "%s(%d): orig line is %zu, CT_CLASS found, OPEN IT\n", __func__, __LINE__, pc->GetOrigLine()); frm.push(pc, __func__, __LINE__); if (options::indent_ignore_first_continue()) { frm.top().indent = get_indent_first_continue(pc); } else { frm.top().indent = frm.prev().indent + options::indent_continue_class_head(); } log_indent(); frm.top().indent_tmp = frm.top().indent; frm.top().indent_tab = frm.top().indent; log_indent_tmp(); classFound = true; } pc = pc->GetNext(); if (pc->Is(CT_SPACE)) // Issue #3710 { pc = pc->GetNext(); } LOG_FMT(LINDLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); } null_pc: // Throw out any stuff inside a preprocessor - no need to warn while ( !frm.empty() && frm.top().in_preproc) { frm.pop(__func__, __LINE__, pc); } // Throw out any VBRACE_OPEN at the end - implied with the end of file while ( !frm.empty() && frm.top().type == CT_VBRACE_OPEN) { frm.pop(__func__, __LINE__, pc); } for (size_t idx_temp = 1; idx_temp < frm.size(); idx_temp++) { LOG_FMT(LWARN, "%s(%d): size is %zu\n", __func__, __LINE__, frm.size()); LOG_FMT(LWARN, "%s(%d): File: %s, open_line is %zu, parent is %s: Unmatched %s\n", __func__, __LINE__, cpd.filename.c_str(), frm.at(idx_temp).open_line, get_token_name(frm.at(idx_temp).parent), get_token_name(frm.at(idx_temp).type)); exit(EX_IOERR); } LOG_FMT(LINDLINE, "%s(%d): before quick_align_again\n", __func__, __LINE__); quick_align_again(); quick_indent_again(); LOG_FMT(LINDLINE, "%s(%d): after quick_align_again\n", __func__, __LINE__); } // indent_text static bool single_line_comment_indent_rule_applies(Chunk *start, bool forward) { LOG_FUNC_ENTRY(); if (!start->IsSingleLineComment()) { return(false); } Chunk *pc = start; size_t nl_count = 0; while ((pc = forward ? pc->GetNext() : pc->GetPrev())->IsNotNullChunk()) { if (pc->IsNewline()) { if ( nl_count > 0 || pc->GetNlCount() > 1) { return(false); } nl_count++; } else if (pc->IsSingleLineComment()) { nl_count = 0; } else if ( pc->Is(CT_COMMENT_MULTI) || (forward && pc->IsBraceClose()) || (!forward && pc->IsBraceOpen())) { /* * check for things we wouldn't want to indent the comment for * example: non-single line comment, closing brace */ return(false); } else { return(true); } } return(false); } // single_line_comment_indent_rule_applies static bool is_end_of_assignment(Chunk *pc, const ParseFrame &frm) { return( ( frm.top().type == CT_ASSIGN_NL || frm.top().type == CT_MEMBER || frm.top().type == CT_ASSIGN) && ( pc->IsSemicolon() || pc->Is(CT_COMMA) || pc->Is(CT_BRACE_OPEN) || pc->Is(CT_SPAREN_CLOSE) || ( pc->Is(CT_SQUARE_OPEN) && pc->GetParentType() == CT_ASSIGN)) && pc->GetParentType() != CT_CPP_LAMBDA); } static size_t calc_comment_next_col_diff(Chunk *pc) { Chunk *next = pc; // assumes pc has a comment type LOG_FMT(LCMTIND, "%s(%d): next->Text() is '%s'\n", __func__, __LINE__, next->Text()); // Note: every comment is squashed into a single token // (including newline chars for multiline comments) and is followed by // a newline token (unless there are no more tokens left) do { Chunk *newline_token = next->GetNext(); LOG_FMT(LCMTIND, "%s(%d): newline_token->Text() is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, newline_token->Text(), newline_token->GetOrigLine(), newline_token->GetOrigCol()); if ( newline_token->IsNullChunk() || newline_token->GetNlCount() > 1) { return(5000); // FIXME: Max thresh magic number 5000 } next = newline_token->GetNext(); if (next->IsNotNullChunk()) { LOG_FMT(LCMTIND, "%s(%d): next->Text() is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, next->Text(), next->GetOrigLine(), next->GetOrigCol()); } } while (next->IsComment()); if (next->IsNullChunk()) { return(5000); // FIXME: Max thresh magic number 5000 } LOG_FMT(LCMTIND, "%s(%d): next->Text() is '%s'\n", __func__, __LINE__, next->Text()); // here next is the first non comment, non newline token return(next->GetOrigCol() > pc->GetOrigCol() ? next->GetOrigCol() - pc->GetOrigCol() : pc->GetOrigCol() - next->GetOrigCol()); } static void indent_comment(Chunk *pc, size_t col) { LOG_FUNC_ENTRY(); char copy[1000]; LOG_FMT(LCMTIND, "%s(%d): pc->Text() is '%s', orig line %zu, orig col %zu, level %zu\n", __func__, __LINE__, pc->ElidedText(copy), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); // force column 1 comment to column 1 if not changing them log_rule_B("indent_col1_comment"); if ( pc->GetOrigCol() == 1 && !options::indent_col1_comment() && !pc->TestFlags(PCF_INSERTED)) { LOG_FMT(LCMTIND, "%s(%d): rule 1 - keep in col 1\n", __func__, __LINE__); reindent_line(pc, 1); return; } Chunk *nl = pc->GetPrev(); if (nl->IsNotNullChunk()) { LOG_FMT(LCMTIND, "%s(%d): nl->Text() is '%s', orig line %zu, orig col %zu, level %zu\n", __func__, __LINE__, nl->Text(), nl->GetOrigLine(), nl->GetOrigCol(), nl->GetLevel()); } if (pc->GetOrigCol() > 1) { Chunk *prev = nl->GetPrev(); if (prev->IsNotNullChunk()) { LOG_FMT(LCMTIND, "%s(%d): prev->Text() is '%s', orig line %zu, orig col %zu, level %zu\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol(), prev->GetLevel()); log_pcf_flags(LCMTIND, prev->GetFlags()); } if ( prev->IsComment() && nl->GetNlCount() == 1) { const size_t prev_col_diff = (prev->GetOrigCol() > pc->GetOrigCol()) ? prev->GetOrigCol() - pc->GetOrigCol() : pc->GetOrigCol() - prev->GetOrigCol(); LOG_FMT(LCMTIND, "%s(%d): prev_col_diff is %zu\n", __func__, __LINE__, prev_col_diff); /* * Here we want to align comments that are relatively close one to * another but not when the comment is a Doxygen comment (Issue #1134) */ if (prev_col_diff <= options::indent_comment_align_thresh()) { LOG_FMT(LCMTIND, "%s(%d): prev->Text() is '%s', Doxygen_comment(prev) is %s\n", __func__, __LINE__, prev->Text(), prev->IsDoxygenComment() ? "TRUE" : "FALSE"); LOG_FMT(LCMTIND, "%s(%d): pc->Text() is '%s', Doxygen_comment(pc) is %s\n", __func__, __LINE__, pc->Text(), pc->IsDoxygenComment() ? "TRUE" : "FALSE"); if (prev->IsDoxygenComment() == pc->IsDoxygenComment()) { const size_t next_col_diff = calc_comment_next_col_diff(pc); LOG_FMT(LCMTIND, "%s(%d): next_col_diff is %zu\n", __func__, __LINE__, next_col_diff); // Align to the previous comment or to the next token? if ( prev_col_diff <= next_col_diff || next_col_diff == 5000) // FIXME: Max thresh magic number 5000 { LOG_FMT(LCMTIND, "%s(%d): rule 3 - prev comment, coldiff = %zu, now in %zu\n", __func__, __LINE__, prev_col_diff, pc->GetColumn()); reindent_line(pc, prev->GetColumn()); return; } } } } } // check if special single-line-comment-before-code rule applies log_rule_B("indent_single_line_comments_before"); if ( (options::indent_single_line_comments_before() > 0) && single_line_comment_indent_rule_applies(pc, true)) { LOG_FMT(LCMTIND, "%s(%d): rule 4 - indent single line comments before code, now in %zu\n", __func__, __LINE__, pc->GetColumn()); reindent_line(pc, col + options::indent_single_line_comments_before()); return; } // check if special single-line-comment-after-code rule applies log_rule_B("indent_single_line_comments_after"); if ( (options::indent_single_line_comments_after() > 0) && single_line_comment_indent_rule_applies(pc, false)) { LOG_FMT(LCMTIND, "%s(%d): rule 4 - indent single line comments after code, now in %zu\n", __func__, __LINE__, pc->GetColumn()); reindent_line(pc, col + options::indent_single_line_comments_after()); return; } log_rule_B("indent_comment"); if ( pc->GetOrigCol() > 1 && !options::indent_comment()) { LOG_FMT(LCMTIND, "%s(%d): rule 5 - keep in orig col\n", __func__, __LINE__); reindent_line(pc, pc->GetOrigCol()); return; } LOG_FMT(LCMTIND, "%s(%d): rule 6 - fall-through, stay in %zu\n", __func__, __LINE__, col); reindent_line(pc, col); } // indent_comment bool ifdef_over_whole_file() { LOG_FUNC_ENTRY(); // if requested, treat an #if that guards the entire file the same as any other #if // if running as frag, assume #if is not a guard if ( options::pp_indent_in_guard() || cpd.frag) { return(false); } // the results for this file are cached if (cpd.ifdef_over_whole_file) { return(cpd.ifdef_over_whole_file > 0); } Chunk *start_pp = Chunk::NullChunkPtr; Chunk *end_pp = Chunk::NullChunkPtr; size_t IFstage = 0; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { LOG_FMT(LNOTE, "%s(%d): pc->pp level is %zu, pc orig line is %zu, orig col is %zu, pc->Text() is '%s'\n", __func__, __LINE__, pc->GetPpLevel(), pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); if (pc->IsCommentOrNewline()) { continue; } if (IFstage == 0) // 0 is BEGIN { // Check the first preprocessor, make sure it is an #if type if (pc->IsNot(CT_PREPROC)) { break; } Chunk *next = pc->GetNext(); if ( next->IsNullChunk() || next->IsNot(CT_PP_IF)) { break; } IFstage = 1; // 1 is CT_PP_IF found start_pp = pc; } else if (IFstage == 1) // 1 is CT_PP_IF found { // Scan until a preprocessor at level 0 is found - the close to the #if if (pc->Is(CT_PREPROC)) { if (pc->GetPpLevel() == 0) { IFstage = 2; end_pp = pc; } } continue; } else if (IFstage == 2) { // We should only see the rest of the preprocessor if ( pc->Is(CT_PREPROC) || !pc->TestFlags(PCF_IN_PREPROC)) { IFstage = 0; break; } } } cpd.ifdef_over_whole_file = (IFstage == 2) ? 1 : -1; if (cpd.ifdef_over_whole_file > 0) { start_pp->SetFlagBits(PCF_WF_IF); end_pp->SetFlagBits(PCF_WF_ENDIF); } LOG_FMT(LNOTE, "The whole file is%s covered by a #IF\n", (cpd.ifdef_over_whole_file > 0) ? "" : " NOT"); return(cpd.ifdef_over_whole_file > 0); } // ifdef_over_whole_file void indent_preproc() { LOG_FUNC_ENTRY(); // Scan to see if the whole file is covered by one #ifdef const size_t pp_level_sub = ifdef_over_whole_file() ? 1 : 0; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { LOG_FMT(LPPIS, "%s(%d): orig line is %zu, orig col is %zu, pc->Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); if (pc->IsNot(CT_PREPROC)) { continue; } Chunk *next = pc->GetNextNcNnl(); if (next->IsNullChunk()) { break; } const size_t pp_level = (pc->GetPpLevel() > pp_level_sub) ? pc->GetPpLevel() - pp_level_sub : 0; // Adjust the indent of the '#' if (options::pp_indent() & IARF_ADD) { log_rule_B("pp_indent ADD"); reindent_line(pc, 1 + pp_level * options::pp_indent_count()); } else if (options::pp_indent() & IARF_REMOVE) { log_rule_B("pp_indent REMOVE"); reindent_line(pc, 1); } // Add spacing by adjusting the length log_rule_B("pp_space_after"); if ( (options::pp_space_after() != IARF_IGNORE) && next->IsNotNullChunk()) { if (options::pp_space_after() & IARF_ADD) { log_rule_B("pp_space_after ADD"); const size_t mult = options::pp_space_count(); reindent_line(next, pc->GetColumn() + pc->Len() + (pp_level * mult)); } else if (options::pp_space_after() & IARF_REMOVE) { log_rule_B("pp_space_after REMOVE"); reindent_line(next, pc->GetColumn() + pc->Len()); } } // Mark as already handled if not region stuff or in column 1 log_rule_B("pp_indent_at_level"); bool at_file_level = pc->GetBraceLevel() <= ((pc->GetParentType() == CT_PP_DEFINE) ? 1 : 0); if ( ( ( at_file_level && !options::pp_indent_at_level0()) || ( !at_file_level && !options::pp_indent_at_level())) && pc->GetParentType() != CT_PP_REGION && pc->GetParentType() != CT_PP_ENDREGION) { log_rule_B("pp_define_at_level"); if ( !options::pp_define_at_level() || pc->GetParentType() != CT_PP_DEFINE) { pc->SetFlagBits(PCF_DONT_INDENT); } } LOG_FMT(LPPIS, "%s(%d): orig line %zu to %zu (len %zu, next->col %zu)\n", __func__, __LINE__, pc->GetOrigLine(), 1 + pp_level, pc->Len(), next ? next->GetColumn() : -1); } } // indent_preproc uncrustify-uncrustify-0.76.0/src/indent.h000066400000000000000000000022721434072136500204610ustar00rootroot00000000000000/** * @file indent.h * prototypes for indent.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef INDENT_H_INCLUDED #define INDENT_H_INCLUDED #include "uncrustify_types.h" /** * Change the top-level indentation only by changing the column member in * the chunk structures. * The level indicator must already be set. */ void indent_text(); /** * Indent the preprocessor stuff from column 1. * FIXME: This is broken if there is a comment or escaped newline * between '#' and 'define'. */ void indent_preproc(); /** * * @param pc chunk at the start of the line * @param column desired column */ void indent_to_column(Chunk *pc, size_t column); /** * Same as indent_to_column, except we can move both ways * * @param pc chunk at the start of the line * @param column desired column */ void align_to_column(Chunk *pc, size_t column); //! Scan to see if the whole file is covered by one #ifdef bool ifdef_over_whole_file(); /** * Changes the initial indent for a line to the given column * * @param pc The chunk at the start of the line * @param column The desired column */ void reindent_line(Chunk *pc, size_t column); #endif /* INDENT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/keywords.cpp000066400000000000000000001455601434072136500214120ustar00rootroot00000000000000/** * @file keywords.cpp * Manages the table of keywords. * * @author Ben Gardner * @author Guy Maurel since version 0.62 for uncrustify4Qt * October 2015, 2016 * @license GPL v2+ */ #include "keywords.h" #include "args.h" #include "prototypes.h" #include "uncrustify.h" #include "uncrustify_limits.h" #include #include using namespace std; // Dynamic keyword map typedef map dkwmap; static dkwmap dkwm; /** * Compares two chunk_tag_t entries using strcmp on the strings * * @param the 'left' entry * @param the 'right' entry * * @return == 0 if both keywords are equal * @return < 0 p1 is smaller than p2 * @return > 0 p2 is smaller than p1 */ static int kw_compare(const void *p1, const void *p2); /** * search in static keywords for first occurrence of a given tag * * @param tag/keyword to search for */ static const chunk_tag_t *kw_static_first(const chunk_tag_t *tag); static const chunk_tag_t *kw_static_match(bool orig_list, const chunk_tag_t *tag, int lang_flags); /** * selected keywords for the chosen language. */ static chunk_tag_t keyword_for_lang[uncrustify::limits::MAX_KEYWORDS]; static size_t language_count; /** * interesting static keywords - keep sorted. * Table includes the Name, Type, and Language flags. */ static chunk_tag_t keywords[] = { // TODO: it might be useful if users could add their custom keywords to this list { "@autoreleasepool", CT_AUTORELEASEPOOL, LANG_OC }, { "@available", CT_OC_AVAILABLE, LANG_OC }, { "@catch", CT_CATCH, LANG_OC }, { "@dynamic", CT_OC_DYNAMIC, LANG_OC }, { "@end", CT_OC_END, LANG_OC }, { "@finally", CT_FINALLY, LANG_OC }, { "@implementation", CT_OC_IMPL, LANG_OC }, { "@interface", CT_OC_INTF, LANG_OC }, { "@interface", CT_CLASS, LANG_JAVA }, { "@private", CT_ACCESS, LANG_OC }, { "@property", CT_OC_PROPERTY, LANG_OC }, { "@protected", CT_ACCESS, LANG_OC }, { "@protocol", CT_OC_PROTOCOL, LANG_OC }, { "@public", CT_ACCESS, LANG_OC }, { "@selector", CT_OC_SEL, LANG_OC }, { "@synchronized", CT_SYNCHRONIZED, LANG_OC }, { "@synthesize", CT_OC_DYNAMIC, LANG_OC }, { "@throw", CT_THROW, LANG_OC }, { "@try", CT_TRY, LANG_OC }, { "API_AVAILABLE", CT_ATTRIBUTE, LANG_OC }, { "API_DEPRECATED", CT_ATTRIBUTE, LANG_OC }, { "API_DEPRECATED_WITH_REPLACEMENT", CT_ATTRIBUTE, LANG_OC }, { "API_UNAVAILABLE", CT_ATTRIBUTE, LANG_OC }, { "BOOL", CT_TYPE, LANG_OC }, { "INT16_C", CT_TYPE, LANG_CPP }, { "INT32_C", CT_TYPE, LANG_CPP }, { "INT64_C", CT_TYPE, LANG_CPP }, { "INT8_C", CT_TYPE, LANG_CPP }, { "INTMAX_C", CT_TYPE, LANG_CPP }, { "NS_ENUM", CT_ENUM, LANG_OC }, { "NS_OPTIONS", CT_ENUM, LANG_OC }, { "Q_EMIT", CT_Q_EMIT, LANG_CPP }, { "Q_FOREACH", CT_FOR, LANG_CPP }, { "Q_FOREVER", CT_Q_FOREVER, LANG_CPP }, { "Q_GADGET", CT_Q_GADGET, LANG_CPP }, { "Q_OBJECT", CT_COMMENT_EMBED, LANG_CPP }, { "Q_SIGNALS", CT_ACCESS, LANG_CPP }, { "UINT16_C", CT_TYPE, LANG_CPP }, { "UINT32_C", CT_TYPE, LANG_CPP }, { "UINT64_C", CT_TYPE, LANG_CPP }, { "UINT8_C", CT_TYPE, LANG_CPP }, { "UINTMAX_C", CT_TYPE, LANG_CPP }, { "_Bool", CT_TYPE, LANG_C | LANG_CPP }, { "_Complex", CT_TYPE, LANG_C | LANG_CPP }, { "_Imaginary", CT_TYPE, LANG_C | LANG_CPP }, { "_Nonnull", CT_QUALIFIER, LANG_OC }, { "_Null_unspecified", CT_QUALIFIER, LANG_OC }, { "_Nullable", CT_QUALIFIER, LANG_OC }, { "_Pragma", CT_PP_PRAGMA, LANG_ALL | FLAG_PP }, { "__DI__", CT_DI, LANG_C | LANG_CPP }, { "__HI__", CT_HI, LANG_C | LANG_CPP }, { "__QI__", CT_QI, LANG_C | LANG_CPP }, { "__SI__", CT_SI, LANG_C | LANG_CPP }, { "__asm__", CT_ASM, LANG_C | LANG_CPP }, { "__attribute__", CT_ATTRIBUTE, LANG_C | LANG_CPP | LANG_OC }, { "__autoreleasing", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__block", CT_QUALIFIER, LANG_C | LANG_CPP | LANG_OC }, { "__bridge", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__bridge_retained", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__bridge_transfer", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__const__", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__declspec", CT_DECLSPEC, LANG_C | LANG_CPP }, { "__except", CT_CATCH, LANG_C | LANG_CPP }, { "__finally", CT_FINALLY, LANG_C | LANG_CPP }, { "__has_include", CT_CNG_HASINC, LANG_C | LANG_CPP | LANG_OC | FLAG_PP }, { "__has_include_next", CT_CNG_HASINCN, LANG_C | LANG_CPP | FLAG_PP }, { "__inline__", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__nonnull", CT_QUALIFIER, LANG_OC }, { "__nothrow__", CT_NOTHROW, LANG_C | LANG_CPP }, { "__null_unspecified", CT_QUALIFIER, LANG_OC }, { "__nullable", CT_QUALIFIER, LANG_OC }, { "__pragma", CT_PP_PRAGMA, LANG_ALL | FLAG_PP }, { "__restrict", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__signed__", CT_TYPE, LANG_C | LANG_CPP }, { "__strong", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__thread", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__traits", CT_QUALIFIER, LANG_D }, { "__try", CT_TRY, LANG_C | LANG_CPP }, { "__typeof", CT_DECLTYPE, LANG_C | LANG_CPP | LANG_OC }, { "__typeof__", CT_DECLTYPE, LANG_C | LANG_CPP }, { "__unsafe_unretained", CT_QUALIFIER, LANG_OC }, { "__unused", CT_ATTRIBUTE, LANG_C | LANG_CPP }, { "__volatile__", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__weak", CT_QUALIFIER, LANG_C | LANG_CPP }, { "__word__", CT_WORD_, LANG_C | LANG_CPP }, { "abstract", CT_QUALIFIER, LANG_CS | LANG_D | LANG_JAVA | LANG_VALA | LANG_ECMA }, { "add", CT_GETSET, LANG_CS }, { "alias", CT_USING, LANG_D }, { "align", CT_ALIGN, LANG_D }, { "alignof", CT_SIZEOF, LANG_CPP }, { "and", CT_SBOOL, LANG_CPP }, { "and_eq", CT_SASSIGN, LANG_CPP }, { "as", CT_AS, LANG_CS | LANG_VALA }, { "asm", CT_ASM, LANG_C | LANG_CPP | LANG_D }, { "asm", CT_PP_ASM, LANG_ALL | FLAG_PP }, { "assert", CT_ASSERT, LANG_JAVA }, { "assert", CT_FUNCTION, LANG_D | LANG_PAWN }, { "assert", CT_PP_ASSERT, LANG_PAWN | FLAG_PP }, { "auto", CT_TYPE, LANG_C | LANG_CPP | LANG_D }, { "base", CT_BASE, LANG_CS | LANG_VALA }, { "bit", CT_TYPE, LANG_D }, { "bitand", CT_ARITH, LANG_C | LANG_CPP }, { "bitor", CT_ARITH, LANG_C | LANG_CPP }, { "body", CT_BODY, LANG_D }, { "bool", CT_TYPE, LANG_C | LANG_CPP | LANG_CS | LANG_VALA }, { "boolean", CT_TYPE, LANG_JAVA | LANG_ECMA }, { "break", CT_BREAK, LANG_ALL }, { "byte", CT_TYPE, LANG_CS | LANG_D | LANG_JAVA | LANG_ECMA }, { "callback", CT_QUALIFIER, LANG_VALA }, { "case", CT_CASE, LANG_ALL }, { "cast", CT_D_CAST, LANG_D }, { "catch", CT_CATCH, LANG_CPP | LANG_CS | LANG_VALA | LANG_D | LANG_JAVA | LANG_ECMA }, { "cdouble", CT_TYPE, LANG_D }, { "cent", CT_TYPE, LANG_D }, { "cfloat", CT_TYPE, LANG_D }, { "char", CT_CHAR, LANG_PAWN }, { "char", CT_TYPE, LANG_ALLC }, { "checked", CT_QUALIFIER, LANG_CS }, { "class", CT_CLASS, LANG_CPP | LANG_CS | LANG_D | LANG_JAVA | LANG_VALA | LANG_ECMA }, { "compl", CT_ARITH, LANG_CPP }, { "const", CT_QUALIFIER, LANG_ALL }, { "const_cast", CT_TYPE_CAST, LANG_CPP }, { "constexpr", CT_QUALIFIER, LANG_CPP }, { "construct", CT_CONSTRUCT, LANG_VALA }, { "continue", CT_CONTINUE, LANG_ALL }, { "creal", CT_TYPE, LANG_D }, { "dchar", CT_TYPE, LANG_D }, { "debug", CT_DEBUG, LANG_D }, { "debugger", CT_DEBUGGER, LANG_ECMA }, { "decltype", CT_DECLTYPE, LANG_CPP }, { "default", CT_DEFAULT, LANG_ALL }, { "define", CT_PP_DEFINE, LANG_ALL | FLAG_PP }, { "defined", CT_DEFINED, LANG_PAWN }, { "defined", CT_PP_DEFINED, LANG_ALLC | FLAG_PP }, { "delegate", CT_DELEGATE, LANG_CS | LANG_VALA | LANG_D }, { "delete", CT_DELETE, LANG_CPP | LANG_D | LANG_ECMA | LANG_VALA }, { "deprecated", CT_QUALIFIER, LANG_D }, { "do", CT_DO, LANG_ALL }, { "double", CT_TYPE, LANG_ALLC }, { "dynamic_cast", CT_TYPE_CAST, LANG_CPP }, { "elif", CT_PP_ELSE, LANG_ALLC | FLAG_PP }, { "else", CT_ELSE, LANG_ALL }, { "else", CT_PP_ELSE, LANG_ALL | FLAG_PP }, { "elseif", CT_PP_ELSE, LANG_PAWN | FLAG_PP }, { "emit", CT_PP_EMIT, LANG_PAWN | FLAG_PP }, { "endif", CT_PP_ENDIF, LANG_ALL | FLAG_PP }, { "endinput", CT_PP_ENDINPUT, LANG_PAWN | FLAG_PP }, { "endregion", CT_PP_ENDREGION, LANG_ALL | FLAG_PP }, { "endscript", CT_PP_ENDINPUT, LANG_PAWN | FLAG_PP }, { "enum", CT_ENUM, LANG_ALL }, { "error", CT_PP_ERROR, LANG_PAWN | FLAG_PP }, { "errordomain", CT_ENUM, LANG_VALA }, { "event", CT_TYPE, LANG_CS }, { "exit", CT_FUNCTION, LANG_PAWN }, { "explicit", CT_QUALIFIER, LANG_CPP | LANG_CS }, { "export", CT_EXPORT, LANG_CPP | LANG_D | LANG_ECMA }, { "extends", CT_QUALIFIER, LANG_JAVA | LANG_ECMA }, { "extern", CT_EXTERN, LANG_C | LANG_CPP | LANG_OC | LANG_CS | LANG_D | LANG_VALA }, { "false", CT_WORD, LANG_ALL }, { "file", CT_PP_FILE, LANG_PAWN | FLAG_PP }, { "final", CT_QUALIFIER, LANG_CPP | LANG_D | LANG_ECMA }, { "finally", CT_FINALLY, LANG_D | LANG_CS | LANG_VALA | LANG_ECMA | LANG_JAVA }, { "fixed", CT_FIXED, LANG_CS }, { "flags", CT_TYPE, LANG_VALA }, { "float", CT_TYPE, LANG_ALLC }, { "for", CT_FOR, LANG_ALL }, { "foreach", CT_FOR, LANG_CS | LANG_D | LANG_VALA }, { "foreach_reverse", CT_FOR, LANG_D }, { "forward", CT_FORWARD, LANG_PAWN }, { "friend", CT_FRIEND, LANG_CPP }, { "function", CT_FUNCTION, LANG_D | LANG_ECMA }, { "get", CT_GETSET, LANG_CS | LANG_VALA }, { "goto", CT_GOTO, LANG_ALL }, { "idouble", CT_TYPE, LANG_D }, { "if", CT_IF, LANG_ALL }, { "if", CT_PP_IF, LANG_ALL | FLAG_PP }, { "ifdef", CT_PP_IF, LANG_ALLC | FLAG_PP }, { "ifloat", CT_TYPE, LANG_D }, { "ifndef", CT_PP_IF, LANG_ALLC | FLAG_PP }, { "implements", CT_QUALIFIER, LANG_JAVA | LANG_ECMA }, { "implicit", CT_QUALIFIER, LANG_CS }, { "import", CT_IMPORT, LANG_D | LANG_JAVA | LANG_ECMA }, { "import", CT_PP_INCLUDE, LANG_OC | FLAG_PP }, { "in", CT_IN, LANG_D | LANG_CS | LANG_VALA | LANG_ECMA | LANG_OC }, { "include", CT_PP_INCLUDE, LANG_C | LANG_CPP | LANG_OC | LANG_PAWN | FLAG_PP }, { "inline", CT_QUALIFIER, LANG_C | LANG_CPP }, { "inout", CT_QUALIFIER, LANG_D }, { "instanceof", CT_SIZEOF, LANG_JAVA | LANG_ECMA }, { "int", CT_TYPE, LANG_ALLC }, { "interface", CT_CLASS, LANG_CPP | LANG_CS | LANG_D | LANG_JAVA | LANG_VALA | LANG_ECMA }, { "internal", CT_QUALIFIER, LANG_CS | LANG_VALA }, { "invariant", CT_INVARIANT, LANG_D }, { "ireal", CT_TYPE, LANG_D }, { "is", CT_SCOMPARE, LANG_D | LANG_CS | LANG_VALA }, { "lazy", CT_LAZY, LANG_D }, { "line", CT_PP_LINE, LANG_PAWN | FLAG_PP }, { "lock", CT_LOCK, LANG_CS | LANG_VALA }, { "long", CT_TYPE, LANG_ALLC }, { "macro", CT_D_MACRO, LANG_D }, { "mixin", CT_CLASS, LANG_D }, // may need special handling { "module", CT_D_MODULE, LANG_D }, { "mutable", CT_QUALIFIER, LANG_CPP }, { "namespace", CT_NAMESPACE, LANG_CPP | LANG_CS | LANG_VALA }, { "native", CT_NATIVE, LANG_PAWN }, { "native", CT_QUALIFIER, LANG_JAVA | LANG_ECMA }, { "new", CT_NEW, LANG_CPP | LANG_CS | LANG_D | LANG_JAVA | LANG_PAWN | LANG_VALA | LANG_ECMA }, { "noexcept", CT_NOEXCEPT, LANG_CPP }, { "nonnull", CT_TYPE, LANG_OC }, { "not", CT_SARITH, LANG_CPP }, { "not_eq", CT_SCOMPARE, LANG_CPP }, // { "null", CT_TYPE, LANG_CS | LANG_D | LANG_JAVA | LANG_VALA }, { "null_resettable", CT_OC_PROPERTY_ATTR, LANG_OC }, { "null_unspecified", CT_TYPE, LANG_OC }, { "nullable", CT_TYPE, LANG_OC }, { "object", CT_TYPE, LANG_CS }, { "operator", CT_OPERATOR, LANG_CPP | LANG_CS | LANG_PAWN }, { "or", CT_SBOOL, LANG_CPP }, { "or_eq", CT_SASSIGN, LANG_CPP }, { "out", CT_QUALIFIER, LANG_CS | LANG_D | LANG_VALA }, { "override", CT_QUALIFIER, LANG_CPP | LANG_CS | LANG_D | LANG_VALA }, { "package", CT_ACCESS, LANG_D }, { "package", CT_PACKAGE, LANG_ECMA | LANG_JAVA }, { "params", CT_TYPE, LANG_CS | LANG_VALA }, { "pragma", CT_PP_PRAGMA, LANG_ALL | FLAG_PP }, { "private", CT_ACCESS, LANG_ALLC }, // not C { "property", CT_PP_PROPERTY, LANG_CS | FLAG_PP }, { "protected", CT_ACCESS, LANG_ALLC }, // not C { "public", CT_ACCESS, LANG_ALL }, // PAWN // not C { "readonly", CT_QUALIFIER, LANG_CS }, { "real", CT_TYPE, LANG_D }, { "ref", CT_QUALIFIER, LANG_CS | LANG_VALA }, { "region", CT_PP_REGION, LANG_ALL | FLAG_PP }, { "register", CT_QUALIFIER, LANG_C | LANG_CPP }, { "reinterpret_cast", CT_TYPE_CAST, LANG_CPP }, { "remove", CT_GETSET, LANG_CS }, { "restrict", CT_QUALIFIER, LANG_C | LANG_CPP }, { "return", CT_RETURN, LANG_ALL }, { "sbyte", CT_TYPE, LANG_CS }, { "scope", CT_D_SCOPE, LANG_D }, { "sealed", CT_QUALIFIER, LANG_CS }, { "section", CT_PP_SECTION, LANG_PAWN | FLAG_PP }, { "self", CT_THIS, LANG_OC }, { "set", CT_GETSET, LANG_CS | LANG_VALA }, { "short", CT_TYPE, LANG_ALLC }, { "signal", CT_ACCESS, LANG_VALA }, { "signals", CT_ACCESS, LANG_CPP }, { "signed", CT_TYPE, LANG_C | LANG_CPP }, { "size_t", CT_TYPE, LANG_ALLC }, { "sizeof", CT_SIZEOF, LANG_C | LANG_CPP | LANG_CS | LANG_VALA | LANG_PAWN }, { "sleep", CT_SIZEOF, LANG_PAWN }, { "stackalloc", CT_NEW, LANG_CS }, { "state", CT_STATE, LANG_PAWN }, { "static", CT_QUALIFIER, LANG_ALL }, { "static_cast", CT_TYPE_CAST, LANG_CPP }, { "stock", CT_STOCK, LANG_PAWN }, { "strictfp", CT_QUALIFIER, LANG_JAVA }, { "string", CT_TYPE, LANG_CS | LANG_VALA }, { "struct", CT_STRUCT, LANG_C | LANG_CPP | LANG_OC | LANG_CS | LANG_D | LANG_VALA }, { "super", CT_SUPER, LANG_D | LANG_JAVA | LANG_ECMA }, { "switch", CT_SWITCH, LANG_ALL }, { "synchronized", CT_QUALIFIER, LANG_D | LANG_ECMA }, { "synchronized", CT_SYNCHRONIZED, LANG_JAVA }, { "tagof", CT_TAGOF, LANG_PAWN }, { "template", CT_TEMPLATE, LANG_CPP | LANG_D }, { "this", CT_THIS, LANG_CPP | LANG_CS | LANG_D | LANG_JAVA | LANG_VALA | LANG_ECMA }, { "throw", CT_THROW, LANG_CPP | LANG_CS | LANG_VALA | LANG_D | LANG_JAVA | LANG_ECMA }, { "throws", CT_QUALIFIER, LANG_JAVA | LANG_ECMA | LANG_VALA }, { "transient", CT_QUALIFIER, LANG_JAVA | LANG_ECMA }, { "true", CT_WORD, LANG_ALL }, { "try", CT_TRY, LANG_CPP | LANG_CS | LANG_D | LANG_JAVA | LANG_ECMA | LANG_VALA }, { "tryinclude", CT_PP_INCLUDE, LANG_PAWN | FLAG_PP }, { "typedef", CT_TYPEDEF, LANG_C | LANG_CPP | LANG_OC | LANG_D }, { "typeid", CT_SIZEOF, LANG_CPP | LANG_D }, { "typename", CT_TYPENAME, LANG_CPP }, { "typeof", CT_DECLTYPE, LANG_C | LANG_CPP }, { "typeof", CT_SIZEOF, LANG_CS | LANG_D | LANG_VALA | LANG_ECMA }, { "ubyte", CT_TYPE, LANG_D }, { "ucent", CT_TYPE, LANG_D }, { "uint", CT_TYPE, LANG_CS | LANG_VALA | LANG_D }, { "ulong", CT_TYPE, LANG_CS | LANG_VALA | LANG_D }, { "unchecked", CT_QUALIFIER, LANG_CS }, { "undef", CT_PP_UNDEF, LANG_ALL | FLAG_PP }, { "union", CT_UNION, LANG_C | LANG_CPP | LANG_D }, { "unittest", CT_UNITTEST, LANG_D }, { "unsafe", CT_UNSAFE, LANG_CS }, { "unsafe_unretained", CT_QUALIFIER, LANG_OC }, { "unsigned", CT_TYPE, LANG_C | LANG_CPP }, { "ushort", CT_TYPE, LANG_CS | LANG_VALA | LANG_D }, { "using", CT_USING, LANG_CPP | LANG_CS | LANG_VALA }, { "var", CT_TYPE, LANG_CS | LANG_VALA | LANG_ECMA }, { "version", CT_D_VERSION, LANG_D }, { "virtual", CT_QUALIFIER, LANG_CPP | LANG_CS | LANG_VALA }, { "void", CT_TYPE, LANG_ALLC }, { "volatile", CT_QUALIFIER, LANG_C | LANG_CPP | LANG_CS | LANG_JAVA | LANG_ECMA }, { "volatile", CT_VOLATILE, LANG_D }, { "wchar", CT_TYPE, LANG_D }, { "wchar_t", CT_TYPE, LANG_C | LANG_CPP }, { "weak", CT_QUALIFIER, LANG_VALA }, { "when", CT_WHEN, LANG_CS }, { "where", CT_WHERE, LANG_CS }, { "while", CT_WHILE, LANG_ALL }, { "with", CT_D_WITH, LANG_D | LANG_ECMA }, { "xor", CT_SARITH, LANG_CPP }, { "xor_eq", CT_SASSIGN, LANG_CPP }, }; // Issue #3353 void init_keywords_for_language() { unsigned int local_flags = cpd.lang_flags; size_t keywords_count = ARRAY_SIZE(keywords); language_count = 0; for (size_t idx = 0; idx < keywords_count; idx++) { chunk_tag_t *tag = &keywords[idx]; if ((tag->lang_flags & local_flags) != 0) { // for debugging only // fprintf(stderr, "%s(%d): %zu Keyword: '%s', type is '%s'\n", // __func__, __LINE__, idx, tag->tag, get_token_name(tag->type)); keyword_for_lang[language_count].tag = tag->tag; keyword_for_lang[language_count].type = tag->type; keyword_for_lang[language_count].lang_flags = tag->lang_flags; language_count++; } } LOG_FMT(LDYNKW, "%s(%d): Number of Keywords for language %d: '%zu'\n", __func__, __LINE__, local_flags, language_count); } // init_keywords_for_language static int kw_compare(const void *p1, const void *p2) { const chunk_tag_t *t1 = static_cast(p1); const chunk_tag_t *t2 = static_cast(p2); return(strcmp(t1->tag, t2->tag)); } // kw_compare bool keywords_are_sorted() { size_t keywords_count = ARRAY_SIZE(keywords); for (size_t idx = 1; idx < keywords_count; idx++) { if (kw_compare(&keywords[idx - 1], &keywords[idx]) > 0) { fprintf(stderr, "%s: bad sort order at idx %d, words '%s' and '%s'\n", __func__, (int)idx - 1, keywords[idx - 1].tag, keywords[idx].tag); // coveralls will always complain. // these lines are only needed for the developer. log_flush(true); exit(EX_SOFTWARE); } } return(true); } // keywords_are_sorted void add_keyword(const std::string &tag, E_Token type) { // See if the keyword has already been added dkwmap::iterator it = dkwm.find(tag); if (it != dkwm.end()) { LOG_FMT(LDYNKW, "%s(%d): changed '%s' to '%s'\n", __func__, __LINE__, tag.c_str(), get_token_name(type)); (*it).second = type; return; } // Insert the keyword dkwm.insert(dkwmap::value_type(tag, type)); LOG_FMT(LDYNKW, "%s(%d): added '%s' as '%s'\n", __func__, __LINE__, tag.c_str(), get_token_name(type)); } // add_keyword static const chunk_tag_t *kw_static_first(const chunk_tag_t *tag) { const chunk_tag_t *prev = tag - 1; // TODO: avoid pointer arithmetic // loop over static keyword array while ( prev >= &keyword_for_lang[0] // not at beginning of keyword array && strcmp(prev->tag, tag->tag) == 0) // tags match { tag = prev; prev--; } return(tag); } // kw_static_first static const chunk_tag_t *kw_static_match(bool orig_list, const chunk_tag_t *tag, int lang_flags) { bool in_pp = ( cpd.in_preproc != CT_NONE && cpd.in_preproc != CT_PP_DEFINE); for (const chunk_tag_t *iter = kw_static_first(tag); (orig_list) ? (iter < &keywords[ARRAY_SIZE(keywords)]) : (iter < &keyword_for_lang[language_count]); iter++) { bool pp_iter = (iter->lang_flags & FLAG_PP) != 0; // forcing value to bool if ( (strcmp(iter->tag, tag->tag) == 0) && language_is_set(iter->lang_flags) && (lang_flags & iter->lang_flags) && in_pp == pp_iter) { return(iter); } } return(nullptr); } // kw_static_match E_Token find_keyword_type(const char *word, size_t len) { if (len <= 0) { return(CT_NONE); } // check the dynamic word list first string ss(word, len); dkwmap::iterator it = dkwm.find(ss); if (it != dkwm.end()) { return((*it).second); } chunk_tag_t key; key.tag = ss.c_str(); // check the static word list const chunk_tag_t *p_ret = static_cast( bsearch(&key, keyword_for_lang, language_count, sizeof(keyword_for_lang[0]), kw_compare)); if (p_ret != nullptr) { if ( strcmp(p_ret->tag, "__pragma") == 0 || strcmp(p_ret->tag, "_Pragma") == 0) { cpd.in_preproc = CT_PREPROC; } p_ret = kw_static_match(false, p_ret, cpd.lang_flags); } return((p_ret != nullptr) ? p_ret->type : CT_WORD); } // find_keyword_type int load_keyword_file(const char *filename) { FILE *pf = fopen(filename, "r"); if (pf == nullptr) { LOG_FMT(LERR, "%s: fopen(%s) failed: %s (%d)\n", __func__, filename, strerror(errno), errno); exit(EX_IOERR); } const int max_line_length = 256; const int max_arg_count = 2; // maximal length of a line in the file char buf[max_line_length]; char *args[max_arg_count]; size_t line_no = 0; // read file line by line while (fgets(buf, max_line_length, pf) != nullptr) { line_no++; // remove comments after '#' sign char *ptr; if ((ptr = strchr(buf, '#')) != nullptr) { *ptr = 0; // set string end where comment begins } size_t argc = Args::SplitLine(buf, args, max_arg_count); if (argc > 0) { if ( argc == 1 && CharTable::IsKw1(*args[0])) { add_keyword(args[0], CT_TYPE); } else { LOG_FMT(LWARN, "%s:%zu Invalid line (starts with '%s')\n", filename, line_no, args[0]); exit(EX_SOFTWARE); } } else { continue; // the line is empty } } fclose(pf); return(EX_OK); } // load_keyword_file void print_custom_keywords(FILE *pfile) { for (const auto &keyword_pair : dkwm) { E_Token tt = keyword_pair.second; if (tt == CT_TYPE) { fprintf(pfile, "custom type %*.s%s\n", uncrustify::limits::MAX_OPTION_NAME_LEN - 10, " ", keyword_pair.first.c_str()); } else if (tt == CT_MACRO_OPEN) { fprintf(pfile, "macro-open %*.s%s\n", uncrustify::limits::MAX_OPTION_NAME_LEN - 11, " ", keyword_pair.first.c_str()); } else if (tt == CT_MACRO_CLOSE) { fprintf(pfile, "macro-close %*.s%s\n", uncrustify::limits::MAX_OPTION_NAME_LEN - 12, " ", keyword_pair.first.c_str()); } else if (tt == CT_MACRO_ELSE) { fprintf(pfile, "macro-else %*.s%s\n", uncrustify::limits::MAX_OPTION_NAME_LEN - 11, " ", keyword_pair.first.c_str()); } else { const char *tn = get_token_name(tt); fprintf(pfile, "set %s %*.s%s\n", tn, uncrustify::limits::MAX_OPTION_NAME_LEN - (4 + static_cast(strlen(tn))), " ", keyword_pair.first.c_str()); } } } // print_custom_keywords void clear_keyword_file() { dkwm.clear(); } // clear_keyword_file pattern_class_e get_token_pattern_class(E_Token tok) { // TODO: instead of this switch better assign the pattern class to each statement switch (tok) { case CT_IF: case CT_ELSEIF: case CT_SWITCH: case CT_FOR: case CT_WHILE: case CT_SYNCHRONIZED: case CT_USING_STMT: case CT_LOCK: case CT_D_WITH: case CT_D_VERSION_IF: case CT_D_SCOPE_IF: return(pattern_class_e::PBRACED); case CT_ELSE: return(pattern_class_e::ELSE); case CT_DO: case CT_TRY: case CT_FINALLY: case CT_BODY: case CT_UNITTEST: case CT_UNSAFE: case CT_VOLATILE: case CT_GETSET: return(pattern_class_e::BRACED); case CT_CATCH: case CT_D_VERSION: case CT_DEBUG: return(pattern_class_e::OPBRACED); case CT_NAMESPACE: return(pattern_class_e::VBRACED); case CT_WHILE_OF_DO: return(pattern_class_e::PAREN); case CT_INVARIANT: return(pattern_class_e::OPPAREN); default: return(pattern_class_e::NONE); } // switch } // get_token_pattern_class uncrustify-uncrustify-0.76.0/src/keywords.h000066400000000000000000000036541434072136500210540ustar00rootroot00000000000000/** * @file keywords.h * prototypes for keywords.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef KEYWORDS_H_INCLUDED #define KEYWORDS_H_INCLUDED #include "uncrustify_types.h" /** * Initializes keywords table for a given language. * * Let us have a look on the problem is caused by the tokens "in" and "out", * used in the file "Issue_3353.h" under. * The strings representing the tokens ("in" and "out"), are found in the * original table: static chunk_tag_t keywords[] because they are used by * other languages. They are tokenized as CT_IN and CT_OUT. * The correct tokenization is CT_FUNC_VAR. * * It is necessary to create (at run time) a new table with all the keywords * proper to the used language. * */ /** * The file * "Issue_3353.h" * struct A { * void (*in)( * void); * void (*out)( * void); * }; */ void init_keywords_for_language(); /** * Loads the dynamic keywords from a file * * @param filename The path to the file to load * * @retval EX_OK successfully read keywords from file * @retval EX_IOERR reading keywords file failed */ int load_keyword_file(const char *filename); /** * Search first the dynamic and then the static table for a matching keyword * * @param word Pointer to the text -- NOT zero terminated * @param len The length of the text * * @return CT_WORD (no match) or the keyword token */ E_Token find_keyword_type(const char *word, size_t len); /** * Adds a keyword to the list of dynamic keywords * * @param tag The tag (string) must be zero terminated * @param type The type, usually CT_TYPE */ void add_keyword(const std::string &tag, E_Token type); void print_custom_keywords(FILE *pfile); void clear_keyword_file(); //! Returns the pattern that the keyword needs based on the token pattern_class_e get_token_pattern_class(E_Token tok); bool keywords_are_sorted(); #endif /* KEYWORDS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/lang_pawn.cpp000066400000000000000000000316721434072136500215070ustar00rootroot00000000000000/** * @file lang_pawn.cpp * Special functions for pawn stuff * * @author Ben Gardner * @license GPL v2+ */ #include "lang_pawn.h" #include "prototypes.h" using namespace uncrustify; /** * Checks to see if a token continues a statement to the next line. * We need to check for 'open' braces/paren/etc because the level doesn't * change until the token after the open. */ static bool pawn_continued(Chunk *pc, size_t br_level); /** * Functions prototypes and definitions can only appear in level 0. * * Function prototypes start with "native", "forward", or are just a function * with a trailing semicolon instead of a open brace (or something else) * * somefunc(params) <-- def * stock somefunc(params) <-- def * somefunc(params); <-- proto * forward somefunc(params) <-- proto * native somefunc[rect](params) <-- proto * * Functions start with 'stock', 'static', 'public', or '@' (on level 0) * * Variable definitions start with 'stock', 'static', 'new', or 'public'. */ static Chunk *pawn_process_line(Chunk *start); //! We are on a level 0 function proto of def static Chunk *pawn_mark_function0(Chunk *start, Chunk *fcn); /** * follows a variable definition at level 0 until the end. * Adds a semicolon at the end, if needed. */ static Chunk *pawn_process_variable(Chunk *start); static Chunk *pawn_process_func_def(Chunk *pc); Chunk *pawn_add_vsemi_after(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc->IsSemicolon()) { return(pc); } Chunk *next = pc->GetNextNc(); if ( next->IsNotNullChunk() && next->IsSemicolon()) { return(pc); } Chunk chunk = *pc; chunk.SetType(CT_VSEMICOLON); chunk.SetParentType(CT_NONE); chunk.Str() = options::mod_pawn_semicolon() ? ";" : ""; chunk.SetColumn(pc->GetColumn() + pc->Len()); LOG_FMT(LPVSEMI, "%s: Added VSEMI on line %zu, prev='%s' [%s]\n", __func__, pc->GetOrigLine(), pc->Text(), get_token_name(pc->GetType())); return(chunk.CopyAndAddAfter(pc)); } void pawn_scrub_vsemi() { constexpr static auto LCURRENT = LPVSEMI; LOG_FUNC_ENTRY(); log_rule_B("mod_pawn_semicolon"); if (!options::mod_pawn_semicolon()) { return; } for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->IsNot(CT_VSEMICOLON)) { continue; } Chunk *prev = pc->GetPrevNcNnl(); if (prev->Is(CT_BRACE_CLOSE)) { if ( prev->GetParentType() == CT_IF || prev->GetParentType() == CT_ELSE || prev->GetParentType() == CT_SWITCH || prev->GetParentType() == CT_CASE || prev->GetParentType() == CT_WHILE_OF_DO) { pc->Str().clear(); } } } } static bool pawn_continued(Chunk *pc, size_t br_level) { LOG_FUNC_ENTRY(); if (pc == nullptr) { return(false); } if ( pc->GetLevel() > br_level || pc->Is(CT_ARITH) || pc->Is(CT_SHIFT) || pc->Is(CT_CARET) || pc->Is(CT_QUESTION) || pc->Is(CT_BOOL) || pc->Is(CT_ASSIGN) || pc->Is(CT_COMMA) || pc->Is(CT_COMPARE) || pc->Is(CT_IF) || pc->Is(CT_ELSE) || pc->Is(CT_DO) || pc->Is(CT_SWITCH) || pc->Is(CT_WHILE) || pc->Is(CT_BRACE_OPEN) || pc->Is(CT_VBRACE_OPEN) || pc->Is(CT_FPAREN_OPEN) || pc->GetParentType() == CT_IF || pc->GetParentType() == CT_ELSE || pc->GetParentType() == CT_ELSEIF || pc->GetParentType() == CT_DO || pc->GetParentType() == CT_FOR || pc->GetParentType() == CT_SWITCH || pc->GetParentType() == CT_WHILE || pc->GetParentType() == CT_FUNC_DEF || pc->GetParentType() == CT_ENUM || pc->GetFlags().test_any(PCF_IN_ENUM | PCF_IN_STRUCT) || pc->IsString(":") || pc->IsString("+") || pc->IsString("-")) { return(true); } return(false); } // pawn_continued void pawn_prescan() { LOG_FUNC_ENTRY(); /* * Start at the beginning and step through the entire file, and clean up * any questionable stuff */ bool did_nl = true; Chunk *pc = Chunk::GetHead(); while ( pc != nullptr && pc->IsNotNullChunk()) { if ( did_nl && pc->IsNot(CT_PREPROC) && !pc->IsNewline() && pc->GetLevel() == 0) { // pc now points to the start of a line pc = pawn_process_line(pc); } // note that continued lines are ignored if ( pc != nullptr && pc->IsNotNullChunk()) { did_nl = (pc->Is(CT_NEWLINE)); } pc = pc->GetNextNc(); } } static Chunk *pawn_process_line(Chunk *start) { LOG_FUNC_ENTRY(); //LOG_FMT(LSYS, "%s: %d - %s\n", __func__, // start->GetOrigLine(), start->Text()); if ( start->Is(CT_NEW) || start->IsString("const")) { return(pawn_process_variable(start)); } // if a open paren is found before an assign, then this is a function Chunk *fcn = nullptr; if (start->Is(CT_WORD)) { fcn = start; } Chunk *pc = start; while ( ((pc = pc->GetNextNc())->IsNotNullChunk()) && !pc->IsString("(") && pc->IsNot(CT_ASSIGN) && pc->IsNot(CT_NEWLINE)) { if ( pc->GetLevel() == 0 && ( pc->Is(CT_FUNCTION) || pc->Is(CT_WORD) || pc->Is(CT_OPERATOR_VAL))) { fcn = pc; } } if (pc->IsNotNullChunk()) { if (pc->Is(CT_ASSIGN)) { return(pawn_process_variable(pc)); } } if (fcn != nullptr) { //LOG_FMT(LSYS, "FUNCTION: %s\n", fcn->Text()); return(pawn_mark_function0(start, fcn)); } if (start->Is(CT_ENUM)) { pc = start->GetNextType(CT_BRACE_CLOSE, start->GetLevel()); return(pc); } //LOG_FMT(LSYS, "%s: Don't understand line %d, starting with '%s' [%s]\n", // __func__, start->GetOrigLine(), start->Text(), get_token_name(start->GetType())); return(start); } // pawn_process_line static Chunk *pawn_process_variable(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::NullChunkPtr; if ( start != nullptr && start->IsNotNullChunk()) { pc = start; } Chunk *prev = Chunk::NullChunkPtr; while ((pc = pc->GetNextNc())->IsNotNullChunk()) { if ( pc->Is(CT_NEWLINE) && prev->IsNotNullChunk() && !pawn_continued(prev, start->GetLevel())) { if (!prev->IsSemicolon()) { pawn_add_vsemi_after(prev); } break; } prev = pc; } return(pc); } void pawn_add_virtual_semicolons() { LOG_FUNC_ENTRY(); // Add Pawn virtual semicolons if (language_is_set(LANG_PAWN)) { Chunk *prev = Chunk::NullChunkPtr; Chunk *pc = Chunk::GetHead(); while ((pc = pc->GetNext())->IsNotNullChunk()) { if ( !pc->IsCommentOrNewline() && !pc->IsVBrace()) { prev = pc; } if ( prev->IsNullChunk() || ( pc->IsNot(CT_NEWLINE) && !pc->IsBraceClose())) { continue; } // we just hit a newline and we have a previous token if ( !prev->TestFlags(PCF_IN_PREPROC) && !prev->GetFlags().test_any(PCF_IN_ENUM | PCF_IN_STRUCT) && !prev->IsSemicolon() && !pawn_continued(prev, prev->GetBraceLevel())) { pawn_add_vsemi_after(prev); prev = Chunk::NullChunkPtr; } } } } // pawn_add_virtual_semicolons static Chunk *pawn_mark_function0(Chunk *start, Chunk *fcn) { LOG_FUNC_ENTRY(); // handle prototypes if (start == fcn) { Chunk *last = fcn->GetNextType(CT_PAREN_CLOSE, fcn->GetLevel())->GetNext(); if (last->Is(CT_SEMICOLON)) { LOG_FMT(LPFUNC, "%s: %zu] '%s' proto due to semicolon\n", __func__, fcn->GetOrigLine(), fcn->Text()); fcn->SetType(CT_FUNC_PROTO); return(last); } } else { if ( start->Is(CT_FORWARD) || start->Is(CT_NATIVE)) { LOG_FMT(LPFUNC, "%s: %zu] '%s' [%s] proto due to %s\n", __func__, fcn->GetOrigLine(), fcn->Text(), get_token_name(fcn->GetType()), get_token_name(start->GetType())); fcn->SetType(CT_FUNC_PROTO); return(fcn->GetNextNc()); } } // Not a prototype, so it must be a function def return(pawn_process_func_def(fcn)); } static Chunk *pawn_process_func_def(Chunk *pc) { LOG_FUNC_ENTRY(); // We are on a function definition pc->SetType(CT_FUNC_DEF); LOG_FMT(LPFUNC, "%s: %zu:%zu %s\n", __func__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); /* * If we don't have a brace open right after the close fparen, then * we need to add virtual braces around the function body. */ Chunk *clp = pc->GetNextString(")", 1, 0); Chunk *last = clp->GetNextNcNnl(); if (last->IsNotNullChunk()) { LOG_FMT(LPFUNC, "%s: %zu] last is '%s' [%s]\n", __func__, last->GetOrigLine(), last->Text(), get_token_name(last->GetType())); } // See if there is a state clause after the function if ( last->IsNotNullChunk() && last->IsString("<")) { LOG_FMT(LPFUNC, "%s: %zu] '%s' has state angle open %s\n", __func__, pc->GetOrigLine(), pc->Text(), get_token_name(last->GetType())); last->SetType(CT_ANGLE_OPEN); last->SetParentType(CT_FUNC_DEF); while ( ((last = last->GetNext())->IsNotNullChunk()) && !last->IsString(">")) { // do nothing just search, TODO: use search_chunk } if (last->IsNotNullChunk()) { LOG_FMT(LPFUNC, "%s: %zu] '%s' has state angle close %s\n", __func__, pc->GetOrigLine(), pc->Text(), get_token_name(last->GetType())); last->SetType(CT_ANGLE_CLOSE); last->SetParentType(CT_FUNC_DEF); } last = last->GetNextNcNnl(); } if (last->IsNullChunk()) { return(last); } if (last->Is(CT_BRACE_OPEN)) { last->SetParentType(CT_FUNC_DEF); last = last->GetNextType(CT_BRACE_CLOSE, last->GetLevel()); if (last->IsNotNullChunk()) { last->SetParentType(CT_FUNC_DEF); } } else { LOG_FMT(LPFUNC, "%s: %zu] '%s' fdef: expected brace open: %s\n", __func__, pc->GetOrigLine(), pc->Text(), get_token_name(last->GetType())); // do not insert a vbrace before a preproc if (last->TestFlags(PCF_IN_PREPROC)) { return(last); } Chunk chunk = *last; chunk.Str().clear(); chunk.SetType(CT_VBRACE_OPEN); chunk.SetParentType(CT_FUNC_DEF); Chunk *prev = chunk.CopyAndAddBefore(last); last = prev; // find the next newline at level 0 prev = prev->GetNextNcNnl(); do { LOG_FMT(LPFUNC, "%s:%zu] check %s, level %zu\n", __func__, prev->GetOrigLine(), get_token_name(prev->GetType()), prev->GetLevel()); if ( prev->Is(CT_NEWLINE) && prev->GetLevel() == 0) { Chunk *next = prev->GetNextNcNnl(); if ( next->IsNotNullChunk() && next->IsNot(CT_ELSE) && next->IsNot(CT_WHILE_OF_DO)) { break; } } prev->SetLevel(prev->GetLevel() + 1); prev->SetBraceLevel(prev->GetBraceLevel() + 1); last = prev; } while ((prev = prev->GetNext())->IsNotNullChunk()); if ( last != nullptr && last->IsNotNullChunk()) { LOG_FMT(LPFUNC, "%s:%zu] ended on %s, level %zu\n", __func__, last->GetOrigLine(), get_token_name(last->GetType()), last->GetLevel()); } chunk = *last; chunk.Str().clear(); chunk.SetType(CT_VBRACE_CLOSE); chunk.SetParentType(CT_FUNC_DEF); chunk.SetColumn(chunk.GetColumn() + last->Len()); chunk.SetLevel(0); chunk.SetBraceLevel(0); last = chunk.CopyAndAddAfter(last); } return(last); } // pawn_process_func_def Chunk *pawn_check_vsemicolon(Chunk *pc) { LOG_FUNC_ENTRY(); // Grab the open VBrace Chunk *vb_open = pc->GetPrevType(CT_VBRACE_OPEN); /* * Grab the item before the newline * Don't do anything if: * - the only thing previous is the V-Brace open * - in a preprocessor * - level > (vb_open->GetLevel() + 1) -- ie, in () or [] * - it is something that needs a continuation * + arith, assign, bool, comma, compare */ Chunk *prev = pc->GetPrevNcNnl(); if ( prev->IsNullChunk() || prev == vb_open || prev->TestFlags(PCF_IN_PREPROC) || pawn_continued(prev, vb_open->GetLevel() + 1)) { if (prev->IsNotNullChunk()) { LOG_FMT(LPVSEMI, "%s: no VSEMI on line %zu, prev='%s' [%s]\n", __func__, prev->GetOrigLine(), prev->Text(), get_token_name(prev->GetType())); } return(pc); } return(pawn_add_vsemi_after(prev)); } uncrustify-uncrustify-0.76.0/src/lang_pawn.h000066400000000000000000000020321434072136500211400ustar00rootroot00000000000000/** * @file long_pawn.h * prototypes for long_pawn.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef LONG_PAWN_H_INCLUDED #define LONG_PAWN_H_INCLUDED #include "uncrustify_types.h" /** * Does a scan of level 0 BEFORE stuff in combine.cpp is called. * At this point, VSemis have been added only in VBraces. * Otherwise, all level info is correct, except for unbraced functions. * * We are looking for unbraced functions. */ void pawn_prescan(); void pawn_add_virtual_semicolons(); /** * We are in a virtual brace and hit a newline. * If this should end the vbrace, then insert a VSEMICOLON and return that. * * @param pc The newline (CT_NEWLINE) * * @return Either the newline or the newly inserted virtual semicolon */ Chunk *pawn_check_vsemicolon(Chunk *pc); /** * Turns certain virtual semicolons invisible. * - after a close brace with a parent of switch, case, else, if */ void pawn_scrub_vsemi(); //! add a semicolon after ... Chunk *pawn_add_vsemi_after(Chunk *pc); #endif /* LONG_PAWN_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/language_tools.cpp000066400000000000000000000003571434072136500225400ustar00rootroot00000000000000/** * @file language_tools.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "language_tools.h" /** * check if the language(s) is/are set */ bool language_is_set(size_t lang) { return((cpd.lang_flags & lang) != 0); } uncrustify-uncrustify-0.76.0/src/language_tools.h000066400000000000000000000004571434072136500222060ustar00rootroot00000000000000/** * @file language_tools.h * * @author Guy Maurel * @license GPL v2+ */ #ifndef LANGUAGE_TOOLS_H_INCLUDED #define LANGUAGE_TOOLS_H_INCLUDED #include "uncrustify_types.h" /** * check if the language(s) is/are set */ bool language_is_set(size_t lang); #endif /* LANGUAGE_TOOLS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/log_levels.h000066400000000000000000000124351434072136500213350ustar00rootroot00000000000000/** * @file log_levels.h * * Enum for log levels. * Use these for the log severities in LOG_FMT(), etc. * * @author Ben Gardner * @author Guy Maurel October 2015- 2021 * @license GPL v2+ */ #ifndef LOG_LEVELS_H_INCLUDED #define LOG_LEVELS_H_INCLUDED /** * list of available log levels * * The user defines which log level is active using the * -L or -log option. * use -L A to set all the levels * All messages which have a level that is active will be stored to the log * file. * All other log messages will be discarded. * Different parts of the software use different log levels. * This allows to log only operations of a specific operation. * This eases debugging. * To get all log messages use the option -La * By default only system messages (level=LSYS) are logged. */ enum log_sev_t { LSYS = 0, //! system messages LERR = 1, //! error messages LWARN = 2, //! warnings LNOTE = 3, //! user notifications LINFO = 4, //! user information LDATA = 5, //! data logging LFILELIST = 8, //! Files in the file list file LLINEENDS = 9, //! Show which line endings are used LCASTS = 10, //! align casts LALBR = 11, //! align braces LALTD = 12, //! Align Typedef LALPP = 13, //! align #define LALPROTO = 14, //! align prototype LALNLC = 15, //! align backslash-newline LALTC = 16, //! align trailing comments LALADD = 17, //! align add LALASS = 18, //! align assign LFVD = 19, //! fix_var_def LFVD2 = 20, //! fix_var_def-2 LINDENT = 21, //! indent_text LINDENT2 = 22, //! indent_text tab level LINDPSE = 23, //! indent_text stack LINDPC = 24, //! indent play-by-play LNEWLINE = 25, //! newlines LPF = 26, //! Parse Frame LSTMT = 27, //! Marking statements/expressions LTOK = 28, //! Tokenize LALRC = 29, //! align right comment LCMTIND = 30, //! Comment Indent LINDLINE = 31, //! indent line LSIB = 32, //! Scan IB LRETURN = 33, //! add/remove parens for return or throw LBRDEL = 34, //! brace removal LFCN = 35, //! function detection LFCNP = 36, //! function parameters LPCU = 37, //! parse cleanup LDYNKW = 38, //! dynamic keywords LOUTIND = 39, //! output indent LBCSAFTER = 40, //! Brace cleanup stack - after each token LBCSPOP = 41, //! Brace cleanup stack - log pops LBCSPUSH = 42, //! Brace cleanup stack - log push LBCSSWAP = 43, //! Brace cleanup stack - log swaps LFTOR = 44, //! Class Ctor or Dtor LAS = 45, //! align_stack LPPIS = 46, //! Preprocessor Indent and Space LTYPEDEF = 47, //! Typedef and function types LVARDEF = 48, //! Variable def marking LDEFVAL = 49, //! define values LPVSEMI = 50, //! Pawn: virtual semicolons LPFUNC = 51, //! Pawn: function recognition LSPLIT = 52, //! Line splitting LFTYPE = 53, //! Function type detection LTEMPL = 54, //! Template detection LPARADD = 55, //! adding parens in if/while LPARADD2 = 56, //! adding parens in if/while - details LBLANKD = 57, //! blank line details LTEMPFUNC = 58, //! Template function detection LSCANSEMI = 59, //! scan semicolon removal LDELSEMI = 60, //! Removing semicolons LFPARAM = 61, //! Testing for a full parameter LNL1LINE = 62, //! NL check for 1 liners LPFCHK = 63, //! Parse Frame check function call LAVDB = 64, //! align var def braces LSORT = 65, //! Sorting LSPACE = 66, //! Space LALIGN = 67, //! align LALAGAIN = 68, //! align again LOPERATOR = 69, //! operator LASFCP = 70, //! Align Same Function Call Params LINDLINED = 71, //! indent line details LBCTRL = 72, //! beautifier control LRMRETURN = 73, //! remove 'return;' LPPIF = 74, //! #if/#else/#endif pair processing LMCB = 75, //! mod_case_brace LBRCH = 76, //! if brace chain LFCNR = 77, //! function return type LOCCLASS = 78, //! OC Class stuff LOCMSG = 79, //! OC Message stuff LBLANK = 80, //! Blank Lines LOBJCWORD = 81, //! Convert keyword to CT_WORD in certain circumstances LCHANGE = 82, //! something changed LCONTTEXT = 83, //! comment cont_text set LANNOT = 84, //! Java annotation LOCBLK = 85, //! OC Block stuff LFLPAREN = 86, //! Flag paren LOCMSGD = 87, //! OC Message declaration LINDENTAG = 88, //! indent again LNFD = 89, //! newline-function-def LJDBI = 90, //! Java Double Brace Init LSETPAR = 91, //! Chunk::SetParentTypeReal() LSETTYP = 92, //! Chunk::SetTypeReal() LSETFLG = 93, //! set_chunk_flags() LNLFUNCT = 94, //! newlines before function LCHUNK = 95, //! Add or delete chunk LBC = 96, //! brace cleanup LCOMBINE = 97, //! combine LGUY98 = 98, //! for guy-test LGUY = 99, //! for guy-test LBR = 100, //! braces LOUTPUT = 101, //! output LUNC = 102, //! rules used in uncrustify.cpp LQT = 103, //! load/save options for Qt LVARDFBLK = 104, //! newlines for variable definition blocks LOTHER = 255, //! stuff that doesn't neatly fit any other category }; #endif /* LOG_LEVELS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/log_rules.cpp000066400000000000000000000056471434072136500215370ustar00rootroot00000000000000/** * @file log_rules.cpp * is an extract from space.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "log_rules.h" #include "unc_tools.h" void log_rule2(const char *func, size_t line, const char *rule, Chunk *first, Chunk *second) { LOG_FUNC_ENTRY(); if (second->IsNot(CT_NEWLINE)) { LOG_FMT(LSPACE, "%s(%zu): first orig line is %zu, orig col is %zu, Text() is '%s', [%s/%s] <===>\n", func, line, first->GetOrigLine(), first->GetOrigCol(), first->Text(), get_token_name(first->GetType()), get_token_name(first->GetParentType())); LOG_FMT(LSPACE, " second orig line is %zu, orig col is %zu, Text() is '%s', [%s/%s] :", second->GetOrigLine(), second->GetOrigCol(), second->Text(), get_token_name(second->GetType()), get_token_name(second->GetParentType())); LOG_FMT(LSPACE, " rule %s[line %zu]\n", rule, line); } } #ifdef SUPER_LOG void log_rule3(log_sev_t sev, const char *func, size_t line, const char *rule) #else void log_rule3(log_sev_t sev, const char *func, const char *rule) #endif { // some Windows platforms provide a qualified function name ("ABC::XYZ::function_Name") // as __func__; call get_unqualified_func_name() to return an unqualified function name func = get_unqualified_func_name(func); #ifdef SUPER_LOG LOG_FMT(sev, "log_rule(%s:%zu): rule is '%s'\n", func, line, rule); #else LOG_FMT(sev, "log_rule(%s): rule is '%s'\n", func, rule); #endif } void log_rule4(const char *rule, Chunk *first) { if (!(cpd.html_type == tracking_type_e::TT_SPACE)) { return; } if (first->GetTrackingData() == nullptr) { first->TrackingData() = new track_list; } // copy the rule size_t length = strlen(rule) + 1; char *r = (char *)malloc(length); strcpy(r, rule); size_t a_number = get_A_Number(); Track_nr A = make_pair(a_number, r); first->TrackingData()->push_back(A); size_t sizeOfTrack = first->GetTrackingData()->size(); LOG_FMT(LSPACE, "log_rule4(%d): rule is '%s', after '%s', at line %zu, tracking number is %zu, size is %zu\n", __LINE__, rule, first->Text(), first->GetOrigLine(), a_number, sizeOfTrack); } void log_ruleNL(const char *rule, Chunk *pc) { if (!(cpd.html_type == tracking_type_e::TT_NEWLINE)) { return; } if (pc->GetTrackingData() == nullptr) { pc->TrackingData() = new track_list; } // copy the rule size_t length = strlen(rule) + 1; char *r = (char *)malloc(length); strcpy(r, rule); size_t a_number = get_A_Number(); Track_nr A = make_pair(a_number, r); pc->TrackingData()->push_back(A); size_t sizeOfTrack = pc->GetTrackingData()->size(); LOG_FMT(LSPACE, "log_rule4(%d): rule is '%s', after '%s', at line %zu, tracking number is %zu, size is %zu\n", __LINE__, rule, pc->Text(), pc->GetOrigLine(), a_number, sizeOfTrack); } uncrustify-uncrustify-0.76.0/src/log_rules.h000066400000000000000000000024671434072136500212010ustar00rootroot00000000000000/** * @file log_rules.h * prototypes for log_rules.cpp * * @author Guy Maurel * @license GPL v2+ */ #ifndef LOG_RULES_H_INCLUDED #define LOG_RULES_H_INCLUDED #include "chunk.h" #include "uncrustify.h" using namespace uncrustify; #if defined DEBUG #define log_rule(rule) \ log_rule2(__func__, __LINE__, (rule), first, second); \ log_rule4((rule), first) #else #define log_rule(rule) \ log_rule2(__func__, __LINE__, (rule), first, second) #endif // if you need more debug information, remove the comment at the next line #define SUPER_LOG 1 #ifdef SUPER_LOG #define log_rule_B(rule) \ log_rule3(LCURRENT, __func__, __LINE__, (rule)) #else #define log_rule_B(rule) \ log_rule3(LCURRENT, __func__, (rule)) #endif #ifdef SUPER_LOG #define log_rule_NL(rule) \ log_ruleNL((rule), pc) #else #define log_rule_NL(rule) \ log_ruleNL(LCURRENT, __func__, (rule)) #endif void log_rule2(const char *func, size_t line, const char *rule, Chunk *first, Chunk *second); #ifdef SUPER_LOG void log_rule3(log_sev_t sev, const char *func, size_t line, const char *rule); #else void log_rule3(log_sev_t sev, const char *func, const char *rule); #endif void log_rule4(const char *rule, Chunk *first); void log_ruleNL(const char *rule, Chunk *pc); #endif /* LOG_RULES_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/logger.cpp000066400000000000000000000170741434072136500210200ustar00rootroot00000000000000/** * @file logger.cpp * * Functions to do logging. * * If a log statement ends in a newline, the current log is ended. * When the log severity changes, an implicit newline is inserted. * * @author Ben Gardner * @license GPL v2+ */ #include "logger.h" #include "compat.h" #include // to get va_start, va_end struct log_fcn_info { log_fcn_info(const char *name_, int line_) : name(name_) , line(line_) { } const char *name; int line; }; static std::deque g_fq; //! Private log structure struct log_buf { log_buf() : log_file(nullptr) , sev(LSYS) , in_log(0) , buf_len(0) , show_hdr(false) { bufX.clear(); bufX.resize(256); } FILE *log_file; //! file where the log messages are stored into log_sev_t sev; //! log level determines which messages are logged int in_log; //! flag indicates if a log operation is going on size_t buf_len; //! number of characters currently stored in buffer std::vector bufX; //! buffer holds the log message log_mask_t mask; bool show_hdr; //! flag determine if a header gets added to log message }; static struct log_buf g_log; /** * Starts the log statement by flushing if needed and printing the header * * @param sev The log severity * * @return The number of bytes available */ static size_t log_start(log_sev_t sev); /** * Cleans up after a log statement by detecting whether the log is done, * (it ends in a newline) and possibly flushing the log. */ static void log_end(); /** * Initializes the log subsystem - call this first. * This function sets the log stream and enables the top 3 sevs (0-2). * * @param log_file NULL for stderr or the FILE stream for logs. */ void log_init(FILE *log_file) { // set the top 3 severities logmask_set_all(g_log.mask, false); log_set_sev(LSYS, true); log_set_sev(LERR, true); log_set_sev(LWARN, true); g_log.log_file = (log_file != nullptr) ? log_file : stderr; } void log_show_sev(bool show) { g_log.show_hdr = show; } bool log_sev_on(log_sev_t sev) { return(logmask_test(g_log.mask, sev)); } void log_set_sev(log_sev_t sev, bool value) { logmask_set_sev(g_log.mask, sev, value); } void log_set_mask(const log_mask_t &mask) { g_log.mask = mask; } void log_get_mask(log_mask_t &mask) { mask = g_log.mask; } void log_flush(bool force_nl) { if (g_log.buf_len > 0) { if ( force_nl && g_log.bufX[g_log.buf_len - 1] != '\n') { g_log.bufX[g_log.buf_len++] = '\n'; g_log.bufX[g_log.buf_len] = 0; } size_t retlength = fwrite(&g_log.bufX[0], g_log.buf_len, 1, g_log.log_file); if (retlength != 1) { // maybe we should log something to complain... =) } g_log.buf_len = 0; } } static size_t log_start(log_sev_t sev) { if (sev != g_log.sev) { if (g_log.buf_len > 0) { log_flush(true); } g_log.sev = sev; g_log.in_log = false; } // If not in a log, the buffer is empty. Add the header, if enabled. if ( !g_log.in_log && g_log.show_hdr) { g_log.buf_len = static_cast(snprintf(&g_log.bufX[0], g_log.bufX.size(), "<%d>", sev)); } size_t cap = (g_log.bufX.size() - 2) - g_log.buf_len; return((cap > 0) ? cap : 0); } static void log_end() { g_log.in_log = (g_log.bufX[g_log.buf_len - 1] != '\n'); if ( !g_log.in_log || (g_log.buf_len > (g_log.bufX.size() / 2))) { log_flush(false); } } void log_fmt(log_sev_t sev, const char *fmt, ...) { if ( fmt == nullptr || !log_sev_on(sev)) { return; } // Issue #1203 unsigned int length = strlen(fmt); if (length == 0) { return; } // the value of buffer_length is experimental const int buffer_length = 40000; char buf[buffer_length]; // it MUST be a 'unsigned int' variable to be runable under windows if (length >= buffer_length) { fprintf(stderr, "FATAL(1): The variable 'buf' is not big enough:\n"); fprintf(stderr, " it should be bigger as %u\n", length); fprintf(stderr, "Please make a report.\n"); fprintf(stderr, "For the buffer: %s\n", fmt); exit(EX_SOFTWARE); } memcpy(buf, fmt, length); buf[length] = 0; convert_log_zu2lu(buf); while (true) { /* Some implementation of vsnprintf() return the number of characters * that would have been stored if the buffer was large enough instead of * the number of characters actually stored. * * this gets the number of characters that fit into the log buffer */ size_t cap = log_start(sev); // Add on the variable log parameters to the log string va_list args; // determine list of arguments ... va_start(args, fmt); size_t which = g_log.buf_len; char *where = &g_log.bufX[which]; size_t lenX = static_cast(vsnprintf(where, cap, buf, args)); va_end(args); if (lenX > 0) { // The functions snprintf() and vsnprintf() do not write more than size bytes // (including the terminating null byte ('\0')). If the output was truncated due // to this limit, then the return value is the number of characters (excluding the // terminating null byte) which would have been written to the final string if // enough space had been available. Thus, a return value of size or more means // that the output was truncated. if (lenX > cap) { size_t bufXLength = g_log.bufX.size(); size_t X = bufXLength * 2; if (X >= buffer_length) { fprintf(stderr, "FATAL(2): The variable 'buf' is not big enough:\n"); fprintf(stderr, " it should be bigger as %zu\n", X); fprintf(stderr, "Please make a report.\n"); fprintf(stderr, "For the buffer: %s\n", fmt); exit(EX_SOFTWARE); } g_log.bufX.resize(X); } else { g_log.buf_len += lenX; g_log.bufX[g_log.buf_len] = 0; break; } } } log_end(); } // log_fmt log_func::log_func(const char *name, int line) { g_fq.push_back(log_fcn_info(name, line)); } log_func::~log_func() { g_fq.pop_back(); } void log_func_stack(log_sev_t sev, const char *prefix, const char *suffix, size_t skip_cnt) { UNUSED(skip_cnt); if (prefix) { LOG_FMT(sev, "%s", prefix); } #ifdef DEBUG const char *sep = ""; size_t g_fq_size = g_fq.size(); size_t begin_with; if (g_fq_size > (skip_cnt + 1)) { begin_with = g_fq_size - (skip_cnt + 1); for (size_t idx = begin_with; idx != 0; idx--) { LOG_FMT(sev, "%s %s:%d", sep, g_fq[idx].name, g_fq[idx].line); sep = ","; } LOG_FMT(sev, "%s %s:%d", sep, g_fq[0].name, g_fq[0].line); } #else LOG_FMT(sev, "-DEBUG NOT SET-"); #endif if (suffix) { LOG_FMT(sev, "%s", suffix); } } const char *get_unqualified_func_name(const char *func) { /** * we look for the last ':' character; */ for (auto i = strlen(func); i > 0; --i) { if (func[i - 1] == ':') { /** * function name is qualified, so return the * unqualified portion */ return(func + i); } } /** * input function name is unqualified */ return(func); } uncrustify-uncrustify-0.76.0/src/logger.h000066400000000000000000000147441434072136500204660ustar00rootroot00000000000000/** * @file logger.h * * Functions to do logging. * The macros check whether the logsev is active before evaluating the * parameters. Use them instead of the functions. * * If a log statement ends in a newline, the current log is ended. * When the log severity changes, an implicit newline is inserted. * * @author Ben Gardner * @license GPL v2+ */ #ifndef LOGGER_H_INCLUDED #define LOGGER_H_INCLUDED #include "logmask.h" #include // FILE /** * Initializes the log subsystem - call this first. * This function sets the log stream and enables the top 3 sevs (0-2). * * @param log_file nullptr for stderr or the FILE stream for logs. */ void log_init(FILE *log_file); /** * Show or hide the severity prefix "<1>" * * @param show true=show, false=hide */ void log_show_sev(bool show); /** * Returns whether a log severity is active. * * @param sev severity log level * * @return true/false */ bool log_sev_on(log_sev_t sev); /** * Sets a log sev on or off * * @param sev severity log level to modify * @param val new value for severity log level * * @return true/false */ void log_set_sev(log_sev_t sev, bool value); /** * Sets the log mask * * @param mask The mask to copy */ void log_set_mask(const log_mask_t &mask); /** * Gets the log mask * * @param mask Where to copy the mask */ void log_get_mask(log_mask_t &mask); #ifdef __MINGW_PRINTF_FORMAT // On MinGW, the printf functions can be provided by a number of different // implementations, with different format string support. Annontate log_fmt // below with the same format attribute as the currently chosen default printf // function. #define PRINTF_FORMAT __MINGW_PRINTF_FORMAT #else #define PRINTF_FORMAT printf #endif /** * Logs a formatted string -- similar to printf() * * @param sev The severity * @param fmt The format string * @param ... Additional arguments */ void log_fmt(log_sev_t sev, const char *fmt, ...) __attribute__((format(PRINTF_FORMAT, 2, 3))); /** * Flushes the cached log text to the stream * * @param force_nl Append NL if not present */ void log_flush(bool force_nl); // it is necessary to make at least one time pro change a check of all the // uses of the MACRO LOG_FMT under Linux. This to detect all the used pointers, // which might be nullptr. // uncomment the define to do that. // #define NO_MACRO_VARARG #ifdef NO_MACRO_VARARG #define LOG_FMT log_fmt // TODO during debugging add source file and line number #else #define LOG_FMT(sev, ...) \ if (log_sev_on(sev)) { log_fmt(sev, __VA_ARGS__); } #endif #define __unqualified_func__ get_unqualified_func_name(__func__) #define LOG_CHUNK(sev, pc_current) \ if (pc_current->Is(CT_NEWLINE)) \ { \ LOG_FMT(sev, "%s(%d): orig line is %zu, orig col is %zu, , PRE is %s\n", \ __func__, __LINE__, pc_current->GetOrigLine(), pc_current->GetOrigCol(), pc_current->IsPreproc() ? "true" : "false"); \ } \ else if (pc_current->Is(CT_NL_CONT)) \ { \ LOG_FMT(sev, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s, PRE is %s\n", \ __func__, __LINE__, pc_current->GetOrigLine(), pc_current->GetOrigCol(), pc_current->Text(), get_token_name(pc_current->GetType()), pc_current->IsPreproc() ? "true" : "false"); \ } \ else \ { \ LOG_FMT(sev, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s, PRE is %s\n", \ __func__, __LINE__, pc_current->GetOrigLine(), pc_current->GetOrigCol(), pc_current->Text(), get_token_name(pc_current->GetType()), pc_current->IsPreproc() ? "true" : "false"); \ } #ifdef DEBUG /** * This should be called as the first thing in a function. * It uses the log_func class to add an entry to the function log stack. * It is automatically removed when the function returns. */ #define LOG_FUNC_ENTRY() log_func log_fe = log_func(__unqualified_func__, __LINE__) #else #define LOG_FUNC_ENTRY() #endif /** * This class just adds a entry to the top of the stack on construction and * removes it on destruction. * RAII for the win. */ class log_func { public: log_func(const char *name, int line); ~log_func(); }; void log_func_stack(log_sev_t sev, const char *prefix = 0, const char *suffix = "\n", size_t skip_cnt = 0); /** * Return the unqualified function name from the input argument * @param the qualified function name, usually provided by __func__ macro * @return the corresponding unqualified name */ const char *get_unqualified_func_name(const char *func); #define log_func_stack_inline(_sev) log_func_stack((_sev), " [CallStack:", "]\n", 0) #endif /* LOGGER_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/logmask.cpp000066400000000000000000000057511434072136500211750ustar00rootroot00000000000000/** * @file logmask.cpp * * Functions to convert between a string and a severity mask. * * @author Ben Gardner * @license GPL v2+ */ #include "logmask.h" #include "unc_ctype.h" #include // snprintf() #include // strtoul() #ifdef DEVELOP_ONLY /* * the test suite Coveralls: https://coveralls.io * will complains because these functions are only * used at development time. * Don't worry about unused lines for the functions: * logmask_to_str */ char *logmask_to_str(const log_mask_t &mask, char *buf, int size) { if ( buf == nullptr || size <= 0) { return(buf); } int last_sev = -1; bool is_range = false; int len = 0; for (int sev = 0; sev < 256; sev++) { if (logmask_test(mask, static_cast(sev))) { if (last_sev == -1) { len += snprintf(&buf[len], size - len, "%d,", sev); } else { is_range = true; } last_sev = sev; } else { if (is_range) { buf[len - 1] = '-'; // change last comma to a dash len += snprintf(&buf[len], size - len, "%d,", last_sev); is_range = false; } last_sev = -1; } } // handle a range that ends on the last bit if ( is_range && last_sev != -1) { buf[len - 1] = '-'; // change last comma to a dash len += snprintf(&buf[len], size - len, "%d", last_sev); } else { // Eat the last comma if (len > 0) { len--; } } buf[len] = 0; return(buf); } // logmask_to_str #endif /* DEVELOP_ONLY */ void logmask_from_string(const char *str, log_mask_t &mask) { if (str == nullptr) { return; } logmask_set_all(mask, false); // Start with a clean mask // If the first character is 'a' or 'A', set all severities if (unc_toupper(*str) == 'A') { logmask_set_all(mask, true); str++; } char *ptmp; bool was_dash = false; int last_level = -1; while (*str != 0) // check string until termination character { if (unc_isspace(*str)) // ignore spaces and go on with next character { str++; continue; } if (unc_isdigit(*str)) { int level = strtoul(str, &ptmp, 10); str = ptmp; logmask_set_sev(mask, static_cast(level), true); if (was_dash) { for (int idx = last_level + 1; idx < level; idx++) { logmask_set_sev(mask, static_cast(idx), true); } was_dash = false; } last_level = level; } else if (*str == '-') // a dash marks all bits until the next number { was_dash = true; str++; } else // probably a comma { last_level = -1; was_dash = false; str++; } } } // logmask_from_string uncrustify-uncrustify-0.76.0/src/logmask.h000066400000000000000000000040131434072136500206300ustar00rootroot00000000000000/** * @file logmask.h * * Functions to manipulate a log severity mask. * * @author Ben Gardner * @license GPL v2+ */ #ifndef LOGMASK_H_INCLUDED #define LOGMASK_H_INCLUDED #include "base_types.h" #include "log_levels.h" #include #include // memset() /* * the test suite Coveralls: https://coveralls.io * will complains because these functions are only * used at development time. * Don't worry about unused lines for the functions: * logmask_test * logmask_set_all */ //! A simple array of 256 bits typedef std::bitset<256> log_mask_t; /** * Tests whether a sev bit is set in the mask * * @param mask log mask to evaluate * @param sev severity bit to check * * @return true (is set) or false (not set) */ static inline bool logmask_test(const log_mask_t &mask, log_sev_t sev) { return(mask.test(sev)); } /** * Sets a set bit in the mask * * @param mask log mask to modify * @param sev The severity to check * @param value true (set bit) or false (clear bit) */ static inline void logmask_set_sev(log_mask_t &mask, log_sev_t sev, bool value) { mask.set(sev, value); } /** * Sets all bits to the same value * * @param mast log mask to operate on * @param value true (set bit) or false (clear bit) */ static inline void logmask_set_all(log_mask_t &mask, bool value) { if (value) { mask.set(); } else { mask.reset(); } } #ifdef DEVELOP_ONLY /** * Convert a logmask into a string. * The string is a comma-delimited list of severities. * Example: 1,3,5-10 * * @param mask the mask to convert * @param buf the buffer to hold the string * @param size the size of the buffer * * @return buf (pass through) */ char *logmask_to_str(const log_mask_t &mask, char *buf, int size); #endif /* DEVELOP_ONLY */ /** * Parses a string into a log severity * * @param str string to parse * @param mask bit mask to populate with log levels */ void logmask_from_string(const char *str, log_mask_t &mask); #endif /* LOGMASK_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/mark_question_colon.cpp000066400000000000000000000102071434072136500236030ustar00rootroot00000000000000/** * @file mark_question_colon.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "mark_question_colon.h" #include "chunk.h" #include "combine_tools.h" #include "log_levels.h" #include "unc_tools.h" /* * Issue #3558 * will be called if a chunk ? (CT_QUESTION) is entcountered * return the chunk : * return nullptr is a chunk ; (CT_SEMI_COLON) is found */ Chunk *search_for_colon(Chunk *pc_local) { Chunk *pc2; LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() is '%s'\n", __func__, __LINE__, pc_local->GetOrigLine(), pc_local->GetOrigCol(), pc_local->GetLevel(), pc_local->Text()); Chunk *colon = pc_local->GetNextType(CT_COLON, pc_local->GetLevel()); if (colon != nullptr) { LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() is '%s'\n", __func__, __LINE__, colon->GetOrigLine(), colon->GetOrigCol(), colon->GetLevel(), colon->Text()); colon->SetType(CT_COND_COLON); flag_series(pc_local, colon, PCF_IN_CONDITIONAL); // examine the next tokens, search for a next CT_QUESTION for (pc2 = colon->GetNext(); pc2->IsNotNullChunk(); pc2 = pc2->GetNextNcNnl()) { LOG_FMT(LCOMBINE, "%s(%d): THE NEXT: orig line is %zu, orig col is %zu, level is %zu, Text() is '%s'\n", __func__, __LINE__, pc2->GetOrigLine(), pc2->GetOrigCol(), pc2->GetLevel(), pc2->Text()); pc2->SetFlagBits(PCF_IN_CONDITIONAL); log_pcf_flags(LCOMBINE, pc2->GetFlags()); if (pc2->Is(CT_SEMICOLON)) { LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() is '%s'\n", __func__, __LINE__, pc2->GetOrigLine(), pc2->GetOrigCol(), pc2->GetLevel(), pc2->Text()); return(pc2); } else if (pc2->Is(CT_QUESTION)) { LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() is '%s'\n", __func__, __LINE__, pc2->GetOrigLine(), pc2->GetOrigCol(), pc2->GetLevel(), pc2->Text()); pc2 = search_for_colon(pc2); LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() is '%s'\n", __func__, __LINE__, pc2->GetOrigLine(), pc2->GetOrigCol(), pc2->GetLevel(), pc2->Text()); return(pc2); } } } else { LOG_FMT(LWARN, "%s(%d): %zu: Error: Expected a colon\n", __func__, __LINE__, pc_local->GetOrigLine()); exit(EX_SOFTWARE); } LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() is '?'\n", __func__, __LINE__, pc2->GetOrigLine(), pc2->GetOrigCol(), pc2->GetLevel()); return(pc2); } // search_for_colon void mark_question_colon() { LOG_FUNC_ENTRY(); Chunk *pc; // Issue #3558 for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel(), pc->Text()); log_pcf_flags(LCOMBINE, pc->GetFlags()); if (pc->Is(CT_QUESTION)) { Chunk *colon = search_for_colon(pc); if (colon != nullptr) { LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() is '%s'\n", __func__, __LINE__, colon->GetOrigLine(), colon->GetOrigCol(), colon->GetLevel(), colon->Text()); if (colon->Is(CT_SEMICOLON)) { // set at the end of the question statement ... pc = colon; LOG_FMT(LCOMBINE, "%s(%d): orig line is %zu, orig col is %zu, level is %zu, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel(), pc->Text()); // ... and go on } } else { LOG_FMT(LWARN, "%s(%d): %zu: Error: Expected a colon\n", __func__, __LINE__, pc->GetOrigLine()); exit(EX_SOFTWARE); } } } } // mark_question_colon uncrustify-uncrustify-0.76.0/src/mark_question_colon.h000066400000000000000000000003561434072136500232540ustar00rootroot00000000000000/** * @file mark_question_colon.h * * @author Guy Maurel * @license GPL v2+ */ #ifndef MARK_QUESTION_COLON_H_INCLUDED #define MARK_QUESTION_COLON_H_INCLUDED void mark_question_colon(); #endif /* MARK_QUESTION_COLON_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/md5.cpp000066400000000000000000000210751434072136500202220ustar00rootroot00000000000000/** * This code implements the MD5 message-digest algorithm. * The algorithm is due to Ron Rivest. This code was * written by Colin Plumb in 1993, no copyright is claimed. * This code is in the public domain; do with it what you wish. * * Equivalent code is available from RSA Data Security, Inc. * This code has been tested against that, and is equivalent, * except that you don't need to include two pages of legales * with every copy. * * To compute the message digest of a chunk of bytes, declare an * MD5Context structure, pass it to MD5Init, call MD5Update as * needed on buffers full of bytes, and then call MD5Final, which * will fill a supplied 16-byte array with the digest. * * @license Public Domain / GPL v2+ */ #include "md5.h" #include void MD5::reverse_u32(UINT8 *buf, int n_u32) { UINT8 tmp; if (m_big_endian) { // change { 4, 3, 2, 1 } => { 1, 2, 3, 4 } while (n_u32-- > 0) { tmp = buf[0]; buf[0] = buf[3]; buf[3] = tmp; tmp = buf[1]; buf[1] = buf[2]; buf[2] = tmp; buf += 4; } } else { // change { 4, 3, 2, 1 } => { 3, 4, 1, 2 } while (n_u32-- > 0) { tmp = buf[0]; buf[0] = buf[1]; buf[1] = tmp; tmp = buf[2]; buf[2] = buf[3]; buf[3] = tmp; buf += 4; } } } MD5::MD5() { m_buf[0] = 0x01020304; /* * Little endian = { 4, 3, 2, 1 } * Big endian = { 1, 2, 3, 4 } * PDP endian = { 3, 4, 1, 2 } * * The MD5 stuff is written for little endian. */ m_in8 = (UINT8 *)m_in32; m_need_byteswap = *(UINT8 *)m_buf != 4; m_big_endian = *(UINT8 *)m_buf == 1; } //! Start MD5 accumulation. void MD5::Init() { m_buf[0] = 0x67452301; m_buf[1] = 0xefcdab89; m_buf[2] = 0x98badcfe; m_buf[3] = 0x10325476; m_bits[0] = 0; m_bits[1] = 0; } //! Update context to reflect the concatenation of another buffer full of bytes. void MD5::Update(const void *data, UINT32 len) { const UINT8 *buf = (const UINT8 *)data; UINT32 t = m_bits[0]; // Update bitcount if ((m_bits[0] = t + ((UINT32)len << 3)) < t) { m_bits[1]++; // Carry from low to high } m_bits[1] += len >> 29; t = (t >> 3) & 0x3f; // Bytes already in shsInfo->data // Handle any leading odd-sized chunks if (t) { UINT8 *p = m_in8 + t; t = 64 - t; if (len < t) { memcpy(p, buf, len); return; } memcpy(p, buf, t); if (m_need_byteswap) { reverse_u32(m_in8, 16); } Transform(m_buf, m_in32); buf += t; len -= t; } // Process data in 64-byte chunks while (len >= 64) { memcpy(m_in32, buf, 64); if (m_need_byteswap) { reverse_u32(m_in8, 16); } Transform(m_buf, m_in32); buf += 64; // TODO: possible creation of out-of-bounds pointer 64 beyond end of data len -= 64; } // Save off any remaining bytes of data memcpy(m_in32, buf, len); // TODO: possible access beyond array } // MD5::Update void MD5::Final(UINT8 digest[16]) { // Compute number of bytes modulo 64 UINT32 count = (m_bits[0] >> 3) & 0x3F; /* * Set the first char of padding to 0x80. This is safe since there is always * at least one byte free */ UINT8 *p = m_in8 + count; *p++ = 0x80; // Bytes of padding needed to make 64 bytes count = 64 - 1 - count; // Pad out to 56 modulo 64 if (count < 8) { // Two lots of padding: Pad the first block to 64 bytes memset(p, 0, count); if (m_need_byteswap) { reverse_u32(m_in8, 16); } Transform(m_buf, m_in32); // Now fill the next block with 56 bytes memset(m_in32, 0, 56); } else { // Pad block to 56 bytes memset(p, 0, count - 8); } if (m_need_byteswap) { reverse_u32(m_in8, 14); } // Append length in bits and transform memcpy(m_in8 + 56, &m_bits[0], 4); memcpy(m_in8 + 60, &m_bits[1], 4); Transform(m_buf, m_in32); if (m_need_byteswap) { reverse_u32((UINT8 *)m_buf, 4); } memcpy(digest, m_buf, 16); } // MD5::Final // The four core functions - F1 is optimized somewhat // #define F1(x, y, z) (x & y | ~x & z) #define F1(x, y, z) (z ^ (x & (y ^ z))) #define F2(x, y, z) F1(z, x, y) #define F3(x, y, z) (x ^ y ^ z) #define F4(x, y, z) (y ^ (x | ~z)) // This is the central step in the MD5 algorithm. #define MD5STEP(f, w, x, y, z, data, s) \ ((w) += f((x), (y), (z)) + (data), (w) = (w) << (s) | (w) >> (32 - (s)), (w) += (x)) void MD5::Transform(UINT32 buf[4], UINT32 in_data[16]) { UINT32 a = buf[0]; UINT32 b = buf[1]; UINT32 c = buf[2]; UINT32 d = buf[3]; MD5STEP(F1, a, b, c, d, in_data[0] + 0xd76aa478, 7); MD5STEP(F1, d, a, b, c, in_data[1] + 0xe8c7b756, 12); MD5STEP(F1, c, d, a, b, in_data[2] + 0x242070db, 17); MD5STEP(F1, b, c, d, a, in_data[3] + 0xc1bdceee, 22); MD5STEP(F1, a, b, c, d, in_data[4] + 0xf57c0faf, 7); MD5STEP(F1, d, a, b, c, in_data[5] + 0x4787c62a, 12); MD5STEP(F1, c, d, a, b, in_data[6] + 0xa8304613, 17); MD5STEP(F1, b, c, d, a, in_data[7] + 0xfd469501, 22); MD5STEP(F1, a, b, c, d, in_data[8] + 0x698098d8, 7); MD5STEP(F1, d, a, b, c, in_data[9] + 0x8b44f7af, 12); MD5STEP(F1, c, d, a, b, in_data[10] + 0xffff5bb1, 17); MD5STEP(F1, b, c, d, a, in_data[11] + 0x895cd7be, 22); MD5STEP(F1, a, b, c, d, in_data[12] + 0x6b901122, 7); MD5STEP(F1, d, a, b, c, in_data[13] + 0xfd987193, 12); MD5STEP(F1, c, d, a, b, in_data[14] + 0xa679438e, 17); MD5STEP(F1, b, c, d, a, in_data[15] + 0x49b40821, 22); MD5STEP(F2, a, b, c, d, in_data[1] + 0xf61e2562, 5); MD5STEP(F2, d, a, b, c, in_data[6] + 0xc040b340, 9); MD5STEP(F2, c, d, a, b, in_data[11] + 0x265e5a51, 14); MD5STEP(F2, b, c, d, a, in_data[0] + 0xe9b6c7aa, 20); MD5STEP(F2, a, b, c, d, in_data[5] + 0xd62f105d, 5); MD5STEP(F2, d, a, b, c, in_data[10] + 0x02441453, 9); MD5STEP(F2, c, d, a, b, in_data[15] + 0xd8a1e681, 14); MD5STEP(F2, b, c, d, a, in_data[4] + 0xe7d3fbc8, 20); MD5STEP(F2, a, b, c, d, in_data[9] + 0x21e1cde6, 5); MD5STEP(F2, d, a, b, c, in_data[14] + 0xc33707d6, 9); MD5STEP(F2, c, d, a, b, in_data[3] + 0xf4d50d87, 14); MD5STEP(F2, b, c, d, a, in_data[8] + 0x455a14ed, 20); MD5STEP(F2, a, b, c, d, in_data[13] + 0xa9e3e905, 5); MD5STEP(F2, d, a, b, c, in_data[2] + 0xfcefa3f8, 9); MD5STEP(F2, c, d, a, b, in_data[7] + 0x676f02d9, 14); MD5STEP(F2, b, c, d, a, in_data[12] + 0x8d2a4c8a, 20); MD5STEP(F3, a, b, c, d, in_data[5] + 0xfffa3942, 4); MD5STEP(F3, d, a, b, c, in_data[8] + 0x8771f681, 11); MD5STEP(F3, c, d, a, b, in_data[11] + 0x6d9d6122, 16); MD5STEP(F3, b, c, d, a, in_data[14] + 0xfde5380c, 23); MD5STEP(F3, a, b, c, d, in_data[1] + 0xa4beea44, 4); MD5STEP(F3, d, a, b, c, in_data[4] + 0x4bdecfa9, 11); MD5STEP(F3, c, d, a, b, in_data[7] + 0xf6bb4b60, 16); MD5STEP(F3, b, c, d, a, in_data[10] + 0xbebfbc70, 23); MD5STEP(F3, a, b, c, d, in_data[13] + 0x289b7ec6, 4); MD5STEP(F3, d, a, b, c, in_data[0] + 0xeaa127fa, 11); MD5STEP(F3, c, d, a, b, in_data[3] + 0xd4ef3085, 16); MD5STEP(F3, b, c, d, a, in_data[6] + 0x04881d05, 23); MD5STEP(F3, a, b, c, d, in_data[9] + 0xd9d4d039, 4); MD5STEP(F3, d, a, b, c, in_data[12] + 0xe6db99e5, 11); MD5STEP(F3, c, d, a, b, in_data[15] + 0x1fa27cf8, 16); MD5STEP(F3, b, c, d, a, in_data[2] + 0xc4ac5665, 23); MD5STEP(F4, a, b, c, d, in_data[0] + 0xf4292244, 6); MD5STEP(F4, d, a, b, c, in_data[7] + 0x432aff97, 10); MD5STEP(F4, c, d, a, b, in_data[14] + 0xab9423a7, 15); MD5STEP(F4, b, c, d, a, in_data[5] + 0xfc93a039, 21); MD5STEP(F4, a, b, c, d, in_data[12] + 0x655b59c3, 6); MD5STEP(F4, d, a, b, c, in_data[3] + 0x8f0ccc92, 10); MD5STEP(F4, c, d, a, b, in_data[10] + 0xffeff47d, 15); MD5STEP(F4, b, c, d, a, in_data[1] + 0x85845dd1, 21); MD5STEP(F4, a, b, c, d, in_data[8] + 0x6fa87e4f, 6); MD5STEP(F4, d, a, b, c, in_data[15] + 0xfe2ce6e0, 10); MD5STEP(F4, c, d, a, b, in_data[6] + 0xa3014314, 15); MD5STEP(F4, b, c, d, a, in_data[13] + 0x4e0811a1, 21); MD5STEP(F4, a, b, c, d, in_data[4] + 0xf7537e82, 6); MD5STEP(F4, d, a, b, c, in_data[11] + 0xbd3af235, 10); MD5STEP(F4, c, d, a, b, in_data[2] + 0x2ad7d2bb, 15); MD5STEP(F4, b, c, d, a, in_data[9] + 0xeb86d391, 21); buf[0] += a; buf[1] += b; buf[2] += c; buf[3] += d; } // MD5::Transform void MD5::Calc(const void *data, UINT32 length, UINT8 digest[16]) { MD5 md5; md5.Init(); md5.Update(data, length); md5.Final(digest); } uncrustify-uncrustify-0.76.0/src/md5.h000066400000000000000000000033661434072136500176720ustar00rootroot00000000000000/** * @file md5.h * A simple class for MD5 calculation * * @author Ben Gardner * @license GPL v2+ */ #ifndef MD5_H_INCLUDED #define MD5_H_INCLUDED #include "base_types.h" class MD5 { public: MD5(); ~MD5() { } /** * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious * initialization constants. */ void Init(); /** * Update context to reflect the concatenation of another buffer full * of bytes. */ void Update(const void *data, UINT32 len); /** * Final wrapup - pad to 64-byte boundary with the bit pattern * 1 0* (64-bit count of bits processed, MSB-first) * * @param[out] digest calculated MD5 checksum */ void Final(UINT8 digest[16]); /** * The core of the MD5 algorithm, this alters an existing MD5 hash to * reflect the addition of 16 longwords of new data. MD5::Update blocks * the data and converts bytes into longwords for this routine. */ static void Transform(UINT32 buf[4], UINT32 in_data[16]); /** * Calculates MD5 for a block of data * * @param data data to calculate MD5 for * @param length number of bytes in data * @param[out] digest calculated MD5 checksum */ static void Calc(const void *data, UINT32 length, UINT8 digest[16]); private: UINT32 m_buf[4]; UINT32 m_bits[2]; UINT32 m_in32[16]; // Alternate view of m_in32 UINT8 *m_in8; bool m_need_byteswap; bool m_big_endian; /** * Reverse the bytes in 32-bit chunks. * 'buf' might not be word-aligned. * * @param buf The byte array to reverse * @param n_u32 The number of UINT32's in the data */ void reverse_u32(UINT8 *buf, int n_u32); }; #endif /* MD5_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/newlines.cpp000066400000000000000000006413141434072136500213650ustar00rootroot00000000000000/** * @file newlines.cpp * Adds or removes newlines. * * Information * "Ignore" means do not change it. * "Add" in the context of spaces means make sure there is at least 1. * "Add" elsewhere means make sure one is present. * "Remove" mean remove the space/brace/newline/etc. * "Force" in the context of spaces means ensure that there is exactly 1. * "Force" in other contexts means the same as "add". * * Rmk: spaces = space + nl * * @author Ben Gardner * @author Guy Maurel * @license GPL v2+ */ #include "newlines.h" #include "align_stack.h" #include "combine_skip.h" #include "flag_parens.h" #include "indent.h" #include "keywords.h" #include "prototypes.h" #include "space.h" #include "unc_tools.h" #ifdef WIN32 #include // to get max #endif // ifdef WIN32 constexpr static auto LCURRENT = LNEWLINE; using namespace std; using namespace uncrustify; static void mark_change(const char *func, size_t line); /** * Check to see if we are allowed to increase the newline count. * We can't increase the newline count: * - if nl_squeeze_ifdef and a preproc is after the newline. * - if eat_blanks_before_close_brace and the next is '}' * - unless function contains an empty body and * nl_inside_empty_func is non-zero * - if eat_blanks_after_open_brace and the prev is '{' * - unless the brace belongs to a namespace * and nl_inside_namespace is non-zero */ static bool can_increase_nl(Chunk *nl); /** * Basic approach: * 1. Find next open brace * 2. Find next close brace * 3. Determine why the braces are there * a. struct/union/enum "enum [name] {" * c. assignment "= {" * b. if/while/switch/for/etc ") {" * d. else "} else {" */ static void setup_newline_add(Chunk *prev, Chunk *nl, Chunk *next); //! Make sure there is a blank line after a commented group of values static void newlines_double_space_struct_enum_union(Chunk *open_brace); //! If requested, make sure each entry in an enum is on its own line static void newlines_enum_entries(Chunk *open_brace, iarf_e av); /** * Checks to see if it is OK to add a newline around the chunk. * Don't want to break one-liners... * return value: * true: a new line may be added * false: a new line may NOT be added */ static bool one_liner_nl_ok(Chunk *pc); static void nl_create_one_liner(Chunk *vbrace_open); static void nl_create_list_liner(Chunk *brace_open); /** * Test if a chunk belongs to a one-liner method definition inside a class body */ static bool is_class_one_liner(Chunk *pc); /** * Test if a chunk may be combined with a function prototype group. * * If nl_class_leave_one_liner_groups is enabled, a chunk may be combined with * a function prototype group if it is a one-liner inside a class body, and is * a definition of the same sort as surrounding prototypes. This checks against * either the function name, or the function closing brace. */ bool is_func_proto_group(Chunk *pc, E_Token one_liner_type); /** * Test if an opening brace is part of a function call or definition. */ static bool is_func_call_or_def(Chunk *pc); //! Find the next newline or nl_cont static void nl_handle_define(Chunk *pc); /** * Does the Ignore, Add, Remove, or Force thing between two chunks * * @param before The first chunk * @param after The second chunk * @param av The IARF value */ static void newline_iarf_pair(Chunk *before, Chunk *after, iarf_e av, bool check_nl_assign_leave_one_liners = false); /** * Adds newlines to multi-line function call/decl/def * Start points to the open paren */ static void newline_func_multi_line(Chunk *start); static void newline_template(Chunk *start); /** * Formats a function declaration * Start points to the open paren */ static void newline_func_def_or_call(Chunk *start); /** * Formats a message, adding newlines before the item before the colons. * * Start points to the open '[' in: * [myObject doFooWith:arg1 name:arg2 // some lines with >1 arg * error:arg3]; */ static void newline_oc_msg(Chunk *start); //! Ensure that the next non-comment token after close brace is a newline static void newline_end_newline(Chunk *br_close); /** * Add or remove a newline between the closing paren and opening brace. * Also uncuddles anything on the closing brace. (may get fixed later) * * "if (...) { \n" or "if (...) \n { \n" * * For virtual braces, we can only add a newline after the vbrace open. * If we do so, also add a newline after the vbrace close. */ static bool newlines_if_for_while_switch(Chunk *start, iarf_e nl_opt); /** * Add or remove extra newline before the chunk. * Adds before comments * Doesn't do anything if open brace before it * "code\n\ncomment\nif (...)" or "code\ncomment\nif (...)" */ static void newlines_if_for_while_switch_pre_blank_lines(Chunk *start, iarf_e nl_opt); static void blank_line_set(Chunk *pc, Option &opt); /** * Add one/two newline(s) before the chunk. * Adds before comments * Adds before destructor * Doesn't do anything if open brace before it * "code\n\ncomment\nif (...)" or "code\ncomment\nif (...)" */ static void newlines_func_pre_blank_lines(Chunk *start, E_Token start_type); static Chunk *get_closing_brace(Chunk *start); /** * remove any consecutive newlines following this chunk * skip vbraces */ static void remove_next_newlines(Chunk *start); /** * Add or remove extra newline after end of the block started in chunk. * Doesn't do anything if close brace after it * Interesting issue is that at this point, nls can be before or after vbraces * VBraces will stay VBraces, conversion to real ones should have already happened * "if (...)\ncode\ncode" or "if (...)\ncode\n\ncode" */ static void newlines_if_for_while_switch_post_blank_lines(Chunk *start, iarf_e nl_opt); /** * Adds or removes a newline between the keyword and the open brace. * If there is something after the '{' on the same line, then * the newline is removed unconditionally. * If there is a '=' between the keyword and '{', do nothing. * * "struct [name] {" or "struct [name] \n {" */ static void newlines_struct_union(Chunk *start, iarf_e nl_opt, bool leave_trailing); static void newlines_enum(Chunk *start); static void newlines_namespace(Chunk *start); // Issue #2186 /** * Cuddles or un-cuddles a chunk with a previous close brace * * "} while" vs "} \n while" * "} else" vs "} \n else" * * @param start The chunk - should be CT_ELSE or CT_WHILE_OF_DO */ static void newlines_cuddle_uncuddle(Chunk *start, iarf_e nl_opt); /** * Adds/removes a newline between else and '{'. * "else {" or "else \n {" */ static void newlines_do_else(Chunk *start, iarf_e nl_opt); //! Check if token starts a variable declaration static bool is_var_def(Chunk *pc, Chunk *next); //! Put newline(s) before and/or after a block of variable definitions static Chunk *newline_var_def_blk(Chunk *start); /** * Handles the brace_on_func_line setting and decides if the closing brace * of a pair should be right after a newline. * The only cases where the closing brace shouldn't be the first thing on a line * is where the opening brace has junk after it AND where a one-liner in a * class is supposed to be preserved. * * General rule for break before close brace: * If the brace is part of a function (call or definition) OR if the only * thing after the opening brace is comments, the there must be a newline * before the close brace. * * Example of no newline before close * struct mystring { int len; * char str[]; }; * while (*(++ptr) != 0) { } * * Examples of newline before close * void foo() { * } */ static void newlines_brace_pair(Chunk *br_open); /** * Put a empty line between the 'case' statement and the previous case colon * or semicolon. * Does not work with PAWN (?) */ static void newline_case(Chunk *start); static void newline_case_colon(Chunk *start); //! Put a blank line before a return statement, unless it is after an open brace static void newline_before_return(Chunk *start); /** * Put a empty line after a return statement, unless it is followed by a * close brace. * * May not work with PAWN */ static void newline_after_return(Chunk *start); static void blank_line_max(Chunk *pc, Option &opt); static iarf_e newline_template_option(Chunk *pc, iarf_e special, iarf_e base, iarf_e fallback); #define MARK_CHANGE() mark_change(__func__, __LINE__) static void mark_change(const char *func, size_t line) { LOG_FUNC_ENTRY(); cpd.changes++; if (cpd.pass_count == 0) { LOG_FMT(LCHANGE, "%s(%d): change %d on %s:%zu\n", __func__, __LINE__, cpd.changes, func, line); } } // mark_change static bool can_increase_nl(Chunk *nl) { LOG_FUNC_ENTRY(); Chunk *prev = nl->GetPrevNc(); Chunk *pcmt = nl->GetPrev(); Chunk *next = nl->GetNext(); if (options::nl_squeeze_ifdef()) { log_rule_B("nl_squeeze_ifdef"); Chunk *pp_start = prev->GetPpStart(); if ( pp_start->IsNotNullChunk() && ( pp_start->GetParentType() == CT_PP_IF || pp_start->GetParentType() == CT_PP_ELSE) && ( pp_start->GetLevel() > 0 || options::nl_squeeze_ifdef_top_level())) { log_rule_B("nl_squeeze_ifdef_top_level"); bool rv = ifdef_over_whole_file() && pp_start->TestFlags(PCF_WF_IF); LOG_FMT(LBLANKD, "%s(%d): nl_squeeze_ifdef %zu (prev) pp_lvl=%zu rv=%d\n", __func__, __LINE__, nl->GetOrigLine(), nl->GetPpLevel(), rv); return(rv); } if ( next->Is(CT_PREPROC) && ( next->GetParentType() == CT_PP_ELSE || next->GetParentType() == CT_PP_ENDIF) && ( next->GetLevel() > 0 || options::nl_squeeze_ifdef_top_level())) { log_rule_B("nl_squeeze_ifdef_top_level"); bool rv = ifdef_over_whole_file() && next->TestFlags(PCF_WF_ENDIF); LOG_FMT(LBLANKD, "%s(%d): nl_squeeze_ifdef %zu (next) pp_lvl=%zu rv=%d\n", __func__, __LINE__, nl->GetOrigLine(), nl->GetPpLevel(), rv); return(rv); } } if (next->Is(CT_BRACE_CLOSE)) { if ( options::nl_inside_namespace() > 0 && next->GetParentType() == CT_NAMESPACE) { log_rule_B("nl_inside_namespace"); LOG_FMT(LBLANKD, "%s(%d): nl_inside_namespace %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(true); } if ( options::nl_inside_empty_func() > 0 && prev->Is(CT_BRACE_OPEN) && ( next->GetParentType() == CT_FUNC_DEF || next->GetParentType() == CT_FUNC_CLASS_DEF)) { log_rule_B("nl_inside_empty_func"); LOG_FMT(LBLANKD, "%s(%d): nl_inside_empty_func %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(true); } if (options::eat_blanks_before_close_brace()) { log_rule_B("eat_blanks_before_close_brace"); LOG_FMT(LBLANKD, "%s(%d): eat_blanks_before_close_brace %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(false); } } if (prev->Is(CT_BRACE_CLOSE)) { if ( options::nl_before_namespace() && prev->GetParentType() == CT_NAMESPACE) { log_rule_B("nl_before_namespace"); LOG_FMT(LBLANKD, "%s(%d): nl_before_namespace %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(true); } } if (prev->Is(CT_BRACE_OPEN)) { if ( options::nl_inside_namespace() > 0 && prev->GetParentType() == CT_NAMESPACE) { log_rule_B("nl_inside_namespace"); LOG_FMT(LBLANKD, "%s(%d): nl_inside_namespace %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(true); } if ( options::nl_inside_empty_func() > 0 && next->Is(CT_BRACE_CLOSE) && ( prev->GetParentType() == CT_FUNC_DEF || prev->GetParentType() == CT_FUNC_CLASS_DEF)) { log_rule_B("nl_inside_empty_func"); LOG_FMT(LBLANKD, "%s(%d): nl_inside_empty_func %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(true); } if (options::eat_blanks_after_open_brace()) { log_rule_B("eat_blanks_after_open_brace"); LOG_FMT(LBLANKD, "%s(%d): eat_blanks_after_open_brace %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(false); } } log_rule_B("nl_start_of_file"); if ( !pcmt && (options::nl_start_of_file() != IARF_IGNORE)) { LOG_FMT(LBLANKD, "%s(%d): SOF no prev %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(false); } log_rule_B("nl_end_of_file"); if ( next->IsNullChunk() && (options::nl_end_of_file() != IARF_IGNORE)) { LOG_FMT(LBLANKD, "%s(%d): EOF no next %zu\n", __func__, __LINE__, nl->GetOrigLine()); return(false); } return(true); } // can_increase_nl static void setup_newline_add(Chunk *prev, Chunk *nl, Chunk *next) { LOG_FUNC_ENTRY(); if ( prev == nullptr || nl == nullptr || next == nullptr) { return; } undo_one_liner(prev); nl->SetOrigLine(prev->GetOrigLine()); nl->SetLevel(prev->GetLevel()); nl->SetPpLevel(prev->GetPpLevel()); nl->SetBraceLevel(prev->GetBraceLevel()); nl->SetPpLevel(prev->GetPpLevel()); nl->SetNlCount(1); nl->SetFlags((prev->GetFlags() & PCF_COPY_FLAGS) & ~PCF_IN_PREPROC); nl->SetOrigCol(prev->GetOrigColEnd()); nl->SetColumn(prev->GetOrigCol()); if ( prev->TestFlags(PCF_IN_PREPROC) && next->TestFlags(PCF_IN_PREPROC)) { nl->SetFlagBits(PCF_IN_PREPROC); } if (nl->TestFlags(PCF_IN_PREPROC)) { nl->SetType(CT_NL_CONT); nl->Str() = "\\\n"; } else { nl->SetType(CT_NEWLINE); nl->Str() = "\n"; } } // setup_newline_add void double_newline(Chunk *nl) { LOG_FUNC_ENTRY(); Chunk *prev = Chunk::NullChunkPtr; if (nl != nullptr) { prev = nl->GetPrev(); } if (prev->IsNullChunk()) { return; } LOG_FMT(LNEWLINE, "%s(%d): add newline after ", __func__, __LINE__); if (prev->Is(CT_VBRACE_CLOSE)) { LOG_FMT(LNEWLINE, "VBRACE_CLOSE "); } else { LOG_FMT(LNEWLINE, "'%s' ", prev->Text()); } LOG_FMT(LNEWLINE, "on line %zu", prev->GetOrigLine()); if (!can_increase_nl(nl)) { LOG_FMT(LNEWLINE, " - denied\n"); return; } LOG_FMT(LNEWLINE, " - done\n"); if (nl->GetNlCount() != 2) { nl->SetNlCount(2); MARK_CHANGE(); } } // double_newline Chunk *newline_add_before(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk nl; Chunk *prev = pc->GetPrevNvb(); if (prev->IsNewline()) { // Already has a newline before this chunk return(prev); } LOG_FMT(LNEWLINE, "%s(%d): Text() '%s', on orig line is %zu, orig col is %zu, pc column is %zu", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetColumn()); log_func_stack_inline(LNEWLINE); setup_newline_add(prev, &nl, pc); nl.SetOrigCol(pc->GetOrigCol()); nl.SetPpLevel(pc->GetPpLevel()); LOG_FMT(LNEWLINE, "%s(%d): nl column is %zu\n", __func__, __LINE__, nl.GetColumn()); MARK_CHANGE(); return(nl.CopyAndAddBefore(pc)); } // newline_add_before Chunk *newline_force_before(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *nl = newline_add_before(pc); if ( nl->IsNotNullChunk() && nl->GetNlCount() > 1) { nl->SetNlCount(1); MARK_CHANGE(); } return(nl); } // newline_force_before Chunk *newline_add_after(Chunk *pc) { LOG_FUNC_ENTRY(); if (pc == nullptr) { return(Chunk::NullChunkPtr); } Chunk *next = pc->GetNextNvb(); if (next->IsNewline()) { // Already has a newline after this chunk return(next); } LOG_FMT(LNEWLINE, "%s(%d): '%s' on line %zu", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); log_func_stack_inline(LNEWLINE); Chunk nl; nl.SetOrigLine(pc->GetOrigLine()); nl.SetOrigCol(pc->GetOrigCol()); setup_newline_add(pc, &nl, next); MARK_CHANGE(); // TO DO: check why the next statement is necessary nl.SetOrigCol(pc->GetOrigCol()); nl.SetPpLevel(pc->GetPpLevel()); return(nl.CopyAndAddAfter(pc)); } // newline_add_after Chunk *newline_force_after(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *nl = newline_add_after(pc); // add a newline if ( nl->IsNotNullChunk() && nl->GetNlCount() > 1) // check if there are more than 1 newline { nl->SetNlCount(1); // if so change the newline count back to 1 MARK_CHANGE(); } return(nl); } // newline_force_after static void newline_end_newline(Chunk *br_close) { LOG_FUNC_ENTRY(); Chunk *next = br_close->GetNext(); Chunk nl; if (!next->IsCommentOrNewline()) { nl.SetOrigLine(br_close->GetOrigLine()); nl.SetOrigCol(br_close->GetOrigCol()); nl.SetNlCount(1); nl.SetPpLevel(0); nl.SetFlags((br_close->GetFlags() & PCF_COPY_FLAGS) & ~PCF_IN_PREPROC); if ( br_close->TestFlags(PCF_IN_PREPROC) && next->IsNotNullChunk() && next->TestFlags(PCF_IN_PREPROC)) { nl.SetFlagBits(PCF_IN_PREPROC); } if (nl.TestFlags(PCF_IN_PREPROC)) { nl.SetType(CT_NL_CONT); nl.Str() = "\\\n"; } else { nl.SetType(CT_NEWLINE); nl.Str() = "\n"; } MARK_CHANGE(); LOG_FMT(LNEWLINE, "%s(%d): %zu:%zu add newline after '%s'\n", __func__, __LINE__, br_close->GetOrigLine(), br_close->GetOrigCol(), br_close->Text()); nl.CopyAndAddAfter(br_close); } } // newline_end_newline static void newline_min_after(Chunk *ref, size_t count, E_PcfFlag flag) { LOG_FUNC_ENTRY(); LOG_FMT(LNEWLINE, "%s(%d): for '%s', at orig line %zu, count is %zu,\n flag is %s:", __func__, __LINE__, ref->Text(), ref->GetOrigLine(), count, pcf_flags_str(flag).c_str()); log_func_stack_inline(LNEWLINE); Chunk *pc = ref; do { pc = pc->GetNext(); } while ( pc->IsNotNullChunk() && !pc->IsNewline()); if (pc->IsNotNullChunk()) // Coverity CID 76002 { LOG_FMT(LNEWLINE, "%s(%d): type is %s, orig line %zu, orig col %zu\n", __func__, __LINE__, get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetOrigCol()); } Chunk *next = pc->GetNext(); if (next->IsNullChunk()) { return; } if ( next->IsComment() && next->GetNlCount() == 1 && pc->GetPrev()->IsComment()) { newline_min_after(next, count, flag); return; } pc->SetFlagBits(flag); if ( pc->IsNewline() && can_increase_nl(pc)) { if (pc->GetNlCount() < count) { pc->SetNlCount(count); MARK_CHANGE(); } } } // newline_min_after Chunk *newline_add_between(Chunk *start, Chunk *end) { LOG_FUNC_ENTRY(); if ( start == nullptr || end == nullptr || end->Is(CT_IGNORED)) { return(nullptr); } LOG_FMT(LNEWLINE, "%s(%d): start->Text() is '%s', type is %s, orig line is %zu, orig col is %zu\n", __func__, __LINE__, start->Text(), get_token_name(start->GetType()), start->GetOrigLine(), start->GetOrigCol()); LOG_FMT(LNEWLINE, "%s(%d): and end->Text() is '%s', orig line is %zu, orig col is %zu\n ", __func__, __LINE__, end->Text(), end->GetOrigLine(), end->GetOrigCol()); log_func_stack_inline(LNEWLINE); // Back-up check for one-liners (should never be true!) if (!one_liner_nl_ok(start)) { return(nullptr); } /* * Scan for a line break, if there is a line break between start and end * we won't add another one */ for (Chunk *pc = start; pc != end; pc = pc->GetNext()) { if (pc->IsNewline()) { return(pc); } } /* * If the second one is a brace open, then check to see * if a comment + newline follows */ if (end->Is(CT_BRACE_OPEN)) { Chunk *pc = end->GetNext(); if (pc->IsComment()) { pc = pc->GetNext(); if (pc->IsNewline()) { // are there some more (comment + newline)s ? Chunk *pc1 = end->GetNextNcNnl(); if (!pc1->IsNewline()) { // yes, go back Chunk *pc2 = pc1->GetPrev(); pc = pc2; } if (end == pc) { LOG_FMT(LNEWLINE, "%s(%d): pc1 and pc are identical\n", __func__, __LINE__); } else { // Move the open brace to after the newline end->MoveAfter(pc); } LOG_FMT(LNEWLINE, "%s(%d):\n", __func__, __LINE__); newline_add_after(end); return(pc); } else // Issue #3873 { LOG_FMT(LNEWLINE, "%s(%d):\n", __func__, __LINE__); } } else { LOG_FMT(LNEWLINE, "%s(%d):\n", __func__, __LINE__); } } else { LOG_FMT(LNEWLINE, "%s(%d):\n", __func__, __LINE__); } Chunk *tmp = newline_add_before(end); return(tmp); } // newline_add_between void newline_del_between(Chunk *start, Chunk *end) { LOG_FUNC_ENTRY(); LOG_FMT(LNEWLINE, "%s(%d): start->Text() is '%s', orig line is %zu, orig col is %zu\n", __func__, __LINE__, start->Text(), start->GetOrigLine(), start->GetOrigCol()); LOG_FMT(LNEWLINE, "%s(%d): and end->Text() is '%s', orig line is %zu, orig col is %zu: preproc=%c/%c\n", __func__, __LINE__, end->Text(), end->GetOrigLine(), end->GetOrigCol(), start->TestFlags(PCF_IN_PREPROC) ? 'y' : 'n', end->TestFlags(PCF_IN_PREPROC) ? 'y' : 'n'); log_func_stack_inline(LNEWLINE); // Can't remove anything if the preproc status differs if (!start->IsSamePreproc(end)) { return; } Chunk *pc = start; bool start_removed = false; do { Chunk *next = pc->GetNext(); if (pc->IsNewline()) { Chunk *prev = pc->GetPrev(); if ( ( !prev->IsComment() && !next->IsComment()) || prev->IsNewline() || next->IsNewline()) { if (pc->SafeToDeleteNl()) { if (pc == start) { start_removed = true; } Chunk::Delete(pc); MARK_CHANGE(); if (prev->IsNotNullChunk()) { align_to_column(next, prev->GetColumn() + space_col_align(prev, next)); } } } else { if (pc->GetNlCount() > 1) { pc->SetNlCount(1); MARK_CHANGE(); } } } pc = next; } while (pc != end); if ( !start_removed && end->IsString("{") && ( start->IsString(")") || start->Is(CT_DO) || start->Is(CT_ELSE))) { end->MoveAfter(start); } } // newline_del_between void newlines_sparens() { LOG_FUNC_ENTRY(); //Chunk *sparen_open; for (Chunk *sparen_open = Chunk::GetHead()->GetNextType(CT_SPAREN_OPEN, ANY_LEVEL); sparen_open->IsNotNullChunk(); sparen_open = sparen_open->GetNextType(CT_SPAREN_OPEN, ANY_LEVEL)) { Chunk *sparen_close = sparen_open->GetNextType(CT_SPAREN_CLOSE, sparen_open->GetLevel()); if (sparen_close->IsNullChunk()) { continue; } Chunk *sparen_content_start = sparen_open->GetNextNnl(); Chunk *sparen_content_end = sparen_close->GetPrevNnl(); bool is_multiline = ( sparen_content_start != sparen_content_end && !sparen_content_start->IsOnSameLine(sparen_content_end)); // Add a newline after '(' if an if/for/while/switch condition spans multiple lines, // as e.g. required by the ROS 2 development style guidelines: // https://index.ros.org/doc/ros2/Contributing/Developer-Guide/#open-versus-cuddled-braces if (is_multiline) { log_rule_B("nl_multi_line_sparen_open"); newline_iarf(sparen_open, options::nl_multi_line_sparen_open()); } // Add a newline before ')' if an if/for/while/switch condition spans multiple lines. Overrides nl_before_if_closing_paren if both are specified. if ( is_multiline && options::nl_multi_line_sparen_close() != IARF_IGNORE) { log_rule_B("nl_multi_line_sparen_close"); newline_iarf(sparen_content_end, options::nl_multi_line_sparen_close()); } else { // add/remove trailing newline in an if condition Chunk *ctrl_structure = sparen_open->GetPrevNcNnl(); if ( ctrl_structure->Is(CT_IF) || ctrl_structure->Is(CT_ELSEIF)) { log_rule_B("nl_before_if_closing_paren"); newline_iarf_pair(sparen_content_end, sparen_close, options::nl_before_if_closing_paren()); } } } } // newlines_sparens static bool newlines_if_for_while_switch(Chunk *start, iarf_e nl_opt) { LOG_FUNC_ENTRY(); log_rule_B("nl_define_macro"); if ( nl_opt == IARF_IGNORE || ( start->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro())) { return(false); } bool retval = false; Chunk *pc = start->GetNextNcNnl(); if (pc->Is(CT_SPAREN_OPEN)) { Chunk *close_paren = pc->GetNextType(CT_SPAREN_CLOSE, pc->GetLevel()); Chunk *brace_open = close_paren->GetNextNcNnl(); if ( ( brace_open->Is(CT_BRACE_OPEN) || brace_open->Is(CT_VBRACE_OPEN)) && one_liner_nl_ok(brace_open)) { log_rule_B("nl_multi_line_cond"); if (options::nl_multi_line_cond()) { while ((pc = pc->GetNext()) != close_paren) { if (pc->IsNewline()) { nl_opt = IARF_ADD; break; } } } if (brace_open->Is(CT_VBRACE_OPEN)) { // Can only add - we don't want to create a one-line here if (nl_opt & IARF_ADD) { newline_iarf_pair(close_paren, brace_open->GetNextNcNnl(), nl_opt); pc = brace_open->GetNextType(CT_VBRACE_CLOSE, brace_open->GetLevel()); if ( !pc->GetPrevNc()->IsNewline() && !pc->GetNextNc()->IsNewline()) { newline_add_after(pc); retval = true; } } } else { newline_iarf_pair(close_paren, brace_open, nl_opt); Chunk *next = brace_open->GetNextNcNnl(); if (brace_open->GetType() != next->GetType()) // Issue #2836 { newline_add_between(brace_open, brace_open->GetNextNcNnl()); } // Make sure nothing is cuddled with the closing brace pc = brace_open->GetNextType(CT_BRACE_CLOSE, brace_open->GetLevel()); newline_add_between(pc, pc->GetNextNcNnlNet()); retval = true; } } } return(retval); } // newlines_if_for_while_switch static void newlines_if_for_while_switch_pre_blank_lines(Chunk *start, iarf_e nl_opt) { LOG_FUNC_ENTRY(); LOG_FMT(LNEWLINE, "%s(%d): start->Text() is '%s', type is %s, orig line is %zu, orig col is %zu\n", __func__, __LINE__, start->Text(), get_token_name(start->GetType()), start->GetOrigLine(), start->GetOrigCol()); log_rule_B("nl_define_macro"); if ( nl_opt == IARF_IGNORE || ( start->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro())) { return; } /* * look backwards until we find * open brace (don't add or remove) * 2 newlines in a row (don't add) * something else (don't remove) */ for (Chunk *pc = start->GetPrev(); pc->IsNotNullChunk(); pc = pc->GetPrev()) { size_t level = start->GetLevel(); bool do_add = (nl_opt & IARF_ADD) != IARF_IGNORE; // forcing value to bool Chunk *last_nl = nullptr; if (pc->IsNewline()) { last_nl = pc; // if we found 2 or more in a row if ( pc->GetNlCount() > 1 || pc->GetPrevNvb()->IsNewline()) { // need to remove if ( (nl_opt & IARF_REMOVE) && !pc->TestFlags(PCF_VAR_DEF)) { // if we're also adding, take care of that here size_t nl_count = do_add ? 2 : 1; if (nl_count != pc->GetNlCount()) { pc->SetNlCount(nl_count); MARK_CHANGE(); } Chunk *prev; // can keep using pc because anything other than newline stops loop, and we delete if newline while ((prev = pc->GetPrevNvb())->IsNewline()) { // Make sure we don't combine a preproc and non-preproc if (!prev->SafeToDeleteNl()) { break; } Chunk::Delete(prev); MARK_CHANGE(); } } return; } } else if ( pc->IsBraceOpen() || pc->GetLevel() < level) { return; } else if (pc->IsComment()) { // vbrace close is ok because it won't go into output, so we should skip it last_nl = nullptr; continue; } else { if ( pc->Is(CT_CASE_COLON) && options::nl_before_ignore_after_case()) { return; } if (do_add) // we found something previously besides a comment or a new line { // if we have run across a newline if ( last_nl != nullptr && last_nl->IsNotNullChunk()) { if (last_nl->GetNlCount() < 2) { double_newline(last_nl); } } else { Chunk *next; // we didn't run into a newline, so we need to add one if ( ((next = pc->GetNext())->IsNotNullChunk()) && next->IsComment()) { pc = next; } if ((last_nl = newline_add_after(pc))->IsNotNullChunk()) { double_newline(last_nl); } } } return; } } } // newlines_if_for_while_switch_pre_blank_lines static void blank_line_set(Chunk *pc, Option &opt) { LOG_FUNC_ENTRY(); if (pc == nullptr) { return; } const unsigned optval = opt(); if ( (optval > 0) && (pc->GetNlCount() != optval)) { LOG_FMT(LBLANKD, "%s(%d): do_blank_lines: %s set line %zu to %u\n", __func__, __LINE__, opt.name(), pc->GetOrigLine(), optval); pc->SetNlCount(optval); MARK_CHANGE(); } } // blank_line_set bool do_it_newlines_func_pre_blank_lines(Chunk *last_nl, E_Token start_type) { LOG_FUNC_ENTRY(); if (last_nl == nullptr) { return(false); } LOG_FMT(LNLFUNCT, "%s(%d): orig line is %zu, orig col is %zu, type is %s, Text() is '%s'\n", __func__, __LINE__, last_nl->GetOrigLine(), last_nl->GetOrigCol(), get_token_name(last_nl->GetType()), last_nl->Text()); switch (start_type) { case CT_FUNC_CLASS_DEF: { log_rule_B("nl_before_func_class_def"); bool diff = options::nl_before_func_class_def() <= last_nl->GetNlCount(); LOG_FMT(LNLFUNCT, "%s(%d): is %s\n", __func__, __LINE__, diff ? "TRUE" : "FALSE"); log_rule_B("nl_before_func_class_def"); if (options::nl_before_func_class_def() != last_nl->GetNlCount()) { LOG_FMT(LNLFUNCT, "%s(%d): set blank line(s) to %u\n", __func__, __LINE__, options::nl_before_func_class_def()); blank_line_set(last_nl, options::nl_before_func_class_def); } return(diff); } case CT_FUNC_CLASS_PROTO: { log_rule_B("nl_before_func_class_proto"); bool diff = options::nl_before_func_class_proto() <= last_nl->GetNlCount(); LOG_FMT(LNLFUNCT, "%s(%d): is %s\n", __func__, __LINE__, diff ? "TRUE" : "FALSE"); log_rule_B("nl_before_func_class_proto"); if (options::nl_before_func_class_proto() != last_nl->GetNlCount()) { LOG_FMT(LNLFUNCT, "%s(%d): set blank line(s) to %u\n", __func__, __LINE__, options::nl_before_func_class_proto()); blank_line_set(last_nl, options::nl_before_func_class_proto); } return(diff); } case CT_FUNC_DEF: { LOG_FMT(LNLFUNCT, "%s(%d): nl_before_func_body_def() is %u, last_nl new line count is %zu\n", __func__, __LINE__, options::nl_before_func_body_def(), last_nl->GetNlCount()); log_rule_B("nl_before_func_body_def"); bool diff = options::nl_before_func_body_def() <= last_nl->GetNlCount(); LOG_FMT(LNLFUNCT, "%s(%d): is %s\n", __func__, __LINE__, diff ? "TRUE" : "FALSE"); log_rule_B("nl_before_func_body_def"); if (options::nl_before_func_body_def() != last_nl->GetNlCount()) { LOG_FMT(LNLFUNCT, "%s(%d): set blank line(s) to %u\n", __func__, __LINE__, options::nl_before_func_body_def()); log_rule_B("nl_before_func_body_def"); blank_line_set(last_nl, options::nl_before_func_body_def); } LOG_FMT(LNLFUNCT, "%s(%d): nl_before_func_body_def() is %u, last_nl new line count is %zu\n", __func__, __LINE__, options::nl_before_func_body_def(), last_nl->GetNlCount()); return(diff); } case CT_FUNC_PROTO: { log_rule_B("nl_before_func_body_proto"); bool diff = options::nl_before_func_body_proto() <= last_nl->GetNlCount(); LOG_FMT(LNLFUNCT, "%s(%d): is %s\n", __func__, __LINE__, diff ? "TRUE" : "FALSE"); log_rule_B("nl_before_func_body_proto"); if (options::nl_before_func_body_proto() != last_nl->GetNlCount()) { LOG_FMT(LNLFUNCT, "%s(%d): set blank line(s) to %u\n", __func__, __LINE__, options::nl_before_func_body_proto()); log_rule_B("nl_before_func_body_proto"); blank_line_set(last_nl, options::nl_before_func_body_proto); } return(diff); } default: { LOG_FMT(LERR, "%s(%d): setting to blank line(s) at line %zu not possible\n", __func__, __LINE__, last_nl->GetOrigLine()); return(false); } } // switch } // do_it_newlines_func_pre_blank_lines static void newlines_func_pre_blank_lines(Chunk *start, E_Token start_type) { LOG_FUNC_ENTRY(); log_rule_B("nl_before_func_class_def"); log_rule_B("nl_before_func_class_proto"); log_rule_B("nl_before_func_body_def"); log_rule_B("nl_before_func_body_proto"); if ( start == nullptr || ( ( start_type != CT_FUNC_CLASS_DEF || options::nl_before_func_class_def() == 0) && ( start_type != CT_FUNC_CLASS_PROTO || options::nl_before_func_class_proto() == 0) && ( start_type != CT_FUNC_DEF || options::nl_before_func_body_def() == 0) && ( start_type != CT_FUNC_PROTO || options::nl_before_func_body_proto() == 0))) { return; } LOG_FMT(LNLFUNCT, "%s(%d): set blank line(s): for at line %zu, column %zu, start_type is %s\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol(), get_token_name(start_type)); LOG_FMT(LNLFUNCT, "%s(%d): BEGIN set blank line(s) for '%s' at line %zu\n", __func__, __LINE__, start->Text(), start->GetOrigLine()); /* * look backwards until we find: * - open brace (don't add or remove) * - two newlines in a row (don't add) * - a destructor * - something else (don't remove) */ Chunk *pc = nullptr; Chunk *last_nl = nullptr; Chunk *last_comment = nullptr; size_t first_line = start->GetOrigLine(); for (pc = start->GetPrev(); pc->IsNotNullChunk(); pc = pc->GetPrev()) { LOG_FMT(LNLFUNCT, "%s(%d): orig line is %zu, orig col is %zu, type is %s, Text() is '%s', new line count is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->Text(), pc->GetNlCount()); if (pc->IsNewline()) { last_nl = pc; LOG_FMT(LNLFUNCT, "%s(%d): found at line %zu, column %zu, new line count is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetNlCount()); LOG_FMT(LNLFUNCT, "%s(%d): last_nl set to %zu\n", __func__, __LINE__, last_nl->GetOrigLine()); bool break_now = false; if (pc->GetNlCount() > 1) { break_now = do_it_newlines_func_pre_blank_lines(last_nl, start_type); LOG_FMT(LNLFUNCT, "%s(%d): break_now is %s\n", __func__, __LINE__, break_now ? "TRUE" : "FALSE"); } if (break_now) { break; } else { continue; } } else if (pc->IsComment()) { LOG_FMT(LNLFUNCT, "%s(%d): found at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); if ( ( pc->GetOrigLine() < first_line && ((first_line - pc->GetOrigLine() - (pc->Is(CT_COMMENT_MULTI) ? pc->GetNlCount() : 0))) < 2) || ( last_comment != nullptr && pc->Is(CT_COMMENT_CPP) // combine only cpp comments && last_comment->Is(pc->GetType()) // don't mix comment types && last_comment->GetOrigLine() > pc->GetOrigLine() && (last_comment->GetOrigLine() - pc->GetOrigLine()) < 2)) { last_comment = pc; continue; } bool break_now = do_it_newlines_func_pre_blank_lines(last_nl, start_type); LOG_FMT(LNLFUNCT, "%s(%d): break_now is %s\n", __func__, __LINE__, break_now ? "TRUE" : "FALSE"); continue; } else if ( pc->Is(CT_DESTRUCTOR) || pc->Is(CT_TYPE) || pc->Is(CT_TEMPLATE) || pc->Is(CT_QUALIFIER) || pc->Is(CT_PTR_TYPE) || pc->Is(CT_BYREF) // Issue #2163 || pc->Is(CT_DC_MEMBER) || pc->Is(CT_EXTERN) || ( pc->Is(CT_STRING) && pc->GetParentType() == CT_EXTERN)) { LOG_FMT(LNLFUNCT, "%s(%d): first_line set to %zu\n", __func__, __LINE__, pc->GetOrigLine()); first_line = pc->GetOrigLine(); continue; } else if ( pc->Is(CT_ANGLE_CLOSE) && pc->GetParentType() == CT_TEMPLATE) { LOG_FMT(LNLFUNCT, "%s(%d):\n", __func__, __LINE__); // skip template stuff to add newlines before it pc = pc->GetOpeningParen(); if (pc->IsNotNullChunk()) { first_line = pc->GetOrigLine(); } continue; } else { LOG_FMT(LNLFUNCT, "%s(%d): else ==================================\n", __func__, __LINE__); bool break_now = do_it_newlines_func_pre_blank_lines(last_nl, start_type); LOG_FMT(LNLFUNCT, "%s(%d): break_now is %s\n", __func__, __LINE__, break_now ? "TRUE" : "FALSE"); break; } } } // newlines_func_pre_blank_lines static Chunk *get_closing_brace(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *pc; size_t level = start->GetLevel(); for (pc = start; (pc = pc->GetNext())->IsNotNullChunk();) { if ( (pc->IsBraceClose()) && pc->GetLevel() == level) { return(pc); } // for some reason, we can have newlines between if and opening brace that are lower level than either if ( !pc->IsNewline() && pc->GetLevel() < level) { return(nullptr); } } return(nullptr); } // get_closing_brace static void remove_next_newlines(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *next; while ((next = start->GetNext())->IsNotNullChunk()) { if ( next->IsNewline() && next->SafeToDeleteNl()) { Chunk::Delete(next); MARK_CHANGE(); } else if (next->IsVBrace()) { start = next; } else { break; } } } // remove_next_newlines static void newlines_if_for_while_switch_post_blank_lines(Chunk *start, iarf_e nl_opt) { LOG_FUNC_ENTRY(); Chunk *prev; LOG_FMT(LNEWLINE, "%s(%d): start->Text() is '%s', type is %s, orig line is %zu, orig col is %zu\n", __func__, __LINE__, start->Text(), get_token_name(start->GetType()), start->GetOrigLine(), start->GetOrigCol()); log_rule_B("nl_define_macro"); if ( nl_opt == IARF_IGNORE || ( start->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro())) { return; } Chunk *pc = get_closing_brace(start); // first find ending brace if (pc == nullptr) { return; } LOG_FMT(LNEWLINE, "%s(%d): pc->Text() is '%s', type is %s, orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetOrigCol()); /* * if we're dealing with an if, we actually want to add or remove * blank lines after any else */ if (start->Is(CT_IF)) { Chunk *next; while (true) { next = pc->GetNextNcNnl(); if ( next->IsNotNullChunk() && ( next->Is(CT_ELSE) || next->Is(CT_ELSEIF))) { // point to the closing brace of the else if ((pc = get_closing_brace(next)) == nullptr) { return; } LOG_FMT(LNEWLINE, "%s(%d): pc->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetOrigCol()); } else { break; } } } /* * if we're dealing with a do/while, we actually want to add or * remove blank lines after while and its condition */ if (start->Is(CT_DO)) { // point to the next semicolon if ((pc = pc->GetNextType(CT_SEMICOLON, start->GetLevel()))->IsNullChunk()) { return; } LOG_FMT(LNEWLINE, "%s(%d): pc->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetOrigCol()); } bool isVBrace = (pc->Is(CT_VBRACE_CLOSE)); if (isVBrace) { LOG_FMT(LNEWLINE, "%s(%d): isVBrace is TRUE\n", __func__, __LINE__); } else { LOG_FMT(LNEWLINE, "%s(%d): isVBrace is FALSE\n", __func__, __LINE__); } if ((prev = pc->GetPrevNvb())->IsNullChunk()) { return; } bool have_pre_vbrace_nl = isVBrace && prev->IsNewline(); if (have_pre_vbrace_nl) { LOG_FMT(LNEWLINE, "%s(%d): have_pre_vbrace_nl is TRUE\n", __func__, __LINE__); } else { LOG_FMT(LNEWLINE, "%s(%d): have_pre_vbrace_nl is FALSE\n", __func__, __LINE__); } if (nl_opt & IARF_REMOVE) { Chunk *next; // if chunk before is a vbrace, remove any newlines after it if (have_pre_vbrace_nl) { if (prev->GetNlCount() != 1) { prev->SetNlCount(1); MARK_CHANGE(); } remove_next_newlines(pc); } else if ( ((next = pc->GetNextNvb())->IsNewline()) && !next->TestFlags(PCF_VAR_DEF)) { // otherwise just deal with newlines after brace if (next->GetNlCount() != 1) { next->SetNlCount(1); MARK_CHANGE(); } remove_next_newlines(next); } } // may have a newline before and after vbrace // don't do anything with it if the next non newline chunk is a closing brace if (nl_opt & IARF_ADD) { Chunk *next = pc->GetNextNnl(); do { if (next->IsNullChunk()) { return; } if (next->IsNot(CT_VBRACE_CLOSE)) { break; } next = next->GetNextNnl(); } while (true); LOG_FMT(LNEWLINE, "%s(%d): next->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, next->Text(), get_token_name(next->GetType()), next->GetOrigLine(), next->GetOrigCol()); if (next->IsNot(CT_BRACE_CLOSE)) { // if vbrace, have to check before and after // if chunk before vbrace, check its count size_t nl_count = have_pre_vbrace_nl ? prev->GetNlCount() : 0; LOG_FMT(LNEWLINE, "%s(%d): new line count %zu\n", __func__, __LINE__, nl_count); if ((next = pc->GetNextNvb())->IsNewline()) { LOG_FMT(LNEWLINE, "%s(%d): next->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, next->Text(), get_token_name(next->GetType()), next->GetOrigLine(), next->GetOrigCol()); nl_count += next->GetNlCount(); LOG_FMT(LNEWLINE, "%s(%d): new line count is %zu\n", __func__, __LINE__, nl_count); } // if we have no newlines, add one and make it double if (nl_count == 0) { LOG_FMT(LNEWLINE, "%s(%d): new line count is 0\n", __func__, __LINE__); if ( ((next = pc->GetNext())->IsNotNullChunk()) && next->IsComment()) { LOG_FMT(LNEWLINE, "%s(%d): next->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, next->Text(), get_token_name(next->GetType()), next->GetOrigLine(), next->GetOrigCol()); pc = next; LOG_FMT(LNEWLINE, "%s(%d): pc->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetOrigCol()); } if ((next = newline_add_after(pc))->IsNullChunk()) { return; } LOG_FMT(LNEWLINE, "%s(%d): next->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, next->Text(), get_token_name(next->GetType()), next->GetOrigLine(), next->GetOrigCol()); double_newline(next); } else if (nl_count == 1) // if we don't have enough newlines { LOG_FMT(LNEWLINE, "%s(%d): new line count is 1\n", __func__, __LINE__); // if we have a preceding vbrace, add one after it if (have_pre_vbrace_nl) { LOG_FMT(LNEWLINE, "%s(%d): have_pre_vbrace_nl is TRUE\n", __func__, __LINE__); next = newline_add_after(pc); LOG_FMT(LNEWLINE, "%s(%d): next->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, next->Text(), get_token_name(next->GetType()), next->GetOrigLine(), next->GetOrigCol()); } else { LOG_FMT(LNEWLINE, "%s(%d): have_pre_vbrace_nl is FALSE\n", __func__, __LINE__); prev = next->GetPrevNnl(); LOG_FMT(LNEWLINE, "%s(%d): prev->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, prev->Text(), get_token_name(prev->GetType()), prev->GetOrigLine(), prev->GetOrigCol()); pc = next->GetNextNl(); LOG_FMT(LNEWLINE, "%s(%d): pc->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetOrigCol()); Chunk *pc2 = pc->GetNext(); if (pc2->IsNotNullChunk()) { pc = pc2; LOG_FMT(LNEWLINE, "%s(%d): pc->Text() is '%s', type %s, orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetOrigCol()); } else { LOG_FMT(LNEWLINE, "%s(%d): no next found: \n", __func__, __LINE__); } log_rule_B("nl_squeeze_ifdef"); if ( pc->Is(CT_PREPROC) && pc->GetParentType() == CT_PP_ENDIF && options::nl_squeeze_ifdef()) { LOG_FMT(LNEWLINE, "%s(%d): cannot add newline after orig line %zu due to nl_squeeze_ifdef\n", __func__, __LINE__, prev->GetOrigLine()); } else { // make newline after double LOG_FMT(LNEWLINE, "%s(%d): call double_newline\n", __func__, __LINE__); double_newline(next); } } } } } } // newlines_if_for_while_switch_post_blank_lines static void newlines_struct_union(Chunk *start, iarf_e nl_opt, bool leave_trailing) { LOG_FUNC_ENTRY(); log_rule_B("nl_define_macro"); if ( nl_opt == IARF_IGNORE || ( start->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro())) { return; } /* * step past any junk between the keyword and the open brace * Quit if we hit a semicolon or '=', which are not expected. */ size_t level = start->GetLevel(); Chunk *pc = start->GetNextNcNnl(); while ( pc->IsNotNullChunk() && pc->GetLevel() >= level) { if ( pc->GetLevel() == level && ( pc->Is(CT_BRACE_OPEN) || pc->IsSemicolon() || pc->Is(CT_ASSIGN))) { break; } start = pc; pc = pc->GetNextNcNnl(); } // If we hit a brace open, then we need to toy with the newlines if (pc->Is(CT_BRACE_OPEN)) { // Skip over embedded C comments Chunk *next = pc->GetNext(); while (next->Is(CT_COMMENT)) { next = next->GetNext(); } if ( leave_trailing && !next->IsCommentOrNewline()) { nl_opt = IARF_IGNORE; } newline_iarf_pair(start, pc, nl_opt); } } // newlines_struct_union // enum { // enum class angle_state_e : unsigned int { // enum-key attr(optional) identifier(optional) enum-base(optional) { enumerator-list(optional) } // enum-key attr(optional) nested-name-specifier(optional) identifier enum-base(optional) ; TODO // enum-key - one of enum, enum class or enum struct TODO // identifier - the name of the enumeration that's being declared // enum-base(C++11) - colon (:), followed by a type-specifier-seq // enumerator-list - comma-separated list of enumerator definitions static void newlines_enum(Chunk *start) { LOG_FUNC_ENTRY(); log_rule_B("nl_define_macro"); if ( start->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro()) { return; } // look for 'enum class' Chunk *pcClass = start->GetNextNcNnl(); if (pcClass->Is(CT_ENUM_CLASS)) { log_rule_B("nl_enum_class"); newline_iarf_pair(start, pcClass, options::nl_enum_class()); // look for 'identifier'/ 'type' Chunk *pcType = pcClass->GetNextNcNnl(); if (pcType->Is(CT_TYPE)) { log_rule_B("nl_enum_class_identifier"); newline_iarf_pair(pcClass, pcType, options::nl_enum_class_identifier()); // look for ':' Chunk *pcColon = pcType->GetNextNcNnl(); if (pcColon->Is(CT_BIT_COLON)) { log_rule_B("nl_enum_identifier_colon"); newline_iarf_pair(pcType, pcColon, options::nl_enum_identifier_colon()); // look for 'type' i.e. unsigned Chunk *pcType1 = pcColon->GetNextNcNnl(); if (pcType1->Is(CT_TYPE)) { log_rule_B("nl_enum_colon_type"); newline_iarf_pair(pcColon, pcType1, options::nl_enum_colon_type()); // look for 'type' i.e. int Chunk *pcType2 = pcType1->GetNextNcNnl(); if (pcType2->Is(CT_TYPE)) { log_rule_B("nl_enum_colon_type"); newline_iarf_pair(pcType1, pcType2, options::nl_enum_colon_type()); } } } } } /* * step past any junk between the keyword and the open brace * Quit if we hit a semicolon or '=', which are not expected. */ size_t level = start->GetLevel(); Chunk *pc = start->GetNextNcNnl(); while ( pc->IsNotNullChunk() && pc->GetLevel() >= level) { if ( pc->GetLevel() == level && ( pc->Is(CT_BRACE_OPEN) || pc->IsSemicolon() || pc->Is(CT_ASSIGN))) { break; } start = pc; pc = pc->GetNextNcNnl(); } // If we hit a brace open, then we need to toy with the newlines if (pc->Is(CT_BRACE_OPEN)) { // Skip over embedded C comments Chunk *next = pc->GetNext(); while (next->Is(CT_COMMENT)) { next = next->GetNext(); } iarf_e nl_opt; if (!next->IsCommentOrNewline()) { nl_opt = IARF_IGNORE; } else { log_rule_B("nl_enum_brace"); nl_opt = options::nl_enum_brace(); } newline_iarf_pair(start, pc, nl_opt); } } // newlines_enum // namespace { // namespace word { // namespace type::word { static void newlines_namespace(Chunk *start) { LOG_FUNC_ENTRY(); log_rule_B("nl_namespace_brace"); // Add or remove newline between 'namespace' and 'BRACE_OPEN' log_rule_B("nl_define_macro"); iarf_e nl_opt = options::nl_namespace_brace(); if ( nl_opt == IARF_IGNORE || ( start->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro())) { return; } Chunk *braceOpen = start->GetNextType(CT_BRACE_OPEN, start->GetLevel()); LOG_FMT(LNEWLINE, "%s(%d): braceOpen orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, braceOpen->GetOrigLine(), braceOpen->GetOrigCol(), braceOpen->Text()); // produces much more log output. Use it only debugging purpose //log_pcf_flags(LNEWLINE, braceOpen->GetFlags()); if (braceOpen->TestFlags(PCF_ONE_LINER)) { LOG_FMT(LNEWLINE, "%s(%d): is one_liner\n", __func__, __LINE__); return; } Chunk *beforeBrace = braceOpen->GetPrev(); LOG_FMT(LNEWLINE, "%s(%d): beforeBrace orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, beforeBrace->GetOrigLine(), beforeBrace->GetOrigCol(), beforeBrace->Text()); // 'namespace' 'BRACE_OPEN' newline_iarf_pair(beforeBrace, braceOpen, nl_opt); } // newlines_namespace static void newlines_cuddle_uncuddle(Chunk *start, iarf_e nl_opt) { LOG_FUNC_ENTRY(); log_rule_B("nl_define_macro"); if ( start->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro()) { return; } Chunk *br_close = start->GetPrevNcNnlNi(); // Issue #2279 if (br_close->Is(CT_BRACE_CLOSE)) { newline_iarf_pair(br_close, start, nl_opt); } } // newlines_cuddle_uncuddle static void newlines_do_else(Chunk *start, iarf_e nl_opt) { LOG_FUNC_ENTRY(); log_rule_B("nl_define_macro"); log_ruleNL("nl_define_macro", start); if ( nl_opt == IARF_IGNORE || ( start->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro())) { return; } Chunk *next = start->GetNextNcNnl(); if ( next->IsNotNullChunk() && ( next->Is(CT_BRACE_OPEN) || next->Is(CT_VBRACE_OPEN))) { if (!one_liner_nl_ok(next)) { LOG_FMT(LNL1LINE, "%s(%d): a new line may NOT be added\n", __func__, __LINE__); return; } LOG_FMT(LNL1LINE, "%s(%d): a new line may be added\n", __func__, __LINE__); if (next->Is(CT_VBRACE_OPEN)) { // Can only add - we don't want to create a one-line here if (nl_opt & IARF_ADD) { newline_iarf_pair(start, next->GetNextNcNnl(), nl_opt); Chunk *tmp = next->GetNextType(CT_VBRACE_CLOSE, next->GetLevel()); if ( !tmp->GetNextNc()->IsNewline() && !tmp->GetPrevNc()->IsNewline()) { newline_add_after(tmp); } } } else { newline_iarf_pair(start, next, nl_opt); newline_add_between(next, next->GetNextNcNnl()); } } } // newlines_do_else static bool is_var_def(Chunk *pc, Chunk *next) { if ( pc->Is(CT_DECLTYPE) && next->Is(CT_PAREN_OPEN)) { // If current token starts a decltype expression, skip it next = next->GetClosingParen(); next = next->GetNextNcNnl(); } else if (!pc->IsTypeDefinition()) { // Otherwise, if the current token is not a type --> not a declaration return(false); } else if (next->Is(CT_DC_MEMBER)) { // If next token is CT_DC_MEMBER, skip it next = next->SkipDcMember(); } else if (next->Is(CT_ANGLE_OPEN)) { // If we have a template type, skip it next = next->GetClosingParen(); next = next->GetNextNcNnl(); } bool is = ( ( next->IsTypeDefinition() && next->GetParentType() != CT_FUNC_DEF) // Issue #2639 || next->Is(CT_WORD) || next->Is(CT_FUNC_CTOR_VAR)); return(is); } // is_var_def static bool is_func_call_or_def(Chunk *pc) { if ( pc->GetParentType() == CT_FUNC_DEF || pc->GetParentType() == CT_FUNC_CALL || pc->GetParentType() == CT_FUNC_CALL_USER || pc->GetParentType() == CT_FUNC_CLASS_DEF || pc->GetParentType() == CT_OC_CLASS || pc->GetParentType() == CT_OC_MSG_DECL || pc->GetParentType() == CT_CS_PROPERTY || pc->GetParentType() == CT_CPP_LAMBDA) { return(true); } return(false); } // is_func_call_or_def // Put newline(s) before and/or after a block of variable definitions static Chunk *newline_var_def_blk(Chunk *start) { //prot_the_line(__func__, __LINE__, 15, 4); LOG_FUNC_ENTRY(); Chunk *pc = start; Chunk *prev = start->GetPrevNcNnlNi(); // Issue #2279 bool did_this_line = false; bool fn_top = false; bool var_blk = false; bool first_var_blk = true; LOG_FMT(LVARDFBLK, "%s(%d): start orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol(), start->Text()); if (start->Is(CT_BRACE_OPEN)) { // can't be any variable definitions in a "= {" block if ( (prev != nullptr) && prev->IsNotNullChunk() && prev->Is(CT_ASSIGN)) { Chunk *tmp = start->GetClosingParen(); return(tmp->GetNextNcNnl()); } // check if we're at the top of a function definition, or function call with a // possible variable block fn_top = is_func_call_or_def(start); // opening brace is processed, start with next chunk pc = pc->GetNext(); } while ( pc->IsNotNullChunk() && ( pc->GetLevel() >= start->GetLevel() || pc->GetLevel() == 0)) { LOG_CHUNK(LTOK, pc); Chunk *next_pc = pc->GetNext(); LOG_FMT(LVARDFBLK, "%s(%d): next_pc orig line is %zu, orig col is %zu, type is %s, Text() is '%s'\n", __func__, __LINE__, next_pc->GetOrigLine(), next_pc->GetOrigCol(), get_token_name(next_pc->GetType()), next_pc->Text()); // If next_pc token is CT_DC_MEMBER, skip it if (next_pc->Is(CT_DC_MEMBER)) { pc = pc->SkipDcMember(); } // skip qualifiers if (pc->Is(CT_QUALIFIER)) { pc = pc->GetNext(); continue; } if (pc->IsComment()) { pc = pc->GetNext(); continue; } // process nested braces if (pc->Is(CT_BRACE_OPEN)) { pc = newline_var_def_blk(pc); continue; } // Done with this brace set? if (pc->Is(CT_BRACE_CLOSE)) { pc = pc->GetNext(); break; } // skip vbraces if (pc->Is(CT_VBRACE_OPEN)) { pc = pc->GetNextType(CT_VBRACE_CLOSE, pc->GetLevel()); pc = pc->GetNext(); continue; } // Ignore stuff inside parenthesis/squares/angles if (pc->GetLevel() > pc->GetBraceLevel()) { pc = pc->GetNext(); continue; } if (pc->IsNewline()) { did_this_line = false; pc = pc->GetNext(); continue; } // Determine if this is a variable definition or code if ( !did_this_line && pc->IsNot(CT_FUNC_CLASS_DEF) && pc->IsNot(CT_FUNC_CLASS_PROTO) && ( (pc->GetLevel() == (start->GetLevel() + 1)) || pc->GetLevel() == 0)) { Chunk *next = pc->GetNextNcNnl(); LOG_FMT(LVARDFBLK, "%s(%d): next orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text()); // skip over all other type-like things while ( next->Is(CT_PTR_TYPE) // Issue #2692 || next->Is(CT_BYREF) // Issue #3018 || next->Is(CT_QUALIFIER) || next->Is(CT_TSQUARE)) { next = next->GetNextNcNnl(); LOG_FMT(LVARDFBLK, "%s(%d): next orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text()); } if (next->IsNullChunk()) { break; } LOG_FMT(LVARDFBLK, "%s(%d): next orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text()); prev = pc->GetPrevNcNnl(); while ( prev->Is(CT_DC_MEMBER) || prev->Is(CT_QUALIFIER) || prev->Is(CT_TYPE)) { prev = prev->GetPrevNcNnl(); } if (!( prev->IsBraceOpen() || prev->IsBraceClose())) { prev = pc->GetPrevType(CT_SEMICOLON, pc->GetLevel()); } if (prev->IsNullChunk()) { prev = pc->GetPrevType(CT_BRACE_OPEN, pc->GetLevel() - 1); // Issue #2692 } if ( prev->Is(CT_STRING) && prev->GetParentType() == CT_EXTERN && prev->GetPrev()->Is(CT_EXTERN)) { prev = prev->GetPrev()->GetPrevNcNnlNi(); // Issue #2279 } LOG_FMT(LVARDFBLK, "%s(%d): pc orig line is %zu, orig col is %zu, type is %s, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->Text()); LOG_FMT(LVARDFBLK, "%s(%d): next orig line is %zu, orig col is %zu, type is %s, Text() is '%s'\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), get_token_name(next->GetType()), next->Text()); if (is_var_def(pc, next)) { LOG_FMT(LVARDFBLK, "%s(%d): 'typ==var' found: '%s %s' at line %zu\n", __func__, __LINE__, pc->Text(), next->Text(), pc->GetOrigLine()); LOG_FMT(LBLANKD, "%s(%d): var_blk %s, first_var_blk %s, fn_top %s\n", __func__, __LINE__, var_blk ? "TRUE" : "FALSE", first_var_blk ? "TRUE" : "FALSE", fn_top ? "TRUE" : "FALSE"); // Put newline(s) before a block of variable definitions log_rule_B("nl_var_def_blk_start"); if ( !var_blk && !first_var_blk && options::nl_var_def_blk_start() > 0) { LOG_FMT(LVARDFBLK, "%s(%d): pc is '%s', orig line is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); if (prev == nullptr) { LOG_FMT(LVARDFBLK, "%s(%d): prev is nullptr\n", __func__, __LINE__); } else { LOG_FMT(LVARDFBLK, "%s(%d): prev is '%s', orig line is %zu\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine()); if (!prev->IsBraceOpen()) { newline_min_after(prev, options::nl_var_def_blk_start() + 1, PCF_VAR_DEF); } } } // set newlines within var def block log_rule_B("nl_var_def_blk_in"); if ( var_blk && (options::nl_var_def_blk_in() > 0)) { prev = pc->GetPrev(); LOG_FMT(LVARDFBLK, "%s(%d): prev orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), prev->Text()); if (prev->IsNewline()) { if (prev->GetNlCount() > options::nl_var_def_blk_in()) { prev->SetNlCount(options::nl_var_def_blk_in()); MARK_CHANGE(); } } } pc = pc->GetNextType(CT_SEMICOLON, pc->GetLevel()); var_blk = true; } else if (var_blk) { LOG_FMT(LVARDFBLK, "%s(%d): var_blk %s, first_var_blk %s, fn_top %s\n", __func__, __LINE__, var_blk ? "TRUE" : "FALSE", first_var_blk ? "TRUE" : "FALSE", fn_top ? "TRUE" : "FALSE"); log_rule_B("nl_var_def_blk_end_func_top"); log_rule_B("nl_var_def_blk_end"); if ( first_var_blk && fn_top) { // set blank lines after first var def block at the top of a function if (options::nl_var_def_blk_end_func_top() > 0) { LOG_FMT(LVARDFBLK, "%s(%d): nl_var_def_blk_end_func_top at line %zu\n", __func__, __LINE__, prev->GetOrigLine()); prot_the_line(__func__, __LINE__, 15, 4); newline_min_after(prev, options::nl_var_def_blk_end_func_top() + 1, PCF_VAR_DEF); } } else if ( !pc->IsPreproc() && options::nl_var_def_blk_end() > 0) { // set blank lines after other var def blocks LOG_FMT(LVARDFBLK, "%s(%d): nl_var_def_blk_end at line %zu\n", __func__, __LINE__, prev->GetOrigLine()); // Issue #3516 newline_min_after(prev, options::nl_var_def_blk_end() + 1, PCF_VAR_DEF); } // reset the variables for the next block prot_the_line(__func__, __LINE__, 15, 4); first_var_blk = false; var_blk = false; } else { first_var_blk = false; var_blk = false; } } else { if (pc->Is(CT_FUNC_CLASS_DEF)) { log_rule_B("nl_var_def_blk_end"); if ( var_blk && options::nl_var_def_blk_end() > 0) { prev = pc->GetPrev(); prev = prev->GetPrev(); newline_min_after(prev, options::nl_var_def_blk_end() + 1, PCF_VAR_DEF); pc = pc->GetNext(); first_var_blk = false; var_blk = false; } } } did_this_line = true; if (pc == nullptr) { pc = Chunk::NullChunkPtr; } pc = pc->GetNext(); } LOG_FMT(LVARDFBLK, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s', level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), pc->GetLevel()); LOG_FMT(LVARDFBLK, "%s(%d): start orig line is %zu, orig col is %zu, Text() is '%s', level is %zu\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol(), start->Text(), start->GetLevel()); //prot_the_line(__func__, __LINE__, 15, 4); return(pc); } // newline_var_def_blk static void collapse_empty_body(Chunk *br_open) { for (Chunk *pc = br_open->GetNext(); pc->IsNot(CT_BRACE_CLOSE); pc = pc->GetNext()) { if ( pc->Is(CT_NEWLINE) && pc->SafeToDeleteNl()) { pc = pc->GetPrev(); Chunk *next = pc->GetNext(); Chunk::Delete(next); MARK_CHANGE(); } } } // collapse_empty_body static void newlines_brace_pair(Chunk *br_open) { LOG_FUNC_ENTRY(); log_rule_B("nl_define_macro"); if ( br_open->TestFlags(PCF_IN_PREPROC) && !options::nl_define_macro()) { return; } //fixes 1235 Add single line namespace support if ( br_open->Is(CT_BRACE_OPEN) && (br_open->GetParentType() == CT_NAMESPACE) && br_open->GetPrev()->IsNewline()) { Chunk *chunk_brace_close = br_open->GetClosingParen(); if (chunk_brace_close->IsNotNullChunk()) { if (br_open->IsOnSameLine(chunk_brace_close)) { log_rule_B("nl_namespace_two_to_one_liner - 1"); if (options::nl_namespace_two_to_one_liner()) { Chunk *prev = br_open->GetPrevNnl(); newline_del_between(prev, br_open); } /* Below code is to support conversion of 2 liner to 4 liners * else * { * Chunk *nxt = br_open->GetNext(); * newline_add_between(br_open, nxt); * }*/ } } } // fix 1247 oneliner function support - converts 4,3,2 liners to oneliner log_rule_B("nl_create_func_def_one_liner"); if ( br_open->GetParentType() == CT_FUNC_DEF && options::nl_create_func_def_one_liner() && !br_open->TestFlags(PCF_NOT_POSSIBLE)) // Issue #2795 { Chunk *br_close = br_open->GetClosingParen(); Chunk *tmp = br_open->GetPrevNcNnlNi(); // Issue #2279 if ( br_close->IsNotNullChunk() // Issue #2594 && ((br_close->GetOrigLine() - br_open->GetOrigLine()) <= 2) && tmp->IsParenClose()) // need to check the conditions. { // Issue #1825 bool is_it_possible = true; while ( tmp->IsNotNullChunk() && (tmp = tmp->GetNext())->IsNotNullChunk() && !tmp->IsBraceClose() && (tmp->GetNext()->IsNotNullChunk())) { LOG_FMT(LNL1LINE, "%s(%d): tmp orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text()); if (tmp->IsComment()) { is_it_possible = false; break; } } if (is_it_possible) { // Issue 2795 // we have to check if it could be too long for code_width // make a vector to save the chunk vector saved_chunk; log_rule_B("code_width"); if (options::code_width() > 0) { saved_chunk.reserve(16); Chunk *current = br_open->GetPrevNcNnlNi(); Chunk *next_br_close = br_close->GetNext(); current = current->GetNext(); while (current->IsNotNullChunk()) { LOG_FMT(LNL1LINE, "%s(%d): zu kopieren: current orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, current->GetOrigLine(), current->GetOrigCol(), current->Text()); saved_chunk.push_back(*current); Chunk *the_next = current->GetNext(); if ( the_next->IsNullChunk() || the_next == next_br_close) { break; } current = the_next; } } Chunk *tmp_1 = br_open->GetPrevNcNnlNi(); while ( tmp_1->IsNotNullChunk() && (tmp_1 = tmp_1->GetNext())->IsNotNullChunk() && !tmp_1->IsBraceClose() && (tmp_1->GetNext()->IsNotNullChunk())) { LOG_FMT(LNL1LINE, "%s(%d): tmp_1 orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, tmp_1->GetOrigLine(), tmp_1->GetOrigCol(), tmp_1->Text()); if (tmp_1->IsNewline()) { tmp_1 = tmp_1->GetPrev(); // Issue #1825 newline_iarf_pair(tmp_1, tmp_1->GetNextNcNnl(), IARF_REMOVE); } } br_open->SetFlagBits(PCF_ONE_LINER); // set the one liner flag if needed br_close->SetFlagBits(PCF_ONE_LINER); log_rule_B("code_width"); if ( options::code_width() > 0 && br_close->GetColumn() > options::code_width()) { // the created line is too long // it is not possible to make an one_liner // because the line would be too long br_open->SetFlagBits(PCF_NOT_POSSIBLE); // restore the code size_t count; Chunk tmp_2; Chunk *current = br_open; for (count = 0; count < saved_chunk.size(); count++) { tmp_2 = saved_chunk.at(count); if (tmp_2.GetOrigLine() != current->GetOrigLine()) { // restore the newline Chunk chunk; chunk.SetType(CT_NEWLINE); chunk.SetOrigLine(current->GetOrigLine()); chunk.SetOrigCol(current->GetOrigCol()); chunk.SetPpLevel(current->GetPpLevel()); chunk.SetNlCount(1); chunk.CopyAndAddBefore(current); LOG_FMT(LNEWLINE, "%s(%d): %zu:%zu add newline before '%s'\n", __func__, __LINE__, current->GetOrigLine(), current->GetOrigCol(), current->Text()); } else { current = current->GetNext(); } } } } } } // Make sure we don't break a one-liner if (!one_liner_nl_ok(br_open)) { LOG_FMT(LNL1LINE, "%s(%d): br_open orig line is %zu, orig col is %zu, a new line may NOT be added\n", __func__, __LINE__, br_open->GetOrigLine(), br_open->GetOrigCol()); return; } LOG_FMT(LNL1LINE, "%s(%d): a new line may be added\n", __func__, __LINE__); Chunk *next = br_open->GetNextNc(); // Insert a newline between the '=' and open brace, if needed LOG_FMT(LNL1LINE, "%s(%d): br_open->Text() '%s', br_open->GetType() [%s], br_open->GetParentType() [%s]\n", __func__, __LINE__, br_open->Text(), get_token_name(br_open->GetType()), get_token_name(br_open->GetParentType())); if (br_open->GetParentType() == CT_ASSIGN) { // Only mess with it if the open brace is followed by a newline if (next->IsNewline()) { Chunk *prev = br_open->GetPrevNcNnlNi(); // Issue #2279 log_rule_B("nl_assign_brace"); newline_iarf_pair(prev, br_open, options::nl_assign_brace()); } } if ( br_open->GetParentType() == CT_OC_MSG_DECL || br_open->GetParentType() == CT_FUNC_DEF || br_open->GetParentType() == CT_FUNC_CLASS_DEF || br_open->GetParentType() == CT_OC_CLASS || br_open->GetParentType() == CT_CS_PROPERTY || br_open->GetParentType() == CT_CPP_LAMBDA || br_open->GetParentType() == CT_FUNC_CALL || br_open->GetParentType() == CT_FUNC_CALL_USER) { Chunk *prev = Chunk::NullChunkPtr; iarf_e val; if (br_open->GetParentType() == CT_OC_MSG_DECL) { log_rule_B("nl_oc_mdef_brace"); val = options::nl_oc_mdef_brace(); } else { if ( br_open->GetParentType() == CT_FUNC_DEF || br_open->GetParentType() == CT_FUNC_CLASS_DEF || br_open->GetParentType() == CT_OC_CLASS) { val = IARF_NOT_DEFINED; log_rule_B("nl_fdef_brace_cond"); const iarf_e nl_fdef_brace_cond_v = options::nl_fdef_brace_cond(); if (nl_fdef_brace_cond_v != IARF_IGNORE) { prev = br_open->GetPrevNcNnlNi(); // Issue #2279 if (prev->Is(CT_FPAREN_CLOSE)) { val = nl_fdef_brace_cond_v; } } if (val == IARF_NOT_DEFINED) { log_rule_B("nl_fdef_brace"); val = options::nl_fdef_brace(); } } else { log_rule_B("nl_property_brace"); log_rule_B("nl_cpp_ldef_brace"); log_rule_B("nl_fcall_brace"); val = ((br_open->GetParentType() == CT_CS_PROPERTY) ? options::nl_property_brace() : ((br_open->GetParentType() == CT_CPP_LAMBDA) ? options::nl_cpp_ldef_brace() : options::nl_fcall_brace())); } } if (val != IARF_IGNORE) { if (prev->IsNullChunk()) { // Grab the chunk before the open brace prev = br_open->GetPrevNcNnlNi(); // Issue #2279 } newline_iarf_pair(prev, br_open, val); } } if (br_open->GetNextNnl()->Is(CT_BRACE_CLOSE)) { // Chunk is "{" and "}" with only whitespace/newlines in between if (br_open->GetParentType() == CT_FUNC_DEF) { // Braces belong to a function definition log_rule_B("nl_collapse_empty_body_functions"); if (options::nl_collapse_empty_body_functions()) { collapse_empty_body(br_open); return; } } else { log_rule_B("nl_collapse_empty_body"); if (options::nl_collapse_empty_body()) { collapse_empty_body(br_open); return; } } } //fixes #1245 will add new line between tsquare and brace open based on nl_tsquare_brace if (br_open->Is(CT_BRACE_OPEN)) { Chunk *chunk_closing_brace = br_open->GetClosingParen(); if (chunk_closing_brace->IsNotNullChunk()) { if (chunk_closing_brace->GetOrigLine() > br_open->GetOrigLine()) { Chunk *prev = br_open->GetPrevNc(); if ( prev->Is(CT_TSQUARE) && next->IsNewline()) { log_rule_B("nl_tsquare_brace"); newline_iarf_pair(prev, br_open, options::nl_tsquare_brace()); } } } } // Eat any extra newlines after the brace open log_rule_B("eat_blanks_after_open_brace"); if (options::eat_blanks_after_open_brace()) { if (next->IsNewline()) { log_rule_B("nl_inside_empty_func"); log_rule_B("nl_inside_namespace"); if ( options::nl_inside_empty_func() > 0 && br_open->GetNextNnl()->Is(CT_BRACE_CLOSE) && ( br_open->GetParentType() == CT_FUNC_CLASS_DEF || br_open->GetParentType() == CT_FUNC_DEF)) { blank_line_set(next, options::nl_inside_empty_func); } else if ( options::nl_inside_namespace() > 0 && br_open->GetParentType() == CT_NAMESPACE) { blank_line_set(next, options::nl_inside_namespace); } else if (next->GetNlCount() > 1) { next->SetNlCount(1); LOG_FMT(LBLANKD, "%s(%d): eat_blanks_after_open_brace %zu\n", __func__, __LINE__, next->GetOrigLine()); MARK_CHANGE(); } } } bool nl_close_brace = false; // Handle the cases where the brace is part of a function call or definition if (is_func_call_or_def(br_open)) { // Need to force a newline before the close brace, if not in a class body if (!br_open->TestFlags(PCF_IN_CLASS)) { nl_close_brace = true; } // handle newlines after the open brace Chunk *pc = br_open->GetNextNcNnl(); newline_add_between(br_open, pc); } // Grab the matching brace close Chunk *br_close = br_open->GetNextType(CT_BRACE_CLOSE, br_open->GetLevel()); if (br_close->IsNullChunk()) { return; } if (!nl_close_brace) { /* * If the open brace hits a CT_NEWLINE, CT_NL_CONT, CT_COMMENT_MULTI, or * CT_COMMENT_CPP without hitting anything other than CT_COMMENT, then * there should be a newline before the close brace. */ Chunk *pc = br_open->GetNext(); while (pc->Is(CT_COMMENT)) { pc = pc->GetNext(); } if (pc->IsCommentOrNewline()) { nl_close_brace = true; } } Chunk *prev = br_close->GetPrevNcNnlNet(); if (nl_close_brace) { newline_add_between(prev, br_close); } else { newline_del_between(prev, br_close); } } // newlines_brace_pair static void newline_case(Chunk *start) { LOG_FUNC_ENTRY(); // printf("%s case (%s) on line %d col %d\n", // __func__, c_chunk_names[start->GetType()], // start->GetOrigLine(), start->GetOrigCol()); // Scan backwards until a '{' or ';' or ':'. Abort if a multi-newline is found Chunk *prev = start; do { prev = prev->GetPrevNc(); if ( prev->IsNotNullChunk() && prev->IsNewline() && prev->GetNlCount() > 1) { return; } } while ( prev->IsNot(CT_BRACE_OPEN) && prev->IsNot(CT_BRACE_CLOSE) && prev->IsNot(CT_SEMICOLON) && prev->IsNot(CT_CASE_COLON)); if (prev->IsNullChunk()) { return; } Chunk *pc = newline_add_between(prev, start); if (pc == nullptr) { return; } // Only add an extra line after a semicolon or brace close if ( prev->Is(CT_SEMICOLON) || prev->Is(CT_BRACE_CLOSE)) { if ( pc->IsNewline() && pc->GetNlCount() < 2) { double_newline(pc); } } } // newline_case static void newline_case_colon(Chunk *start) { LOG_FUNC_ENTRY(); // Scan forwards until a non-comment is found Chunk *pc = start; do { pc = pc->GetNext(); } while (pc->IsComment()); if ( pc->IsNotNullChunk() && !pc->IsNewline()) { newline_add_before(pc); } } // newline_case_colon static void newline_before_return(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::NullChunkPtr; if (start != nullptr) { pc = start->GetPrev(); } Chunk *nl = pc; // Skip over single preceding newline if (pc->IsNewline()) { // Do we already have a blank line? if (nl->GetNlCount() > 1) { return; } pc = nl->GetPrev(); } // Skip over preceding comments that are not a trailing comment, taking // into account that comment blocks may span multiple lines. // Trailing comments are considered part of the previous token, not the // return statement. They are handled below. while ( pc->IsComment() && pc->GetParentType() != CT_COMMENT_END) { pc = pc->GetPrev(); if (!pc->IsNewline()) { return; } nl = pc; pc = pc->GetPrev(); } pc = nl->GetPrev(); // Peek over trailing comment of previous token if ( pc->IsComment() && pc->GetParentType() == CT_COMMENT_END) { pc = pc->GetPrev(); } // Don't add extra blanks after an opening brace or a case statement if ( pc->IsNullChunk() || ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_VBRACE_OPEN) || pc->Is(CT_CASE_COLON))) { return; } if ( nl->IsNewline() && nl->GetNlCount() < 2) { nl->SetNlCount(nl->GetNlCount() + 1); MARK_CHANGE(); LOG_FMT(LBLANK, "%s(%d): orig line is %zu, orig col is %zu, text is '%s', new line count is now %zu\n", __func__, __LINE__, nl->GetOrigLine(), nl->GetOrigCol(), nl->Text(), nl->GetNlCount()); } } // newline_before_return static void newline_after_return(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *semi = start->GetNextType(CT_SEMICOLON, start->GetLevel()); Chunk *after = semi->GetNextNcNnlNet(); // If we hit a brace or an 'else', then a newline isn't needed if ( after->IsNullChunk() || after->IsBraceClose() || after->Is(CT_ELSE)) { return; } Chunk *pc; for (pc = semi->GetNext(); pc != after; pc = pc->GetNext()) { if (pc->Is(CT_NEWLINE)) { if (pc->GetNlCount() < 2) { double_newline(pc); } return; } } } // newline_after_return static void newline_iarf_pair(Chunk *before, Chunk *after, iarf_e av, bool check_nl_assign_leave_one_liners) { LOG_FUNC_ENTRY(); LOG_FMT(LNEWLINE, "%s(%d): ", __func__, __LINE__); log_func_stack(LNEWLINE, "CallStack:"); if ( before == nullptr || before == Chunk::NullChunkPtr || after == nullptr || after == Chunk::NullChunkPtr || after->Is(CT_IGNORED)) { return; } if (av & IARF_ADD) { if ( check_nl_assign_leave_one_liners && options::nl_assign_leave_one_liners() && after->TestFlags(PCF_ONE_LINER)) { log_rule_B("nl_assign_leave_one_liners"); return; } Chunk *nl = newline_add_between(before, after); LOG_FMT(LNEWLINE, "%s(%d): newline_add_between '%s' and '%s'\n", __func__, __LINE__, before->Text(), after->Text()); if ( nl != nullptr && av == IARF_FORCE && nl->GetNlCount() > 1) { nl->SetNlCount(1); } } else if (av & IARF_REMOVE) { LOG_FMT(LNEWLINE, "%s(%d): newline_remove_between '%s' and '%s'\n", __func__, __LINE__, before->Text(), after->Text()); newline_del_between(before, after); } } // newline_iarf_pair void newline_iarf(Chunk *pc, iarf_e av) { LOG_FUNC_ENTRY(); LOG_FMT(LNFD, "%s(%d): ", __func__, __LINE__); log_func_stack(LNFD, "CallStack:"); Chunk *after = Chunk::NullChunkPtr; if (pc != nullptr) { after = pc->GetNextNnl(); } if ( (pc != nullptr && pc->Is(CT_FPAREN_OPEN)) // Issue #2914 && pc->GetParentType() == CT_FUNC_CALL && after->Is(CT_COMMENT_CPP) && options::donot_add_nl_before_cpp_comment()) { return; } newline_iarf_pair(pc, after, av); } // newline_iarf static void newline_func_multi_line(Chunk *start) { LOG_FUNC_ENTRY(); LOG_FMT(LNFD, "%s(%d): called on %zu:%zu '%s' [%s/%s]\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol(), start->Text(), get_token_name(start->GetType()), get_token_name(start->GetParentType())); bool add_start; bool add_args; bool add_end; if ( start->GetParentType() == CT_FUNC_DEF || start->GetParentType() == CT_FUNC_CLASS_DEF) { log_rule_B("nl_func_def_start_multi_line"); add_start = options::nl_func_def_start_multi_line(); log_rule_B("nl_func_def_args_multi_line"); add_args = options::nl_func_def_args_multi_line(); log_rule_B("nl_func_def_end_multi_line"); add_end = options::nl_func_def_end_multi_line(); } else if ( start->GetParentType() == CT_FUNC_CALL || start->GetParentType() == CT_FUNC_CALL_USER) { log_rule_B("nl_func_call_start_multi_line"); add_start = options::nl_func_call_start_multi_line(); log_rule_B("nl_func_call_args_multi_line"); add_args = options::nl_func_call_args_multi_line(); log_rule_B("nl_func_call_end_multi_line"); add_end = options::nl_func_call_end_multi_line(); } else { log_rule_B("nl_func_decl_start_multi_line"); add_start = options::nl_func_decl_start_multi_line(); log_rule_B("nl_func_decl_args_multi_line"); add_args = options::nl_func_decl_args_multi_line(); log_rule_B("nl_func_decl_end_multi_line"); add_end = options::nl_func_decl_end_multi_line(); } if ( !add_start && !add_args && !add_end) { return; } Chunk *pc = start->GetNextNcNnl(); while ( pc->IsNotNullChunk() && pc->GetLevel() > start->GetLevel()) { pc = pc->GetNextNcNnl(); } if ( pc->Is(CT_FPAREN_CLOSE) && start->IsNewlineBetween(pc)) { Chunk *start_next = start->GetNextNcNnl(); bool has_leading_closure = ( start_next->GetParentType() == CT_OC_BLOCK_EXPR || start_next->GetParentType() == CT_CPP_LAMBDA || start_next->Is(CT_BRACE_OPEN)); Chunk *prev_end = pc->GetPrevNcNnl(); bool has_trailing_closure = ( prev_end->GetParentType() == CT_OC_BLOCK_EXPR || prev_end->GetParentType() == CT_CPP_LAMBDA || prev_end->Is(CT_BRACE_OPEN)); if ( add_start && !start->GetNext()->IsNewline()) { log_rule_B("nl_func_call_args_multi_line_ignore_closures"); if (options::nl_func_call_args_multi_line_ignore_closures()) { if ( !has_leading_closure && !has_trailing_closure) { newline_iarf(start, IARF_ADD); } } else { newline_iarf(start, IARF_ADD); } } if ( add_end && !pc->GetPrev()->IsNewline()) { log_rule_B("nl_func_call_args_multi_line_ignore_closures"); if (options::nl_func_call_args_multi_line_ignore_closures()) { if ( !has_leading_closure && !has_trailing_closure) { newline_iarf(pc->GetPrev(), IARF_ADD); } } else { newline_iarf(pc->GetPrev(), IARF_ADD); } } if (add_args) { // process the function in reverse and leave the first comma if the option to leave trailing closure // is on. nl_func_call_args_multi_line_ignore_trailing_closure for (pc = start->GetNextNcNnl(); pc->IsNotNullChunk() && pc->GetLevel() > start->GetLevel(); pc = pc->GetNextNcNnl()) { if ( pc->Is(CT_COMMA) && (pc->GetLevel() == (start->GetLevel() + 1))) { Chunk *tmp = pc->GetNext(); if (tmp->IsComment()) { pc = tmp; } if (!pc->GetNext()->IsNewline()) { log_rule_B("nl_func_call_args_multi_line_ignore_closures"); if (options::nl_func_call_args_multi_line_ignore_closures()) { Chunk *prev_comma = pc->GetPrevNcNnl(); Chunk *after_comma = pc->GetNextNcNnl(); if (!( ( prev_comma->GetParentType() == CT_OC_BLOCK_EXPR || prev_comma->GetParentType() == CT_CPP_LAMBDA || prev_comma->Is(CT_BRACE_OPEN)) || ( after_comma->GetParentType() == CT_OC_BLOCK_EXPR || after_comma->GetParentType() == CT_CPP_LAMBDA || after_comma->Is(CT_BRACE_OPEN)))) { newline_iarf(pc, IARF_ADD); } } else { newline_iarf(pc, IARF_ADD); } } } } } } } // newline_func_multi_line static void newline_template(Chunk *start) { LOG_FUNC_ENTRY(); LOG_FMT(LNFD, "%s(%d): called on %zu:%zu '%s' [%s/%s]\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol(), start->Text(), get_token_name(start->GetType()), get_token_name(start->GetParentType())); log_rule_B("nl_template_start"); bool add_start = options::nl_template_start(); log_rule_B("nl_template_args"); bool add_args = options::nl_template_args(); log_rule_B("nl_template_end"); bool add_end = options::nl_template_end(); if ( !add_start && !add_args && !add_end) { return; } Chunk *pc = start->GetNextNcNnl(); while ( pc->IsNotNullChunk() && pc->GetLevel() > start->GetLevel()) { pc = pc->GetNextNcNnl(); } if (pc->Is(CT_ANGLE_CLOSE)) { if (add_start) { newline_iarf(start, IARF_ADD); } if (add_end) { newline_iarf(pc->GetPrev(), IARF_ADD); } if (add_args) { Chunk *pc_1; for (pc_1 = start->GetNextNcNnl(); pc_1->IsNotNullChunk() && pc_1->GetLevel() > start->GetLevel(); pc_1 = pc_1->GetNextNcNnl()) { if ( pc_1->Is(CT_COMMA) && (pc_1->GetLevel() == (start->GetLevel() + 1))) { Chunk *tmp = pc_1->GetNext(); if (tmp->IsComment()) { pc_1 = tmp; } if (!pc_1->GetNext()->IsNewline()) { newline_iarf(pc_1, IARF_ADD); } } } } } } // newline_template static void newline_func_def_or_call(Chunk *start) { LOG_FUNC_ENTRY(); LOG_FMT(LNFD, "%s(%d): called on start->Text() is '%s', orig line is %zu, orig col is %zu, [%s/%s]\n", __func__, __LINE__, start->Text(), start->GetOrigLine(), start->GetOrigCol(), get_token_name(start->GetType()), get_token_name(start->GetParentType())); bool is_def = (start->GetParentType() == CT_FUNC_DEF) || start->GetParentType() == CT_FUNC_CLASS_DEF; bool is_call = (start->GetParentType() == CT_FUNC_CALL) || start->GetParentType() == CT_FUNC_CALL_USER; LOG_FMT(LNFD, "%s(%d): is_def is %s, is_call is %s\n", __func__, __LINE__, is_def ? "TRUE" : "FALSE", is_call ? "TRUE" : "FALSE"); if (is_call) { log_rule_B("nl_func_call_paren"); iarf_e atmp = options::nl_func_call_paren(); if (atmp != IARF_IGNORE) { Chunk *prev = start->GetPrevNcNnlNi(); // Issue #2279 if (prev->IsNotNullChunk()) { newline_iarf(prev, atmp); } } Chunk *pc = start->GetNextNcNnl(); if (pc->IsString(")")) { log_rule_B("nl_func_call_paren_empty"); atmp = options::nl_func_call_paren_empty(); if (atmp != IARF_IGNORE) { Chunk *prev = start->GetPrevNcNnlNi(); // Issue #2279 if (prev->IsNotNullChunk()) { newline_iarf(prev, atmp); } } log_rule_B("nl_func_call_empty"); atmp = options::nl_func_call_empty(); if (atmp != IARF_IGNORE) { newline_iarf(start, atmp); } return; } } else { log_rule_B("nl_func_def_paren"); log_rule_B("nl_func_paren"); iarf_e atmp = is_def ? options::nl_func_def_paren() : options::nl_func_paren(); LOG_FMT(LSPACE, "%s(%d): atmp is %s\n", __func__, __LINE__, (atmp == IARF_IGNORE) ? "IGNORE" : (atmp == IARF_ADD) ? "ADD" : (atmp == IARF_REMOVE) ? "REMOVE" : "FORCE"); if (atmp != IARF_IGNORE) { Chunk *prev = start->GetPrevNcNnlNi(); // Issue #2279 if (prev->IsNotNullChunk()) { newline_iarf(prev, atmp); } } // Handle break newlines type and function Chunk *prev = start->GetPrevNcNnlNi(); // Issue #2279 prev = skip_template_prev(prev); // Don't split up a function variable prev = prev->IsParenClose() ? Chunk::NullChunkPtr : prev->GetPrevNcNnlNi(); // Issue #2279 log_rule_B("nl_func_class_scope"); if ( prev->Is(CT_DC_MEMBER) && (options::nl_func_class_scope() != IARF_IGNORE)) { newline_iarf(prev->GetPrevNcNnlNi(), options::nl_func_class_scope()); // Issue #2279 } if (prev->IsNot(CT_ACCESS_COLON)) { Chunk *tmp; if (prev->Is(CT_OPERATOR)) { tmp = prev; prev = prev->GetPrevNcNnlNi(); // Issue #2279 } else { tmp = start; } if (prev->Is(CT_DC_MEMBER)) { log_rule_B("nl_func_scope_name"); if ( options::nl_func_scope_name() != IARF_IGNORE && !start->TestFlags(PCF_IN_DECLTYPE)) { newline_iarf(prev, options::nl_func_scope_name()); } } const Chunk *tmp_next = prev->GetNextNcNnl(); if (tmp_next->IsNot(CT_FUNC_CLASS_DEF)) { Chunk *closing = tmp->GetClosingParen(); Chunk *brace = closing->GetNextNcNnl(); iarf_e a; // Issue #2561 if ( tmp->GetParentType() == CT_FUNC_PROTO || tmp->GetParentType() == CT_FUNC_CLASS_PROTO) { // proto log_rule_B("nl_func_proto_type_name"); a = options::nl_func_proto_type_name(); } else { // def log_rule_B("nl_func_leave_one_liners"); if ( options::nl_func_leave_one_liners() && ( brace == nullptr || brace->TestFlags(PCF_ONE_LINER))) // Issue #1511 and #3274 { a = IARF_IGNORE; } else { log_rule_B("nl_func_type_name"); a = options::nl_func_type_name(); } } log_rule_B("nl_func_type_name_class"); if ( tmp->TestFlags(PCF_IN_CLASS) && (options::nl_func_type_name_class() != IARF_IGNORE)) { a = options::nl_func_type_name_class(); } if ( (a != IARF_IGNORE) && prev->IsNotNullChunk()) { LOG_FMT(LNFD, "%s(%d): prev->Text() '%s', orig line is %zu, orig col is %zu, [%s/%s]\n", __func__, __LINE__, prev->Text(), prev->GetOrigLine(), prev->GetOrigCol(), get_token_name(prev->GetType()), get_token_name(prev->GetParentType())); if (prev->Is(CT_DESTRUCTOR)) { prev = prev->GetPrevNcNnlNi(); // Issue #2279 } /* * If we are on a '::', step back two tokens * TODO: do we also need to check for '.' ? */ while (prev->Is(CT_DC_MEMBER)) { prev = prev->GetPrevNcNnlNi(); // Issue #2279 prev = skip_template_prev(prev); prev = prev->GetPrevNcNnlNi(); // Issue #2279 } if ( !prev->IsBraceClose() && prev->IsNot(CT_BRACE_OPEN) && prev->IsNot(CT_SEMICOLON) && prev->IsNot(CT_ACCESS_COLON) // #1008: if we landed on an operator check that it is having // a type before it, in order to not apply nl_func_type_name // on conversion operators as they don't have a normal // return type syntax && (tmp_next->IsNot(CT_OPERATOR) ? true : prev->IsTypeDefinition())) { newline_iarf(prev, a); } } } } Chunk *pc = start->GetNextNcNnl(); if (pc->IsString(")")) { log_rule_B("nl_func_def_empty"); log_rule_B("nl_func_decl_empty"); atmp = is_def ? options::nl_func_def_empty() : options::nl_func_decl_empty(); if (atmp != IARF_IGNORE) { newline_iarf(start, atmp); } log_rule_B("nl_func_def_paren_empty"); log_rule_B("nl_func_paren_empty"); atmp = is_def ? options::nl_func_def_paren_empty() : options::nl_func_paren_empty(); if (atmp != IARF_IGNORE) { prev = start->GetPrevNcNnlNi(); // Issue #2279 if (prev->IsNotNullChunk()) { newline_iarf(prev, atmp); } } return; } } // Now scan for commas size_t comma_count = 0; Chunk *tmp; Chunk *pc; for (pc = start->GetNextNcNnl(); pc->IsNotNullChunk() && pc->GetLevel() > start->GetLevel(); pc = pc->GetNextNcNnl()) { if ( pc->Is(CT_COMMA) && (pc->GetLevel() == (start->GetLevel() + 1))) { comma_count++; tmp = pc->GetNext(); if (tmp->IsComment()) { pc = tmp; } if (is_def) { log_rule_B("nl_func_def_args"); newline_iarf(pc, options::nl_func_def_args()); } else if (is_call) { // Issue #2604 log_rule_B("nl_func_call_args"); newline_iarf(pc, options::nl_func_call_args()); } else // start->GetParentType() == CT_FUNC_DECL { log_rule_B("nl_func_decl_args"); newline_iarf(pc, options::nl_func_decl_args()); } } } log_rule_B("nl_func_def_start"); log_rule_B("nl_func_decl_start"); iarf_e as = is_def ? options::nl_func_def_start() : options::nl_func_decl_start(); log_rule_B("nl_func_def_end"); log_rule_B("nl_func_decl_end"); iarf_e ae = is_def ? options::nl_func_def_end() : options::nl_func_decl_end(); if (comma_count == 0) { iarf_e atmp; log_rule_B("nl_func_def_start_single"); log_rule_B("nl_func_decl_start_single"); atmp = is_def ? options::nl_func_def_start_single() : options::nl_func_decl_start_single(); if (atmp != IARF_IGNORE) { as = atmp; } log_rule_B("nl_func_def_end_single"); log_rule_B("nl_func_decl_end_single"); atmp = is_def ? options::nl_func_def_end_single() : options::nl_func_decl_end_single(); if (atmp != IARF_IGNORE) { ae = atmp; } } if (!is_call) { newline_iarf(start, as); } // and fix up the close parenthesis if (pc->Is(CT_FPAREN_CLOSE)) { Chunk *prev = pc->GetPrevNnl(); if ( prev->IsNot(CT_FPAREN_OPEN) && !is_call) { newline_iarf(prev, ae); } newline_func_multi_line(start); } } // newline_func_def_or_call static void newline_oc_msg(Chunk *start) { LOG_FUNC_ENTRY(); Chunk *sq_c = start->GetClosingParen(); if (sq_c->IsNullChunk()) { return; } log_rule_B("nl_oc_msg_leave_one_liner"); if (options::nl_oc_msg_leave_one_liner()) { return; } bool should_nl_msg = false; // Get count of parameters size_t parameter_count = 0; for (Chunk *pc = start->GetNextNcNnl(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if (pc->GetLevel() <= start->GetLevel()) { break; } if (pc->Is(CT_OC_COLON) && pc->GetLevel() - 1 == start->GetLevel()) { parameter_count++; } } size_t min_params = options::nl_oc_msg_args_min_params(); if ( parameter_count >= min_params && min_params != 0) { should_nl_msg = true; } // Get length of longest line size_t longest_line = 0; for (Chunk *pc = start->GetNextNcNnl(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if (pc->GetLevel() <= start->GetLevel()) { break; } if (pc->GetOrigColEnd() > longest_line) { longest_line = pc->GetOrigColEnd(); } } size_t max_code_width = options::nl_oc_msg_args_max_code_width(); if ( longest_line > max_code_width && max_code_width != 0) { should_nl_msg = true; } // If both nl_oc_msg_args_min_params and nl_oc_msg_args_max_code_width are disabled // we should newline all messages. if ( max_code_width == 0 && min_params == 0) { should_nl_msg = true; } if (!should_nl_msg) { return; } for (Chunk *pc = start->GetNextNcNnl(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if (pc->GetLevel() <= start->GetLevel()) { break; } if (pc->Is(CT_OC_MSG_NAME) && pc->GetLevel() - 1 == start->GetLevel()) { newline_add_before(pc); } } } // newline_oc_msg static bool one_liner_nl_ok(Chunk *pc) { LOG_FUNC_ENTRY(); LOG_FMT(LNL1LINE, "%s(%d): check type is %s, parent is %s, flag is %s, orig line is %zu, orig col is %zu\n", __func__, __LINE__, get_token_name(pc->GetType()), get_token_name(pc->GetParentType()), pcf_flags_str(pc->GetFlags()).c_str(), pc->GetOrigLine(), pc->GetOrigCol()); if (!pc->TestFlags(PCF_ONE_LINER)) { LOG_FMT(LNL1LINE, "%s(%d): true (not 1-liner), a new line may be added\n", __func__, __LINE__); return(true); } // Step back to find the opening brace Chunk *br_open = pc; if (br_open->IsBraceClose()) { br_open = br_open->GetPrevType(br_open->Is(CT_BRACE_CLOSE) ? CT_BRACE_OPEN : CT_VBRACE_OPEN, br_open->GetLevel(), E_Scope::ALL); } else { while ( br_open->IsNotNullChunk() && br_open->TestFlags(PCF_ONE_LINER) && !br_open->IsBraceOpen() && !br_open->IsBraceClose()) { br_open = br_open->GetPrev(); } } pc = br_open; if ( pc->IsNotNullChunk() && pc->TestFlags(PCF_ONE_LINER) && ( pc->IsBraceOpen() || pc->IsBraceClose())) { log_rule_B("nl_class_leave_one_liners"); if ( options::nl_class_leave_one_liners() && pc->TestFlags(PCF_IN_CLASS)) { LOG_FMT(LNL1LINE, "%s(%d): false (class)\n", __func__, __LINE__); return(false); } log_rule_B("nl_assign_leave_one_liners"); if ( options::nl_assign_leave_one_liners() && pc->GetParentType() == CT_ASSIGN) { LOG_FMT(LNL1LINE, "%s(%d): false (assign)\n", __func__, __LINE__); return(false); } log_rule_B("nl_enum_leave_one_liners"); if ( options::nl_enum_leave_one_liners() && pc->GetParentType() == CT_ENUM) { LOG_FMT(LNL1LINE, "%s(%d): false (enum)\n", __func__, __LINE__); return(false); } log_rule_B("nl_getset_leave_one_liners"); if ( options::nl_getset_leave_one_liners() && pc->GetParentType() == CT_GETSET) { LOG_FMT(LNL1LINE, "%s(%d): false (get/set), a new line may NOT be added\n", __func__, __LINE__); return(false); } // Issue #UT-98 log_rule_B("nl_cs_property_leave_one_liners"); if ( options::nl_cs_property_leave_one_liners() && pc->GetParentType() == CT_CS_PROPERTY) { LOG_FMT(LNL1LINE, "%s(%d): false (c# property), a new line may NOT be added\n", __func__, __LINE__); return(false); } log_rule_B("nl_func_leave_one_liners"); if ( options::nl_func_leave_one_liners() && ( pc->GetParentType() == CT_FUNC_DEF || pc->GetParentType() == CT_FUNC_CLASS_DEF)) { LOG_FMT(LNL1LINE, "%s(%d): false (func def)\n", __func__, __LINE__); return(false); } log_rule_B("nl_func_leave_one_liners"); if ( options::nl_func_leave_one_liners() && pc->GetParentType() == CT_OC_MSG_DECL) { LOG_FMT(LNL1LINE, "%s(%d): false (method def)\n", __func__, __LINE__); return(false); } log_rule_B("nl_cpp_lambda_leave_one_liners"); if ( options::nl_cpp_lambda_leave_one_liners() && ((pc->GetParentType() == CT_CPP_LAMBDA))) { LOG_FMT(LNL1LINE, "%s(%d): false (lambda)\n", __func__, __LINE__); return(false); } log_rule_B("nl_oc_msg_leave_one_liner"); if ( options::nl_oc_msg_leave_one_liner() && pc->TestFlags(PCF_IN_OC_MSG)) { LOG_FMT(LNL1LINE, "%s(%d): false (message)\n", __func__, __LINE__); return(false); } log_rule_B("nl_if_leave_one_liners"); if ( options::nl_if_leave_one_liners() && ( pc->GetParentType() == CT_IF || pc->GetParentType() == CT_ELSEIF || pc->GetParentType() == CT_ELSE)) { LOG_FMT(LNL1LINE, "%s(%d): false (if/else)\n", __func__, __LINE__); return(false); } log_rule_B("nl_while_leave_one_liners"); if ( options::nl_while_leave_one_liners() && pc->GetParentType() == CT_WHILE) { LOG_FMT(LNL1LINE, "%s(%d): false (while)\n", __func__, __LINE__); return(false); } log_rule_B("nl_do_leave_one_liners"); if ( options::nl_do_leave_one_liners() && pc->GetParentType() == CT_DO) { LOG_FMT(LNL1LINE, "%s(%d): false (do)\n", __func__, __LINE__); return(false); } log_rule_B("nl_for_leave_one_liners"); if ( options::nl_for_leave_one_liners() && pc->GetParentType() == CT_FOR) { LOG_FMT(LNL1LINE, "%s(%d): false (for)\n", __func__, __LINE__); return(false); } log_rule_B("nl_namespace_two_to_one_liner - 2"); if ( options::nl_namespace_two_to_one_liner() && pc->GetParentType() == CT_NAMESPACE) { LOG_FMT(LNL1LINE, "%s(%d): false (namespace)\n", __func__, __LINE__); return(false); } } LOG_FMT(LNL1LINE, "%s(%d): true, a new line may be added\n", __func__, __LINE__); return(true); } // one_liner_nl_ok void undo_one_liner(Chunk *pc) { LOG_FUNC_ENTRY(); if ( pc != nullptr && pc->TestFlags(PCF_ONE_LINER)) { LOG_FMT(LNL1LINE, "%s(%d): pc->Text() '%s', orig line is %zu, orig col is %zu", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); pc->ResetFlagBits(PCF_ONE_LINER); // scan backward LOG_FMT(LNL1LINE, "%s(%d): scan backward\n", __func__, __LINE__); Chunk *tmp = pc; while ((tmp = tmp->GetPrev())->IsNotNullChunk()) { if (!tmp->TestFlags(PCF_ONE_LINER)) { LOG_FMT(LNL1LINE, "%s(%d): tmp->Text() '%s', orig line is %zu, orig col is %zu, --> break\n", __func__, __LINE__, tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol()); break; } LOG_FMT(LNL1LINE, "%s(%d): clear for tmp->Text() '%s', orig line is %zu, orig col is %zu", __func__, __LINE__, tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol()); tmp->ResetFlagBits(PCF_ONE_LINER); } // scan forward LOG_FMT(LNL1LINE, "%s(%d): scan forward\n", __func__, __LINE__); tmp = pc; LOG_FMT(LNL1LINE, "%s(%d): - \n", __func__, __LINE__); while ((tmp = tmp->GetNext())->IsNotNullChunk()) { if (!tmp->TestFlags(PCF_ONE_LINER)) { LOG_FMT(LNL1LINE, "%s(%d): tmp->Text() '%s', orig line is %zu, orig col is %zu, --> break\n", __func__, __LINE__, tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol()); break; } LOG_FMT(LNL1LINE, "%s(%d): clear for tmp->Text() '%s', orig line is %zu, orig col is %zu", __func__, __LINE__, tmp->Text(), tmp->GetOrigLine(), tmp->GetOrigCol()); tmp->ResetFlagBits(PCF_ONE_LINER); } LOG_FMT(LNL1LINE, "\n"); } } // undo_one_liner static void nl_create_one_liner(Chunk *vbrace_open) { LOG_FUNC_ENTRY(); // See if we get a newline between the next text and the vbrace_close Chunk *tmp = vbrace_open->GetNextNcNnl(); Chunk *first = tmp; if ( first->IsNullChunk() || get_token_pattern_class(first->GetType()) != pattern_class_e::NONE) { return; } size_t nl_total = 0; while (tmp->IsNot(CT_VBRACE_CLOSE)) { if (tmp->IsNewline()) { nl_total += tmp->GetNlCount(); if (nl_total > 1) { return; } } tmp = tmp->GetNext(); } if ( tmp->IsNotNullChunk() && first->IsNotNullChunk()) { newline_del_between(vbrace_open, first); } } // nl_create_one_liner static void nl_create_list_liner(Chunk *brace_open) { LOG_FUNC_ENTRY(); // See if we get a newline between the next text and the vbrace_close if (brace_open == nullptr) { return; } Chunk *closing = brace_open->GetNextType(CT_BRACE_CLOSE, brace_open->GetLevel()); Chunk *tmp = brace_open; do { if (tmp->Is(CT_COMMA)) { return; } tmp = tmp->GetNext(); } while (tmp != closing); newline_del_between(brace_open, closing); } // nl_create_list_liner void newlines_remove_newlines() { LOG_FUNC_ENTRY(); LOG_FMT(LBLANK, "%s(%d):\n", __func__, __LINE__); Chunk *pc = Chunk::GetHead(); if (!pc->IsNewline()) { pc = pc->GetNextNl(); } Chunk *next; Chunk *prev; while (pc->IsNotNullChunk()) { // Remove all newlines not in preproc if (!pc->TestFlags(PCF_IN_PREPROC)) { next = pc->GetNext(); prev = pc->GetPrev(); newline_iarf(pc, IARF_REMOVE); if (next == Chunk::GetHead()) { pc = next; continue; } else if ( prev->IsNotNullChunk() && !prev->GetNext()->IsNewline()) { pc = prev; } } pc = pc->GetNextNl(); } } // newlines_remove_newlines void newlines_remove_disallowed() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); Chunk *next; while ((pc = pc->GetNextNl())->IsNotNullChunk()) { LOG_FMT(LBLANKD, "%s(%d): orig line is %zu, orig col is %zu, , nl is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetNlCount()); next = pc->GetNext(); if ( next->IsNotNullChunk() && !next->Is(CT_NEWLINE) && !can_increase_nl(pc)) { LOG_FMT(LBLANKD, "%s(%d): force to 1 orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); if (pc->GetNlCount() != 1) { pc->SetNlCount(1); MARK_CHANGE(); } } } } // newlines_remove_disallowed void newlines_cleanup_angles() { // Issue #1167 LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { char copy[1000]; LOG_FMT(LBLANK, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy)); if (pc->Is(CT_ANGLE_OPEN)) { newline_template(pc); } } } // newlines_cleanup_angles void newlines_cleanup_braces(bool first) { //prot_the_line(__func__, __LINE__, 15, 4); LOG_FUNC_ENTRY(); // Get the first token that's not an empty line: Chunk *pc = Chunk::GetHead(); if (pc->IsNewline()) { pc = pc->GetNextNcNnl(); } for ( ; pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { //prot_the_line(__func__, __LINE__, 15, 4); char copy[1000]; LOG_FMT(LBLANK, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy)); if ( pc->Is(CT_IF) || pc->Is(CT_CONSTEXPR)) { log_rule_B("nl_if_brace"); newlines_if_for_while_switch(pc, options::nl_if_brace()); } else if (pc->Is(CT_ELSEIF)) { log_rule_B("nl_elseif_brace"); iarf_e arg = options::nl_elseif_brace(); log_rule_B("nl_if_brace"); newlines_if_for_while_switch( pc, (arg != IARF_IGNORE) ? arg : options::nl_if_brace()); } else if (pc->Is(CT_FOR)) { log_rule_B("nl_for_brace"); newlines_if_for_while_switch(pc, options::nl_for_brace()); } else if (pc->Is(CT_CATCH)) { log_rule_B("nl_oc_brace_catch"); if ( language_is_set(LANG_OC) && (pc->GetStr()[0] == '@') && (options::nl_oc_brace_catch() != IARF_IGNORE)) { newlines_cuddle_uncuddle(pc, options::nl_oc_brace_catch()); } else { log_rule_B("nl_brace_catch"); newlines_cuddle_uncuddle(pc, options::nl_brace_catch()); } Chunk *next = pc->GetNextNcNnl(); if (next->Is(CT_BRACE_OPEN)) { log_rule_B("nl_oc_catch_brace"); if ( language_is_set(LANG_OC) && (options::nl_oc_catch_brace() != IARF_IGNORE)) { log_rule_B("nl_oc_catch_brace"); newlines_do_else(pc, options::nl_oc_catch_brace()); } else { log_rule_B("nl_catch_brace"); newlines_do_else(pc, options::nl_catch_brace()); } } else { log_rule_B("nl_oc_catch_brace"); if ( language_is_set(LANG_OC) && (options::nl_oc_catch_brace() != IARF_IGNORE)) { newlines_if_for_while_switch(pc, options::nl_oc_catch_brace()); } else { log_rule_B("nl_catch_brace"); newlines_if_for_while_switch(pc, options::nl_catch_brace()); } } } else if (pc->Is(CT_WHILE)) { log_rule_B("nl_while_brace"); newlines_if_for_while_switch(pc, options::nl_while_brace()); } else if (pc->Is(CT_USING_STMT)) { log_rule_B("nl_using_brace"); newlines_if_for_while_switch(pc, options::nl_using_brace()); } else if (pc->Is(CT_D_SCOPE_IF)) { log_rule_B("nl_scope_brace"); newlines_if_for_while_switch(pc, options::nl_scope_brace()); } else if (pc->Is(CT_UNITTEST)) { log_rule_B("nl_unittest_brace"); newlines_do_else(pc, options::nl_unittest_brace()); } else if (pc->Is(CT_D_VERSION_IF)) { log_rule_B("nl_version_brace"); newlines_if_for_while_switch(pc, options::nl_version_brace()); } else if (pc->Is(CT_SWITCH)) { log_rule_B("nl_switch_brace"); newlines_if_for_while_switch(pc, options::nl_switch_brace()); } else if (pc->Is(CT_SYNCHRONIZED)) { log_rule_B("nl_synchronized_brace"); newlines_if_for_while_switch(pc, options::nl_synchronized_brace()); } else if (pc->Is(CT_DO)) { log_rule_B("nl_do_brace"); newlines_do_else(pc, options::nl_do_brace()); } else if (pc->Is(CT_ELSE)) { log_rule_B("nl_brace_else"); newlines_cuddle_uncuddle(pc, options::nl_brace_else()); Chunk *next = pc->GetNextNcNnl(); if (next->Is(CT_ELSEIF)) { log_rule_B("nl_else_if"); newline_iarf_pair(pc, next, options::nl_else_if()); } log_rule_B("nl_else_brace"); newlines_do_else(pc, options::nl_else_brace()); } else if (pc->Is(CT_TRY)) { log_rule_B("nl_try_brace"); newlines_do_else(pc, options::nl_try_brace()); // Issue #1734 Chunk *po = pc->GetNextNcNnl(); flag_parens(po, PCF_IN_TRY_BLOCK, po->GetType(), CT_NONE, false); } else if (pc->Is(CT_GETSET)) { log_rule_B("nl_getset_brace"); newlines_do_else(pc, options::nl_getset_brace()); } else if (pc->Is(CT_FINALLY)) { log_rule_B("nl_brace_finally"); newlines_cuddle_uncuddle(pc, options::nl_brace_finally()); log_rule_B("nl_finally_brace"); newlines_do_else(pc, options::nl_finally_brace()); } else if (pc->Is(CT_WHILE_OF_DO)) { log_rule_B("nl_brace_while"); newlines_cuddle_uncuddle(pc, options::nl_brace_while()); } else if (pc->Is(CT_BRACE_OPEN)) { switch (pc->GetParentType()) { case CT_DOUBLE_BRACE: { log_rule_B("nl_paren_dbrace_open"); if (options::nl_paren_dbrace_open() != IARF_IGNORE) { Chunk *prev = pc->GetPrevNcNnlNi(E_Scope::PREPROC); // Issue #2279 if (prev->IsParenClose()) { log_rule_B("nl_paren_dbrace_open"); newline_iarf_pair(prev, pc, options::nl_paren_dbrace_open()); } } break; } case CT_ENUM: { log_rule_B("nl_enum_own_lines"); if (options::nl_enum_own_lines() != IARF_IGNORE) { newlines_enum_entries(pc, options::nl_enum_own_lines()); } log_rule_B("nl_ds_struct_enum_cmt"); if (options::nl_ds_struct_enum_cmt()) { newlines_double_space_struct_enum_union(pc); } break; } case CT_STRUCT: case CT_UNION: { log_rule_B("nl_ds_struct_enum_cmt"); if (options::nl_ds_struct_enum_cmt()) { newlines_double_space_struct_enum_union(pc); } break; } case CT_CLASS: { if (pc->GetLevel() == pc->GetBraceLevel()) { log_rule_B("nl_class_brace"); log_ruleNL("nl_class_brace", pc->GetPrevNnl()); newlines_do_else(pc->GetPrevNnl(), options::nl_class_brace()); } break; } case CT_OC_CLASS: { if (pc->GetLevel() == pc->GetBraceLevel()) { // Request #126 // introduce two new options // look back if we have a @interface or a @implementation for (Chunk *tmp = pc->GetPrev(); tmp->IsNotNullChunk(); tmp = tmp->GetPrev()) { LOG_FMT(LBLANK, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text()); if ( tmp->Is(CT_OC_INTF) || tmp->Is(CT_OC_IMPL)) { LOG_FMT(LBLANK, "%s(%d): orig line is %zu, orig col is %zu, may be remove/force newline before {\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); if (tmp->Is(CT_OC_INTF)) { log_rule_B("nl_oc_interface_brace"); newlines_do_else(pc->GetPrevNnl(), options::nl_oc_interface_brace()); } else { log_rule_B("nl_oc_implementation_brace"); newlines_do_else(pc->GetPrevNnl(), options::nl_oc_implementation_brace()); } break; } } } break; } case CT_BRACED_INIT_LIST: { // Issue #1052 log_rule_B("nl_create_list_one_liner"); if (options::nl_create_list_one_liner()) { nl_create_list_liner(pc); break; } Chunk *prev = pc->GetPrevNnl(); if ( prev->IsNotNullChunk() && ( prev->GetType() == CT_TYPE || prev->GetType() == CT_WORD || prev->GetType() == CT_ASSIGN // Issue #2957 || prev->GetParentType() == CT_TEMPLATE || prev->GetParentType() == CT_DECLTYPE)) { log_rule_B("nl_type_brace_init_lst"); newline_iarf_pair(prev, pc, options::nl_type_brace_init_lst(), true); } break; } case CT_OC_BLOCK_EXPR: { // issue # 477 log_rule_B("nl_oc_block_brace"); newline_iarf_pair(pc->GetPrev(), pc, options::nl_oc_block_brace()); break; } case CT_FUNC_CLASS_DEF: // Issue #2343 { if (!one_liner_nl_ok(pc)) { LOG_FMT(LNL1LINE, "a new line may NOT be added\n"); // no change - preserve one liner body } else { log_rule_B("nl_before_opening_brace_func_class_def"); if (options::nl_before_opening_brace_func_class_def() != IARF_IGNORE) { newline_iarf_pair(pc->GetPrev(), pc, options::nl_before_opening_brace_func_class_def()); } } } default: { break; } } // switch log_rule_B("nl_brace_brace"); if (options::nl_brace_brace() != IARF_IGNORE) { Chunk *next = pc->GetNextNc(E_Scope::PREPROC); if (next->Is(CT_BRACE_OPEN)) { newline_iarf_pair(pc, next, options::nl_brace_brace()); } } Chunk *next = pc->GetNextNnl(); if (next->IsNullChunk()) { // do nothing } else if (next->Is(CT_BRACE_CLOSE)) { // TODO: add an option to split open empty statements? { }; } else if (next->Is(CT_BRACE_OPEN)) { // already handled } else { next = pc->GetNextNcNnl(); // Handle unnamed temporary direct-list-initialization if (pc->GetParentType() == CT_BRACED_INIT_LIST) { log_rule_B("nl_type_brace_init_lst_open"); newline_iarf_pair(pc, pc->GetNextNnl(), options::nl_type_brace_init_lst_open(), true); } // Handle nl_after_brace_open else if ( ( pc->GetParentType() == CT_CPP_LAMBDA || pc->GetLevel() == pc->GetBraceLevel()) && options::nl_after_brace_open()) { log_rule_B("nl_after_brace_open"); if (!one_liner_nl_ok(pc)) { LOG_FMT(LNL1LINE, "a new line may NOT be added (nl_after_brace_open)\n"); // no change - preserve one liner body } else if ( pc->TestFlags(PCF_IN_ARRAY_ASSIGN) || pc->TestFlags(PCF_IN_PREPROC)) { // no change - don't break up array assignments or preprocessors } else { // Step back from next to the first non-newline item Chunk *tmp = next->GetPrev(); while (tmp != pc) { if (tmp->IsComment()) { log_rule_B("nl_after_brace_open_cmt"); if ( !options::nl_after_brace_open_cmt() && tmp->IsNot(CT_COMMENT_MULTI)) { break; } } tmp = tmp->GetPrev(); } // Add the newline newline_iarf(tmp, IARF_ADD); } } } // braced-init-list is more like a function call with arguments, // than curly braces that determine a structure of a source code, // so, don't add a newline before a closing brace. Issue #1405. log_rule_B("nl_type_brace_init_lst_open"); log_rule_B("nl_type_brace_init_lst_close"); if (!( pc->GetParentType() == CT_BRACED_INIT_LIST && options::nl_type_brace_init_lst_open() == IARF_IGNORE && options::nl_type_brace_init_lst_close() == IARF_IGNORE)) { newlines_brace_pair(pc); } // Handle nl_before_brace_open if ( pc->Is(CT_BRACE_OPEN) && pc->GetLevel() == pc->GetBraceLevel() && options::nl_before_brace_open()) { log_rule_B("nl_before_brace_open"); if (!one_liner_nl_ok(pc)) { LOG_FMT(LNL1LINE, "a new line may NOT be added (nl_before_brace_open)\n"); // no change - preserve one liner body } else if ( pc->TestFlags(PCF_IN_PREPROC) || pc->TestFlags(PCF_IN_ARRAY_ASSIGN)) { // no change - don't break up array assignments or preprocessors } else { // Step back to previous non-newline item Chunk *tmp = pc->GetPrev(); if (!tmp->Is(CT_NEWLINE)) { newline_iarf(tmp, IARF_ADD); } } } } else if (pc->Is(CT_BRACE_CLOSE)) { // newline between a close brace and x log_rule_B("nl_brace_brace"); if (options::nl_brace_brace() != IARF_IGNORE) { Chunk *next = pc->GetNextNc(E_Scope::PREPROC); if (next->Is(CT_BRACE_CLOSE)) { log_rule_B("nl_brace_brace"); newline_iarf_pair(pc, next, options::nl_brace_brace()); } } log_rule_B("nl_brace_square"); if (options::nl_brace_square() != IARF_IGNORE) { Chunk *next = pc->GetNextNc(E_Scope::PREPROC); if (next->Is(CT_SQUARE_CLOSE)) { log_rule_B("nl_brace_square"); newline_iarf_pair(pc, next, options::nl_brace_square()); } } log_rule_B("nl_brace_fparen"); if (options::nl_brace_fparen() != IARF_IGNORE) { Chunk *next = pc->GetNextNc(E_Scope::PREPROC); log_rule_B("nl_brace_fparen"); if ( next->Is(CT_NEWLINE) && (options::nl_brace_fparen() == IARF_REMOVE)) { next = next->GetNextNc(E_Scope::PREPROC); // Issue #1000 } if (next->Is(CT_FPAREN_CLOSE)) { log_rule_B("nl_brace_fparen"); newline_iarf_pair(pc, next, options::nl_brace_fparen()); } } // newline before a close brace log_rule_B("nl_type_brace_init_lst_close"); if ( pc->GetParentType() == CT_BRACED_INIT_LIST && options::nl_type_brace_init_lst_close() != IARF_IGNORE) { // Handle unnamed temporary direct-list-initialization newline_iarf_pair(pc->GetPrevNnl(), pc, options::nl_type_brace_init_lst_close(), true); } // blanks before a close brace log_rule_B("eat_blanks_before_close_brace"); if (options::eat_blanks_before_close_brace()) { // Limit the newlines before the close brace to 1 Chunk *prev = pc->GetPrev(); if (prev->IsNewline()) { log_rule_B("nl_inside_namespace"); log_rule_B("nl_inside_empty_func"); if ( options::nl_inside_empty_func() > 0 && pc->GetPrevNnl()->Is(CT_BRACE_OPEN) && ( pc->GetParentType() == CT_FUNC_CLASS_DEF || pc->GetParentType() == CT_FUNC_DEF)) { blank_line_set(prev, options::nl_inside_empty_func); } else if ( options::nl_inside_namespace() > 0 && pc->GetParentType() == CT_NAMESPACE) { blank_line_set(prev, options::nl_inside_namespace); } else if (prev->GetNlCount() != 1) { prev->SetNlCount(1); LOG_FMT(LBLANKD, "%s(%d): eat_blanks_before_close_brace %zu\n", __func__, __LINE__, prev->GetOrigLine()); MARK_CHANGE(); } } } else if ( options::nl_ds_struct_enum_close_brace() && ( pc->GetParentType() == CT_ENUM || pc->GetParentType() == CT_STRUCT || pc->GetParentType() == CT_UNION)) { log_rule_B("nl_ds_struct_enum_close_brace"); if (!pc->TestFlags(PCF_ONE_LINER)) { // Make sure the brace is preceded by two newlines Chunk *prev = pc->GetPrev(); if (!prev->IsNewline()) { prev = newline_add_before(pc); } if (prev->GetNlCount() < 2) { double_newline(prev); } } } // Force a newline after a close brace log_rule_B("nl_brace_struct_var"); if ( (options::nl_brace_struct_var() != IARF_IGNORE) && ( pc->GetParentType() == CT_STRUCT || pc->GetParentType() == CT_ENUM || pc->GetParentType() == CT_UNION)) { Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); if ( next->IsNot(CT_SEMICOLON) && next->IsNot(CT_COMMA)) { log_rule_B("nl_brace_struct_var"); newline_iarf(pc, options::nl_brace_struct_var()); } } else if ( pc->GetParentType() != CT_OC_AT && pc->GetParentType() != CT_BRACED_INIT_LIST && ( options::nl_after_brace_close() || pc->GetParentType() == CT_FUNC_CLASS_DEF || pc->GetParentType() == CT_FUNC_DEF || pc->GetParentType() == CT_OC_MSG_DECL)) { log_rule_B("nl_after_brace_close"); Chunk *next = pc->GetNext(); if ( next->IsNot(CT_SEMICOLON) && next->IsNot(CT_COMMA) && next->IsNot(CT_SPAREN_CLOSE) // Issue #664 && next->IsNot(CT_SQUARE_CLOSE) && next->IsNot(CT_FPAREN_CLOSE) && next->IsNot(CT_PAREN_CLOSE) && next->IsNot(CT_WHILE_OF_DO) && next->IsNot(CT_VBRACE_CLOSE) // Issue #666 && ( next->IsNot(CT_BRACE_CLOSE) || !next->TestFlags(PCF_ONE_LINER)) // #1258 && !pc->TestFlags(PCF_IN_ARRAY_ASSIGN) && !pc->TestFlags(PCF_IN_TYPEDEF) && !next->IsCommentOrNewline() && next->IsNotNullChunk()) { // #1258 // dont add newline between two consecutive braces closes, if the second is a part of one liner. newline_end_newline(pc); } } else if (pc->GetParentType() == CT_NAMESPACE) { log_rule_B("nl_after_namespace"); if (options::nl_after_namespace() > 0) { Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); if (next->IsNotNullChunk()) { newline_add_before(next); // newline_iarf(next, IARF_ADD); } } } } else if (pc->Is(CT_VBRACE_OPEN)) { log_rule_B("nl_after_vbrace_open"); log_rule_B("nl_after_vbrace_open_empty"); if ( options::nl_after_vbrace_open() || options::nl_after_vbrace_open_empty()) { Chunk *next = pc->GetNext(E_Scope::PREPROC); bool add_it; if (next->IsSemicolon()) { log_rule_B("nl_after_vbrace_open_empty"); add_it = options::nl_after_vbrace_open_empty(); } else { log_rule_B("nl_after_vbrace_open"); add_it = ( options::nl_after_vbrace_open() && next->IsNot(CT_VBRACE_CLOSE) && !next->IsCommentOrNewline()); } if (add_it) { newline_iarf(pc, IARF_ADD); } } log_rule_B("nl_create_if_one_liner"); log_rule_B("nl_create_for_one_liner"); log_rule_B("nl_create_while_one_liner"); if ( ( ( pc->GetParentType() == CT_IF || pc->GetParentType() == CT_ELSEIF || pc->GetParentType() == CT_ELSE) && options::nl_create_if_one_liner()) || ( pc->GetParentType() == CT_FOR && options::nl_create_for_one_liner()) || ( pc->GetParentType() == CT_WHILE && options::nl_create_while_one_liner())) { nl_create_one_liner(pc); } log_rule_B("nl_split_if_one_liner"); log_rule_B("nl_split_for_one_liner"); log_rule_B("nl_split_while_one_liner"); if ( ( ( pc->GetParentType() == CT_IF || pc->GetParentType() == CT_ELSEIF || pc->GetParentType() == CT_ELSE) && options::nl_split_if_one_liner()) || ( pc->GetParentType() == CT_FOR && options::nl_split_for_one_liner()) || ( pc->GetParentType() == CT_WHILE && options::nl_split_while_one_liner())) { if (pc->TestFlags(PCF_ONE_LINER)) { // split one-liner Chunk *end = pc->GetNext()->GetNextType(CT_SEMICOLON)->GetNext(); // Scan for clear flag LOG_FMT(LNEWLINE, "(%d) ", __LINE__); LOG_FMT(LNEWLINE, "\n"); for (Chunk *temp = pc; temp != end; temp = temp->GetNext()) { LOG_FMT(LNEWLINE, "%s(%d): Text() is '%s', type is %s, level is %zu\n", __func__, __LINE__, temp->Text(), get_token_name(temp->GetType()), temp->GetLevel()); // produces much more log output. Use it only debugging purpose //log_pcf_flags(LNEWLINE, temp->GetFlags()); temp->ResetFlagBits(PCF_ONE_LINER); } // split newline_add_between(pc, pc->GetNext()); } } } else if (pc->Is(CT_VBRACE_CLOSE)) { log_rule_B("nl_after_vbrace_close"); if (options::nl_after_vbrace_close()) { if (!pc->GetNextNc()->IsNewline()) { newline_iarf(pc, IARF_ADD); } } } else if ( pc->Is(CT_SQUARE_OPEN) && pc->GetParentType() == CT_OC_MSG) { log_rule_B("nl_oc_msg_args"); if (options::nl_oc_msg_args()) { newline_oc_msg(pc); } } else if (pc->Is(CT_STRUCT)) { log_rule_B("nl_struct_brace"); newlines_struct_union(pc, options::nl_struct_brace(), true); } else if (pc->Is(CT_UNION)) { log_rule_B("nl_union_brace"); newlines_struct_union(pc, options::nl_union_brace(), true); } else if (pc->Is(CT_ENUM)) { newlines_enum(pc); } else if (pc->Is(CT_CASE)) { // Note: 'default' also maps to CT_CASE log_rule_B("nl_before_case"); if (options::nl_before_case()) { newline_case(pc); } } else if (pc->Is(CT_THROW)) { Chunk *prev = pc->GetPrev(); if ( prev->Is(CT_PAREN_CLOSE) || prev->Is(CT_FPAREN_CLOSE)) // Issue #1122 { log_rule_B("nl_before_throw"); newline_iarf(pc->GetPrevNcNnlNi(), options::nl_before_throw()); // Issue #2279 } } else if ( pc->Is(CT_QUALIFIER) && !strcmp(pc->Text(), "throws")) { Chunk *prev = pc->GetPrev(); if ( prev->Is(CT_PAREN_CLOSE) || prev->Is(CT_FPAREN_CLOSE)) // Issue #1122 { log_rule_B("nl_before_throw"); newline_iarf(pc->GetPrevNcNnlNi(), options::nl_before_throw()); // Issue #2279 } } else if (pc->Is(CT_CASE_COLON)) { Chunk *next = pc->GetNextNnl(); log_rule_B("nl_case_colon_brace"); if ( next->Is(CT_BRACE_OPEN) && options::nl_case_colon_brace() != IARF_IGNORE) { newline_iarf(pc, options::nl_case_colon_brace()); } else if (options::nl_after_case()) { log_rule_B("nl_after_case"); newline_case_colon(pc); } } else if (pc->Is(CT_SPAREN_CLOSE)) { Chunk *next = pc->GetNextNcNnl(); if (next->Is(CT_BRACE_OPEN)) { /* * TODO: this could be used to control newlines between the * the if/while/for/switch close parenthesis and the open brace, but * that is currently handled elsewhere. */ } } else if (pc->Is(CT_RETURN)) { log_rule_B("nl_before_return"); if (options::nl_before_return()) { newline_before_return(pc); } log_rule_B("nl_after_return"); if (options::nl_after_return()) { newline_after_return(pc); } } else if (pc->Is(CT_SEMICOLON)) { log_rule_B("nl_after_semicolon"); log_rule_NL("nl_after_semicolon"); if ( !pc->TestFlags(PCF_IN_SPAREN) && !pc->TestFlags(PCF_IN_PREPROC) && options::nl_after_semicolon()) { Chunk *next = pc->GetNext(); while (next->Is(CT_VBRACE_CLOSE)) { next = next->GetNext(); } if ( next->IsNotNullChunk() && !next->IsCommentOrNewline()) { if (one_liner_nl_ok(next)) { LOG_FMT(LNL1LINE, "%s(%d): a new line may be added\n", __func__, __LINE__); newline_iarf(pc, IARF_ADD); } else { LOG_FMT(LNL1LINE, "%s(%d): a new line may NOT be added\n", __func__, __LINE__); } } } else if (pc->GetParentType() == CT_CLASS) { log_rule_B("nl_after_class"); if (options::nl_after_class() > 0) { /* * If there is already a "class" comment, then don't add a newline if * one exists after the comment. or else this will interfere with the * mod_add_long_class_closebrace_comment option. */ iarf_e mode = IARF_ADD; Chunk *next = pc->GetNext(); if (next->IsComment()) { pc = next; next = pc->GetNext(); if (next->IsNewline()) { mode = IARF_IGNORE; } } newline_iarf(pc, mode); } } } else if (pc->Is(CT_FPAREN_OPEN)) { log_rule_B("nl_func_decl_start"); log_rule_B("nl_func_def_start"); log_rule_B("nl_func_decl_start_single"); log_rule_B("nl_func_def_start_single"); log_rule_B("nl_func_decl_start_multi_line"); log_rule_B("nl_func_def_start_multi_line"); log_rule_B("nl_func_decl_args"); log_rule_B("nl_func_def_args"); log_rule_B("nl_func_decl_args_multi_line"); log_rule_B("nl_func_def_args_multi_line"); log_rule_B("nl_func_decl_end"); log_rule_B("nl_func_def_end"); log_rule_B("nl_func_decl_end_single"); log_rule_B("nl_func_def_end_single"); log_rule_B("nl_func_decl_end_multi_line"); log_rule_B("nl_func_def_end_multi_line"); log_rule_B("nl_func_decl_empty"); log_rule_B("nl_func_def_empty"); log_rule_B("nl_func_type_name"); log_rule_B("nl_func_type_name_class"); log_rule_B("nl_func_class_scope"); log_rule_B("nl_func_scope_name"); log_rule_B("nl_func_proto_type_name"); log_rule_B("nl_func_paren"); log_rule_B("nl_func_def_paren"); log_rule_B("nl_func_def_paren_empty"); log_rule_B("nl_func_paren_empty"); if ( ( pc->GetParentType() == CT_FUNC_DEF || pc->GetParentType() == CT_FUNC_PROTO || pc->GetParentType() == CT_FUNC_CLASS_DEF || pc->GetParentType() == CT_FUNC_CLASS_PROTO || pc->GetParentType() == CT_OPERATOR) && ( options::nl_func_decl_start() != IARF_IGNORE || options::nl_func_def_start() != IARF_IGNORE || options::nl_func_decl_start_single() != IARF_IGNORE || options::nl_func_def_start_single() != IARF_IGNORE || options::nl_func_decl_start_multi_line() || options::nl_func_def_start_multi_line() || options::nl_func_decl_args() != IARF_IGNORE || options::nl_func_def_args() != IARF_IGNORE || options::nl_func_decl_args_multi_line() || options::nl_func_def_args_multi_line() || options::nl_func_decl_end() != IARF_IGNORE || options::nl_func_def_end() != IARF_IGNORE || options::nl_func_decl_end_single() != IARF_IGNORE || options::nl_func_def_end_single() != IARF_IGNORE || options::nl_func_decl_end_multi_line() || options::nl_func_def_end_multi_line() || options::nl_func_decl_empty() != IARF_IGNORE || options::nl_func_def_empty() != IARF_IGNORE || options::nl_func_type_name() != IARF_IGNORE || options::nl_func_type_name_class() != IARF_IGNORE || options::nl_func_class_scope() != IARF_IGNORE || options::nl_func_scope_name() != IARF_IGNORE || options::nl_func_proto_type_name() != IARF_IGNORE || options::nl_func_paren() != IARF_IGNORE || options::nl_func_def_paren() != IARF_IGNORE || options::nl_func_def_paren_empty() != IARF_IGNORE || options::nl_func_paren_empty() != IARF_IGNORE)) { newline_func_def_or_call(pc); } else if ( ( pc->GetParentType() == CT_FUNC_CALL || pc->GetParentType() == CT_FUNC_CALL_USER) && ( (options::nl_func_call_start_multi_line()) || (options::nl_func_call_args_multi_line()) || (options::nl_func_call_end_multi_line()) || (options::nl_func_call_start() != IARF_IGNORE) // Issue #2020 || (options::nl_func_call_args() != IARF_IGNORE) // Issue #2604 || (options::nl_func_call_paren() != IARF_IGNORE) || (options::nl_func_call_paren_empty() != IARF_IGNORE) || (options::nl_func_call_empty() != IARF_IGNORE))) { log_rule_B("nl_func_call_start_multi_line"); log_rule_B("nl_func_call_args_multi_line"); log_rule_B("nl_func_call_end_multi_line"); log_rule_B("nl_func_call_start"); log_rule_B("nl_func_call_args"); log_rule_B("nl_func_call_paren"); log_rule_B("nl_func_call_paren_empty"); log_rule_B("nl_func_call_empty"); if (options::nl_func_call_start() != IARF_IGNORE) { newline_iarf(pc, options::nl_func_call_start()); } // note that newline_func_def_or_call() calls newline_func_multi_line() newline_func_def_or_call(pc); } else if ( first && (options::nl_remove_extra_newlines() == 1)) { log_rule_B("nl_remove_extra_newlines"); newline_iarf(pc, IARF_REMOVE); } } else if (pc->Is(CT_FPAREN_CLOSE)) // Issue #2758 { if ( ( pc->GetParentType() == CT_FUNC_CALL || pc->GetParentType() == CT_FUNC_CALL_USER) && options::nl_func_call_end() != IARF_IGNORE) { log_rule_B("nl_func_call_end"); newline_iarf(pc->GetPrev(), options::nl_func_call_end()); } } else if (pc->Is(CT_ANGLE_CLOSE)) { if (pc->GetParentType() == CT_TEMPLATE) { Chunk *next = pc->GetNextNcNnl(); if ( next->IsNotNullChunk() && next->GetLevel() == next->GetBraceLevel()) { Chunk *tmp = pc->GetPrevType(CT_ANGLE_OPEN, pc->GetLevel())->GetPrevNcNnlNi(); // Issue #2279 if (tmp->Is(CT_TEMPLATE)) { if (next->Is(CT_USING)) { newline_iarf(pc, options::nl_template_using()); log_rule_B("nl_template_using"); } else if (next->GetParentType() == CT_FUNC_DEF) // function definition { iarf_e const action = newline_template_option( pc, options::nl_template_func_def_special(), options::nl_template_func_def(), options::nl_template_func()); log_rule_B("nl_template_func_def_special"); log_rule_B("nl_template_func_def"); log_rule_B("nl_template_func"); newline_iarf(pc, action); } else if (next->GetParentType() == CT_FUNC_PROTO) // function declaration { iarf_e const action = newline_template_option( pc, options::nl_template_func_decl_special(), options::nl_template_func_decl(), options::nl_template_func()); log_rule_B("nl_template_func_decl_special"); log_rule_B("nl_template_func_decl"); log_rule_B("nl_template_func"); newline_iarf(pc, action); } else if ( next->Is(CT_TYPE) || next->Is(CT_QUALIFIER)) // variable { newline_iarf(pc, options::nl_template_var()); log_rule_B("nl_template_var"); } else if (next->TestFlags(PCF_INCOMPLETE)) // class declaration { iarf_e const action = newline_template_option( pc, options::nl_template_class_decl_special(), options::nl_template_class_decl(), options::nl_template_class()); log_rule_B("nl_template_class_decl_special"); log_rule_B("nl_template_class_decl"); log_rule_B("nl_template_class"); newline_iarf(pc, action); } else // class definition { iarf_e const action = newline_template_option( pc, options::nl_template_class_def_special(), options::nl_template_class_def(), options::nl_template_class()); log_rule_B("nl_template_class_def_special"); log_rule_B("nl_template_class_def"); log_rule_B("nl_template_class"); newline_iarf(pc, action); } } } } } else if ( pc->Is(CT_NAMESPACE) && pc->GetParentType() != CT_USING) { // Issue #2387 Chunk *next = pc->GetNextNcNnl(); if (next->IsNotNullChunk()) { next = next->GetNextNcNnl(); if (!next->Is(CT_ASSIGN)) { // Issue #1235 // Issue #2186 Chunk *braceOpen = pc->GetNextType(CT_BRACE_OPEN, pc->GetLevel()); if (braceOpen->IsNullChunk()) { // fatal error LOG_FMT(LERR, "%s(%d): Missing BRACE_OPEN after namespace\n orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); exit(EXIT_FAILURE); } LOG_FMT(LNEWLINE, "%s(%d): braceOpen orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, braceOpen->GetOrigLine(), braceOpen->GetOrigCol(), braceOpen->Text()); // produces much more log output. Use it only debugging purpose //log_pcf_flags(LNEWLINE, braceOpen->GetFlags()); newlines_namespace(pc); } } } else if (pc->Is(CT_SQUARE_OPEN)) { if ( pc->GetParentType() == CT_ASSIGN && !pc->TestFlags(PCF_ONE_LINER)) { Chunk *tmp = pc->GetPrevNcNnlNi(); // Issue #2279 newline_iarf(tmp, options::nl_assign_square()); log_rule_B("nl_assign_square"); iarf_e arg = options::nl_after_square_assign(); log_rule_B("nl_after_square_assign"); if (options::nl_assign_square() & IARF_ADD) { log_rule_B("nl_assign_square"); arg = IARF_ADD; } newline_iarf(pc, arg); /* * if there is a newline after the open, then force a newline * before the close */ tmp = pc->GetNextNc(); if (tmp->IsNewline()) { tmp = pc->GetNextType(CT_SQUARE_CLOSE, pc->GetLevel()); if (tmp->IsNotNullChunk()) { newline_add_before(tmp); } } } } else if (pc->Is(CT_ACCESS)) { // Make sure there is a newline before an access spec if (options::nl_before_access_spec() > 0) { log_rule_B("nl_before_access_spec"); Chunk *prev = pc->GetPrev(); if (!prev->IsNewline()) { newline_add_before(pc); } } } else if (pc->Is(CT_ACCESS_COLON)) { // Make sure there is a newline after an access spec if (options::nl_after_access_spec() > 0) { log_rule_B("nl_after_access_spec"); Chunk *next = pc->GetNext(); if (!next->IsNewline()) { newline_add_before(next); } } } else if (pc->Is(CT_PP_DEFINE)) { if (options::nl_multi_line_define()) { log_rule_B("nl_multi_line_define"); nl_handle_define(pc); } } else if ( first && (options::nl_remove_extra_newlines() == 1) && !pc->TestFlags(PCF_IN_PREPROC)) { log_rule_B("nl_remove_extra_newlines"); log_rule_NL("nl_remove_extra_newlines"); newline_iarf(pc, IARF_REMOVE); } else if ( pc->Is(CT_MEMBER) && ( language_is_set(LANG_JAVA) || language_is_set(LANG_CPP))) // Issue #2574 { // Issue #1124 if (pc->GetParentType() != CT_FUNC_DEF) { newline_iarf(pc->GetPrevNnl(), options::nl_before_member()); log_rule_B("nl_before_member"); newline_iarf(pc, options::nl_after_member()); log_rule_B("nl_after_member"); } } else { // ignore it } } //prot_the_line(__func__, __LINE__, 15, 4); newline_var_def_blk(Chunk::GetHead()); //prot_the_line(__func__, __LINE__, 15, 4); } // newlines_cleanup_braces static void nl_handle_define(Chunk *pc) { LOG_FUNC_ENTRY(); Chunk *nl = pc; Chunk *ref = Chunk::NullChunkPtr; while ((nl = nl->GetNext())->IsNotNullChunk()) { if (nl->Is(CT_NEWLINE)) { return; } if ( nl->Is(CT_MACRO) || ( nl->Is(CT_FPAREN_CLOSE) && nl->GetParentType() == CT_MACRO_FUNC)) { ref = nl; } if (nl->Is(CT_NL_CONT)) { if (ref->IsNotNullChunk()) { newline_add_after(ref); } return; } } } // nl_handle_define void newline_after_multiline_comment() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->IsNot(CT_COMMENT_MULTI)) { continue; } Chunk *tmp = pc; while ( ((tmp = tmp->GetNext())->IsNotNullChunk()) && !tmp->IsNewline()) { if (!tmp->IsComment()) { newline_add_before(tmp); break; } } } } // newline_after_multiline_comment void newline_after_label_colon() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->IsNot(CT_LABEL_COLON)) { continue; } newline_add_after(pc); } } // newline_after_label_colon static bool is_class_one_liner(Chunk *pc) { if ( ( pc->Is(CT_FUNC_CLASS_DEF) || pc->Is(CT_FUNC_DEF)) && pc->TestFlags(PCF_IN_CLASS)) { // Find opening brace pc = pc->GetNextType(CT_BRACE_OPEN, pc->GetLevel()); return( pc->IsNotNullChunk() && pc->TestFlags(PCF_ONE_LINER)); } return(false); } // is_class_one_liner void newlines_insert_blank_lines() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { //LOG_FMT(LNEWLINE, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", // __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); if (pc->Is(CT_IF)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_before_if()); log_rule_B("nl_before_if"); newlines_if_for_while_switch_post_blank_lines(pc, options::nl_after_if()); log_rule_B("nl_after_if"); } else if (pc->Is(CT_FOR)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_before_for()); log_rule_B("nl_before_for"); newlines_if_for_while_switch_post_blank_lines(pc, options::nl_after_for()); log_rule_B("nl_after_for"); } else if (pc->Is(CT_WHILE)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_before_while()); log_rule_B("nl_before_while"); newlines_if_for_while_switch_post_blank_lines(pc, options::nl_after_while()); log_rule_B("nl_after_while"); } else if (pc->Is(CT_SWITCH)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_before_switch()); log_rule_B("nl_before_switch"); newlines_if_for_while_switch_post_blank_lines(pc, options::nl_after_switch()); log_rule_B("nl_after_switch"); } else if (pc->Is(CT_SYNCHRONIZED)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_before_synchronized()); log_rule_B("nl_before_synchronized"); newlines_if_for_while_switch_post_blank_lines(pc, options::nl_after_synchronized()); log_rule_B("nl_after_synchronized"); } else if (pc->Is(CT_DO)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_before_do()); log_rule_B("nl_before_do"); newlines_if_for_while_switch_post_blank_lines(pc, options::nl_after_do()); log_rule_B("nl_after_do"); } else if (pc->Is(CT_OC_INTF)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_oc_before_interface()); log_rule_B("nl_oc_before_interface"); } else if (pc->Is(CT_OC_END)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_oc_before_end()); log_rule_B("nl_oc_before_end"); } else if (pc->Is(CT_OC_IMPL)) { newlines_if_for_while_switch_pre_blank_lines(pc, options::nl_oc_before_implementation()); log_rule_B("nl_oc_before_implementation"); } else if ( pc->Is(CT_FUNC_CLASS_DEF) || pc->Is(CT_FUNC_DEF) || pc->Is(CT_FUNC_CLASS_PROTO) || pc->Is(CT_FUNC_PROTO)) { if ( options::nl_class_leave_one_liner_groups() && is_class_one_liner(pc)) { log_rule_B("nl_class_leave_one_liner_groups"); newlines_func_pre_blank_lines(pc, CT_FUNC_PROTO); } else { newlines_func_pre_blank_lines(pc, pc->GetType()); } } else { // ignore it //LOG_FMT(LNEWLINE, "%s(%d): ignore it\n", __func__, __LINE__); } } } // newlines_insert_blank_lines void newlines_functions_remove_extra_blank_lines() { LOG_FUNC_ENTRY(); const size_t nl_max_blank_in_func = options::nl_max_blank_in_func(); log_rule_B("nl_max_blank_in_func"); if (nl_max_blank_in_func == 0) { LOG_FMT(LNEWLINE, "%s(%d): nl_max_blank_in_func is zero\n", __func__, __LINE__); return; } for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { LOG_FMT(LNEWLINE, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); if ( pc->IsNot(CT_BRACE_OPEN) || ( pc->GetParentType() != CT_FUNC_DEF && pc->GetParentType() != CT_CPP_LAMBDA)) { continue; } const size_t startMoveLevel = pc->GetLevel(); while (pc->IsNotNullChunk()) { if ( pc->Is(CT_BRACE_CLOSE) && pc->GetLevel() == startMoveLevel) { break; } // delete newlines if ( !pc->Is(CT_COMMENT_MULTI) // Issue #2195 && pc->GetNlCount() > nl_max_blank_in_func) { LOG_FMT(LNEWLINE, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); pc->SetNlCount(nl_max_blank_in_func); MARK_CHANGE(); remove_next_newlines(pc); } else { pc = pc->GetNext(); } } } } // newlines_functions_remove_extra_blank_lines void newlines_squeeze_ifdef() { LOG_FUNC_ENTRY(); Chunk *pc; for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if ( pc->Is(CT_PREPROC) && ( pc->GetLevel() > 0 || options::nl_squeeze_ifdef_top_level())) { log_rule_B("nl_squeeze_ifdef_top_level"); Chunk *ppr = pc->GetNext(); if ( ppr->Is(CT_PP_IF) || ppr->Is(CT_PP_ELSE) || ppr->Is(CT_PP_ENDIF)) { Chunk *pnl = Chunk::NullChunkPtr; Chunk *nnl = ppr->GetNextNl(); if ( ppr->Is(CT_PP_ELSE) || ppr->Is(CT_PP_ENDIF)) { pnl = pc->GetPrevNl(); } Chunk *tmp1; Chunk *tmp2; if (nnl->IsNotNullChunk()) { if (pnl->IsNotNullChunk()) { if (pnl->GetNlCount() > 1) { pnl->SetNlCount(1); MARK_CHANGE(); tmp1 = pnl->GetPrevNnl(); tmp2 = nnl->GetPrevNnl(); LOG_FMT(LNEWLINE, "%s(%d): moved from after line %zu to after %zu\n", __func__, __LINE__, tmp1->GetOrigLine(), tmp2->GetOrigLine()); } } if ( ppr->Is(CT_PP_IF) || ppr->Is(CT_PP_ELSE)) { if (nnl->GetNlCount() > 1) { tmp1 = nnl->GetPrevNnl(); LOG_FMT(LNEWLINE, "%s(%d): trimmed newlines after line %zu from %zu\n", __func__, __LINE__, tmp1->GetOrigLine(), nnl->GetNlCount()); nnl->SetNlCount(1); MARK_CHANGE(); } } } } } } } // newlines_squeeze_ifdef void newlines_squeeze_paren_close() { LOG_FUNC_ENTRY(); Chunk *pc; for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { Chunk *next; Chunk *prev; if (pc->Is(CT_NEWLINE)) { prev = pc->GetPrev(); } else { prev = pc; } next = pc->GetNext(); if ( next->IsNotNullChunk() && prev->IsNotNullChunk() && next->IsParenClose() && prev->IsParenClose()) { Chunk *prev_op = prev->GetOpeningParen(); Chunk *next_op = next->GetOpeningParen(); bool flag = true; Chunk *tmp = prev; while (tmp->IsParenClose()) { tmp = tmp->GetPrev(); } if (tmp->IsNot(CT_NEWLINE)) { flag = false; } if (flag) { if (next_op->IsOnSameLine(prev_op)) { if (pc->Is(CT_NEWLINE)) { pc = next; } newline_del_between(prev, next); } else { newline_add_between(prev, next); } } } } } // newlines_squeeze_paren_close void newlines_eat_start_end() { LOG_FUNC_ENTRY(); Chunk *pc; // Process newlines at the start of the file if ( cpd.frag_cols == 0 && ( (options::nl_start_of_file() & IARF_REMOVE) || ( (options::nl_start_of_file() & IARF_ADD) && (options::nl_start_of_file_min() > 0)))) { log_rule_B("nl_start_of_file"); log_rule_B("nl_start_of_file_min"); pc = Chunk::GetHead(); if (pc->IsNotNullChunk()) { if (pc->Is(CT_NEWLINE)) { if (options::nl_start_of_file() == IARF_REMOVE) { log_rule_B("nl_start_of_file"); LOG_FMT(LBLANKD, "%s(%d): eat_blanks_start_of_file %zu\n", __func__, __LINE__, pc->GetOrigLine()); Chunk::Delete(pc); MARK_CHANGE(); } else if ( options::nl_start_of_file() == IARF_FORCE || (pc->GetNlCount() < options::nl_start_of_file_min())) { log_rule_B("nl_start_of_file"); LOG_FMT(LBLANKD, "%s(%d): set_blanks_start_of_file %zu\n", __func__, __LINE__, pc->GetOrigLine()); pc->SetNlCount(options::nl_start_of_file_min()); log_rule_B("nl_start_of_file_min"); MARK_CHANGE(); } } else if ( (options::nl_start_of_file() & IARF_ADD) && (options::nl_start_of_file_min() > 0)) { log_rule_B("nl_start_of_file"); log_rule_B("nl_start_of_file_min"); Chunk chunk; chunk.SetType(CT_NEWLINE); chunk.SetOrigLine(pc->GetOrigLine()); chunk.SetOrigCol(pc->GetOrigCol()); chunk.SetPpLevel(pc->GetPpLevel()); chunk.SetNlCount(options::nl_start_of_file_min()); log_rule_B("nl_start_of_file_min"); chunk.CopyAndAddBefore(pc); LOG_FMT(LNEWLINE, "%s(%d): %zu:%zu add newline before '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); MARK_CHANGE(); } } } // Process newlines at the end of the file if ( cpd.frag_cols == 0 && ( (options::nl_end_of_file() & IARF_REMOVE) || ( (options::nl_end_of_file() & IARF_ADD) && (options::nl_end_of_file_min() > 0)))) { log_rule_B("nl_end_of_file"); log_rule_B("nl_end_of_file_min"); pc = Chunk::GetTail(); if (pc->IsNotNullChunk()) { if (pc->Is(CT_NEWLINE)) { if (options::nl_end_of_file() == IARF_REMOVE) { log_rule_B("nl_end_of_file"); LOG_FMT(LBLANKD, "%s(%d): eat_blanks_end_of_file %zu\n", __func__, __LINE__, pc->GetOrigLine()); Chunk::Delete(pc); MARK_CHANGE(); } else if ( options::nl_end_of_file() == IARF_FORCE || (pc->GetNlCount() < options::nl_end_of_file_min())) { log_rule_B("nl_end_of_file"); log_rule_B("nl_end_of_file_min"); if (pc->GetNlCount() != options::nl_end_of_file_min()) { log_rule_B("nl_end_of_file_min"); LOG_FMT(LBLANKD, "%s(%d): set_blanks_end_of_file %zu\n", __func__, __LINE__, pc->GetOrigLine()); pc->SetNlCount(options::nl_end_of_file_min()); log_rule_B("nl_end_of_file_min"); MARK_CHANGE(); } } } else if ( (options::nl_end_of_file() & IARF_ADD) && (options::nl_end_of_file_min() > 0)) { log_rule_B("nl_end_of_file"); log_rule_B("nl_end_of_file_min"); Chunk chunk; chunk.SetType(CT_NEWLINE); chunk.SetOrigLine(pc->GetOrigLine()); chunk.SetOrigCol(pc->GetOrigCol()); chunk.SetPpLevel(pc->GetPpLevel()); chunk.SetNlCount(options::nl_end_of_file_min()); log_rule_B("nl_end_of_file_min"); chunk.CopyAndAddBefore(Chunk::NullChunkPtr); LOG_FMT(LNEWLINE, "%s(%d): %zu:%zu add newline after '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); MARK_CHANGE(); } } } } // newlines_eat_start_end void newlines_chunk_pos(E_Token chunk_type, token_pos_e mode) { LOG_FUNC_ENTRY(); LOG_FMT(LNEWLINE, "%s(%d): mode is %s\n", __func__, __LINE__, to_string(mode)); if ( !(mode & (TP_JOIN | TP_LEAD | TP_TRAIL)) && chunk_type != CT_COMMA) { return; } for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { char copy[1000]; LOG_FMT(LNEWLINE, "%s(%d): pc orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy)); // produces much more log output. Use it only debugging purpose //log_pcf_flags(LNEWLINE, pc->GetFlags()); if (pc->Is(chunk_type)) { token_pos_e mode_local; if (chunk_type == CT_COMMA) { LOG_FMT(LNEWLINE, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); // produces much more log output. Use it only debugging purpose //log_pcf_flags(LNEWLINE, pc->GetFlags()); if (pc->TestFlags(PCF_IN_CONST_ARGS)) // Issue #2250 { continue; } /* * for chunk_type == CT_COMMA * we get 'mode' from options::pos_comma() * BUT we must take care of options::pos_class_comma() * TODO and options::pos_constr_comma() */ if (pc->TestFlags(PCF_IN_CLASS_BASE)) { // change mode log_rule_B("pos_class_comma"); mode_local = options::pos_class_comma(); } else if (pc->TestFlags(PCF_IN_ENUM)) { log_rule_B("pos_enum_comma"); mode_local = options::pos_enum_comma(); } else { mode_local = mode; } LOG_FMT(LNEWLINE, "%s(%d): mode_local is %s\n", __func__, __LINE__, to_string(mode_local)); } else { mode_local = mode; } Chunk *prev = pc->GetPrevNc(); Chunk *next = pc->GetNextNc(); LOG_FMT(LNEWLINE, "%s(%d): mode_local is %s\n", __func__, __LINE__, to_string(mode_local)); LOG_FMT(LNEWLINE, "%s(%d): prev orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), prev->Text()); LOG_FMT(LNEWLINE, "%s(%d): next orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text()); size_t nl_flag = ((prev->IsNewline() ? 1 : 0) | (next->IsNewline() ? 2 : 0)); LOG_FMT(LNEWLINE, "%s(%d): nl_flag is %zu\n", __func__, __LINE__, nl_flag); if (mode_local & TP_JOIN) { if (nl_flag & 1) { // remove newline if not preceded by a comment Chunk *prev2 = prev->GetPrev(); if ( prev2->IsNotNullChunk() && !(prev2->IsComment())) { remove_next_newlines(prev2); } } if (nl_flag & 2) { // remove newline if not followed by a comment or by '{' Chunk *next2 = next->GetNext(); if ( next2->IsNotNullChunk() && !next2->IsComment() && !next2->Is(CT_BRACE_OPEN)) { remove_next_newlines(pc); } } continue; } if ( ( nl_flag == 0 && !(mode_local & (TP_FORCE | TP_BREAK))) || ( nl_flag == 3 && !(mode_local & TP_FORCE))) { // No newlines and not adding any or both and not forcing continue; } if ( ( (mode_local & TP_LEAD) && nl_flag == 1) || ( (mode_local & TP_TRAIL) && nl_flag == 2)) { // Already a newline before (lead) or after (trail) continue; } // If there were no newlines, we need to add one if (nl_flag == 0) { if (mode_local & TP_LEAD) { newline_add_before(pc); } else { newline_add_after(pc); } continue; } // If there were both newlines, we need to remove one if (nl_flag == 3) { if (mode_local & TP_LEAD) { remove_next_newlines(pc); } else { remove_next_newlines(pc->GetPrevNcNnlNi()); // Issue #2279 } continue; } // we need to move the newline if (mode_local & TP_LEAD) { Chunk *next2 = next->GetNext(); if ( next2->Is(CT_PREPROC) || ( chunk_type == CT_ASSIGN && next2->Is(CT_BRACE_OPEN))) { continue; } if (next->GetNlCount() == 1) { if ( prev != nullptr && !prev->TestFlags(PCF_IN_PREPROC)) { // move the CT_BOOL to after the newline pc->MoveAfter(next); } } } else { LOG_FMT(LNEWLINE, "%s(%d): prev orig line is %zu, orig col is %zu, Text() is '%s', new line count is %zu\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), prev->Text(), prev->GetNlCount()); if (prev->GetNlCount() == 1) { // Back up to the next non-comment item prev = prev->GetPrevNc(); LOG_FMT(LNEWLINE, "%s(%d): prev orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), prev->Text()); if ( prev->IsNotNullChunk() && !prev->IsNewline() && !prev->TestFlags(PCF_IN_PREPROC) && !prev->TestFlags(PCF_IN_OC_MSG)) { pc->MoveAfter(prev); } } } } } } // newlines_chunk_pos void newlines_class_colon_pos(E_Token tok) { LOG_FUNC_ENTRY(); token_pos_e tpc; token_pos_e pcc; iarf_e anc; iarf_e ncia; if (tok == CT_CLASS_COLON) { tpc = options::pos_class_colon(); log_rule_B("pos_class_colon"); anc = options::nl_class_colon(); log_rule_B("nl_class_colon"); ncia = options::nl_class_init_args(); log_rule_B("nl_class_init_args"); pcc = options::pos_class_comma(); log_rule_B("pos_class_comma"); } else // tok == CT_CONSTR_COLON { tpc = options::pos_constr_colon(); log_rule_B("pos_constr_colon"); anc = options::nl_constr_colon(); log_rule_B("nl_constr_colon"); ncia = options::nl_constr_init_args(); log_rule_B("nl_constr_init_args"); pcc = options::pos_constr_comma(); log_rule_B("pos_constr_comma"); } Chunk *ccolon = nullptr; size_t acv_span = options::align_constr_value_span(); log_rule_B("align_constr_value_span"); bool with_acv = (acv_span > 0) && language_is_set(LANG_CPP); AlignStack constructorValue; // ABC_Member(abc_value) if (with_acv) { int acv_thresh = options::align_constr_value_thresh(); log_rule_B("align_constr_value_thresh"); size_t acv_gap = options::align_constr_value_gap(); log_rule_B("align_constr_value_gap"); constructorValue.Start(acv_span, acv_thresh); constructorValue.m_gap = acv_gap; constructorValue.m_right_align = !options::align_on_tabstop(); log_rule_B("align_on_tabstop"); } for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if ( ccolon == nullptr && pc->IsNot(tok)) { continue; } Chunk *prev; Chunk *next; if (pc->Is(tok)) { LOG_FMT(LBLANKD, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); ccolon = pc; prev = pc->GetPrevNc(); next = pc->GetNextNc(); if (pc->Is(CT_CONSTR_COLON)) { LOG_FMT(LBLANKD, "%s(%d): pc orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); Chunk *paren_vor_value = pc->GetNextType(CT_FPAREN_OPEN, pc->GetLevel()); if ( with_acv && paren_vor_value->IsNotNullChunk()) { LOG_FMT(LBLANKD, "%s(%d): paren_vor_value orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, paren_vor_value->GetOrigLine(), paren_vor_value->GetOrigCol(), paren_vor_value->Text(), get_token_name(paren_vor_value->GetType())); constructorValue.NewLines(paren_vor_value->GetNlCount()); constructorValue.Add(paren_vor_value); } } if ( !prev->IsNewline() && !next->IsNewline() && (anc & IARF_ADD)) // nl_class_colon, nl_constr_colon: 1 { newline_add_after(pc); prev = pc->GetPrevNc(); next = pc->GetNextNc(); } if (anc == IARF_REMOVE) // nl_class_colon, nl_constr_colon: 2 { if ( prev->IsNewline() && prev->SafeToDeleteNl()) { Chunk::Delete(prev); MARK_CHANGE(); prev = pc->GetPrevNc(); } if ( next->IsNewline() && next->SafeToDeleteNl()) { Chunk::Delete(next); MARK_CHANGE(); next = pc->GetNextNc(); } } if (tpc & TP_TRAIL) // pos_class_colon, pos_constr_colon: 4 { if ( prev->IsNewline() && prev->GetNlCount() == 1 && prev->SafeToDeleteNl()) { pc->Swap(prev); } } else if (tpc & TP_LEAD) // pos_class_colon, pos_constr_colon: 3 { if ( next->IsNewline() && next->GetNlCount() == 1 && next->SafeToDeleteNl()) { pc->Swap(next); } } } else { // (pc->GetType() != tok) if ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_SEMICOLON)) { ccolon = nullptr; if (with_acv) { constructorValue.End(); } continue; } if ( pc->Is(CT_COMMA) && pc->GetLevel() == ccolon->GetLevel()) { LOG_FMT(LBLANKD, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); Chunk *paren_vor_value = pc->GetNextType(CT_FPAREN_OPEN, pc->GetLevel()); if ( with_acv && paren_vor_value->IsNotNullChunk()) { LOG_FMT(LBLANKD, "%s(%d): paren_vor_value orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, paren_vor_value->GetOrigLine(), paren_vor_value->GetOrigCol(), paren_vor_value->Text(), get_token_name(paren_vor_value->GetType())); constructorValue.NewLines(paren_vor_value->GetNlCount()); constructorValue.Add(paren_vor_value); } if (ncia & IARF_ADD) // nl_class_init_args, nl_constr_init_args: { if (pcc & TP_TRAIL) // pos_class_comma, pos_constr_comma { if (ncia == IARF_FORCE) // nl_class_init_args, nl_constr_init_args: 5 { Chunk *after = pc->GetNext(); // Issue #2759 if (after->IsNot(CT_COMMENT_CPP)) { newline_force_after(pc); } } else { // (ncia == IARF_ADD) // nl_class_init_args, nl_constr_init_args: 8 newline_add_after(pc); } prev = pc->GetPrevNc(); if ( prev->IsNewline() && prev->SafeToDeleteNl()) { Chunk::Delete(prev); MARK_CHANGE(); } } else if (pcc & TP_LEAD) // pos_class_comma, pos_constr_comma { if (ncia == IARF_FORCE) // nl_class_init_args, nl_constr_init_args: 7 { newline_force_before(pc); } else { // (ncia == IARF_ADD) // nl_class_init_args, nl_constr_init_args: 9 newline_add_before(pc); } next = pc->GetNextNc(); if ( next->IsNewline() && next->SafeToDeleteNl()) { Chunk::Delete(next); MARK_CHANGE(); } } } else if (ncia == IARF_REMOVE) // nl_class_init_args, nl_constr_init_args: 6 { next = pc->GetNext(); if ( next->IsNewline() && next->SafeToDeleteNl()) { // comma is after Chunk::Delete(next); MARK_CHANGE(); } else { prev = pc->GetPrev(); if ( prev->IsNewline() && prev->SafeToDeleteNl()) { // comma is before Chunk::Delete(prev); MARK_CHANGE(); } } } } } } } // newlines_class_colon_pos static void blank_line_max(Chunk *pc, Option &opt) { LOG_FUNC_ENTRY(); if (pc == nullptr) { return; } const auto optval = opt(); if ( (optval > 0) && (pc->GetNlCount() > optval)) { LOG_FMT(LBLANKD, "%s(%d): do_blank_lines: %s max line %zu\n", __func__, __LINE__, opt.name(), pc->GetOrigLine()); pc->SetNlCount(optval); MARK_CHANGE(); } } // blank_line_max iarf_e newline_template_option(Chunk *pc, iarf_e special, iarf_e base, iarf_e fallback) { Chunk *const prev = pc->GetPrevNcNnl(); if ( prev->Is(CT_ANGLE_OPEN) && special != IARF_IGNORE) { return(special); } else if (base != IARF_IGNORE) { return(base); } else { return(fallback); } } // newline_template_option bool is_func_proto_group(Chunk *pc, E_Token one_liner_type) { if ( pc != nullptr && options::nl_class_leave_one_liner_groups() && ( pc->Is(one_liner_type) || pc->GetParentType() == one_liner_type) && pc->TestFlags(PCF_IN_CLASS)) { log_rule_B("nl_class_leave_one_liner_groups"); if (pc->Is(CT_BRACE_CLOSE)) { return(pc->TestFlags(PCF_ONE_LINER)); } else { // Find opening brace pc = pc->GetNextType(CT_BRACE_OPEN, pc->GetLevel()); return( pc->IsNotNullChunk() && pc->TestFlags(PCF_ONE_LINER)); } } return(false); } // is_func_proto_group void do_blank_lines() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->Is(CT_NEWLINE)) { LOG_FMT(LBLANKD, "%s(%d): orig line is %zu, orig col is %zu, , nl is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetNlCount()); } else { char copy[1000]; LOG_FMT(LBLANKD, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy), get_token_name(pc->GetType())); } LOG_FMT(LBLANK, "%s(%d): new line count is %zu\n", __func__, __LINE__, pc->GetNlCount()); if (pc->IsNot(CT_NEWLINE)) { continue; } Chunk *prev = pc->GetPrevNc(); if (prev->IsNotNullChunk()) { LOG_FMT(LBLANK, "%s(%d): prev orig line is %zu, prev->Text() '%s', prev->GetType() is %s\n", __func__, __LINE__, pc->GetOrigLine(), prev->Text(), get_token_name(prev->GetType())); if (prev->Is(CT_IGNORED)) { continue; } } Chunk *next = pc->GetNext(); Chunk *pcmt = pc->GetPrev(); bool line_added = false; /* * If this is the first or the last token, pretend that there is an extra * line. It will be removed at the end. */ if ( pc == Chunk::GetHead() || next->IsNullChunk()) { line_added = true; pc->SetNlCount(pc->GetNlCount() + 1); LOG_FMT(LBLANK, "%s(%d): orig line is %zu, orig col is %zu, text is '%s', new line count is now %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), pc->GetNlCount()); } // Limit consecutive newlines if ( (options::nl_max() > 0) && (pc->GetNlCount() > options::nl_max())) { log_rule_B("nl_max"); blank_line_max(pc, options::nl_max); } if (!can_increase_nl(pc)) { LOG_FMT(LBLANKD, "%s(%d): force to 1 orig line is %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); if (pc->GetNlCount() != 1) { pc->SetNlCount(1); MARK_CHANGE(); } continue; } // Control blanks before multi-line comments if ( (options::nl_before_block_comment() > pc->GetNlCount()) && next->Is(CT_COMMENT_MULTI)) { log_rule_B("nl_before_block_comment"); // Don't add blanks after an open brace or a case statement if ( ( prev->IsNullChunk() || ( prev->IsNot(CT_BRACE_OPEN) && prev->IsNot(CT_VBRACE_OPEN) && prev->IsNot(CT_CASE_COLON))) && pcmt->IsNot(CT_COMMENT_MULTI)) // Issue #2383 { blank_line_set(pc, options::nl_before_block_comment); log_rule_B("nl_before_block_comment"); } } // Control blanks before single line C comments if ( (options::nl_before_c_comment() > pc->GetNlCount()) && next->Is(CT_COMMENT)) { log_rule_B("nl_before_c_comment"); // Don't add blanks after an open brace, a case stamement, or a comment if ( ( prev->IsNullChunk() || ( prev->IsNot(CT_BRACE_OPEN) && prev->IsNot(CT_VBRACE_OPEN) && prev->IsNot(CT_CASE_COLON))) && pcmt->IsNot(CT_COMMENT)) // Issue #2383 { blank_line_set(pc, options::nl_before_c_comment); log_rule_B("nl_before_c_comment"); } } // Control blanks before CPP comments if ( (options::nl_before_cpp_comment() > pc->GetNlCount()) && next->Is(CT_COMMENT_CPP)) { log_rule_B("nl_before_cpp_comment"); // Don't add blanks after an open brace or a case statement if ( ( prev->IsNullChunk() || ( prev->IsNot(CT_BRACE_OPEN) && prev->IsNot(CT_VBRACE_OPEN) && prev->IsNot(CT_CASE_COLON))) && pcmt->IsNot(CT_COMMENT_CPP)) // Issue #2383 { blank_line_set(pc, options::nl_before_cpp_comment); log_rule_B("nl_before_cpp_comment"); } } // Control blanks before a class/struct if ( ( prev->Is(CT_SEMICOLON) || prev->Is(CT_BRACE_CLOSE)) && ( prev->GetParentType() == CT_CLASS || prev->GetParentType() == CT_STRUCT)) { E_Token parent_type = prev->GetParentType(); Chunk *start = prev->GetPrevType(parent_type, prev->GetLevel()); Chunk *tmp = start; // Is this a class/struct template? if (tmp->GetParentType() == CT_TEMPLATE) { tmp = tmp->GetPrevType(CT_TEMPLATE, prev->GetLevel()); tmp = tmp->GetPrevNc(); } else { tmp = tmp->GetPrevNc(); while ( tmp->Is(CT_NEWLINE) && tmp->GetPrev()->IsComment()) { tmp = tmp->GetPrev()->GetPrevNc(); } if (tmp->Is(CT_FRIEND)) { // Account for a friend declaration tmp = tmp->GetPrevNc(); } } while ( tmp->Is(CT_NEWLINE) && tmp->GetPrev()->IsComment()) { tmp = tmp->GetPrev()->GetPrevNc(); } if ( tmp->IsNotNullChunk() && !start->TestFlags(PCF_INCOMPLETE)) { if (parent_type == CT_CLASS && options::nl_before_class() > tmp->GetNlCount()) { log_rule_B("nl_before_class"); blank_line_set(tmp, options::nl_before_class); } else if (parent_type == CT_STRUCT && options::nl_before_struct() > tmp->GetNlCount()) { log_rule_B("nl_before_struct"); blank_line_set(tmp, options::nl_before_struct); } } } if ( prev->Is(CT_BRACE_CLOSE) && prev->GetParentType() == CT_NAMESPACE) { // Control blanks before a namespace Chunk *tmp = prev->GetPrevType(CT_NAMESPACE, prev->GetLevel()); tmp = tmp->GetPrevNc(); while ( tmp->Is(CT_NEWLINE) && tmp->GetPrev()->IsComment()) { tmp = tmp->GetPrev()->GetPrevNc(); } if ( tmp->IsNotNullChunk() && options::nl_before_namespace() > tmp->GetNlCount()) { log_rule_B("nl_before_namespace"); blank_line_set(tmp, options::nl_before_namespace); } // Add blanks after namespace if (options::nl_after_namespace() > pc->GetNlCount()) { log_rule_B("nl_after_namespace"); blank_line_set(pc, options::nl_after_namespace); } } // Control blanks inside empty function body if ( prev->Is(CT_BRACE_OPEN) && next->Is(CT_BRACE_CLOSE) && ( prev->GetParentType() == CT_FUNC_DEF || prev->GetParentType() == CT_FUNC_CLASS_DEF) && options::nl_inside_empty_func() > pc->GetNlCount() && prev->TestFlags(PCF_EMPTY_BODY)) { blank_line_set(pc, options::nl_inside_empty_func); log_rule_B("nl_inside_empty_func"); } // Control blanks after an access spec if ( (options::nl_after_access_spec() > 0) && (options::nl_after_access_spec() != pc->GetNlCount()) && prev->Is(CT_ACCESS_COLON)) { log_rule_B("nl_after_access_spec"); // Don't add blanks before a closing brace if ( next->IsNullChunk() || !next->IsBraceClose()) { log_rule_B("nl_after_access_spec"); blank_line_set(pc, options::nl_after_access_spec); } } // Add blanks after function bodies if ( prev->Is(CT_BRACE_CLOSE) && ( prev->GetParentType() == CT_FUNC_DEF || prev->GetParentType() == CT_FUNC_CLASS_DEF || prev->GetParentType() == CT_OC_MSG_DECL || prev->GetParentType() == CT_ASSIGN)) { if (prev->TestFlags(PCF_ONE_LINER)) { if (options::nl_after_func_body_one_liner() > pc->GetNlCount()) { log_rule_B("nl_after_func_body_one_liner"); blank_line_set(pc, options::nl_after_func_body_one_liner); } } else { if ( prev->TestFlags(PCF_IN_CLASS) && (options::nl_after_func_body_class() > 0)) { log_rule_B("nl_after_func_body_class"); if (options::nl_after_func_body_class() != pc->GetNlCount()) { log_rule_B("nl_after_func_body_class"); blank_line_set(pc, options::nl_after_func_body_class); } } else if (options::nl_after_func_body() > 0) { log_rule_B("nl_after_func_body"); // Issue #1734 if (!(pc->GetPrev()->TestFlags(PCF_IN_TRY_BLOCK))) { if (options::nl_after_func_body() != pc->GetNlCount()) { log_rule_B("nl_after_func_body"); blank_line_set(pc, options::nl_after_func_body); } } } } } // Add blanks after function prototypes if ( ( prev->Is(CT_SEMICOLON) && prev->GetParentType() == CT_FUNC_PROTO) || is_func_proto_group(prev, CT_FUNC_DEF)) { if (options::nl_after_func_proto() > pc->GetNlCount()) { log_rule_B("nl_after_func_proto"); pc->SetNlCount(options::nl_after_func_proto()); MARK_CHANGE(); } if ( (options::nl_after_func_proto_group() > pc->GetNlCount()) && next->IsNotNullChunk() && next->GetParentType() != CT_FUNC_PROTO && !is_func_proto_group(next, CT_FUNC_DEF)) { log_rule_B("nl_after_func_proto_group"); blank_line_set(pc, options::nl_after_func_proto_group); } } // Issue #411: Add blanks after function class prototypes if ( ( prev->Is(CT_SEMICOLON) && prev->GetParentType() == CT_FUNC_CLASS_PROTO) || is_func_proto_group(prev, CT_FUNC_CLASS_DEF)) { if (options::nl_after_func_class_proto() > pc->GetNlCount()) { log_rule_B("nl_after_func_class_proto"); pc->SetNlCount(options::nl_after_func_class_proto()); MARK_CHANGE(); } if ( (options::nl_after_func_class_proto_group() > pc->GetNlCount()) && next->IsNot(CT_FUNC_CLASS_PROTO) && next->GetParentType() != CT_FUNC_CLASS_PROTO && !is_func_proto_group(next, CT_FUNC_CLASS_DEF)) { log_rule_B("nl_after_func_class_proto_group"); blank_line_set(pc, options::nl_after_func_class_proto_group); } } // Add blanks after struct/enum/union/class if ( ( prev->Is(CT_SEMICOLON) || prev->Is(CT_BRACE_CLOSE)) && ( prev->GetParentType() == CT_STRUCT || prev->GetParentType() == CT_ENUM || prev->GetParentType() == CT_UNION || prev->GetParentType() == CT_CLASS)) { auto &opt = (prev->GetParentType() == CT_CLASS ? options::nl_after_class : options::nl_after_struct); log_rule_B("nl_after_class"); log_rule_B("nl_after_struct"); if (opt() > pc->GetNlCount()) { // Issue #1702 // look back if we have a variable Chunk *tmp = pc; bool is_var_def = false; bool is_fwd_decl = false; while ((tmp = tmp->GetPrev())->IsNotNullChunk()) { if (tmp->GetLevel() > pc->GetLevel()) { continue; } LOG_FMT(LBLANK, "%s(%d): %zu:%zu token is '%s'\n", __func__, __LINE__, tmp->GetOrigLine(), tmp->GetOrigCol(), tmp->Text()); if (tmp->TestFlags(PCF_VAR_DEF)) { is_var_def = true; break; } if (tmp->Is(prev->GetParentType())) { is_fwd_decl = tmp->TestFlags(PCF_INCOMPLETE); break; } } LOG_FMT(LBLANK, "%s(%d): var_def = %s, fwd_decl = %s\n", __func__, __LINE__, is_var_def ? "yes" : "no", is_fwd_decl ? "yes" : "no"); if ( !is_var_def && !is_fwd_decl) { blank_line_set(pc, opt); } } } // Change blanks between a function comment and body if ( (options::nl_comment_func_def() != 0) && pcmt->Is(CT_COMMENT_MULTI) && pcmt->GetParentType() == CT_COMMENT_WHOLE && next->IsNotNullChunk() && ( next->GetParentType() == CT_FUNC_DEF || next->GetParentType() == CT_FUNC_CLASS_DEF)) { log_rule_B("nl_comment_func_def"); if (options::nl_comment_func_def() != pc->GetNlCount()) { log_rule_B("nl_comment_func_def"); blank_line_set(pc, options::nl_comment_func_def); } } // Change blanks after a try-catch-finally block if ( (options::nl_after_try_catch_finally() != 0) && (options::nl_after_try_catch_finally() != pc->GetNlCount()) && prev->IsNotNullChunk() && next->IsNotNullChunk()) { log_rule_B("nl_after_try_catch_finally"); if ( prev->Is(CT_BRACE_CLOSE) && ( prev->GetParentType() == CT_CATCH || prev->GetParentType() == CT_FINALLY)) { if ( next->IsNot(CT_BRACE_CLOSE) && next->IsNot(CT_CATCH) && next->IsNot(CT_FINALLY)) { blank_line_set(pc, options::nl_after_try_catch_finally); log_rule_B("nl_after_try_catch_finally"); } } } // Change blanks after a try-catch-finally block if ( (options::nl_between_get_set() != 0) && (options::nl_between_get_set() != pc->GetNlCount()) && prev->IsNotNullChunk() && next->IsNotNullChunk()) { log_rule_B("nl_between_get_set"); if ( prev->GetParentType() == CT_GETSET && next->IsNot(CT_BRACE_CLOSE) && ( prev->Is(CT_BRACE_CLOSE) || prev->Is(CT_SEMICOLON))) { blank_line_set(pc, options::nl_between_get_set); log_rule_B("nl_between_get_set"); } } // Change blanks after a try-catch-finally block if ( (options::nl_around_cs_property() != 0) && (options::nl_around_cs_property() != pc->GetNlCount()) && prev->IsNotNullChunk() && next->IsNotNullChunk()) { log_rule_B("nl_around_cs_property"); if ( prev->Is(CT_BRACE_CLOSE) && prev->GetParentType() == CT_CS_PROPERTY && next->IsNot(CT_BRACE_CLOSE)) { blank_line_set(pc, options::nl_around_cs_property); log_rule_B("nl_around_cs_property"); } else if ( next->GetParentType() == CT_CS_PROPERTY && next->TestFlags(PCF_STMT_START)) { blank_line_set(pc, options::nl_around_cs_property); log_rule_B("nl_around_cs_property"); } } // Control blanks before an access spec if ( (options::nl_before_access_spec() > 0) && (options::nl_before_access_spec() != pc->GetNlCount()) && next->Is(CT_ACCESS)) { log_rule_B("nl_before_access_spec"); // Don't add blanks after an open brace if ( prev->IsNullChunk() || ( prev->IsNot(CT_BRACE_OPEN) && prev->IsNot(CT_VBRACE_OPEN))) { log_rule_B("nl_before_access_spec"); blank_line_set(pc, options::nl_before_access_spec); } } // Change blanks inside namespace braces if ( (options::nl_inside_namespace() != 0) && (options::nl_inside_namespace() != pc->GetNlCount()) && ( ( prev->Is(CT_BRACE_OPEN) && prev->GetParentType() == CT_NAMESPACE) || ( next->Is(CT_BRACE_CLOSE) && next->GetParentType() == CT_NAMESPACE))) { log_rule_B("nl_inside_namespace"); blank_line_set(pc, options::nl_inside_namespace); } // Control blanks before a whole-file #ifdef if ( options::nl_before_whole_file_ifdef() != 0 && options::nl_before_whole_file_ifdef() != pc->GetNlCount() && next->Is(CT_PREPROC) && next->GetParentType() == CT_PP_IF && ifdef_over_whole_file() && next->TestFlags(PCF_WF_IF)) { log_rule_B("nl_before_whole_file_ifdef"); blank_line_set(pc, options::nl_before_whole_file_ifdef); } // Control blanks after a whole-file #ifdef if ( options::nl_after_whole_file_ifdef() != 0 && options::nl_after_whole_file_ifdef() != pc->GetNlCount()) { Chunk *pp_start = prev->GetPpStart(); if ( pp_start->IsNotNullChunk() && pp_start->GetParentType() == CT_PP_IF && ifdef_over_whole_file() && pp_start->TestFlags(PCF_WF_IF)) { log_rule_B("nl_after_whole_file_ifdef"); blank_line_set(pc, options::nl_after_whole_file_ifdef); } } // Control blanks before a whole-file #endif if ( options::nl_before_whole_file_endif() != 0 && options::nl_before_whole_file_endif() != pc->GetNlCount() && next->Is(CT_PREPROC) && next->GetParentType() == CT_PP_ENDIF && ifdef_over_whole_file() && next->TestFlags(PCF_WF_ENDIF)) { log_rule_B("nl_before_whole_file_endif"); blank_line_set(pc, options::nl_before_whole_file_endif); } // Control blanks after a whole-file #endif if ( options::nl_after_whole_file_endif() != 0 && options::nl_after_whole_file_endif() != pc->GetNlCount()) { Chunk *pp_start = prev->GetPpStart(); if ( pp_start->IsNotNullChunk() && pp_start->GetParentType() == CT_PP_ENDIF && ifdef_over_whole_file() && pp_start->TestFlags(PCF_WF_ENDIF)) { log_rule_B("nl_after_whole_file_endif"); blank_line_set(pc, options::nl_after_whole_file_endif); } } if ( line_added && pc->GetNlCount() > 1) { pc->SetNlCount(pc->GetNlCount() - 1); LOG_FMT(LBLANK, "%s(%d): orig line is %zu, orig col is %zu, text is '%s', new line count is now %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), pc->GetNlCount()); } LOG_FMT(LBLANK, "%s(%d): orig line is %zu, orig col is %zu, text is '%s', end new line count is now %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), pc->GetNlCount()); } } // do_blank_lines void newlines_cleanup_dup() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); Chunk *next = pc; while (pc->IsNotNullChunk()) { next = next->GetNext(); if ( pc->Is(CT_NEWLINE) && next->Is(CT_NEWLINE)) { next->SetNlCount(max(pc->GetNlCount(), next->GetNlCount())); Chunk::Delete(pc); MARK_CHANGE(); } pc = next; } } // newlines_cleanup_dup static void newlines_enum_entries(Chunk *open_brace, iarf_e av) { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::NullChunkPtr; if (open_brace != nullptr) { pc = open_brace; } while ( (pc = pc->GetNextNc())->IsNotNullChunk() && pc->GetLevel() > open_brace->GetLevel()) { if ( (pc->GetLevel() != (open_brace->GetLevel() + 1)) || pc->IsNot(CT_COMMA) || ( pc->Is(CT_COMMA) && pc->GetNext()->IsNotNullChunk() && ( pc->GetNext()->GetType() == CT_COMMENT_CPP || pc->GetNext()->GetType() == CT_COMMENT))) { continue; } newline_iarf(pc, av); } newline_iarf(open_brace, av); } // newlines_enum_entries static void newlines_double_space_struct_enum_union(Chunk *open_brace) { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::NullChunkPtr; if (open_brace != nullptr) { pc = open_brace; } while ( (pc = pc->GetNextNc())->IsNotNullChunk() && pc->GetLevel() > open_brace->GetLevel()) { if ( pc->GetLevel() != (open_brace->GetLevel() + 1) || pc->IsNot(CT_NEWLINE)) { continue; } /* * If the newline is NOT after a comment or a brace open and * it is before a comment, then make sure that the newline is * at least doubled */ Chunk *prev = pc->GetPrev(); if ( !prev->IsComment() && prev->IsNot(CT_BRACE_OPEN) && pc->GetNext()->IsComment()) { if (pc->GetNlCount() < 2) { double_newline(pc); } } } } // newlines_double_space_struct_enum_union void annotations_newlines() { LOG_FUNC_ENTRY(); Chunk *next; Chunk *prev; Chunk *ae; // last token of the annotation Chunk *pc = Chunk::GetHead(); while ( (pc = pc->GetNextType(CT_ANNOTATION))->IsNotNullChunk() && (next = pc->GetNextNnl())->IsNotNullChunk()) { // find the end of this annotation if (next->IsParenOpen()) { // TODO: control newline between annotation and '(' ? ae = next->GetClosingParen(); } else { ae = pc; } if (ae->IsNullChunk()) { break; } LOG_FMT(LANNOT, "%s(%d): orig line is %zu, orig col is %zu, annotation is '%s', end @ orig line %zu, orig col %zu, is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), ae->GetOrigLine(), ae->GetOrigCol(), ae->Text()); prev = ae->GetPrev(); // Issue #1845 LOG_FMT(LANNOT, "%s(%d): prev orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, prev->GetOrigLine(), prev->GetOrigCol(), prev->Text()); next = ae->GetNextNnl(); if (next->Is(CT_ANNOTATION)) { LOG_FMT(LANNOT, "%s(%d): -- nl_between_annotation\n", __func__, __LINE__); newline_iarf(ae, options::nl_between_annotation()); log_rule_B("nl_between_annotation"); } if (next->Is(CT_NEWLINE)) { if (next->Is(CT_ANNOTATION)) { LOG_FMT(LANNOT, "%s(%d): -- nl_after_annotation\n", __func__, __LINE__); newline_iarf(ae, options::nl_after_annotation()); log_rule_B("nl_after_annotation"); } } } } // annotations_newlines bool newlines_between(Chunk *pc_start, Chunk *pc_end, size_t &newlines, E_Scope scope) { if ( pc_start == nullptr || pc_end == nullptr) { return(false); } newlines = 0; Chunk *it = pc_start; for ( ; it->IsNotNullChunk() && it != pc_end; it = it->GetNext(scope)) { newlines += it->GetNlCount(); } // newline count is valid if search stopped on expected chunk return(it == pc_end); } // newlines_between uncrustify-uncrustify-0.76.0/src/newlines.h000066400000000000000000000117571434072136500210340ustar00rootroot00000000000000/** * @file newlines.h * prototypes for newlines.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef NEWLINES_H_INCLUDED #define NEWLINES_H_INCLUDED #include "chunk.h" /** * Double the newline, if allowed. */ void double_newline(Chunk *nl); /** * Remove all extra newlines. * Modify line breaks as needed. */ void newlines_remove_newlines(); /** * Remove all newlines that fail the checks performed by the can_increase_nl() function */ void newlines_remove_disallowed(); /** Step through all chunks, altering newlines inside parens of if/for/while/do as needed. * Handles the style options: nl_multi_line_sparen_open, nl_multi_line_sparen_close, nl_before_if_closing_paren */ void newlines_sparens(); //! Step through all chunks. void newlines_cleanup_braces(bool first); void newlines_cleanup_angles(); //! Handle insertion/removal of blank lines before if/for/while/do and functions void newlines_insert_blank_lines(); /** * Handle removal of extra blank lines in functions * x <= 0: do nothing, x > 0: allow max x-1 blank lines */ void newlines_functions_remove_extra_blank_lines(); void newlines_squeeze_ifdef(); /** * In case of consecutive closing parens, which follow a newline, * the closing paren are altered to different lines, as per the respective opening parens. * In the given example, first 2 opening paren are in same line, hence the respective closing paren are put in the same line. * input: * func1(func2( * func3( * func4( * ) * ) * ) * ); * output: * func1(func2( * func3( * func4( * ) * ) * )); */ void newlines_squeeze_paren_close(); //! removes unnecessary newlines at start and end of a file void newlines_eat_start_end(); /** * Searches for a chunk of type chunk_type and moves them, if needed. * Will not move tokens that are on their own line or have other than * exactly 1 newline before (UO_pos_comma == TRAIL) or after (UO_pos_comma == LEAD). * We can't remove a newline if it is right before a preprocessor. */ void newlines_chunk_pos(E_Token chunk_type, uncrustify::token_pos_e mode); /** * Searches for CT_CLASS_COLON and moves them, if needed. * Also breaks up the args */ void newlines_class_colon_pos(E_Token tok); void newlines_cleanup_dup(); void annotations_newlines(); void newline_after_multiline_comment(); //! Handle insertion of blank lines after label colons void newline_after_label_colon(); /** * Scans for newline tokens and changes the nl_count. * A newline token has a minimum nl_count of 1. * Note that a blank line is actually 2 newlines, unless the newline is the * first chunk. * So, most comparisons have +1 below. */ void do_blank_lines(); /** * Clears the PCF_ONE_LINER flag on the current line. * Done right before inserting a newline. */ void undo_one_liner(Chunk *pc); /** * Does a simple Ignore, Add, Remove, or Force after the given chunk * * @param pc The chunk * @param av The IARF value */ void newline_iarf(Chunk *pc, uncrustify::iarf_e av); /** * Add a newline before the chunk if there isn't already a newline present. * Virtual braces are skipped, as they do not contribute to the output. */ Chunk *newline_add_before(Chunk *pc); /** * Add a newline after the chunk if there isn't already a newline present. * Virtual braces are skipped, as they do not contribute to the output. */ Chunk *newline_force_before(Chunk *pc); Chunk *newline_add_after(Chunk *pc); Chunk *newline_force_after(Chunk *pc); /** * Removes any CT_NEWLINE or CT_NL_CONT between start and end. * Start must be before end on the chunk list. * If the 'PCF_IN_PREPROC' status differs between two tags, we can't remove * the newline. * * @param start The starting chunk (if it is a newline, it will be removed!) * @param end The ending chunk (will not be removed, even if it is a newline) * * @return true/false - removed something */ void newline_del_between(Chunk *start, Chunk *end); /** * Add a newline between two tokens. * If there is already a newline between then, nothing is done. * Otherwise a newline is inserted. * * If end is CT_BRACE_OPEN and a comment and newline follow, then * the brace open is moved instead of inserting a newline. * * In this situation: * if (...) { //comment * * you get: * if (...) //comment * { */ Chunk *newline_add_between(Chunk *start, Chunk *end); /** * Counts newlines between two chunk elements * * @param pc_start chunk from which the counting of newlines will start * @param pc_end chunk at which the counting of newlines will end * @param newlines reference in which the amount of newlines will be written to * (will be initialized with 0) * @param scope specifies region chunks should/should not be considered. * * @return false if pc_start or pc_end are nullptr or if pc_end is not reached * @return true if above cases are not met */ bool newlines_between(Chunk *pc_start, Chunk *pc_end, size_t &newlines, E_Scope scope = E_Scope::ALL); #endif /* NEWLINES_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/option.cpp000066400000000000000000001000471434072136500210420ustar00rootroot00000000000000/** * @file option.cpp * Parses the options from the config file. * * @author Ben Gardner * @author Guy Maurel October 2015, 2021 * @author Matthew Woehlke since version 0.67 * @license GPL v2+ */ #include "option.h" #include "keywords.h" #include "uncrustify.h" #include "uncrustify_version.h" #include #include #include // to get std::tolower #include // to get va_start, va_end namespace uncrustify { namespace { static const char *DOC_TEXT_END = u8R"___( # Meaning of the settings: # Ignore - do not do any changes # Add - makes sure there is 1 or more space/brace/newline/etc # Force - makes sure there is exactly 1 space/brace/newline/etc, # behaves like Add in some contexts # Remove - removes space/brace/newline/etc # # # - Token(s) can be treated as specific type(s) with the 'set' option: # `set tokenType tokenString [tokenString...]` # # Example: # `set BOOL __AND__ __OR__` # # tokenTypes are defined in src/token_enum.h, use them without the # 'CT_' prefix: 'CT_BOOL' => 'BOOL' # # # - Token(s) can be treated as type(s) with the 'type' option. # `type tokenString [tokenString...]` # # Example: # `type int c_uint_8 Rectangle` # # This can also be achieved with `set TYPE int c_uint_8 Rectangle` # # # To embed whitespace in tokenStrings use the '\' escape character, or quote # the tokenStrings. These quotes are supported: "'` # # # - Support for the auto detection of languages through the file ending can be # added using the 'file_ext' command. # `file_ext langType langString [langString..]` # # Example: # `file_ext CPP .ch .cxx .cpp.in` # # langTypes are defined in uncrusify_types.h in the lang_flag_e enum, use # them without the 'LANG_' prefix: 'LANG_CPP' => 'CPP' # # # - Custom macro-based indentation can be set up using 'macro-open', # 'macro-else' and 'macro-close'. # `(macro-open | macro-else | macro-close) tokenString` # # Example: # `macro-open BEGIN_TEMPLATE_MESSAGE_MAP` # `macro-open BEGIN_MESSAGE_MAP` # `macro-close END_MESSAGE_MAP` # # )___"; std::vector option_groups; std::unordered_map option_map; #define LOG_CONFIG(...) \ log_config(); LOG_FMT(LNOTE, __VA_ARGS__); //----------------------------------------------------------------------------- constexpr int option_level(int major, int minor, int patch = 0) { return((major << 20) | (minor << 10) | (patch << 0)); } //----------------------------------------------------------------------------- void log_config() { // Print the name of the configuration file only once static bool config_name_logged = false; if (!config_name_logged) { LOG_FMT(LNOTE, "log_config: the configuration file is: %s\n", cpd.filename.c_str()); config_name_logged = true; } } //----------------------------------------------------------------------------- // This identity function exists so that all Option::str can simply call // to_string(m_val); this function will be used by Option std::string to_string(const std::string &in) { return(in); } using std::to_string; //----------------------------------------------------------------------------- std::string to_lower(const char *in, std::string::size_type size = 0) { std::string out; if (size > 0) { out.reserve(size); } while (*in) { out += static_cast(std::tolower(*in)); ++in; } return(out); } //----------------------------------------------------------------------------- std::string to_lower(const std::string &in) { return(to_lower(in.data(), in.size())); } //----------------------------------------------------------------------------- bool is_arg_sep(int ch) { return( isspace(ch) || ch == ',' || ch == '='); } //----------------------------------------------------------------------------- bool is_varg_sep(int ch) { return(ch == '.'); } //----------------------------------------------------------------------------- std::vector split_args(std::string in, const char *filename, bool (*is_sep)(int)) { std::vector out; std::string::size_type n = 0; std::string::size_type k = in.size(); // Parse input string while (n < k) { // Skip leading space while ( n < k && is_sep(in[n])) { ++n; } // Detect comments or trailing space if ( n >= k || in[n] == '#') { break; } // Detect and extract quoted string if (const auto *quote = strchr("\'\"`", in[n])) { const auto start = ++n; for ((void)n; in[n] != *quote; ++n) { if ( n < k && in[n] == '\\') { in.erase(n, 1); --k; } if (n >= k) { OptionWarning w{ filename }; w("found unterminated quoted-string"); return{}; } } out.push_back(in.substr(start, n - start)); if ( ++n < k && !is_sep(in[n])) { OptionWarning w{ filename }; w("unexpected text following quoted-string"); return{}; } continue; } // Extract anything else const auto start = n; for ((void)n; ( n < k && !is_sep(in[n])); ++n) { if (in[n] == '\\') { in.erase(n, 1); --k; } if (n >= k) { OptionWarning w{ filename }; w("found unterminated quoted-string"); return{}; } } out.push_back(in.substr(start, n - start)); } return(out); } // split_args //----------------------------------------------------------------------------- bool is_path_relative(const std::string &path) { assert(!path.empty()); #ifdef WIN32 // Check for partition labels as indication for an absolute path // 'X:\path\to\file' style absolute disk path if ( path.size() > 1 && isalpha(path[0]) && path[1] == ':') { return(false); } // Check for double backslashes as indication for a network path // '\\server\path\to\file style' absolute UNC path if ( path.size() > 1 && path[0] == '\\' && path[1] == '\\') { return(false); } #endif // Check for a slash as indication for a filename with leading path // '/path/to/file' style absolute path return(path[0] != '/'); } //----------------------------------------------------------------------------- void print_description(FILE *pfile, std::string description, const char *eol_marker) { // Descriptions always start with a '\n', so skip the first character for (std::string::size_type start = 1, length = description.length(); ( start != std::string::npos && start < length); ++start) { // Check for empty line so we can squelch trailing whitespace if (description[start] == '\n') { fprintf(pfile, "#%s", eol_marker); } else { const auto end = description.find('\n', start); fprintf(pfile, "# %s%s", description.substr(start, end - start).c_str(), eol_marker); start = end; } } } //----------------------------------------------------------------------------- bool process_option_line_compat_0_68(const std::string &cmd, const std::vector &args, const char *filename) { if (cmd == "sp_cpp_lambda_paren") { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; use '%s' instead", cmd.c_str(), options::sp_cpp_lambda_square_paren.name()); UNUSED(options::sp_cpp_lambda_square_paren.read(args[1].c_str())); return(true); } return(false); } // process_option_line_compat_0_68 bool process_option_line_compat_0_70(const std::string &cmd, const char *filename) { if (cmd == "sp_word_brace") // Issue #2428 { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; did you want to use '%s' instead?", cmd.c_str(), options::sp_type_brace_init_lst.name()); //UNUSED(options::sp_type_brace_init_lst.read(args[1].c_str())); return(true); } return(false); } // process_option_line_compat_0_70 bool process_option_line_compat_0_73(const std::string &cmd, const char *filename) { if (cmd == "indent_sing_line_comments") // Issue #3249 { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; did you want to use '%s' instead?", cmd.c_str(), options::indent_single_line_comments_before.name()); //UNUSED(options::indent_single_line_comments_before.read(args[1].c_str())); return(true); } if (cmd == "sp_before_tr_emb_cmt") // Issue #3339 { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; did you want to use '%s' instead?", cmd.c_str(), options::sp_before_tr_cmt.name()); //UNUSED(options::sp_before_tr_cmt.read(args[1].c_str())); return(true); } if (cmd == "sp_num_before_tr_emb_cmt") // Issue #3339 { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; did you want to use '%s' instead?", cmd.c_str(), options::sp_num_before_tr_cmt.name()); //UNUSED(options::sp_num_before_tr_cmt.read(args[1].c_str())); return(true); } return(false); } // process_option_line_compat_0_73 bool process_option_line_compat_0_74(const std::string &cmd, const char *filename) { if (cmd == "sp_type_question") // PR #3638 { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; did you want to use '%s' instead?", cmd.c_str(), options::sp_before_ptr_star.name()); return(true); } return(false); } // process_option_line_compat_0_74 bool process_option_line_compat_0_75(const std::string &cmd, const char *filename) { if (cmd == "pp_space") { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; it has been replaced by '%s'.", cmd.c_str(), options::pp_space_after.name()); return(true); } if (cmd == "pp_space_before") { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; it was a temporary option used\n" "during the development of version 0.76. Use '%s' and '%s' instead.", cmd.c_str(), options::pp_indent.name(), options::pp_indent_count.name()); return(true); } return(false); } // process_option_line_compat_0_75 bool process_option_line_compat_0_76(const std::string &cmd, const std::vector &args, const char *filename) { if (cmd == "nl_func_var_def_blk") { OptionWarning w{ filename, OptionWarning::MINOR }; w("option '%s' is deprecated; it has been replaced by '%s'.\n" "You can also use '%s' for additional functionality", cmd.c_str(), options::nl_var_def_blk_end_func_top.name(), options::nl_var_def_blk_end.name()); UNUSED(options::nl_var_def_blk_end_func_top.read(args[1].c_str())); return(true); } return(false); } // process_option_line_compat_0_76 } // namespace /////////////////////////////////////////////////////////////////////////////// //BEGIN Option and helpers //----------------------------------------------------------------------------- OptionWarning::OptionWarning(const char *filename, Severity severity) { UNUSED(severity); if (cpd.line_number != 0) { fprintf(stderr, "%s:%u: ", filename, cpd.line_number); } else { fprintf(stderr, "%s: ", filename); } } //----------------------------------------------------------------------------- OptionWarning::OptionWarning(const GenericOption *opt, Severity severity) { UNUSED(severity); fprintf(stderr, "Option<%s>: at %s:%d: ", to_string(opt->type()), cpd.filename.c_str(), cpd.line_number); } //----------------------------------------------------------------------------- OptionWarning::~OptionWarning() { fprintf(stderr, "\n"); log_flush(true); } //----------------------------------------------------------------------------- void OptionWarning::operator()(const char *fmt, ...) { va_list args; va_start(args, fmt); vfprintf(stderr, fmt, args); va_end(args); } //----------------------------------------------------------------------------- void GenericOption::warnUnexpectedValue(const char *actual) const { OptionWarning w{ this }; auto values = possibleValues(); if (values[1] == nullptr) { w("Expected %s ", *values); } else { w("Expected one of "); while (*values) { w("'%s'", *values); if (*(++values)) { w(", "); } } } w(", for '%s'; got '%s'", name(), actual); } //----------------------------------------------------------------------------- void GenericOption::warnIncompatibleReference(const GenericOption *ref) const { OptionWarning w{ this }; w("%s references option %s with incompatible type %s", name(), ref->name(), to_string(ref->type())); } //----------------------------------------------------------------------------- template bool read_enum(const char *in, Option &out) { assert(in); if (convert_string(in, out.m_val)) { return(true); } if (const auto *const opt = find_option(in)) { if (opt->type() != out.type()) { out.warnIncompatibleReference(opt); return(false); } auto &topt = *static_cast *>(opt); out.m_val = topt(); return(true); } out.warnUnexpectedValue(in); return(false); } //----------------------------------------------------------------------------- template bool read_number(const char *in, Option &out) { assert(in); char *c; const auto val = std::strtol(in, &c, 10); if ( *c == 0 && out.validate(val)) { out.m_val = static_cast(val); return(true); } bool invert = false; if (strchr("-", in[0])) { invert = true; ++in; } if (const auto *const opt = find_option(in)) { LOG_CONFIG("%s(%d): line_number is %d, option(%s) %s, ref(%s) %s\n", __func__, __LINE__, cpd.line_number, to_string(out.type()), out.name(), to_string(opt->type()), opt->name()); long tval; if (opt->type() == OT_NUM) { auto &sopt = *static_cast *>(opt); tval = static_cast(sopt()); } else if (opt->type() == OT_UNUM) { auto &uopt = *static_cast *>(opt); tval = static_cast(uopt()); } else { out.warnIncompatibleReference(opt); return(false); } const auto rval = (invert ? -tval : tval); if (out.validate(rval)) { out.m_val = static_cast(rval); return(true); } return(false); } out.warnUnexpectedValue(in); return(false); } // read_number //----------------------------------------------------------------------------- template void Option::reset() { m_val = m_default; } //----------------------------------------------------------------------------- template std::string Option::str() const { return(to_string(m_val)); } //----------------------------------------------------------------------------- template std::string Option::defaultStr() const { return(m_default != T{} ? to_string(m_default) : std::string{}); } // Explicit instantiations template class Option; template class Option; template class Option; template class Option; template class Option; template class Option; template class Option; //END Option and helpers /////////////////////////////////////////////////////////////////////////////// //BEGIN Option //----------------------------------------------------------------------------- template<> option_type_e Option::type() const { return(OT_BOOL); } //----------------------------------------------------------------------------- template<> const char *const *Option::possibleValues() const { static char const *values[] = { "true", "false", nullptr }; return(values); } //----------------------------------------------------------------------------- template<> bool Option::read(const char *in) { assert(in); if (convert_string(in, m_val)) { return(true); } bool invert = false; if (strchr("~!-", in[0])) { invert = true; ++in; } if (const auto *const opt = find_option(in)) { if (opt->type() != OT_BOOL) { warnIncompatibleReference(opt); return(false); } auto &bopt = *static_cast *>(opt); m_val = (invert ? !bopt() : bopt()); return(true); } warnUnexpectedValue(in); return(false); } //END Option /////////////////////////////////////////////////////////////////////////////// //BEGIN Option //----------------------------------------------------------------------------- template<> option_type_e Option::type() const { return(OT_IARF); } //----------------------------------------------------------------------------- template<> const char *const *Option::possibleValues() const { return(iarf_values); } //----------------------------------------------------------------------------- template<> bool Option::read(const char *in) { return(read_enum(in, *this)); } //END Option /////////////////////////////////////////////////////////////////////////////// //BEGIN Option //----------------------------------------------------------------------------- template<> option_type_e Option::type() const { return(OT_LINEEND); } //----------------------------------------------------------------------------- template<> const char *const *Option::possibleValues() const { return(line_end_values); } //----------------------------------------------------------------------------- template<> bool Option::read(const char *in) { return(read_enum(in, *this)); } //END Option /////////////////////////////////////////////////////////////////////////////// //BEGIN Option //----------------------------------------------------------------------------- template<> option_type_e Option::type() const { return(OT_TOKENPOS); } //----------------------------------------------------------------------------- template<> const char *const *Option::possibleValues() const { return(token_pos_values); } //----------------------------------------------------------------------------- template<> bool Option::read(const char *in) { return(read_enum(in, *this)); } //END Option /////////////////////////////////////////////////////////////////////////////// //BEGIN Option //----------------------------------------------------------------------------- template<> option_type_e Option::type() const { return(OT_NUM); } //----------------------------------------------------------------------------- template<> const char *const *Option::possibleValues() const { static char const *values[] = { "number", nullptr }; return(values); } //----------------------------------------------------------------------------- template<> bool Option::read(const char *in) { return(read_number(in, *this)); } //END Option /////////////////////////////////////////////////////////////////////////////// //BEGIN Option //----------------------------------------------------------------------------- template<> option_type_e Option::type() const { return(OT_UNUM); } //----------------------------------------------------------------------------- template<> const char *const *Option::possibleValues() const { static char const *values[] = { "unsigned number", nullptr }; return(values); } //----------------------------------------------------------------------------- template<> bool Option::read(const char *in) { return(read_number(in, *this)); } //END Option /////////////////////////////////////////////////////////////////////////////// //BEGIN Option //----------------------------------------------------------------------------- template<> option_type_e Option::type() const { return(OT_STRING); } //----------------------------------------------------------------------------- template<> const char *const *Option::possibleValues() const { static char const *values[] = { "string", nullptr }; return(values); } //----------------------------------------------------------------------------- template<> bool Option::read(const char *in) { m_val = in; return(true); } //END Option /////////////////////////////////////////////////////////////////////////////// //BEGIN global functions for options //----------------------------------------------------------------------------- void begin_option_group(const char *description) { auto g = OptionGroup{ description, {} }; option_groups.push_back(g); } //----------------------------------------------------------------------------- void register_option(GenericOption *option) { assert(!option_groups.empty()); option_groups.back().options.push_back(option); option_map.emplace(option->name(), option); } //----------------------------------------------------------------------------- uncrustify::GenericOption *find_option(const char *name) { const auto iter = option_map.find(to_lower(name)); if (iter != option_map.end()) { return(iter->second); } return(nullptr); } //----------------------------------------------------------------------------- OptionGroup *get_option_group(size_t i) { if (i >= option_groups.size()) { return(nullptr); } return(&option_groups[i]); } //----------------------------------------------------------------------------- size_t get_option_count() { return(option_map.size()); } //----------------------------------------------------------------------------- void process_option_line(const std::string &config_line, const char *filename, int &compat_level) { // Split line into arguments, and punt if no arguments are present auto args = split_args(config_line, filename, is_arg_sep); if (args.empty()) { return; } // Check for necessary arguments const auto &cmd = to_lower(args.front()); if ( cmd == "set" || cmd == "file_ext") { if (args.size() < 3) { OptionWarning w{ filename }; w("%s requires at least three arguments", cmd.c_str()); return; } } else { if (args.size() < 2) { OptionWarning w{ filename }; w("%s requires at least two arguments", cmd.c_str()); return; } } if (cmd == "type") { for (size_t i = 1; i < args.size(); ++i) { add_keyword(args[i], CT_TYPE); } } else if (cmd == "macro-open") { add_keyword(args[1], CT_MACRO_OPEN); } else if (cmd == "macro-close") { add_keyword(args[1], CT_MACRO_CLOSE); } else if (cmd == "macro-else") { add_keyword(args[1], CT_MACRO_ELSE); } else if (cmd == "set") { const auto token = find_token_name(args[1].c_str()); if (token != CT_NONE) { LOG_FMT(LNOTE, "%s:%d set '%s':", filename, cpd.line_number, args[1].c_str()); for (size_t i = 2; i < args.size(); ++i) { LOG_FMT(LNOTE, " '%s'", args[i].c_str()); add_keyword(args[i], token); } LOG_FMT(LNOTE, "\n"); } else { OptionWarning w{ filename }; w("%s: unknown type '%s'", cmd.c_str(), args[1].c_str()); } } #ifndef EMSCRIPTEN else if (cmd == "include") { auto this_line_number = cpd.line_number; const auto &include_path = args[1]; if (include_path.empty()) { OptionWarning w{ filename }; w("include: path cannot be empty"); } else if (is_path_relative(include_path)) { // include is a relative path to the current config file unc_text ut = std::string{ filename }; ut.resize(static_cast(path_dirname_len(filename))); ut.append(include_path); UNUSED(load_option_file(ut.c_str(), compat_level)); } else { // include is an absolute path UNUSED(load_option_file(include_path.c_str(), compat_level)); } cpd.line_number = this_line_number; } #endif else if (cmd == "file_ext") { auto *const lang_arg = args[1].c_str(); for (size_t i = 2; i < args.size(); ++i) { auto *const lang_name = extension_add(args[i].c_str(), lang_arg); if (lang_name) { LOG_FMT(LNOTE, "%s:%d file_ext '%s' => '%s'\n", filename, cpd.line_number, args[i].c_str(), lang_name); } else { OptionWarning w{ filename }; w("file_ext: unknown language '%s'", lang_arg); break; } } } else if (cmd == "using") { auto vargs = split_args(args[1], filename, is_varg_sep); if (vargs.size() == 2) { compat_level = option_level(std::stoi(vargs[0]), std::stoi(vargs[1])); } else if (vargs.size() == 3) { compat_level = option_level(std::stoi(vargs[0]), std::stoi(vargs[1]), std::stoi(vargs[2])); } else { OptionWarning w{ filename }; w("%s requires a version number in the form MAJOR.MINOR[.PATCH]", cmd.c_str()); } } else { // Must be a regular option = value if (compat_level < option_level(0, 69)) { if (process_option_line_compat_0_68(cmd, args, filename)) { return; } } if (compat_level < option_level(0, 71)) { if (process_option_line_compat_0_70(cmd, filename)) { return; } } if (compat_level < option_level(0, 74)) { if (process_option_line_compat_0_73(cmd, filename)) { return; } } if (compat_level < option_level(0, 75)) { if (process_option_line_compat_0_74(cmd, filename)) { return; } } if (compat_level < option_level(0, 76)) { if (process_option_line_compat_0_75(cmd, filename)) { return; } } if (compat_level < option_level(0, 77)) { if (process_option_line_compat_0_76(cmd, args, filename)) { return; } } const auto oi = option_map.find(cmd); if (oi == option_map.end()) { OptionWarning w{ filename }; w("unknown option '%s'", args[0].c_str()); } else { UNUSED(oi->second->read(args[1].c_str())); } } } // process_option_line //----------------------------------------------------------------------------- bool load_option_file(const char *filename, int compat_level) { cpd.line_number = 0; #ifdef WIN32 // "/dev/null" not understood by "fopen" in Windows if (strcasecmp(filename, "/dev/null") == 0) { return(true); } #endif std::ifstream in; in.open(filename, std::ifstream::in); if (!in.good()) { OptionWarning w{ filename }; w("file could not be opened: %s (%d)\n", strerror(errno), errno); exit(EX_SOFTWARE); } // Read in the file line by line std::string line; while (std::getline(in, line)) { // check all characters of the line size_t howmany = line.length(); int ch; for (size_t n = 0; n < howmany; n++) { ch = line[n]; // do not check characters in comment part of line if ('#' == ch) { break; } // ch >= 0 && ch <= 255 if ( ch < 0 || ch > 255) { // error // related to PR #3298 fprintf(stderr, "%s: line %u: Character at position %zu, is not printable.\n", filename, cpd.line_number + 1, n + 1); exit(EX_SOFTWARE); } } ++cpd.line_number; process_option_line(line, filename, compat_level); } return(true); } // load_option_file //----------------------------------------------------------------------------- const char *get_eol_marker() { static char eol[3] = { 0x0A, 0x00, 0x00 }; const auto &lines = cpd.newline.get(); for (size_t i = 0; i < lines.size(); ++i) { eol[i] = static_cast(lines[i]); } return(eol); } //----------------------------------------------------------------------------- void save_option_file(FILE *pfile, bool with_doc, bool minimal) { int non_default_values = 0; const char *eol_marker = get_eol_marker(); fprintf(pfile, "# %s%s", UNCRUSTIFY_VERSION, eol_marker); // Print the options by group for (auto &og : option_groups) { bool first = true; for (auto *option : og.options) { const auto val = option->str(); if (!option->isDefault()) { ++non_default_values; } else if (minimal) { continue; } //.................................................................... if (with_doc) { assert(option->description() != nullptr); assert(*option->description() != 0); if (first) { fprintf(pfile, "%s#%s", eol_marker, eol_marker); print_description(pfile, og.description, eol_marker); fprintf(pfile, "#%s", eol_marker); } fprintf(pfile, "%s", eol_marker); print_description(pfile, option->description(), eol_marker); const auto ds = option->defaultStr(); if (!ds.empty()) { fprintf(pfile, "#%s# Default: %s%s", eol_marker, ds.c_str(), eol_marker); } } first = false; const int name_len = static_cast(strlen(option->name())); const int pad = name_len < uncrustify::limits::MAX_OPTION_NAME_LEN ? (uncrustify::limits::MAX_OPTION_NAME_LEN - name_len) : 1; fprintf(pfile, "%s%*.s= ", option->name(), pad, " "); if (option->type() == OT_STRING) { fprintf(pfile, "\"%s\"", val.c_str()); } else { fprintf(pfile, "%s", val.c_str()); } if (with_doc) { const int val_len = static_cast(val.length()); fprintf(pfile, "%*.s # ", 8 - val_len, " "); for (auto pv = option->possibleValues(); *pv; ++pv) { fprintf(pfile, "%s%s", *pv, pv[1] ? "/" : ""); } } fputs(eol_marker, pfile); } } if (with_doc) { fprintf(pfile, "%s", DOC_TEXT_END); } print_custom_keywords(pfile); // Print custom keywords print_extensions(pfile); // Print custom file extensions fprintf(pfile, "# option(s) with 'not default' value: %d%s#%s", non_default_values, eol_marker, eol_marker); } // save_option_file } // namespace uncrustify uncrustify-uncrustify-0.76.0/src/option.h000066400000000000000000000253461434072136500205170ustar00rootroot00000000000000/** * @file option.h * Enumerations and data types for options. * * @author Ben Gardner * @author Guy Maurel since version 0.62 for uncrustify4Qt * October 2015, 2016 * @author Matthew Woehlke since version 0.67 * @license GPL v2+ */ #ifndef OPTION_H_INCLUDED #define OPTION_H_INCLUDED /* NOTE: * This file is processed by make_option_enum.py, which parses any 'enum class' * it finds, as well as the special macros UNC_OPTVAL_ALIAS and UNC_OPTVALS. * * The '// ' comment after an 'enum class' tells the script to generate * aliases for the enum values using the prefix that is given in the '<>'s. * Don't remove or alter these. */ #include "enum_flags.h" #include #include #include #ifdef IGNORE // WinBase.h #undef IGNORE #endif namespace uncrustify { template class Option; //----------------------------------------------------------------------------- // Option types enum class option_type_e // { // UNC_CONVERT_INTERNAL BOOL, IARF, LINEEND, TOKENPOS, NUM, UNUM, STRING, }; #if 0 // Fake enumeration for make_option_enum.py enum class bool { true, false, }; #endif //----------------------------------------------------------------------------- /// I/A/R/F values - these are bit fields enum class iarf_e // { IGNORE = 0, //! option ignores a given feature ADD = (1u << 0), //! option adds a given feature REMOVE = (1u << 1), //! option removes a given feature FORCE = (ADD | REMOVE), //! option forces the usage of a given feature NOT_DEFINED = (1u << 2) //! for debugging }; UNC_DECLARE_FLAGS(iarf_flags_t, iarf_e); UNC_DECLARE_OPERATORS_FOR_FLAGS(iarf_flags_t); //----------------------------------------------------------------------------- /// Line endings enum class line_end_e // { LF, //! "\n" typically used on Unix/Linux system CRLF, //! "\r\n" typically used on Windows systems CR, //! "\r" carriage return without newline AUTO, //! keep last }; constexpr auto line_end_styles = static_cast(line_end_e::AUTO); //----------------------------------------------------------------------------- /// Token position - these are bit fields enum class token_pos_e // { IGNORE = 0, //! don't change it BREAK = 1, //! add a newline before or after the if not present FORCE = 2, //! force a newline on one side and not the other LEAD = 4, //! at the start of a line or leading if wrapped line TRAIL = 8, //! at the end of a line or trailing if wrapped line JOIN = 16, //! remove newlines on both sides LEAD_BREAK = (LEAD | BREAK), // 5 LEAD_FORCE = (LEAD | FORCE), // 6 TRAIL_BREAK = (TRAIL | BREAK), // 9 TRAIL_FORCE = (TRAIL | FORCE), // 10 }; UNC_DECLARE_FLAGS(token_pos_flags_t, token_pos_e); UNC_DECLARE_OPERATORS_FOR_FLAGS(token_pos_flags_t); //----------------------------------------------------------------------------- /// Abstract (untyped) interface for options class GenericOption { public: GenericOption(const char *opt_name, const char *opt_desc) : m_name{opt_name} , m_desc{opt_desc} {} virtual ~GenericOption() = default; virtual option_type_e type() const = 0; const char *name() const { return(m_name); } const char *description() const { return(m_desc); } virtual const char *const *possibleValues() const = 0; virtual std::string defaultStr() const = 0; virtual std::string minStr() const { return(std::string{}); } virtual std::string maxStr() const { return(std::string{}); } virtual bool isDefault() const = 0; virtual void reset() = 0; virtual bool read(const char *s) = 0; virtual std::string str() const = 0; protected: template friend bool read_enum(const char *s, Option &o); template friend bool read_number(const char *s, Option &o); void warnUnexpectedValue(const char *actual) const; void warnIncompatibleReference(const GenericOption *ref) const; const char *const m_name; const char *const m_desc; }; //----------------------------------------------------------------------------- // Helper class for reporting problems with options class OptionWarning { public: enum class /* UNC_NO_META */ Severity { OS_CRITICAL, OS_MINOR, }; constexpr static auto CRITICAL = Severity::OS_CRITICAL; constexpr static auto MINOR = Severity::OS_MINOR; OptionWarning(const char *filename, Severity = CRITICAL); OptionWarning(const GenericOption *, Severity = CRITICAL); OptionWarning(const OptionWarning &) = delete; ~OptionWarning(); #ifdef __GNUC__ [[gnu::format(printf, 2, 3)]] #endif void operator()(const char *fmt, ...); }; //----------------------------------------------------------------------------- // Concrete (strongly typed) interface for options template class Option : public GenericOption { public: Option(const char *opt_name, const char *opt_desc, T opt_val = T{}) : GenericOption{opt_name, opt_desc} , m_val{opt_val} , m_default{opt_val} {} option_type_e type() const override; const char *const *possibleValues() const override; std::string defaultStr() const override; bool isDefault() const override { return(m_val == m_default); } //! resets option to its default value //- currently only used by the emscripten interface virtual void reset() override; bool read(const char *s) override; std::string str() const override; T operator()() const { return(m_val); } Option &operator=(T val) { m_val = val; return(*this); } protected: template friend bool read_enum(const char *s, Option &o); template friend bool read_number(const char *s, Option &o); virtual bool validate(long) { return(true); } T m_val = T{}; T m_default = T{}; }; //----------------------------------------------------------------------------- // Concrete (strongly typed) interface for bounded numeric options template class BoundedOption : public Option { public: BoundedOption(const char *opt_name, const char *opt_desc, T opt_val = T{}) : Option{opt_name, opt_desc, opt_val} { assert( opt_val >= min && opt_val <= max); } std::string minStr() const override { return(std::to_string(min)); } std::string maxStr() const override { return(std::to_string(max)); } protected: bool validate(long val) override { if (val < static_cast(min)) { OptionWarning w{ this }; w("requested value %ld for option '%s' " "is less than the minimum value %ld", val, this->name(), static_cast(min)); return(false); } if (val > static_cast(max)) { OptionWarning w{ this }; w("requested value %ld for option '%s' " "is greater than the maximum value %ld", val, this->name(), static_cast(max)); return(false); } return(true); } }; /////////////////////////////////////////////////////////////////////////////// // Declaration of option types; implementations are in option.cpp #define UNC_IMPLEMENT_OPTION(T) \ template<> option_type_e Option::type() const; \ template<> const char *const *Option::possibleValues() const; \ template<> bool Option::read(const char *s); \ extern template class Option UNC_IMPLEMENT_OPTION(bool); UNC_IMPLEMENT_OPTION(iarf_e); UNC_IMPLEMENT_OPTION(line_end_e); UNC_IMPLEMENT_OPTION(token_pos_e); UNC_IMPLEMENT_OPTION(signed); UNC_IMPLEMENT_OPTION(unsigned); UNC_IMPLEMENT_OPTION(std::string); // Additional mappings for option values #define UNC_OPTVAL_ALIAS(...) \ static_assert(true, "This is just a tag for make_option_enum.py") UNC_OPTVAL_ALIAS(bool, false, "0", "f", "n", "no"); UNC_OPTVAL_ALIAS(bool, true, "1", "t", "y", "yes"); UNC_OPTVAL_ALIAS(iarf_e, IGNORE, "i"); UNC_OPTVAL_ALIAS(iarf_e, ADD, "a", "2", "t", "true", "y", "yes"); UNC_OPTVAL_ALIAS(iarf_e, REMOVE, "r", "0", "f", "false", "n", "no"); UNC_OPTVAL_ALIAS(iarf_e, FORCE, "f", "1"); // Possible values for options, by type #define UNC_OPTVALS(e) extern const char *const e ## _values[] UNC_OPTVALS(iarf); UNC_OPTVALS(line_end); UNC_OPTVALS(token_pos); extern bool convert_string(const char *, bool &); extern bool convert_string(const char *, iarf_e &); extern bool convert_string(const char *, line_end_e &); extern bool convert_string(const char *, token_pos_e &); extern const char *to_string(bool); extern const char *to_string(iarf_e); extern const char *to_string(line_end_e); extern const char *to_string(token_pos_e); extern const char *to_string(option_type_e); struct OptionGroup { const char *description; std::vector options; }; /** * @brief Defines a new group of uncrustify options. * * New options are always added to the most recently defined group. */ void begin_option_group(const char *description); /** * @brief Adds an uncrustify option to the global option registry. * * The option is added to the most recently defined option group. */ void register_option(GenericOption *); GenericOption *find_option(const char *name); //! Add all uncrustify options to the global option registry void register_options(); OptionGroup *get_option_group(size_t); size_t get_option_count(); /** * processes a single line string to extract configuration settings * increments cpd.line_number and cpd.error_count * * @param config_line single line string that will be processed * @param filename for log messages, file from which the \p config_line * param was extracted * @param compat_level version of Uncrustify with which to be compatible */ void process_option_line(const std::string &config_line, const char *filename, int &compat_level); bool load_option_file(const char *filename, int compat_level = 0); /** * save the used options into a text file * * @param pfile file to print into * @param with_doc also print description * @param minimal print only options with non default value */ void save_option_file(FILE *pfile, bool with_doc = false, bool minimal = false); /** * get the marker that was selected for the end of line via the config file * * @return "\n" if newlines was set to LE_LF in the config file * @return "\r\n" if newlines was set to LE_CRLF in the config file * @return "\r" if newlines was set to LE_CR in the config file * @return "\n" if newlines was set to LE_AUTO in the config file */ const char *get_eol_marker(); } // namespace uncrustify #endif /* OPTION_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/option_enum.cpp.in000066400000000000000000000006471434072136500225000ustar00rootroot00000000000000##BANNER## #include "options.h" #include "base_types.h" #include "logger.h" #include #ifdef HAVE_STRINGS_H #include // strcasecmp() #endif #if defined(_MSC_VER) #pragma warning(disable: 4809) #elif __GNUC__ > 4 || __clang_major__ > 3 || __clang_minor__ > 4 #pragma GCC diagnostic ignored "-Wswitch-bool" #endif namespace uncrustify { ##VALUE_STRINGS## ##CONVERSIONS## } // namespace uncrustify uncrustify-uncrustify-0.76.0/src/option_enum.h.in000066400000000000000000000003631434072136500221400ustar00rootroot00000000000000##BANNER## #ifndef OPTION_ENUM_H_INCLUDED #define OPTION_ENUM_H_INCLUDED #include "option.h" #ifdef IGNORE // WinBase.h #undef IGNORE #endif namespace uncrustify { ##ALIASES## } // namespace uncrustify #endif /* OPTION_ENUM_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/options.cpp.in000066400000000000000000000007171434072136500216350ustar00rootroot00000000000000##BANNER## #include "uncrustify_types.h" namespace uncrustify { //BEGIN declarations of option object instances namespace options { ##DECLARATIONS## } // namespace options //END declarations of option object instances /////////////////////////////////////////////////////////////////////////////// //----------------------------------------------------------------------------- void register_options(void) { ##REGISTRATIONS## } } // namespace uncrustify uncrustify-uncrustify-0.76.0/src/options.h000066400000000000000000004011121434072136500206670ustar00rootroot00000000000000/** * @file options.h * Declarations of all the options. * * September 2020 * @author Ben Gardner * @author Guy Maurel * @author Matthew Woehlke * @license GPL v2+ */ #ifndef OPTIONS_H_INCLUDED #define OPTIONS_H_INCLUDED /* NOTE: * This file is processed by make_options.py, and must conform to a particular * format. Option groups are marked by '//begin ' (in upper case; this example * is lower case to prevent being considered a region marker for code folding) * followed by the group description. Options consist of two lines of * declaration preceded by one or more lines of C++ comments. The comments form * the option description and are taken verbatim, aside from stripping the * leading '// '. Only comments immediately preceding an option declaration, * with no blank lines, are taken as part of the description, so a blank line * may be used to separate notations from a description. * * An option declaration is 'extern TYPE\nNAME;', optionally followed by * ' // = VALUE' if the option has a default value that is different from the * default-constructed value type of the option. The 'VALUE' must be valid C++ * code, and is taken verbatim as an argument when creating the option's * instantiation. Note also that the line break, as shown, is required. */ #include "option_enum.h" namespace uncrustify { namespace options { using std::string; /////////////////////////////////////////////////////////////////////////////// //BEGIN General options // The type of line endings. extern Option newlines; // = LE_AUTO // The original size of tabs in the input. extern BoundedOption input_tab_size; // = 8 // The size of tabs in the output (only used if align_with_tabs=true). extern BoundedOption output_tab_size; // = 8 // The ASCII value of the string escape char, usually 92 (\) or (Pawn) 94 (^). extern BoundedOption string_escape_char; // = '\\' // Alternate string escape char (usually only used for Pawn). // Only works right before the quote char. extern BoundedOption string_escape_char2; // Replace tab characters found in string literals with the escape sequence \t // instead. extern Option string_replace_tab_chars; // Allow interpreting '>=' and '>>=' as part of a template in code like // 'void f(list>=val);'. If true, 'assert(x<0 && y>=3)' will be broken. // Improvements to template detection may make this option obsolete. extern Option tok_split_gte; // Disable formatting of NL_CONT ('\\n') ended lines (e.g. multi-line macros). extern Option disable_processing_nl_cont; // Specify the marker used in comments to disable processing of part of the // file. extern Option disable_processing_cmt; // = UNCRUSTIFY_OFF_TEXT // Specify the marker used in comments to (re)enable processing in a file. extern Option enable_processing_cmt; // = UNCRUSTIFY_ON_TEXT // Enable parsing of digraphs. extern Option enable_digraphs; // Option to allow both disable_processing_cmt and enable_processing_cmt // strings, if specified, to be interpreted as ECMAScript regular expressions. // If true, a regex search will be performed within comments according to the // specified patterns in order to disable/enable processing. extern Option processing_cmt_as_regex; // Add or remove the UTF-8 BOM (recommend 'remove'). extern Option utf8_bom; // If the file contains bytes with values between 128 and 255, but is not // UTF-8, then output as UTF-8. extern Option utf8_byte; // Force the output encoding to UTF-8. extern Option utf8_force; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Spacing options // Add or remove space around non-assignment symbolic operators ('+', '/', '%', // '<<', and so forth). extern Option sp_arith; // Add or remove space around arithmetic operators '+' and '-'. // // Overrides sp_arith. extern Option sp_arith_additive; // Add or remove space around assignment operator '=', '+=', etc. extern Option sp_assign; // Add or remove space around '=' in C++11 lambda capture specifications. // // Overrides sp_assign. extern Option sp_cpp_lambda_assign; // Add or remove space after the capture specification of a C++11 lambda when // an argument list is present, as in '[] (int x){ ... }'. extern Option sp_cpp_lambda_square_paren; // Add or remove space after the capture specification of a C++11 lambda with // no argument list is present, as in '[] { ... }'. extern Option sp_cpp_lambda_square_brace; // Add or remove space after the opening parenthesis and before the closing // parenthesis of a argument list of a C++11 lambda, as in // '[]( int x ){ ... }'. extern Option sp_cpp_lambda_argument_list; // Add or remove space after the argument list of a C++11 lambda, as in // '[](int x) { ... }'. extern Option sp_cpp_lambda_paren_brace; // Add or remove space between a lambda body and its call operator of an // immediately invoked lambda, as in '[]( ... ){ ... } ( ... )'. extern Option sp_cpp_lambda_fparen; // Add or remove space around assignment operator '=' in a prototype. // // If set to ignore, use sp_assign. extern Option sp_assign_default; // Add or remove space before assignment operator '=', '+=', etc. // // Overrides sp_assign. extern Option sp_before_assign; // Add or remove space after assignment operator '=', '+=', etc. // // Overrides sp_assign. extern Option sp_after_assign; // Add or remove space in 'enum {'. extern Option sp_enum_brace; // = IARF_ADD // Add or remove space in 'NS_ENUM ('. extern Option sp_enum_paren; // Add or remove space around assignment '=' in enum. extern Option sp_enum_assign; // Add or remove space before assignment '=' in enum. // // Overrides sp_enum_assign. extern Option sp_enum_before_assign; // Add or remove space after assignment '=' in enum. // // Overrides sp_enum_assign. extern Option sp_enum_after_assign; // Add or remove space around assignment ':' in enum. extern Option sp_enum_colon; // Add or remove space around preprocessor '##' concatenation operator. extern Option sp_pp_concat; // = IARF_ADD // Add or remove space after preprocessor '#' stringify operator. // Also affects the '#@' charizing operator. extern Option sp_pp_stringify; // Add or remove space before preprocessor '#' stringify operator // as in '#define x(y) L#y'. extern Option sp_before_pp_stringify; // Add or remove space around boolean operators '&&' and '||'. extern Option sp_bool; // Add or remove space around compare operator '<', '>', '==', etc. extern Option sp_compare; // Add or remove space inside '(' and ')'. extern Option sp_inside_paren; // Add or remove space between nested parentheses, i.e. '((' vs. ') )'. extern Option sp_paren_paren; // Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('. extern Option sp_cparen_oparen; // Whether to balance spaces inside nested parentheses. extern Option sp_balance_nested_parens; // Add or remove space between ')' and '{'. extern Option sp_paren_brace; // Add or remove space between nested braces, i.e. '{{' vs. '{ {'. extern Option sp_brace_brace; // Add or remove space before pointer star '*'. extern Option sp_before_ptr_star; // Add or remove space before pointer star '*' that isn't followed by a // variable name. If set to ignore, sp_before_ptr_star is used instead. extern Option sp_before_unnamed_ptr_star; // Add or remove space between pointer stars '*', as in 'int ***a;'. extern Option sp_between_ptr_star; // Add or remove space after pointer star '*', if followed by a word. // // Overrides sp_type_func. extern Option sp_after_ptr_star; // Add or remove space after pointer caret '^', if followed by a word. extern Option sp_after_ptr_block_caret; // Add or remove space after pointer star '*', if followed by a qualifier. extern Option sp_after_ptr_star_qualifier; // Add or remove space after a pointer star '*', if followed by a function // prototype or function definition. // // Overrides sp_after_ptr_star and sp_type_func. extern Option sp_after_ptr_star_func; // Add or remove space after a pointer star '*' in the trailing return of a // function prototype or function definition. extern Option sp_after_ptr_star_trailing; // Add or remove space between the pointer star '*' and the name of the variable // in a function pointer definition. extern Option sp_ptr_star_func_var; // Add or remove space between the pointer star '*' and the name of the type // in a function pointer type definition. extern Option sp_ptr_star_func_type; // Add or remove space after a pointer star '*', if followed by an open // parenthesis, as in 'void* (*)()'. extern Option sp_ptr_star_paren; // Add or remove space before a pointer star '*', if followed by a function // prototype or function definition. extern Option sp_before_ptr_star_func; // Add or remove space before a pointer star '*' in the trailing return of a // function prototype or function definition. extern Option sp_before_ptr_star_trailing; // Add or remove space before a reference sign '&'. extern Option sp_before_byref; // Add or remove space before a reference sign '&' that isn't followed by a // variable name. If set to ignore, sp_before_byref is used instead. extern Option sp_before_unnamed_byref; // Add or remove space after reference sign '&', if followed by a word. // // Overrides sp_type_func. extern Option sp_after_byref; // Add or remove space after a reference sign '&', if followed by a function // prototype or function definition. // // Overrides sp_after_byref and sp_type_func. extern Option sp_after_byref_func; // Add or remove space before a reference sign '&', if followed by a function // prototype or function definition. extern Option sp_before_byref_func; // Add or remove space after a reference sign '&', if followed by an open // parenthesis, as in 'char& (*)()'. extern Option sp_byref_paren; // Add or remove space between type and word. In cases where total removal of // whitespace would be a syntax error, a value of 'remove' is treated the same // as 'force'. // // This also affects some other instances of space following a type that are // not covered by other options; for example, between the return type and // parenthesis of a function type template argument, between the type and // parenthesis of an array parameter, or between 'decltype(...)' and the // following word. extern Option sp_after_type; // = IARF_FORCE // Add or remove space between 'decltype(...)' and word, // brace or function call. extern Option sp_after_decltype; // (D) Add or remove space before the parenthesis in the D constructs // 'template Foo(' and 'class Foo('. extern Option sp_before_template_paren; // Add or remove space between 'template' and '<'. // If set to ignore, sp_before_angle is used. extern Option sp_template_angle; // Add or remove space before '<'. extern Option sp_before_angle; // Add or remove space inside '<' and '>'. extern Option sp_inside_angle; // Add or remove space inside '<>'. extern Option sp_inside_angle_empty; // Add or remove space between '>' and ':'. extern Option sp_angle_colon; // Add or remove space after '>'. extern Option sp_after_angle; // Add or remove space between '>' and '(' as found in 'new List(foo);'. extern Option sp_angle_paren; // Add or remove space between '>' and '()' as found in 'new List();'. extern Option sp_angle_paren_empty; // Add or remove space between '>' and a word as in 'List m;' or // 'template static ...'. extern Option sp_angle_word; // Add or remove space between '>' and '>' in '>>' (template stuff). extern Option sp_angle_shift; // = IARF_ADD // (C++11) Permit removal of the space between '>>' in 'foo >'. Note // that sp_angle_shift cannot remove the space without this option. extern Option sp_permit_cpp11_shift; // Add or remove space before '(' of control statements ('if', 'for', 'switch', // 'while', etc.). extern Option sp_before_sparen; // Add or remove space inside '(' and ')' of control statements other than // 'for'. extern Option sp_inside_sparen; // Add or remove space after '(' of control statements other than 'for'. // // Overrides sp_inside_sparen. extern Option sp_inside_sparen_open; // Add or remove space before ')' of control statements other than 'for'. // // Overrides sp_inside_sparen. extern Option sp_inside_sparen_close; // Add or remove space inside '(' and ')' of 'for' statements. extern Option sp_inside_for; // Add or remove space after '(' of 'for' statements. // // Overrides sp_inside_for. extern Option sp_inside_for_open; // Add or remove space before ')' of 'for' statements. // // Overrides sp_inside_for. extern Option sp_inside_for_close; // Add or remove space between '((' or '))' of control statements. extern Option sp_sparen_paren; // Add or remove space after ')' of control statements. extern Option sp_after_sparen; // Add or remove space between ')' and '{' of control statements. extern Option sp_sparen_brace; // Add or remove space between 'do' and '{'. extern Option sp_do_brace_open; // Add or remove space between '}' and 'while'. extern Option sp_brace_close_while; // Add or remove space between 'while' and '('. Overrides sp_before_sparen. extern Option sp_while_paren_open; // (D) Add or remove space between 'invariant' and '('. extern Option sp_invariant_paren; // (D) Add or remove space after the ')' in 'invariant (C) c'. extern Option sp_after_invariant_paren; // Add or remove space before empty statement ';' on 'if', 'for' and 'while'. extern Option sp_special_semi; // Add or remove space before ';'. extern Option sp_before_semi; // = IARF_REMOVE // Add or remove space before ';' in non-empty 'for' statements. extern Option sp_before_semi_for; // Add or remove space before a semicolon of an empty left part of a for // statement, as in 'for ( ; ; )'. extern Option sp_before_semi_for_empty; // Add or remove space between the semicolons of an empty middle part of a for // statement, as in 'for ( ; ; )'. extern Option sp_between_semi_for_empty; // Add or remove space after ';', except when followed by a comment. extern Option sp_after_semi; // = IARF_ADD // Add or remove space after ';' in non-empty 'for' statements. extern Option sp_after_semi_for; // = IARF_FORCE // Add or remove space after the final semicolon of an empty part of a for // statement, as in 'for ( ; ; )'. extern Option sp_after_semi_for_empty; // Add or remove space before '[' (except '[]'). extern Option sp_before_square; // Add or remove space before '[' for a variable definition. extern Option sp_before_vardef_square; // = IARF_REMOVE // Add or remove space before '[' for asm block. extern Option sp_before_square_asm_block; // Add or remove space before '[]'. extern Option sp_before_squares; // Add or remove space before C++17 structured bindings. extern Option sp_cpp_before_struct_binding; // Add or remove space inside a non-empty '[' and ']'. extern Option sp_inside_square; // Add or remove space inside '[]'. extern Option sp_inside_square_empty; // (OC) Add or remove space inside a non-empty Objective-C boxed array '@[' and // ']'. If set to ignore, sp_inside_square is used. extern Option sp_inside_square_oc_array; // Add or remove space after ',', i.e. 'a,b' vs. 'a, b'. extern Option sp_after_comma; // Add or remove space before ',', i.e. 'a,b' vs. 'a ,b'. extern Option sp_before_comma; // = IARF_REMOVE // (C#, Vala) Add or remove space between ',' and ']' in multidimensional array type // like 'int[,,]'. extern Option sp_after_mdatype_commas; // (C#, Vala) Add or remove space between '[' and ',' in multidimensional array type // like 'int[,,]'. extern Option sp_before_mdatype_commas; // (C#, Vala) Add or remove space between ',' in multidimensional array type // like 'int[,,]'. extern Option sp_between_mdatype_commas; // Add or remove space between an open parenthesis and comma, // i.e. '(,' vs. '( ,'. extern Option sp_paren_comma; // = IARF_FORCE // Add or remove space between a type and ':'. extern Option sp_type_colon; // Add or remove space after the variadic '...' when preceded by a // non-punctuator. // The value REMOVE will be overridden with FORCE extern Option sp_after_ellipsis; // Add or remove space before the variadic '...' when preceded by a // non-punctuator. // The value REMOVE will be overridden with FORCE extern Option sp_before_ellipsis; // Add or remove space between a type and '...'. extern Option sp_type_ellipsis; // Add or remove space between a '*' and '...'. extern Option sp_ptr_type_ellipsis; // Add or remove space between ')' and '...'. extern Option sp_paren_ellipsis; // Add or remove space between '&&' and '...'. extern Option sp_byref_ellipsis; // Add or remove space between ')' and a qualifier such as 'const'. extern Option sp_paren_qualifier; // Add or remove space between ')' and 'noexcept'. extern Option sp_paren_noexcept; // Add or remove space after class ':'. extern Option sp_after_class_colon; // Add or remove space before class ':'. extern Option sp_before_class_colon; // Add or remove space after class constructor ':'. extern Option sp_after_constr_colon; // = IARF_ADD // Add or remove space before class constructor ':'. extern Option sp_before_constr_colon; // = IARF_ADD // Add or remove space before case ':'. extern Option sp_before_case_colon; // = IARF_REMOVE // Add or remove space between 'operator' and operator sign. extern Option sp_after_operator; // Add or remove space between the operator symbol and the open parenthesis, as // in 'operator ++('. extern Option sp_after_operator_sym; // Overrides sp_after_operator_sym when the operator has no arguments, as in // 'operator *()'. extern Option sp_after_operator_sym_empty; // Add or remove space after C/D cast, i.e. 'cast(int)a' vs. 'cast(int) a' or // '(int)a' vs. '(int) a'. extern Option sp_after_cast; // Add or remove spaces inside cast parentheses. extern Option sp_inside_paren_cast; // Add or remove space between the type and open parenthesis in a C++ cast, // i.e. 'int(exp)' vs. 'int (exp)'. extern Option sp_cpp_cast_paren; // Add or remove space between 'sizeof' and '('. extern Option sp_sizeof_paren; // Add or remove space between 'sizeof' and '...'. extern Option sp_sizeof_ellipsis; // Add or remove space between 'sizeof...' and '('. extern Option sp_sizeof_ellipsis_paren; // Add or remove space between '...' and a parameter pack. extern Option sp_ellipsis_parameter_pack; // Add or remove space between a parameter pack and '...'. extern Option sp_parameter_pack_ellipsis; // Add or remove space between 'decltype' and '('. extern Option sp_decltype_paren; // (Pawn) Add or remove space after the tag keyword. extern Option sp_after_tag; // Add or remove space inside enum '{' and '}'. extern Option sp_inside_braces_enum; // Add or remove space inside struct/union '{' and '}'. extern Option sp_inside_braces_struct; // (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}' extern Option sp_inside_braces_oc_dict; // Add or remove space after open brace in an unnamed temporary // direct-list-initialization // if statement is a brace_init_lst // works only if sp_brace_brace is set to ignore. extern Option sp_after_type_brace_init_lst_open; // Add or remove space before close brace in an unnamed temporary // direct-list-initialization // if statement is a brace_init_lst // works only if sp_brace_brace is set to ignore. extern Option sp_before_type_brace_init_lst_close; // Add or remove space inside an unnamed temporary direct-list-initialization // if statement is a brace_init_lst // works only if sp_brace_brace is set to ignore // works only if sp_before_type_brace_init_lst_close is set to ignore. extern Option sp_inside_type_brace_init_lst; // Add or remove space inside '{' and '}'. extern Option sp_inside_braces; // Add or remove space inside '{}'. extern Option sp_inside_braces_empty; // Add or remove space around trailing return operator '->'. extern Option sp_trailing_return; // Add or remove space between return type and function name. A minimum of 1 // is forced except for pointer return types. extern Option sp_type_func; // Add or remove space between type and open brace of an unnamed temporary // direct-list-initialization. extern Option sp_type_brace_init_lst; // Add or remove space between function name and '(' on function declaration. extern Option sp_func_proto_paren; // Add or remove space between function name and '()' on function declaration // without parameters. extern Option sp_func_proto_paren_empty; // Add or remove space between function name and '(' with a typedef specifier. extern Option sp_func_type_paren; // Add or remove space between alias name and '(' of a non-pointer function type typedef. extern Option sp_func_def_paren; // Add or remove space between function name and '()' on function definition // without parameters. extern Option sp_func_def_paren_empty; // Add or remove space inside empty function '()'. // Overrides sp_after_angle unless use_sp_after_angle_always is set to true. extern Option sp_inside_fparens; // Add or remove space inside function '(' and ')'. extern Option sp_inside_fparen; // Add or remove space inside the first parentheses in a function type, as in // 'void (*x)(...)'. extern Option sp_inside_tparen; // Add or remove space between the ')' and '(' in a function type, as in // 'void (*x)(...)'. extern Option sp_after_tparen_close; // Add or remove space between ']' and '(' when part of a function call. extern Option sp_square_fparen; // Add or remove space between ')' and '{' of function. extern Option sp_fparen_brace; // Add or remove space between ')' and '{' of a function call in object // initialization. // // Overrides sp_fparen_brace. extern Option sp_fparen_brace_initializer; // (Java) Add or remove space between ')' and '{{' of double brace initializer. extern Option sp_fparen_dbrace; // Add or remove space between function name and '(' on function calls. extern Option sp_func_call_paren; // Add or remove space between function name and '()' on function calls without // parameters. If set to ignore (the default), sp_func_call_paren is used. extern Option sp_func_call_paren_empty; // Add or remove space between the user function name and '(' on function // calls. You need to set a keyword to be a user function in the config file, // like: // set func_call_user tr _ i18n extern Option sp_func_call_user_paren; // Add or remove space inside user function '(' and ')'. extern Option sp_func_call_user_inside_fparen; // Add or remove space between nested parentheses with user functions, // i.e. '((' vs. '( ('. extern Option sp_func_call_user_paren_paren; // Add or remove space between a constructor/destructor and the open // parenthesis. extern Option sp_func_class_paren; // Add or remove space between a constructor without parameters or destructor // and '()'. extern Option sp_func_class_paren_empty; // Add or remove space after 'return'. extern Option sp_return; // = IARF_FORCE // Add or remove space between 'return' and '('. extern Option sp_return_paren; // Add or remove space between 'return' and '{'. extern Option sp_return_brace; // Add or remove space between '__attribute__' and '('. extern Option sp_attribute_paren; // Add or remove space between 'defined' and '(' in '#if defined (FOO)'. extern Option sp_defined_paren; // Add or remove space between 'throw' and '(' in 'throw (something)'. extern Option sp_throw_paren; // Add or remove space between 'throw' and anything other than '(' as in // '@throw [...];'. extern Option sp_after_throw; // Add or remove space between 'catch' and '(' in 'catch (something) { }'. // If set to ignore, sp_before_sparen is used. extern Option sp_catch_paren; // (OC) Add or remove space between '@catch' and '(' // in '@catch (something) { }'. If set to ignore, sp_catch_paren is used. extern Option sp_oc_catch_paren; // (OC) Add or remove space before Objective-C protocol list // as in '@protocol Protocol' or '@interface MyClass : NSObject'. extern Option sp_before_oc_proto_list; // (OC) Add or remove space between class name and '(' // in '@interface className(categoryName):BaseClass' extern Option sp_oc_classname_paren; // (D) Add or remove space between 'version' and '(' // in 'version (something) { }'. If set to ignore, sp_before_sparen is used. extern Option sp_version_paren; // (D) Add or remove space between 'scope' and '(' // in 'scope (something) { }'. If set to ignore, sp_before_sparen is used. extern Option sp_scope_paren; // Add or remove space between 'super' and '(' in 'super (something)'. extern Option sp_super_paren; // = IARF_REMOVE // Add or remove space between 'this' and '(' in 'this (something)'. extern Option sp_this_paren; // = IARF_REMOVE // Add or remove space between a macro name and its definition. extern Option sp_macro; // Add or remove space between a macro function ')' and its definition. extern Option sp_macro_func; // Add or remove space between 'else' and '{' if on the same line. extern Option sp_else_brace; // Add or remove space between '}' and 'else' if on the same line. extern Option sp_brace_else; // Add or remove space between '}' and the name of a typedef on the same line. extern Option sp_brace_typedef; // Add or remove space before the '{' of a 'catch' statement, if the '{' and // 'catch' are on the same line, as in 'catch (decl) {'. extern Option sp_catch_brace; // (OC) Add or remove space before the '{' of a '@catch' statement, if the '{' // and '@catch' are on the same line, as in '@catch (decl) {'. // If set to ignore, sp_catch_brace is used. extern Option sp_oc_catch_brace; // Add or remove space between '}' and 'catch' if on the same line. extern Option sp_brace_catch; // (OC) Add or remove space between '}' and '@catch' if on the same line. // If set to ignore, sp_brace_catch is used. extern Option sp_oc_brace_catch; // Add or remove space between 'finally' and '{' if on the same line. extern Option sp_finally_brace; // Add or remove space between '}' and 'finally' if on the same line. extern Option sp_brace_finally; // Add or remove space between 'try' and '{' if on the same line. extern Option sp_try_brace; // Add or remove space between get/set and '{' if on the same line. extern Option sp_getset_brace; // Add or remove space between a variable and '{' for C++ uniform // initialization. extern Option sp_word_brace_init_lst; // Add or remove space between a variable and '{' for a namespace. extern Option sp_word_brace_ns; // = IARF_ADD // Add or remove space before the '::' operator. extern Option sp_before_dc; // Add or remove space after the '::' operator. extern Option sp_after_dc; // (D) Add or remove around the D named array initializer ':' operator. extern Option sp_d_array_colon; // Add or remove space after the '!' (not) unary operator. extern Option sp_not; // = IARF_REMOVE // Add or remove space between two '!' (not) unary operators. // If set to ignore, sp_not will be used. extern Option sp_not_not; // = IARF_IGNORE // Add or remove space after the '~' (invert) unary operator. extern Option sp_inv; // = IARF_REMOVE // Add or remove space after the '&' (address-of) unary operator. This does not // affect the spacing after a '&' that is part of a type. extern Option sp_addr; // = IARF_REMOVE // Add or remove space around the '.' or '->' operators. extern Option sp_member; // = IARF_REMOVE // Add or remove space after the '*' (dereference) unary operator. This does // not affect the spacing after a '*' that is part of a type. extern Option sp_deref; // = IARF_REMOVE // Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. extern Option sp_sign; // = IARF_REMOVE // Add or remove space between '++' and '--' the word to which it is being // applied, as in '(--x)' or 'y++;'. extern Option sp_incdec; // = IARF_REMOVE // Add or remove space before a backslash-newline at the end of a line. extern Option sp_before_nl_cont; // = IARF_ADD // (OC) Add or remove space after the scope '+' or '-', as in '-(void) foo;' // or '+(int) bar;'. extern Option sp_after_oc_scope; // (OC) Add or remove space after the colon in message specs, // i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'. extern Option sp_after_oc_colon; // (OC) Add or remove space before the colon in message specs, // i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'. extern Option sp_before_oc_colon; // (OC) Add or remove space after the colon in immutable dictionary expression // 'NSDictionary *test = @{@"foo" :@"bar"};'. extern Option sp_after_oc_dict_colon; // (OC) Add or remove space before the colon in immutable dictionary expression // 'NSDictionary *test = @{@"foo" :@"bar"};'. extern Option sp_before_oc_dict_colon; // (OC) Add or remove space after the colon in message specs, // i.e. '[object setValue:1];' vs. '[object setValue: 1];'. extern Option sp_after_send_oc_colon; // (OC) Add or remove space before the colon in message specs, // i.e. '[object setValue:1];' vs. '[object setValue :1];'. extern Option sp_before_send_oc_colon; // (OC) Add or remove space after the (type) in message specs, // i.e. '-(int)f: (int) x;' vs. '-(int)f: (int)x;'. extern Option sp_after_oc_type; // (OC) Add or remove space after the first (type) in message specs, // i.e. '-(int) f:(int)x;' vs. '-(int)f:(int)x;'. extern Option sp_after_oc_return_type; // (OC) Add or remove space between '@selector' and '(', // i.e. '@selector(msgName)' vs. '@selector (msgName)'. // Also applies to '@protocol()' constructs. extern Option sp_after_oc_at_sel; // (OC) Add or remove space between '@selector(x)' and the following word, // i.e. '@selector(foo) a:' vs. '@selector(foo)a:'. extern Option sp_after_oc_at_sel_parens; // (OC) Add or remove space inside '@selector' parentheses, // i.e. '@selector(foo)' vs. '@selector( foo )'. // Also applies to '@protocol()' constructs. extern Option sp_inside_oc_at_sel_parens; // (OC) Add or remove space before a block pointer caret, // i.e. '^int (int arg){...}' vs. ' ^int (int arg){...}'. extern Option sp_before_oc_block_caret; // (OC) Add or remove space after a block pointer caret, // i.e. '^int (int arg){...}' vs. '^ int (int arg){...}'. extern Option sp_after_oc_block_caret; // (OC) Add or remove space between the receiver and selector in a message, // as in '[receiver selector ...]'. extern Option sp_after_oc_msg_receiver; // (OC) Add or remove space after '@property'. extern Option sp_after_oc_property; // (OC) Add or remove space between '@synchronized' and the open parenthesis, // i.e. '@synchronized(foo)' vs. '@synchronized (foo)'. extern Option sp_after_oc_synchronized; // Add or remove space around the ':' in 'b ? t : f'. extern Option sp_cond_colon; // Add or remove space before the ':' in 'b ? t : f'. // // Overrides sp_cond_colon. extern Option sp_cond_colon_before; // Add or remove space after the ':' in 'b ? t : f'. // // Overrides sp_cond_colon. extern Option sp_cond_colon_after; // Add or remove space around the '?' in 'b ? t : f'. extern Option sp_cond_question; // Add or remove space before the '?' in 'b ? t : f'. // // Overrides sp_cond_question. extern Option sp_cond_question_before; // Add or remove space after the '?' in 'b ? t : f'. // // Overrides sp_cond_question. extern Option sp_cond_question_after; // In the abbreviated ternary form '(a ?: b)', add or remove space between '?' // and ':'. // // Overrides all other sp_cond_* options. extern Option sp_cond_ternary_short; // Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make // sense here. extern Option sp_case_label; // (D) Add or remove space around the D '..' operator. extern Option sp_range; // Add or remove space after ':' in a Java/C++11 range-based 'for', // as in 'for (Type var : expr)'. extern Option sp_after_for_colon; // Add or remove space before ':' in a Java/C++11 range-based 'for', // as in 'for (Type var : expr)'. extern Option sp_before_for_colon; // (D) Add or remove space between 'extern' and '(' as in 'extern (C)'. extern Option sp_extern_paren; // Add or remove space after the opening of a C++ comment, as in '// A'. extern Option sp_cmt_cpp_start; // Add or remove space in a C++ region marker comment, as in '// BEGIN'. // A region marker is defined as a comment which is not preceded by other text // (i.e. the comment is the first non-whitespace on the line), and which starts // with either 'BEGIN' or 'END'. // // Overrides sp_cmt_cpp_start. extern Option sp_cmt_cpp_region; // If true, space added with sp_cmt_cpp_start will be added after Doxygen // sequences like '///', '///<', '//!' and '//!<'. extern Option sp_cmt_cpp_doxygen; // If true, space added with sp_cmt_cpp_start will be added after Qt translator // or meta-data comments like '//:', '//=', and '//~'. extern Option sp_cmt_cpp_qttr; // Add or remove space between #else or #endif and a trailing comment. extern Option sp_endif_cmt; // Add or remove space after 'new', 'delete' and 'delete[]'. extern Option sp_after_new; // Add or remove space between 'new' and '(' in 'new()'. extern Option sp_between_new_paren; // Add or remove space between ')' and type in 'new(foo) BAR'. extern Option sp_after_newop_paren; // Add or remove space inside parentheses of the new operator // as in 'new(foo) BAR'. extern Option sp_inside_newop_paren; // Add or remove space after the open parenthesis of the new operator, // as in 'new(foo) BAR'. // // Overrides sp_inside_newop_paren. extern Option sp_inside_newop_paren_open; // Add or remove space before the close parenthesis of the new operator, // as in 'new(foo) BAR'. // // Overrides sp_inside_newop_paren. extern Option sp_inside_newop_paren_close; // Add or remove space before a trailing comment. extern Option sp_before_tr_cmt; // Number of spaces before a trailing comment. extern BoundedOption sp_num_before_tr_cmt; // Add or remove space before an embedded comment. extern Option sp_before_emb_cmt; // = IARF_FORCE // Number of spaces before an embedded comment. extern BoundedOption sp_num_before_emb_cmt; // = 1 // Add or remove space after an embedded comment. extern Option sp_after_emb_cmt; // = IARF_FORCE // Number of spaces after an embedded comment. extern BoundedOption sp_num_after_emb_cmt; // = 1 // (Java) Add or remove space between an annotation and the open parenthesis. extern Option sp_annotation_paren; // If true, vbrace tokens are dropped to the previous token and skipped. extern Option sp_skip_vbrace_tokens; // Add or remove space after 'noexcept'. extern Option sp_after_noexcept; // Add or remove space after '_'. extern Option sp_vala_after_translation; // If true, a is inserted after #define. extern Option force_tab_after_define; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Indenting options // The number of columns to indent per level. Usually 2, 3, 4, or 8. extern BoundedOption indent_columns; // = 8 // Whether to ignore indent for the first continuation line. Subsequent // continuation lines will still be indented to match the first. extern Option indent_ignore_first_continue; // The continuation indent. If non-zero, this overrides the indent of '(', '[' // and '=' continuation indents. Negative values are OK; negative value is // absolute and not increased for each '(' or '[' level. // // For FreeBSD, this is set to 4. // Requires indent_ignore_first_continue=false. extern BoundedOption indent_continue; // The continuation indent, only for class header line(s). If non-zero, this // overrides the indent of 'class' continuation indents. // Requires indent_ignore_first_continue=false. extern BoundedOption indent_continue_class_head; // Whether to indent empty lines (i.e. lines which contain only spaces before // the newline character). extern Option indent_single_newlines; // The continuation indent for func_*_param if they are true. If non-zero, this // overrides the indent. extern BoundedOption indent_param; // How to use tabs when indenting code. // // 0: Spaces only // 1: Indent with tabs to brace level, align with spaces (default) // 2: Indent and align with tabs, using spaces when not on a tabstop extern BoundedOption indent_with_tabs; // = 1 // Whether to indent comments that are not at a brace level with tabs on a // tabstop. Requires indent_with_tabs=2. If false, will use spaces. extern Option indent_cmt_with_tabs; // Whether to indent strings broken by '\' so that they line up. extern Option indent_align_string; // The number of spaces to indent multi-line XML strings. // Requires indent_align_string=true. extern BoundedOption indent_xml_string; // Spaces to indent '{' from level. extern BoundedOption indent_brace; // Whether braces are indented to the body level. extern Option indent_braces; // Whether to disable indenting function braces if indent_braces=true. extern Option indent_braces_no_func; // Whether to disable indenting class braces if indent_braces=true. extern Option indent_braces_no_class; // Whether to disable indenting struct braces if indent_braces=true. extern Option indent_braces_no_struct; // Whether to indent based on the size of the brace parent, // i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc. extern Option indent_brace_parent; // Whether to indent based on the open parenthesis instead of the open brace // in '({\n'. extern Option indent_paren_open_brace; // (C#) Whether to indent the brace of a C# delegate by another level. extern Option indent_cs_delegate_brace; // (C#) Whether to indent a C# delegate (to handle delegates with no brace) by // another level. extern Option indent_cs_delegate_body; // Whether to indent the body of a 'namespace'. extern Option indent_namespace; // Whether to indent only the first namespace, and not any nested namespaces. // Requires indent_namespace=true. extern Option indent_namespace_single_indent; // The number of spaces to indent a namespace block. // If set to zero, use the value indent_columns extern BoundedOption indent_namespace_level; // If the body of the namespace is longer than this number, it won't be // indented. Requires indent_namespace=true. 0 means no limit. extern BoundedOption indent_namespace_limit; // Whether to indent only in inner namespaces (nested in other namespaces). // Requires indent_namespace=true. extern Option indent_namespace_inner_only; // Whether the 'extern "C"' body is indented. extern Option indent_extern; // Whether the 'class' body is indented. extern Option indent_class; // Whether to ignore indent for the leading base class colon. extern Option indent_ignore_before_class_colon; // Additional indent before the leading base class colon. // Negative values decrease indent down to the first column. // Requires indent_ignore_before_class_colon=false and a newline break before // the colon (see pos_class_colon and nl_class_colon) extern BoundedOption indent_before_class_colon; // Whether to indent the stuff after a leading base class colon. extern Option indent_class_colon; // Whether to indent based on a class colon instead of the stuff after the // colon. Requires indent_class_colon=true. extern Option indent_class_on_colon; // Whether to ignore indent for a leading class initializer colon. extern Option indent_ignore_before_constr_colon; // Whether to indent the stuff after a leading class initializer colon. extern Option indent_constr_colon; // Virtual indent from the ':' for leading member initializers. extern BoundedOption indent_ctor_init_leading; // = 2 // Virtual indent from the ':' for following member initializers. extern BoundedOption indent_ctor_init_following; // = 2 // Additional indent for constructor initializer list. // Negative values decrease indent down to the first column. extern BoundedOption indent_ctor_init; // Whether to indent 'if' following 'else' as a new block under the 'else'. // If false, 'else\nif' is treated as 'else if' for indenting purposes. extern Option indent_else_if; // Amount to indent variable declarations after a open brace. // // <0: Relative // >=0: Absolute extern BoundedOption indent_var_def_blk; // Whether to indent continued variable declarations instead of aligning. extern Option indent_var_def_cont; // How to indent continued shift expressions ('<<' and '>>'). // Set align_left_shift=false when using this. // 0: Align shift operators instead of indenting them (default) // 1: Indent by one level // -1: Preserve original indentation extern BoundedOption indent_shift; // Whether to force indentation of function definitions to start in column 1. extern Option indent_func_def_force_col1; // Whether to indent continued function call parameters one indent level, // rather than aligning parameters under the open parenthesis. extern Option indent_func_call_param; // Whether to indent continued function definition parameters one indent level, // rather than aligning parameters under the open parenthesis. extern Option indent_func_def_param; // for function definitions, only if indent_func_def_param is false // Allows to align params when appropriate and indent them when not // behave as if it was true if paren position is more than this value // if paren position is more than the option value extern BoundedOption indent_func_def_param_paren_pos_threshold; // Whether to indent continued function call prototype one indent level, // rather than aligning parameters under the open parenthesis. extern Option indent_func_proto_param; // Whether to indent continued function call declaration one indent level, // rather than aligning parameters under the open parenthesis. extern Option indent_func_class_param; // Whether to indent continued class variable constructors one indent level, // rather than aligning parameters under the open parenthesis. extern Option indent_func_ctor_var_param; // Whether to indent continued template parameter list one indent level, // rather than aligning parameters under the open parenthesis. extern Option indent_template_param; // Double the indent for indent_func_xxx_param options. // Use both values of the options indent_columns and indent_param. extern Option indent_func_param_double; // Indentation column for standalone 'const' qualifier on a function // prototype. extern BoundedOption indent_func_const; // Indentation column for standalone 'throw' qualifier on a function // prototype. extern BoundedOption indent_func_throw; // How to indent within a macro followed by a brace on the same line // This allows reducing the indent in macros that have (for example) // `do { ... } while (0)` blocks bracketing them. // // true: add an indent for the brace on the same line as the macro // false: do not add an indent for the brace on the same line as the macro extern Option indent_macro_brace; // = true // The number of spaces to indent a continued '->' or '.'. // Usually set to 0, 1, or indent_columns. extern BoundedOption indent_member; // Whether lines broken at '.' or '->' should be indented by a single indent. // The indent_member option will not be effective if this is set to true. extern Option indent_member_single; // Spaces to indent single line ('//') comments on lines before code. extern BoundedOption indent_single_line_comments_before; // Spaces to indent single line ('//') comments on lines after code. extern BoundedOption indent_single_line_comments_after; // When opening a paren for a control statement (if, for, while, etc), increase // the indent level by this value. Negative values decrease the indent level. extern BoundedOption indent_sparen_extra; // Whether to indent trailing single line ('//') comments relative to the code // instead of trying to keep the same absolute column. extern Option indent_relative_single_line_comments; // Spaces to indent 'case' from 'switch'. Usually 0 or indent_columns. // It might be wise to choose the same value for the option indent_case_brace. extern BoundedOption indent_switch_case; // Spaces to indent the body of a 'switch' before any 'case'. // Usually the same as indent_columns or indent_switch_case. extern BoundedOption indent_switch_body; // Whether to ignore indent for '{' following 'case'. extern Option indent_ignore_case_brace; // Spaces to indent '{' from 'case'. By default, the brace will appear under // the 'c' in case. Usually set to 0 or indent_columns. Negative values are OK. // It might be wise to choose the same value for the option indent_switch_case. extern BoundedOption indent_case_brace; // indent 'break' with 'case' from 'switch'. extern Option indent_switch_break_with_case; // Whether to indent preprocessor statements inside of switch statements. extern Option indent_switch_pp; // = true // Spaces to shift the 'case' line, without affecting any other lines. // Usually 0. extern BoundedOption indent_case_shift; // Whether to align comments before 'case' with the 'case'. extern Option indent_case_comment; // = true // Whether to indent comments not found in first column. extern Option indent_comment; // = true // Whether to indent comments found in first column. extern Option indent_col1_comment; // Whether to indent multi string literal in first column. extern Option indent_col1_multi_string_literal; // Align comments on adjacent lines that are this many columns apart or less. extern BoundedOption indent_comment_align_thresh; // = 3 // Whether to ignore indent for goto labels. extern Option indent_ignore_label; // How to indent goto labels. Requires indent_ignore_label=false. // // >0: Absolute column where 1 is the leftmost column // <=0: Subtract from brace indent extern BoundedOption indent_label; // = 1 // How to indent access specifiers that are followed by a // colon. // // >0: Absolute column where 1 is the leftmost column // <=0: Subtract from brace indent extern BoundedOption indent_access_spec; // = 1 // Whether to indent the code after an access specifier by one level. // If true, this option forces 'indent_access_spec=0'. extern Option indent_access_spec_body; // If an open parenthesis is followed by a newline, whether to indent the next // line so that it lines up after the open parenthesis (not recommended). extern Option indent_paren_nl; // How to indent a close parenthesis after a newline. // // 0: Indent to body level (default) // 1: Align under the open parenthesis // 2: Indent to the brace level // -1: Preserve original indentation extern BoundedOption indent_paren_close; // Whether to indent the open parenthesis of a function definition, // if the parenthesis is on its own line. extern Option indent_paren_after_func_def; // Whether to indent the open parenthesis of a function declaration, // if the parenthesis is on its own line. extern Option indent_paren_after_func_decl; // Whether to indent the open parenthesis of a function call, // if the parenthesis is on its own line. extern Option indent_paren_after_func_call; // How to indent a comma when inside braces. // 0: Indent by one level (default) // 1: Align under the open brace // -1: Preserve original indentation extern BoundedOption indent_comma_brace; // How to indent a comma when inside parentheses. // 0: Indent by one level (default) // 1: Align under the open parenthesis // -1: Preserve original indentation extern BoundedOption indent_comma_paren; // How to indent a Boolean operator when inside parentheses. // 0: Indent by one level (default) // 1: Align under the open parenthesis // -1: Preserve original indentation extern BoundedOption indent_bool_paren; // Whether to ignore the indentation of a Boolean operator when outside // parentheses. extern Option indent_ignore_bool; // Whether to ignore the indentation of an arithmetic operator. extern Option indent_ignore_arith; // Whether to indent a semicolon when inside a for parenthesis. // If true, aligns under the open for parenthesis. extern Option indent_semicolon_for_paren; // Whether to ignore the indentation of a semicolon outside of a 'for' // statement. extern Option indent_ignore_semicolon; // Whether to align the first expression to following ones // if indent_bool_paren=1. extern Option indent_first_bool_expr; // Whether to align the first expression to following ones // if indent_semicolon_for_paren=true. extern Option indent_first_for_expr; // If an open square is followed by a newline, whether to indent the next line // so that it lines up after the open square (not recommended). extern Option indent_square_nl; // (ESQL/C) Whether to preserve the relative indent of 'EXEC SQL' bodies. extern Option indent_preserve_sql; // Whether to ignore the indentation of an assignment operator. extern Option indent_ignore_assign; // Whether to align continued statements at the '='. If false or if the '=' is // followed by a newline, the next line is indent one tab. extern Option indent_align_assign; // = true // If true, the indentation of the chunks after a '=' sequence will be set at // LHS token indentation column before '='. extern Option indent_off_after_assign; // Whether to align continued statements at the '('. If false or the '(' is // followed by a newline, the next line indent is one tab. extern Option indent_align_paren; // = true // (OC) Whether to indent Objective-C code inside message selectors. extern Option indent_oc_inside_msg_sel; // (OC) Whether to indent Objective-C blocks at brace level instead of usual // rules. extern Option indent_oc_block; // (OC) Indent for Objective-C blocks in a message relative to the parameter // name. // // =0: Use indent_oc_block rules // >0: Use specified number of spaces to indent extern BoundedOption indent_oc_block_msg; // (OC) Minimum indent for subsequent parameters extern BoundedOption indent_oc_msg_colon; // (OC) Whether to prioritize aligning with initial colon (and stripping spaces // from lines, if necessary). extern Option indent_oc_msg_prioritize_first_colon; // = true // (OC) Whether to indent blocks the way that Xcode does by default // (from the keyword if the parameter is on its own line; otherwise, from the // previous indentation level). Requires indent_oc_block_msg=true. extern Option indent_oc_block_msg_xcode_style; // (OC) Whether to indent blocks from where the brace is, relative to a // message keyword. Requires indent_oc_block_msg=true. extern Option indent_oc_block_msg_from_keyword; // (OC) Whether to indent blocks from where the brace is, relative to a message // colon. Requires indent_oc_block_msg=true. extern Option indent_oc_block_msg_from_colon; // (OC) Whether to indent blocks from where the block caret is. // Requires indent_oc_block_msg=true. extern Option indent_oc_block_msg_from_caret; // (OC) Whether to indent blocks from where the brace caret is. // Requires indent_oc_block_msg=true. extern Option indent_oc_block_msg_from_brace; // When indenting after virtual brace open and newline add further spaces to // reach this minimum indent. extern BoundedOption indent_min_vbrace_open; // Whether to add further spaces after regular indent to reach next tabstop // when indenting after virtual brace open and newline. extern Option indent_vbrace_open_on_tabstop; // How to indent after a brace followed by another token (not a newline). // true: indent all contained lines to match the token // false: indent all contained lines to match the brace extern Option indent_token_after_brace; // = true // Whether to indent the body of a C++11 lambda. extern Option indent_cpp_lambda_body; // How to indent compound literals that are being returned. // true: add both the indent from return & the compound literal open brace // (i.e. 2 indent levels) // false: only indent 1 level, don't add the indent for the open brace, only // add the indent for the return. extern Option indent_compound_literal_return; // = true // (C#) Whether to indent a 'using' block if no braces are used. extern Option indent_using_block; // = true // How to indent the continuation of ternary operator. // // 0: Off (default) // 1: When the `if_false` is a continuation, indent it under the `if_true` branch // 2: When the `:` is a continuation, indent it under `?` extern BoundedOption indent_ternary_operator; // Whether to indent the statements inside ternary operator. extern Option indent_inside_ternary_operator; // If true, the indentation of the chunks after a `return` sequence will be set at return indentation column. extern Option indent_off_after_return; // If true, the indentation of the chunks after a `return new` sequence will be set at return indentation column. extern Option indent_off_after_return_new; // If true, the tokens after return are indented with regular single indentation. By default (false) the indentation is after the return token. extern Option indent_single_after_return; // Whether to ignore indent and alignment for 'asm' blocks (i.e. assume they // have their own indentation). extern Option indent_ignore_asm_block; // Don't indent the close parenthesis of a function definition, // if the parenthesis is on its own line. extern Option donot_indent_func_def_close_paren; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Newline adding and removing options // Whether to collapse empty blocks between '{' and '}' except for functions. // Use nl_collapse_empty_body_functions to specify how empty function braces // should be formatted. extern Option nl_collapse_empty_body; // Whether to collapse empty blocks between '{' and '}' for functions only. // If true, overrides nl_inside_empty_func. extern Option nl_collapse_empty_body_functions; // Don't split one-line braced assignments, as in 'foo_t f = { 1, 2 };'. extern Option nl_assign_leave_one_liners; // Don't split one-line braced statements inside a 'class xx { }' body. extern Option nl_class_leave_one_liners; // Don't split one-line enums, as in 'enum foo { BAR = 15 };' extern Option nl_enum_leave_one_liners; // Don't split one-line get or set functions. extern Option nl_getset_leave_one_liners; // (C#) Don't split one-line property get or set functions. extern Option nl_cs_property_leave_one_liners; // Don't split one-line function definitions, as in 'int foo() { return 0; }'. // might modify nl_func_type_name extern Option nl_func_leave_one_liners; // Don't split one-line C++11 lambdas, as in '[]() { return 0; }'. extern Option nl_cpp_lambda_leave_one_liners; // Don't split one-line if/else statements, as in 'if(...) b++;'. extern Option nl_if_leave_one_liners; // Don't split one-line while statements, as in 'while(...) b++;'. extern Option nl_while_leave_one_liners; // Don't split one-line do statements, as in 'do { b++; } while(...);'. extern Option nl_do_leave_one_liners; // Don't split one-line for statements, as in 'for(...) b++;'. extern Option nl_for_leave_one_liners; // (OC) Don't split one-line Objective-C messages. extern Option nl_oc_msg_leave_one_liner; // (OC) Add or remove newline between method declaration and '{'. extern Option nl_oc_mdef_brace; // (OC) Add or remove newline between Objective-C block signature and '{'. extern Option nl_oc_block_brace; // (OC) Add or remove blank line before '@interface' statement. extern Option nl_oc_before_interface; // (OC) Add or remove blank line before '@implementation' statement. extern Option nl_oc_before_implementation; // (OC) Add or remove blank line before '@end' statement. extern Option nl_oc_before_end; // (OC) Add or remove newline between '@interface' and '{'. extern Option nl_oc_interface_brace; // (OC) Add or remove newline between '@implementation' and '{'. extern Option nl_oc_implementation_brace; // Add or remove newlines at the start of the file. extern Option nl_start_of_file; // The minimum number of newlines at the start of the file (only used if // nl_start_of_file is 'add' or 'force'). extern BoundedOption nl_start_of_file_min; // Add or remove newline at the end of the file. extern Option nl_end_of_file; // The minimum number of newlines at the end of the file (only used if // nl_end_of_file is 'add' or 'force'). extern BoundedOption nl_end_of_file_min; // Add or remove newline between '=' and '{'. extern Option nl_assign_brace; // (D) Add or remove newline between '=' and '['. extern Option nl_assign_square; // Add or remove newline between '[]' and '{'. extern Option nl_tsquare_brace; // (D) Add or remove newline after '= ['. Will also affect the newline before // the ']'. extern Option nl_after_square_assign; // Add or remove newline between a function call's ')' and '{', as in // 'list_for_each(item, &list) { }'. extern Option nl_fcall_brace; // Add or remove newline between 'enum' and '{'. extern Option nl_enum_brace; // Add or remove newline between 'enum' and 'class'. extern Option nl_enum_class; // Add or remove newline between 'enum class' and the identifier. extern Option nl_enum_class_identifier; // Add or remove newline between 'enum class' type and ':'. extern Option nl_enum_identifier_colon; // Add or remove newline between 'enum class identifier :' and type. extern Option nl_enum_colon_type; // Add or remove newline between 'struct and '{'. extern Option nl_struct_brace; // Add or remove newline between 'union' and '{'. extern Option nl_union_brace; // Add or remove newline between 'if' and '{'. extern Option nl_if_brace; // Add or remove newline between '}' and 'else'. extern Option nl_brace_else; // Add or remove newline between 'else if' and '{'. If set to ignore, // nl_if_brace is used instead. extern Option nl_elseif_brace; // Add or remove newline between 'else' and '{'. extern Option nl_else_brace; // Add or remove newline between 'else' and 'if'. extern Option nl_else_if; // Add or remove newline before '{' opening brace extern Option nl_before_opening_brace_func_class_def; // Add or remove newline before 'if'/'else if' closing parenthesis. extern Option nl_before_if_closing_paren; // Add or remove newline between '}' and 'finally'. extern Option nl_brace_finally; // Add or remove newline between 'finally' and '{'. extern Option nl_finally_brace; // Add or remove newline between 'try' and '{'. extern Option nl_try_brace; // Add or remove newline between get/set and '{'. extern Option nl_getset_brace; // Add or remove newline between 'for' and '{'. extern Option nl_for_brace; // Add or remove newline before the '{' of a 'catch' statement, as in // 'catch (decl) {'. extern Option nl_catch_brace; // (OC) Add or remove newline before the '{' of a '@catch' statement, as in // '@catch (decl) {'. If set to ignore, nl_catch_brace is used. extern Option nl_oc_catch_brace; // Add or remove newline between '}' and 'catch'. extern Option nl_brace_catch; // (OC) Add or remove newline between '}' and '@catch'. If set to ignore, // nl_brace_catch is used. extern Option nl_oc_brace_catch; // Add or remove newline between '}' and ']'. extern Option nl_brace_square; // Add or remove newline between '}' and ')' in a function invocation. extern Option nl_brace_fparen; // Add or remove newline between 'while' and '{'. extern Option nl_while_brace; // (D) Add or remove newline between 'scope (x)' and '{'. extern Option nl_scope_brace; // (D) Add or remove newline between 'unittest' and '{'. extern Option nl_unittest_brace; // (D) Add or remove newline between 'version (x)' and '{'. extern Option nl_version_brace; // (C#) Add or remove newline between 'using' and '{'. extern Option nl_using_brace; // Add or remove newline between two open or close braces. Due to general // newline/brace handling, REMOVE may not work. extern Option nl_brace_brace; // Add or remove newline between 'do' and '{'. extern Option nl_do_brace; // Add or remove newline between '}' and 'while' of 'do' statement. extern Option nl_brace_while; // Add or remove newline between 'switch' and '{'. extern Option nl_switch_brace; // Add or remove newline between 'synchronized' and '{'. extern Option nl_synchronized_brace; // Add a newline between ')' and '{' if the ')' is on a different line than the // if/for/etc. // // Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch and // nl_catch_brace. extern Option nl_multi_line_cond; // Add a newline after '(' if an if/for/while/switch condition spans multiple // lines extern Option nl_multi_line_sparen_open; // Add a newline before ')' if an if/for/while/switch condition spans multiple // lines. Overrides nl_before_if_closing_paren if both are specified. extern Option nl_multi_line_sparen_close; // Force a newline in a define after the macro name for multi-line defines. extern Option nl_multi_line_define; // Whether to add a newline before 'case', and a blank line before a 'case' // statement that follows a ';' or '}'. extern Option nl_before_case; // Whether to add a newline after a 'case' statement. extern Option nl_after_case; // Add or remove newline between a case ':' and '{'. // // Overrides nl_after_case. extern Option nl_case_colon_brace; // Add or remove newline between ')' and 'throw'. extern Option nl_before_throw; // Add or remove newline between 'namespace' and '{'. extern Option nl_namespace_brace; // Add or remove newline after 'template<...>' of a template class. extern Option nl_template_class; // Add or remove newline after 'template<...>' of a template class declaration. // // Overrides nl_template_class. extern Option nl_template_class_decl; // Add or remove newline after 'template<>' of a specialized class declaration. // // Overrides nl_template_class_decl. extern Option nl_template_class_decl_special; // Add or remove newline after 'template<...>' of a template class definition. // // Overrides nl_template_class. extern Option nl_template_class_def; // Add or remove newline after 'template<>' of a specialized class definition. // // Overrides nl_template_class_def. extern Option nl_template_class_def_special; // Add or remove newline after 'template<...>' of a template function. extern Option nl_template_func; // Add or remove newline after 'template<...>' of a template function // declaration. // // Overrides nl_template_func. extern Option nl_template_func_decl; // Add or remove newline after 'template<>' of a specialized function // declaration. // // Overrides nl_template_func_decl. extern Option nl_template_func_decl_special; // Add or remove newline after 'template<...>' of a template function // definition. // // Overrides nl_template_func. extern Option nl_template_func_def; // Add or remove newline after 'template<>' of a specialized function // definition. // // Overrides nl_template_func_def. extern Option nl_template_func_def_special; // Add or remove newline after 'template<...>' of a template variable. extern Option nl_template_var; // Add or remove newline between 'template<...>' and 'using' of a templated // type alias. extern Option nl_template_using; // Add or remove newline between 'class' and '{'. extern Option nl_class_brace; // Add or remove newline before or after (depending on pos_class_comma, // may not be IGNORE) each',' in the base class list. extern Option nl_class_init_args; // Add or remove newline after each ',' in the constructor member // initialization. Related to nl_constr_colon, pos_constr_colon and // pos_constr_comma. extern Option nl_constr_init_args; // Add or remove newline before first element, after comma, and after last // element, in 'enum'. extern Option nl_enum_own_lines; // Add or remove newline between return type and function name in a function // definition. // might be modified by nl_func_leave_one_liners extern Option nl_func_type_name; // Add or remove newline between return type and function name inside a class // definition. If set to ignore, nl_func_type_name or nl_func_proto_type_name // is used instead. extern Option nl_func_type_name_class; // Add or remove newline between class specification and '::' // in 'void A::f() { }'. Only appears in separate member implementation (does // not appear with in-line implementation). extern Option nl_func_class_scope; // Add or remove newline between function scope and name, as in // 'void A :: f() { }'. extern Option nl_func_scope_name; // Add or remove newline between return type and function name in a prototype. extern Option nl_func_proto_type_name; // Add or remove newline between a function name and the opening '(' in the // declaration. extern Option nl_func_paren; // Overrides nl_func_paren for functions with no parameters. extern Option nl_func_paren_empty; // Add or remove newline between a function name and the opening '(' in the // definition. extern Option nl_func_def_paren; // Overrides nl_func_def_paren for functions with no parameters. extern Option nl_func_def_paren_empty; // Add or remove newline between a function name and the opening '(' in the // call. extern Option nl_func_call_paren; // Overrides nl_func_call_paren for functions with no parameters. extern Option nl_func_call_paren_empty; // Add or remove newline after '(' in a function declaration. extern Option nl_func_decl_start; // Add or remove newline after '(' in a function definition. extern Option nl_func_def_start; // Overrides nl_func_decl_start when there is only one parameter. extern Option nl_func_decl_start_single; // Overrides nl_func_def_start when there is only one parameter. extern Option nl_func_def_start_single; // Whether to add a newline after '(' in a function declaration if '(' and ')' // are in different lines. If false, nl_func_decl_start is used instead. extern Option nl_func_decl_start_multi_line; // Whether to add a newline after '(' in a function definition if '(' and ')' // are in different lines. If false, nl_func_def_start is used instead. extern Option nl_func_def_start_multi_line; // Add or remove newline after each ',' in a function declaration. extern Option nl_func_decl_args; // Add or remove newline after each ',' in a function definition. extern Option nl_func_def_args; // Add or remove newline after each ',' in a function call. extern Option nl_func_call_args; // Whether to add a newline after each ',' in a function declaration if '(' // and ')' are in different lines. If false, nl_func_decl_args is used instead. extern Option nl_func_decl_args_multi_line; // Whether to add a newline after each ',' in a function definition if '(' // and ')' are in different lines. If false, nl_func_def_args is used instead. extern Option nl_func_def_args_multi_line; // Add or remove newline before the ')' in a function declaration. extern Option nl_func_decl_end; // Add or remove newline before the ')' in a function definition. extern Option nl_func_def_end; // Overrides nl_func_decl_end when there is only one parameter. extern Option nl_func_decl_end_single; // Overrides nl_func_def_end when there is only one parameter. extern Option nl_func_def_end_single; // Whether to add a newline before ')' in a function declaration if '(' and ')' // are in different lines. If false, nl_func_decl_end is used instead. extern Option nl_func_decl_end_multi_line; // Whether to add a newline before ')' in a function definition if '(' and ')' // are in different lines. If false, nl_func_def_end is used instead. extern Option nl_func_def_end_multi_line; // Add or remove newline between '()' in a function declaration. extern Option nl_func_decl_empty; // Add or remove newline between '()' in a function definition. extern Option nl_func_def_empty; // Add or remove newline between '()' in a function call. extern Option nl_func_call_empty; // Whether to add a newline after '(' in a function call, // has preference over nl_func_call_start_multi_line. extern Option nl_func_call_start; // Whether to add a newline before ')' in a function call. extern Option nl_func_call_end; // Whether to add a newline after '(' in a function call if '(' and ')' are in // different lines. extern Option nl_func_call_start_multi_line; // Whether to add a newline after each ',' in a function call if '(' and ')' // are in different lines. extern Option nl_func_call_args_multi_line; // Whether to add a newline before ')' in a function call if '(' and ')' are in // different lines. extern Option nl_func_call_end_multi_line; // Whether to respect nl_func_call_XXX option in case of closure args. extern Option nl_func_call_args_multi_line_ignore_closures; // false // Whether to add a newline after '<' of a template parameter list. extern Option nl_template_start; // Whether to add a newline after each ',' in a template parameter list. extern Option nl_template_args; // Whether to add a newline before '>' of a template parameter list. extern Option nl_template_end; // (OC) Whether to put each Objective-C message parameter on a separate line. // See nl_oc_msg_leave_one_liner. extern Option nl_oc_msg_args; // (OC) Minimum number of Objective-C message parameters before applying nl_oc_msg_args. extern BoundedOption nl_oc_msg_args_min_params; // (OC) Max code width of Objective-C message before applying nl_oc_msg_args. extern BoundedOption nl_oc_msg_args_max_code_width; // Add or remove newline between function signature and '{'. extern Option nl_fdef_brace; // Add or remove newline between function signature and '{', // if signature ends with ')'. Overrides nl_fdef_brace. extern Option nl_fdef_brace_cond; // Add or remove newline between C++11 lambda signature and '{'. extern Option nl_cpp_ldef_brace; // Add or remove newline between 'return' and the return expression. extern Option nl_return_expr; // Add or remove newline between 'throw' and the throw expression. extern Option nl_throw_expr; // Whether to add a newline after semicolons, except in 'for' statements. extern Option nl_after_semicolon; // (Java) Add or remove newline between the ')' and '{{' of the double brace // initializer. extern Option nl_paren_dbrace_open; // Whether to add a newline after the type in an unnamed temporary // direct-list-initialization, better: // before a direct-list-initialization. extern Option nl_type_brace_init_lst; // Whether to add a newline after the open brace in an unnamed temporary // direct-list-initialization. extern Option nl_type_brace_init_lst_open; // Whether to add a newline before the close brace in an unnamed temporary // direct-list-initialization. extern Option nl_type_brace_init_lst_close; // Whether to add a newline before '{'. extern Option nl_before_brace_open; // Whether to add a newline after '{'. extern Option nl_after_brace_open; // Whether to add a newline between the open brace and a trailing single-line // comment. Requires nl_after_brace_open=true. extern Option nl_after_brace_open_cmt; // Whether to add a newline after a virtual brace open with a non-empty body. // These occur in un-braced if/while/do/for statement bodies. extern Option nl_after_vbrace_open; // Whether to add a newline after a virtual brace open with an empty body. // These occur in un-braced if/while/do/for statement bodies. extern Option nl_after_vbrace_open_empty; // Whether to add a newline after '}'. Does not apply if followed by a // necessary ';'. extern Option nl_after_brace_close; // Whether to add a newline after a virtual brace close, // as in 'if (foo) a++; return;'. extern Option nl_after_vbrace_close; // Add or remove newline between the close brace and identifier, // as in 'struct { int a; } b;'. Affects enumerations, unions and // structures. If set to ignore, uses nl_after_brace_close. extern Option nl_brace_struct_var; // Whether to alter newlines in '#define' macros. extern Option nl_define_macro; // Whether to alter newlines between consecutive parenthesis closes. The number // of closing parentheses in a line will depend on respective open parenthesis // lines. extern Option nl_squeeze_paren_close; // Whether to remove blanks after '#ifxx' and '#elxx', or before '#elxx' and // '#endif'. Does not affect top-level #ifdefs. extern Option nl_squeeze_ifdef; // Makes the nl_squeeze_ifdef option affect the top-level #ifdefs as well. extern Option nl_squeeze_ifdef_top_level; // Add or remove blank line before 'if'. extern Option nl_before_if; // Add or remove blank line after 'if' statement. Add/Force work only if the // next token is not a closing brace. extern Option nl_after_if; // Add or remove blank line before 'for'. extern Option nl_before_for; // Add or remove blank line after 'for' statement. extern Option nl_after_for; // Add or remove blank line before 'while'. extern Option nl_before_while; // Add or remove blank line after 'while' statement. extern Option nl_after_while; // Add or remove blank line before 'switch'. extern Option nl_before_switch; // Add or remove blank line after 'switch' statement. extern Option nl_after_switch; // Add or remove blank line before 'synchronized'. extern Option nl_before_synchronized; // Add or remove blank line after 'synchronized' statement. extern Option nl_after_synchronized; // Add or remove blank line before 'do'. extern Option nl_before_do; // Add or remove blank line after 'do/while' statement. extern Option nl_after_do; // Ignore nl_before_{if,for,switch,do,synchronized} if the control // statement is immediately after a case statement. // if nl_before_{if,for,switch,do} is set to remove, this option // does nothing. extern Option nl_before_ignore_after_case; // Whether to put a blank line before 'return' statements, unless after an open // brace. extern Option nl_before_return; // Whether to put a blank line after 'return' statements, unless followed by a // close brace. extern Option nl_after_return; // Whether to put a blank line before a member '.' or '->' operators. extern Option nl_before_member; // (Java) Whether to put a blank line after a member '.' or '->' operators. extern Option nl_after_member; // Whether to double-space commented-entries in 'struct'/'union'/'enum'. extern Option nl_ds_struct_enum_cmt; // Whether to force a newline before '}' of a 'struct'/'union'/'enum'. // (Lower priority than eat_blanks_before_close_brace.) extern Option nl_ds_struct_enum_close_brace; // Add or remove newline before or after (depending on pos_class_colon) a class // colon, as in 'class Foo : public Bar'. extern Option nl_class_colon; // Add or remove newline around a class constructor colon. The exact position // depends on nl_constr_init_args, pos_constr_colon and pos_constr_comma. extern Option nl_constr_colon; // Whether to collapse a two-line namespace, like 'namespace foo\n{ decl; }' // into a single line. If true, prevents other brace newline rules from turning // such code into four lines. If true, it also preserves one-liner namespaces. extern Option nl_namespace_two_to_one_liner; // Whether to remove a newline in simple unbraced if statements, turning them // into one-liners, as in 'if(b)\n i++;' => 'if(b) i++;'. extern Option nl_create_if_one_liner; // Whether to remove a newline in simple unbraced for statements, turning them // into one-liners, as in 'for (...)\n stmt;' => 'for (...) stmt;'. extern Option nl_create_for_one_liner; // Whether to remove a newline in simple unbraced while statements, turning // them into one-liners, as in 'while (expr)\n stmt;' => 'while (expr) stmt;'. extern Option nl_create_while_one_liner; // Whether to collapse a function definition whose body (not counting braces) // is only one line so that the entire definition (prototype, braces, body) is // a single line. extern Option nl_create_func_def_one_liner; // Whether to split one-line simple list definitions into three lines by // adding newlines, as in 'int a[12] = { 0 };'. extern Option nl_create_list_one_liner; // Whether to split one-line simple unbraced if statements into two lines by // adding a newline, as in 'if(b) i++;'. extern Option nl_split_if_one_liner; // Whether to split one-line simple unbraced for statements into two lines by // adding a newline, as in 'for (...) stmt;'. extern Option nl_split_for_one_liner; // Whether to split one-line simple unbraced while statements into two lines by // adding a newline, as in 'while (expr) stmt;'. extern Option nl_split_while_one_liner; // Don't add a newline before a cpp-comment in a parameter list of a function // call. extern Option donot_add_nl_before_cpp_comment; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Blank line options // The maximum number of consecutive newlines (3 = 2 blank lines). extern BoundedOption nl_max; // The maximum number of consecutive newlines in a function. extern BoundedOption nl_max_blank_in_func; // The number of newlines inside an empty function body. // This option overrides eat_blanks_after_open_brace and // eat_blanks_before_close_brace, but is ignored when // nl_collapse_empty_body_functions=true extern BoundedOption nl_inside_empty_func; // The number of newlines before a function prototype. extern BoundedOption nl_before_func_body_proto; // The number of newlines before a multi-line function definition. Where // applicable, this option is overridden with eat_blanks_after_open_brace=true extern BoundedOption nl_before_func_body_def; // The number of newlines before a class constructor/destructor prototype. extern BoundedOption nl_before_func_class_proto; // The number of newlines before a class constructor/destructor definition. extern BoundedOption nl_before_func_class_def; // The number of newlines after a function prototype. extern BoundedOption nl_after_func_proto; // The number of newlines after a function prototype, if not followed by // another function prototype. extern BoundedOption nl_after_func_proto_group; // The number of newlines after a class constructor/destructor prototype. extern BoundedOption nl_after_func_class_proto; // The number of newlines after a class constructor/destructor prototype, // if not followed by another constructor/destructor prototype. extern BoundedOption nl_after_func_class_proto_group; // Whether one-line method definitions inside a class body should be treated // as if they were prototypes for the purposes of adding newlines. // // Requires nl_class_leave_one_liners=true. Overrides nl_before_func_body_def // and nl_before_func_class_def for one-liners. extern Option nl_class_leave_one_liner_groups; // The number of newlines after '}' of a multi-line function body. extern BoundedOption nl_after_func_body; // The number of newlines after '}' of a multi-line function body in a class // declaration. Also affects class constructors/destructors. // // Overrides nl_after_func_body. extern BoundedOption nl_after_func_body_class; // The number of newlines after '}' of a single line function body. Also // affects class constructors/destructors. // // Overrides nl_after_func_body and nl_after_func_body_class. extern BoundedOption nl_after_func_body_one_liner; // The number of newlines before a block of typedefs. If nl_after_access_spec // is non-zero, that option takes precedence. // // 0: No change (default). extern BoundedOption nl_typedef_blk_start; // The number of newlines after a block of typedefs. // // 0: No change (default). extern BoundedOption nl_typedef_blk_end; // The maximum number of consecutive newlines within a block of typedefs. // // 0: No change (default). extern BoundedOption nl_typedef_blk_in; // The minimum number of blank lines after a block of variable definitions // at the top of a function body. If any preprocessor directives appear // between the opening brace of the function and the variable block, then // it is considered as not at the top of the function.Newlines are added // before trailing preprocessor directives, if any exist. // // 0: No change (default). extern BoundedOption nl_var_def_blk_end_func_top; // The minimum number of empty newlines before a block of variable definitions // not at the top of a function body. If nl_after_access_spec is non-zero, // that option takes precedence. Newlines are not added at the top of the // file or just after an opening brace. Newlines are added above any // preprocessor directives before the block. // // 0: No change (default). extern BoundedOption nl_var_def_blk_start; // The minimum number of empty newlines after a block of variable definitions // not at the top of a function body. Newlines are not added if the block // is at the bottom of the file or just before a preprocessor directive. // // 0: No change (default). extern BoundedOption nl_var_def_blk_end; // The maximum number of consecutive newlines within a block of variable // definitions. // // 0: No change (default). extern BoundedOption nl_var_def_blk_in; // The minimum number of newlines before a multi-line comment. // Doesn't apply if after a brace open or another multi-line comment. extern BoundedOption nl_before_block_comment; // The minimum number of newlines before a single-line C comment. // Doesn't apply if after a brace open or other single-line C comments. extern BoundedOption nl_before_c_comment; // The minimum number of newlines before a CPP comment. // Doesn't apply if after a brace open or other CPP comments. extern BoundedOption nl_before_cpp_comment; // Whether to force a newline after a multi-line comment. extern Option nl_after_multiline_comment; // Whether to force a newline after a label's colon. extern Option nl_after_label_colon; // The number of newlines before a struct definition. extern BoundedOption nl_before_struct; // The number of newlines after '}' or ';' of a struct/enum/union definition. extern BoundedOption nl_after_struct; // The number of newlines before a class definition. extern BoundedOption nl_before_class; // The number of newlines after '}' or ';' of a class definition. extern BoundedOption nl_after_class; // The number of newlines before a namespace. extern BoundedOption nl_before_namespace; // The number of newlines after '{' of a namespace. This also adds newlines // before the matching '}'. // // 0: Apply eat_blanks_after_open_brace or eat_blanks_before_close_brace if // applicable, otherwise no change. // // Overrides eat_blanks_after_open_brace and eat_blanks_before_close_brace. extern BoundedOption nl_inside_namespace; // The number of newlines after '}' of a namespace. extern BoundedOption nl_after_namespace; // The number of newlines before an access specifier label. This also includes // the Qt-specific 'signals:' and 'slots:'. Will not change the newline count // if after a brace open. // // 0: No change (default). extern BoundedOption nl_before_access_spec; // The number of newlines after an access specifier label. This also includes // the Qt-specific 'signals:' and 'slots:'. Will not change the newline count // if after a brace open. // // 0: No change (default). // // Overrides nl_typedef_blk_start and nl_var_def_blk_start. extern BoundedOption nl_after_access_spec; // The number of newlines between a function definition and the function // comment, as in '// comment\n void foo() {...}'. // // 0: No change (default). extern BoundedOption nl_comment_func_def; // The number of newlines after a try-catch-finally block that isn't followed // by a brace close. // // 0: No change (default). extern BoundedOption nl_after_try_catch_finally; // (C#) The number of newlines before and after a property, indexer or event // declaration. // // 0: No change (default). extern BoundedOption nl_around_cs_property; // (C#) The number of newlines between the get/set/add/remove handlers. // // 0: No change (default). extern BoundedOption nl_between_get_set; // (C#) Add or remove newline between property and the '{'. extern Option nl_property_brace; // Whether to remove blank lines after '{'. extern Option eat_blanks_after_open_brace; // Whether to remove blank lines before '}'. extern Option eat_blanks_before_close_brace; // How aggressively to remove extra newlines not in preprocessor. // // 0: No change (default) // 1: Remove most newlines not handled by other config // 2: Remove all newlines and reformat completely by config extern BoundedOption nl_remove_extra_newlines; // (Java) Add or remove newline after an annotation statement. Only affects // annotations that are after a newline. extern Option nl_after_annotation; // (Java) Add or remove newline between two annotations. extern Option nl_between_annotation; // The number of newlines before a whole-file #ifdef. // // 0: No change (default). extern BoundedOption nl_before_whole_file_ifdef; // The number of newlines after a whole-file #ifdef. // // 0: No change (default). extern BoundedOption nl_after_whole_file_ifdef; // The number of newlines before a whole-file #endif. // // 0: No change (default). extern BoundedOption nl_before_whole_file_endif; // The number of newlines after a whole-file #endif. // // 0: No change (default). extern BoundedOption nl_after_whole_file_endif; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Positioning options // The position of arithmetic operators in wrapped expressions. extern Option pos_arith; // The position of assignment in wrapped expressions. Do not affect '=' // followed by '{'. extern Option pos_assign; // The position of Boolean operators in wrapped expressions. extern Option pos_bool; // The position of comparison operators in wrapped expressions. extern Option pos_compare; // The position of conditional operators, as in the '?' and ':' of // 'expr ? stmt : stmt', in wrapped expressions. extern Option pos_conditional; // The position of the comma in wrapped expressions. extern Option pos_comma; // The position of the comma in enum entries. extern Option pos_enum_comma; // The position of the comma in the base class list if there is more than one // line. Affects nl_class_init_args. extern Option pos_class_comma; // The position of the comma in the constructor initialization list. // Related to nl_constr_colon, nl_constr_init_args and pos_constr_colon. extern Option pos_constr_comma; // The position of trailing/leading class colon, between class and base class // list. Affects nl_class_colon. extern Option pos_class_colon; // The position of colons between constructor and member initialization. // Related to nl_constr_colon, nl_constr_init_args and pos_constr_comma. extern Option pos_constr_colon; // The position of shift operators in wrapped expressions. extern Option pos_shift; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Line splitting options // Try to limit code width to N columns. extern BoundedOption code_width; // Whether to fully split long 'for' statements at semi-colons. extern Option ls_for_split_full; // Whether to fully split long function prototypes/calls at commas. // The option ls_code_width has priority over the option ls_func_split_full. extern Option ls_func_split_full; // Whether to split lines as close to code_width as possible and ignore some // groupings. // The option ls_code_width has priority over the option ls_func_split_full. extern Option ls_code_width; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Code alignment options (not left column spaces/tabs) // Whether to keep non-indenting tabs. extern Option align_keep_tabs; // Whether to use tabs for aligning. extern Option align_with_tabs; // Whether to bump out to the next tab when aligning. extern Option align_on_tabstop; // Whether to right-align numbers. extern Option align_number_right; // Whether to keep whitespace not required for alignment. extern Option align_keep_extra_space; // Whether to align variable definitions in prototypes and functions. extern Option align_func_params; // The span for aligning parameter definitions in function on parameter name. // // 0: Don't align (default). extern BoundedOption align_func_params_span; // The threshold for aligning function parameter definitions. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_func_params_thresh; // The gap for aligning function parameter definitions. extern BoundedOption align_func_params_gap; // The span for aligning constructor value. // // 0: Don't align (default). extern BoundedOption align_constr_value_span; // The threshold for aligning constructor value. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_constr_value_thresh; // The gap for aligning constructor value. extern BoundedOption align_constr_value_gap; // Whether to align parameters in single-line functions that have the same // name. The function names must already be aligned with each other. extern Option align_same_func_call_params; // The span for aligning function-call parameters for single line functions. // // 0: Don't align (default). extern BoundedOption align_same_func_call_params_span; // The threshold for aligning function-call parameters for single line // functions. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_same_func_call_params_thresh; // The span for aligning variable definitions. // // 0: Don't align (default). extern BoundedOption align_var_def_span; // How to consider (or treat) the '*' in the alignment of variable definitions. // // 0: Part of the type 'void * foo;' (default) // 1: Part of the variable 'void *foo;' // 2: Dangling 'void *foo;' // Dangling: the '*' will not be taken into account when aligning. extern BoundedOption align_var_def_star_style; // How to consider (or treat) the '&' in the alignment of variable definitions. // // 0: Part of the type 'long & foo;' (default) // 1: Part of the variable 'long &foo;' // 2: Dangling 'long &foo;' // Dangling: the '&' will not be taken into account when aligning. extern BoundedOption align_var_def_amp_style; // The threshold for aligning variable definitions. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_var_def_thresh; // The gap for aligning variable definitions. extern BoundedOption align_var_def_gap; // Whether to align the colon in struct bit fields. extern Option align_var_def_colon; // The gap for aligning the colon in struct bit fields. extern BoundedOption align_var_def_colon_gap; // Whether to align any attribute after the variable name. extern Option align_var_def_attribute; // Whether to align inline struct/enum/union variable definitions. extern Option align_var_def_inline; // The span for aligning on '=' in assignments. // // 0: Don't align (default). extern BoundedOption align_assign_span; // The span for aligning on '=' in function prototype modifier. // // 0: Don't align (default). extern BoundedOption align_assign_func_proto_span; // The threshold for aligning on '=' in assignments. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_assign_thresh; // Whether to align on the left most assignment when multiple // definitions are found on the same line. // Depends on 'align_assign_span' and 'align_assign_thresh' settings. extern Option align_assign_on_multi_var_defs; // The span for aligning on '{' in braced init list. // // 0: Don't align (default). extern BoundedOption align_braced_init_list_span; // The threshold for aligning on '{' in braced init list. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_braced_init_list_thresh; // How to apply align_assign_span to function declaration "assignments", i.e. // 'virtual void foo() = 0' or '~foo() = {default|delete}'. // // 0: Align with other assignments (default) // 1: Align with each other, ignoring regular assignments // 2: Don't align extern BoundedOption align_assign_decl_func; // The span for aligning on '=' in enums. // // 0: Don't align (default). extern BoundedOption align_enum_equ_span; // The threshold for aligning on '=' in enums. // Use a negative number for absolute thresholds. // // 0: no limit (default). extern BoundedOption align_enum_equ_thresh; // The span for aligning class member definitions. // // 0: Don't align (default). extern BoundedOption align_var_class_span; // The threshold for aligning class member definitions. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_var_class_thresh; // The gap for aligning class member definitions. extern BoundedOption align_var_class_gap; // The span for aligning struct/union member definitions. // // 0: Don't align (default). extern BoundedOption align_var_struct_span; // The threshold for aligning struct/union member definitions. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_var_struct_thresh; // The gap for aligning struct/union member definitions. extern BoundedOption align_var_struct_gap; // The span for aligning struct initializer values. // // 0: Don't align (default). extern BoundedOption align_struct_init_span; // The span for aligning single-line typedefs. // // 0: Don't align (default). extern BoundedOption align_typedef_span; // The minimum space between the type and the synonym of a typedef. extern BoundedOption align_typedef_gap; // How to align typedef'd functions with other typedefs. // // 0: Don't mix them at all (default) // 1: Align the open parenthesis with the types // 2: Align the function type name with the other type names extern BoundedOption align_typedef_func; // How to consider (or treat) the '*' in the alignment of typedefs. // // 0: Part of the typedef type, 'typedef int * pint;' (default) // 1: Part of type name: 'typedef int *pint;' // 2: Dangling: 'typedef int *pint;' // Dangling: the '*' will not be taken into account when aligning. extern BoundedOption align_typedef_star_style; // How to consider (or treat) the '&' in the alignment of typedefs. // // 0: Part of the typedef type, 'typedef int & intref;' (default) // 1: Part of type name: 'typedef int &intref;' // 2: Dangling: 'typedef int &intref;' // Dangling: the '&' will not be taken into account when aligning. extern BoundedOption align_typedef_amp_style; // The span for aligning comments that end lines. // // 0: Don't align (default). extern BoundedOption align_right_cmt_span; // Minimum number of columns between preceding text and a trailing comment in // order for the comment to qualify for being aligned. Must be non-zero to have // an effect. extern BoundedOption align_right_cmt_gap; // If aligning comments, whether to mix with comments after '}' and #endif with // less than three spaces before the comment. extern Option align_right_cmt_mix; // Whether to only align trailing comments that are at the same brace level. extern Option align_right_cmt_same_level; // Minimum column at which to align trailing comments. Comments which are // aligned beyond this column, but which can be aligned in a lesser column, // may be "pulled in". // // 0: Ignore (default). extern BoundedOption align_right_cmt_at_col; // The span for aligning function prototypes. // // 0: Don't align (default). extern BoundedOption align_func_proto_span; // How to consider (or treat) the '*' in the alignment of function prototypes. // // 0: Part of the type 'void * foo();' (default) // 1: Part of the function 'void *foo();' // 2: Dangling 'void *foo();' // Dangling: the '*' will not be taken into account when aligning. extern BoundedOption align_func_proto_star_style; // How to consider (or treat) the '&' in the alignment of function prototypes. // // 0: Part of the type 'long & foo();' (default) // 1: Part of the function 'long &foo();' // 2: Dangling 'long &foo();' // Dangling: the '&' will not be taken into account when aligning. extern BoundedOption align_func_proto_amp_style; // The threshold for aligning function prototypes. // Use a negative number for absolute thresholds. // // 0: No limit (default). extern BoundedOption align_func_proto_thresh; // Minimum gap between the return type and the function name. extern BoundedOption align_func_proto_gap; // Whether to align function prototypes on the 'operator' keyword instead of // what follows. extern Option align_on_operator; // Whether to mix aligning prototype and variable declarations. If true, // align_var_def_XXX options are used instead of align_func_proto_XXX options. extern Option align_mix_var_proto; // Whether to align single-line functions with function prototypes. // Uses align_func_proto_span. extern Option align_single_line_func; // Whether to align the open brace of single-line functions. // Requires align_single_line_func=true. Uses align_func_proto_span. extern Option align_single_line_brace; // Gap for align_single_line_brace. extern BoundedOption align_single_line_brace_gap; // (OC) The span for aligning Objective-C message specifications. // // 0: Don't align (default). extern BoundedOption align_oc_msg_spec_span; // Whether to align macros wrapped with a backslash and a newline. This will // not work right if the macro contains a multi-line comment. extern Option align_nl_cont; // Whether to align macro functions and variables together. extern Option align_pp_define_together; // The span for aligning on '#define' bodies. // // =0: Don't align (default) // >0: Number of lines (including comments) between blocks extern BoundedOption align_pp_define_span; // The minimum space between label and value of a preprocessor define. extern BoundedOption align_pp_define_gap; // Whether to align lines that start with '<<' with previous '<<'. extern Option align_left_shift; // = true // Whether to align comma-separated statements following '<<' (as used to // initialize Eigen matrices). extern Option align_eigen_comma_init; // Whether to align text after 'asm volatile ()' colons. extern Option align_asm_colon; // (OC) Span for aligning parameters in an Objective-C message call // on the ':'. // // 0: Don't align. extern BoundedOption align_oc_msg_colon_span; // (OC) Whether to always align with the first parameter, even if it is too // short. extern Option align_oc_msg_colon_first; // (OC) Whether to align parameters in an Objective-C '+' or '-' declaration // on the ':'. extern Option align_oc_decl_colon; // (OC) Whether to not align parameters in an Objectve-C message call if first // colon is not on next line of the message call (the same way Xcode does // alignment) extern Option align_oc_msg_colon_xcode_like; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Comment modification options // Try to wrap comments at N columns. extern BoundedOption cmt_width; // How to reflow comments. // // 0: No reflowing (apart from the line wrapping due to cmt_width) (default) // 1: No touching at all // 2: Full reflow (enable cmt_indent_multi for indent with line wrapping due to cmt_width) extern BoundedOption cmt_reflow_mode; // Path to a file that contains regular expressions describing patterns for // which the end of one line and the beginning of the next will be folded into // the same sentence or paragraph during full comment reflow. The regular // expressions are described using ECMAScript syntax. The syntax for this // specification is as follows, where "..." indicates the custom regular // expression and "n" indicates the nth end_of_prev_line_regex and // beg_of_next_line_regex regular expression pair: // // end_of_prev_line_regex[1] = "...$" // beg_of_next_line_regex[1] = "^..." // end_of_prev_line_regex[2] = "...$" // beg_of_next_line_regex[2] = "^..." // . // . // . // end_of_prev_line_regex[n] = "...$" // beg_of_next_line_regex[n] = "^..." // // Note that use of this option overrides the default reflow fold regular // expressions, which are internally defined as follows: // // end_of_prev_line_regex[1] = "[\w,\]\)]$" // beg_of_next_line_regex[1] = "^[\w,\[\(]" // end_of_prev_line_regex[2] = "\.$" // beg_of_next_line_regex[2] = "^[A-Z]" extern Option cmt_reflow_fold_regex_file; // Whether to indent wrapped lines to the start of the encompassing paragraph // during full comment reflow (cmt_reflow_mode = 2). Overrides the value // specified by cmt_sp_after_star_cont. // // Note that cmt_align_doxygen_javadoc_tags overrides this option for // paragraphs associated with javadoc tags extern Option cmt_reflow_indent_to_paragraph_start; // Whether to convert all tabs to spaces in comments. If false, tabs in // comments are left alone, unless used for indenting. extern Option cmt_convert_tab_to_spaces; // TODO This description is confusing and should be revised. // Whether to apply changes to multi-line comments, including cmt_width, // keyword substitution and leading chars. extern Option cmt_indent_multi; // = true // Whether to align doxygen javadoc-style tags ('@param', '@return', etc.) // and corresponding fields such that groups of consecutive block tags, // parameter names, and descriptions align with one another. Overrides that // which is specified by the cmt_sp_after_star_cont. If cmt_width > 0, it may // be necessary to enable cmt_indent_multi and set cmt_reflow_mode = 2 // in order to achieve the desired alignment for line-wrapping. extern Option cmt_align_doxygen_javadoc_tags; // The number of spaces to insert after the star and before doxygen // javadoc-style tags (@param, @return, etc). Requires enabling // cmt_align_doxygen_javadoc_tags. Overrides that which is specified by the // cmt_sp_after_star_cont. extern BoundedOption cmt_sp_before_doxygen_javadoc_tags; // = 1 // Whether to change trailing, single-line c-comments into cpp-comments. extern Option cmt_trailing_single_line_c_to_cpp; // Whether to group c-comments that look like they are in a block. extern Option cmt_c_group; // Whether to put an empty '/*' on the first line of the combined c-comment. extern Option cmt_c_nl_start; // Whether to add a newline before the closing '*/' of the combined c-comment. extern Option cmt_c_nl_end; // Whether to change cpp-comments into c-comments. extern Option cmt_cpp_to_c; // Whether to group cpp-comments that look like they are in a block. Only // meaningful if cmt_cpp_to_c=true. extern Option cmt_cpp_group; // Whether to put an empty '/*' on the first line of the combined cpp-comment // when converting to a c-comment. // // Requires cmt_cpp_to_c=true and cmt_cpp_group=true. extern Option cmt_cpp_nl_start; // Whether to add a newline before the closing '*/' of the combined cpp-comment // when converting to a c-comment. // // Requires cmt_cpp_to_c=true and cmt_cpp_group=true. extern Option cmt_cpp_nl_end; // Whether to put a star on subsequent comment lines. extern Option cmt_star_cont; // The number of spaces to insert at the start of subsequent comment lines. extern BoundedOption cmt_sp_before_star_cont; // The number of spaces to insert after the star on subsequent comment lines. extern BoundedOption cmt_sp_after_star_cont; // TODO This description is confusing and should be revised. // For multi-line comments with a '*' lead, remove leading spaces if the first // and last lines of the comment are the same length. extern Option cmt_multi_check_last; // = true // TODO This description is confusing and should be revised. // For multi-line comments with a '*' lead, remove leading spaces if the first // and last lines of the comment are the same length AND if the length is // bigger as the first_len minimum. extern BoundedOption cmt_multi_first_len_minimum; // = 4 // Path to a file that contains text to insert at the beginning of a file if // the file doesn't start with a C/C++ comment. If the inserted text contains // '$(filename)', that will be replaced with the current file's name. extern Option cmt_insert_file_header; // Path to a file that contains text to insert at the end of a file if the // file doesn't end with a C/C++ comment. If the inserted text contains // '$(filename)', that will be replaced with the current file's name. extern Option cmt_insert_file_footer; // Path to a file that contains text to insert before a function definition if // the function isn't preceded by a C/C++ comment. If the inserted text // contains '$(function)', '$(javaparam)' or '$(fclass)', these will be // replaced with, respectively, the name of the function, the javadoc '@param' // and '@return' stuff, or the name of the class to which the member function // belongs. extern Option cmt_insert_func_header; // Path to a file that contains text to insert before a class if the class // isn't preceded by a C/C++ comment. If the inserted text contains '$(class)', // that will be replaced with the class name. extern Option cmt_insert_class_header; // Path to a file that contains text to insert before an Objective-C message // specification, if the method isn't preceded by a C/C++ comment. If the // inserted text contains '$(message)' or '$(javaparam)', these will be // replaced with, respectively, the name of the function, or the javadoc // '@param' and '@return' stuff. extern Option cmt_insert_oc_msg_header; // TODO This description may be confusing; consider revising. // Whether a comment should be inserted if a preprocessor is encountered when // stepping backwards from a function name. // // Applies to cmt_insert_oc_msg_header, cmt_insert_func_header and // cmt_insert_class_header. extern Option cmt_insert_before_preproc; // Whether a comment should be inserted if a function is declared inline to a // class definition. // // Applies to cmt_insert_func_header. extern Option cmt_insert_before_inlines; // = true // Whether a comment should be inserted if the function is a class constructor // or destructor. // // Applies to cmt_insert_func_header. extern Option cmt_insert_before_ctor_dtor; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Code modifying options (non-whitespace) // Add or remove braces on a single-line 'do' statement. extern Option mod_full_brace_do; // Add or remove braces on a single-line 'for' statement. extern Option mod_full_brace_for; // (Pawn) Add or remove braces on a single-line function definition. extern Option mod_full_brace_function; // Add or remove braces on a single-line 'if' statement. Braces will not be // removed if the braced statement contains an 'else'. extern Option mod_full_brace_if; // Whether to enforce that all blocks of an 'if'/'else if'/'else' chain either // have, or do not have, braces. Overrides mod_full_brace_if. // // 0: Don't override mod_full_brace_if // 1: Add braces to all blocks if any block needs braces and remove braces if // they can be removed from all blocks // 2: Add braces to all blocks if any block already has braces, regardless of // whether it needs them // 3: Add braces to all blocks if any block needs braces and remove braces if // they can be removed from all blocks, except if all blocks have braces // despite none needing them extern BoundedOption mod_full_brace_if_chain; // Whether to add braces to all blocks of an 'if'/'else if'/'else' chain. // If true, mod_full_brace_if_chain will only remove braces from an 'if' that // does not have an 'else if' or 'else'. extern Option mod_full_brace_if_chain_only; // Add or remove braces on single-line 'while' statement. extern Option mod_full_brace_while; // Add or remove braces on single-line 'using ()' statement. extern Option mod_full_brace_using; // Don't remove braces around statements that span N newlines extern BoundedOption mod_full_brace_nl; // Whether to prevent removal of braces from 'if'/'for'/'while'/etc. blocks // which span multiple lines. // // Affects: // mod_full_brace_for // mod_full_brace_if // mod_full_brace_if_chain // mod_full_brace_if_chain_only // mod_full_brace_while // mod_full_brace_using // // Does not affect: // mod_full_brace_do // mod_full_brace_function extern Option mod_full_brace_nl_block_rem_mlcond; // Add or remove unnecessary parentheses on 'return' statement. extern Option mod_paren_on_return; // Add or remove unnecessary parentheses on 'throw' statement. extern Option mod_paren_on_throw; // (Pawn) Whether to change optional semicolons to real semicolons. extern Option mod_pawn_semicolon; // Whether to fully parenthesize Boolean expressions in 'while' and 'if' // statement, as in 'if (a && b > c)' => 'if (a && (b > c))'. extern Option mod_full_paren_if_bool; // Whether to fully parenthesize Boolean expressions after '=' // statement, as in 'x = a && b > c;' => 'x = (a && (b > c));'. extern Option mod_full_paren_assign_bool; // Whether to fully parenthesize Boolean expressions after '=' // statement, as in 'return a && b > c;' => 'return (a && (b > c));'. extern Option mod_full_paren_return_bool; // Whether to remove superfluous semicolons. extern Option mod_remove_extra_semicolon; // Whether to remove duplicate include. extern Option mod_remove_duplicate_include; // If a function body exceeds the specified number of newlines and doesn't have // a comment after the close brace, a comment will be added. extern BoundedOption mod_add_long_function_closebrace_comment; // If a namespace body exceeds the specified number of newlines and doesn't // have a comment after the close brace, a comment will be added. extern BoundedOption mod_add_long_namespace_closebrace_comment; // If a class body exceeds the specified number of newlines and doesn't have a // comment after the close brace, a comment will be added. extern BoundedOption mod_add_long_class_closebrace_comment; // If a switch body exceeds the specified number of newlines and doesn't have a // comment after the close brace, a comment will be added. extern BoundedOption mod_add_long_switch_closebrace_comment; // If an #ifdef body exceeds the specified number of newlines and doesn't have // a comment after the #endif, a comment will be added. extern BoundedOption mod_add_long_ifdef_endif_comment; // If an #ifdef or #else body exceeds the specified number of newlines and // doesn't have a comment after the #else, a comment will be added. extern BoundedOption mod_add_long_ifdef_else_comment; // Whether to take care of the case by the mod_sort_xx options. extern Option mod_sort_case_sensitive; // Whether to sort consecutive single-line 'import' statements. extern Option mod_sort_import; // (C#) Whether to sort consecutive single-line 'using' statements. extern Option mod_sort_using; // Whether to sort consecutive single-line '#include' statements (C/C++) and // '#import' statements (Objective-C). Be aware that this has the potential to // break your code if your includes/imports have ordering dependencies. extern Option mod_sort_include; // Whether to prioritize '#include' and '#import' statements that contain // filename without extension when sorting is enabled. extern Option mod_sort_incl_import_prioritize_filename; // Whether to prioritize '#include' and '#import' statements that does not // contain extensions when sorting is enabled. extern Option mod_sort_incl_import_prioritize_extensionless; // Whether to prioritize '#include' and '#import' statements that contain // angle over quotes when sorting is enabled. extern Option mod_sort_incl_import_prioritize_angle_over_quotes; // Whether to ignore file extension in '#include' and '#import' statements // for sorting comparison. extern Option mod_sort_incl_import_ignore_extension; // Whether to group '#include' and '#import' statements when sorting is enabled. extern Option mod_sort_incl_import_grouping_enabled; // Whether to move a 'break' that appears after a fully braced 'case' before // the close brace, as in 'case X: { ... } break;' => 'case X: { ... break; }'. extern Option mod_move_case_break; // Whether to move a 'return' that appears after a fully braced 'case' before // the close brace, as in 'case X: { ... } return;' => 'case X: { ... return; }'. extern Option mod_move_case_return; // Add or remove braces around a fully braced case statement. Will only remove // braces if there are no variable declarations in the block. extern Option mod_case_brace; // Whether to remove a void 'return;' that appears as the last statement in a // function. extern Option mod_remove_empty_return; // Add or remove the comma after the last value of an enumeration. extern Option mod_enum_last_comma; // Syntax to use for infinite loops. // // 0: Leave syntax alone (default) // 1: Rewrite as `for(;;)` // 2: Rewrite as `while(true)` // 3: Rewrite as `do`...`while(true);` // 4: Rewrite as `while(1)` // 5: Rewrite as `do`...`while(1);` // // Infinite loops that do not already match one of these syntaxes are ignored. // Other options that affect loop formatting will be applied after transforming // the syntax. extern BoundedOption mod_infinite_loop; // Add or remove the 'int' keyword in 'int short'. extern Option mod_int_short; // Add or remove the 'int' keyword in 'short int'. extern Option mod_short_int; // Add or remove the 'int' keyword in 'int long'. extern Option mod_int_long; // Add or remove the 'int' keyword in 'long int'. extern Option mod_long_int; // Add or remove the 'int' keyword in 'int signed'. extern Option mod_int_signed; // Add or remove the 'int' keyword in 'signed int'. extern Option mod_signed_int; // Add or remove the 'int' keyword in 'int unsigned'. extern Option mod_int_unsigned; // Add or remove the 'int' keyword in 'unsigned int'. extern Option mod_unsigned_int; // If there is a situation where mod_int_* and mod_*_int would result in // multiple int keywords, whether to keep the rightmost int (the default) or the // leftmost int. extern Option mod_int_prefer_int_on_left; // (OC) Whether to organize the properties. If true, properties will be // rearranged according to the mod_sort_oc_property_*_weight factors. extern Option mod_sort_oc_properties; // (OC) Weight of a class property modifier. extern Option mod_sort_oc_property_class_weight; // (OC) Weight of 'atomic' and 'nonatomic'. extern Option mod_sort_oc_property_thread_safe_weight; // (OC) Weight of 'readwrite' when organizing properties. extern Option mod_sort_oc_property_readwrite_weight; // (OC) Weight of a reference type specifier ('retain', 'copy', 'assign', // 'weak', 'strong') when organizing properties. extern Option mod_sort_oc_property_reference_weight; // (OC) Weight of getter type ('getter=') when organizing properties. extern Option mod_sort_oc_property_getter_weight; // (OC) Weight of setter type ('setter=') when organizing properties. extern Option mod_sort_oc_property_setter_weight; // (OC) Weight of nullability type ('nullable', 'nonnull', 'null_unspecified', // 'null_resettable') when organizing properties. extern Option mod_sort_oc_property_nullability_weight; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Preprocessor options // How to use tabs when indenting preprocessor code. // // -1: Use 'indent_with_tabs' setting (default) // 0: Spaces only // 1: Indent with tabs to brace level, align with spaces // 2: Indent and align with tabs, using spaces when not on a tabstop extern BoundedOption pp_indent_with_tabs; // = -1 // Add or remove indentation of preprocessor directives inside #if blocks // at brace level 0 (file-level). extern Option pp_indent; // Whether to indent #if/#else/#endif at the brace level. If false, these are // indented from column 1. extern Option pp_indent_at_level; // Whether to indent #if/#else/#endif at the parenthesis level if the brace // level is 0. If false, these are indented from column 1. extern Option pp_indent_at_level0; // Specifies the number of columns to indent preprocessors per level // at brace level 0 (file-level). If pp_indent_at_level=false, also specifies // the number of columns to indent preprocessors per level // at brace level > 0 (function-level). extern BoundedOption pp_indent_count; // = 1 // Add or remove space after # based on pp level of #if blocks. extern Option pp_space_after; // Sets the number of spaces per level added with pp_space_after. extern BoundedOption pp_space_count; // The indent for '#region' and '#endregion' in C# and '#pragma region' in // C/C++. Negative values decrease indent down to the first column. extern BoundedOption pp_indent_region; // Whether to indent the code between #region and #endregion. extern Option pp_region_indent_code; // If pp_indent_at_level=true, sets the indent for #if, #else and #endif when // not at file-level. Negative values decrease indent down to the first column. // // =0: Indent preprocessors using output_tab_size // >0: Column at which all preprocessors will be indented extern BoundedOption pp_indent_if; // Whether to indent the code between #if, #else and #endif. extern Option pp_if_indent_code; // Whether to indent the body of an #if that encompasses all the code in the file. extern Option pp_indent_in_guard; // Whether to indent '#define' at the brace level. If false, these are // indented from column 1. extern Option pp_define_at_level; // Whether to indent '#include' at the brace level. extern Option pp_include_at_level; // Whether to ignore the '#define' body while formatting. extern Option pp_ignore_define_body; // An offset value that controls the indentation of the body of a multiline #define. // 'body' refers to all the lines of a multiline #define except the first line. // Requires 'pp_ignore_define_body = false'. // // <0: Absolute column: the body indentation starts off at the specified column // (ex. -3 ==> the body is indented starting from column 3) // >=0: Relative to the column of the '#' of '#define' // (ex. 3 ==> the body is indented starting 3 columns at the right of '#') extern BoundedOption pp_multiline_define_body_indent; // = 8 // TODO The following descriptions are confusing and suffer from sub-optimal // grammar, and should be revised; from here... // Whether to indent case statements between #if, #else, and #endif. // Only applies to the indent of the preprocessor that the case statements // directly inside of. extern Option pp_indent_case; // = true // Whether to indent whole function definitions between #if, #else, and #endif. // Only applies to the indent of the preprocessor that the function definition // is directly inside of. extern Option pp_indent_func_def; // = true // Whether to indent extern C blocks between #if, #else, and #endif. // Only applies to the indent of the preprocessor that the extern block is // directly inside of. extern Option pp_indent_extern; // = true // How to indent braces directly inside #if, #else, and #endif. // Requires pp_if_indent_code=true and only applies to the indent of the // preprocessor that the braces are directly inside of. // 0: No extra indent // 1: Indent by one level // -1: Preserve original indentation extern BoundedOption pp_indent_brace; // = 1 // Whether to print warning messages for unbalanced #if and #else blocks. // This will print a message in the following cases: // - if an #ifdef block ends on a different indent level than // where it started from. Example: // // #ifdef TEST // int i; // { // int j; // #endif // // - an #elif/#else block ends on a different indent level than // the corresponding #ifdef block. Example: // // #ifdef TEST // int i; // #else // } // int j; // #endif extern Option pp_warn_unbalanced_if; // = false // TODO ...until here. //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Sort includes options // The regex for include category with priority 0. extern Option include_category_0; // The regex for include category with priority 1. extern Option include_category_1; // The regex for include category with priority 2. extern Option include_category_2; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Use or Do not Use options // true: indent_func_call_param will be used (default) // false: indent_func_call_param will NOT be used extern Option use_indent_func_call_param; // = true // The value of the indentation for a continuation line is calculated // differently if the statement is: // - a declaration: your case with QString fileName ... // - an assignment: your case with pSettings = new QSettings( ... // // At the second case the indentation value might be used twice: // - at the assignment // - at the function call (if present) // // To prevent the double use of the indentation value, use this option with the // value 'true'. // // true: indent_continue will be used only once // false: indent_continue will be used every time (default) // // Requires indent_ignore_first_continue=false. extern Option use_indent_continue_only_once; // The indentation can be: // - after the assignment, at the '[' character // - at the beginning of the lambda body // // true: indentation will be at the beginning of the lambda body // false: indentation will be after the assignment (default) extern Option indent_cpp_lambda_only_once; // Whether sp_after_angle takes precedence over sp_inside_fparen. This was the // historic behavior, but is probably not the desired behavior, so this is off // by default. extern Option use_sp_after_angle_always; // Whether to apply special formatting for Qt SIGNAL/SLOT macros. Essentially, // this tries to format these so that they match Qt's normalized form (i.e. the // result of QMetaObject::normalizedSignature), which can slightly improve the // performance of the QObject::connect call, rather than how they would // otherwise be formatted. // // See options_for_QT.cpp for details. extern Option use_options_overriding_for_qt_macros; // = true // If true: the form feed character is removed from the list of whitespace // characters. See https://en.cppreference.com/w/cpp/string/byte/isspace. extern Option use_form_feed_no_more_as_whitespace_character; //END /////////////////////////////////////////////////////////////////////////////// //BEGIN Warn levels - 1: error, 2: warning (default), 3: note // (C#) Warning is given if doing tab-to-\t replacement and we have found one // in a C# verbatim string literal. extern BoundedOption warn_level_tabs_found_in_verbatim_string_literals; // = LWARN // For debugging purpose only. // Limit the number of loops. // Used by uncrustify.cpp to exit from infinite loop. // 0: no limit. extern Option debug_max_number_of_loops; // Set the number of the line to protocol; // Used in the function prot_the_line if the 2. parameter is zero. // 0: nothing protocol. extern Option debug_line_number_to_protocol; // Set the number of second(s) before terminating formatting the current file, // 0: no timeout. // only for linux extern Option debug_timeout; // Set the number of characters to be printed if the text is too long, // 0: do not truncate. extern BoundedOption debug_truncate; // sort (or not) the tracking info. extern Option debug_sort_the_tracks; // = true // decode (or not) the flags as a new line. // only if the -p option is set. extern Option debug_decode_the_flags; // insert the number of the line at the beginning of each line extern Option set_numbering_for_html_output; //END } // namespace options } // namespace uncrustify #endif /* OPTIONS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/options_for_QT.cpp000066400000000000000000000064721434072136500225060ustar00rootroot00000000000000/** * @file options_for_QT.cpp * Save the options which are needed to be changed to * process the SIGNAL and SLOT QT macros. * http://doc.qt.io/qt-4.8/qtglobal.html * * @author Guy Maurel since version 0.62 for uncrustify4Qt * October 2015, 2016 * @license GPL v2+ */ #include "options_for_QT.h" #include "log_rules.h" constexpr static auto LCURRENT = LQT; using namespace uncrustify; // for the modification of options within the SIGNAL/SLOT call. bool QT_SIGNAL_SLOT_found = false; size_t QT_SIGNAL_SLOT_level = 0; bool restoreValues = false; namespace { //----------------------------------------------------------------------------- class temporary_iarf_option { public: temporary_iarf_option(Option *option, iarf_e override_value = IARF_REMOVE) : m_option{option} , m_override_value{override_value} {} void save_and_override(); void restore(); private: Option *m_option; const iarf_e m_override_value; iarf_e m_saved_value = IARF_NOT_DEFINED; }; //----------------------------------------------------------------------------- void temporary_iarf_option::save_and_override() { m_saved_value = (*m_option)(); (*m_option) = m_override_value; } //----------------------------------------------------------------------------- void temporary_iarf_option::restore() { (*m_option) = m_saved_value; m_saved_value = IARF_NOT_DEFINED; } //----------------------------------------------------------------------------- temporary_iarf_option for_qt_options[] = { { &options::sp_inside_fparen }, // Issue #481 // connect( timer,SIGNAL( timeout() ),this,SLOT( timeoutImage() ) ); { &options::sp_inside_fparens }, { &options::sp_paren_paren }, { &options::sp_before_comma }, { &options::sp_after_comma }, // Bug #654 // connect(&mapper, SIGNAL(mapped(QString &)), this, SLOT(onSomeEvent(QString &))); { &options::sp_before_byref }, { &options::sp_before_unnamed_byref }, { &options::sp_after_type }, // Issue #1969 // connect( a, SIGNAL(b(c *)), this, SLOT(d(e *)) ); { &options::sp_before_ptr_star }, { &options::sp_before_unnamed_ptr_star }, // connect( a, SIGNAL(b(c< d >)), this, SLOT(e(f< g >)) ); { &options::sp_inside_angle }, }; } // anonymous namespace //----------------------------------------------------------------------------- void save_set_options_for_QT(size_t level) { log_rule_B("use_options_overriding_for_qt_macros"); assert(options::use_options_overriding_for_qt_macros()); LOG_FMT(LGUY, "save values, level=%zu\n", level); // save the values QT_SIGNAL_SLOT_level = level; for (auto &opt : for_qt_options) { opt.save_and_override(); } QT_SIGNAL_SLOT_found = true; } //----------------------------------------------------------------------------- void restore_options_for_QT() { log_rule_B("use_options_overriding_for_qt_macros"); assert(options::use_options_overriding_for_qt_macros()); LOG_FMT(LGUY, "restore values\n"); // restore the values we had before SIGNAL/SLOT QT_SIGNAL_SLOT_level = 0; for (auto &opt : for_qt_options) { opt.restore(); } QT_SIGNAL_SLOT_found = false; restoreValues = false; } uncrustify-uncrustify-0.76.0/src/options_for_QT.h000066400000000000000000000012061434072136500221410ustar00rootroot00000000000000/** * @file options_for_QT.h * Save the options which are needed to be changed to * process the SIGNAL and SLOT QT macros. * http://doc.qt.io/qt-4.8/qtglobal.html * * @author Guy Maurel since version 0.62 for uncrustify4Qt * January 2016 * @license GPL v2+ */ #ifndef OPTIONS_FOR_QT_H_INCLUDED #define OPTIONS_FOR_QT_H_INCLUDED #include "uncrustify_types.h" // TODO can we avoid those extern variables? extern bool QT_SIGNAL_SLOT_found; extern size_t QT_SIGNAL_SLOT_level; extern bool restoreValues; void save_set_options_for_QT(size_t level); void restore_options_for_QT(); #endif /* OPTIONS_FOR_QT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/output.cpp000066400000000000000000003127051434072136500211000ustar00rootroot00000000000000/** * @file output.cpp * Does all the output & comment formatting. * * @author Ben Gardner * @author Guy Maurel October 2015, 2021 * @license GPL v2+ */ #include "output.h" #include "align_tab_column.h" #include "braces.h" #include "indent.h" #include "prototypes.h" #include "tokenize.h" #include "unc_ctype.h" #include "unicode.h" #include #include #include #include // if you need more logs, commented out the next define line #define EXTRA_LOG constexpr static auto LCURRENT = LOUTPUT; using namespace uncrustify; struct cmt_reflow { Chunk *pc = nullptr; size_t column = 0; //! Column of the comment start size_t brace_col = 0; //! Brace column (for indenting with tabs) size_t base_col = 0; //! Base column (for indenting with tabs) size_t word_count = 0; //! number of words on this line size_t xtra_indent = 0; //! extra indent of non-first lines (0 or 1) unc_text cont_text; //! fixed text to output at the start of a line (0 to 3 chars) bool reflow = false; //! reflow the current line }; // for tracking line numbering bool numbering_status = false; int line_number; char char_number[16] = { 0 }; void set_numbering(bool status) { if (options::set_numbering_for_html_output()) { numbering_status = status; } } bool get_numbering() { return(numbering_status); } void set_line_number() { line_number = 0; } void print_numbering() { if (get_numbering()) { line_number++; sprintf(char_number, "%d ", line_number); write_string(char_number); } } /** * A multiline comment * The only trick here is that we have to trim out whitespace characters * to get the comment to line up. */ static void output_comment_multi(Chunk *pc); static bool kw_fcn_filename(Chunk *cmt, unc_text &out_txt); static bool kw_fcn_class(Chunk *cmt, unc_text &out_txt); static bool kw_fcn_message(Chunk *cmt, unc_text &out_txt); static bool kw_fcn_category(Chunk *cmt, unc_text &out_txt); static bool kw_fcn_scope(Chunk *cmt, unc_text &out_txt); static bool kw_fcn_function(Chunk *cmt, unc_text &out_txt); /** * Adds the javadoc-style @param and @return stuff, based on the params and * return value for pc. * If the arg list is '()' or '(void)', then no @params are added. * Likewise, if the return value is 'void', then no @return is added. */ static bool kw_fcn_javaparam(Chunk *cmt, unc_text &out_txt); static bool kw_fcn_fclass(Chunk *cmt, unc_text &out_txt); static bool kw_fcn_year(Chunk *cmt, unc_text &out_txt); /** * Output a multiline comment without any reformatting other than shifting * it left or right to get the column right. * * Trims trailing whitespaces. */ static void output_comment_multi_simple(Chunk *pc); /** * This renders the #if condition to a string buffer. * * @param[out] dst unc_text buffer to be filled * @param[in] ifdef if conditional as chunk list */ static void generate_if_conditional_as_text(unc_text &dst, Chunk *ifdef); /** * Do keyword substitution on a comment. * NOTE: it is assumed that a comment will contain at most one of each type * of keyword. */ static void do_kw_subst(Chunk *pc); //! All output text is sent here, one char at a time. static void add_char(UINT32 ch, bool is_literal = false); static void add_text(const char *ascii_text); static void add_text(const unc_text &text, bool is_ignored, bool is_literal); /** * Count the number of characters to the end of the next chunk of text. * If it exceeds the limit, return true. */ static bool next_word_exceeds_limit(const unc_text &text, size_t idx); /** * Output a comment to the column using indent_with_tabs and * indent_cmt_with_tabs as the rules. * base_col is the indent of the first line of the comment. * On the first line, column == base_col. * On subsequent lines, column >= base_col. * * @param brace_col the brace-level indent of the comment * @param base_col the indent of the start of the comment (multiline) * @param column the column that we should end up in */ static void cmt_output_indent(size_t brace_col, size_t base_col, size_t column); /** * Checks for and updates the lead chars. * * @param line the comment line * * @return 0: not present, >0: number of chars that are part of the lead */ static size_t cmt_parse_lead(const unc_text &line, bool is_last); /** * Scans a multiline comment to determine the following: * - the extra indent of the non-first line (0 or 1) * - the continuation text ('' or '* ') * * The decision is based on: * - cmt_indent_multi * - cmt_star_cont * - cmt_multi_first_len_minimum * - the first line length * - the second line leader length * - the last line length (without leading space/tab) * * If the first and last line are the same length and don't contain any alnum * chars and (the first line len > 2 or the second leader is the same as the * first line length), then the indent is 0. * * If the leader on the second line is 1 wide or missing, then the indent is 1. * * Otherwise, the indent is 0. * * @param str The comment string * @param len Length of the comment * @param start_col Starting column * * @return cmt.xtra_indent is set to 0 or 1 */ static void calculate_comment_body_indent(cmt_reflow &cmt, const unc_text &str); static int next_up(const unc_text &text, size_t idx, const unc_text &tag); /** * Outputs the C comment at pc. * C comment combining is done here * * @return the last chunk output'd */ static Chunk *output_comment_c(Chunk *pc); /** * Outputs the CPP comment at pc. * CPP comment combining is done here * * @return the last chunk output'd */ static Chunk *output_comment_cpp(Chunk *pc); static void cmt_trim_whitespace(unc_text &line, bool in_preproc); /** * Outputs a comment. The initial opening '//' may be included in the text. * Subsequent openings (if combining comments), should not be included. * The closing (for C/D comments) should not be included. * * TODO: * If reflowing text, the comment should be added one word (or line) at a time. * A newline should only be sent if a blank line is encountered or if the next * line is indented beyond the current line (optional?). * If the last char on a line is a ':' or '.', then the next line won't be * combined. */ static void add_comment_text(const unc_text &text, cmt_reflow &cmt, bool esc_close, size_t continuation_indent = 0); static void output_cmt_start(cmt_reflow &cmt, Chunk *pc); /** * Checks to see if the current comment can be combined with the next comment. * The two can be combined if: * 1. They are the same type * 2. There is exactly one newline between then * 3. They are indented to the same level */ static bool can_combine_comment(Chunk *pc, cmt_reflow &cmt); #define LOG_CONTTEXT() \ LOG_FMT(LCONTTEXT, "%s(%d): set cont_text to '%s'\n", __func__, __LINE__, cmt.cont_text.c_str()) static void add_spaces() { while (cpd.spaces > 0) { write_char(' '); cpd.spaces--; } } static void add_char(UINT32 ch, bool is_literal) { // If we did a '\r' and it isn't followed by a '\n', then output a newline if ( (cpd.last_char == '\r') && (ch != '\n')) { write_string(cpd.newline); cpd.column = 1; cpd.did_newline = true; cpd.spaces = 0; } // convert a newline into the LF/CRLF/CR sequence if (ch == '\n') { add_spaces(); write_string(cpd.newline); cpd.column = 1; cpd.did_newline = true; cpd.spaces = 0; print_numbering(); } else if (ch == '\r') // do not output the CARRIAGERETURN { // do not output '\r' cpd.column = 1; cpd.did_newline = true; cpd.spaces = 0; } else if ( (ch == '\t') && cpd.output_tab_as_space) { size_t endcol = next_tab_column(cpd.column); while (cpd.column < endcol) { add_char(' '); } return; } else { // explicitly disallow a tab after a space if ( !is_literal && ch == '\t' && cpd.last_char == ' ') { log_rule_B("indent_with_tabs"); int indent_with_tabs = options::pp_indent_with_tabs(); if ( cpd.in_preproc != CT_PREPROC || indent_with_tabs == -1) { indent_with_tabs = options::indent_with_tabs(); } if (indent_with_tabs == 0) { size_t endcol = next_tab_column(cpd.column); while (cpd.column < endcol) { add_char(' '); } return; } } if ( (ch == ' ') && !cpd.output_trailspace) { cpd.spaces++; cpd.column++; } else { add_spaces(); write_char(ch); if (ch == '\t') { cpd.column = next_tab_column(cpd.column); } else { cpd.column++; } } } cpd.last_char = ch; } // add_char static void add_text(const char *ascii_text) { char ch; while ((ch = *ascii_text) != 0) { ascii_text++; add_char(ch); } } static void add_text(const unc_text &text, bool is_ignored = false, bool is_literal = false) { for (size_t idx = 0; idx < text.size(); idx++) { int ch = text[idx]; if (is_ignored) { write_char(ch); } else { add_char(ch, is_literal); } } } static bool next_word_exceeds_limit(const unc_text &text, size_t idx) { LOG_FMT(LCONTTEXT, "%s(%d): idx is %zu\n", __func__, __LINE__, idx); size_t length = 0; // Count any whitespace while ( (idx < text.size()) && unc_isspace(text[idx])) { idx++; length++; } // Count non-whitespace while ( (idx < text.size()) && !unc_isspace(text[idx])) { idx++; length++; } return((cpd.column + length - 1) > options::cmt_width()); } /** * Advance to a specific column * cpd.column is the current column * * @param column The column to advance to */ static void output_to_column(size_t column, bool allow_tabs) { cpd.did_newline = false; if (allow_tabs) { // tab out as far as possible and then use spaces size_t next_column = next_tab_column(cpd.column); while (next_column <= column) { add_text("\t"); next_column = next_tab_column(cpd.column); } } // space out the final bit while (cpd.column < column) { add_text(" "); } } static void cmt_output_indent(size_t brace_col, size_t base_col, size_t column) { log_rule_B("indent_cmt_with_tabs"); size_t iwt = options::indent_cmt_with_tabs() ? 2 : (options::indent_with_tabs() ? 1 : 0); size_t tab_col = (iwt == 0) ? 0 : ((iwt == 1) ? brace_col : base_col); // LOG_FMT(LSYS, "%s(brace=%zd base=%zd col=%zd iwt=%zd) tab=%zd cur=%zd\n", // __func__, brace_col, base_col, column, iwt, tab_col, cpd.column); cpd.did_newline = false; if ( iwt == 2 || ( cpd.column == 1 && iwt == 1)) { // tab out as far as possible and then use spaces while (next_tab_column(cpd.column) <= tab_col) { add_text("\t"); } } // space out the rest while (cpd.column < column) { add_text(" "); } } // cmt_output_indent void output_parsed(FILE *pfile, bool withOptions) { const char *eol_marker = get_eol_marker(); if (withOptions) { save_option_file(pfile, false, true); } fprintf(pfile, "# -=====-%s", eol_marker); fprintf(pfile, "# number of loops = %d\n", cpd.changes); fprintf(pfile, "# -=====-%s", eol_marker); fprintf(pfile, "# language = %s\n", language_name_from_flags(cpd.lang_flags)); fprintf(pfile, "# -=====-%s", eol_marker); // MAXLENGTHOFTHENAME must be consider at the format line at the file // output.cpp, line 427: fprintf(pfile, "# Line Tag Parent... // and 430: ... fprintf(pfile, "%s# %3zu>%19.19s[%19.19s] ... // here xx xx xx xx #ifdef WIN32 fprintf(pfile, "# Line Tag Parent_type Type of the parent Columns Br/Lvl/pp Nl Text"); #else // not WIN32 fprintf(pfile, "# Line Tag Parent_type Type of the parent Columns Br/Lvl/pp Flags Nl Text"); #endif // ifdef WIN32 for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { #ifdef WIN32 fprintf(pfile, "%s# %3d>%19.19s|%19.19s|%19.19s[%3d/%3d/%3d/%3d][%d/%d/%d][%d-%d]", eol_marker, (int)pc->GetOrigLine(), get_token_name(pc->GetType()), get_token_name(pc->GetParentType()), get_token_name(pc->GetTypeOfParent()), (int)pc->GetColumn(), (int)pc->GetOrigCol(), (int)pc->GetOrigColEnd(), (int)pc->GetOrigPrevSp(), (int)pc->GetBraceLevel(), (int)pc->GetLevel(), (int)pc->GetPpLevel(), (int)pc->GetNlCount(), pc->GetAfterTab()); #else // not WIN32 fprintf(pfile, "%s# %3zu>%19.19s|%19.19s|%19.19s[%3zu/%3zu/%3zu/%3zu][%zu/%zu/%zu]", eol_marker, pc->GetOrigLine(), get_token_name(pc->GetType()), get_token_name(pc->GetParentType()), get_token_name(pc->GetTypeOfParent()), pc->GetColumn(), pc->GetOrigCol(), pc->GetOrigColEnd(), pc->GetOrigPrevSp(), pc->GetBraceLevel(), pc->GetLevel(), pc->GetPpLevel()); // Print pc flags in groups of 4 hex characters char flag_string[24]; sprintf(flag_string, "%16llx", static_cast(pc->GetFlags())); fprintf(pfile, "[%.4s %.4s %.4s %.4s]", flag_string, flag_string + 4, flag_string + 8, flag_string + 12); fprintf(pfile, "[%zu-%d]", pc->GetNlCount(), pc->GetAfterTab()); #endif // ifdef WIN32 if ( pc->IsNot(CT_NEWLINE) && (pc->Len() != 0)) { for (size_t cnt = 0; cnt < pc->GetColumn(); cnt++) { fprintf(pfile, " "); } if (pc->IsNot(CT_NL_CONT)) { fprintf(pfile, "%s", pc->Text()); } else { fprintf(pfile, "\\"); } } if (options::debug_decode_the_flags()) { // such as: // The flags are: [0xc0400:IN_CLASS,STMT_START,EXPR_START] fprintf(pfile, "%s The flags are: ", eol_marker); fprintf(pfile, "%s", pcf_flags_str(pc->GetFlags()).c_str()); } } fprintf(pfile, "%s# -=====-%s", eol_marker, eol_marker); fflush(pfile); } // output_parsed void output_parsed_csv(FILE *pfile) { const char *eol_marker = get_eol_marker(); fprintf(pfile, "number of loops,%d,\n", cpd.changes); fprintf(pfile, "language,%s,\n", language_name_from_flags(cpd.lang_flags)); fprintf(pfile, "Line,Tag,Parent_type,Type of the parent,Column,Orig Col Strt," "Orig Col End,Orig Sp Before,Br,Lvl,pp,Flags,Nl Before,Nl After,Text,"); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { fprintf(pfile, "%s%zu,%s,%s,%s,%zu,%zu,%zu,%zu,%zu,%zu,%zu,", eol_marker, pc->GetOrigLine(), get_token_name(pc->GetType()), get_token_name(pc->GetParentType()), get_token_name(pc->GetTypeOfParent()), pc->GetColumn(), pc->GetOrigCol(), pc->GetOrigColEnd(), pc->GetOrigPrevSp(), pc->GetBraceLevel(), pc->GetLevel(), pc->GetPpLevel()); auto pcf_flag_str = pcf_flags_str(E_PcfFlag(pc->GetFlags())); #ifdef WIN32 auto pcf_flag_str_start = pcf_flag_str.find("[") + 1; #else // not WIN32 auto pcf_flag_str_start = pcf_flag_str.find(":") + 1; #endif // ifdef WIN32 auto pcf_flag_str_end = pcf_flag_str.find("]"); auto pcf_names = pcf_flag_str.substr(pcf_flag_str_start, pcf_flag_str_end - pcf_flag_str_start); fprintf(pfile, "\"%s\",", pcf_names.c_str()); fprintf(pfile, "%zu,%d,", pc->GetNlCount(), pc->GetAfterTab()); if ( pc->IsNot(CT_NEWLINE) && (pc->Len() != 0)) { fprintf(pfile, "\""); for (size_t cnt = 0; cnt < pc->GetColumn(); cnt++) { fprintf(pfile, " "); } if (pc->IsNot(CT_NL_CONT)) { for (auto *ch = pc->Text(); *ch != '\0'; ++ch) { fprintf(pfile, "%c", *ch); if (*ch == '"') { // need to escape the double-quote for csv-format fprintf(pfile, "\""); } } } else { fprintf(pfile, "\\"); } fprintf(pfile, "\""); } } fflush(pfile); } // output_parsed_csv // Compares two tracks according to second in descending order. bool compareTrack(Track_nr t1, Track_nr t2) { char *t1s = t1.second; char *t2s = t2.second; int vergleich = strcmp(t2s, t1s); bool int_vergleich = vergleich > 0; return(int_vergleich); } void output_text(FILE *pfile) { bool tracking = cpd.html_type != tracking_type_e::TT_NONE; // special for debugging cpd.fout = pfile; cpd.did_newline = true; cpd.column = 1; if (cpd.bom) { write_bom(); } Chunk *pc; if (cpd.frag_cols > 0) { size_t indent = cpd.frag_cols - 1; // loop over the whole chunk list for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { pc->SetColumn(pc->GetColumn() + indent); pc->SetColumnIndent(pc->GetColumnIndent() + indent); } cpd.frag_cols = 0; } if (tracking) { set_numbering(false); add_text("\n"); add_text("\n"); add_text(" \n"); add_text(" Uncrustify: where do the Spaces options work\n"); add_text("\n"); add_text("\n"); add_text("

\n"); add_text("

\n"); add_text("
\n");
      set_numbering(true);
      set_line_number();
      print_numbering();
   }
   bool write_in_tracking   = false;
   int  pp_indent_with_tabs = options::pp_indent_with_tabs();

   if (pp_indent_with_tabs == -1)
   {
      pp_indent_with_tabs = options::indent_with_tabs();
   }

   // loop over the whole chunk list
   for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext())
   {
      char copy[1000];
      LOG_FMT(LCONTTEXT, "%s(%d): Text() is '%s', type is %s, orig line is %zu, column is %zu, nl is %zu\n",
              __func__, __LINE__, pc->ElidedText(copy), get_token_name(pc->GetType()), pc->GetOrigLine(), pc->GetColumn(), pc->GetNlCount());
      cpd.output_tab_as_space = false;

      if (pc->Is(CT_NEWLINE))
      {
         for (size_t cnt = 0; cnt < pc->GetNlCount(); cnt++)
         {
            if (  cnt > 0
               && pc->GetNlColumn() > 1)
            {
               log_rule_B("indent_with_tabs - newline");

               if (pc->IsPreproc())
               {
                  output_to_column(pc->GetNlColumn(), (pp_indent_with_tabs == 2));
               }
               else
               {
                  output_to_column(pc->GetNlColumn(), (options::indent_with_tabs() == 2));
               }
            }
            add_char('\n');
         }

         cpd.did_newline = true;
         cpd.column      = 1;
      }
      else if (pc->Is(CT_NL_CONT))
      {
         // FIXME: this really shouldn't be done here!
         if (!pc->TestFlags(PCF_WAS_ALIGNED))
         {
            // Add or remove space before a backslash-newline at the end of a line.
            log_rule_B("sp_before_nl_cont");

            if (options::sp_before_nl_cont() & IARF_REMOVE)
            {
               log_rule_B("sp_before_nl_cont");
               pc->SetColumn(cpd.column + (options::sp_before_nl_cont() == IARF_FORCE));
            }
            else
            {
               // Try to keep the same relative spacing
               Chunk *prev = pc->GetPrev();

               if (prev->Is(CT_PP_IGNORE))
               {
                  /*
                   * Want to completely leave alone PP_IGNORE'd blocks because
                   * they likely have special column aligned newline
                   * continuations (common in multiline macros)
                   */
                  pc->SetColumn(pc->GetOrigCol());
               }
               else
               {
                  // Try to keep the same relative spacing
                  while (  prev != nullptr
                        && prev->IsNotNullChunk()
                        && prev->GetOrigCol() == 0
                        && prev->GetNlCount() == 0)
                  {
                     prev = prev->GetPrev();
                  }

                  if (  prev != nullptr
                     && prev->IsNotNullChunk()
                     && prev->GetNlCount() == 0)
                  {
                     int orig_sp = pc->GetOrigPrevSp();

                     if ((int)(cpd.column + orig_sp) < 0)
                     {
#ifdef WIN32
                        fprintf(stderr, "FATAL: negative value.\n   pc->GetOrigCol() is %d, prev->GetOrigColEnd() is %d\n",
                                (int)pc->GetOrigCol(), (int)prev->GetOrigColEnd());
#else // not WIN32
                        fprintf(stderr, "FATAL: negative value.\n   pc->GetOrigCol() is %zu, prev->GetOrigColEnd() is %zu\n",
                                pc->GetOrigCol(), prev->GetOrigColEnd());
#endif // ifdef WIN32
                        log_flush(true);
                        exit(EX_SOFTWARE);
                     }
                     pc->SetColumn(cpd.column + orig_sp);

                     // Add or remove space before a backslash-newline at the end of a line.
                     log_rule_B("sp_before_nl_cont");

                     if (  (options::sp_before_nl_cont() != IARF_IGNORE)
                        && (pc->GetColumn() < (cpd.column + 1)))
                     {
                        pc->SetColumn(cpd.column + 1);
                     }
                  }
               }
            }
            output_to_column(pc->GetColumn(), false);
         }
         else
         {
            log_rule_B("indent_with_tabs - newline cont");

            if (pc->IsPreproc())
            {
               output_to_column(pc->GetColumn(), (pp_indent_with_tabs == 2));
            }
            else
            {
               output_to_column(pc->GetColumn(), (options::indent_with_tabs() == 2));
            }
         }
         add_char('\\');
         add_char('\n');
         cpd.did_newline = true;
         cpd.column      = 1;
      }
      else if (pc->Is(CT_COMMENT_MULTI))
      {
         log_rule_B("cmt_indent_multi");
         log_rule_B("cmt_convert_tab_to_spaces - multi");
         cpd.output_tab_as_space = options::cmt_convert_tab_to_spaces();

         if (options::cmt_indent_multi())
         {
            output_comment_multi(pc);
         }
         else
         {
            output_comment_multi_simple(pc);
         }
      }
      else if (pc->Is(CT_COMMENT_CPP))
      {
         log_rule_B("cmt_comment_cpp");
         log_rule_B("cmt_convert_tab_to_spaces - comment_cpp");
         cpd.output_tab_as_space = options::cmt_convert_tab_to_spaces();

         bool tmp = cpd.output_trailspace;
         /*
          * keep trailing spaces if they are still present in a chunk;
          * note that tokenize() already strips spaces in comments,
          * so if they made it up to here, they are to stay
          */
         cpd.output_trailspace = true;
         pc                    = output_comment_cpp(pc);
         cpd.output_trailspace = tmp;
      }
      else if (pc->Is(CT_COMMENT))
      {
         log_rule_B("cmt_comment");
         log_rule_B("cmt_convert_tab_to_spaces - comment");
         cpd.output_tab_as_space = options::cmt_convert_tab_to_spaces();

         pc = output_comment_c(pc);
      }
      else if (  pc->Is(CT_JUNK)
              || pc->Is(CT_IGNORED))
      {
         LOG_FMT(LOUTIND, "%s(%d): orig line is %zu, orig col is %zu,\npc->Text() >%s<, pc->str.size() is %zu\n",
                 __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), pc->GetStr().size());
         // do not adjust the column for junk
         add_text(pc->GetStr(), true);
      }
      else if (pc->Len() == 0)
      {
         // don't do anything for non-visible stuff
         LOG_FMT(LOUTIND, "%s(%d): orig line is %zu, column is %zu, non-visible stuff: type is %s\n",
                 __func__, __LINE__, pc->GetOrigLine(), pc->GetColumn(), get_token_name(pc->GetType()));
      }
      else
      {
         bool allow_tabs;
         cpd.output_trailspace = (pc->Is(CT_STRING_MULTI));

         // indent to the 'level' first
         if (cpd.did_newline)
         {
            if (  (  pc->IsPreproc()
                  && pp_indent_with_tabs == 1)
               || (  !pc->IsPreproc()
                  && options::indent_with_tabs() == 1))
            {
               size_t lvlcol;

               /*
                * FIXME: it would be better to properly set m_columnIndent in
                * indent_text(), but this hack for '}' and '#' seems to work.
                */
               if (  pc->Is(CT_BRACE_CLOSE)
                  || pc->Is(CT_CASE_COLON)
                  || pc->IsPreproc())
               {
                  lvlcol = pc->GetColumn();
               }
               else
               {
                  lvlcol = pc->GetColumnIndent();

                  if (lvlcol > pc->GetColumn())
                  {
                     lvlcol = pc->GetColumn();
                  }
               }

               if (lvlcol > 1)
               {
                  log_rule_B("indent_with_tabs - hack");
                  output_to_column(lvlcol, true);
               }
            }
            log_rule_B("indent_with_tabs");
            allow_tabs = (  pc->IsPreproc()
                         && pp_indent_with_tabs == 2)
                         || (  !pc->IsPreproc()
                            && options::indent_with_tabs() == 2)
                         || (  pc->IsComment()
                            && options::indent_with_tabs() != 0);

            LOG_FMT(LOUTIND, "%s(%d): orig line is %zu, column is %zu, column indent is %zu, cpd.column is %zu\n",
                    __func__, __LINE__, pc->GetOrigLine(), pc->GetColumn(), pc->GetColumnIndent(), cpd.column);
         }
         else
         {
            /*
             * Reformatting multi-line comments can screw up the column.
             * Make sure we don't mess up the spacing on this line.
             * This has to be done here because comments are not formatted
             * until the output phase.
             */
            if (pc->GetColumn() < cpd.column)
            {
               reindent_line(pc, cpd.column);
            }
            // not the first item on a line
            Chunk *prev = pc->GetPrev();
            log_rule_B("align_with_tabs");
            allow_tabs = (  options::align_with_tabs()
                         && pc->TestFlags(PCF_WAS_ALIGNED)
                         && ((prev->GetColumn() + prev->Len() + 1) != pc->GetColumn()));

            log_rule_B("align_keep_tabs");

            if (options::align_keep_tabs())
            {
               allow_tabs |= pc->GetAfterTab();
            }
            LOG_FMT(LOUTIND, "%s(%d): at column %zu(%s)\n",
                    __func__, __LINE__, pc->GetColumn(), (allow_tabs ? "true" : "FALSE"));
         }
         output_to_column(pc->GetColumn(), allow_tabs);

         if (write_in_tracking)
         {
            if (pc->Is(CT_ANGLE_OPEN))
            {
               add_text("<", false, false);
            }
            else if (pc->Is(CT_ANGLE_CLOSE))
            {
               add_text(">", false, false);
            }
            else
            {
               if (tracking)
               {
                  if (pc->GetStr()[0] == '<')
                  {
                     add_text("<", false, false);
                     size_t lang = pc->GetStr().size();

                     for (size_t idx = 1; idx < lang - 1; idx++)
                     {
                        int ch = pc->GetStr()[idx];
                        add_char(ch);
                     }

                     add_text(">", false, false);
                  }
               }
               add_text(pc->GetStr(), false, pc->Is(CT_STRING));
            }
            write_in_tracking = false;
         }
         else
         {
            add_text(pc->GetStr(), false, pc->Is(CT_STRING));
         }

         if (pc->Is(CT_PP_DEFINE))  // Issue #876
         {
            // If true, a  is inserted after #define.
            log_rule_B("force_tab_after_define");

            if (options::force_tab_after_define())
            {
               add_char('\t');
            }
         }
         cpd.did_newline       = pc->IsNewline();
         cpd.output_trailspace = false;
      }

      if (pc->GetTrackingData() != nullptr)
      {
         LOG_FMT(LGUY, " Tracking info are: \n");
         LOG_FMT(LGUY, "  number of track(s) %zu\n", pc->GetTrackingData()->size());
         add_text("GetTrackingData()->size();

         if (many > 1)
         {
#ifdef EXTRA_LOG
            // protocol before sort
            for (size_t track = 0; track < pc->GetTrackingData()->size(); track++)
            {
               const track_list *A       = pc->GetTrackingData();
               const Track_nr   B        = A->at(track);
               size_t           Bfirst   = B.first;
               char             *Bsecond = B.second;

               LOG_FMT(LGUY, "  %zu, tracking number is %zu\n", track, Bfirst);
               LOG_FMT(LGUY, "  %zu, rule            is %s\n", track, Bsecond);
            }
#endif

            if (options::debug_sort_the_tracks())
            {
               track_list *A1 = pc->TrackingData();
               sort(A1->begin(), A1->end(), compareTrack);
            }
#ifdef EXTRA_LOG
            // protocol after sort
            for (size_t track = 0; track < pc->GetTrackingData()->size(); track++)
            {
               const track_list *A       = pc->GetTrackingData();
               const Track_nr   B        = A->at(track);
               size_t           Bfirst   = B.first;
               char             *Bsecond = B.second;

               LOG_FMT(LGUY, "  %zu, tracking number is %zu\n", track, Bfirst);
               LOG_FMT(LGUY, "  %zu, rule            is %s\n", track, Bsecond);
            }
#endif
         }
         char *old_one = nullptr;

         for (size_t track = 0; track < pc->GetTrackingData()->size(); track++)
         {
            const track_list *A         = pc->GetTrackingData();
            const Track_nr   B          = A->at(track);
            size_t           Bfirst     = B.first;
            char             *Bsecond   = B.second;
            bool             first_text = true;

            if (  old_one == nullptr
               || strcmp(old_one, Bsecond) != 0)
            {
               // first time this option
               if (old_one != nullptr)
               {
                  add_text("
");
               }
               old_one = Bsecond;

               if (first_text)
               {
                  sprintf(tempText, "%s", Bsecond);
                  add_text(tempText);
                  add_text(": ");
                  first_text = false;
               }
            }
            else
            {
               add_text(", ");
            }
            sprintf(tempText, "%zu", Bfirst);
            add_text(tempText);
         } // for (size_t track = 0; track < pc->GetTrackingData()->size(); track++)

         add_text("\">M");
         write_in_tracking = true;
      } // if (pc->GetTrackingData() != nullptr)
   } // loop over the whole chunk list

   if (tracking)
   {
      set_numbering(false);
      add_text("
\n"); add_text("\n"); add_text("\n"); } } // output_text void dump_step(const char *filename, const char *step_description) { static int file_num = 0; char buffer[256]; FILE *dump_file; if ( filename == nullptr || strlen(filename) == 0) { return; } // On the first call, also save the options in use if (file_num == 0) { snprintf(buffer, 256, "New dump file: %s_%03d.log - Options in use", filename, file_num); log_rule_B(buffer); snprintf(buffer, 256, "%s_%03d.log", filename, file_num); ++file_num; dump_file = fopen(buffer, "wb"); if (dump_file != nullptr) { save_option_file(dump_file, false, true); fclose(dump_file); } } snprintf(buffer, 256, "New dump file: %s_%03d.log - %s", filename, file_num, step_description); log_rule_B(buffer); snprintf(buffer, 256, "%s_%03d.log", filename, file_num); ++file_num; dump_file = fopen(buffer, "wb"); if (dump_file != nullptr) { fprintf(dump_file, "STEP: %s\n--------------\n", step_description); output_parsed(dump_file, false); fclose(dump_file); } } // dump_step static size_t cmt_parse_lead(const unc_text &line, bool is_last) { size_t len = 0; while ( len < 32 && len < line.size()) // TODO what is the meaning of 32? { if ( len > 0 && line[len] == '/') { // ignore combined comments size_t tmp = len + 1; while ( tmp < line.size() && unc_isspace(line[tmp])) { tmp++; } if ( tmp < line.size() && line[tmp] == '/') { return(1); } break; } else if (strchr("*|\\#+", line[len]) == nullptr) { break; // none of the characters '*|\#+' found in line } len++; } if (len > 30) // TODO: what is the meaning of 30? { return(1); } if ( len > 0 && ( len >= line.size() || unc_isspace(line[len]))) { return(len); } if ( len == 1 && line[0] == '*') { return(len); } if ( is_last && len > 0) { return(len); } return(0); } // cmt_parse_lead /** * Eat whitespace characters starting at the specified index in the forward or reverse direction * within a single line * @param str the input string containing the comment text * @param idx the starting index * @param forward if true, searches in the forward direction; * if false, searches in the reverse direction * @return the first index at which a non-whitespace character is encountered, including * a newline character */ template static int eat_line_whitespace(const String &str, int idx, bool forward = true) { auto advance_index = [&](int i) { return(forward ? i + 1 : i - 1); }; auto index_in_range = [&](int i) { // TODO: the following BREAKS with source code formatting; uncrustify seems to // think that the following is a template. This will NEED to be fixed!!! // For now, reformulate the statement //return(forward ? i = 0); return(forward ? (i < int(str.size())) : (i >= 0)); }; while ( index_in_range(idx) && str[idx] != '\n' && str[idx] != '\r' && unc_isspace(str[idx])) { idx = advance_index(idx); } return(idx); } // eat_line_whitespace /** * Returns whether or not a javaparam tag is the leading * text in a comment line, with only a sequence of whitespace * and/or '*' characters preceding it * @param str the input string containing the comment text * @param idx the starting index * @return true/false */ template static bool javaparam_tag_is_start_of_line(const String &str, int idx) { idx = eat_line_whitespace(str, str[idx] == '@' ? idx - 1 : idx, false); while (true) { if ( idx < 0 || str[idx] == '\n' || str[idx] == '\r') { return(true); } if (str[idx] == '*') { idx = eat_line_whitespace(str, idx - 1, false); } else { return(false); } } } // javaparam_tag_is_start_of_line /** * Attempts to match a doxygen/javadoc-style comment tag * @param str the input string containing the comment text * @param idx the starting index * @return the index of the character immediately following the matched tag, * or -1 if no match is found */ static int match_doxygen_javadoc_tag(const std::wstring &str, size_t idx) { std::wsmatch match; if (str[idx] == L'@') { // Issue #3357 std::wregex criteria(L"(@(?:author|" L"deprecated|" L"exception|" L"param(?:\\s*?\\[\\s*(?:in\\s*,\\s*out|in|out)\\s*?\\])?|" L"return|" L"see|" L"since|" L"throws|" L"version)(?=\\s))"); if ( std::regex_search(str.cbegin() + idx, str.cend(), match, criteria) && match[1].matched && match.position(1) == std::wsmatch::difference_type(0)) { std::set block_tags = { L"@author", L"@deprecated", L"@exception", L"@param", L"@param[in]", L"@param[in,out]", L"@param[out]", L"@return", L"@see", L"@since", L"@throws", L"@version" }; std::wstring result(match[1]); result.erase(std::remove_if(result.begin(), result.end(), ::isspace), result.end()); auto &&it_block_tag = block_tags.find(result); if ( it_block_tag != block_tags.end() && javaparam_tag_is_start_of_line(str, idx)) { return(int(idx + match[1].length())); } } } return(-1); } // match_javadoc_block_tag static void calculate_doxygen_javadoc_indent_alignment(const std::wstring &str, size_t &doxygen_javadoc_param_name_indent, size_t &doxygen_javadoc_continuation_indent) { log_rule_B("cmt_align_doxygen_javadoc_tags"); doxygen_javadoc_continuation_indent = 0; doxygen_javadoc_param_name_indent = 0; if (!options::cmt_align_doxygen_javadoc_tags()) { return; } for (size_t idx = 0; idx < str.size(); ++idx) { int start_idx = idx; int end_idx = match_doxygen_javadoc_tag(str, start_idx); if (end_idx > start_idx) { size_t block_tag_width = 1 + std::count_if(str.begin() + start_idx, str.begin() + end_idx, [](wchar_t ch) { return(!unc_isspace(ch)); }); if (block_tag_width > doxygen_javadoc_param_name_indent) { doxygen_javadoc_param_name_indent = block_tag_width; } idx = eat_line_whitespace(str, end_idx); size_t param_name_width = 0; if (str.find(L"@param", start_idx) == size_t(start_idx)) { param_name_width = 1; while (true) { while ( !unc_isspace(str[idx]) && str[idx] != ',') { ++param_name_width; ++idx; } idx = eat_line_whitespace(str, idx); if (str[idx] != ',') { break; } param_name_width += 2; idx = eat_line_whitespace(str, idx + 1); } } if (param_name_width > doxygen_javadoc_continuation_indent) { doxygen_javadoc_continuation_indent = param_name_width; } } } if (doxygen_javadoc_param_name_indent > 0) { log_rule_B("cmt_sp_before_doxygen_javadoc_tags"); doxygen_javadoc_param_name_indent += options::cmt_sp_before_doxygen_javadoc_tags(); doxygen_javadoc_continuation_indent += doxygen_javadoc_param_name_indent; } } // calculate_doxygen_javadoc_indent_alignment static void calculate_comment_body_indent(cmt_reflow &cmt, const unc_text &str) { cmt.xtra_indent = 0; log_rule_B("cmt_indent_multi"); if (!options::cmt_indent_multi()) { return; } size_t idx = 0; size_t len = str.size(); size_t last_len = 0; log_rule_B("cmt_multi_check_last"); if (options::cmt_multi_check_last()) { // find the last line length for (idx = len - 1; idx > 0; idx--) { if ( str[idx] == '\n' || str[idx] == '\r') { idx++; while ( idx < len && ( str[idx] == ' ' || str[idx] == '\t')) { idx++; } last_len = len - idx; break; } } } // find the first line length size_t first_len = 0; for (idx = 0; idx < len; idx++) { if ( str[idx] == '\n' || str[idx] == '\r') { first_len = idx; while ( str[first_len - 1] == ' ' || str[first_len - 1] == '\t') { if (first_len == 0) { fprintf(stderr, "%s(%d): first_len is ZERO, cannot be decremented.\n", __func__, __LINE__); log_flush(true); exit(EX_SOFTWARE); } first_len--; } // handle DOS endings if ( str[idx] == '\r' && str[idx + 1] == '\n') { idx++; } idx++; break; } } // Scan the second line size_t width = 0; for ( ; idx < len - 1; idx++) { if ( str[idx] == ' ' || str[idx] == '\t') { if (width > 0) { break; } continue; } if ( str[idx] == '\n' || str[idx] == '\r') { break; // Done with second line } // Count the leading chars if ( str[idx] == '*' || str[idx] == '|' || str[idx] == '\\' || str[idx] == '#' || str[idx] == '+') { width++; } else { if ( width != 1 || str[idx - 1] != '*') { width = 0; } break; } } // LOG_FMT(LSYS, "%s: first=%d last=%d width=%d\n", __func__, first_len, last_len, width); /* * If the first and last line are the same length and don't contain any * alphanumeric chars and (the first line len > cmt_multi_first_len_minimum * or the second leader is the same as the first line length), then the * indent is 0. */ log_rule_B("cmt_multi_first_len_minimum"); if ( first_len == last_len && ( first_len > options::cmt_multi_first_len_minimum() || first_len == width)) { return; } cmt.xtra_indent = (width == 2) ? 0 : 1; } // calculate_comment_body_indent // TODO: can we use search_next_chunk here? static Chunk *get_next_function(Chunk *pc) { if (pc == nullptr) { pc = Chunk::NullChunkPtr; } while ((pc = pc->GetNext())->IsNotNullChunk()) { if ( pc->Is(CT_FUNC_DEF) || pc->Is(CT_FUNC_PROTO) || pc->Is(CT_FUNC_CLASS_DEF) || pc->Is(CT_FUNC_CLASS_PROTO) || pc->Is(CT_OC_MSG_DECL)) { return(pc); } } return(nullptr); } static Chunk *get_next_class(Chunk *pc) { return(pc->GetNextType(CT_CLASS)->GetNext()); } static Chunk *get_prev_category(Chunk *pc) { return(pc->GetPrevType(CT_OC_CATEGORY)); } static Chunk *get_next_scope(Chunk *pc) { return(pc->GetNextType(CT_OC_SCOPE)); } static Chunk *get_prev_oc_class(Chunk *pc) { return(pc->GetPrevType(CT_OC_CLASS)); } static int next_up(const unc_text &text, size_t idx, const unc_text &tag) { size_t offs = 0; while ( idx < text.size() && unc_isspace(text[idx])) { idx++; offs++; } if (text.startswith(tag, idx)) { return(offs); } return(-1); } static void add_comment_text(const unc_text &text, cmt_reflow &cmt, bool esc_close, size_t continuation_indent) { bool was_star = false; bool was_slash = false; bool in_word = false; size_t len = text.size(); size_t ch_cnt = 0; // chars since newline // If the '//' is included write it first else we may wrap an empty line size_t idx = 0; if (text.startswith("//")) { add_text("//"); idx += 2; while (unc_isspace(text[idx])) { add_char(text[idx++]); } } for ( ; idx < len; idx++) // TODO: avoid modifying idx in loop { // Split the comment if (text[idx] == '\n') { in_word = false; add_char('\n'); cmt_output_indent(cmt.brace_col, cmt.base_col, cmt.column); if (cmt.xtra_indent > 0) { add_char(' '); } // hack to get escaped newlines to align and not duplicate the leading '//' int tmp = next_up(text, idx + 1, "//"); if (tmp < 0) { add_text(cmt.cont_text); } else { idx += tmp; } ch_cnt = 0; } else if ( cmt.reflow && text[idx] == ' ' && options::cmt_width() > 0 && ( cpd.column > options::cmt_width() || ( ch_cnt > 1 && next_word_exceeds_limit(text, idx)))) { log_rule_B("cmt_width"); in_word = false; add_char('\n'); cmt_output_indent(cmt.brace_col, cmt.base_col, cmt.column); if (cmt.xtra_indent > 0) { add_char(' '); } // The number of spaces to insert after the star on subsequent comment lines. log_rule_B("cmt_sp_after_star_cont"); /** * calculate the output column */ size_t column = options::cmt_sp_after_star_cont(); if ( text[idx + 1] == 42 // this is star * && text[idx + 2] == 47) // this is / { LOG_FMT(LCONTTEXT, "%s(%d): we have a comment end\n", __func__, __LINE__); column += cmt.column; } else { add_text(cmt.cont_text); if (continuation_indent > 0) { if (options::cmt_align_doxygen_javadoc_tags()) { log_rule_B("cmt_align_doxygen_javadoc_tags"); } else if (options::cmt_reflow_indent_to_paragraph_start()) { log_rule_B("cmt_reflow_indent_to_paragraph_start"); } column += continuation_indent; log_rule_B("cmt_sp_after_star_cont"); if (column >= options::cmt_sp_after_star_cont()) { column -= options::cmt_sp_after_star_cont(); } } /** * count the number trailing spaces in the comment continuation text */ size_t num_trailing_sp = 0; while ( num_trailing_sp < cmt.cont_text.size() && unc_isspace(cmt.cont_text[cmt.cont_text.size() - 1 - num_trailing_sp])) { ++num_trailing_sp; } column += cpd.column; if (column >= num_trailing_sp) { column -= num_trailing_sp; } } output_to_column(column, false); ch_cnt = 0; } else { // Escape a C closure in a CPP comment if ( esc_close && ( ( was_star && text[idx] == '/') || ( was_slash && text[idx] == '*'))) { add_char(' '); } if ( !in_word && !unc_isspace(text[idx])) { cmt.word_count++; } in_word = !unc_isspace(text[idx]); add_char(text[idx]); was_star = (text[idx] == '*'); was_slash = (text[idx] == '/'); ch_cnt++; } } } // add_comment_text static void output_cmt_start(cmt_reflow &cmt, Chunk *pc) { cmt.pc = pc; cmt.column = pc->GetColumn(); cmt.brace_col = pc->GetColumnIndent(); cmt.base_col = pc->GetColumnIndent(); cmt.word_count = 0; cmt.xtra_indent = 0; cmt.cont_text.clear(); cmt.reflow = false; // Issue #2752 log_rule_B("cmt_insert_file_header"); log_rule_B("cmt_insert_file_footer"); log_rule_B("cmt_insert_func_header)"); log_rule_B("cmt_insert_class_header"); log_rule_B("cmt_insert_oc_msg_header"); if ( options::cmt_insert_file_header().size() > 0 || options::cmt_insert_file_footer().size() > 0 || options::cmt_insert_func_header().size() > 0 || options::cmt_insert_class_header().size() > 0 || options::cmt_insert_oc_msg_header().size() > 0) { LOG_FMT(LCONTTEXT, "%s(%d): cmt_insert_file\n", __func__, __LINE__); do_kw_subst(pc); } else { LOG_FMT(LCONTTEXT, "%s(%d): no cmt_insert_file\n", __func__, __LINE__); } if (cmt.brace_col == 0) { log_rule_B("output_tab_size"); cmt.brace_col = 1 + (pc->GetBraceLevel() * options::output_tab_size()); } // LOG_FMT(LSYS, "%s: line %zd, brace=%zd base=%zd col=%zd orig=%zd aligned=%x\n", // __func__, pc->GetOrigLine(), cmt.brace_col, cmt.base_col, cmt.column, pc->GetOrigCol(), // pc->GetFlags() & (PCF_WAS_ALIGNED | PCF_RIGHT_COMMENT)); if ( pc->GetParentType() == CT_COMMENT_START || pc->GetParentType() == CT_COMMENT_WHOLE) { log_rule_B("indent_col1_comment"); if ( !options::indent_col1_comment() && pc->GetOrigCol() == 1 && !pc->TestFlags(PCF_INSERTED)) { cmt.column = 1; cmt.base_col = 1; cmt.brace_col = 1; } } // tab aligning code log_rule_B("indent_cmt_with_tabs"); if ( options::indent_cmt_with_tabs() && ( pc->GetParentType() == CT_COMMENT_END || pc->GetParentType() == CT_COMMENT_WHOLE)) { cmt.column = align_tab_column(cmt.column - 1); // LOG_FMT(LSYS, "%s: line %d, orig:%d new:%d\n", // __func__, pc->GetOrigLine(), pc->GetColumn(), cmt.column); pc->SetColumn(cmt.column); } cmt.base_col = cmt.column; // LOG_FMT(LSYS, "%s: -- brace=%d base=%d col=%d\n", // __func__, cmt.brace_col, cmt.base_col, cmt.column); // Bump out to the column cmt_output_indent(cmt.brace_col, cmt.base_col, cmt.column); } // output_cmt_start static bool can_combine_comment(Chunk *pc, cmt_reflow &cmt) { // We can't combine if there is something other than a newline next if (pc->GetParentType() == CT_COMMENT_START) { return(false); } // next is a newline for sure, make sure it is a single newline if (pc == nullptr) { pc = Chunk::NullChunkPtr; } Chunk *next = pc->GetNext(); if ( next->IsNotNullChunk() && next->GetNlCount() == 1) { // Make sure the comment is the same type at the same column next = next->GetNext(); if ( next->Is(pc->GetType()) && ( ( next->GetColumn() == 1 && pc->GetColumn() == 1) || ( next->GetColumn() == cmt.base_col && pc->GetColumn() == cmt.base_col) || ( next->GetColumn() > cmt.base_col && pc->GetParentType() == CT_COMMENT_END))) { return(true); } } return(false); } // can_combine_comment static Chunk *output_comment_c(Chunk *first) { cmt_reflow cmt; output_cmt_start(cmt, first); log_rule_B("cmt_reflow_mode"); cmt.reflow = (options::cmt_reflow_mode() != 1); // See if we can combine this comment with the next comment log_rule_B("cmt_c_group"); if ( !options::cmt_c_group() || !can_combine_comment(first, cmt)) { // Just add the single comment log_rule_B("cmt_star_cont"); cmt.cont_text = options::cmt_star_cont() ? " * " : " "; LOG_CONTTEXT(); log_rule_B("cmt_trailing_single_line_c_to_cpp"); if (options::cmt_trailing_single_line_c_to_cpp() && first->IsLastChunkOnLine()) { add_text("//"); unc_text tmp; tmp.set(first->GetStr(), 2, first->Len() - 4); cmt_trim_whitespace(tmp, false); add_comment_text(tmp, cmt, false); } else { add_comment_text(first->GetStr(), cmt, false); } return(first); } log_rule_B("cmt_star_cont"); cmt.cont_text = options::cmt_star_cont() ? " *" : " "; LOG_CONTTEXT(); add_text("/*"); log_rule_B("cmt_c_nl_start"); if (options::cmt_c_nl_start()) { add_comment_text("\n", cmt, false); } Chunk *pc = first; unc_text tmp; while (can_combine_comment(pc, cmt)) { LOG_FMT(LCONTTEXT, "%s(%d): Text() is '%s'\n", __func__, __LINE__, pc->Text()); tmp.set(pc->GetStr(), 2, pc->Len() - 4); if ( cpd.last_char == '*' && tmp[0] != ' ') // Issue #1908 { LOG_FMT(LCONTTEXT, "%s(%d): add_text a " "\n", __func__, __LINE__); add_text(" "); } // In case of reflow, original comment could contain trailing spaces before closing the comment, we don't need them after reflow LOG_FMT(LCONTTEXT, "%s(%d): trim\n", __func__, __LINE__); cmt_trim_whitespace(tmp, false); LOG_FMT(LCONTTEXT, "%s(%d): add_comment_text(tmp is '%s')\n", __func__, __LINE__, tmp.c_str()); add_comment_text(tmp, cmt, false); LOG_FMT(LCONTTEXT, "%s(%d): add_comment_text(newline)\n", __func__, __LINE__); add_comment_text("\n", cmt, false); pc = pc->GetNext(); pc = pc->GetNext(); } tmp.set(pc->GetStr(), 2, pc->Len() - 4); if ( cpd.last_char == '*' && tmp[0] == '/') { add_text(" "); } // In case of reflow, original comment could contain trailing spaces before closing the comment, we don't need them after reflow cmt_trim_whitespace(tmp, false); add_comment_text(tmp, cmt, false); log_rule_B("cmt_c_nl_end"); if (options::cmt_c_nl_end()) { cmt.cont_text = " "; LOG_CONTTEXT(); add_comment_text("\n", cmt, false); } add_comment_text("*/", cmt, false); return(pc); } // output_comment_c static Chunk *output_comment_cpp(Chunk *first) { cmt_reflow cmt; output_cmt_start(cmt, first); log_rule_B("cmt_reflow_mode"); cmt.reflow = (options::cmt_reflow_mode() != 1); unc_text leadin = "//"; // default setting to keep previous behaviour // If true, space is added with sp_cmt_cpp_start will be added after doxygen // sequences like '///', '///<', '//!' and '//!<'. log_rule_B("sp_cmt_cpp_doxygen"); if (options::sp_cmt_cpp_doxygen()) // special treatment for doxygen style comments (treat as unity) { const char *sComment = first->Text(); bool grouping = (sComment[2] == '@'); size_t brace = 3; if ( sComment[2] == '/' || sComment[2] == '!') // doxygen style found! { leadin += sComment[2]; // at least one additional char (either "///" or "//!") if (sComment[3] == '<') // and a further one (either "///<" or "//!<") { leadin += '<'; } else { grouping = (sComment[3] == '@'); // or a further one (grouping) brace = 4; } } if ( grouping && ( sComment[brace] == '{' || sComment[brace] == '}')) { leadin += '@'; leadin += sComment[brace]; } } // Special treatment for Qt translator or meta-data comments (treat as unity) // If true, space is added with sp_cmt_cpp_start will be added after Qt // translator or meta-data comments like '//:', '//=', and '//~'. log_rule_B("sp_cmt_cpp_qttr"); if (options::sp_cmt_cpp_qttr()) { const int c = first->GetStr()[2]; if ( c == ':' || c == '=' || c == '~') { leadin += c; } } // CPP comments can't be grouped unless they are converted to C comments log_rule_B("cmt_cpp_to_c"); if (!options::cmt_cpp_to_c()) { auto const *cmt_text = first->GetStr().c_str() + 2; // Add or remove space after the opening of a C++ comment, // i.e. '// A' vs. '//A'. auto *sp_cmt = &options::sp_cmt_cpp_start; cmt.cont_text = leadin; // Get start of comment text while ( *cmt_text != '\0' && unc_isspace(*cmt_text)) { ++cmt_text; } // Determine if we are dealing with a region marker if ( ( first->GetPrev()->IsNullChunk() || first->GetPrev()->GetOrigLine() != first->GetOrigLine()) && ( strncmp(cmt_text, "BEGIN", 5) == 0 || strncmp(cmt_text, "END", 3) == 0)) { // If sp_cmt_cpp_region is not ignore, use that instead of // sp_cmt_cpp_start if (options::sp_cmt_cpp_region() != IARF_IGNORE) { sp_cmt = &options::sp_cmt_cpp_region; } } // Add or remove space after the opening of a C++ comment, // i.e. '// A' vs. '//A'. log_rule_B(sp_cmt->name()); if ((*sp_cmt)() != IARF_REMOVE) { cmt.cont_text += ' '; } LOG_CONTTEXT(); // Add or remove space after the opening of a C++ comment, // i.e. '// A' vs. '//A'. log_rule_B(sp_cmt->name()); if ((*sp_cmt)() == IARF_IGNORE) { add_comment_text(first->GetStr(), cmt, false); } else { size_t iLISz = leadin.size(); unc_text tmp(first->GetStr(), 0, iLISz); add_comment_text(tmp, cmt, false); tmp.set(first->GetStr(), iLISz, first->Len() - iLISz); // Add or remove space after the opening of a C++ comment, // i.e. '// A' vs. '//A'. log_rule_B("sp_cmt_cpp_start"); if ((*sp_cmt)() & IARF_REMOVE) { while ( (tmp.size() > 0) && unc_isspace(tmp[0])) { tmp.pop_front(); } } if (tmp.size() > 0) { // Add or remove space after the opening of a C++ comment, // i.e. '// A' vs. '//A'. log_rule_B("sp_cmt_cpp_start"); if ((*sp_cmt)() & IARF_ADD) { if ( !unc_isspace(tmp[0]) && (tmp[0] != '/')) { add_comment_text(" ", cmt, false); } } add_comment_text(tmp, cmt, false); } } return(first); } // We are going to convert the CPP comments to C comments log_rule_B("cmt_star_cont"); cmt.cont_text = options::cmt_star_cont() ? " * " : " "; LOG_CONTTEXT(); unc_text tmp; // See if we can combine this comment with the next comment log_rule_B("cmt_cpp_group"); if ( !options::cmt_cpp_group() || !can_combine_comment(first, cmt)) { // nothing to group: just output a single line add_text("/*"); // patch # 32, 2012-03-23 // Add or remove space after the opening of a C++ comment, // i.e. '// A' vs. '//A'. log_rule_B("sp_cmt_cpp_start"); if ( !unc_isspace(first->GetStr()[2]) && (options::sp_cmt_cpp_start() & IARF_ADD)) { add_char(' '); } tmp.set(first->GetStr(), 2, first->Len() - 2); add_comment_text(tmp, cmt, true); add_text(" */"); return(first); } add_text("/*"); log_rule_B("cmt_cpp_nl_start"); if (options::cmt_cpp_nl_start()) { add_comment_text("\n", cmt, false); } else { add_text(" "); } Chunk *pc = first; int offs; while (can_combine_comment(pc, cmt)) { offs = unc_isspace(pc->GetStr()[2]) ? 1 : 0; tmp.set(pc->GetStr(), 2 + offs, pc->Len() - (2 + offs)); if ( cpd.last_char == '*' && tmp[0] == '/') { add_text(" "); } add_comment_text(tmp, cmt, true); add_comment_text("\n", cmt, false); pc = pc->GetNext()->GetNext(); } offs = unc_isspace(pc->GetStr()[2]) ? 1 : 0; tmp.set(pc->GetStr(), 2 + offs, pc->Len() - (2 + offs)); add_comment_text(tmp, cmt, true); log_rule_B("cmt_cpp_nl_end"); if (options::cmt_cpp_nl_end()) { cmt.cont_text = ""; LOG_CONTTEXT(); add_comment_text("\n", cmt, false); } add_comment_text(" */", cmt, false); return(pc); } // output_comment_cpp static void cmt_trim_whitespace(unc_text &line, bool in_preproc) { // Remove trailing whitespace on the line while ( line.size() > 0 && ( line.back() == ' ' || line.back() == '\t')) { line.pop_back(); } // Shift back to the comment text, ... if ( in_preproc // if in a preproc ... && line.size() > 1 // with a line that holds ... && line.back() == '\\') // a backslash-newline ... { bool do_space = false; // If there was any space before the backslash, change it to 1 space line.pop_back(); while ( line.size() > 0 && ( line.back() == ' ' || line.back() == '\t')) { do_space = true; line.pop_back(); } if (do_space) { line.append(' '); } line.append('\\'); } } // cmt_trim_whitespace /** * Return an indexed-map of reflow fold end of line/beginning of line regex pairs read * from file */ static std::map > get_reflow_fold_regex_map() { /** * TODO: should the following be static to prevent initializing it multiple times? */ static std::map > regex_map; if (regex_map.empty()) { if (!options::cmt_reflow_fold_regex_file().empty()) { std::wstring raw_wstring(cpd.reflow_fold_regex.raw.begin(), cpd.reflow_fold_regex.raw.end()); std::wregex criteria(L"\\s*(?:(?:(beg_of_next)|(end_of_prev))_line_regex)" "\\s*\\[\\s*([0-9]+)\\s*\\]\\s*=\\s*\"(.*)\"\\s*" "(?=\\r\\n|\\r|\\n|$)"); std::wsregex_iterator it_regex(raw_wstring.cbegin(), raw_wstring.cend(), criteria); std::wsregex_iterator it_regex_end = std::wsregex_iterator(); while (it_regex != it_regex_end) { std::wsmatch match = *it_regex; if ( (( match[1].matched || match[2].matched)) && match[3].matched && match[4].matched) { auto &&index = std::stoi(match[3].str()); std::wregex *p_wregex = match[1].matched ? ®ex_map[index].second : ®ex_map[index].first; *p_wregex = match[4].str(); } ++it_regex; } } else { regex_map.emplace(0L, std::make_pair((std::wregex)L"[\\w,\\]\\)]$", (std::wregex)L"^[\\w,\\[\\(]")); regex_map.emplace(1L, std::make_pair((std::wregex)L"\\.$", (std::wregex)L"^[A-Z]")); } } return(regex_map); } // get_reflow_fold_regex_map static void output_comment_multi(Chunk *pc) { if (pc == nullptr) { return; } cmt_reflow cmt; char copy[1000]; LOG_FMT(LCONTTEXT, "%s(%d): Text() is '%s', type is %s, orig col is %zu, column is %zu\n", __func__, __LINE__, pc->ElidedText(copy), get_token_name(pc->GetType()), pc->GetOrigCol(), pc->GetColumn()); output_cmt_start(cmt, pc); log_rule_B("cmt_reflow_mode"); cmt.reflow = (options::cmt_reflow_mode() != 1); size_t cmt_col = cmt.base_col; int col_diff = pc->GetOrigCol() - cmt.base_col; calculate_comment_body_indent(cmt, pc->GetStr()); log_rule_B("cmt_indent_multi"); log_rule_B("cmt_star_cont"); cmt.cont_text = !options::cmt_indent_multi() ? "" : (options::cmt_star_cont() ? "* " : " "); LOG_CONTTEXT(); std::wstring pc_wstring(pc->GetStr().get().cbegin(), pc->GetStr().get().cend()); size_t doxygen_javadoc_param_name_indent = 0; size_t doxygen_javadoc_continuation_indent = 0; size_t reflow_paragraph_continuation_indent = 0; calculate_doxygen_javadoc_indent_alignment(pc_wstring, doxygen_javadoc_param_name_indent, doxygen_javadoc_continuation_indent); size_t line_count = 0; size_t ccol = pc->GetColumn(); // the col of subsequent comment lines size_t cmt_idx = 0; bool nl_end = false; bool doxygen_javadoc_indent_align = false; unc_text line; /* * Get a map of regex pairs that define expressions to match at both the end * of the previous line and the beginning of the next line */ auto &&cmt_reflow_regex_map = get_reflow_fold_regex_map(); line.clear(); LOG_FMT(LCONTTEXT, "%s(%d): pc->Len() is %zu\n", __func__, __LINE__, pc->Len()); //LOG_FMT(LCONTTEXT, "%s(%d): pc->str is %s\n", // __func__, __LINE__, pc->str.c_str()); /** * check for enable/disable processing comment strings that may * both be embedded within the same multi-line comment */ auto disable_processing_cmt_idx = find_disable_processing_comment_marker(pc->GetStr()); auto enable_processing_cmt_idx = find_enable_processing_comment_marker(pc->GetStr()); while (cmt_idx < pc->Len()) { int ch = pc->GetStr()[cmt_idx]; cmt_idx++; if ( cmt_idx > std::size_t(disable_processing_cmt_idx) && enable_processing_cmt_idx > disable_processing_cmt_idx) { auto length = enable_processing_cmt_idx - disable_processing_cmt_idx; unc_text verbatim_text(pc->GetStr(), disable_processing_cmt_idx, length); add_text(verbatim_text); cmt_idx = enable_processing_cmt_idx; /** * check for additional enable/disable processing comment strings that may * both be embedded within the same multi-line comment */ disable_processing_cmt_idx = find_disable_processing_comment_marker(pc->GetStr(), enable_processing_cmt_idx); enable_processing_cmt_idx = find_enable_processing_comment_marker(pc->GetStr(), enable_processing_cmt_idx); /** * it's probably necessary to reset the line count to prevent line * continuation characters from being added to the end of the current line */ line_count = 0; } // handle the CRLF and CR endings. convert both to LF if (ch == '\r') { ch = '\n'; if ( cmt_idx < pc->Len() && pc->GetStr()[cmt_idx] == '\n') { cmt_idx++; } } // Find the start column if (line.size() == 0) { nl_end = false; if (ch == ' ') { ccol++; continue; } else if (ch == '\t') { log_rule_B("input_tab_size"); ccol = calc_next_tab_column(ccol, options::input_tab_size()); continue; } else { LOG_FMT(LCONTTEXT, "%s(%d):ch is %d, %c\n", __func__, __LINE__, ch, char(ch)); } } if ( ch == '@' && options::cmt_align_doxygen_javadoc_tags()) { int start_idx = cmt_idx - 1; int end_idx = match_doxygen_javadoc_tag(pc_wstring, start_idx); if (end_idx > start_idx) { doxygen_javadoc_indent_align = true; std::string match(pc->GetStr().get().cbegin() + start_idx, pc->GetStr().get().cbegin() + end_idx); match.erase(std::remove_if(match.begin(), match.end(), ::isspace), match.end()); /** * remove whitespace before the '@' */ int line_size_before_indent = line.size(); while ( line_size_before_indent > 0 && unc_isspace(line.back())) { line.pop_back(); --line_size_before_indent; } log_rule_B("cmt_sp_before_doxygen_javadoc_tags"); int indent = options::cmt_sp_before_doxygen_javadoc_tags(); while (indent-- > 0) { line.append(' '); } cmt_idx += (end_idx - start_idx); line.append(match.c_str()); bool is_exception_tag = match.find("@exception") != std::string::npos; bool is_param_tag = match.find("@param") != std::string::npos; bool is_throws_tag = match.find("@throws") != std::string::npos; if ( is_exception_tag || is_param_tag || is_throws_tag) { indent = int(doxygen_javadoc_param_name_indent) - int(line.size()); while (indent-- > -line_size_before_indent) { line.append(' '); } while (true) { cmt_idx = eat_line_whitespace(pc->GetStr(), cmt_idx); while ( cmt_idx < pc->Len() && !unc_isspace(pc->GetStr()[cmt_idx]) && pc->GetStr()[cmt_idx] != ',') { line.append(pc->Str()[cmt_idx++]); } if (!is_param_tag) { break; } /** * check for the possibility that comma-separated parameter names are present */ cmt_idx = eat_line_whitespace(pc->GetStr(), cmt_idx); if (pc->GetStr()[cmt_idx] != ',') { break; } ++cmt_idx; line.append(", "); } } cmt_idx = eat_line_whitespace(pc->GetStr(), cmt_idx); indent = int(doxygen_javadoc_continuation_indent) - int(line.size()); while (indent-- > -line_size_before_indent) { line.append(' '); } while ( cmt_idx < pc->Len() && !unc_isspace(pc->GetStr()[cmt_idx])) { line.append(pc->Str()[cmt_idx++]); } continue; } } /* * Now see if we need/must fold the next line with the current to enable * full reflow */ log_rule_B("cmt_reflow_mode"); if ( options::cmt_reflow_mode() == 2 && ch == '\n' && cmt_idx < pc->Len()) { int next_nonempty_line = -1; int prev_nonempty_line = -1; size_t nwidx = line.size(); // strip trailing whitespace from the line collected so far while (nwidx > 0) { nwidx--; if ( prev_nonempty_line < 0 && !unc_isspace(line[nwidx]) && line[nwidx] != '*' // block comment: skip '*' at end of line && (pc->TestFlags(PCF_IN_PREPROC) ? ( line[nwidx] != '\\' || ( line[nwidx + 1] != '\r' && line[nwidx + 1] != '\n')) : true)) { prev_nonempty_line = nwidx; // last non-whitespace char in the previous line } } for (size_t nxt_idx = cmt_idx; ( nxt_idx < pc->Len() && pc->GetStr()[nxt_idx] != '\r' && pc->GetStr()[nxt_idx] != '\n'); nxt_idx++) { if ( next_nonempty_line < 0 && !unc_isspace(pc->GetStr()[nxt_idx]) && pc->GetStr()[nxt_idx] != '*' && (pc->TestFlags(PCF_IN_PREPROC) ? ( pc->GetStr()[nxt_idx] != '\\' || ( pc->GetStr()[nxt_idx + 1] != '\r' && pc->GetStr()[nxt_idx + 1] != '\n')) : true)) { next_nonempty_line = nxt_idx; // first non-whitespace char in the next line } } if ( options::cmt_reflow_indent_to_paragraph_start() && next_nonempty_line >= 0 && ( prev_nonempty_line <= 0 || doxygen_javadoc_indent_align)) { log_rule_B("cmt_reflow_indent_to_paragraph_start"); int cmt_star_indent = 0; while ( next_nonempty_line > cmt_star_indent && pc->GetStr()[next_nonempty_line - cmt_star_indent - 1] != '*') { ++cmt_star_indent; } reflow_paragraph_continuation_indent = size_t(cmt_star_indent); } /* * see if we should fold up; usually that'd be a YES, but there are a few * situations where folding/reflowing by merging lines is frowned upon: * * - ASCII art in the comments (most often, these are drawings done in +-\/|.,*) * * - Doxygen/JavaDoc/etc. parameters: these often start with \ or @, at least * something clearly non-alphanumeric (you see where we're going with this?) * * - bullet lists that are closely spaced: bullets are always non-alphanumeric * characters, such as '-' or '+' (or, oh horror, '*' - that's bloody ambiguous * to parse :-( ... with or without '*' comment start prefix, that's the * question, then.) * * - semi-HTML formatted code, e.g. 
...
comment sections (NDoc, etc.) * * - New lines which form a new paragraph without there having been added an * extra empty line between the last sentence and the new one. * A bit like this, really; so it is opportune to check if the last line ended * in a terminal (that would be the set '.:;!?') and the new line starts with * a capital. * Though new lines starting with comment delimiters, such as '(', should be * pulled up. * * So it bores down to this: the only folding (& reflowing) that's going to happen * is when the next line starts with an alphanumeric character AND the last * line didn't end with an non-alphanumeric character, except: ',' AND the next * line didn't start with a '*' all of a sudden while the previous one didn't * (the ambiguous '*'-for-bullet case!) */ if ( prev_nonempty_line >= 0 && next_nonempty_line >= int(cmt_idx)) { std::wstring prev_line(line.get().cbegin(), line.get().cend()); std::wstring next_line(pc->GetStr().get().cbegin() + next_nonempty_line, pc->GetStr().get().cend()); for (auto &&cmt_reflow_regex_map_entry : cmt_reflow_regex_map) { auto &&cmt_reflow_regex_pair = cmt_reflow_regex_map_entry.second; auto &&end_of_prev_line_regex = cmt_reflow_regex_pair.first; auto &&beg_of_next_line_regex = cmt_reflow_regex_pair.second; std::wsmatch match[2]; if ( std::regex_search(prev_line, match[0], end_of_prev_line_regex) && match[0].position(0) + match[0].length(0) == std::wsmatch::difference_type(line.size()) && std::regex_search(next_line, match[1], beg_of_next_line_regex) && match[1].position(0) == 0) { // rewind the line to the last non-alpha: line.resize(prev_nonempty_line + 1); // roll the current line forward to the first non-alpha: cmt_idx = next_nonempty_line; // override the NL and make it a single whitespace: ch = ' '; break; } } } } if (ch == '\n') { LOG_FMT(LCONTTEXT, "%s(%d):ch is newline\n", __func__, __LINE__); } else { LOG_FMT(LCONTTEXT, "%s(%d):ch is %d, %c\n", __func__, __LINE__, ch, char(ch)); } line.append(ch); // If we just hit an end of line OR we just hit end-of-comment... if ( ch == '\n' || cmt_idx == pc->Len()) { if (ch == '\n') { LOG_FMT(LCONTTEXT, "%s(%d):ch is newline\n", __func__, __LINE__); } else { LOG_FMT(LCONTTEXT, "%s(%d):ch is %d, %c\n", __func__, __LINE__, ch, char(ch)); } line_count++; LOG_FMT(LCONTTEXT, "%s(%d):line_count is %zu\n", __func__, __LINE__, line_count); // strip trailing tabs and spaces before the newline if (ch == '\n') { nl_end = true; line.pop_back(); cmt_trim_whitespace(line, pc->TestFlags(PCF_IN_PREPROC)); } if (line_count == 1) { // this is the first line - add unchanged add_comment_text(line, cmt, false); if (nl_end) { add_char('\n'); } } else { /* * This is not the first line, so we need to indent to the * correct column. Each line is indented 0 or more spaces. */ // Ensure ccol is not negative if (static_cast(ccol) >= col_diff) { ccol -= col_diff; } if (ccol < (cmt_col + 3)) { ccol = cmt_col + 3; } if (line.size() == 0) { // Empty line - just a '\n' log_rule_B("cmt_star_cont"); if (options::cmt_star_cont()) { // The number of spaces to insert at the start of subsequent comment lines. log_rule_B("cmt_sp_before_star_cont"); cmt.column = cmt_col + options::cmt_sp_before_star_cont(); cmt_output_indent(cmt.brace_col, cmt.base_col, cmt.column); if (cmt.xtra_indent > 0) { add_char(' '); } // multiline comments can have empty lines with some spaces in them for alignment // while adding * symbol and aligning them we don't want to keep these trailing spaces unc_text tmp = unc_text(cmt.cont_text); cmt_trim_whitespace(tmp, false); add_text(tmp); } add_char('\n'); } else { /* * If this doesn't start with a '*' or '|'. * '\name' is a common parameter documentation thing. */ log_rule_B("cmt_indent_multi"); if ( options::cmt_indent_multi() && line[0] != '*' && line[0] != '|' && line[0] != '#' && ( line[0] != '\\' || unc_isalpha(line[1])) && line[0] != '+') { // The number of spaces to insert at the start of subsequent comment lines. log_rule_B("cmt_sp_before_star_cont"); size_t start_col = cmt_col + options::cmt_sp_before_star_cont(); log_rule_B("cmt_star_cont"); if (options::cmt_star_cont()) { cmt.column = start_col; cmt_output_indent(cmt.brace_col, cmt.base_col, cmt.column); if (cmt.xtra_indent > 0) { add_char(' '); } add_text(cmt.cont_text); // The number of spaces to insert after the star on subsequent comment lines. log_rule_B("cmt_sp_after_star_cont"); output_to_column(ccol + options::cmt_sp_after_star_cont(), false); } else { cmt.column = ccol; cmt_output_indent(cmt.brace_col, cmt.base_col, cmt.column); } } else { // The number of spaces to insert at the start of subsequent comment lines. log_rule_B("cmt_sp_before_star_cont"); cmt.column = cmt_col + options::cmt_sp_before_star_cont(); cmt_output_indent(cmt.brace_col, cmt.base_col, cmt.column); if (cmt.xtra_indent > 0) { add_char(' '); } size_t idx; // Checks for and updates the lead chars. // @return 0=not present, >0=number of chars that are part of the lead idx = cmt_parse_lead(line, (cmt_idx == pc->Len())); if (idx > 0) { // >0=number of chars that are part of the lead cmt.cont_text.set(line, 0, idx); LOG_CONTTEXT(); if ( (line.size() >= 2) && (line[0] == '*') && unc_isalnum(line[1])) { line.insert(1, ' '); } } else { // bug #653 if (language_is_set(LANG_D)) { // 0=no lead char present add_text(cmt.cont_text); } } } size_t continuation_indent = 0; if (doxygen_javadoc_indent_align) { continuation_indent = doxygen_javadoc_continuation_indent; } else if (reflow_paragraph_continuation_indent > 0) { continuation_indent = reflow_paragraph_continuation_indent; } add_comment_text(line, cmt, false, continuation_indent); if (nl_end) { add_text("\n"); } } } line.clear(); doxygen_javadoc_indent_align = false; ccol = 1; } } } // output_comment_multi static bool kw_fcn_filename(Chunk *cmt, unc_text &out_txt) { UNUSED(cmt); out_txt.append(path_basename(cpd.filename.c_str())); return(true); } static bool kw_fcn_class(Chunk *cmt, unc_text &out_txt) { Chunk *tmp = Chunk::NullChunkPtr; if (language_is_set(LANG_CPP | LANG_OC)) { Chunk *fcn = get_next_function(cmt); if ( fcn != nullptr && fcn->Is(CT_OC_MSG_DECL)) { tmp = get_prev_oc_class(cmt); } else { tmp = get_next_class(cmt); } } else if (language_is_set(LANG_OC)) { tmp = get_prev_oc_class(cmt); } if (tmp->IsNullChunk()) { tmp = get_next_class(cmt); } if (tmp->IsNotNullChunk()) { out_txt.append(tmp->GetStr()); while ((tmp = tmp->GetNext())->IsNotNullChunk()) { if (tmp->IsNot(CT_DC_MEMBER)) { break; } tmp = tmp->GetNext(); if (tmp->IsNotNullChunk()) { out_txt.append("::"); out_txt.append(tmp->GetStr()); } } return(true); } return(false); } // kw_fcn_class static bool kw_fcn_message(Chunk *cmt, unc_text &out_txt) { Chunk *fcn = get_next_function(cmt); if (fcn == nullptr) { return(false); } out_txt.append(fcn->GetStr()); Chunk *tmp = fcn->GetNextNcNnl(); Chunk *word = Chunk::NullChunkPtr; while (tmp->IsNotNullChunk()) { if ( tmp->Is(CT_BRACE_OPEN) || tmp->Is(CT_SEMICOLON)) { break; } if (tmp->Is(CT_OC_COLON)) { if (word->IsNotNullChunk()) { out_txt.append(word->GetStr()); word = Chunk::NullChunkPtr; } out_txt.append(":"); } if (tmp->Is(CT_WORD)) { word = tmp; } tmp = tmp->GetNextNcNnl(); } return(true); } // kw_fcn_message static bool kw_fcn_category(Chunk *cmt, unc_text &out_txt) { Chunk *category = get_prev_category(cmt); if (category->IsNotNullChunk()) { out_txt.append('('); out_txt.append(category->GetStr()); out_txt.append(')'); } return(true); } // kw_fcn_category static bool kw_fcn_scope(Chunk *cmt, unc_text &out_txt) { Chunk *scope = get_next_scope(cmt); if (scope->IsNotNullChunk()) { out_txt.append(scope->GetStr()); return(true); } return(false); } // kw_fcn_scope static bool kw_fcn_function(Chunk *cmt, unc_text &out_txt) { Chunk *fcn = get_next_function(cmt); if (fcn != nullptr) { if (fcn->GetParentType() == CT_OPERATOR) { out_txt.append("operator "); } if (fcn->GetPrev()->GetType() == CT_DESTRUCTOR) { out_txt.append('~'); } out_txt.append(fcn->GetStr()); return(true); } return(false); } static bool kw_fcn_javaparam(Chunk *cmt, unc_text &out_txt) { Chunk *fcn = get_next_function(cmt); if (fcn == nullptr) { return(false); } Chunk *fpo; Chunk *fpc; bool has_param = true; bool need_nl = false; if (fcn->Is(CT_OC_MSG_DECL)) { Chunk *tmp = fcn->GetNextNcNnl(); has_param = false; while (tmp->IsNotNullChunk()) { if ( tmp->Is(CT_BRACE_OPEN) || tmp->Is(CT_SEMICOLON)) { break; } if (has_param) { if (need_nl) { out_txt.append("\n"); } need_nl = true; out_txt.append("@param"); out_txt.append(" "); out_txt.append(tmp->GetStr()); out_txt.append(" TODO"); } has_param = false; if (tmp->Is(CT_PAREN_CLOSE)) { has_param = true; } tmp = tmp->GetNextNcNnl(); } fpo = fpc = Chunk::NullChunkPtr; } else { fpo = fcn->GetNextType(CT_FPAREN_OPEN, fcn->GetLevel()); if (fpo->IsNullChunk()) { return(true); } fpc = fpo->GetNextType(CT_FPAREN_CLOSE, fcn->GetLevel()); if (fpc->IsNullChunk()) { return(true); } } Chunk *tmp; // Check for 'foo()' and 'foo(void)' if (fpo->IsNotNullChunk()) { if (fpo->GetNextNcNnl() == fpc) { has_param = false; } else { tmp = fpo->GetNextNcNnl(); if ( (tmp == fpc->GetPrevNcNnl()) && tmp->IsString("void")) { has_param = false; } } } if (has_param) { Chunk *prev = Chunk::NullChunkPtr; tmp = fpo; while ((tmp = tmp->GetNext())->IsNotNullChunk()) { if ( tmp->Is(CT_COMMA) || tmp == fpc) { if (need_nl) { out_txt.append("\n"); } need_nl = true; out_txt.append("@param"); if (prev->IsNotNullChunk()) { out_txt.append(" "); out_txt.append(prev->GetStr()); out_txt.append(" TODO"); } prev = Chunk::NullChunkPtr; if (tmp == fpc) { break; } } if (tmp->Is(CT_WORD)) { prev = tmp; } } } // Do the return stuff tmp = fcn->GetPrevNcNnl(); // For Objective-C we need to go to the previous chunk if ( tmp->IsNotNullChunk() && tmp->GetParentType() == CT_OC_MSG_DECL && tmp->Is(CT_PAREN_CLOSE)) { tmp = tmp->GetPrevNcNnl(); } if ( tmp->IsNotNullChunk() && !tmp->IsString("void")) { if (need_nl) { out_txt.append("\n"); } out_txt.append("@return TODO"); } return(true); } // kw_fcn_javaparam static bool kw_fcn_fclass(Chunk *cmt, unc_text &out_txt) { Chunk *fcn = get_next_function(cmt); if (!fcn) { return(false); } if (fcn->TestFlags(PCF_IN_CLASS)) { // if inside a class, we need to find to the class name Chunk *tmp = fcn->GetPrevType(CT_BRACE_OPEN, fcn->GetLevel() - 1); tmp = tmp->GetPrevType(CT_CLASS, tmp->GetLevel()); if (tmp->IsNullChunk()) { tmp = Chunk::NullChunkPtr; } else { tmp = tmp->GetNextNcNnl(); } while ( tmp->IsNotNullChunk() && tmp->GetNextNcNnl()->Is(CT_DC_MEMBER)) { tmp = tmp->GetNextNcNnl(); tmp = tmp->GetNextNcNnl(); } if (tmp->IsNotNullChunk()) { out_txt.append(tmp->GetStr()); return(true); } } else { // if outside a class, we expect "CLASS::METHOD(...)" Chunk *tmp = fcn->GetPrevNcNnl(); if (tmp->Is(CT_OPERATOR)) { tmp = tmp->GetPrevNcNnl(); } if ( tmp->IsNotNullChunk() && ( tmp->Is(CT_DC_MEMBER) || tmp->Is(CT_MEMBER))) { tmp = tmp->GetPrevNcNnl(); out_txt.append(tmp->GetStr()); return(true); } } return(false); } // kw_fcn_fclass static bool kw_fcn_year(Chunk *cmt, unc_text &out_txt) { UNUSED(cmt); time_t now = time(nullptr); out_txt.append(std::to_string(1900 + localtime(&now)->tm_year)); return(true); } struct kw_subst_t { const char *tag; bool (*func)(Chunk *cmt, unc_text &out_txt); }; static const kw_subst_t kw_subst_table[] = { { "$(filename)", kw_fcn_filename }, { "$(class)", kw_fcn_class }, { "$(message)", kw_fcn_message }, { "$(category)", kw_fcn_category }, { "$(scope)", kw_fcn_scope }, { "$(function)", kw_fcn_function }, { "$(javaparam)", kw_fcn_javaparam }, { "$(fclass)", kw_fcn_fclass }, { "$(year)", kw_fcn_year }, }; static void do_kw_subst(Chunk *pc) { for (const auto &kw : kw_subst_table) { int idx = pc->GetStr().find(kw.tag); if (idx < 0) { continue; } unc_text tmp_txt; tmp_txt.clear(); if (kw.func(pc, tmp_txt)) { // if the replacement contains '\n' we need to fix the lead if (tmp_txt.find("\n") >= 0) { size_t nl_idx = pc->GetStr().rfind("\n", idx); if (nl_idx > 0) { // idx and nl_idx are both positive unc_text nl_txt; nl_txt.append("\n"); nl_idx++; while ( (nl_idx < static_cast(idx)) && !unc_isalnum(pc->GetStr()[nl_idx])) { nl_txt.append(pc->Str()[nl_idx++]); } tmp_txt.replace("\n", nl_txt); } } pc->Str().replace(kw.tag, tmp_txt); } } } // do_kw_subst static void output_comment_multi_simple(Chunk *pc) { if ( pc == nullptr && pc->IsNotNullChunk()) { return; } cmt_reflow cmt; LOG_FMT(LCONTTEXT, "%s(%d): Text() is '%s', type is %s, orig col is %zu, column is %zu\n", __func__, __LINE__, pc->Text(), get_token_name(pc->GetType()), pc->GetOrigCol(), pc->GetColumn()); output_cmt_start(cmt, pc); // The multiline comment is saved inside one chunk. If the comment is // shifted all lines of the comment need to be shifted by the same amount. // Save the difference of initial and current position to apply it on every // line_column const int col_diff = [pc]() { int diff = 0; if (pc->GetPrev()->IsNewline()) { // The comment should be indented correctly diff = pc->GetColumn() - pc->GetOrigCol(); } return(diff); }(); /** * check for enable/disable processing comment strings that may * both be embedded within the same multi-line comment */ auto disable_processing_cmt_idx = find_disable_processing_comment_marker(pc->GetStr()); auto enable_processing_cmt_idx = find_enable_processing_comment_marker(pc->GetStr()); unc_text line; size_t line_count = 0; size_t line_column = pc->GetColumn(); size_t cmt_idx = 0; while (cmt_idx < pc->Len()) { int ch = pc->GetStr()[cmt_idx]; cmt_idx++; if ( cmt_idx > std::size_t(disable_processing_cmt_idx) && enable_processing_cmt_idx > disable_processing_cmt_idx) { auto length = enable_processing_cmt_idx - disable_processing_cmt_idx; unc_text verbatim_text(pc->GetStr(), disable_processing_cmt_idx, length); add_text(verbatim_text); cmt_idx = enable_processing_cmt_idx; /** * check for additional enable/disable processing comment strings that may * both be embedded within the same multi-line comment */ disable_processing_cmt_idx = find_disable_processing_comment_marker(pc->GetStr(), enable_processing_cmt_idx); enable_processing_cmt_idx = find_enable_processing_comment_marker(pc->GetStr(), enable_processing_cmt_idx); line.clear(); continue; } // 1: step through leading tabs and spaces to find the start column log_rule_B("cmt_convert_tab_to_spaces"); if ( line.size() == 0 && ( line_column < cmt.base_col || options::cmt_convert_tab_to_spaces())) { if (ch == ' ') { line_column++; continue; } else if (ch == '\t') { log_rule_B("input_tab_size"); line_column = calc_next_tab_column(line_column, options::input_tab_size()); continue; } else { LOG_FMT(LCONTTEXT, "%s(%d):ch is %d, %c\n", __func__, __LINE__, ch, char(ch)); } } // 2: add chars to line, handle the CRLF and CR endings (convert both to LF) if (ch == '\r') { ch = '\n'; if ( (cmt_idx < pc->Len()) && (pc->GetStr()[cmt_idx] == '\n')) { cmt_idx++; } } LOG_FMT(LCONTTEXT, "%s(%d):Line is %s\n", __func__, __LINE__, line.c_str()); line.append(ch); LOG_FMT(LCONTTEXT, "%s(%d):Line is %s\n", __func__, __LINE__, line.c_str()); // If we just hit an end of line OR we just hit end-of-comment... if ( ch == '\n' || cmt_idx == pc->Len()) { line_count++; LOG_FMT(LCONTTEXT, "%s(%d):line_count is %zu\n", __func__, __LINE__, line_count); // strip trailing tabs and spaces before the newline if (ch == '\n') { line.pop_back(); // Say we aren't in a preproc to prevent changing any bs-nl cmt_trim_whitespace(line, false); line.append('\n'); } if (line.size() > 0) { // unless line contains only a single newline char, indent if the // line consists of either: if ( line.size() > 1 // more than a single newline char or || ch != '\n') // (end-of-comment) a single non newline char { if (line_count > 1) { // apply comment column shift without underflowing line_column = (col_diff<0 && (size_t)(abs(col_diff))> line_column) ? 0 : line_column + col_diff; } cmt.column = line_column; cmt_output_indent(cmt.brace_col, cmt.base_col, cmt.column); } add_text(line); line.clear(); } line_column = 1; } } } // output_comment_multi_simple static void generate_if_conditional_as_text(unc_text &dst, Chunk *ifdef) { int column = -1; dst.clear(); for (Chunk *pc = ifdef; pc != nullptr && pc->IsNotNullChunk(); pc = pc->GetNext()) { if (column == -1) { column = pc->GetColumn(); } if ( pc->Is(CT_NEWLINE) || pc->Is(CT_COMMENT_MULTI) || pc->Is(CT_COMMENT_CPP)) { break; } else if (pc->Is(CT_NL_CONT)) { dst += ' '; column = -1; } else if ( pc->Is(CT_COMMENT) || pc->Is(CT_COMMENT_EMBED)) { } else // if (pc->Is(CT_JUNK)) || else { for (int spacing = pc->GetColumn() - column; spacing > 0; spacing--) { dst += ' '; column++; } dst.append(pc->GetStr()); column += pc->Len(); } } } // generate_if_conditional_as_text void add_long_preprocessor_conditional_block_comment() { Chunk *pp_start = nullptr; Chunk *pp_end = nullptr; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { // just track the preproc level: if (pc->Is(CT_PREPROC)) { pp_end = pp_start = pc; } if ( pc->IsNot(CT_PP_IF) || !pp_start) { continue; } #if 0 if (pc->TestFlags(PCF_IN_PREPROC)) { continue; } #endif Chunk *br_close; Chunk *br_open = pc; size_t nl_count = 0; Chunk *tmp = pc; while ((tmp = tmp->GetNext())->IsNotNullChunk()) { // just track the preproc level: if (tmp->Is(CT_PREPROC)) { pp_end = tmp; } if (tmp->IsNewline()) { nl_count += tmp->GetNlCount(); } else if ( pp_end->GetPpLevel() == pp_start->GetPpLevel() && ( tmp->Is(CT_PP_ENDIF) || ((br_open->Is(CT_PP_IF)) ? (tmp->Is(CT_PP_ELSE)) : 0))) { br_close = tmp; LOG_FMT(LPPIF, "found #if / %s section on lines %zu and %zu, new line count=%zu\n", (tmp->Is(CT_PP_ENDIF) ? "#endif" : "#else"), br_open->GetOrigLine(), br_close->GetOrigLine(), nl_count); // Found the matching #else or #endif - make sure a newline is next tmp = tmp->GetNext(); LOG_FMT(LPPIF, "next item type %d (is %s)\n", (tmp ? tmp->GetType() : -1), (tmp ? tmp->IsNewline() ? "newline" : tmp->IsComment() ? "comment" : "other" : "---")); if ( tmp->IsNullChunk() || tmp->Is(CT_NEWLINE)) // tmp->IsNewline()) { size_t nl_min; if (br_close->Is(CT_PP_ENDIF)) { log_rule_B("mod_add_long_ifdef_endif_comment"); nl_min = options::mod_add_long_ifdef_endif_comment(); } else { log_rule_B("mod_add_long_ifdef_else_comment"); nl_min = options::mod_add_long_ifdef_else_comment(); } const char *txt = !tmp ? "EOF" : ((tmp->Is(CT_PP_ENDIF)) ? "#endif" : "#else"); LOG_FMT(LPPIF, "#if / %s section candidate for augmenting when over NL threshold %zu != 0 (new line count=%zu)\n", txt, nl_min, nl_count); if ( nl_min > 0 && nl_count > nl_min) // nl_count is 1 too large at all times as #if line was counted too { // determine the added comment style E_Token style = (language_is_set(LANG_CPP)) ? CT_COMMENT_CPP : CT_COMMENT; unc_text str; generate_if_conditional_as_text(str, br_open); LOG_FMT(LPPIF, "#if / %s section over threshold %zu (new line count=%zu) --> insert comment after the %s: %s\n", txt, nl_min, nl_count, txt, str.c_str()); // Add a comment after the close brace insert_comment_after(br_close, style, str); } } // checks both the #else and #endif for a given level, only then look further in the main loop if (br_close->Is(CT_PP_ENDIF)) { break; } } } } } // add_long_preprocessor_conditional_block_comment uncrustify-uncrustify-0.76.0/src/output.h000066400000000000000000000024651434072136500205440ustar00rootroot00000000000000/** * @file output.h * prototypes for output.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef OUTPUT_H_INCLUDED #define OUTPUT_H_INCLUDED #include "unc_text.h" #include //! This renders the chunk list to a file. void output_parsed(FILE *pfile, bool withOptions = true); //! This renders the chunk list to a file formatted as csv. void output_parsed_csv(FILE *pfile); //! This renders the chunk list to a file. void output_text(FILE *pfile); //! This save the next formatting step to a file void dump_step(const char *filename, const char *description); /** * See also it's preprocessor counterpart * add_long_closebrace_comment * in braces.cpp * * Note: since this concerns itself with the preprocessor -- which is line-oriented -- * it turns out that just looking at pc->GetPpLevel() is NOT the right thing to do. * See a --parsed dump if you don't believe this: an '#endif' will be one level * UP from the corresponding #ifdef when you look at the tokens 'ifdef' versus 'endif', * but it's a whole another story when you look at their CT_PREPROC ('#') tokens! * * Hence we need to track and seek matching CT_PREPROC pp_levels here, which complicates * things a little bit, but not much. */ void add_long_preprocessor_conditional_block_comment(); #endif /* OUTPUT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/parameter_pack_cleanup.cpp000066400000000000000000000026141434072136500242200ustar00rootroot00000000000000/** * @file parameter_pack_cleanup.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "parameter_pack_cleanup.h" #include "chunk.h" #include "uncrustify.h" void parameter_pack_cleanup() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { LOG_CHUNK(LTOK, pc); // look for template if (pc->Is(CT_TEMPLATE)) // Issue #3309 { Chunk *template_end = pc->GetNextType(CT_SEMICOLON, pc->GetLevel()); // look for a parameter pack while (pc->IsNotNullChunk()) { LOG_CHUNK(LTOK, pc); if (pc->Is(CT_PARAMETER_PACK)) { Chunk *parameter_pack = pc; // look for a token with the same text while (pc->IsNotNullChunk()) { LOG_CHUNK(LTOK, pc); if (pc == template_end) { break; } if (strcmp(pc->Text(), parameter_pack->Text()) == 0) { pc->SetType(CT_PARAMETER_PACK); } pc = pc->GetNext(); } } pc = pc->GetNext(); if (pc == template_end) { break; } } } pc = pc->GetNext(); } } // parameter_pack_cleanup uncrustify-uncrustify-0.76.0/src/parameter_pack_cleanup.h000066400000000000000000000004341434072136500236630ustar00rootroot00000000000000/** * @file parameter_pack_cleanup.h * * @author Guy Maurel * @license GPL v2+ */ #ifndef PARAMETER_PACK_CLEANUP_H_INCLUDED #define PARAMETER_PACK_CLEANUP_H_INCLUDED #include "uncrustify_types.h" void parameter_pack_cleanup(); #endif /* PARAMETER_PACK_CLEANUP_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/parens.cpp000066400000000000000000000236071434072136500210300ustar00rootroot00000000000000/** * @file parens.cpp * Adds or removes parens. * * @author Ben Gardner * @license GPL v2+ */ #include "parens.h" #include "log_rules.h" using namespace uncrustify; //! Add an open parenthesis after first and add a close parenthesis before the last static void add_parens_between(Chunk *first, Chunk *last); /** * Scans between two parens and adds additional parens if needed. * This function is recursive. If it hits another open paren, it'll call itself * with the new bounds. * * Adds optional parens in an IF or SWITCH conditional statement. * * This basically just checks for a CT_COMPARE that isn't surrounded by parens. * The edges for the compare are the open, close and any CT_BOOL tokens. * * This only handles VERY simple patterns: * (!a && b) => (!a && b) -- no change * (a && b == 1) => (a && (b == 1)) * (a == 1 || b > 2) => ((a == 1) || (b > 2)) * * FIXME: we really should bail if we transition between a preprocessor and * a non-preprocessor */ static void check_bool_parens(Chunk *popen, Chunk *pclose, int nest); void do_parens() { constexpr static auto LCURRENT = LPARADD; LOG_FUNC_ENTRY(); log_rule_B("mod_full_paren_if_bool"); if (options::mod_full_paren_if_bool()) { Chunk *pc = Chunk::GetHead(); while ( (pc = pc->GetNextNcNnl()) != nullptr && pc->IsNotNullChunk()) { if ( pc->IsNot(CT_SPAREN_OPEN) || ( pc->GetParentType() != CT_IF && pc->GetParentType() != CT_ELSEIF && pc->GetParentType() != CT_SWITCH)) { continue; } // Grab the close sparen Chunk *pclose = pc->GetNextType(CT_SPAREN_CLOSE, pc->GetLevel(), E_Scope::PREPROC); if (pclose->IsNotNullChunk()) { check_bool_parens(pc, pclose, 0); pc = pclose; } } } } // do_parens void do_parens_assign() // Issue #3316 { constexpr static auto LCURRENT = LPARADD; LOG_FUNC_ENTRY(); log_rule_B("mod_full_paren_assign_bool"); if (options::mod_full_paren_assign_bool()) { Chunk *pc = Chunk::GetHead(); while ( (pc = pc->GetNextNcNnl()) != nullptr && pc->IsNotNullChunk()) { if (pc->Is(CT_ASSIGN)) { LOG_FMT(LPARADD, "%s(%d): orig line is %zu, text is '%s', level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->Text(), pc->GetLevel()); // look before for a open sparen size_t check_level = pc->GetLevel(); Chunk *p = pc->GetPrevNc(E_Scope::PREPROC); while (p->IsNotNullChunk()) { LOG_FMT(LPARADD, "%s(%d): orig line is %zu, text is '%s', level is %zu, type is %s\n", __func__, __LINE__, p->GetOrigLine(), p->Text(), p->GetLevel(), get_token_name(p->GetType())); //log_pcf_flags(LPARADD, p->GetFlags()); if (p->TestFlags(PCF_STMT_START)) { break; } if (p->Is(CT_PAREN_OPEN)) { check_level--; } if (p->Is(CT_SPAREN_OPEN)) { break; } p = p->GetPrevNc(E_Scope::PREPROC); if (p->GetLevel() < check_level - 1) { break; } } LOG_FMT(LPARADD, "%s(%d): orig line is %zu, text is '%s', level is %zu, type is %s\n", __func__, __LINE__, p->GetOrigLine(), p->Text(), p->GetLevel(), get_token_name(p->GetType())); if (p->GetParentType() == CT_WHILE) { continue; } // Grab the semicolon Chunk *semicolon = pc->GetNextType(CT_SEMICOLON, pc->GetLevel(), E_Scope::PREPROC); if (semicolon->IsNotNullChunk()) { check_bool_parens(pc, semicolon, 0); pc = semicolon; } } } } } // do_parens_assign void do_parens_return() // Issue #3316 { constexpr static auto LCURRENT = LPARADD; LOG_FUNC_ENTRY(); log_rule_B("mod_full_paren_return_bool"); if (options::mod_full_paren_return_bool()) { Chunk *pc = Chunk::GetHead(); while ( (pc = pc->GetNextNcNnl()) != nullptr && pc->IsNotNullChunk()) { if (pc->Is(CT_RETURN)) { LOG_FMT(LPARADD, "%s(%d): orig line is %zu, text is '%s', level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->Text(), pc->GetLevel()); // look before for a open sparen size_t check_level = pc->GetLevel(); Chunk *p = pc->GetPrevNc(E_Scope::PREPROC); while (p->IsNotNullChunk()) { LOG_FMT(LPARADD, "%s(%d): orig line is %zu, text is '%s', level is %zu, type is %s\n", __func__, __LINE__, p->GetOrigLine(), p->Text(), p->GetLevel(), get_token_name(p->GetType())); //log_pcf_flags(LPARADD, p->GetFlags()); if (p->TestFlags(PCF_STMT_START)) { break; } if (p->Is(CT_PAREN_OPEN)) { check_level--; } if (p->Is(CT_SPAREN_OPEN)) { break; } p = p->GetPrevNc(E_Scope::PREPROC); if (p->GetLevel() < check_level - 1) { break; } } LOG_FMT(LPARADD, "%s(%d): orig line is %zu, text is '%s', level is %zu, type is %s\n", __func__, __LINE__, p->GetOrigLine(), p->Text(), p->GetLevel(), get_token_name(p->GetType())); if (p->GetParentType() == CT_WHILE) { continue; } // Grab the semicolon Chunk *semicolon = pc->GetNextType(CT_SEMICOLON, pc->GetLevel(), E_Scope::PREPROC); if (semicolon->IsNotNullChunk()) { check_bool_parens(pc, semicolon, 0); pc = semicolon; } } } } } // do_parens_return static void add_parens_between(Chunk *first, Chunk *last) { LOG_FUNC_ENTRY(); LOG_FMT(LPARADD, "%s(%d): line %zu, between '%s' [lvl is %zu] and '%s' [lvl is %zu]\n", __func__, __LINE__, first->GetOrigLine(), first->Text(), first->GetLevel(), last->Text(), last->GetLevel()); // Don't do anything if we have a bad sequence, ie "&& )" Chunk *first_n = first->GetNextNcNnl(); if (first_n == last) { return; } Chunk pc; pc.SetType(CT_PAREN_OPEN); pc.SetOrigLine(first_n->GetOrigLine()); pc.SetOrigCol(first_n->GetOrigCol()); pc.Str() = "("; pc.SetFlags(first_n->GetFlags() & PCF_COPY_FLAGS); pc.SetLevel(first_n->GetLevel()); pc.SetPpLevel(first_n->GetPpLevel()); pc.SetBraceLevel(first_n->GetBraceLevel()); pc.CopyAndAddBefore(first_n); Chunk *last_p = last->GetPrevNcNnl(E_Scope::PREPROC); pc.SetType(CT_PAREN_CLOSE); pc.SetOrigLine(last_p->GetOrigLine()); pc.SetOrigCol(last_p->GetOrigCol()); pc.Str() = ")"; pc.SetFlags(last_p->GetFlags() & PCF_COPY_FLAGS); pc.SetLevel(last_p->GetLevel()); pc.SetPpLevel(last_p->GetPpLevel()); pc.SetBraceLevel(last_p->GetBraceLevel()); pc.CopyAndAddAfter(last_p); for (Chunk *tmp = first_n; tmp != last_p; tmp = tmp->GetNextNcNnl()) { tmp->SetLevel(tmp->GetLevel() + 1); } last_p->SetLevel(last_p->GetLevel() + 1); } // add_parens_between static void check_bool_parens(Chunk *popen, Chunk *pclose, int nest) { LOG_FUNC_ENTRY(); Chunk *ref = popen; bool hit_compare = false; LOG_FMT(LPARADD, "%s(%d): nest is %d, popen on line %zu, orig col is %zu, pclose on line %zu, orig col is %zu, level is %zu\n", __func__, __LINE__, nest, popen->GetOrigLine(), popen->GetOrigCol(), pclose->GetOrigLine(), pclose->GetOrigCol(), popen->GetLevel()); Chunk *pc = popen; while ( (pc = pc->GetNextNcNnl()) != nullptr && pc->IsNotNullChunk() && pc != pclose) { if (pc->TestFlags(PCF_IN_PREPROC)) { LOG_FMT(LPARADD2, " -- bail on PP %s [%s] at line %zu col %zu, level %zu\n", get_token_name(pc->GetType()), pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); return; } if ( pc->Is(CT_BOOL) || pc->Is(CT_QUESTION) || pc->Is(CT_COND_COLON) || pc->Is(CT_COMMA)) { LOG_FMT(LPARADD2, " -- %s [%s] at line %zu col %zu, level %zu\n", get_token_name(pc->GetType()), pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); if (hit_compare) { hit_compare = false; if (!language_is_set(LANG_CS)) { add_parens_between(ref, pc); } } ref = pc; } else if (pc->Is(CT_COMPARE)) { LOG_FMT(LPARADD2, " -- compare '%s' at line %zu, orig col is %zu, level is %zu\n", pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetLevel()); hit_compare = true; } else if (pc->IsParenOpen()) { Chunk *next = pc->GetClosingParen(); if (next->IsNotNullChunk()) { check_bool_parens(pc, next, nest + 1); pc = next; } } else if ( pc->Is(CT_BRACE_OPEN) || pc->Is(CT_SQUARE_OPEN) || pc->Is(CT_ANGLE_OPEN)) { // Skip [], {}, and <> pc = pc->GetClosingParen(); } } if ( hit_compare && ref != popen && !language_is_set(LANG_CS)) { add_parens_between(ref, pclose); } } // check_bool_parens uncrustify-uncrustify-0.76.0/src/parens.h000066400000000000000000000004661434072136500204730ustar00rootroot00000000000000/** * @file parens.h * prototypes for parens.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef PARENS_H_INCLUDED #define PARENS_H_INCLUDED #include "uncrustify_types.h" //! add parenthesis void do_parens(); void do_parens_assign(); void do_parens_return(); #endif /* PARENS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/parent_for_pp.cpp000066400000000000000000000027411434072136500223720ustar00rootroot00000000000000/** * @file parent_for_pp.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "parent_for_pp.h" #include "chunk.h" void do_parent_for_pp() { LOG_FUNC_ENTRY(); vector viz; Chunk *pc = Chunk::GetHead()->GetNextNcNnl(); while (pc->IsNotNullChunk()) { // CT_PP_IF, // #if, #ifdef, or #ifndef // CT_PP_ELSE, // #else or #elif // CT_PP_ENDIF, // #endif if (pc->Is(CT_PP_IF)) { LOG_FMT(LMCB, "%s(%d): IF: orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_pcf_flags(LMCB, pc->GetFlags()); viz.push_back(pc); } else if (pc->Is(CT_PP_ELSE)) { LOG_FMT(LMCB, "%s(%d): ELSE: orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_pcf_flags(LMCB, pc->GetFlags()); size_t level = pc->GetPpLevel(); Chunk *a = viz.at(level - 1); pc->SetParent(a); } else if (pc->Is(CT_PP_ENDIF)) { LOG_FMT(LMCB, "%s(%d): ENDIF: orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_pcf_flags(LMCB, pc->GetFlags()); size_t level = pc->GetPpLevel(); Chunk *a = viz.at(level); pc->SetParent(a); viz.pop_back(); } pc = pc->GetNextNcNnl(); } } // do_parent_for_pp uncrustify-uncrustify-0.76.0/src/parent_for_pp.h000066400000000000000000000004131434072136500220310ustar00rootroot00000000000000/** * @file parent_for_pp.h * prototype for parent_for_pp.cpp * * @author Guy Maurel * @license GPL v2+ */ #ifndef PARENT_FOR_PP_H_INCLUDED #define PARENT_FOR_PP_H_INCLUDED // mark the parent void do_parent_for_pp(); #endif /* PARENT_FOR_PP_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/pcf_flags.cpp000066400000000000000000000050111434072136500214510ustar00rootroot00000000000000/** * @file pcf_flags.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "pcf_flags.h" static const char *pcf_names[] = { "IN_PREPROC", // 0 "IN_STRUCT", // 1 "IN_ENUM", // 2 "IN_FCN_DEF", // 3 "IN_FCN_CALL", // 4 "IN_SPAREN", // 5 "IN_TEMPLATE", // 6 "IN_TYPEDEF", // 7 "IN_CONST_ARGS", // 8 "IN_ARRAY_ASSIGN", // 9 "IN_CLASS", // 10 "IN_CLASS_BASE", // 11 "IN_NAMESPACE", // 12 "IN_FOR", // 13 "IN_OC_MSG", // 14 "IN_WHERE_SPEC", // 15 "IN_DECLTYPE", // 16 "FORCE_SPACE", // 17 "STMT_START", // 18 "EXPR_START", // 19 "DONT_INDENT", // 20 "ALIGN_START", // 21 "WAS_ALIGNED", // 22 "VAR_TYPE", // 23 "VAR_DEF", // 24 "VAR_1ST", // 25 "VAR_INLINE", // 26 "RIGHT_COMMENT", // 27 "OLD_FCN_PARAMS", // 28 "LVALUE", // 29 "ONE_LINER", // 30 "EMPTY_BODY", // 31 "ANCHOR", // 32 "PUNCTUATOR", // 33 "INSERTED", // 34 "LONG_BLOCK", // 35 "OC_BOXED", // 36 "KEEP_BRACE", // 37 "OC_RTYPE", // 38 "OC_ATYPE", // 39 "WF_ENDIF", // 40 "IN_QT_MACRO", // 41 "IN_FCN_CTOR", // 42 Issue #2152 "IN_TRY_BLOCK", // 43 Issue #1734 "INCOMPLETE", // 44 "IN_LAMBDA", // 45 "WF_IF", // 46 "NOT_POSSIBLE", // 47 "IN_CONDITIONAL", // 48 Issue #3558 "PCF_OC_IN_BLOCK", // 49 }; std::string pcf_flags_str(T_PcfFlags flags) { char buffer[64]; // Generate hex representation first #ifdef WIN32 snprintf(buffer, 63, "["); #else // not WIN32 snprintf(buffer, 63, "[0x%llx:", (long long unsigned int)(flags)); #endif // ifdef WIN32 // Add human-readable names auto out = std::string{ buffer }; auto first = true; for (size_t i = 0; i < ARRAY_SIZE(pcf_names); ++i) { if (flags & static_cast(pcf_bit(i))) { if (first) { first = false; } else { out += ','; } out += pcf_names[i]; } } out += ']'; return(out); } void log_pcf_flags(log_sev_t sev, T_PcfFlags flags) { if (!log_sev_on(sev)) { return; } log_fmt(sev, "%s\n", pcf_flags_str(flags).c_str()); } uncrustify-uncrustify-0.76.0/src/pcf_flags.h000066400000000000000000000076111434072136500211260ustar00rootroot00000000000000/** * @file pcf_flags.h * * @author Guy Maurel * @license GPL v2+ */ #ifndef PCF_FLAGS_STR_INCLUDED #define PCF_FLAGS_STR_INCLUDED #include "enum_flags.h" #include "logger.h" // and the ever-so-important array size macro #ifndef ARRAY_SIZE #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) #endif using namespace std; constexpr auto pcf_bit(size_t b) -> decltype(0ULL) { return(1ULL << b); } enum E_PcfFlag : decltype ( 0ULL ) { // Copy flags are in the lower 17 bits PCF_NONE = 0ULL, PCF_COPY_FLAGS = 0x0001ffffULL, PCF_IN_PREPROC = pcf_bit(0), //! in a preprocessor PCF_IN_STRUCT = pcf_bit(1), //! in a struct PCF_IN_ENUM = pcf_bit(2), //! in enum PCF_IN_FCN_DEF = pcf_bit(3), //! inside function def parens PCF_IN_FCN_CALL = pcf_bit(4), //! inside function call parens PCF_IN_SPAREN = pcf_bit(5), //! inside for/if/while/switch parens PCF_IN_TEMPLATE = pcf_bit(6), PCF_IN_TYPEDEF = pcf_bit(7), PCF_IN_CONST_ARGS = pcf_bit(8), PCF_IN_ARRAY_ASSIGN = pcf_bit(9), PCF_IN_CLASS = pcf_bit(10), PCF_IN_CLASS_BASE = pcf_bit(11), PCF_IN_NAMESPACE = pcf_bit(12), PCF_IN_FOR = pcf_bit(13), PCF_IN_OC_MSG = pcf_bit(14), PCF_IN_WHERE_SPEC = pcf_bit(15), /* inside C# 'where' constraint clause on class or function def */ PCF_IN_DECLTYPE = pcf_bit(16), // Non-Copy flags are in the upper 47 bits PCF_FORCE_SPACE = pcf_bit(17), //! must have a space after this token PCF_STMT_START = pcf_bit(18), //! marks the start of a statement PCF_EXPR_START = pcf_bit(19), PCF_DONT_INDENT = pcf_bit(20), //! already aligned! PCF_ALIGN_START = pcf_bit(21), PCF_WAS_ALIGNED = pcf_bit(22), PCF_VAR_TYPE = pcf_bit(23), //! part of a variable def type PCF_VAR_DEF = pcf_bit(24), //! variable name in a variable def PCF_VAR_1ST = pcf_bit(25), //! 1st variable def in a statement PCF_VAR_1ST_DEF = (PCF_VAR_DEF | PCF_VAR_1ST), PCF_VAR_INLINE = pcf_bit(26), //! type was an inline struct/enum/union PCF_RIGHT_COMMENT = pcf_bit(27), PCF_OLD_FCN_PARAMS = pcf_bit(28), PCF_LVALUE = pcf_bit(29), //! left of assignment PCF_ONE_LINER = pcf_bit(30), PCF_ONE_CLASS = (PCF_ONE_LINER | PCF_IN_CLASS), PCF_EMPTY_BODY = pcf_bit(31), PCF_ANCHOR = pcf_bit(32), //! aligning anchor PCF_PUNCTUATOR = pcf_bit(33), PCF_INSERTED = pcf_bit(34), //! chunk was inserted from another file PCF_LONG_BLOCK = pcf_bit(35), //! the block is 'long' by some measure PCF_OC_BOXED = pcf_bit(36), //! inside OC boxed expression PCF_KEEP_BRACE = pcf_bit(37), //! do not remove brace PCF_OC_RTYPE = pcf_bit(38), //! inside OC return type PCF_OC_ATYPE = pcf_bit(39), //! inside OC arg type PCF_WF_ENDIF = pcf_bit(40), //! #endif for whole file ifdef PCF_IN_QT_MACRO = pcf_bit(41), //! in a QT-macro, i.e. SIGNAL, SLOT PCF_IN_FCN_CTOR = pcf_bit(42), //! inside function constructor PCF_IN_TRY_BLOCK = pcf_bit(43), //! inside Function-try-block PCF_INCOMPLETE = pcf_bit(44), //! class/struct forward declaration PCF_IN_LAMBDA = pcf_bit(45), //! inside a lambda expression PCF_WF_IF = pcf_bit(46), //! #if for a whole file ifdef PCF_NOT_POSSIBLE = pcf_bit(47), //! it is not possible to make an one_liner //! because the line would be too long PCF_IN_CONDITIONAL = pcf_bit(48), //! inside a conditional ternary expression PCF_OC_IN_BLOCK = pcf_bit(49), //! inside OC block function }; UNC_DECLARE_FLAGS(T_PcfFlags, E_PcfFlag); UNC_DECLARE_OPERATORS_FOR_FLAGS(T_PcfFlags); std::string pcf_flags_str(T_PcfFlags flags); void log_pcf_flags(log_sev_t sev, T_PcfFlags flags); #endif /* PCF_FLAGS_STR_INCLUDED */ uncrustify-uncrustify-0.76.0/src/pragma_cleanup.cpp000066400000000000000000000052211434072136500225060ustar00rootroot00000000000000/** * @file pragma_cleanup.cpp * * @author Guy Maurel * @license GPL v2+ */ #include "pragma_cleanup.h" #include "chunk.h" #include "unc_tools.h" void pragma_cleanup() { LOG_FUNC_ENTRY(); bool preproc_found = false; bool pragma_found = false; bool parameter_found = false; Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { LOG_CHUNK(LTOK, pc); if (!preproc_found) { if (pc->Is(CT_PREPROC)) { LOG_FMT(LMCB, "%s(%d): PREPROC found: orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_pcf_flags(LMCB, pc->GetFlags()); preproc_found = true; } } else { if (!pragma_found) { if (pc->Is(CT_PP_PRAGMA)) { LOG_FMT(LMCB, "%s(%d): PP_PRAGMA found: orig line %zu, orig col is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_pcf_flags(LMCB, pc->GetFlags()); pragma_found = true; } } else { if (!parameter_found) { LOG_FMT(LMCB, "%s(%d): PARAMETER found: orig line %zu, orig col is %zu, Text is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); log_pcf_flags(LMCB, pc->GetFlags()); if (strcmp(pc->Text(), "endasm") == 0) { pc->SetType(CT_PP_ENDASM); } else if (strcmp(pc->Text(), "region") == 0) { pc->SetType(CT_PP_REGION); } //else if (strcmp(pc->Text(), "comment") == 0) //{ // pc->SetType(CT_PP_COMMENT); //} else { pc->SetType(CT_PP_PRAGMA); } parameter_found = true; } else { LOG_FMT(LMCB, "%s(%d): orig line is %zu, orig col is %zu, Text is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text()); if (pc->IsNewline()) { // reset preproc_found = false; pragma_found = false; parameter_found = false; } else { pc->SetType(CT_PP_IGNORE); } } } } pc = pc->GetNext(); } //prot_the_line(__func__, __LINE__, 3, 0); } // pragma_cleanup uncrustify-uncrustify-0.76.0/src/pragma_cleanup.h000066400000000000000000000003641434072136500221560ustar00rootroot00000000000000/** * @file pragma_cleanup.h * * @author Guy Maurel * @license GPL v2+ */ #ifndef PRAGMA_CLEANUP_H_INCLUDED #define PRAGMA_CLEANUP_H_INCLUDED // cleanup the pagma line(s) void pragma_cleanup(); #endif /* PRAGMA_CLEANUP_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/prototypes.h000066400000000000000000000022641434072136500214310ustar00rootroot00000000000000/** * @file prototypes.h * Big jumble of prototypes used in Uncrustify. * * @author Ben Gardner * @license GPL v2+ */ #ifndef C_PARSE_PROTOTYPES_H_INCLUDED #define C_PARSE_PROTOTYPES_H_INCLUDED #include "chunk.h" #include "log_rules.h" #include "uncrustify_types.h" #include #include /** * Advances to the next tab stop. * Column 1 is the left-most column. * * @param col The current column * @param tabsize The tabsize * @return the next tabstop column */ static inline size_t calc_next_tab_column(size_t col, size_t tabsize) { if (col == 0) { col = 1; } if (cpd.frag_cols > 0) { col += cpd.frag_cols - 1; } col = 1 + ((((col - 1) / tabsize) + 1) * tabsize); if (cpd.frag_cols > 0) { col -= cpd.frag_cols - 1; } return(col); } /** * Advances to the next tab stop for output. * * @param col The current column * @return the next tabstop column */ static inline size_t next_tab_column(size_t col) { constexpr static auto LCURRENT = LINDENT; log_rule_B("output_tab_size"); return(calc_next_tab_column(col, uncrustify::options::output_tab_size())); } #endif /* C_PARSE_PROTOTYPES_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/punctuators.cpp000066400000000000000000000045761434072136500221330ustar00rootroot00000000000000/** * @file punctuators.cpp * Manages the table of punctuators. * * @author Ben Gardner * @license GPL v2+ */ #include "punctuators.h" //#include "log_rules.h" #include "prototypes.h" #include constexpr static auto LCURRENT = LOTHER; using namespace std; using namespace uncrustify; /** * * The file "punctuator_table.h" was generated by punc.py from this file. * If you change one of the below symbol tables, re-run punc.py. * $ python scripts/punc.py > src/punctuator_table.h * now automatically with CMakeLists.txt * * NOTE: the tables below do not need to be sorted. */ #include "symbols_table.h" // must be positioned here, after all symbolsX[], because punc_table uses them #include "punctuator_table.h" const chunk_tag_t *find_punctuator(const char *str, int lang_flags) { if ( str == nullptr || str[0] == '\0') { return(nullptr); } const auto binary_find = [](const lookup_entry_t *first, const lookup_entry_t *last, const char &value) { const auto tmp = std::lower_bound(first, last, value, lookup_entry_t::comperator()); return((value == tmp->ch) ? tmp : nullptr); }; const chunk_tag_t *match = nullptr; const auto *parent = punc_table; //!< graph in table form, initially point at first entry auto ch_idx = int{}; while ( ch_idx < 6 && str[ch_idx] != '\0') //!< symbols6: max punc len = 6 { // search for next parent node in all current child nodes parent = binary_find(parent, next(parent, parent->left_in_group), str[ch_idx]); if (parent == nullptr) { break; // no nodes found with the searched char } log_rule_B("enable_digraphs"); if ( parent->tag != nullptr && (parent->tag->lang_flags & lang_flags) != 0 // punctuator lang and processing lang match && ( (parent->tag->lang_flags & FLAG_DIG) == 0 // punctuator is not a di/tri-graph || options::enable_digraphs())) // or di/tri-graph processing is enabled { match = parent->tag; } if (parent->next_idx == 0) { break; // no child nodes, leaf reached } parent = &punc_table[parent->next_idx]; // point at the first child node ch_idx++; continue; } return(match); } // find_punctuator uncrustify-uncrustify-0.76.0/src/punctuators.h000066400000000000000000000020751434072136500215700ustar00rootroot00000000000000/** * @file punctuators.h */ #ifndef PUNCTUATORS_H_INCLUDED #define PUNCTUATORS_H_INCLUDED #include "uncrustify_types.h" struct lookup_entry_t { char ch; char left_in_group; UINT16 next_idx; const chunk_tag_t *tag; struct comperator { static char get_char(const lookup_entry_t &v) { return(v.ch); } static char get_char(char t) { return(t); } template bool operator()(T1 const &t1, T2 const &t2) { return(get_char(t1) < get_char(t2)); } }; }; /** * Checks if the first max. 6 chars of a given string match a punctuator * * @param str string that will be checked, can be shorter than 6 chars * @param lang_flags specifies from which language punctuators will be considered * * @retval chunk tag of the found punctuator * @retval nullptr if nothing found */ const chunk_tag_t *find_punctuator(const char *str, int lang_flags); #endif /* PUNCTUATORS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/quick_align_again.cpp000066400000000000000000000033521434072136500231600ustar00rootroot00000000000000/** * @file quick_align_again.cpp * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #include "quick_align_again.h" #include "align_stack.h" #include "chunk.h" void quick_align_again() { LOG_FUNC_ENTRY(); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { char copy[1000]; LOG_FMT(LALAGAIN, "%s(%d): orig line is %zu, orig col is %zu, column is %zu, Text() '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetColumn(), pc->ElidedText(copy)); if ( pc->GetAlignmentData().next != nullptr && pc->TestFlags(PCF_ALIGN_START)) { AlignStack as; as.Start(100, 0); as.m_right_align = pc->GetAlignmentData().right_align; as.m_star_style = static_cast(pc->GetAlignmentData().star_style); as.m_amp_style = static_cast(pc->GetAlignmentData().amp_style); as.m_gap = pc->GetAlignmentData().gap; LOG_FMT(LALAGAIN, "%s(%d): pc->Text() is '%s', orig line is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); as.Add(pc->GetAlignmentData().start); pc->SetFlagBits(PCF_WAS_ALIGNED); for (Chunk *tmp = pc->GetAlignmentData().next; tmp != nullptr; tmp = tmp->GetAlignmentData().next) { tmp->SetFlagBits(PCF_WAS_ALIGNED); as.Add(tmp->GetAlignmentData().start); LOG_FMT(LALAGAIN, "%s(%d): => tmp->Text() is '%s', orig line is %zu\n", __func__, __LINE__, tmp->Text(), tmp->GetOrigLine()); } LOG_FMT(LALAGAIN, "\n"); as.End(); } } } // quick_align_again uncrustify-uncrustify-0.76.0/src/quick_align_again.h000066400000000000000000000004631434072136500226250ustar00rootroot00000000000000/** * @file quick_align_again.h * * @author Guy Maurel * split from align.cpp * @author Ben Gardner * @license GPL v2+ */ #ifndef QUICK_ALIGN_AGAIN_H_INCLUDED #define QUICK_ALIGN_AGAIN_H_INCLUDED #include "uncrustify_types.h" void quick_align_again(); #endif /* QUICK_ALIGN_AGAIN_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/remove_duplicate_include.cpp000066400000000000000000000057051434072136500245710ustar00rootroot00000000000000/** * @file remove_duplicate_include.cpp * * @author Guy Maurel * October 2015, 2016 * @license GPL v2+ */ #include "remove_duplicate_include.h" #include "chunk.h" #include "uncrustify.h" using std::vector; void remove_duplicate_include() { LOG_FUNC_ENTRY(); vector includes; Chunk *preproc = Chunk::NullChunkPtr; Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { //LOG_FMT(LRMRETURN, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s, parent type is %s\n", // __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), // get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); if (pc->Is(CT_PREPROC)) { preproc = pc; } else if (pc->Is(CT_PP_INCLUDE)) { Chunk *next = pc->GetNext(); //LOG_FMT(LRMRETURN, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s, parent type is %s\n", // __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text(), // get_token_name(next->GetType()), get_token_name(next->GetParentType())); if (includes.empty()) { includes.push_back(next); // goto next newline pc = next->GetNextNl(); } else { //LOG_FMT(LRMRETURN, "%s(%d): size is %zu\n", // __func__, __LINE__, includes.size()); // look for duplicate auto ite = includes.end(); for (auto itc = includes.begin(); itc != ite; ++itc) { Chunk *current = *itc; //LOG_FMT(LRMRETURN, "%s(%d): next->Text() is '%s'\n", // __func__, __LINE__, next->Text()); //LOG_FMT(LRMRETURN, "%s(%d): current->Text() is '%s'\n", // __func__, __LINE__, current->Text()); if (std::strcmp(next->Text(), current->Text()) == 0) { // erase the statement Chunk *temp = pc; Chunk *comment = next->GetNext(); Chunk *eol = next->GetNextNl(); pc = preproc->GetPrev(); Chunk::Delete(preproc); Chunk::Delete(temp); Chunk::Delete(next); if (comment != eol) { Chunk::Delete(comment); } Chunk::Delete(eol); break; } else { // goto next newline pc = next->GetNextNl(); // and still look for duplicate } } // for (auto itc = includes.begin(); } // if (includes.empty()) } // else if (pc->Is(CT_PP_INCLUDE)) // get the next token pc = pc->GetNext(); } } // remove_duplicate_include uncrustify-uncrustify-0.76.0/src/remove_duplicate_include.h000066400000000000000000000005661434072136500242360ustar00rootroot00000000000000/** * @file remove_duplicate_include.h * prototypes for remove_duplicate_include.cpp * * @author Guy Maurel * @license GPL v2+ */ #ifndef REMOVE_DUPLICATE_INCLUDE_H_INCLUDED #define REMOVE_DUPLICATE_INCLUDE_H_INCLUDED #include "chunk.h" /** * @brief Remove duplicate include */ void remove_duplicate_include(); #endif /* REMOVE_DUPLICATE_INCLUDE_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/remove_extra_returns.cpp000066400000000000000000000050041434072136500240110ustar00rootroot00000000000000/** * @file remove_extra_returns.cpp * * @author Guy Maurel * October 2015, 2016 * @license GPL v2+ * extract from combine.cpp */ #include "remove_extra_returns.h" #include "chunk.h" #include "uncrustify.h" void remove_extra_returns() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { LOG_FMT(LRMRETURN, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s', type is %s, parent type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType()), get_token_name(pc->GetParentType())); if ( pc->Is(CT_RETURN) && !pc->TestFlags(PCF_IN_PREPROC)) { // we might be in a class, check it Issue #2705 // look for a closing brace bool remove_it = false; Chunk *closing_brace = pc->GetNextType(CT_BRACE_CLOSE, 1); LOG_FMT(LRMRETURN, "%s(%d): on orig line %zu, level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetLevel()); if (closing_brace->IsNotNullChunk()) { if (closing_brace->GetParentType() == CT_FUNC_CLASS_DEF) { // we have a class. Do nothing } else if ( closing_brace->GetParentType() == CT_FUNC_DEF && pc->GetLevel() < 2) { remove_it = true; } } else { // it is not a class // look for a closing brace closing_brace = pc->GetNextType(CT_BRACE_CLOSE, 0); LOG_FMT(LRMRETURN, "%s(%d): on orig line %zu, level is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetLevel()); if (closing_brace->IsNotNullChunk()) { if (closing_brace->GetParentType() == CT_FUNC_DEF) { remove_it = true; } } } if (remove_it) { Chunk *semicolon = pc->GetNextNcNnl(); if ( semicolon->IsNotNullChunk() && semicolon->Is(CT_SEMICOLON)) { LOG_FMT(LRMRETURN, "%s(%d): Removed 'return;' on orig line %zu\n", __func__, __LINE__, pc->GetOrigLine()); Chunk::Delete(pc); Chunk::Delete(semicolon); pc = closing_brace; } } } pc = pc->GetNext(); } } // remove_extra_returns uncrustify-uncrustify-0.76.0/src/remove_extra_returns.h000066400000000000000000000006641434072136500234650ustar00rootroot00000000000000/** * @file remove_extra_returns.h * prototypes for remove_extra_returns.cpp * * @author Guy Maurel * @license GPL v2+ * extract from combine.h */ #ifndef REMOVE_EXTRA_RETURNS_H_INCLUDED #define REMOVE_EXTRA_RETURNS_H_INCLUDED /** * @brief Remove unnecessary returns * that is remove 'return;' that appears as the last statement in a function */ void remove_extra_returns(); #endif /* REMOVE_EXTRA_RETURNS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/rewrite_infinite_loops.cpp000066400000000000000000000213461434072136500243200ustar00rootroot00000000000000/** * @file rewrite_infinite_loops.cpp * * @author Alex Henrie * @license GPL v2+ */ #include "rewrite_infinite_loops.h" #include "chunk.h" #include "newlines.h" #include "uncrustify.h" using namespace uncrustify; static bool for_needs_rewrite(Chunk *pc, E_Token desired_type) { // The 'for' statement needs to be rewritten if `for(;;)` is not the // preferred syntax for infinite loops and this 'for' is an infinite loop // with no extra tokens (such as inline comments). if (desired_type == CT_FOR) { return(false); } pc = pc->GetNext(); if (!pc->Is(CT_SPAREN_OPEN)) { return(false); } pc = pc->GetNext(); if (!pc->Is(CT_SEMICOLON)) { return(false); } pc = pc->GetNext(); if (!pc->Is(CT_SEMICOLON)) { return(false); } pc = pc->GetNext(); if (!pc->Is(CT_SPAREN_CLOSE)) { return(false); } return(true); } static bool while_needs_rewrite(Chunk *keyword, E_Token desired_type, const char *desired_condition) { // The 'while' statement needs to be rewritten if it has only the tokens that // are strictly necessary (keyword, condition, two parentheses, and semicolon // if do-while) and either the keyword or the condition needs to be changed. Chunk *oparen = keyword->GetNext(); Chunk *condition = oparen->GetNext(); Chunk *cparen = condition->GetNext(); if (!oparen->Is(CT_SPAREN_OPEN)) { return(false); } if ( strcmp(condition->Text(), "true") != 0 && strcmp(condition->Text(), "1") != 0) { return(false); } if (!cparen->Is(CT_SPAREN_CLOSE)) { return(false); } if (keyword->Is(CT_WHILE_OF_DO)) { Chunk *semicolon = cparen->GetNext(); if (!semicolon->Is(CT_SEMICOLON)) { return(false); } } if (!keyword->Is(desired_type)) { return(true); } if ( strcmp(condition->Text(), "true") == 0 && strcmp(desired_condition, "true") != 0) { return(true); } if ( strcmp(condition->Text(), "1") == 0 && strcmp(desired_condition, "1") != 0) { return(true); } return(false); } // while_needs_rewrite void rewrite_loop_keyword(Chunk *keyword, E_Token new_type) { keyword->SetType(new_type); switch (new_type) { case CT_DO: keyword->SetOrigColEnd(keyword->GetOrigColEnd() + strlen("do") - keyword->Len()); keyword->Str() = "do"; break; case CT_WHILE: case CT_WHILE_OF_DO: keyword->SetOrigColEnd(keyword->GetOrigColEnd() + strlen("while") - keyword->Len()); keyword->Str() = "while"; break; case CT_FOR: keyword->SetOrigColEnd(keyword->GetOrigColEnd() + strlen("for") - keyword->Len()); keyword->Str() = "for"; break; default: break; } } static void move_one_token(Chunk * &source, Chunk * &destination, E_Token parent_type) { Chunk *next_source = source->GetNext(); // Place the source token immediately after the destination token, without // any whitespace. source->MoveAfter(destination); source->SetColumn(destination->GetColumn() + destination->Len()); source->SetOrigCol(destination->GetOrigCol() + destination->Len()); source->SetOrigColEnd(source->GetOrigColEnd() + source->Len()); source->SetOrigPrevSp(0); source->SetParentType(parent_type); destination = source; source = next_source; } static void rewrite_loop_condition(Chunk * &source, Chunk * &destination, E_Token desired_type, const char *desired_condition) { // Move the opening parenthesis move_one_token(source, destination, desired_type); // Move the condition if (desired_type == CT_FOR) { source->SetType(CT_SEMICOLON); source->SetParentType(CT_FOR); source->Str() = ";"; move_one_token(source, destination, desired_type); destination = (destination)->CopyAndAddAfter(destination); } else { source->SetType(CT_WORD); source->Str() = desired_condition; move_one_token(source, destination, desired_type); } // If converting a 'for' to a 'while', delete the second semicolon if (source->Is(CT_SEMICOLON)) { Chunk *next_source = source->GetNext(); Chunk::Delete(source); source = next_source; } // Move the closing parenthesis move_one_token(source, destination, desired_type); } void rewrite_loop_in_place(Chunk *keyword, E_Token desired_type, const char *desired_condition) { Chunk *top = keyword->GetNext(); Chunk *bottom = keyword; rewrite_loop_keyword(keyword, desired_type); rewrite_loop_condition(top, bottom, desired_type, desired_condition); } static Chunk *find_start_brace(Chunk *pc) { while (!pc->IsBraceOpen()) { pc = pc->GetNextNcNnl(); } return(pc); } void rewrite_infinite_loops() { LOG_FUNC_ENTRY(); E_Token desired_type; const char *desired_condition; switch (options::mod_infinite_loop()) { case 1: // for(;;) desired_type = CT_FOR; desired_condition = nullptr; break; case 2: // while(true) desired_type = CT_WHILE; desired_condition = "true"; break; case 3: // do...while(true) desired_type = CT_WHILE_OF_DO; desired_condition = "true"; break; case 4: // while(1) desired_type = CT_WHILE; desired_condition = "1"; break; case 5: // do...while(1) desired_type = CT_WHILE_OF_DO; desired_condition = "1"; break; default: return; } for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if (pc->Is(CT_DO)) { Chunk *start_brace = find_start_brace(pc); Chunk *end_brace = start_brace->GetClosingParen(); Chunk *while_keyword = end_brace->GetNextNcNnl(); if ( !while_keyword->Is(CT_WHILE_OF_DO) || !while_needs_rewrite(while_keyword, desired_type, desired_condition)) { continue; } if (desired_type == CT_WHILE_OF_DO) { // Change the loop condition rewrite_loop_in_place(while_keyword, desired_type, desired_condition); // Update the braces' parent types start_brace->SetParentType(CT_DO); end_brace->SetParentType(CT_DO); } else { Chunk *top = pc; Chunk *bottom = while_keyword->GetNext(); // Change the 'do' at the top of the loop to a 'for' or a 'while' rewrite_loop_keyword(top, desired_type); // Delete the 'while' at the bottom of the loop Chunk::Delete(while_keyword); // Move the rest of the tokens from the bottom to the top rewrite_loop_condition(bottom, top, desired_type, desired_condition); // Delete the final semicolon Chunk::Delete(bottom); // Update the braces' parent types start_brace->SetParentType(desired_type); end_brace->SetParentType(desired_type); } } else if ( ( pc->Is(CT_WHILE) && while_needs_rewrite(pc, desired_type, desired_condition)) || ( pc->Is(CT_FOR) && for_needs_rewrite(pc, desired_type))) { Chunk *start_brace = find_start_brace(pc); Chunk *end_brace = start_brace->GetClosingParen(); if (desired_type == CT_WHILE_OF_DO) { Chunk *top = pc; Chunk *bottom = end_brace; if (bottom->Is(CT_VBRACE_CLOSE)) { // Insert a new line before the new 'while' keyword newline_add_before(bottom); } // Add a 'while' at the bottom of the loop bottom = top->CopyAndAddAfter(bottom); rewrite_loop_keyword(bottom, CT_WHILE_OF_DO); // Change the 'while' at the top of the loop to a 'do' rewrite_loop_keyword(top, CT_DO); top = top->GetNext(); // Move the tokens from the top to the bottom rewrite_loop_condition(top, bottom, desired_type, desired_condition); // Add the final semicolon bottom = bottom->CopyAndAddAfter(bottom); bottom->SetType(CT_SEMICOLON); bottom->Str() = ";"; // Update the braces' parent types start_brace->SetParentType(CT_DO); end_brace->SetParentType(CT_DO); } else { // Change 'for' to 'while' or vice-versa rewrite_loop_in_place(pc, desired_type, desired_condition); // Update the braces' parent types start_brace->SetParentType(desired_type); end_brace->SetParentType(desired_type); } } } } // rewrite_infinite_loops uncrustify-uncrustify-0.76.0/src/rewrite_infinite_loops.h000066400000000000000000000005551434072136500237640ustar00rootroot00000000000000/** * @file rewrite_infinite_loops.h * prototypes for rewrite_infinite_loops.cpp * * @author Alex Henrie * @license GPL v2+ */ #ifndef REWRITE_INFINITE_LOOPS_H_INCLUDED #define REWRITE_INFINITE_LOOPS_H_INCLUDED /** * @brief Rewrite infinite loops in a consistent syntax */ void rewrite_infinite_loops(); #endif /* REWRITE_INFINITE_LOOPS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/semicolons.cpp000066400000000000000000000111451434072136500217050ustar00rootroot00000000000000/** * @file semicolons.cpp * Removes extra semicolons * * @author Ben Gardner * @license GPL v2+ */ #include "semicolons.h" #include "prototypes.h" static void remove_semicolon(Chunk *pc); /** * We are on a semicolon that is after an unidentified brace close. * Check for what is before the brace open. * Do not remove if it is a square close, word, type, or paren close. */ static void check_unknown_brace_close(Chunk *semi, Chunk *brace_close); static void remove_semicolon(Chunk *pc) { LOG_FUNC_ENTRY(); LOG_FMT(LDELSEMI, "%s(%d): Removed semicolon: orig line is %zu, orig col is %zu", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_func_stack_inline(LDELSEMI); // TODO: do we want to shift stuff back a column? Chunk::Delete(pc); } void remove_extra_semicolons() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); while (pc->IsNotNullChunk()) { Chunk *next = pc->GetNextNcNnl(); Chunk *prev; if ( pc->Is(CT_SEMICOLON) && !pc->TestFlags(PCF_IN_PREPROC) && (prev = pc->GetPrevNcNnl())->IsNotNullChunk()) { LOG_FMT(LSCANSEMI, "%s(%d): Semi orig line is %zu, orig col is %zu, parent is %s, prev = '%s' [%s/%s]\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetParentType()), prev->Text(), get_token_name(prev->GetType()), get_token_name(prev->GetParentType())); if (pc->GetParentType() == CT_TYPEDEF) { // keep it } else if ( prev->Is(CT_BRACE_CLOSE) && ( prev->GetParentType() == CT_IF || prev->GetParentType() == CT_ELSEIF || prev->GetParentType() == CT_ELSE || prev->GetParentType() == CT_SWITCH || prev->GetParentType() == CT_WHILE || prev->GetParentType() == CT_USING_STMT || prev->GetParentType() == CT_FOR || prev->GetParentType() == CT_FUNC_DEF || prev->GetParentType() == CT_OC_MSG_DECL || prev->GetParentType() == CT_FUNC_CLASS_DEF || prev->GetParentType() == CT_NAMESPACE)) { // looking for code block vs. initialisation bool code_block_found = true; Chunk *closing_brace = pc->GetPrevNcNnl(); // Issue #3506 if ( closing_brace != nullptr && closing_brace->IsNotNullChunk()) { Chunk *opening_brace = closing_brace->GetOpeningParen(); if ( opening_brace != nullptr && opening_brace->IsNotNullChunk()) { Chunk *equal_sign = opening_brace->GetPrevNcNnl(); if ( equal_sign != nullptr && equal_sign->IsNotNullChunk() && equal_sign->Is(CT_ASSIGN)) { // initialisation found code_block_found = false; } } } if (code_block_found) { // code block found remove_semicolon(pc); } } else if ( prev->Is(CT_BRACE_CLOSE) && prev->GetParentType() == CT_NONE) { check_unknown_brace_close(pc, prev); } else if ( prev->Is(CT_SEMICOLON) && prev->GetParentType() != CT_FOR) { remove_semicolon(pc); } else if ( language_is_set(LANG_D) && ( prev->GetParentType() == CT_ENUM || prev->GetParentType() == CT_UNION || prev->GetParentType() == CT_STRUCT)) { remove_semicolon(pc); } else if ( language_is_set(LANG_JAVA) && prev->GetParentType() == CT_SYNCHRONIZED) { remove_semicolon(pc); } else if (prev->Is(CT_BRACE_OPEN)) { remove_semicolon(pc); } } pc = next; } } // remove_extra_semicolons static void check_unknown_brace_close(Chunk *semi, Chunk *brace_close) { LOG_FUNC_ENTRY(); Chunk *pc = brace_close->GetPrevType(CT_BRACE_OPEN, brace_close->GetLevel()); pc = pc->GetPrevNcNnl(); if ( pc->IsNotNullChunk() && pc->IsNot(CT_RETURN) && pc->IsNot(CT_WORD) && pc->IsNot(CT_TYPE) && pc->IsNot(CT_SQUARE_CLOSE) && pc->IsNot(CT_ANGLE_CLOSE) && pc->IsNot(CT_TSQUARE) && !pc->IsParenClose()) { remove_semicolon(semi); } } uncrustify-uncrustify-0.76.0/src/semicolons.h000066400000000000000000000011571434072136500213540ustar00rootroot00000000000000/** * @file semicolons.h * prototypes for semicolons.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef SEMICOLONS_H_INCLUDED #define SEMICOLONS_H_INCLUDED #include "uncrustify_types.h" /** * Removes superfluous semicolons: * - after brace close whose parent is IF, ELSE, SWITCH, WHILE, FOR, NAMESPACE * - after another semicolon where parent is not FOR * - (D) after brace close whose parent is ENUM/STRUCT/UNION * - (Java) after brace close whose parent is SYNCHRONIZED * - after an open brace * - when not in a #DEFINE */ void remove_extra_semicolons(); #endif /* SEMICOLONS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/sorting.cpp000066400000000000000000000446661434072136500212350ustar00rootroot00000000000000/** * @file sorting.cpp * Sorts chunks and imports * * @author Ben Gardner * @license GPL v2+ */ #include "sorting.h" #include "newlines.h" #include "prototypes.h" #include #include constexpr static auto LCURRENT = LSORT; using namespace uncrustify; Option *include_category_options[] = { &options::include_category_0, &options::include_category_1, &options::include_category_2, }; constexpr static int kIncludeCategoriesCount = 3; struct include_category { include_category(const std::string &pattern) : regex(pattern) { } std::regex regex; }; include_category *include_categories[kIncludeCategoriesCount]; unordered_map chunk_priority_cache; unordered_map filename_without_ext_cache; /** * Compare two series of chunks, starting with the given ones. * @param pc1 first instance to compare * @param pc2 second instance to compare * @param tcare take care of case (lower case/ upper case) Issue #2091 * * @retval == 0 both text elements are equal * @retval > 0 * @retval < 0 */ static int compare_chunks(Chunk *pc1, Chunk *pc2, bool tcare); /** * Sort all of the chunks in O(n log n) time with a maximum of O(n) swaps */ static void do_the_sort(Chunk **chunks, size_t num_chunks); #define MARK_CHANGE() mark_change(__func__, __LINE__) static void mark_change(const char *func, size_t line) { LOG_FUNC_ENTRY(); cpd.changes++; if (cpd.pass_count == 0) { LOG_FMT(LCHANGE, "%s(%d): change %d on %s:%zu\n", __func__, __LINE__, cpd.changes, func, line); } } static void prepare_categories() { for (int i = 0; i < kIncludeCategoriesCount; ++i) { const auto &cat_pattern = (*include_category_options[i])(); if (!cat_pattern.empty()) { include_categories[i] = new include_category(cat_pattern); } else { include_categories[i] = nullptr; } } } static void cleanup_categories() { chunk_priority_cache.clear(); filename_without_ext_cache.clear(); for (auto &include_category : include_categories) { if (include_category == nullptr) { continue; } delete include_category; include_category = NULL; } } static int get_chunk_priority(Chunk *pc) { if (chunk_priority_cache.count(pc) > 0) { return(chunk_priority_cache[pc]); } int category = kIncludeCategoriesCount; for (int i = 0; i < kIncludeCategoriesCount; i++) { if (include_categories[i] != nullptr) { if (std::regex_match(pc->Text(), include_categories[i]->regex)) { category = i; break; } } } chunk_priority_cache[pc] = category; return(category); } /** * Returns true if the text contains filename without extension. */ static bool text_contains_filename_without_ext(const char *text) { if (filename_without_ext_cache.count(text) > 0) { return(filename_without_ext_cache[text]); } std::string filepath = cpd.filename; size_t slash_idx = filepath.find_last_of("/\\"); std::string filename_without_ext = filepath; if ( slash_idx != std::string::npos && slash_idx < (filepath.size() - 1)) { std::string filename = filepath.substr(slash_idx + 1); size_t dot_idx = filename.find_last_of('.'); filename_without_ext = filename.substr(0, dot_idx); } const std::regex special_chars = std::regex(R"([-[\]{}()*+?.,\^$|#\s])"); const std::string sanitized_filename = std::regex_replace(filename_without_ext, special_chars, R"(\$&)"); const std::regex filename_pattern = std::regex("\\S?" + sanitized_filename + "\\b.*"); filename_without_ext_cache[text] = std::regex_match(text, filename_pattern); return(filename_without_ext_cache[text]); } /** * Get chunk text without the extension. */ static unc_text get_text_without_ext(const unc_text &chunk_text) { unc_text result = chunk_text; int idx = result.rfind(".", result.size() - 1); if (idx == -1) { return(result); } result.erase(idx, result.size() - idx); return(result); } /** * Returns true if unc_text has "." which implies extension. */ static bool has_dot(const unc_text &chunk_text) { int idx = chunk_text.rfind(".", chunk_text.size() - 1); return(idx != -1); } /** * Returns chunk string required for sorting. */ static unc_text chunk_sort_str(Chunk *pc) { if (pc->GetParentType() == CT_PP_INCLUDE) { return(unc_text{ pc->GetStr(), 0, pc->Len() - 1 }); } return(pc->GetStr()); } //! Compare two chunks static int compare_chunks(Chunk *pc1, Chunk *pc2, bool tcare) { LOG_FUNC_ENTRY(); LOG_FMT(LSORT, "%s(%d): @begin pc1->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc1->Len(), pc1->GetOrigLine(), pc1->GetOrigCol()); LOG_FMT(LSORT, "%s(%d): @begin pc2->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc2->Len(), pc2->GetOrigLine(), pc2->GetOrigCol()); if (pc1 == pc2) // same chunk is always identical thus return 0 differences { return(0); } while ( pc1->IsNotNullChunk() && pc2->IsNotNullChunk()) { auto const &s1_ext = chunk_sort_str(pc1); auto const &s2_ext = chunk_sort_str(pc2); log_rule_B("mod_sort_incl_import_ignore_extension"); auto const &s1 = (options::mod_sort_incl_import_ignore_extension()) ? get_text_without_ext(s1_ext) : s1_ext; auto const &s2 = (options::mod_sort_incl_import_ignore_extension()) ? get_text_without_ext(s2_ext) : s2_ext; log_rule_B("mod_sort_incl_import_prioritize_filename"); if (options::mod_sort_incl_import_prioritize_filename()) { bool s1_contains_filename = text_contains_filename_without_ext(s1.c_str()); bool s2_contains_filename = text_contains_filename_without_ext(s2.c_str()); if ( s1_contains_filename && !s2_contains_filename) { return(-1); } else if ( !s1_contains_filename && s2_contains_filename) { return(1); } } if (options::mod_sort_incl_import_prioritize_extensionless()) { log_rule_B("mod_sort_incl_import_prioritize_extensionless"); const bool s1_has_dot = has_dot(s1_ext); const bool s2_has_dot = has_dot(s2_ext); if ( s1_has_dot && !s2_has_dot) { return(1); } else if ( !s1_has_dot && s2_has_dot) { return(-1); } } if (options::mod_sort_incl_import_prioritize_angle_over_quotes()) { log_rule_B("mod_sort_incl_import_prioritize_angle_over_quotes"); if ( s1.startswith("<") && s2.startswith("\"")) { return(-1); } else if ( s1.startswith("\"") && s2.startswith("<")) { return(1); } } int ppc1 = get_chunk_priority(pc1); int ppc2 = get_chunk_priority(pc2); if (ppc1 != ppc2) { return(ppc1 - ppc2); } LOG_FMT(LSORT, "%s(%d): text is %s, pc1->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc1->Text(), pc1->Len(), pc1->GetOrigLine(), pc1->GetOrigCol()); LOG_FMT(LSORT, "%s(%d): text is %s, pc2->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc2->Text(), pc2->Len(), pc2->GetOrigLine(), pc2->GetOrigCol()); int ret_val = unc_text::compare(s1, s2, std::min(s1.size(), s2.size()), tcare); LOG_FMT(LSORT, "%s(%d): ret_val is %d\n", __func__, __LINE__, ret_val); if (ret_val != 0) { return(ret_val); } if (pc1->Len() != pc2->Len()) { return(pc1->Len() - pc2->Len()); } // Same word, same length. Step to the next chunk. pc1 = pc1->GetNext(); LOG_FMT(LSORT, "%s(%d): text is %s, pc1->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc1->Text(), pc1->Len(), pc1->GetOrigLine(), pc1->GetOrigCol()); if (pc1->Is(CT_MEMBER)) { pc1 = pc1->GetNext(); LOG_FMT(LSORT, "%s(%d): text is %s, pc1->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc1->Text(), pc1->Len(), pc1->GetOrigLine(), pc1->GetOrigCol()); } pc2 = pc2->GetNext(); LOG_FMT(LSORT, "%s(%d): text is %s, pc2->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc2->Text(), pc2->Len(), pc2->GetOrigLine(), pc2->GetOrigCol()); if (pc2->Is(CT_MEMBER)) { pc2 = pc2->GetNext(); LOG_FMT(LSORT, "%s(%d): text is %s, pc2->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc2->Text(), pc2->Len(), pc2->GetOrigLine(), pc2->GetOrigCol()); } LOG_FMT(LSORT, "%s(%d): >>>text is %s, pc1->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc1->Text(), pc1->Len(), pc1->GetOrigLine(), pc1->GetOrigCol()); LOG_FMT(LSORT, "%s(%d): >>>text is %s, pc2->len is %zu, line is %zu, column is %zu\n", __func__, __LINE__, pc2->Text(), pc2->Len(), pc2->GetOrigLine(), pc2->GetOrigCol()); // If we hit a newline or nullptr, we are done if ( pc1->IsNullChunk() || pc1->IsNewline() || pc2->IsNullChunk() || pc2->IsNewline()) { break; } } if ( pc1->IsNullChunk() || !pc2->IsNewline()) { return(-1); } if (!pc1->IsNewline()) { return(1); } return(0); } // compare_chunks /** * Sort all of the chunks in O(n log n) time with a maximum of O(n) swaps */ static void do_the_sort(Chunk **chunks, size_t num_chunks) { LOG_FUNC_ENTRY(); LOG_FMT(LSORT, "%s(%d): %zu chunks:", __func__, __LINE__, num_chunks); for (size_t idx = 0; idx < num_chunks; idx++) { LOG_FMT(LSORT, " [%s]", chunks[idx]->Text()); } LOG_FMT(LSORT, "\n"); log_rule_B("mod_sort_case_sensitive"); bool take_care = options::mod_sort_case_sensitive(); // Issue #2091 // Sort an array of the chunk positions in order to minimize the number of swaps std::vector chunk_positions(num_chunks); for (size_t idx = 0; idx < num_chunks; idx++) { chunk_positions[idx] = idx; } sort(chunk_positions.begin(), chunk_positions.end(), [chunks, take_care](const size_t &l, const size_t &r) { return(compare_chunks(chunks[l], chunks[r], take_care) < 0); }); // Swap the chunk positions for (size_t idx = 0; idx < num_chunks; idx++) { if (chunk_positions[idx] != idx) { log_rule_B("mod_sort_incl_import_grouping_enabled"); const size_t from = chunk_positions[idx]; const size_t to = chunk_positions[from]; chunks[from]->SwapLines(chunks[to]); Chunk *pc = chunks[from]; chunks[from] = chunks[to]; chunks[to] = pc; chunk_positions[from] = from; chunk_positions[idx] = to; idx--; } } } // do_the_sort /** * Remove blank lines between chunks. */ static void remove_blank_lines_between_imports(Chunk **chunks, size_t num_chunks) { LOG_FUNC_ENTRY(); if (num_chunks < 2) { return; } for (size_t idx = 0; idx < (num_chunks - 1); idx++) { Chunk *chunk1 = chunks[idx]->GetNextNl(); chunk1->SetNlCount(1); MARK_CHANGE(); } } /** * Delete chunks on line having chunk. */ static void delete_chunks_on_line_having_chunk(Chunk *chunk) { LOG_FUNC_ENTRY(); Chunk *pc = chunk->GetFirstChunkOnLine(); while ( pc->IsNotNullChunk() && !pc->IsComment()) { Chunk *next_pc = pc->GetNext(); LOG_FMT(LCHUNK, "%s(%d): Removed '%s' on orig line %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine()); if (pc->IsNewline()) { Chunk::Delete(pc); break; } else { Chunk::Delete(pc); } pc = next_pc; } } /** * Dedupe import/include directives. */ static void dedupe_imports(Chunk **chunks, size_t num_chunks) { LOG_FUNC_ENTRY(); log_rule_B("mod_sort_case_sensitive"); for (size_t idx = 1; idx < num_chunks; idx++) { auto const &s1 = chunk_sort_str(chunks[idx - 1]); auto const &s2 = chunk_sort_str(chunks[idx]); if (s1.size() != s2.size()) { continue; } int ret_val = unc_text::compare(s1, s2, std::min(s1.size(), s2.size()), options::mod_sort_case_sensitive()); if (ret_val == 0) { delete_chunks_on_line_having_chunk(chunks[idx - 1]); } } } /** * Add blank line before the chunk. */ static void blankline_add_before(Chunk *pc) { Chunk *newline = newline_add_before(pc->GetFirstChunkOnLine()); if (newline->GetNlCount() < 2) { double_newline(newline); } } /** * Group imports. */ static void group_imports_by_adding_newlines(Chunk **chunks, size_t num_chunks) { LOG_FUNC_ENTRY(); // Group imports based on first character, typically quote or angle. int c_idx = -1; int c_idx_last = -1; for (size_t idx = 0; idx < num_chunks; idx++) { if (chunks[idx]->GetStr().size() > 0) { c_idx = chunks[idx]->GetStr().at(0); } else { c_idx = -1; } if ( c_idx_last != c_idx && idx > 0) { blankline_add_before(chunks[idx]); } c_idx_last = c_idx; } // Group imports based on having extension. bool chunk_has_dot = false; bool chunk_last_has_dot = false; for (size_t idx = 0; idx < num_chunks; idx++) { chunk_has_dot = has_dot(chunks[idx]->GetStr()); if ( chunk_last_has_dot != chunk_has_dot && idx > 0) { blankline_add_before(chunks[idx]); } chunk_last_has_dot = chunk_has_dot; } // Group imports based on priority defined by config. int chunk_pri = -1; int chunk_pri_last = -1; for (size_t idx = 0; idx < num_chunks; idx++) { chunk_pri = get_chunk_priority(chunks[idx]); if ( chunk_pri_last != chunk_pri && idx > 0) { blankline_add_before(chunks[idx]); } chunk_pri_last = chunk_pri; } // Group imports that contain filename pattern. bool chunk_has_filename = false; bool last_chunk_has_filename = false; for (size_t idx = 0; idx < num_chunks; idx++) { auto const &chunk_text = chunk_sort_str(chunks[idx]); chunk_has_filename = text_contains_filename_without_ext(chunk_text.c_str()); if ( !chunk_has_filename && last_chunk_has_filename) { blankline_add_before(chunks[idx]); } last_chunk_has_filename = chunk_has_filename; } } // group_imports_by_adding_newlines void sort_imports() { LOG_FUNC_ENTRY(); const int max_number_to_sort = 1024; const int max_lines_to_check_for_sort_after_include = 128; const int max_gap_threshold_between_include_to_sort = 32; Chunk *chunks[max_number_to_sort]; size_t num_chunks = 0; Chunk *p_last = nullptr; Chunk *p_imp = nullptr; Chunk *p_imp_last = nullptr; prepare_categories(); Chunk *pc = Chunk::GetHead(); log_rule_B("mod_sort_incl_import_grouping_enabled"); while (pc->IsNotNullChunk()) { // Simple optimization to limit the sorting. Any MAX_LINES_TO_CHECK_AFTER_INCLUDE lines after last // import is seen are ignore from sorting. if ( options::mod_sort_incl_import_grouping_enabled() && p_imp_last != nullptr && (pc->GetOrigLine() - p_imp_last->GetOrigLine()) > max_lines_to_check_for_sort_after_include) { break; } Chunk *next = pc->GetNext(); if (pc->IsNewline()) { bool did_import = false; if ( p_imp != nullptr && p_imp->IsNotNullChunk() && p_last != nullptr && ( p_last->Is(CT_SEMICOLON) || p_imp->TestFlags(PCF_IN_PREPROC))) { if (num_chunks < max_number_to_sort) { LOG_FMT(LSORT, "%s(%d): p_imp is %s\n", __func__, __LINE__, p_imp->Text()); chunks[num_chunks++] = p_imp; } else { fprintf(stderr, "Number of 'import' to be sorted is too big for the current value %d.\n", max_number_to_sort); fprintf(stderr, "Please make a report.\n"); log_flush(true); exit(EX_SOFTWARE); } did_import = true; } log_rule_B("mod_sort_incl_import_grouping_enabled"); if ( !did_import || ( !options::mod_sort_incl_import_grouping_enabled() && pc->GetNlCount() > 1) || ( options::mod_sort_incl_import_grouping_enabled() && p_imp_last != nullptr && (pc->GetOrigLine() - p_imp_last->GetOrigLine()) > max_gap_threshold_between_include_to_sort) || next->IsNullChunk()) { if (num_chunks > 1) { log_rule_B("mod_sort_incl_import_grouping_enabled"); if (options::mod_sort_incl_import_grouping_enabled()) { remove_blank_lines_between_imports(chunks, num_chunks); do_the_sort(chunks, num_chunks); group_imports_by_adding_newlines(chunks, num_chunks); dedupe_imports(chunks, num_chunks); } else { do_the_sort(chunks, num_chunks); } } num_chunks = 0; } p_imp_last = p_imp; p_imp = nullptr; p_last = nullptr; } else if (pc->Is(CT_IMPORT)) { log_rule_B("mod_sort_import"); if (options::mod_sort_import()) { p_imp = pc->GetNext(); } } else if (pc->Is(CT_USING)) { log_rule_B("mod_sort_using"); if (options::mod_sort_using()) { p_imp = pc->GetNext(); } } else if (pc->Is(CT_PP_INCLUDE)) { log_rule_B("mod_sort_include"); if (options::mod_sort_include()) { p_imp = pc->GetNext(); p_last = pc; } } else if (!pc->IsComment()) { p_last = pc; } pc = next; } cleanup_categories(); } // sort_imports uncrustify-uncrustify-0.76.0/src/sorting.h000066400000000000000000000006261434072136500206660ustar00rootroot00000000000000/** * @file sorting.h * prototypes for sorting.cpp * * @author Ben Gardner * @license GPL v2+ */ #ifndef SORTING_H_INCLUDED #define SORTING_H_INCLUDED #include "uncrustify_types.h" /** * alphabetically sort the #include or #import * statements of a file * * @todo better use a chunk pointer parameter * instead of a global variable */ void sort_imports(); #endif /* SORTING_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/space.cpp000066400000000000000000003546641434072136500206450ustar00rootroot00000000000000/** * @file space.cpp * Adds or removes inter-chunk spaces. * * Information * "Ignore" means do not change it. * "Add" in the context of spaces means make sure there is at least 1. * "Add" elsewhere means make sure one is present. * "Remove" mean remove the space/brace/newline/etc. * "Force" in the context of spaces means ensure that there is exactly 1. * "Force" in other contexts means the same as "add". * * Rmk: spaces = space + nl * * @author Ben Gardner * @author Guy Maurel, 2015-2022 * @license GPL v2+ */ #include "space.h" #include "add_space_table.h" #include "log_rules.h" #include "options_for_QT.h" #include "punctuators.h" #ifdef WIN32 #include // to get max #endif // ifdef WIN32 using namespace std; using namespace uncrustify; /** * Decides how to change inter-chunk spacing. * Note that the order of the if statements is VERY important. * * @param first The first chunk * @param second The second chunk * * @return IARF_IGNORE, IARF_ADD, IARF_REMOVE or IARF_FORCE */ static iarf_e do_space(Chunk *first, Chunk *second, int &min_sp); /** * Ensure to force the space between the \a first and the \a second chunks * if the PCF_FORCE_SPACE flag is set in the \a first. * * @param first The first chunk * @param second The second chunk * @param av Av from the do_space() * * @return IARF_IGNORE, IARF_ADD, IARF_REMOVE or IARF_FORCE */ static iarf_e ensure_force_space(Chunk *first, Chunk *second, iarf_e av); bool token_is_within_trailing_return(Chunk *pc) { // look back for '->' type is TRAILING_RET // until CT_FPAREN_CLOSE // or CT_FPAREN_OPEN is found Chunk *prev = pc; if (prev == nullptr) { prev = Chunk::NullChunkPtr; } while (prev->IsNotNullChunk()) { if (prev->Is(CT_TRAILING_RET)) { return(true); } else if ( prev->Is(CT_FPAREN_CLOSE) || prev->Is(CT_FPAREN_OPEN)) { return(false); } else { prev = prev->GetPrev(); } } return(false); } // token_is_within_trailing_return /* * this function is called for every chunk in the input file. * Thus it is important to keep this function efficient */ static iarf_e do_space(Chunk *first, Chunk *second, int &min_sp) { LOG_FUNC_ENTRY(); LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, first Text() '%s', type is %s\n", __func__, __LINE__, first->GetOrigLine(), first->GetOrigCol(), first->Text(), get_token_name(first->GetType())); min_sp = 1; if ( first->Is(CT_PP_IGNORE) && second->Is(CT_PP_IGNORE)) { // Leave spacing alone between PP_IGNORE tokens as we don't want the default behavior (which is ADD). log_rule("PP_IGNORE"); return(IARF_IGNORE); } if ( first->Is(CT_PP) || second->Is(CT_PP)) { // Add or remove space around preprocessor '##' concatenation operator. log_rule("sp_pp_concat"); return(options::sp_pp_concat()); } if (first->Is(CT_POUND)) { // Add or remove space after preprocessor '#' stringify operator. // Also affects the '#@' charizing operator. log_rule("sp_pp_stringify"); return(options::sp_pp_stringify()); } if ( second->Is(CT_POUND) && second->TestFlags(PCF_IN_PREPROC) && first->GetParentType() != CT_MACRO_FUNC) { // Add or remove space before preprocessor '#' stringify operator // as in '#define x(y) L#y'. log_rule("sp_before_pp_stringify"); return(options::sp_before_pp_stringify()); } if ( first->Is(CT_SPACE) || second->Is(CT_SPACE)) { log_rule("REMOVE"); return(IARF_REMOVE); } if (first->Is(CT_DECLSPEC)) // Issue 1289 { log_rule("REMOVE"); return(IARF_REMOVE); } if ( second->Is(CT_NEWLINE) || second->Is(CT_VBRACE_OPEN)) { log_rule("REMOVE"); return(IARF_REMOVE); } if ( first->Is(CT_VBRACE_OPEN) && second->IsNot(CT_NL_CONT) && second->IsNot(CT_SEMICOLON)) // # Issue 1158 { log_rule("FORCE"); return(IARF_FORCE); } if ( first->Is(CT_VBRACE_CLOSE) && second->IsNot(CT_NL_CONT)) { log_rule("REMOVE"); return(IARF_REMOVE); } if (second->Is(CT_VSEMICOLON)) { log_rule("REMOVE"); return(IARF_REMOVE); } if (first->Is(CT_MACRO_FUNC)) { log_rule("REMOVE"); return(IARF_REMOVE); } if (second->Is(CT_NL_CONT)) { // Add or remove space before a backslash-newline at the end of a line. log_rule("sp_before_nl_cont"); return(options::sp_before_nl_cont()); } if ( language_is_set(LANG_D) && ( first->Is(CT_D_ARRAY_COLON) || second->Is(CT_D_ARRAY_COLON))) { // (D) Add or remove around the D named array initializer ':' operator. log_rule("sp_d_array_colon"); return(options::sp_d_array_colon()); } if ( first->Is(CT_CASE) && (( CharTable::IsKw1(second->GetStr()[0]) || second->Is(CT_NUMBER)))) { // Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make // sense here. log_rule("sp_case_label"); return(options::sp_case_label() | IARF_ADD); } if (first->Is(CT_FOR_COLON)) { // java // Add or remove space after ':' in a Java/C++11 range-based 'for', // as in 'for (Type var : expr)'. log_rule("sp_after_for_colon"); return(options::sp_after_for_colon()); } if (second->Is(CT_FOR_COLON)) { // java // Add or remove space before ':' in a Java/C++11 range-based 'for', // as in 'for (Type var : expr)'. log_rule("sp_before_for_colon"); return(options::sp_before_for_colon()); } if ( first->Is(CT_QUESTION) && second->Is(CT_COND_COLON)) { // In the abbreviated ternary form '(a ?: b)', add or remove space between '?' // and ':'. // Overrides all other sp_cond_* options. log_rule("sp_cond_ternary_short"); return(options::sp_cond_ternary_short()); } if ( first->Is(CT_QUESTION) // see the tests cpp:34513-34516 || second->Is(CT_QUESTION)) { if ( second->Is(CT_QUESTION) && (options::sp_cond_question_before() != IARF_IGNORE)) { // Add or remove space before the '?' in 'b ? t : f'. // Overrides sp_cond_question. log_rule("sp_cond_question_before"); return(options::sp_cond_question_before()); } if ( first->Is(CT_QUESTION) && (options::sp_cond_question_after() != IARF_IGNORE)) { // Add or remove space after the '?' in 'b ? t : f'. // Overrides sp_cond_question. log_rule("sp_cond_question_after"); return(options::sp_cond_question_after()); } log_rule("sp_cond_question"); return(options::sp_cond_question()); } if ( first->Is(CT_COND_COLON) || second->Is(CT_COND_COLON)) { if ( second->Is(CT_COND_COLON) && (options::sp_cond_colon_before() != IARF_IGNORE)) { // Add or remove space before the ':' in 'b ? t : f'. // Overrides sp_cond_colon. log_rule("sp_cond_colon_before"); return(options::sp_cond_colon_before()); } if ( first->Is(CT_COND_COLON) && (options::sp_cond_colon_after() != IARF_IGNORE)) { // Add or remove space after the ':' in 'b ? t : f'. // Overrides sp_cond_colon. log_rule("sp_cond_colon_after"); return(options::sp_cond_colon_after()); } // Issue #2596 // replace "if (first->Is(CT_WORD) && second->Is(CT_COND_COLON))" // Add or remove space around the ':' in 'b ? t : f'. log_rule("sp_cond_colon"); return(options::sp_cond_colon()); } if ( language_is_set(LANG_D) && ( first->Is(CT_RANGE) || second->Is(CT_RANGE))) { // (D) Add or remove space around the D '..' operator. log_rule("sp_range"); return(options::sp_range()); } if ( first->Is(CT_COLON) && first->GetParentType() == CT_SQL_EXEC) { log_rule("REMOVE"); return(IARF_REMOVE); } // Macro stuff can only return IGNORE, ADD, or FORCE if (first->Is(CT_MACRO)) { // Add or remove space between a macro name and its definition. log_rule("sp_macro"); iarf_e arg = options::sp_macro(); return(arg | ((arg != IARF_IGNORE) ? IARF_ADD : IARF_IGNORE)); } if ( first->Is(CT_FPAREN_CLOSE) && first->GetParentType() == CT_MACRO_FUNC) { // Add or remove space between a macro function ')' and its definition. log_rule("sp_macro_func"); iarf_e arg = options::sp_macro_func(); return(arg | ((arg != IARF_IGNORE) ? IARF_ADD : IARF_IGNORE)); } if (first->Is(CT_PREPROC)) { // Remove spaces, unless we are ignoring. See indent_preproc() log_rule("pp_space_after"); if (options::pp_space_after() == IARF_IGNORE) { log_rule("IGNORE"); return(IARF_IGNORE); } log_rule("REMOVE"); return(IARF_REMOVE); } if (second->Is(CT_PREPROC)) { // Remove spaces, unless we are ignoring. See indent_preproc() log_rule("pp_indent"); if (options::pp_indent() == IARF_IGNORE) { log_rule("IGNORE"); return(IARF_IGNORE); } log_rule("REMOVE"); return(IARF_REMOVE); } if (second->Is(CT_SEMICOLON)) // see the tests cpp:34517-34519 { if (first->Is(CT_VBRACE_OPEN)) { // Add or remove space before ';'. log_rule("sp_before_semi"); return(options::sp_before_semi()); } if (second->GetParentType() == CT_FOR) { if (first->Is(CT_SPAREN_OPEN)) { // empty, e.g. for (;;) // ^ is first // ^ is second // Add or remove space before a semicolon of an empty left part of a for statement. log_rule("sp_before_semi_for_empty"); return(options::sp_before_semi_for_empty()); } if (first->Is(CT_SEMICOLON)) { // empty, e.g. for (;;) // ^ is first // ^ is second // Add or remove space between semicolons of an empty middle part of a for statement. log_rule("sp_between_semi_for_empty"); return(options::sp_between_semi_for_empty()); } // Add or remove space before ';' in non-empty 'for' statements. log_rule("sp_before_semi_for"); return(options::sp_before_semi_for()); } iarf_e arg = options::sp_before_semi(); // see the tests cpp:34517-34519 if ( first->Is(CT_VBRACE_OPEN) // Issue #2942 && first->GetPrev()->Is(CT_SPAREN_CLOSE) && first->GetParentType() != CT_WHILE_OF_DO) { // Add or remove space before empty statement ';' on 'if', 'for' and 'while'. log_rule("sp_special_semi"); arg = arg | options::sp_special_semi(); } else { // Add or remove space before ';'. log_rule("sp_before_semi"); } return(arg); } if ( ( second->Is(CT_COMMENT) || second->Is(CT_COMMENT_CPP)) && ( first->Is(CT_PP_ELSE) || first->Is(CT_PP_ENDIF))) { second->SetType(CT_COMMENT_ENDIF); // Add or remove space between #else or #endif and a trailing comment. log_rule("sp_endif_cmt"); return(options::sp_endif_cmt()); } if ( options::sp_before_tr_cmt() != IARF_IGNORE && second->GetParentType() == CT_COMMENT_END) { // Add or remove space before a trailing comment. // Number of spaces before a trailing comment. log_rule("sp_num_before_tr_cmt"); min_sp = options::sp_num_before_tr_cmt(); return(options::sp_before_tr_cmt()); } if (second->GetParentType() == CT_COMMENT_END) { switch (second->GetOrigPrevSp()) { case 0: log_rule("orig prev sp - REMOVE"); return(IARF_REMOVE); case 1: log_rule("orig prev sp - FORCE"); return(IARF_FORCE); default: log_rule("orig prev sp - ADD"); return(IARF_ADD); } } // "for (;;)" vs. "for (;; )" and "for (a;b;c)" vs. "for (a; b; c)" if (first->Is(CT_SEMICOLON)) // see the tests cpp:34517-34519 { if (first->GetParentType() == CT_FOR) { if (second->Is(CT_SPAREN_CLOSE)) { // Add or remove space after the final semicolon of an empty part of a for // statement, as in 'for ( ; ; )'. log_rule("sp_after_semi_for_empty"); return(options::sp_after_semi_for_empty()); } if (second->IsNot(CT_SPAREN_CLOSE)) // Issue 1324 { // Add or remove space after ';' in non-empty 'for' statements. log_rule("sp_after_semi_for"); return(options::sp_after_semi_for()); } } else if ( !second->IsComment() && second->IsNot(CT_BRACE_CLOSE)) // issue #197 { // Add or remove space after ';', except when followed by a comment. // see the tests cpp:34517-34519 log_rule("sp_after_semi"); return(options::sp_after_semi()); } // Let the comment spacing rules handle this } // puts a space in the rare '+-' or '-+' if ( ( first->Is(CT_NEG) || first->Is(CT_POS) || first->Is(CT_ARITH) || first->Is(CT_SHIFT)) && ( second->Is(CT_NEG) || second->Is(CT_POS) || second->Is(CT_ARITH) || second->Is(CT_SHIFT))) { log_rule("ADD"); return(IARF_ADD); } // "return(a);" vs. "return (foo_t)a + 3;" vs. "return a;" vs. "return;" if (first->Is(CT_RETURN)) { if ( second->Is(CT_PAREN_OPEN) && second->GetParentType() == CT_RETURN) { // Add or remove space between 'return' and '('. log_rule("sp_return_paren"); return(options::sp_return_paren()); } else if ( second->Is(CT_BRACE_OPEN) && second->GetParentType() == CT_BRACED_INIT_LIST) { // Add or remove space between 'return' and '{'. log_rule("sp_return_brace"); return(options::sp_return_brace()); } // Everything else requires a space // The value REMOVE will be overridden with FORCE log_rule("sp_return"); if (options::sp_return() == IARF_REMOVE) { return(IARF_FORCE); } return(options::sp_return()); } // "sizeof(foo_t)" vs. "sizeof (foo_t)" if (first->Is(CT_SIZEOF)) { if (second->Is(CT_PAREN_OPEN)) { // Add or remove space between 'sizeof' and '('. log_rule("sp_sizeof_paren"); return(options::sp_sizeof_paren()); } if (second->Is(CT_ELLIPSIS)) { // Add or remove space between 'sizeof' and '...'. log_rule("sp_sizeof_ellipsis"); return(options::sp_sizeof_ellipsis()); } log_rule("FORCE"); return(IARF_FORCE); } // "decltype(foo_t)" vs. "decltype (foo_t)" if (first->Is(CT_DECLTYPE)) { if (second->Is(CT_PAREN_OPEN)) { // Add or remove space between 'decltype' and '('. log_rule("sp_decltype_paren"); return(options::sp_decltype_paren()); } log_rule("FORCE"); return(IARF_FORCE); } // handle '::' if (first->Is(CT_DC_MEMBER)) { // Add or remove space after the '::' operator. log_rule("sp_after_dc"); return(options::sp_after_dc()); } // Issue #889 // mapped_file_source abc((int) ::CW2A(sTemp)); if ( first->Is(CT_PAREN_CLOSE) && second->Is(CT_DC_MEMBER) && second->GetNext()->GetType() == CT_FUNC_CALL) { log_rule("sp_after_cast"); return(options::sp_after_cast()); } if (second->Is(CT_DC_MEMBER)) { /* '::' at the start of an identifier is not member access, but global scope operator. * Detect if previous chunk is keyword */ switch (first->GetType()) { case CT_SBOOL: case CT_SASSIGN: case CT_ARITH: case CT_SHIFT: case CT_CASE: case CT_CLASS: case CT_DELETE: case CT_FRIEND: case CT_NAMESPACE: case CT_NEW: case CT_SARITH: case CT_SCOMPARE: case CT_OPERATOR: case CT_ACCESS: case CT_QUALIFIER: case CT_RETURN: case CT_SIZEOF: case CT_DECLTYPE: case CT_STRUCT: case CT_THROW: case CT_TYPEDEF: case CT_TYPENAME: case CT_UNION: case CT_USING: log_rule("FORCE"); return(IARF_FORCE); default: break; } if ( ( first->Is(CT_WORD) || first->Is(CT_TYPE) || first->Is(CT_PAREN_CLOSE) || CharTable::IsKw1(first->GetStr()[0])) && (strcmp(first->Text(), "void") != 0)) // Issue 1249 { // Add or remove space before the '::' operator. log_rule("sp_before_dc"); return(options::sp_before_dc()); } } // "a,b" vs. "a, b" if (first->Is(CT_COMMA)) // see the tests cpp:34520-34524 // see the tests c-sharp:12200-12202 { if ( language_is_set(LANG_CS | LANG_VALA) && first->GetParentType() == CT_TYPE) { // (C#, Vala) multidimensional array type: ',,' vs. ', ,' or ',]' vs. ', ]' if (second->Is(CT_COMMA)) { // (C#, Vala) Add or remove space between ',' in multidimensional array type // like 'int[,,]'. log_rule("sp_between_mdatype_commas"); return(options::sp_between_mdatype_commas()); } // (C#, Vala) Add or remove space between ',' and ']' in multidimensional array type // like 'int[,,]'. log_rule("sp_after_mdatype_commas"); return(options::sp_after_mdatype_commas()); } // Fix for issue #1243 // Don't add extra space after comma immediately followed by Angle close if (second->Is(CT_ANGLE_CLOSE)) { log_rule("IGNORE"); return(IARF_IGNORE); } // Add or remove space after ',', i.e. 'a,b' vs. 'a, b'. log_rule("sp_after_comma"); return(options::sp_after_comma()); } // test if we are within a SIGNAL/SLOT call if (QT_SIGNAL_SLOT_found) { if ( first->Is(CT_FPAREN_CLOSE) && ( second->Is(CT_FPAREN_CLOSE) || second->Is(CT_COMMA))) { if (second->GetLevel() == QT_SIGNAL_SLOT_level) { restoreValues = true; } } } if (second->Is(CT_COMMA)) { if ( language_is_set(LANG_CS | LANG_VALA) && first->Is(CT_SQUARE_OPEN) && first->GetParentType() == CT_TYPE) { // (C#, Vala) Add or remove space between '[' and ',' in multidimensional array type // like 'int[,,]'. log_rule("sp_before_mdatype_commas"); return(options::sp_before_mdatype_commas()); } if ( first->Is(CT_PAREN_OPEN) || first->Is(CT_FPAREN_OPEN)) { // Add or remove space between an open parenthesis and comma, // i.e. '(,' vs. '( ,'. log_rule("sp_paren_comma"); return(options::sp_paren_comma()); } // Add or remove space before ',', i.e. 'a,b' vs. 'a ,b'. log_rule("sp_before_comma"); return(options::sp_before_comma()); } if (second->Is(CT_ELLIPSIS)) { // type followed by a ellipsis Chunk *tmp = first; if ( tmp->Is(CT_PTR_TYPE) || tmp->Is(CT_BYREF)) { tmp = tmp->GetPrevNcNnl(); } if ( tmp->Is(CT_TYPE) || tmp->Is(CT_QUALIFIER)) { // Add or remove space between a type and '...'. log_rule("sp_type_ellipsis"); return(options::sp_type_ellipsis()); } // non-punc followed by a ellipsis if ( !first->TestFlags(PCF_PUNCTUATOR) && (options::sp_before_ellipsis() != IARF_IGNORE)) { // Add or remove space before the variadic '...' when preceded by a // non-punctuator. log_rule("sp_before_ellipsis"); return(options::sp_before_ellipsis()); } if ( first->Is(CT_FPAREN_CLOSE) || first->Is(CT_PAREN_CLOSE)) { // Add or remove space between ')' and '...'. log_rule("sp_paren_ellipsis"); return(options::sp_paren_ellipsis()); } if (first->Is(CT_TAG_COLON)) { log_rule("FORCE"); return(IARF_FORCE); } if (first->Is(CT_BYREF)) // Issue #3309 { log_rule("sp_byref_ellipsis"); return(options::sp_byref_ellipsis()); } if (first->Is(CT_PARAMETER_PACK)) // Issue #3309 { log_rule("sp_parameter_pack_ellipsis"); return(options::sp_parameter_pack_ellipsis()); } } if (first->Is(CT_ELLIPSIS)) { if (second->Is(CT_PARAMETER_PACK)) // Issue #3309 { log_rule("sp_ellipsis_parameter_pack"); return(options::sp_ellipsis_parameter_pack()); } if (CharTable::IsKw1(second->GetStr()[0])) { log_rule("FORCE"); return(IARF_FORCE); } if ( second->Is(CT_PAREN_OPEN) && first->GetPrev()->Is(CT_SIZEOF)) { // Add or remove space between 'sizeof...' and '('. log_rule("sp_sizeof_ellipsis_paren"); return(options::sp_sizeof_ellipsis_paren()); } } if ( language_is_set(LANG_PAWN) && first->Is(CT_TAG_COLON)) { // (Pawn) Add or remove space after the tag keyword. log_rule("sp_after_tag"); return(options::sp_after_tag()); } if (second->Is(CT_TAG_COLON)) { log_rule("REMOVE"); return(IARF_REMOVE); } // handle '~' if (first->Is(CT_DESTRUCTOR)) { log_rule("REMOVE"); return(IARF_REMOVE); } if ( language_is_set(LANG_OC) && first->Is(CT_CATCH) && second->Is(CT_SPAREN_OPEN) && (options::sp_oc_catch_paren() != IARF_IGNORE)) { // (OC) Add or remove space between '@catch' and '(' // in '@catch (something) { }'. If set to ignore, sp_catch_paren is used. log_rule("sp_oc_catch_paren"); return(options::sp_oc_catch_paren()); } if ( language_is_set(LANG_OC) && ( first->Is(CT_PAREN_CLOSE) || first->Is(CT_OC_CLASS) || first->Is(CT_WORD)) && second->Is(CT_ANGLE_OPEN) && ( second->GetParentType() == CT_OC_PROTO_LIST || second->GetParentType() == CT_OC_GENERIC_SPEC) && (options::sp_before_oc_proto_list() != IARF_IGNORE)) { // (OC) Add or remove space before Objective-C protocol list // as in '@protocol Protocol' or '@interface MyClass : NSObject'. log_rule("sp_before_oc_proto_list"); return(options::sp_before_oc_proto_list()); } if ( language_is_set(LANG_OC) && first->Is(CT_OC_CLASS) && second->Is(CT_PAREN_OPEN) && (options::sp_oc_classname_paren() != IARF_IGNORE)) { // (OC) Add or remove space between class name and '(' // in '@interface className(categoryName):BaseClass' log_rule("sp_oc_classname_paren"); return(options::sp_oc_classname_paren()); } if ( first->Is(CT_CATCH) && second->Is(CT_SPAREN_OPEN) && (options::sp_catch_paren() != IARF_IGNORE)) { // Add or remove space between 'catch' and '(' in 'catch (something) { }'. // If set to ignore, sp_before_sparen is used. log_rule("sp_catch_paren"); return(options::sp_catch_paren()); } if ( language_is_set(LANG_D) && first->Is(CT_D_VERSION_IF) && second->Is(CT_SPAREN_OPEN) && (options::sp_version_paren() != IARF_IGNORE)) { // (D) Add or remove space between 'version' and '(' // in 'version (something) { }'. If set to ignore, sp_before_sparen is used. log_rule("sp_version_paren"); return(options::sp_version_paren()); } if ( language_is_set(LANG_D) && first->Is(CT_D_SCOPE_IF) && second->Is(CT_SPAREN_OPEN) && (options::sp_scope_paren() != IARF_IGNORE)) { // (D) Add or remove space between 'scope' and '(' // in 'scope (something) { }'. If set to ignore, sp_before_sparen is used. log_rule("sp_scope_paren"); return(options::sp_scope_paren()); } if ( language_is_set(LANG_OC) && first->Is(CT_SYNCHRONIZED) && second->Is(CT_SPAREN_OPEN)) { // (OC) Add or remove space between '@synchronized' and the open parenthesis, // i.e. '@synchronized(foo)' vs. '@synchronized (foo)'. log_rule("sp_after_oc_synchronized"); return(options::sp_after_oc_synchronized()); } // "if (" vs. "if(" if (second->Is(CT_SPAREN_OPEN)) { // Add or remove space after 'do' between 'while' and '('. Issue #995 if ( first->Is(CT_WHILE_OF_DO) && options::sp_while_paren_open() != IARF_IGNORE) { log_rule("sp_while_paren_open"); return(options::sp_while_paren_open()); } // Add or remove space before '(' of other control statements ('if', 'for', // 'switch', 'while', etc.). log_rule("sp_before_sparen"); return(options::sp_before_sparen()); } if ( first->Is(CT_LAMBDA) || second->Is(CT_LAMBDA)) { // Add or remove space around assignment operator '=', '+=', etc. log_rule("sp_assign (lambda)"); return(options::sp_assign()); } // Handle the special lambda case for C++11: // [=](Something arg){.....} // Add or remove space around '=' in C++11 lambda capture specifications. // Overrides sp_assign. if ( (options::sp_cpp_lambda_assign() != IARF_IGNORE) && ( ( first->Is(CT_SQUARE_OPEN) && first->GetParentType() == CT_CPP_LAMBDA && second->Is(CT_ASSIGN)) || ( first->Is(CT_ASSIGN) && second->Is(CT_SQUARE_CLOSE) && second->GetParentType() == CT_CPP_LAMBDA))) { log_rule("sp_cpp_lambda_assign"); return(options::sp_cpp_lambda_assign()); } if ( first->Is(CT_SQUARE_CLOSE) && first->GetParentType() == CT_CPP_LAMBDA) { // Handle the special lambda case for C++11: // [](Something arg){.....} // Add or remove space after the capture specification of a C++11 lambda when // an argument list is present, as in '[] (int x){ ... }'. if (second->Is(CT_LPAREN_OPEN)) { log_rule("sp_cpp_lambda_square_paren"); return(options::sp_cpp_lambda_square_paren()); } else if (second->Is(CT_BRACE_OPEN)) { // Add or remove space after the capture specification of a C++11 lambda with // no argument list is present, as in '[] { ... }'. log_rule("sp_cpp_lambda_square_brace"); return(options::sp_cpp_lambda_square_brace()); } } if (first->Is(CT_LPAREN_OPEN)) { // Add or remove space after the opening parenthesis of a argument list // of a C++11 lambda, as in '[]( int x ){ ... }'. log_rule("sp_cpp_lambda_argument_list"); return(options::sp_cpp_lambda_argument_list()); } if (first->Is(CT_LPAREN_CLOSE)) { if (second->Is(CT_BRACE_OPEN)) { // Add or remove space after the argument list of a C++11 lambda, as in // '[](int x) { ... }'. log_rule("sp_cpp_lambda_paren_brace"); return(options::sp_cpp_lambda_paren_brace()); } } if (second->Is(CT_LPAREN_CLOSE)) { // Add or remove space before the closing parenthesis of a argument list // of a C++11 lambda, as in '[]( int x ){ ... }'. log_rule("sp_cpp_lambda_argument_list"); return(options::sp_cpp_lambda_argument_list()); } if ( first->Is(CT_BRACE_CLOSE) && first->GetParentType() == CT_CPP_LAMBDA && second->Is(CT_FPAREN_OPEN)) { // Add or remove space between a lambda body and its call operator of an // immediately invoked lambda, as in '[]( ... ){ ... } ( ... )'. log_rule("sp_cpp_lambda_fparen"); return(options::sp_cpp_lambda_fparen()); } if (first->Is(CT_ENUM)) { if (second->Is(CT_BRACE_OPEN)) { // Add or remove space in 'enum {'. log_rule("sp_enum_brace"); return(options::sp_enum_brace()); } else if (second->Is(CT_FPAREN_OPEN)) { // Add or remove space in 'NS_ENUM ('. log_rule("sp_enum_paren"); return(options::sp_enum_paren()); } } if (second->Is(CT_ASSIGN)) { if (second->TestFlags(PCF_IN_ENUM)) { // Add or remove space before assignment '=' in enum. // Overrides sp_enum_assign. if (options::sp_enum_before_assign() != IARF_IGNORE) { log_rule("sp_enum_before_assign"); return(options::sp_enum_before_assign()); } // Add or remove space around assignment '=' in enum. log_rule("sp_enum_assign"); return(options::sp_enum_assign()); } // Add or remove space around assignment operator '=' in a prototype. // If set to ignore, use sp_assign. if ( (options::sp_assign_default() != IARF_IGNORE) && second->GetParentType() == CT_FUNC_PROTO) { log_rule("sp_assign_default"); return(options::sp_assign_default()); } // Add or remove space before assignment operator '=', '+=', etc. // Overrides sp_assign. if (options::sp_before_assign() != IARF_IGNORE) { log_rule("sp_before_assign"); return(options::sp_before_assign()); } // Add or remove space around assignment operator '=', '+=', etc. log_rule("sp_assign"); return(options::sp_assign()); } if (second->Is(CT_ASSIGN_DEFAULT_ARG)) { // Add or remove space around assignment operator '=' in a prototype. // If set to ignore, use sp_assign. if ( (options::sp_assign_default() != IARF_IGNORE) && second->GetParentType() == CT_FUNC_PROTO) { log_rule("sp_assign_default"); return(options::sp_assign_default()); } // Add or remove space before assignment operator '=', '+=', etc. // Overrides sp_assign. if (options::sp_before_assign() != IARF_IGNORE) { log_rule("sp_before_assign"); return(options::sp_before_assign()); } // Add or remove space around assignment operator '=', '+=', etc. log_rule("sp_assign"); return(options::sp_assign()); } if (first->Is(CT_ASSIGN)) { if (first->TestFlags(PCF_IN_ENUM)) { // Add or remove space after assignment '=' in enum. // Overrides sp_enum_assign. if (options::sp_enum_after_assign() != IARF_IGNORE) { log_rule("sp_enum_after_assign"); return(options::sp_enum_after_assign()); } // Add or remove space around assignment '=' in enum. log_rule("sp_enum_assign"); return(options::sp_enum_assign()); } // Add or remove space around assignment operator '=' in a prototype. // If set to ignore, use sp_assign. if ( (options::sp_assign_default() != IARF_IGNORE) && first->GetParentType() == CT_FUNC_PROTO) { log_rule("sp_assign_default"); return(options::sp_assign_default()); } // Add or remove space after assignment operator '=', '+=', etc. // Overrides sp_assign. if (options::sp_after_assign() != IARF_IGNORE) { log_rule("sp_after_assign"); return(options::sp_after_assign()); } // Add or remove space around assignment operator '=', '+=', etc. log_rule("sp_assign"); return(options::sp_assign()); } if ( first->Is(CT_TRAILING_RET) || first->Is(CT_CPP_LAMBDA_RET) || second->Is(CT_TRAILING_RET) || second->Is(CT_CPP_LAMBDA_RET)) { // Add or remove space around trailing return operator '->'. log_rule("sp_trailing_return"); return(options::sp_trailing_return()); } if (first->Is(CT_ASSIGN_DEFAULT_ARG)) { // Add or remove space around assignment operator '=' in a prototype. // If set to ignore, use sp_assign. if ( (options::sp_assign_default() != IARF_IGNORE) && first->GetParentType() == CT_FUNC_PROTO) { log_rule("sp_assign_default"); return(options::sp_assign_default()); } // Add or remove space after assignment operator '=', '+=', etc. // Overrides sp_assign. if (options::sp_after_assign() != IARF_IGNORE) { log_rule("sp_after_assign"); return(options::sp_after_assign()); } // Add or remove space around assignment operator '=', '+=', etc. log_rule("sp_assign"); return(options::sp_assign()); } if (first->Is(CT_BIT_COLON)) { if ( first->TestFlags(PCF_IN_ENUM) || first->GetParentType() == CT_ENUM) { // Add or remove space around assignment ':' in enum. log_rule("sp_enum_colon"); return(options::sp_enum_colon()); } } if (second->Is(CT_BIT_COLON)) { if ( second->TestFlags(PCF_IN_ENUM) || second->GetParentType() == CT_ENUM) { // Add or remove space around assignment ':' in enum. log_rule("sp_enum_colon"); return(options::sp_enum_colon()); } } if ( first->Is(CT_OC_AVAILABLE_VALUE) || second->Is(CT_OC_AVAILABLE_VALUE)) { log_rule("IGNORE"); return(IARF_IGNORE); } if (language_is_set(LANG_OC)) { if (second->Is(CT_OC_BLOCK_CARET)) { // (OC) Add or remove space before a block pointer caret, // i.e. '^int (int arg){...}' vs. ' ^int (int arg){...}'. log_rule("sp_before_oc_block_caret"); return(options::sp_before_oc_block_caret()); } if (first->Is(CT_OC_BLOCK_CARET)) { // (OC) Add or remove space after a block pointer caret, // i.e. '^int (int arg){...}' vs. '^ int (int arg){...}'. log_rule("sp_after_oc_block_caret"); return(options::sp_after_oc_block_caret()); } if (second->Is(CT_OC_MSG_FUNC)) { if ( (options::sp_after_oc_msg_receiver() == IARF_REMOVE) && ( first->IsNot(CT_SQUARE_CLOSE) && first->IsNot(CT_FPAREN_CLOSE) && first->IsNot(CT_PAREN_CLOSE))) { log_rule("FORCE"); return(IARF_FORCE); } // (OC) Add or remove space between the receiver and selector in a message, // as in '[receiver selector ...]'. log_rule("sp_after_oc_msg_receiver"); return(options::sp_after_oc_msg_receiver()); } } // c++17 structured bindings e.g., "auto [x, y, z]" vs. a[x, y, z]" or "auto const [x, y, z]" vs. "auto const[x, y, z]" if ( language_is_set(LANG_CPP) && ( first->Is(CT_BYREF) || first->Is(CT_QUALIFIER) || first->Is(CT_TYPE)) && second->Is(CT_SQUARE_OPEN) && second->GetParentType() != CT_OC_MSG && second->GetParentType() != CT_CS_SQ_STMT) { // Add or remove space before C++17 structured bindings. log_rule("sp_cpp_before_struct_binding"); return(options::sp_cpp_before_struct_binding()); } // "a [x]" vs. "a[x]" if ( second->Is(CT_SQUARE_OPEN) && ( second->GetParentType() != CT_OC_MSG && second->GetParentType() != CT_CS_SQ_STMT && second->GetParentType() != CT_CPP_LAMBDA)) { if ( second->TestFlags(PCF_IN_SPAREN) && (first->Is(CT_IN))) { log_rule("FORCE"); return(IARF_FORCE); } if (first->Is(CT_ASM_COLON)) { // Add or remove space before '[' for asm block. log_rule("sp_before_square_asm_block"); return(options::sp_before_square_asm_block()); } if (first->TestFlags(PCF_VAR_DEF)) { // Add or remove space before '[' for a variable definition. log_rule("sp_before_vardef_square"); return(options::sp_before_vardef_square()); } // Add or remove space before '[' (except '[]'). log_rule("sp_before_square"); return(options::sp_before_square()); } // "byte[]" vs. "byte []" if (second->Is(CT_TSQUARE)) { // Add or remove space before '[]'. log_rule("sp_before_squares"); return(options::sp_before_squares()); } if ( (options::sp_angle_shift() != IARF_IGNORE) && first->Is(CT_ANGLE_CLOSE) && second->Is(CT_ANGLE_CLOSE)) { // Add or remove space between '>' and '>' in '>>' (template stuff). log_rule("sp_angle_shift"); return(options::sp_angle_shift()); } // spacing around template < > stuff if ( first->Is(CT_ANGLE_OPEN) || second->Is(CT_ANGLE_CLOSE)) { if ( first->Is(CT_ANGLE_OPEN) && second->Is(CT_ANGLE_CLOSE)) { // Add or remove space inside '<>'. log_rule("sp_inside_angle_empty"); return(options::sp_inside_angle_empty()); } // Add or remove space inside '<' and '>'. log_rule("sp_inside_angle"); iarf_e op = options::sp_inside_angle(); // special: if we're not supporting digraphs, then we shouldn't create them! if ( (op == IARF_REMOVE) && !options::enable_digraphs() && first->Is(CT_ANGLE_OPEN) && second->Is(CT_DC_MEMBER)) { op = IARF_IGNORE; } return(op); } if (second->Is(CT_ANGLE_OPEN)) { if ( first->Is(CT_TEMPLATE) && (options::sp_template_angle() != IARF_IGNORE)) { // Add or remove space between 'template' and '<'. // If set to ignore, sp_before_angle is used. log_rule("sp_template_angle"); return(options::sp_template_angle()); } if (first->IsNot(CT_QUALIFIER)) { // Add or remove space before '<'. log_rule("sp_before_angle"); return(options::sp_before_angle()); } } if (first->Is(CT_ANGLE_CLOSE)) { if ( second->Is(CT_WORD) || CharTable::IsKw1(second->GetStr()[0])) { // Add or remove space between '>' and a word as in 'List m;' or // 'template static ...'. log_rule("sp_angle_word"); return(options::sp_angle_word()); } if ( second->Is(CT_FPAREN_OPEN) || second->Is(CT_PAREN_OPEN)) { Chunk *next = second->GetNextNcNnl(); if (next->Is(CT_FPAREN_CLOSE)) { // Add or remove space between '>' and '()' as found in 'new List();'. log_rule("sp_angle_paren_empty"); return(options::sp_angle_paren_empty()); } // Add or remove space between '>' and '(' as found in 'new List(foo);'. log_rule("sp_angle_paren"); return(options::sp_angle_paren()); } if (second->Is(CT_DC_MEMBER)) { // Add or remove space before the '::' operator. log_rule("sp_before_dc"); return(options::sp_before_dc()); } if ( second->IsNot(CT_BYREF) && second->IsNot(CT_PTR_TYPE) && second->IsNot(CT_BRACE_OPEN) && second->IsNot(CT_PAREN_CLOSE)) { if ( second->Is(CT_CLASS_COLON) && options::sp_angle_colon() != IARF_IGNORE) { // Add or remove space between '>' and ':'. log_rule("sp_angle_colon"); return(options::sp_angle_colon()); } // Whether sp_after_angle takes precedence over sp_inside_fparen. This was the // historic behavior, but is probably not the desired behavior, so this is off // by default. if ( second->Is(CT_FPAREN_CLOSE) && options::sp_inside_fparen() != IARF_IGNORE && !options::use_sp_after_angle_always()) { // Add or remove space between '>' and ')'. log_rule("sp_inside_fparen"); return(options::sp_inside_fparen()); } // Add or remove space after '>'. log_rule("sp_after_angle"); return(options::sp_after_angle()); } } if (first->Is(CT_BYREF)) // see the tests cpp:34509-34512 { if (second->Is(CT_PAREN_OPEN)) { // Add or remove space after a reference sign '&', if followed by an open // parenthesis, as in 'char& (*)()'. log_rule("sp_byref_paren"); return(options::sp_byref_paren()); } else if ( first->GetParentType() == CT_FUNC_DEF // Issue #3197, #3210 || first->GetParentType() == CT_FUNC_PROTO) { // Add or remove space after a reference sign '&', if followed by a function // prototype or function definition. log_rule("sp_after_byref_func"); // byref 2 return(options::sp_after_byref_func()); } else if ( CharTable::IsKw1(second->GetStr()[0]) && ( options::sp_after_byref() != IARF_IGNORE || ( !second->Is(CT_FUNC_PROTO) && !second->Is(CT_FUNC_DEF)))) { // Add or remove space after reference sign '&', if followed by a word. log_rule("sp_after_byref"); // byref 1 return(options::sp_after_byref()); } } if ( second->Is(CT_BYREF) && !first->Is(CT_PAREN_OPEN)) // Issue #1804 { if ( second->GetParentType() == CT_FUNC_DEF // Issue #3197, #3210 || second->GetParentType() == CT_FUNC_PROTO) { // Add or remove space before a reference sign '&', if followed by a function // prototype or function definition. log_rule("sp_before_byref_func"); // byref 4 return(options::sp_before_byref_func()); } Chunk *next = second->GetNext(); if ( next->IsNotNullChunk() && ( next->Is(CT_COMMA) || next->Is(CT_PAREN_CLOSE) // Issue #3691 || next->Is(CT_FPAREN_CLOSE) || next->Is(CT_SEMICOLON))) { if (options::sp_before_unnamed_byref() != IARF_IGNORE) // Issue #3691 { // Add or remove space before a reference sign '&' that isn't followed by a // variable name. If set to 'ignore', sp_before_byref is used instead. log_rule("sp_before_unnamed_byref"); // byref 5 return(options::sp_before_unnamed_byref()); } else { // Add or remove space before a reference sign '&'. log_rule("sp_before_byref"); // byref 3 return(options::sp_before_byref()); } } // Add or remove space before a reference sign '&'. log_rule("sp_before_byref"); // byref 3 return(options::sp_before_byref()); } if (first->Is(CT_SPAREN_CLOSE)) { if (second->Is(CT_BRACE_OPEN)) { if (second->GetParentType() == CT_CATCH) { if ( language_is_set(LANG_OC) && (options::sp_oc_catch_brace() != IARF_IGNORE)) { // (OC) Add or remove space before the '{' of a '@catch' statement, if the '{' // and '@catch' are on the same line, as in '@catch (decl) {'. // If set to ignore, sp_catch_brace is used. // only to help the vim command }} log_rule("sp_oc_catch_brace"); return(options::sp_oc_catch_brace()); } if (options::sp_catch_brace() != IARF_IGNORE) { // Add or remove space before the '{' of a 'catch' statement, if the '{' and // 'catch' are on the same line, as in 'catch (decl) {'. log_rule("sp_catch_brace"); return(options::sp_catch_brace()); } } if (options::sp_sparen_brace() != IARF_IGNORE) { // Add or remove space between ')' and '{' of control statements. log_rule("sp_sparen_brace"); return(options::sp_sparen_brace()); } } if ( !second->IsComment() && (options::sp_after_sparen() != IARF_IGNORE)) { // Add or remove space after ')' of control statements. log_rule("sp_after_sparen"); return(options::sp_after_sparen()); } } if ( second->Is(CT_FPAREN_OPEN) && first->GetParentType() == CT_OPERATOR && (options::sp_after_operator_sym() != IARF_IGNORE)) { if ( (options::sp_after_operator_sym_empty() != IARF_IGNORE) && second->Is(CT_FPAREN_OPEN)) { Chunk *next = second->GetNextNcNnl(); if (next->Is(CT_FPAREN_CLOSE)) { // Overrides sp_after_operator_sym when the operator has no arguments, as in // 'operator *()'. log_rule("sp_after_operator_sym_empty"); return(options::sp_after_operator_sym_empty()); } } // Add or remove space between the operator symbol and the open parenthesis, as // in 'operator ++('. log_rule("sp_after_operator_sym"); return(options::sp_after_operator_sym()); } // Issue #2270 // Translations under vala if ( language_is_set(LANG_VALA) && first->Is(CT_FUNC_CALL)) { if ( first->IsString("_") && second->Is(CT_FPAREN_OPEN) && (options::sp_vala_after_translation() != IARF_IGNORE)) { // Add or remove space after '_'. log_rule("sp_vala_after_translation"); return(options::sp_vala_after_translation()); } } if ( first->Is(CT_MACRO_OPEN) || first->Is(CT_MACRO_CLOSE) || first->Is(CT_MACRO_ELSE)) { if (second->Is(CT_FPAREN_OPEN)) { // TODO: provide some test data to check this block // Add or remove space between function name and '(' on function calls. log_rule("sp_func_call_paren"); return(options::sp_func_call_paren()); } log_rule("IGNORE"); return(IARF_IGNORE); } // spaces between function and open paren if ( first->Is(CT_FUNC_CALL) || first->Is(CT_FUNCTION) // Issue #2665 || first->Is(CT_FUNC_CTOR_VAR) || first->Is(CT_CNG_HASINC) || first->Is(CT_CNG_HASINCN) || ( first->Is(CT_BRACE_CLOSE) && first->GetParentType() == CT_BRACED_INIT_LIST && second->Is(CT_FPAREN_OPEN)) || ( first->Is(CT_FUNC_VAR) // Issue #3852 && second->Is(CT_PAREN_OPEN))) { if ( (options::sp_func_call_paren_empty() != IARF_IGNORE) && second->Is(CT_FPAREN_OPEN)) { Chunk *next = second->GetNextNcNnl(); if (next->Is(CT_FPAREN_CLOSE)) { // Add or remove space between function name and '()' on function calls without // parameters. If set to 'ignore' (the default), sp_func_call_paren is used. log_rule("sp_func_call_paren_empty"); return(options::sp_func_call_paren_empty()); } } // Add or remove space between function name and '(' on function calls. log_rule("sp_func_call_paren"); return(options::sp_func_call_paren()); } if (first->Is(CT_FUNC_CALL_USER)) { // Add or remove space between the user function name and '(' on function // calls. You need to set a keyword to be a user function in the config file, // like: // set func_call_user tr _ i18n log_rule("sp_func_call_user_paren"); return(options::sp_func_call_user_paren()); } if ( first->Is(CT_ATTRIBUTE) && second->IsParenOpen()) { // Add or remove space between '__attribute__' and '('. log_rule("sp_attribute_paren"); return(options::sp_attribute_paren()); } if (first->Is(CT_FUNC_DEF)) { if ( (options::sp_func_def_paren_empty() != IARF_IGNORE) && second->Is(CT_FPAREN_OPEN)) { Chunk *next = second->GetNextNcNnl(); if (next->Is(CT_FPAREN_CLOSE)) { // Add or remove space between function name and '()' on function definition // without parameters. log_rule("sp_func_def_paren_empty"); return(options::sp_func_def_paren_empty()); } } // Add or remove space between function name and '(' on function definition. log_rule("sp_func_def_paren"); return(options::sp_func_def_paren()); } if ( first->Is(CT_CPP_CAST) || first->Is(CT_TYPE_WRAP)) { // Add or remove space between the type and open parenthesis in a C++ cast, // i.e. 'int(exp)' vs. 'int (exp)'. log_rule("sp_cpp_cast_paren"); return(options::sp_cpp_cast_paren()); } if ( first->Is(CT_SPAREN_CLOSE) && second->Is(CT_WHEN)) { // TODO: provide some test data to check this block log_rule("FORCE"); return(IARF_FORCE); // TODO: make this configurable? } if ( first->Is(CT_PAREN_CLOSE) && ( second->Is(CT_PAREN_OPEN) || second->Is(CT_FPAREN_OPEN))) { // "(int)a" vs. "(int) a" or "cast(int)a" vs. "cast(int) a" if ( first->GetParentType() == CT_C_CAST || first->GetParentType() == CT_D_CAST) { // Add or remove space after C/D cast, i.e. 'cast(int)a' vs. 'cast(int) a' or // '(int)a' vs. '(int) a'. log_rule("sp_after_cast"); return(options::sp_after_cast()); } // Probably a parenthesized indirect function call or similar (issue #3260) log_rule("sp_cparen_oparen"); return(options::sp_cparen_oparen()); } // handle the space between parens in fcn type 'void (*f)(void)' if (first->Is(CT_TPAREN_CLOSE)) { // Add or remove space between the ')' and '(' in a function type, as in // 'void (*x)(...)'. log_rule("sp_after_tparen_close"); return(options::sp_after_tparen_close()); } // ")(" vs. ") (" if ( ( first->IsString(")") && second->IsString("(")) || ( first->IsParenClose() && second->IsParenOpen())) { // Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('. log_rule("sp_cparen_oparen"); return(options::sp_cparen_oparen()); } if ( first->Is(CT_FUNC_PROTO) || ( second->Is(CT_FPAREN_OPEN) && second->GetParentType() == CT_FUNC_PROTO)) { if ( (options::sp_func_proto_paren_empty() != IARF_IGNORE) && second->Is(CT_FPAREN_OPEN)) { Chunk *next = second->GetNextNcNnl(); if (next->Is(CT_FPAREN_CLOSE)) { // Add or remove space between function name and '()' on function declaration // without parameters. log_rule("sp_func_proto_paren_empty"); return(options::sp_func_proto_paren_empty()); } } // Add or remove space between function name and '(' on function declaration. log_rule("sp_func_proto_paren"); return(options::sp_func_proto_paren()); } // Issue #2437 if ( first->Is(CT_FUNC_TYPE) && second->Is(CT_FPAREN_OPEN)) { // Add or remove space between function name and '(' with a typedef specifier. log_rule("sp_func_type_paren"); return(options::sp_func_type_paren()); } if ( first->Is(CT_FUNC_CLASS_DEF) || first->Is(CT_FUNC_CLASS_PROTO)) { if ( (options::sp_func_class_paren_empty() != IARF_IGNORE) && second->Is(CT_FPAREN_OPEN)) { Chunk *next = second->GetNextNcNnl(); if (next->Is(CT_FPAREN_CLOSE)) { // Add or remove space between a constructor without parameters or destructor // and '()'. log_rule("sp_func_class_paren_empty"); return(options::sp_func_class_paren_empty()); } } // Add or remove space between a constructor/destructor and the open // parenthesis. log_rule("sp_func_class_paren"); return(options::sp_func_class_paren()); } if ( first->Is(CT_CLASS) && !first->TestFlags(PCF_IN_OC_MSG)) { log_rule("FORCE"); return(IARF_FORCE); } if ( first->Is(CT_BRACE_OPEN) && second->Is(CT_BRACE_CLOSE)) { // Add or remove space inside '{}'. log_rule("sp_inside_braces_empty"); return(options::sp_inside_braces_empty()); } if ( ( first->Is(CT_TYPE) // Issue #2428 || first->Is(CT_ANGLE_CLOSE)) && second->Is(CT_BRACE_OPEN) && second->GetParentType() == CT_BRACED_INIT_LIST) { iarf_flags_t arg = iarf_flags_t{ options::sp_type_brace_init_lst() }; if ( arg != IARF_IGNORE || first->GetParentType() != CT_DECLTYPE) { // 'int{9}' vs. 'int {9}' // Add or remove space between type and open brace of an unnamed temporary // direct-list-initialization. log_rule("sp_type_brace_init_lst"); return(arg); } } if ( ( first->Is(CT_WORD) // Issue #2428 || first->Is(CT_SQUARE_CLOSE) || first->Is(CT_TSQUARE)) && second->Is(CT_BRACE_OPEN) && second->GetParentType() == CT_BRACED_INIT_LIST) { // Add or remove space between a variable and '{' for C++ uniform // initialization. auto arg = iarf_flags_t{ options::sp_word_brace_init_lst() }; if ( arg != IARF_IGNORE || first->GetParentType() != CT_DECLTYPE) { // 'a{9}' vs. 'a {9}' // Add or remove space between variable/word and open brace of an unnamed // temporary direct-list-initialization. log_rule("sp_word_brace_init_lst"); return(arg); } } if (second->Is(CT_BRACE_CLOSE)) { if (second->GetParentType() == CT_ENUM) { // Add or remove space inside enum '{' and '}'. log_rule("sp_inside_braces_enum"); return(options::sp_inside_braces_enum()); } if ( second->GetParentType() == CT_STRUCT || second->GetParentType() == CT_UNION) { // Fix for issue #1240 adding space in struct initializers Chunk *tmp = second->GetOpeningParen()->GetPrevNcNnl(); if (tmp->Is(CT_ASSIGN)) { // TODO: provide some test data to check this block log_rule("IGNORE"); return(IARF_IGNORE); } // Add or remove space inside struct/union '{' and '}'. log_rule("sp_inside_braces_struct"); return(options::sp_inside_braces_struct()); } else if ( language_is_set(LANG_OC) && second->GetParentType() == CT_OC_AT && options::sp_inside_braces_oc_dict() != IARF_IGNORE) { // (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}' log_rule("sp_inside_braces_oc_dict"); return(options::sp_inside_braces_oc_dict()); } if (second->GetParentType() == CT_BRACED_INIT_LIST) { // Add or remove space between nested braces, i.e. '{{' vs. '{ {'. // only to help the vim command }}}} if ( options::sp_brace_brace() != IARF_IGNORE && first->Is(CT_BRACE_CLOSE) && first->GetParentType() == CT_BRACED_INIT_LIST) { log_rule("sp_brace_brace"); return(options::sp_brace_brace()); } if (options::sp_before_type_brace_init_lst_close() != IARF_IGNORE) { // Add or remove space before close brace in an unnamed temporary // direct-list-initialization // if statement is a brace_init_lst // works only if sp_brace_brace is set to ignore. log_rule("sp_before_type_brace_init_lst_close"); return(options::sp_before_type_brace_init_lst_close()); } if (options::sp_inside_type_brace_init_lst() != IARF_IGNORE) { // Add or remove space inside an unnamed temporary direct-list-initialization. // if statement is a brace_init_lst // works only if sp_brace_brace is set to ignore // works only if sp_before_type_brace_init_lst_close is set to ignore. log_rule("sp_inside_type_brace_init_lst"); return(options::sp_inside_type_brace_init_lst()); } } // Add or remove space inside '{' and '}'. log_rule("sp_inside_braces"); return(options::sp_inside_braces()); } if (first->Is(CT_D_CAST)) { log_rule("REMOVE"); return(IARF_REMOVE); } if ( first->Is(CT_PP_DEFINED) && second->Is(CT_PAREN_OPEN)) { // Add or remove space between 'defined' and '(' in '#if defined (FOO)'. log_rule("sp_defined_paren"); return(options::sp_defined_paren()); } if (first->Is(CT_THROW)) { if (second->Is(CT_PAREN_OPEN)) { // Add or remove space between 'throw' and '(' in 'throw (something)'. log_rule("sp_throw_paren"); return(options::sp_throw_paren()); } // Add or remove space between 'throw' and anything other than '(' as in // '@throw [...];'. log_rule("sp_after_throw"); return(options::sp_after_throw()); } if ( first->Is(CT_THIS) && second->Is(CT_PAREN_OPEN)) { // Add or remove space between 'this' and '(' in 'this (something)'. log_rule("sp_this_paren"); return(options::sp_this_paren()); } if ( first->Is(CT_STATE) && second->Is(CT_PAREN_OPEN)) { log_rule("ADD"); return(IARF_ADD); } if ( first->Is(CT_DELEGATE) && second->Is(CT_PAREN_OPEN)) { log_rule("REMOVE"); return(IARF_REMOVE); } if ( first->Is(CT_MEMBER) || second->Is(CT_MEMBER)) { // Add or remove space around the '.' or '->' operators. log_rule("sp_member"); return(options::sp_member()); } if (first->Is(CT_C99_MEMBER)) { // always remove space(s) after then '.' of a C99-member log_rule("REMOVE"); return(IARF_REMOVE); } if ( first->Is(CT_SUPER) && second->Is(CT_PAREN_OPEN)) { // Add or remove space between 'super' and '(' in 'super (something)'. log_rule("sp_super_paren"); return(options::sp_super_paren()); } if ( first->Is(CT_FPAREN_CLOSE) && second->Is(CT_BRACE_OPEN)) { if ( language_is_set(LANG_JAVA) && second->GetParentType() == CT_DOUBLE_BRACE) { // (Java) Add or remove space between ')' and '{{' of double brace initializer. // only to help the vim command }} log_rule("sp_fparen_dbrace"); return(options::sp_fparen_dbrace()); } // To fix issue #1234 // check for initializers and add space or ignore based on the option. if (first->GetParentType() == CT_FUNC_CALL) { Chunk *tmp = first->GetPrevType(first->GetParentType(), first->GetLevel()); tmp = tmp->GetPrevNcNnl(); if (tmp->Is(CT_NEW)) { // Add or remove space between ')' and '{' of s function call in object // initialization. // Overrides sp_fparen_brace. log_rule("sp_fparen_brace_initializer"); return(options::sp_fparen_brace_initializer()); } } // Add or remove space between ')' and '{' of function. log_rule("sp_fparen_brace"); return(options::sp_fparen_brace()); } if ( first->Is(CT_D_TEMPLATE) || second->Is(CT_D_TEMPLATE)) { log_rule("REMOVE"); return(IARF_REMOVE); } if ( first->Is(CT_ELSE) && second->Is(CT_BRACE_OPEN)) { // Add or remove space between 'else' and '{' if on the same line. log_rule("sp_else_brace"); return(options::sp_else_brace()); } if ( first->Is(CT_ELSE) && second->Is(CT_ELSEIF)) { log_rule("FORCE"); return(IARF_FORCE); } if ( first->Is(CT_FINALLY) && second->Is(CT_BRACE_OPEN)) { // Add or remove space between 'finally' and '{' if on the same line. log_rule("sp_finally_brace"); return(options::sp_finally_brace()); } if ( first->Is(CT_TRY) && second->Is(CT_BRACE_OPEN)) { // Add or remove space between 'try' and '{' if on the same line. log_rule("sp_try_brace"); return(options::sp_try_brace()); } if ( first->Is(CT_GETSET) && second->Is(CT_BRACE_OPEN)) { // Add or remove space between get/set and '{' if on the same line. log_rule("sp_getset_brace"); return(options::sp_getset_brace()); } if ( first->Is(CT_WORD) && second->Is(CT_BRACE_OPEN)) { if (first->GetParentType() == CT_NAMESPACE) { // Add or remove space between a variable and '{' for a namespace. log_rule("sp_word_brace_ns"); return(options::sp_word_brace_ns()); } } if ( language_is_set(LANG_D) && second->Is(CT_PAREN_OPEN) && second->GetParentType() == CT_INVARIANT) { // (D) Add or remove space between 'invariant' and '('. log_rule("sp_invariant_paren"); return(options::sp_invariant_paren()); } if ( first->Is(CT_PAREN_CLOSE) && first->GetParentType() != CT_DECLTYPE) { if ( language_is_set(LANG_D) && first->GetParentType() == CT_INVARIANT) { // (D) Add or remove space after the ')' in 'invariant (C) c'. log_rule("sp_after_invariant_paren"); return(options::sp_after_invariant_paren()); } // "(struct foo) {...}" vs. "(struct foo){...}" if (second->Is(CT_BRACE_OPEN)) { // Add or remove space between ')' and '{'. log_rule("sp_paren_brace"); return(options::sp_paren_brace()); } // D-specific: "delegate(some thing) dg if (first->GetParentType() == CT_DELEGATE) { log_rule("ADD"); return(IARF_ADD); } // PAWN-specific: "state (condition) next" if (first->GetParentType() == CT_STATE) { log_rule("ADD"); return(IARF_ADD); } /* C++ new operator: new(bar) Foo */ if (first->GetParentType() == CT_NEW) { // Add or remove space between ')' and type in 'new(foo) BAR'. log_rule("sp_after_newop_paren"); return(options::sp_after_newop_paren()); } } /* "((" vs. "( (" or "))" vs. ") )" */ // Issue #1342 if ( ( first->IsString("(") && second->IsString("(")) || ( first->IsString(")") && second->IsString(")"))) { if (second->GetParentType() == CT_FUNC_CALL_USER) { // Add or remove space between nested parentheses with user functions, // i.e. '((' vs. '( ('. log_rule("sp_func_call_user_paren_paren"); return(options::sp_func_call_user_paren_paren()); } if ( options::sp_sparen_paren() != IARF_IGNORE && ( first->Is(CT_SPAREN_OPEN) || second->Is(CT_SPAREN_CLOSE))) { // Add or remove space between nested parentheses with control // statements, i.e. 'if ((' vs. 'if ( ('. Issue #3209 log_rule("sp_sparen_paren"); return(options::sp_sparen_paren()); } // Add or remove space between nested parentheses, i.e. '((' vs. ') )'. log_rule("sp_paren_paren"); return(options::sp_paren_paren()); } // "foo(...)" vs. "foo( ... )" if ( first->Is(CT_FPAREN_OPEN) || second->Is(CT_FPAREN_CLOSE)) { if ( (first->GetParentType() == CT_FUNC_CALL_USER) || ( (second->GetParentType() == CT_FUNC_CALL_USER) && ( (first->Is(CT_WORD)) || (first->Is(CT_SQUARE_CLOSE))))) { // Add or remove space inside user function '(' and ')'. log_rule("sp_func_call_user_inside_fparen"); return(options::sp_func_call_user_inside_fparen()); } if ( first->Is(CT_FPAREN_OPEN) && second->Is(CT_FPAREN_CLOSE)) { // Add or remove space inside empty function '()'. log_rule("sp_inside_fparens"); return(options::sp_inside_fparens()); } // Add or remove space inside function '(' and ')'. log_rule("sp_inside_fparen"); return(options::sp_inside_fparen()); } // "foo(...)" vs. "foo( ... )" if ( first->Is(CT_TPAREN_OPEN) || second->Is(CT_TPAREN_CLOSE)) { // Add or remove space inside the first parentheses in a function type, as in // 'void (*x)(...)'. log_rule("sp_inside_tparen"); return(options::sp_inside_tparen()); } if ( language_is_set(LANG_OC) && first->Is(CT_PAREN_CLOSE)) { if ( first->TestFlags(PCF_OC_RTYPE) // == CT_OC_RTYPE) && ( first->GetParentType() == CT_OC_MSG_DECL || first->GetParentType() == CT_OC_MSG_SPEC)) { // (OC) Add or remove space after the first (type) in message specs, // i.e. '-(int) f:(int)x;' vs. '-(int)f:(int)x;'. log_rule("sp_after_oc_return_type"); return(options::sp_after_oc_return_type()); } if ( first->GetParentType() == CT_OC_MSG_SPEC || first->GetParentType() == CT_OC_MSG_DECL) { // (OC) Add or remove space after the (type) in message specs, // i.e. '-(int)f: (int) x;' vs. '-(int)f: (int)x;'. log_rule("sp_after_oc_type"); return(options::sp_after_oc_type()); } if ( first->GetParentType() == CT_OC_SEL && second->IsNot(CT_SQUARE_CLOSE)) { // (OC) Add or remove space between '@selector(x)' and the following word, // i.e. '@selector(foo) a:' vs. '@selector(foo)a:'. log_rule("sp_after_oc_at_sel_parens"); return(options::sp_after_oc_at_sel_parens()); } } if ( language_is_set(LANG_OC) && options::sp_inside_oc_at_sel_parens() != IARF_IGNORE) { if ( ( first->Is(CT_PAREN_OPEN) && ( first->GetParentType() == CT_OC_SEL || first->GetParentType() == CT_OC_PROTOCOL)) || ( second->Is(CT_PAREN_CLOSE) && ( second->GetParentType() == CT_OC_SEL || second->GetParentType() == CT_OC_PROTOCOL))) { // (OC) Add or remove space inside '@selector' parentheses, // i.e. '@selector(foo)' vs. '@selector( foo )'. // Also applies to '@protocol()' constructs. log_rule("sp_inside_oc_at_sel_parens"); return(options::sp_inside_oc_at_sel_parens()); } } if ( second->Is(CT_PAREN_OPEN) && ( first->Is(CT_OC_SEL) || first->Is(CT_OC_PROTOCOL))) { // (OC) Add or remove space between '@selector' and '(', // i.e. '@selector(msgName)' vs. '@selector (msgName)'. // Also applies to '@protocol()' constructs. log_rule("sp_after_oc_at_sel"); return(options::sp_after_oc_at_sel()); } /* * C cast: "(int)" vs. "( int )" * D cast: "cast(int)" vs. "cast( int )" * CPP cast: "int(a + 3)" vs. "int( a + 3 )" */ if (first->Is(CT_PAREN_OPEN)) { if ( first->GetParentType() == CT_C_CAST || first->GetParentType() == CT_CPP_CAST || first->GetParentType() == CT_D_CAST) { // Add or remove spaces inside cast parentheses. log_rule("sp_inside_paren_cast"); return(options::sp_inside_paren_cast()); } if (first->GetParentType() == CT_NEW) { if (options::sp_inside_newop_paren_open() != IARF_IGNORE) { // Add or remove space after the open parenthesis of the new operator, // as in 'new(foo) BAR'. // Overrides sp_inside_newop_paren. log_rule("sp_inside_newop_paren_open"); return(options::sp_inside_newop_paren_open()); } if (options::sp_inside_newop_paren() != IARF_IGNORE) { // Add or remove space inside parentheses of the new operator // as in 'new(foo) BAR'. log_rule("sp_inside_newop_paren"); return(options::sp_inside_newop_paren()); } } log_rule("sp_inside_paren"); return(options::sp_inside_paren()); } if (second->Is(CT_PAREN_CLOSE)) { if ( second->GetParentType() == CT_C_CAST || second->GetParentType() == CT_CPP_CAST || second->GetParentType() == CT_D_CAST) { // Add or remove spaces inside cast parentheses. log_rule("sp_inside_paren_cast"); return(options::sp_inside_paren_cast()); } if (second->GetParentType() == CT_NEW) { if (options::sp_inside_newop_paren_close() != IARF_IGNORE) { // Add or remove space before the close parenthesis of the new operator, // as in 'new(foo) BAR'. // Overrides sp_inside_newop_paren. log_rule("sp_inside_newop_paren_close"); return(options::sp_inside_newop_paren_close()); } if (options::sp_inside_newop_paren() != IARF_IGNORE) { // Add or remove space inside parentheses of the new operator // as in 'new(foo) BAR'. log_rule("sp_inside_newop_paren"); return(options::sp_inside_newop_paren()); } } // Add or remove space inside '(' and ')'. log_rule("sp_inside_paren"); return(options::sp_inside_paren()); } if ( first->Is(CT_SQUARE_OPEN) && second->Is(CT_SQUARE_CLOSE)) { // Add or remove space inside '[]'. log_rule("sp_inside_square_empty"); return(options::sp_inside_square_empty()); } // "[3]" vs. "[ 3 ]" or for objective-c "@[@3]" vs. "@[ @3 ]" if ( first->Is(CT_SQUARE_OPEN) || second->Is(CT_SQUARE_CLOSE)) { if ( language_is_set(LANG_OC) && ( ( first->GetParentType() == CT_OC_AT && first->Is(CT_SQUARE_OPEN)) || ( second->GetParentType() == CT_OC_AT && second->Is(CT_SQUARE_CLOSE))) && (options::sp_inside_square_oc_array() != IARF_IGNORE)) { // (OC) Add or remove space inside a non-empty Objective-C boxed array '@[' and // ']'. If set to ignore, sp_inside_square is used. log_rule("sp_inside_square_oc_array"); return(options::sp_inside_square_oc_array()); } // Add or remove space inside a non-empty '[' and ']'. log_rule("sp_inside_square"); return(options::sp_inside_square()); } if ( first->Is(CT_SQUARE_CLOSE) && second->Is(CT_FPAREN_OPEN)) { // Add or remove space between ']' and '(' when part of a function call. log_rule("sp_square_fparen"); return(options::sp_square_fparen()); } // "if(...)" vs. "if( ... )" etc. if (second->Is(CT_SPAREN_CLOSE)) { if ( second->GetParentType() == CT_FOR && options::sp_inside_for_open() != IARF_IGNORE) { // Add or remove space before ')' of 'for' statements. // Overrides sp_inside_for. log_rule("sp_inside_for_close"); return(options::sp_inside_for_close()); } else if (options::sp_inside_sparen_open() != IARF_IGNORE) { // Add or remove space before ')' of other control statements. // Overrides sp_inside_sparen. log_rule("sp_inside_sparen_close"); return(options::sp_inside_sparen_close()); } } if (first->Is(CT_SPAREN_OPEN)) { if ( first->GetParentType() == CT_FOR && options::sp_inside_for_open() != IARF_IGNORE) { // Add or remove space before ')' of 'for' statements. // Overrides sp_inside_for. log_rule("sp_inside_for_close"); return(options::sp_inside_for_close()); } else if (options::sp_inside_sparen_open() != IARF_IGNORE) { // Add or remove space after '(' of other control statements. // Overrides sp_inside_sparen. log_rule("sp_inside_sparen_open"); return(options::sp_inside_sparen_open()); } } if (first->Is(CT_SPAREN_OPEN)) { if (first->GetParentType() == CT_FOR) { // Add or remove space inside '(' and ')' of 'for' statements. log_rule("sp_inside_for"); return(options::sp_inside_for()); } else { // Add or remove space inside '(' and ')' of other control statements. log_rule("sp_inside_sparen"); return(options::sp_inside_sparen()); } } if (second->Is(CT_SPAREN_CLOSE)) { if (second->GetParentType() == CT_FOR) { // Add or remove space inside '(' and ')' of 'for' statements. log_rule("sp_inside_for"); return(options::sp_inside_for()); } else { // Add or remove space inside '(' and ')' of other control statements. log_rule("sp_inside_sparen"); return(options::sp_inside_sparen()); } } if (first->Is(CT_CLASS_COLON)) { if ( first->GetParentType() == CT_OC_CLASS && ( first->GetPrevType(CT_OC_INTF, first->GetLevel(), E_Scope::ALL)->IsNullChunk() && first->GetPrevType(CT_OC_IMPL, first->GetLevel(), E_Scope::ALL)->IsNullChunk())) { if (options::sp_after_oc_colon() != IARF_IGNORE) { // TODO: provide some test data to check this block // (OC) Add or remove space after the colon in message specs, // i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'. log_rule("sp_after_oc_colon"); return(options::sp_after_oc_colon()); } } if (options::sp_after_class_colon() != IARF_IGNORE) { // Add or remove space after class ':'. log_rule("sp_after_class_colon"); return(options::sp_after_class_colon()); } } if (second->Is(CT_CLASS_COLON)) { if ( language_is_set(LANG_OC) && second->GetParentType() == CT_OC_CLASS && ( second->GetPrevType(CT_OC_INTF, second->GetLevel(), E_Scope::ALL)->IsNullChunk() && second->GetPrevType(CT_OC_IMPL, second->GetLevel(), E_Scope::ALL)->IsNullChunk())) { if ( second->GetParentType() == CT_OC_CLASS && second->GetPrevType(CT_OC_INTF, second->GetLevel(), E_Scope::ALL)->IsNullChunk()) { if (options::sp_before_oc_colon() != IARF_IGNORE) { // TODO: provide some test data to check this block // (OC) Add or remove space before the colon in message specs, // i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'. log_rule("sp_before_oc_colon"); return(options::sp_before_oc_colon()); } } } if (options::sp_before_class_colon() != IARF_IGNORE) { // Add or remove space before class ':'. log_rule("sp_before_class_colon"); return(options::sp_before_class_colon()); } } if (first->Is(CT_CONSTR_COLON)) { min_sp = options::indent_ctor_init_leading() - 1; // default indent is 1 space // Add or remove space after class constructor ':'. log_rule("sp_after_constr_colon"); return(options::sp_after_constr_colon()); } if (second->Is(CT_CONSTR_COLON)) { // Add or remove space before class constructor ':'. log_rule("sp_before_constr_colon"); return(options::sp_before_constr_colon()); } if (second->Is(CT_CASE_COLON)) { // Add or remove space before case ':'. log_rule("sp_before_case_colon"); return(options::sp_before_case_colon()); } if (first->Is(CT_DOT)) { log_rule("REMOVE"); return(IARF_REMOVE); } if (second->Is(CT_DOT)) { log_rule("ADD"); return(IARF_ADD); } if ( first->Is(CT_NULLCOND) || second->Is(CT_NULLCOND)) { // TODO: provide some test data to check this block // LANG_CS null conditional operator // Add or remove space around the '.' or '->' operators. log_rule("sp_member"); return(options::sp_member()); } if ( first->Is(CT_ARITH) || first->Is(CT_SHIFT) || first->Is(CT_CARET) || second->Is(CT_ARITH) || second->Is(CT_SHIFT) || second->Is(CT_CARET)) { // Add or remove space around arithmetic operators '+' and '-'. // Overrides sp_arith. if (options::sp_arith_additive() != IARF_IGNORE) { auto arith_char = ( first->Is(CT_ARITH) || first->Is(CT_SHIFT) || first->Is(CT_CARET)) ? first->GetStr()[0] : second->GetStr()[0]; if ( arith_char == '+' || arith_char == '-') { log_rule("sp_arith_additive"); return(options::sp_arith_additive()); } } // Add or remove space around non-assignment symbolic operators ('+', '/', '%', // '<<', and so forth). log_rule("sp_arith"); return(options::sp_arith()); } if ( first->Is(CT_BOOL) || second->Is(CT_BOOL)) { // Add or remove space around boolean operators '&&' and '||'. iarf_e arg = options::sp_bool(); if ( (options::pos_bool() != TP_IGNORE) && first->GetOrigLine() != second->GetOrigLine()) { arg = arg | IARF_ADD; } log_rule("sp_bool"); return(arg); } if ( first->Is(CT_COMPARE) || second->Is(CT_COMPARE)) { // Add or remove space around compare operator '<', '>', '==', etc. log_rule("sp_compare"); return(options::sp_compare()); } if ( first->Is(CT_PAREN_OPEN) && second->Is(CT_PTR_TYPE)) { // TODO: provide some test data to check this block log_rule("REMOVE"); return(IARF_REMOVE); } if (first->Is(CT_PTR_TYPE)) // see the tests cpp:34505-34508 { if ( second->Is(CT_FPAREN_OPEN) || second->Is(CT_TPAREN_OPEN)) { // Add or remove space after a pointer star '*', if followed by an open // parenthesis, as in 'void* (*)()'. log_rule("sp_ptr_star_paren"); // ptr_star 10 return(options::sp_ptr_star_paren()); } else if (second->Is(CT_PTR_TYPE)) { // Add or remove space between pointer stars '*'. // as in 'int ***a;'. log_rule("sp_between_ptr_star"); // ptr_star 9 return(options::sp_between_ptr_star()); } else if (second->Is(CT_FUNC_VAR)) { // Add or remove space between the pointer star '*' and the name of the // variable in a function pointer definition. log_rule("sp_ptr_star_func_var"); return(options::sp_ptr_star_func_var()); } else if (second->Is(CT_FUNC_TYPE)) { // Add or remove space between the pointer star '*' and the name of the // type in a function pointer type definition. log_rule("sp_ptr_star_func_type"); return(options::sp_ptr_star_func_type()); } else if ( first->GetParentType() == CT_FUNC_DEF || first->GetParentType() == CT_FUNC_PROTO || first->GetParentType() == CT_FUNC_VAR) { if (token_is_within_trailing_return(first)) { // Add or remove space after a pointer star '*', in the trailing return // a function prototype or function definition. log_rule("sp_after_ptr_star_trailing"); // ptr_star 3 return(options::sp_after_ptr_star_trailing()); } else { // Add or remove space after a pointer star '*', if followed by a function // prototype or function definition. log_rule("sp_after_ptr_star_func"); // ptr_star 2 return(options::sp_after_ptr_star_func()); } } else if (CharTable::IsKw1(second->GetStr()[0])) { Chunk *prev = first->GetPrev(); if (prev->Is(CT_IN)) { // Add or remove space after the '*' (dereference) unary operator. This does // not affect the spacing after a '*' that is part of a type. log_rule("sp_deref"); return(options::sp_deref()); } else if ( first->GetParentType() == CT_FUNC_VAR || first->GetParentType() == CT_FUNC_TYPE) { // Add or remove space after pointer caret '^', if followed by a word. log_rule("sp_after_ptr_block_caret"); return(options::sp_after_ptr_block_caret()); } else if (second->Is(CT_QUALIFIER)) { // Add or remove space after pointer star '*', if followed by a qualifier. log_rule("sp_after_ptr_star_qualifier"); // ptr_star 4 return(options::sp_after_ptr_star_qualifier()); } // Add or remove space after pointer star '*', if followed by a word. log_rule("sp_after_ptr_star"); // ptr_star 1 return(options::sp_after_ptr_star()); } else if (second->Is(CT_PAREN_OPEN)) { // Add or remove space after pointer star '*', if followed by a word. log_rule("sp_after_ptr_star"); // ptr_star 1 return(options::sp_after_ptr_star()); } // must be placed at the end of the block // look back for '->' type is TRAILING_RET if (token_is_within_trailing_return(first)) { log_rule("sp_after_ptr_star_trailing"); // ptr_star 3 return(options::sp_after_ptr_star_trailing()); } } if ( second->Is(CT_PTR_TYPE) && first->IsNot(CT_IN)) { // look back for '->' type is TRAILING_RET if (token_is_within_trailing_return(second)) { log_rule("sp_before_ptr_star_trailing"); // ptr_star 7 return(options::sp_before_ptr_star_trailing()); } // Add or remove space before a pointer star '*', if followed by a function // prototype or function definition. if (options::sp_before_ptr_star_func() != IARF_IGNORE) { // Find the next non-'*' chunk Chunk *next = second; do { next = next->GetNext(); } while (next->Is(CT_PTR_TYPE)); if ( next->Is(CT_FUNC_DEF) || next->Is(CT_FUNC_PROTO)) { log_rule("sp_before_ptr_star_func"); // ptr_star 6 return(options::sp_before_ptr_star_func()); } } // Add or remove space before pointer star '*' that isn't followed by a // variable name. If set to 'ignore', sp_before_ptr_star is used instead. if (options::sp_before_unnamed_ptr_star() != IARF_IGNORE) { Chunk *next = second->GetNextNc(); while (next->Is(CT_PTR_TYPE)) { next = next->GetNextNc(); } if ( next->IsNotNullChunk() && next->IsNot(CT_WORD)) { log_rule("sp_before_unnamed_ptr_star"); // ptr_star 8 return(options::sp_before_unnamed_ptr_star()); } } // Add or remove space before pointer star '*'. if (options::sp_before_ptr_star() != IARF_IGNORE) { log_rule("sp_before_ptr_star"); // ptr_star 5 return(options::sp_before_ptr_star()); } } if (first->Is(CT_OPERATOR)) { // Add or remove space between 'operator' and operator sign. log_rule("sp_after_operator"); return(options::sp_after_operator()); } if ( second->Is(CT_FUNC_PROTO) || second->Is(CT_FUNC_DEF)) { if ( first->IsNot(CT_PTR_TYPE) && first->IsNot(CT_BYREF)) { // Add or remove space between return type and function name. A // minimum of 1 is forced except for pointer/reference return types. log_rule("sp_type_func | ADD"); return(options::sp_type_func() | IARF_ADD); } // Add or remove space between return type and function name. A // minimum of 1 is forced except for pointer/reference return types. log_rule("sp_type_func"); return(options::sp_type_func()); } // "(int)a" vs. "(int) a" or "cast(int)a" vs. "cast(int) a" if ( ( first->GetParentType() == CT_C_CAST || first->GetParentType() == CT_D_CAST) && first->Is(CT_PAREN_CLOSE)) { log_rule("sp_after_cast"); return(options::sp_after_cast()); } if (first->Is(CT_BRACE_CLOSE)) { if (second->Is(CT_ELSE)) { // Add or remove space between '}' and 'else' if on the same line. log_rule("sp_brace_else"); return(options::sp_brace_else()); } if ( language_is_set(LANG_OC) && second->Is(CT_CATCH) && (options::sp_oc_brace_catch() != IARF_IGNORE)) { // TODO: provide some test data to check this block // (OC) Add or remove space between '}' and '@catch' if on the same line. // If set to ignore, sp_brace_catch is used. log_rule("sp_oc_brace_catch"); return(options::sp_oc_brace_catch()); } if (second->Is(CT_CATCH)) { // TODO: provide some test data to check this block // Add or remove space between '}' and 'catch' if on the same line. log_rule("sp_brace_catch"); return(options::sp_brace_catch()); } if (second->Is(CT_FINALLY)) { // Add or remove space between '}' and 'finally' if on the same line. log_rule("sp_brace_finally"); return(options::sp_brace_finally()); } } if (first->Is(CT_BRACE_OPEN)) { if (first->GetParentType() == CT_ENUM) { // Add or remove space inside enum '{' and '}'. log_rule("sp_inside_braces_enum"); return(options::sp_inside_braces_enum()); } if ( first->GetParentType() == CT_STRUCT || first->GetParentType() == CT_UNION) { // Fix for issue #1240 adding space in struct initializers Chunk *tmp = first->GetPrevNcNnl(); if (tmp->Is(CT_ASSIGN)) { // TODO: provide some test data to check this block log_rule("IGNORE"); return(IARF_IGNORE); } // Add or remove space inside struct/union '{' and '}'. log_rule("sp_inside_braces_struct"); return(options::sp_inside_braces_struct()); } else if ( first->GetParentType() == CT_OC_AT && options::sp_inside_braces_oc_dict() != IARF_IGNORE) { // (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}' log_rule("sp_inside_braces_oc_dict"); return(options::sp_inside_braces_oc_dict()); } if (first->GetParentType() == CT_BRACED_INIT_LIST) { // Add or remove space between nested braces, i.e. '{{' vs. '{ {'. // only to help the vim command }}}} if ( options::sp_brace_brace() != IARF_IGNORE && second->Is(CT_BRACE_OPEN) && second->GetParentType() == CT_BRACED_INIT_LIST) { log_rule("sp_brace_brace"); return(options::sp_brace_brace()); } if (options::sp_after_type_brace_init_lst_open() != IARF_IGNORE) { // Add or remove space after open brace in an unnamed temporary // direct-list-initialization // if statement is a brace_init_lst // works only if sp_brace_brace is set to ignore. log_rule("sp_after_type_brace_init_lst_open"); return(options::sp_after_type_brace_init_lst_open()); } if (options::sp_inside_type_brace_init_lst() != IARF_IGNORE) { // Add or remove space inside an unnamed temporary direct-list-initialization // if statement is a brace_init_lst // works only if sp_brace_brace is set to ignore // works only if sp_after_type_brace_init_lst_close is set to ignore. log_rule("sp_inside_type_brace_init_lst"); return(options::sp_inside_type_brace_init_lst()); } } if (!second->IsComment()) { // Add or remove space inside '{' and '}'. log_rule("sp_inside_braces"); return(options::sp_inside_braces()); } } if ( first->Is(CT_BRACE_CLOSE) && first->TestFlags(PCF_IN_TYPEDEF) && ( first->GetParentType() == CT_ENUM || first->GetParentType() == CT_STRUCT || first->GetParentType() == CT_UNION)) { // Add or remove space between '}' and the name of a typedef on the same line. log_rule("sp_brace_typedef"); return(options::sp_brace_typedef()); } if ( language_is_set(LANG_D) && second->Is(CT_PAREN_OPEN) && second->GetParentType() == CT_TEMPLATE) { // (D) Add or remove space before the parenthesis in the D constructs // 'template Foo(' and 'class Foo('. log_rule("sp_before_template_paren"); return(options::sp_before_template_paren()); } // Issue #3080 if ( first->Is(CT_PAREN_CLOSE) && first->GetParentType() == CT_DECLTYPE && ( second->Is(CT_WORD) || second->Is(CT_BRACE_OPEN) || second->Is(CT_FUNC_CALL))) { iarf_e arg = options::sp_after_decltype(); // Add or remove space between 'decltype(...)' and word, brace or function call. log_rule("sp_after_decltype"); return(arg); } // Issue #3080 if ( !language_is_set(LANG_D) && first->Is(CT_PAREN_CLOSE) && second->Is(CT_WORD)) { // Add or remove space between type and word. log_rule("sp_after_type"); return(options::sp_after_type()); } // see if the D template expression is used as a type if ( language_is_set(LANG_D) && first->Is(CT_PAREN_CLOSE) && first->GetParentType() == CT_D_TEMPLATE) { if (second->GetParentType() == CT_USING_ALIAS) { log_rule("sp_after_type | ADD"); return(options::sp_after_type() | IARF_ADD); } if (second->Is(CT_WORD)) { Chunk *open_paren = first->GetOpeningParen(); Chunk *type = open_paren->GetPrev()->GetPrev(); if (type->Is(CT_TYPE)) { log_rule("sp_after_type"); return(options::sp_after_type()); } } } if ( first->Is(CT_TYPE) // Issue #3457 && second->Is(CT_COLON)) { log_rule("sp_type_colon"); return(options::sp_type_colon()); } if ( !second->Is(CT_PTR_TYPE) && ( first->Is(CT_QUALIFIER) || first->Is(CT_TYPE))) { // Add or remove space between type and word. In cases where total removal of // whitespace would be a syntax error, a value of 'remove' is treated the same // as 'force'. // // This also affects some other instances of space following a type that are // not covered by other options; for example, between the return type and // parenthesis of a function type template argument, between the type and // parenthesis of an array parameter, or between 'decltype(...)' and the // following word. iarf_e arg = options::sp_after_type(); log_rule("sp_after_type"); return(arg); } if ( first->Is(CT_PTR_TYPE) && second->Is(CT_ELLIPSIS)) { log_rule("sp_ptr_type_ellipsis"); return(options::sp_ptr_type_ellipsis()); } // If nothing claimed the PTR_TYPE, then return ignore if ( first->Is(CT_PTR_TYPE) || second->Is(CT_PTR_TYPE)) { log_rule("IGNORE"); return(IARF_IGNORE); } if (first->Is(CT_NOT)) { if ( second->Is(CT_NOT) && (options::sp_not_not() != IARF_IGNORE)) { log_rule("sp_not_not"); return(options::sp_not_not()); } // Add or remove space after the '!' (not) unary operator. log_rule("sp_not"); return(options::sp_not()); } if (first->Is(CT_INV)) { // Add or remove space after the '~' (invert) unary operator. log_rule("sp_inv"); return(options::sp_inv()); } if (first->Is(CT_ADDR)) { // Add or remove space after the '&' (address-of) unary operator. This does not // affect the spacing after a '&' that is part of a type. log_rule("sp_addr"); return(options::sp_addr()); } if (first->Is(CT_DEREF)) { // Add or remove space after the '*' (dereference) unary operator. This does // not affect the spacing after a '*' that is part of a type. log_rule("sp_deref"); return(options::sp_deref()); } if ( first->Is(CT_POS) || first->Is(CT_NEG)) { // Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. log_rule("sp_sign"); return(options::sp_sign()); } if ( first->Is(CT_INCDEC_BEFORE) || second->Is(CT_INCDEC_AFTER)) { // Add or remove space between '++' and '--' the word to which it is being // applied, as in '(--x)' or 'y++;'. log_rule("sp_incdec"); return(options::sp_incdec()); } if (second->Is(CT_CS_SQ_COLON)) { log_rule("REMOVE"); return(IARF_REMOVE); } if (first->Is(CT_CS_SQ_COLON)) { log_rule("FORCE"); return(IARF_FORCE); } if ( language_is_set(LANG_OC) && first->Is(CT_OC_SCOPE)) { // (OC) Add or remove space after the scope '+' or '-', as in '-(void) foo;' // or '+(int) bar;'. log_rule("sp_after_oc_scope"); return(options::sp_after_oc_scope()); } if ( language_is_set(LANG_OC) && first->Is(CT_OC_DICT_COLON)) { // (OC) Add or remove space after the colon in immutable dictionary expression // 'NSDictionary *test = @{@"foo" :@"bar"};'. log_rule("sp_after_oc_dict_colon"); return(options::sp_after_oc_dict_colon()); } if ( language_is_set(LANG_OC) && second->Is(CT_OC_DICT_COLON)) { // (OC) Add or remove space before the colon in immutable dictionary expression // 'NSDictionary *test = @{@"foo" :@"bar"};'. log_rule("sp_before_oc_dict_colon"); return(options::sp_before_oc_dict_colon()); } if ( language_is_set(LANG_OC) && first->Is(CT_OC_COLON)) { if (first->TestFlags(PCF_IN_OC_MSG)) { // (OC) Add or remove space after the colon in message specs, // i.e. '[object setValue:1];' vs. '[object setValue: 1];'. log_rule("sp_after_send_oc_colon"); return(options::sp_after_send_oc_colon()); } // (OC) Add or remove space after the colon in message specs, // i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'. log_rule("sp_after_oc_colon"); return(options::sp_after_oc_colon()); } if ( language_is_set(LANG_OC) && second->Is(CT_OC_COLON)) { if ( first->TestFlags(PCF_IN_OC_MSG) && ( first->Is(CT_OC_MSG_FUNC) || first->Is(CT_OC_MSG_NAME))) { // (OC) Add or remove space before the colon in message specs, // i.e. '[object setValue:1];' vs. '[object setValue :1];'. log_rule("sp_before_send_oc_colon"); return(options::sp_before_send_oc_colon()); } // (OC) Add or remove space before the colon in message specs, // i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'. log_rule("sp_before_oc_colon"); return(options::sp_before_oc_colon()); } if ( second->Is(CT_COMMENT) && second->GetParentType() == CT_COMMENT_EMBED) { // Add or remove space before an embedded comment. // Number of spaces before an embedded comment. log_rule("sp_before_emb_cmt"); min_sp = options::sp_num_before_emb_cmt(); return(options::sp_before_emb_cmt()); } if (first->Is(CT_COMMENT)) { // Add or remove space after an embedded comment. // Number of spaces after an embedded comment. log_rule("sp_after_emb_cmt"); min_sp = options::sp_num_after_emb_cmt(); return(options::sp_after_emb_cmt()); } if ( first->Is(CT_NEW) && second->Is(CT_PAREN_OPEN)) { // c# new Constraint, c++ new operator // Add or remove space between 'new' and '(' in 'new()'. log_rule("sp_between_new_paren"); return(options::sp_between_new_paren()); } if ( first->Is(CT_NEW) || first->Is(CT_DELETE) || ( first->Is(CT_TSQUARE) && first->GetParentType() == CT_DELETE)) { // Add or remove space after 'new', 'delete' and 'delete[]'. log_rule("sp_after_new"); return(options::sp_after_new()); } if ( language_is_set(LANG_JAVA) && first->Is(CT_ANNOTATION) && second->IsParenOpen()) { // (Java) Add or remove space between an annotation and the open parenthesis. log_rule("sp_annotation_paren"); return(options::sp_annotation_paren()); } if ( language_is_set(LANG_OC) && first->Is(CT_OC_PROPERTY)) { // (OC) Add or remove space after '@property'. log_rule("sp_after_oc_property"); return(options::sp_after_oc_property()); } if ( language_is_set(LANG_D) && first->Is(CT_EXTERN) && second->Is(CT_PAREN_OPEN)) { // (D) Add or remove space between 'extern' and '(' as in 'extern (C)'. log_rule("sp_extern_paren"); return(options::sp_extern_paren()); } if ( second->Is(CT_TYPE) && ( ( first->Is(CT_STRING) && first->GetParentType() == CT_EXTERN) || ( first->Is(CT_FPAREN_CLOSE) && first->GetParentType() == CT_ATTRIBUTE))) { log_rule("FORCE"); return(IARF_FORCE); /* TODO: make this configurable? */ } if (first->Is(CT_NOEXCEPT)) { // Add or remove space after 'noexcept'. log_rule("sp_after_noexcept"); return(options::sp_after_noexcept()); } // Issue #2138 if (first->Is(CT_FPAREN_CLOSE)) { if (second->Is(CT_QUALIFIER)) { // Add or remove space between ')' and a qualifier such as 'const'. log_rule("sp_paren_qualifier"); return(options::sp_paren_qualifier()); } else if (second->Is(CT_NOEXCEPT)) { // Add or remove space between ')' and 'noexcept'. log_rule("sp_paren_noexcept"); return(options::sp_paren_noexcept()); } } // Issue #2098 if ( first->Is(CT_PP_PRAGMA) && second->Is(CT_PREPROC_BODY)) { log_rule("REMOVE"); return(IARF_REMOVE); } // Issue #1733 if ( first->Is(CT_OPERATOR_VAL) && second->Is(CT_TYPE)) { log_rule("IGNORE"); return(IARF_IGNORE); } // Issue #995 if ( first->Is(CT_DO) && second->Is(CT_BRACE_OPEN)) { // Add or remove space between 'do' and '{'. log_rule("sp_do_brace_open"); return(options::sp_do_brace_open()); } // Issue #995 if ( first->Is(CT_BRACE_CLOSE) && second->Is(CT_WHILE_OF_DO)) { // Add or remove space between '}' and 'while. log_rule("sp_brace_close_while"); return(options::sp_brace_close_while()); } // TODO: have a look to Issue #2186, why NEWLINE? // Issue #2524 if ( first->Is(CT_NEWLINE) && second->Is(CT_BRACE_OPEN)) { log_rule("IGNORE"); return(IARF_IGNORE); } // ============================================================= // category 1 // this table lists out all combos where a space should NOT be present // CT_UNKNOWN is a wildcard. for (auto it : no_space_table) { if ( ( it.first == CT_UNKNOWN || it.first == first->GetType()) && ( it.second == CT_UNKNOWN || it.second == second->GetType())) { log_rule("REMOVE from no_space_table"); return(IARF_REMOVE); } } // ============================================================= // category 2 // this table lists out all combos where a space MUST be present for (auto it : add_space_table) { if ( it.first == first->GetType() && it.second == second->GetType()) { // TODO: if necessary create a new option log_rule("ADD from add_space_table"); return(IARF_ADD); } } // Issue #2386 if ( first->Is(CT_FORM_FEED) || second->Is(CT_FORM_FEED)) { log_rule("IGNORE"); return(IARF_IGNORE); } // TODO: if necessary create a new option if ( first->Is(CT_MACRO_FUNC_CALL) && second->Is(CT_FPAREN_OPEN)) { log_rule("IGNORE"); return(IARF_IGNORE); } if ( first->Is(CT_CASE_ELLIPSIS) && second->Is(CT_NUMBER)) { // Add or remove space after the variadic '...' when preceded by a // non-punctuator. // The value REMOVE will be overridden with FORCE if (options::sp_after_ellipsis() == IARF_REMOVE) { log_rule("sp_after_ellipsis/FORCE"); return(IARF_FORCE); } else { log_rule("sp_after_ellipsis"); return(options::sp_after_ellipsis()); } } if ( first->Is(CT_NUMBER) && second->Is(CT_CASE_ELLIPSIS)) { // Add or remove space before the variadic '...' when preceded by a // non-punctuator. // The value REMOVE will be overridden with FORCE if (options::sp_before_ellipsis() == IARF_REMOVE) { log_rule("sp_before_ellipsis/FORCE"); return(IARF_FORCE); } else { log_rule("sp_before_ellipsis"); return(options::sp_before_ellipsis()); } } // ============================================================= // category 3 // these lines are only useful for debugging uncrustify itself LOG_FMT(LSPACE, "\n\n%s(%d): WARNING: unrecognize do_space:\n", __func__, __LINE__); LOG_FMT(LSPACE, " first orig line is %zu, orig col is %zu, Text() '%s', GetType() is %s\n", first->GetOrigLine(), first->GetOrigCol(), first->Text(), get_token_name(first->GetType())); LOG_FMT(LSPACE, " second orig line is %zu, orig col is %zu, Text() '%s', GetType() is %s\n", second->GetOrigLine(), second->GetOrigCol(), second->Text(), get_token_name(second->GetType())); LOG_FMT(LSPACE, " Please make a call at https://github.com/uncrustify/uncrustify/issues/new\n"); LOG_FMT(LSPACE, " or merge the line:\n"); LOG_FMT(LSPACE, " { CT_%s, CT_%s},\n", get_token_name(first->GetType()), get_token_name(second->GetType())); LOG_FMT(LSPACE, " in the file /src/add_space_table.h\n"); log_rule("ADD as default value"); return(IARF_ADD); } // do_space static iarf_e ensure_force_space(Chunk *first, Chunk *second, iarf_e av) { if (first->TestFlags(PCF_FORCE_SPACE)) { LOG_FMT(LSPACE, "%s(%d): \n", __func__, __LINE__, first->Text(), second->Text()); return(av | IARF_ADD); } return(av); } static iarf_e do_space_ensured(Chunk *first, Chunk *second, int &min_sp) { iarf_e aa = ensure_force_space(first, second, do_space(first, second, min_sp)); return(aa); } void space_text() { LOG_FUNC_ENTRY(); Chunk *pc = Chunk::GetHead(); Chunk *next; size_t prev_column; size_t column = pc->GetColumn(); while (pc->IsNotNullChunk()) { if (pc->Is(CT_NEWLINE)) { LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, , nl is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetNlCount()); } else { char copy[1000]; LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, '%s' type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy), get_token_name(pc->GetType())); } if ( (options::use_options_overriding_for_qt_macros()) && ( (strcmp(pc->Text(), "SIGNAL") == 0) || (strcmp(pc->Text(), "SLOT") == 0))) { LOG_FMT(LSPACE, "%s(%d): orig col is %zu, type is %s SIGNAL/SLOT found\n", __func__, __LINE__, pc->GetOrigLine(), get_token_name(pc->GetType())); pc->SetFlagBits(PCF_IN_QT_MACRO); // flag the chunk for a second processing // save the values save_set_options_for_QT(pc->GetLevel()); } // Bug # 637 // If true, vbrace tokens are dropped to the previous token and skipped. if (options::sp_skip_vbrace_tokens()) { next = pc->GetNext(); while ( next->IsEmptyText() && !next->IsNewline() && next->IsVBrace()) { LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, Skip %s (%zu+%zu)\n", __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), get_token_name(next->GetType()), pc->GetColumn(), pc->GetStr().size()); next->SetColumn(pc->GetColumn() + pc->GetStr().size()); next = next->GetNext(); } } else { next = pc->GetNext(); } if (next->IsNullChunk()) { break; } // Issue # 481 // Whether to balance spaces inside nested parentheses. if ( QT_SIGNAL_SLOT_found && options::sp_balance_nested_parens()) { Chunk *nn = next->GetNext(); // Issue #2734 if ( nn->IsNotNullChunk() && nn->Is(CT_SPACE)) { Chunk::Delete(nn); // remove the space } } /* * If the current chunk contains a newline, do not change the column * of the next item */ if ( pc->IsNewline() || pc->Is(CT_COMMENT_MULTI)) { column = next->GetColumn(); } else { // Set to the minimum allowed column if (pc->GetNlCount() == 0) { column += pc->Len(); } else { column = pc->GetOrigColEnd(); } prev_column = column; /* * Apply a general safety check * If the two chunks combined will tokenize differently, then we * must force a space. * Two chunks -- "()" and "[]" will always tokenize differently. * They are always safe to not have a space after them. */ pc->ResetFlagBits(PCF_FORCE_SPACE); if ( (pc->Len() > 0) && !pc->IsString("[]") && !pc->IsString("{{") && !pc->IsString("}}") && !pc->IsString("()") && !pc->GetStr().startswith("@\"")) { // Find the next non-empty chunk on this line Chunk *tmp = next; while ( tmp->IsNotNullChunk() && (tmp->Len() == 0) && !tmp->IsNewline()) { tmp = tmp->GetNext(); } if ( tmp->IsNotNullChunk() && tmp->Len() > 0) { bool kw1 = CharTable::IsKw2(pc->GetStr()[pc->Len() - 1]); bool kw2 = CharTable::IsKw1(next->GetStr()[0]); if ( kw1 && kw2) { // back-to-back words need a space LOG_FMT(LSPACE, "%s(%d): back-to-back words need a space: pc->Text() '%s', next->Text() '%s'\n", __func__, __LINE__, pc->Text(), next->Text()); pc->SetFlagBits(PCF_FORCE_SPACE); } // TODO: what is the meaning of 4 else if ( !kw1 && !kw2 && (pc->Len() < 4) && (next->Len() < 4)) { // We aren't dealing with keywords. concat and try punctuators char buf[9]; memcpy(buf, pc->Text(), pc->Len()); memcpy(buf + pc->Len(), next->Text(), next->Len()); buf[pc->Len() + next->Len()] = 0; const chunk_tag_t *ct; ct = find_punctuator(buf, cpd.lang_flags); if ( ct != nullptr && (strlen(ct->tag) != pc->Len())) { // punctuator parsed to a different size.. /* * C++11 allows '>>' to mean '> >' in templates: * some_func>(); */ // (C++11) Permit removal of the space between '>>' in 'foo >'. Note // that sp_angle_shift cannot remove the space without this option. if ( ( ( language_is_set(LANG_CPP) && options::sp_permit_cpp11_shift()) || (language_is_set(LANG_JAVA | LANG_CS | LANG_VALA | LANG_OC))) && pc->Is(CT_ANGLE_CLOSE) && next->Is(CT_ANGLE_CLOSE)) { // allow '>' and '>' to become '>>' } else if (strcmp(ct->tag, "[]") == 0) { // this is OK } else { LOG_FMT(LSPACE, "%s(%d): : pc->Text() is %s, next->Text() is %s\n", __func__, __LINE__, pc->Text(), next->Text()); pc->SetFlagBits(PCF_FORCE_SPACE); } } } } } int min_sp; LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, pc-Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); iarf_e av = do_space_ensured(pc, next, min_sp); min_sp = max(1, min_sp); switch (av) { case IARF_FORCE: column += min_sp; // add exactly the specified number of spaces break; case IARF_ADD: { int delta = min_sp; if ( next->GetOrigCol() >= pc->GetOrigColEnd() && pc->GetOrigColEnd() != 0) { // Keep the same relative spacing, minimum 1 delta = next->GetOrigCol() - pc->GetOrigColEnd(); if (delta < min_sp) { delta = min_sp; } } column += delta; break; } case IARF_REMOVE: // the symbols will be back-to-back "a+3" break; case IARF_IGNORE: // Keep the same relative spacing, if possible if ( next->GetOrigCol() >= pc->GetOrigColEnd() && pc->GetOrigColEnd() != 0) { column += next->GetOrigCol() - pc->GetOrigColEnd(); } else { // preserve the position if virtual brace // Issue #1854 if (pc->Is(CT_VBRACE_OPEN)) { column = next->GetOrigCol(); } } break; default: // If we got here, something is wrong... break; } // switch if ( next->IsComment() && next->GetNext()->IsNewline() && column < next->GetOrigCol()) { /* * do some comment adjustments if sp_before_tr_cmt and sp_endif_cmt * did not apply. */ // Add or remove space between #else or #endif and a trailing comment. if ( ( options::sp_before_tr_cmt() == IARF_IGNORE || next->GetParentType() != CT_COMMENT_END) && ( options::sp_endif_cmt() == IARF_IGNORE || ( pc->IsNot(CT_PP_ELSE) && pc->IsNot(CT_PP_ENDIF)))) { if (options::indent_relative_single_line_comments()) { // Try to keep relative spacing between tokens LOG_FMT(LSPACE, "%s(%d): ", __func__, __LINE__); LOG_FMT(LSPACE, "%s(%d): pc is '%s', orig col is %zu, next orig col is %zu, pc orig col end is %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigCol(), next->GetOrigCol(), pc->GetOrigColEnd()); column = pc->GetColumn() + (next->GetOrigCol() - pc->GetOrigColEnd()); } else { /* * If there was a space, we need to force one, otherwise * try to keep the comment in the same column. */ size_t col_min = pc->GetColumn() + pc->Len() + ((next->GetOrigPrevSp() > 0) ? 1 : 0); column = next->GetOrigCol(); if (column < col_min) { column = col_min; } LOG_FMT(LSPACE, "%s(%d): ", __func__, __LINE__); } } } next->SetColumn(column); LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, pc-Text() '%s', type is %s\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); LOG_FMT(LSPACE, "%s(%d): ", __func__, __LINE__); LOG_FMT(LSPACE, " rule = %s @ %zu => %zu\n", (av == IARF_IGNORE) ? "IGNORE" : (av == IARF_ADD) ? "ADD" : (av == IARF_REMOVE) ? "REMOVE" : "FORCE", column - prev_column, next->GetColumn()); if (restoreValues) // guy 2015-09-22 { restore_options_for_QT(); } } pc = next; if (QT_SIGNAL_SLOT_found) { // flag the chunk for a second processing pc->SetFlagBits(PCF_IN_QT_MACRO); } } } // space_text void space_text_balance_nested_parens() { LOG_FUNC_ENTRY(); Chunk *first = Chunk::GetHead(); while (first->IsNotNullChunk()) { Chunk *next = first->GetNext(); if (next->IsNullChunk()) { break; } // if there are two successive opening parenthesis if ( first->IsString("(") && next->IsString("(")) { // insert a space between them space_add_after(first, 1); // test after the closing parens Issue #1703 Chunk *closing = first->GetNextType((E_Token)(first->GetType() + 1), first->GetLevel()); if (closing->GetOrigCol() == closing->GetPrev()->GetOrigColEnd()) { space_add_after(closing->GetPrev(), 1); } } else if ( first->IsString(")") && next->IsString(")")) { // insert a space between the two closing parens space_add_after(first, 1); // test after the opening parens Issue #1703 Chunk *opening = next->GetPrevType((E_Token)(next->GetType() - 1), next->GetLevel()); if (opening->GetOrigColEnd() == opening->GetNext()->GetOrigCol()) { space_add_after(opening, 1); } } first = next; } } // space_text_balance_nested_parens size_t space_needed(Chunk *first, Chunk *second) { LOG_FUNC_ENTRY(); LOG_FMT(LSPACE, "%s(%d)\n", __func__, __LINE__); int min_sp; switch (do_space_ensured(first, second, min_sp)) { case IARF_ADD: case IARF_FORCE: return(max(1, min_sp)); case IARF_REMOVE: return(0); case IARF_IGNORE: default: return(second->GetOrigCol() > (first->GetOrigCol() + first->Len())); } } size_t space_col_align(Chunk *first, Chunk *second) { LOG_FUNC_ENTRY(); LOG_FMT(LSPACE, "%s(%d): first orig line is %zu, orig col is %zu, [%s/%s], Text() '%s' <==>\n", __func__, __LINE__, first->GetOrigLine(), first->GetOrigCol(), get_token_name(first->GetType()), get_token_name(first->GetParentType()), first->Text()); LOG_FMT(LSPACE, "%s(%d): second orig line is %zu, orig col is %zu [%s/%s], Text() '%s',", __func__, __LINE__, second->GetOrigLine(), second->GetOrigCol(), get_token_name(second->GetType()), get_token_name(second->GetParentType()), second->Text()); log_func_stack_inline(LSPACE); int min_sp; iarf_e av = do_space_ensured(first, second, min_sp); LOG_FMT(LSPACE, "%s(%d): av is %s\n", __func__, __LINE__, to_string(av)); size_t coldiff; if (first->GetNlCount()) { LOG_FMT(LSPACE, "%s(%d): new line count is %zu, orig col end is %zu\n", __func__, __LINE__, first->GetNlCount(), first->GetOrigColEnd()); coldiff = first->GetOrigColEnd() - 1; } else { LOG_FMT(LSPACE, "%s(%d): Len is %zu\n", __func__, __LINE__, first->Len()); coldiff = first->Len(); } LOG_FMT(LSPACE, "%s(%d): => coldiff is %zu\n", __func__, __LINE__, coldiff); LOG_FMT(LSPACE, "%s(%d): => av is %s\n", __func__, __LINE__, (av == IARF_IGNORE) ? "IGNORE" : (av == IARF_ADD) ? "ADD" : (av == IARF_REMOVE) ? "REMOVE" : "FORCE"); switch (av) { case IARF_ADD: case IARF_FORCE: coldiff++; break; case IARF_REMOVE: break; case IARF_IGNORE: // Issue #2064 LOG_FMT(LSPACE, "%s(%d): => first orig line is %zu\n", __func__, __LINE__, first->GetOrigLine()); LOG_FMT(LSPACE, "%s(%d): => second orig line is %zu\n", __func__, __LINE__, second->GetOrigLine()); LOG_FMT(LSPACE, "%s(%d): => first Text() is '%s'\n", __func__, __LINE__, first->Text()); LOG_FMT(LSPACE, "%s(%d): => second Text() is '%s'\n", __func__, __LINE__, second->Text()); LOG_FMT(LSPACE, "%s(%d): => first orig col is %zu\n", __func__, __LINE__, first->GetOrigCol()); LOG_FMT(LSPACE, "%s(%d): => second orig col is %zu\n", __func__, __LINE__, second->GetOrigCol()); LOG_FMT(LSPACE, "%s(%d): => first Len() is %zu\n", __func__, __LINE__, first->Len()); if ( first->GetOrigLine() == second->GetOrigLine() && second->GetOrigCol() > (first->GetOrigCol() + first->Len())) { coldiff++; } break; default: // If we got here, something is wrong... break; } LOG_FMT(LSPACE, "%s(%d): => coldiff is %zu\n", __func__, __LINE__, coldiff); return(coldiff); } // space_col_align void space_add_after(Chunk *pc, size_t count) { LOG_FUNC_ENTRY(); Chunk *next = pc->GetNext(); // don't add at the end of the file or before a newline if ( next->IsNullChunk() || next->IsNewline()) { return; } // Limit to 16 spaces if (count > 16) { count = 16; } // Two CT_SPACE in a row -- use the max of the two if (next->Is(CT_SPACE)) { if (next->Len() < count) { while (next->Len() < count) { next->Str().append(' '); } } return; } Chunk sp; sp.SetType(CT_SPACE); sp.SetFlags(pc->GetFlags() & PCF_COPY_FLAGS); sp.Str() = " "; // 16 spaces sp.Str().resize(count); sp.SetLevel(pc->GetLevel()); sp.SetBraceLevel(pc->GetBraceLevel()); sp.SetPpLevel(pc->GetPpLevel()); sp.SetColumn(pc->GetColumn() + pc->Len()); sp.SetOrigLine(pc->GetOrigLine()); sp.SetOrigCol(pc->GetOrigCol()); sp.CopyAndAddAfter(pc); } // space_add_after uncrustify-uncrustify-0.76.0/src/space.h000066400000000000000000000017731434072136500203000ustar00rootroot00000000000000/** * @file space.h * prototypes for space.cpp * * @author Ben Gardner * @license GPL v2+ */ #ifndef SPACE_H_INCLUDED #define SPACE_H_INCLUDED #include "uncrustify_types.h" /** * Marches through the whole file and checks to see how many spaces should be * between two chunks */ void space_text(); //! Marches through the whole file and adds spaces around nested parenthesis void space_text_balance_nested_parens(); //! Determines if a space is required between two chunks size_t space_needed(Chunk *first, Chunk *second); /** * Calculates the column difference between two chunks. * The rules are bent a bit here, as IARF_IGNORE and IARF_ADD become IARF_FORCE. * So the column difference is either first->len or first->len + 1. * * @param first The first chunk * @param second The second chunk * * @return the column difference between the two chunks */ size_t space_col_align(Chunk *first, Chunk *second); void space_add_after(Chunk *pc, size_t count); #endif /* SPACE_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/symbols_table.h000066400000000000000000000236051434072136500220420ustar00rootroot00000000000000/** * @file symbols * Manages the table of punctuators. * * @author Ben Gardner * @license GPL v2+ */ /** * * Content of the generated "punctuator_table.h" file is based off this. * * NOTE: the tables below do not need to be sorted. */ #include "uncrustify_types.h" // 6-char symbols static const chunk_tag_t symbols6[] = { { R"_(??(??))_", CT_TSQUARE, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph [] { R"_(??!??!)_", CT_BOOL, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph || { R"_(??=??=)_", CT_PP, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph ## }; /* 5-char symbols */ static const chunk_tag_t symbols5[] = { { R"_(??!=)_", CT_ASSIGN, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph |= { R"_(??'=)_", CT_ASSIGN, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph ^= { R"_(??=@)_", CT_POUND, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph #@ MS extension }; /* 4-char symbols */ static const chunk_tag_t symbols4[] = { { "!<>=", CT_COMPARE, LANG_D }, { ">>>=", CT_ASSIGN, LANG_D | LANG_JAVA | LANG_PAWN }, { R"_(<::>)_", CT_TSQUARE, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // digraph [] { R"_(%:%:)_", CT_PP, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // digraph ## }; // 3-char symbols static const chunk_tag_t symbols3[] = { { "!<=", CT_COMPARE, LANG_D }, { "!<>", CT_COMPARE, LANG_D }, { "!==", CT_COMPARE, LANG_D | LANG_ECMA }, { "!>=", CT_COMPARE, LANG_D }, { "<=>", CT_COMPARE, LANG_CPP }, { "->*", CT_MEMBER, LANG_C | LANG_CPP | LANG_OC | LANG_D }, { "...", CT_ELLIPSIS, LANG_C | LANG_CPP | LANG_OC | LANG_D | LANG_PAWN | LANG_JAVA }, { "<<=", CT_ASSIGN, LANG_ALL }, { "<>=", CT_COMPARE, LANG_D }, { "===", CT_COMPARE, LANG_D | LANG_ECMA }, { ">>=", CT_ASSIGN, LANG_ALL }, { ">>>", CT_ARITH, LANG_D | LANG_JAVA | LANG_PAWN | LANG_ECMA }, { "%:@", CT_POUND, LANG_C | LANG_CPP | LANG_OC }, // digraph #@ MS extension { R"_(??=)_", CT_POUND, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph # { R"_(??=)_", CT_COMPARE, LANG_CS }, // cs: Null-Coalescing Assignment Operator { R"_(??()_", CT_SQUARE_OPEN, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph [ { R"_(??))_", CT_SQUARE_CLOSE, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph ] { R"_(??')_", CT_CARET, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph ^ { R"_(??<)_", CT_BRACE_OPEN, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph { { R"_(??>)_", CT_BRACE_CLOSE, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph } { R"_(??-)_", CT_INV, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph ~ { R"_(??!)_", CT_ARITH, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph | }; // { R"_(??/)_", CT_UNKNOWN, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // trigraph '\' // 2-char symbols static const chunk_tag_t symbols2[] = { { "!<", CT_COMPARE, LANG_D }, // 0 { "!=", CT_COMPARE, LANG_ALL }, // 1 { "!>", CT_COMPARE, LANG_D }, // 2 { "!~", CT_COMPARE, LANG_D }, // 3 { "##", CT_PP, LANG_C | LANG_CPP | LANG_OC }, // 4 { "#@", CT_POUND, LANG_C | LANG_CPP | LANG_OC }, // MS extension { "%=", CT_ASSIGN, LANG_ALL }, // 6 { "&&", CT_BOOL, LANG_ALL }, // 7 { "&=", CT_ASSIGN, LANG_ALL }, // 8 { "*=", CT_ASSIGN, LANG_ALL }, // 9 { "++", CT_INCDEC_AFTER, LANG_ALL }, // 10 { "+=", CT_ASSIGN, LANG_ALL }, // 11 { "--", CT_INCDEC_AFTER, LANG_ALL }, // 12 { "-=", CT_ASSIGN, LANG_ALL }, // 13 { "->", CT_MEMBER, LANG_ALLC }, // 14 { ".*", CT_MEMBER, LANG_C | LANG_CPP | LANG_OC | LANG_D }, // 15 { "..", CT_RANGE, LANG_D }, // 16 { "?.", CT_NULLCOND, LANG_CS }, // null conditional operator { "/=", CT_ASSIGN, LANG_ALL }, // 18 { "::", CT_DC_MEMBER, LANG_ALLC }, // 19 { "<<", CT_SHIFT, LANG_ALL }, // 20 { "<=", CT_COMPARE, LANG_ALL }, // 21 { "<>", CT_COMPARE, LANG_D }, // 22 { "==", CT_COMPARE, LANG_ALL }, // 23 { ">=", CT_COMPARE, LANG_ALL }, // 24 { ">>", CT_SHIFT, LANG_ALL }, // 25 { "[]", CT_TSQUARE, LANG_ALL }, // 26 { "^=", CT_ASSIGN, LANG_ALL }, // 27 { "|=", CT_ASSIGN, LANG_ALL }, // 28 { "||", CT_BOOL, LANG_ALL }, // 29 { "~=", CT_COMPARE, LANG_D }, // 30 { "~~", CT_COMPARE, LANG_D }, // 31 { "=>", CT_LAMBDA, LANG_VALA | LANG_CS | LANG_D }, // 32 { "??", CT_COMPARE, LANG_CS | LANG_VALA }, // 33 { R"_(<%)_", CT_BRACE_OPEN, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // digraph { { R"_(%>)_", CT_BRACE_CLOSE, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // digraph } { R"_(<:)_", CT_SQUARE_OPEN, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // digraph [ { R"_(:>)_", CT_SQUARE_CLOSE, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // digraph ] { R"_(%:)_", CT_POUND, LANG_C | LANG_CPP | LANG_OC | FLAG_DIG }, // digraph # }; // *INDENT-OFF* // 1-char symbols static const chunk_tag_t symbols1[] = { { R"_( )_", CT_FORM_FEED, LANG_ALL }, { "!", CT_NOT, LANG_ALL }, { "#", CT_POUND, LANG_ALL & ~(LANG_JAVA | LANG_ECMA) }, { "$", CT_COMPARE, LANG_D }, { "%", CT_ARITH, LANG_ALL }, { "&", CT_AMP, LANG_ALL }, { "(", CT_PAREN_OPEN, LANG_ALL }, { ")", CT_PAREN_CLOSE, LANG_ALL }, { "*", CT_STAR, LANG_ALL }, { "+", CT_PLUS, LANG_ALL }, { ",", CT_COMMA, LANG_ALL }, { "-", CT_MINUS, LANG_ALL }, { ".", CT_DOT, LANG_ALL }, { "/", CT_ARITH, LANG_ALL }, { ":", CT_COLON, LANG_ALL }, { ";", CT_SEMICOLON, LANG_ALL }, { "<", CT_ANGLE_OPEN, LANG_ALL }, { "=", CT_ASSIGN, LANG_ALL }, { ">", CT_ANGLE_CLOSE, LANG_ALL }, { "@", CT_OC_AT, LANG_OC }, { "?", CT_QUESTION, LANG_ALL }, { "[", CT_SQUARE_OPEN, LANG_ALL }, { "]", CT_SQUARE_CLOSE, LANG_ALL }, { "^", CT_CARET, LANG_ALL }, { "{", CT_BRACE_OPEN, LANG_ALL }, { "|", CT_ARITH, LANG_ALL }, { "}", CT_BRACE_CLOSE, LANG_ALL }, { "~", CT_INV, LANG_ALL }, }; // *INDENT-ON* uncrustify-uncrustify-0.76.0/src/token_enum.h000066400000000000000000000353221434072136500213460ustar00rootroot00000000000000/** * @file token_enum.h * List of the different tokens used in the program. * * @author Ben Gardner * @author Guy Maurel since version 0.62 for uncrustify4Qt * October 2015 * @license GPL v2+ */ #ifndef TOKEN_ENUM_H_INCLUDED #define TOKEN_ENUM_H_INCLUDED /** * abbreviations used: * CT = chunk type */ /** * This is an enum of all the different chunks/tokens/elements that the * program can work with. The parser and scanner assigns one of these to * each chunk/token. */ enum E_Token { CT_NONE, CT_PARENT_NOT_SET, CT_EOF, CT_UNKNOWN, CT_JUNK, // junk collected when parsing is disabled CT_WHITESPACE, // whitespace without any newlines CT_SPACE, // a fixed number of spaces to support weird spacing rules CT_NEWLINE, // CRA, one or more newlines CT_NL_CONT, // CRA, backslash-newline CT_FORM_FEED, // character 12 CT_COMMENT_CPP, // C++ comment (always followed by CT_NEWLINE) CT_COMMENT, // C-comment, single line CT_COMMENT_MULTI, // Multi-lined comment CT_COMMENT_EMBED, // comment parent_type: non-newline before and after CT_COMMENT_START, // comment parent_type: newline before CT_COMMENT_END, // comment parent_type: newline after CT_COMMENT_WHOLE, // comment parent_type: newline before and after CT_COMMENT_ENDIF, // C-comment, single line, after ENDIF CT_IGNORED, // a chunk of ignored text CT_WORD, // variable, type, function name, etc CT_NUMBER, CT_NUMBER_FP, CT_STRING, // quoted string "hi" or 'a' or for include CT_STRING_MULTI, // quoted string with embedded newline CT_IF, // built-in keywords CT_ELSE, CT_ELSEIF, CT_CONSTEXPR, // only when preceded by 'if' (otherwise CT_QUALIFIER) CT_FOR, CT_WHILE, CT_WHILE_OF_DO, CT_SWITCH, CT_CASE, CT_DO, CT_SYNCHRONIZED, CT_VOLATILE, CT_TYPEDEF, CT_STRUCT, CT_ENUM, CT_ENUM_CLASS, CT_SIZEOF, CT_DECLTYPE, CT_RETURN, CT_BREAK, CT_UNION, CT_GOTO, CT_CONTINUE, CT_C_CAST, // C-style cast: "(int)5.6" CT_CPP_CAST, // C++-style cast: "int(5.6)" CT_D_CAST, // D-style cast: "cast(type)" and "const(type)" CT_TYPE_CAST, // static_cast(exp) CT_TYPENAME, // typename type CT_TEMPLATE, // template<...> CT_PARAMETER_PACK, // template CT_WHERE_SPEC, // 'where' : used in C# generic constraint CT_ASSIGN, // =, +=, /=, etc CT_ASSIGN_NL, // Assign followed by a newline - fake item for indenting CT_SASSIGN, // 'and_eq' CT_ASSIGN_DEFAULT_ARG, // Default argument such as // Foo( int Foo = 5 ); CT_ASSIGN_FUNC_PROTO, // function prototype modifier such as // void* operator new(std::size_t) = delete; // Foo( const Foo & ) = default; // Foo( const Foo & ) = 0; CT_COMPARE, // ==, !=, <=, >= CT_SCOMPARE, // compare op that is a string 'is', 'neq' CT_BOOL, // || or && CT_SBOOL, // or, and CT_ARITH, // +, -, /, etc CT_SARITH, // 'not', 'xor' CT_SHIFT, // <<, >> CT_CARET, // ^ CT_DEREF, // * dereference CT_INCDEC_BEFORE, // ++a or --a CT_INCDEC_AFTER, // a++ or a-- CT_MEMBER, // . or -> CT_DC_MEMBER, // :: CT_C99_MEMBER, // . in structure stuff CT_INV, // ~ CT_DESTRUCTOR, // ~ CT_NOT, // ! CT_D_TEMPLATE, // ! as in Foo!(A) CT_ADDR, // & CT_NEG, // - as in -1 CT_POS, // + as in +1 CT_STAR, // * : raw char to be changed CT_PLUS, // + : raw char to be changed CT_MINUS, // - : raw char to be changed CT_AMP, // & : raw char to be changed CT_BYREF, // & in function def/proto params // CT_BITWISE_AND, // & // is a CT_ARITH // CT_BITWISE_OR, // | // is a CT_ARITH // CT_BITWISE_EXCLUSIVE_OR,// ^ // is a CT_ARITH // CT_BITWISE_NOT, // ~ // is a CT_ARITH CT_POUND, // # CT_PREPROC, // # at the start of a line CT_PREPROC_INDENT, // # at the start of a line that gets indented: #region CT_PREPROC_BODY, // body of every preproc EXCEPT #define CT_PP, // ## CT_ELLIPSIS, // ... CT_RANGE, // .. CT_NULLCOND, // ?. CT_SEMICOLON, CT_VSEMICOLON, // virtual semicolon for PAWN CT_COLON, CT_ASM_COLON, CT_CASE_COLON, CT_CASE_ELLIPSIS, // '...' in `case 1 ... 5`: CT_CLASS_COLON, // colon after a class def CT_CONSTR_COLON, // colon after a constructor CT_D_ARRAY_COLON, // D named array initializer colon CT_COND_COLON, // conditional colon in 'b ? t : f' CT_WHERE_COLON, // C# where-constraint colon (after the type) CT_QUESTION, CT_COMMA, CT_ASM, CT_ATTRIBUTE, CT_AUTORELEASEPOOL, // OC: Autorelease Pool Blocks, used by iOS CT_OC_AVAILABLE, CT_OC_AVAILABLE_VALUE, CT_CATCH, CT_WHEN, CT_WHERE, // C# where clause CT_CLASS, CT_DELETE, CT_EXPORT, CT_FRIEND, CT_NAMESPACE, CT_PACKAGE, CT_NEW, // may turn into CT_PBRACED if followed by a '(' CT_OPERATOR, CT_OPERATOR_VAL, CT_ASSIGN_OPERATOR, // the value after 'operator' such as: // Foo &operator= ( const Foo & ); CT_ACCESS, CT_ACCESS_COLON, CT_THROW, CT_NOEXCEPT, CT_TRY, CT_BRACED_INIT_LIST, CT_USING, CT_USING_STMT, // using (xxx) ... CT_USING_ALIAS, // using identifier attr(optional) = type-id CT_D_WITH, // D: parenthetis+braced CT_D_MODULE, CT_SUPER, CT_DELEGATE, CT_BODY, CT_DEBUG, CT_DEBUGGER, CT_INVARIANT, CT_UNITTEST, CT_UNSAFE, CT_FINALLY, CT_FIXED, // C# fixed CT_IMPORT, CT_D_SCOPE, CT_D_SCOPE_IF, CT_LAZY, CT_D_MACRO, CT_D_VERSION, // turns into CT_D_VERSION_IF if not followed by '=' CT_D_VERSION_IF, // version(x) { } // note for parenthetis/brace/square pairs: close MUST be open + 1 CT_PAREN_OPEN, CT_PAREN_CLOSE, CT_ANGLE_OPEN, // template CT_ANGLE_CLOSE, CT_SPAREN_OPEN, // 'special' parenthetis after if/for/switch/while/synchronized/catch CT_SPAREN_CLOSE, CT_PPAREN_OPEN, // 'protect' parenthetis to protect a type such as (*int) CT_PPAREN_CLOSE, // used at align_func_param CT_FPAREN_OPEN, // 'function' parenthetis after fcn/macro fcn CT_FPAREN_CLOSE, CT_LPAREN_OPEN, // lambda-declarator parenthetis CT_LPAREN_CLOSE, CT_TPAREN_OPEN, // 'type' parenthetis used in function types CT_TPAREN_CLOSE, CT_BRACE_OPEN, // {...} CT_BRACE_CLOSE, CT_VBRACE_OPEN, // virtual brace, i.e. brace inserted by uncrustify CT_VBRACE_CLOSE, CT_SQUARE_OPEN, // [...] CT_SQUARE_CLOSE, CT_TSQUARE, // special case of [] CT_MACRO_OPEN, // stuff specified via custom-pair CT_MACRO_CLOSE, CT_MACRO_ELSE, // aggregate types CT_LABEL, // a non-case label CT_LABEL_COLON, // the colon for a label CT_FUNCTION, // function - unspecified, call mark_function() CT_FUNC_CALL, // function call CT_FUNC_CALL_USER, // function call (special user) CT_FUNC_DEF, // function definition/implementation CT_FUNC_TYPE, // function type - foo in "typedef void (*foo)(void)" CT_FUNC_VAR, // foo and parent type of first parens in "void (*foo)(void)" CT_FUNC_PROTO, // function prototype CT_FUNC_START, // global DC member for functions(void ::func()) CT_FUNC_CLASS_DEF, // ctor or dtor for a class CT_FUNC_CLASS_PROTO, // ctor or dtor for a class CT_FUNC_CTOR_VAR, // variable or class initialization CT_FUNC_WRAP, // macro that wraps the function name CT_PROTO_WRAP, // macro: "RETVAL PROTO_WRAP( fcn_name, (PARAMS))". Parens for PARAMS are optional. CT_MACRO_FUNC, // function-like macro CT_MACRO_FUNC_CALL, // function-like macro call CT_MACRO, // a macro def CT_QUALIFIER, // static, const, etc CT_EXTERN, // extern CT_DECLSPEC, // __declspec CT_ALIGN, // paren'd qualifier: align(4) struct a { } CT_TYPE, CT_PTR_TYPE, // a '*' as part of a type CT_TYPE_WRAP, // macro that wraps a type name CT_CPP_LAMBDA, // parent for '[=](...){...}' CT_CPP_LAMBDA_RET, // '->' in '[=](...) -> type {...}' CT_EXECUTION_CONTEXT, // Keyword for use in lambda statement: [] CT_EXECUTION_CONTEXT ()->{} CT_TRAILING_RET, // '->' in 'auto fname(...) -> type;' // '->' in 'auto fname(...) const -> type;' CT_BIT_COLON, // a ':' in a variable declaration CT_OC_DYNAMIC, CT_OC_END, // ObjC: @end CT_OC_IMPL, // ObjC: @implementation CT_OC_INTF, // ObjC: @interface CT_OC_PROTOCOL, // ObjC: @protocol or @protocol() CT_OC_PROTO_LIST, // ObjC: protocol list < > (parent token only) CT_OC_GENERIC_SPEC, // ObjC: specification of generic < > CT_OC_PROPERTY, // ObjC: @property CT_OC_CLASS, // ObjC: the name after @interface or @implementation CT_OC_CLASS_EXT, // ObjC: a pair of empty parens after the class name in a @interface or @implementation CT_OC_CATEGORY, // ObjC: the category name in parens after the class name in a @interface or @implementation CT_OC_SCOPE, // ObjC: the '-' or '+' in '-(void) func: (int) i;' CT_OC_MSG, // ObjC: parent type to '[', ']' and ';' in '[class func : param name: param];' CT_OC_MSG_CLASS, // ObjC: 'class' in '[class func : param name: param];' (see also PCF_IN_OC_MSG) CT_OC_MSG_FUNC, // ObjC: 'func' in '[class func : param name: param];' (see also PCF_IN_OC_MSG) CT_OC_MSG_NAME, // ObjC: 'name' in '[class func : param name: param];' (see also PCF_IN_OC_MSG) CT_OC_MSG_SPEC, // ObjC: msg spec '-(void) func: (int) i;' CT_OC_MSG_DECL, // ObjC: msg decl '-(void) func: (int) i { }' CT_OC_RTYPE, // ObjC: marks parens of the return type after scope CT_OC_ATYPE, // ObjC: marks parens of the arg type after scope CT_OC_COLON, // ObjC: the colon in a msg spec CT_OC_DICT_COLON, // ObjC: colon in dictionary constant: "KEY: VALUE" CT_OC_SEL, // ObjC: @selector CT_OC_SEL_NAME, // ObjC: selector name CT_OC_BLOCK, // ObjC: block parent type. CT_OC_BLOCK_ARG, // ObjC: block arguments parent type. CT_OC_BLOCK_TYPE, // ObjC: block declaration parent type, e.g. mainly the '(^block_t)' in 'void (^block_t)(int arg);' CT_OC_BLOCK_EXPR, // ObjC: block expression with arg: '^(int arg) { arg++; };' and without (called a block literal): '^{ ... };' CT_OC_BLOCK_CARET, // ObjC: block pointer caret: '^' CT_OC_AT, // ObjC: boxed constants using '@' CT_OC_PROPERTY_ATTR, // ObjC: property attribute (strong, weak, readonly, etc...) // start PP types CT_PP_DEFINE, // #define CT_PP_DEFINED, // #if defined CT_PP_INCLUDE, // #include CT_PP_IF, // #if, #ifdef, or #ifndef CT_PP_ELSE, // #else or #elif CT_PP_ENDIF, // #endif CT_PP_ASSERT, CT_PP_EMIT, CT_PP_ENDASM, // end of assembly code section CT_PP_ENDINPUT, CT_PP_ERROR, CT_PP_FILE, CT_PP_LINE, CT_PP_SECTION, CT_PP_ASM, // start of assembly code section CT_PP_UNDEF, CT_PP_PROPERTY, CT_PP_BODYCHUNK, // everything after this gets put in CT_PREPROC_BODY CT_PP_PRAGMA, // pragma's should not be altered CT_PP_REGION, // C# #region CT_PP_ENDREGION, // C# #endregion CT_PP_REGION_INDENT, // Dummy token for indenting a C# #region CT_PP_IF_INDENT, // Dummy token for indenting a #if stuff CT_PP_IGNORE, // Dummy token for ignoring a certain preprocessor directive (do not do any processing) CT_PP_OTHER, // #line, #error, #pragma, etc // end PP types // PAWN stuff CT_CHAR, CT_DEFINED, CT_FORWARD, CT_NATIVE, CT_STATE, CT_STOCK, CT_TAGOF, CT_DOT, CT_TAG, CT_TAG_COLON, // C-sharp CT_LOCK, // lock/unlock CT_AS, CT_IN, // "foreach (T c in x)" or "foo(in char c)" or "in { ..." CT_BRACED, // simple braced items: try {} CT_THIS, // may turn into CT_PBRACED if followed by a '(' CT_BASE, // C# thingy CT_DEFAULT, // may be changed into CT_CASE CT_GETSET, // must be followed by CT_BRACE_OPEN or reverts to CT_WORD CT_GETSET_EMPTY, // get/set/add/remove followed by a semicolon CT_CONCAT, // The '~' between strings CT_CS_SQ_STMT, // '[assembly: xxx]' or '[Attribute()]' or '[Help()]', etc CT_CS_SQ_COLON, // the colon in one of those [] thingys CT_CS_PROPERTY, // word or ']' followed by '{' // Embedded SQL - always terminated with a semicolon CT_SQL_EXEC, // the 'EXEC' in 'EXEC SQL ...' CT_SQL_BEGIN, // the 'BEGINN' in 'EXEC SQL BEGIN ...' CT_SQL_END, // the 'END' in 'EXEC SQL END ...' CT_SQL_WORD, // CT_WORDs in the 'EXEC SQL' statement CT_SQL_ASSIGN, // := // Vala stuff CT_CONSTRUCT, // braced "construct { }" or qualifier "(construct int x)" CT_LAMBDA, // Java CT_ASSERT, // assert EXP1 [ : EXP2 ] ; CT_ANNOTATION, // @interface or @something(...) CT_FOR_COLON, // colon in "for ( TYPE var: EXPR ) { ... }" CT_DOUBLE_BRACE, // parent for double brace /* Clang */ CT_CNG_HASINC, // Clang: __has_include() CT_CNG_HASINCN, // Clang: __has_include_next() // extensions for Qt macros CT_Q_EMIT, // guy 2015-10-16 CT_Q_FOREACH, // guy 2015-09-23 CT_Q_FOREVER, // guy 2015-10-18 CT_Q_GADGET, // guy 2016-05-04 CT_Q_OBJECT, // guy 2015-10-16 // Machine Modes CT_MODE, // guy 2016-03-11 CT_DI, // guy 2016-03-11 CT_HI, // guy 2016-03-11 CT_QI, // guy 2016-03-11 CT_SI, // guy 2016-03-11 CT_NOTHROW, // guy 2016-03-11 CT_WORD_, // guy 2016-03-11 CT_TOKEN_COUNT_ // NOTE: Keep this the last entry because it's used as a counter. }; #endif /* TOKEN_ENUM_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/tokenize.cpp000066400000000000000000002034621434072136500213670ustar00rootroot00000000000000/** * @file tokenize.cpp * This file breaks up the text stream into tokens or chunks. * * Each routine needs to set pc.len and pc.type. * * @author Ben Gardner * @license GPL v2+ */ #include "tokenize.h" #include "keywords.h" #include "prototypes.h" #include "punctuators.h" #include "unc_ctype.h" #include #include #define LE_COUNT(x) cpd.le_counts[static_cast(LE_ ## x)] constexpr static auto LCURRENT = LTOK; using namespace std; using namespace uncrustify; struct tok_info { tok_info() : last_ch(0) , idx(0) , row(1) , col(1) { } size_t last_ch; size_t idx; size_t row; size_t col; }; struct tok_ctx { tok_ctx(const deque &d) : data(d) { } //! save before trying to parse something that may fail void save() { save(s); } void save(tok_info &info) { info = c; } //! restore previous saved state void restore() { restore(s); } void restore(const tok_info &info) { c = info; } bool more() { return(c.idx < data.size()); } size_t peek() { return(more() ? data[c.idx] : 0); } size_t peek(size_t idx) { idx += c.idx; return((idx < data.size()) ? data[idx] : 0); } size_t get() { if (more()) { size_t ch = data[c.idx++]; switch (ch) { case '\t': log_rule_B("input_tab_size"); c.col = calc_next_tab_column(c.col, options::input_tab_size()); break; case '\n': if (c.last_ch != '\r') { c.row++; c.col = 1; } break; case '\r': c.row++; c.col = 1; break; default: c.col++; break; } c.last_ch = ch; return(ch); } return(0); } bool expect(size_t ch) { if (peek() == ch) { get(); return(true); } return(false); } const deque &data; tok_info c; //! current tok_info s; //! saved }; /** * Count the number of characters in a quoted string. * The next bit of text starts with a quote char " or ' or <. * Count the number of characters until the matching character. * * @param pc The structure to update, str is an input. * * @return Whether a string was parsed */ static bool parse_string(tok_ctx &ctx, Chunk &pc, size_t quote_idx, bool allow_escape); /** * Literal string, ends with single " * Two "" don't end the string. * * @param pc The structure to update, str is an input. * * @return Whether a string was parsed */ static bool parse_cs_string(tok_ctx &ctx, Chunk &pc); /** * VALA verbatim string, ends with three quotes (""") * * @param pc The structure to update, str is an input. */ static void parse_verbatim_string(tok_ctx &ctx, Chunk &pc); static bool tag_compare(const deque &d, size_t a_idx, size_t b_idx, size_t len); /** * Parses a C++0x 'R' string. R"( xxx )" R"tag( )tag" u8R"(x)" uR"(x)" * Newlines may be in the string. * * @param pc structure to update, str is an input. */ static bool parse_cr_string(tok_ctx &ctx, Chunk &pc, size_t q_idx); /** * Count the number of whitespace characters. * * @param pc The structure to update, str is an input. * * @return Whether whitespace was parsed */ static bool parse_whitespace(tok_ctx &ctx, Chunk &pc); /** * Called when we hit a backslash. * If there is nothing but whitespace until the newline, then this is a * backslash newline * * @param pc structure to update, str is an input */ static bool parse_bs_newline(tok_ctx &ctx, Chunk &pc); /** * Parses any number of tab or space chars followed by a newline. * Does not change pc.len if a newline isn't found. * This is not the same as parse_whitespace() because it only consumes until * a single newline is encountered. */ static bool parse_newline(tok_ctx &ctx); /** * PAWN #define is different than C/C++. * #define PATTERN REPLACEMENT_TEXT * The PATTERN may not contain a space or '[' or ']'. * A generic whitespace check should be good enough. * Do not change the pattern. * * @param pc structure to update, str is an input */ static void parse_pawn_pattern(tok_ctx &ctx, Chunk &pc, E_Token tt); static bool parse_ignored(tok_ctx &ctx, Chunk &pc); /** * Skips the next bit of whatever and returns the type of block. * * pc.str is the input text. * pc.len in the output length. * pc.type is the output type * pc.column is output column * * @param pc The structure to update, str is an input. * @param prev_pc The previous structure * * @return true/false - whether anything was parsed */ static bool parse_next(tok_ctx &ctx, Chunk &pc, const Chunk *prev_pc); /** * Parses all legal D string constants. * * Quoted strings: * r"Wysiwyg" # WYSIWYG string * x"hexstring" # Hexadecimal array * `Wysiwyg` # WYSIWYG string * 'char' # single character * "reg_string" # regular string * * Non-quoted strings: * \x12 # 1-byte hex constant * \u1234 # 2-byte hex constant * \U12345678 # 4-byte hex constant * \123 # octal constant * \& # named entity * \n # single character * * @param pc The structure to update, str is an input. * * @return Whether a string was parsed */ static bool d_parse_string(tok_ctx &ctx, Chunk &pc); /** * Figure of the length of the comment at text. * The next bit of text starts with a '/', so it might be a comment. * There are three types of comments: * - C comments that start with '/ *' and end with '* /' * - C++ comments that start with // * - D nestable comments '/+' '+/' * * @param pc The structure to update, str is an input. * * @return Whether a comment was parsed */ static bool parse_comment(tok_ctx &ctx, Chunk &pc); /** * Figure of the length of the code placeholder at text, if present. * This is only for Xcode which sometimes inserts temporary code placeholder chunks, which in plaintext <#look like this#>. * * @param pc The structure to update, str is an input. * * @return Whether a placeholder was parsed. */ static bool parse_code_placeholder(tok_ctx &ctx, Chunk &pc); /** * Parse any attached suffix, which may be a user-defined literal suffix. * If for a string, explicitly exclude common format and scan specifiers, ie, * PRIx32 and SCNx64. */ static void parse_suffix(tok_ctx &ctx, Chunk &pc, bool forstring); //! check if a symbol holds a boolean value static bool is_bin(int ch); static bool is_bin_(int ch); //! check if a symbol holds a octal value static bool is_oct(int ch); static bool is_oct_(int ch); //! check if a symbol holds a decimal value; static bool is_dec(int ch); static bool is_dec_(int ch); //! check if a symbol holds a hexadecimal value static bool is_hex(int ch); static bool is_hex_(int ch); /** * Count the number of characters in the number. * The next bit of text starts with a number (0-9 or '.'), so it is a number. * Count the number of characters in the number. * * This should cover all number formats for all languages. * Note that this is not a strict parser. It will happily parse numbers in * an invalid format. * * For example, only D allows underscores in the numbers, but they are * allowed in all formats. * * @param[in,out] pc The structure to update, str is an input. * * @return Whether a number was parsed */ static bool parse_number(tok_ctx &ctx, Chunk &pc); static bool d_parse_string(tok_ctx &ctx, Chunk &pc) { size_t ch = ctx.peek(); if ( ch == '"' || ch == '\'') { return(parse_string(ctx, pc, 0, true)); } if (ch == '`') { return(parse_string(ctx, pc, 0, false)); } if ( ( ch == 'r' || ch == 'x') && ctx.peek(1) == '"') { return(parse_string(ctx, pc, 1, false)); } if (ch != '\\') { return(false); } ctx.save(); int cnt; pc.Str().clear(); while (ctx.peek() == '\\') { pc.Str().append(ctx.get()); // Check for end of file switch (ctx.peek()) { case 'x': // \x HexDigit HexDigit cnt = 3; while (cnt--) { pc.Str().append(ctx.get()); } break; case 'u': // \u HexDigit (x4) cnt = 5; while (cnt--) { pc.Str().append(ctx.get()); } break; case 'U': // \U HexDigit (x8) cnt = 9; while (cnt--) { pc.Str().append(ctx.get()); } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': // handle up to 3 octal digits pc.Str().append(ctx.get()); ch = ctx.peek(); if ( (ch >= '0') && (ch <= '7')) { pc.Str().append(ctx.get()); ch = ctx.peek(); if ( (ch >= '0') && (ch <= '7')) { pc.Str().append(ctx.get()); } } break; case '&': // \& NamedCharacterEntity ; pc.Str().append(ctx.get()); while (unc_isalpha(ctx.peek())) { pc.Str().append(ctx.get()); } if (ctx.peek() == ';') { pc.Str().append(ctx.get()); } break; default: // Everything else is a single character pc.Str().append(ctx.get()); break; } // switch } if (pc.GetStr().size() < 1) { ctx.restore(); return(false); } pc.SetType(CT_STRING); return(true); } // d_parse_string #if 0 //! A string-in-string search. Like strstr() with a haystack length. static const char *str_search(const char *needle, const char *haystack, int haystack_len) { int needle_len = strlen(needle); while (haystack_len-- >= needle_len) { if (memcmp(needle, haystack, needle_len) == 0) { return(haystack); } haystack++; } return(NULL); } #endif static bool parse_comment(tok_ctx &ctx, Chunk &pc) { bool is_d = language_is_set(LANG_D); bool is_cs = language_is_set(LANG_CS); size_t d_level = 0; // does this start with '/ /' or '/ *' or '/ +' (d) if ( (ctx.peek() != '/') || ( (ctx.peek(1) != '*') && (ctx.peek(1) != '/') && ( (ctx.peek(1) != '+') || !is_d))) { return(false); } ctx.save(); // account for opening two chars pc.Str() = ctx.get(); // opening '/' size_t ch = ctx.get(); pc.Str().append(ch); // second char if (ch == '/') { pc.SetType(CT_COMMENT_CPP); while (true) { int bs_cnt = 0; while (ctx.more()) { ch = ctx.peek(); if ( (ch == '\r') || (ch == '\n')) { break; } if ( (ch == '\\') && !is_cs) // backslashes aren't special in comments in C# { bs_cnt++; } else { bs_cnt = 0; } pc.Str().append(ctx.get()); } /* * If we hit an odd number of backslashes right before the newline, * then we keep going. */ if ( ((bs_cnt & 1) == 0) || !ctx.more()) { break; } if (ctx.peek() == '\r') { pc.Str().append(ctx.get()); } if (ctx.peek() == '\n') { pc.Str().append(ctx.get()); } pc.SetNlCount(pc.GetNlCount() + 1); cpd.did_newline = true; } } else if (!ctx.more()) { // unexpected end of file ctx.restore(); return(false); } else if (ch == '+') { pc.SetType(CT_COMMENT); d_level++; while ( d_level > 0 && ctx.more()) { if ( (ctx.peek() == '+') && (ctx.peek(1) == '/')) { pc.Str().append(ctx.get()); // store the '+' pc.Str().append(ctx.get()); // store the '/' d_level--; continue; } if ( (ctx.peek() == '/') && (ctx.peek(1) == '+')) { pc.Str().append(ctx.get()); // store the '/' pc.Str().append(ctx.get()); // store the '+' d_level++; continue; } ch = ctx.get(); pc.Str().append(ch); if ( (ch == '\n') || (ch == '\r')) { pc.SetType(CT_COMMENT_MULTI); pc.SetNlCount(pc.GetNlCount() + 1); if (ch == '\r') { if (ctx.peek() == '\n') { ++LE_COUNT(CRLF); pc.Str().append(ctx.get()); // store the '\n' } else { ++LE_COUNT(CR); } } else { ++LE_COUNT(LF); } } } } else // must be '/ *' { pc.SetType(CT_COMMENT); while (ctx.more()) { if ( (ctx.peek() == '*') && (ctx.peek(1) == '/')) { pc.Str().append(ctx.get()); // store the '*' pc.Str().append(ctx.get()); // store the '/' tok_info ss; ctx.save(ss); size_t oldsize = pc.GetStr().size(); // If there is another C comment right after this one, combine them while ( (ctx.peek() == ' ') || (ctx.peek() == '\t')) { pc.Str().append(ctx.get()); } if ( (ctx.peek() != '/') || (ctx.peek(1) != '*')) { // undo the attempt to join ctx.restore(ss); pc.Str().resize(oldsize); break; } } ch = ctx.get(); pc.Str().append(ch); if ( (ch == '\n') || (ch == '\r')) { pc.SetType(CT_COMMENT_MULTI); pc.SetNlCount(pc.GetNlCount() + 1); if (ch == '\r') { if (ctx.peek() == '\n') { ++LE_COUNT(CRLF); pc.Str().append(ctx.get()); // store the '\n' } else { ++LE_COUNT(CR); } } else { ++LE_COUNT(LF); } } } } if (cpd.unc_off) { bool found_enable_marker = (find_enable_processing_comment_marker(pc.GetStr()) >= 0); if (found_enable_marker) { const auto &ontext = options::enable_processing_cmt(); LOG_FMT(LBCTRL, "%s(%d): Found '%s' on line %zu\n", __func__, __LINE__, ontext.c_str(), pc.GetOrigLine()); cpd.unc_off = false; } } else { auto position_disable_processing_cmt = find_disable_processing_comment_marker(pc.GetStr()); bool found_disable_marker = (position_disable_processing_cmt >= 0); if (found_disable_marker) { /** * the user may wish to disable processing part of a multiline comment, * in which case we'll handle at a late time. Check to see if processing * is re-enabled elsewhere in this comment */ auto position_enable_processing_cmt = find_enable_processing_comment_marker(pc.GetStr()); if (position_enable_processing_cmt < position_disable_processing_cmt) { const auto &offtext = options::disable_processing_cmt(); LOG_FMT(LBCTRL, "%s(%d): Found '%s' on line %zu\n", __func__, __LINE__, offtext.c_str(), pc.GetOrigLine()); cpd.unc_off = true; // Issue #842 cpd.unc_off_used = true; } } } return(true); } // parse_comment static bool parse_code_placeholder(tok_ctx &ctx, Chunk &pc) { if ( (ctx.peek() != '<') || (ctx.peek(1) != '#')) { return(false); } ctx.save(); // account for opening two chars '<#' pc.Str() = ctx.get(); pc.Str().append(ctx.get()); // grab everything until '#>', fail if not found. size_t last1 = 0; while (ctx.more()) { size_t last2 = last1; last1 = ctx.get(); pc.Str().append(last1); if ( (last2 == '#') && (last1 == '>')) { pc.SetType(CT_WORD); return(true); } } ctx.restore(); return(false); } static void parse_suffix(tok_ctx &ctx, Chunk &pc, bool forstring = false) { if (CharTable::IsKw1(ctx.peek())) { size_t slen = 0; size_t oldsize = pc.GetStr().size(); // don't add the suffix if we see L" or L' or S" size_t p1 = ctx.peek(); size_t p2 = ctx.peek(1); if ( forstring && ( ( (p1 == 'L') && ( (p2 == '"') || (p2 == '\''))) || ( (p1 == 'S') && (p2 == '"')))) { return; } tok_info ss; ctx.save(ss); while ( ctx.more() && CharTable::IsKw2(ctx.peek())) { slen++; pc.Str().append(ctx.get()); } if ( forstring && slen >= 4 && ( pc.GetStr().startswith("PRI", oldsize) || pc.GetStr().startswith("SCN", oldsize))) { ctx.restore(ss); pc.Str().resize(oldsize); } } } static bool is_bin(int ch) { return( (ch == '0') || (ch == '1')); } static bool is_bin_(int ch) { return( is_bin(ch) || ch == '_' || ch == '\''); } static bool is_oct(int ch) { return( (ch >= '0') && (ch <= '7')); } static bool is_oct_(int ch) { return( is_oct(ch) || ch == '_' || ch == '\''); } static bool is_dec(int ch) { return( (ch >= '0') && (ch <= '9')); } static bool is_dec_(int ch) { // number separators: JAVA: "_", C++14: "'" return( is_dec(ch) || (ch == '_') || (ch == '\'')); } static bool is_hex(int ch) { return( ( (ch >= '0') && (ch <= '9')) || ( (ch >= 'a') && (ch <= 'f')) || ( (ch >= 'A') && (ch <= 'F'))); } static bool is_hex_(int ch) { return( is_hex(ch) || ch == '_' || ch == '\''); } static bool parse_number(tok_ctx &ctx, Chunk &pc) { /* * A number must start with a digit or a dot, followed by a digit * (signs handled elsewhere) */ if ( !is_dec(ctx.peek()) && ( (ctx.peek() != '.') || !is_dec(ctx.peek(1)))) { return(false); } bool is_float = (ctx.peek() == '.'); if ( is_float && (ctx.peek(1) == '.')) // make sure it isn't '..' { return(false); } /* * Check for Hex, Octal, or Binary * Note that only D, C++14 and Pawn support binary * Fixes the issue # 1591 * In c# the numbers starting with 0 are not treated as octal numbers. */ bool did_hex = false; if ( ctx.peek() == '0' && !language_is_set(LANG_CS)) { size_t ch; Chunk pc_temp; pc.Str().append(ctx.get()); // store the '0' pc_temp.Str().append('0'); // MS constant might have an "h" at the end. Look for it ctx.save(); while ( ctx.more() && CharTable::IsKw2(ctx.peek())) { ch = ctx.get(); pc_temp.Str().append(ch); } ch = pc_temp.GetStr()[pc_temp.Len() - 1]; ctx.restore(); LOG_FMT(LGUY, "%s(%d): pc_temp:%s\n", __func__, __LINE__, pc_temp.Text()); if (ch == 'h') // TODO can we combine this in analyze_character { // we have an MS hexadecimal number with "h" at the end LOG_FMT(LGUY, "%s(%d): MS hexadecimal number\n", __func__, __LINE__); did_hex = true; do { pc.Str().append(ctx.get()); // store the rest } while (is_hex_(ctx.peek())); pc.Str().append(ctx.get()); // store the h LOG_FMT(LGUY, "%s(%d): pc:%s\n", __func__, __LINE__, pc.Text()); } else { switch (unc_toupper(ctx.peek())) { case 'X': // hex did_hex = true; do { pc.Str().append(ctx.get()); // store the 'x' and then the rest } while (is_hex_(ctx.peek())); break; case 'B': // binary do { pc.Str().append(ctx.get()); // store the 'b' and then the rest } while (is_bin_(ctx.peek())); break; case '0': // octal or decimal case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': do { pc.Str().append(ctx.get()); } while (is_oct_(ctx.peek())); break; default: // either just 0 or 0.1 or 0UL, etc break; } // switch } } else { // Regular int or float while (is_dec_(ctx.peek())) { pc.Str().append(ctx.get()); } } // Check if we stopped on a decimal point & make sure it isn't '..' if ( (ctx.peek() == '.') && (ctx.peek(1) != '.')) { // Issue #1265, 5.clamp() tok_info ss; ctx.save(ss); while ( ctx.more() && CharTable::IsKw2(ctx.peek(1))) { // skip characters to check for paren open ctx.get(); } if (ctx.peek(1) == '(') { ctx.restore(ss); pc.SetType(CT_NUMBER); return(true); } else { ctx.restore(ss); } pc.Str().append(ctx.get()); is_float = true; if (did_hex) { while (is_hex_(ctx.peek())) { pc.Str().append(ctx.get()); } } else { while (is_dec_(ctx.peek())) { pc.Str().append(ctx.get()); } } } /* * Check exponent * Valid exponents per language (not that it matters): * C/C++/D/Java: eEpP * C#/Pawn: eE */ size_t tmp = unc_toupper(ctx.peek()); if ( (tmp == 'E') || (tmp == 'P')) { is_float = true; pc.Str().append(ctx.get()); if ( (ctx.peek() == '+') || (ctx.peek() == '-')) { pc.Str().append(ctx.get()); } while (is_dec_(ctx.peek())) { pc.Str().append(ctx.get()); } } /* * Check the suffixes * Valid suffixes per language (not that it matters): * Integer Float * C/C++: uUlL64 lLfF * C#: uUlL fFdDMm * D: uUL ifFL * Java: lL fFdD * Pawn: (none) (none) * * Note that i, f, d, and m only appear in floats. */ while (1) { size_t tmp2 = unc_toupper(ctx.peek()); if ( (tmp2 == 'I') || (tmp2 == 'F') || (tmp2 == 'D') || (tmp2 == 'M')) { is_float = true; } else if ( (tmp2 != 'L') && (tmp2 != 'U')) { break; } pc.Str().append(ctx.get()); } // skip the Microsoft-specific '32' and '64' suffix if ( ( (ctx.peek() == '3') && (ctx.peek(1) == '2')) || ( (ctx.peek() == '6') && (ctx.peek(1) == '4'))) { pc.Str().append(ctx.get()); pc.Str().append(ctx.get()); } pc.SetType(is_float ? CT_NUMBER_FP : CT_NUMBER); /* * If there is anything left, then we are probably dealing with garbage or * some sick macro junk. Eat it. */ parse_suffix(ctx, pc); return(true); } // parse_number static bool parse_string(tok_ctx &ctx, Chunk &pc, size_t quote_idx, bool allow_escape) { log_rule_B("string_escape_char"); const size_t escape_char = options::string_escape_char(); log_rule_B("string_escape_char2"); const size_t escape_char2 = options::string_escape_char2(); log_rule_B("string_replace_tab_chars"); const bool should_escape_tabs = ( allow_escape && options::string_replace_tab_chars() && language_is_set(LANG_ALLC)); pc.Str().clear(); while (quote_idx-- > 0) { pc.Str().append(ctx.get()); } pc.SetType(CT_STRING); const size_t termination_character = CharTable::Get(ctx.peek()) & 0xff; pc.Str().append(ctx.get()); // store the " bool escaped = false; while (ctx.more()) { const size_t ch = ctx.get(); // convert char 9 (\t) to chars \t if ( (ch == '\t') && should_escape_tabs) { const size_t lastcol = ctx.c.col - 1; ctx.c.col = lastcol + 2; pc.Str().append(escape_char); pc.Str().append('t'); continue; } pc.Str().append(ch); if (ch == '\n') { pc.SetNlCount(pc.GetNlCount() + 1); pc.SetType(CT_STRING_MULTI); } else if ( ch == '\r' && ctx.peek() != '\n') { pc.Str().append(ctx.get()); pc.SetNlCount(pc.GetNlCount() + 1); pc.SetType(CT_STRING_MULTI); } // if last char in prev loop was escaped the one in the current loop isn't if (escaped) { escaped = false; continue; } // see if the current char is a escape char if (allow_escape) { if (ch == escape_char) { escaped = (escape_char != 0); continue; } if ( ch == escape_char2 && (ctx.peek() == termination_character)) { escaped = allow_escape; continue; } } if (ch == termination_character) { break; } } parse_suffix(ctx, pc, true); return(true); } // parse_string enum cs_string_t { CS_STRING_NONE = 0, CS_STRING_STRING = 1 << 0, // is any kind of string CS_STRING_VERBATIM = 1 << 1, // @"" style string CS_STRING_INTERPOLATED = 1 << 2, // $"" or $@"" style string }; static cs_string_t operator|=(cs_string_t &value, cs_string_t other) { return(value = static_cast(value | other)); } static cs_string_t parse_cs_string_start(tok_ctx &ctx, Chunk &pc) { cs_string_t stringType = CS_STRING_NONE; int offset = 0; if (ctx.peek(offset) == '$') { stringType |= CS_STRING_INTERPOLATED; ++offset; } if (ctx.peek(offset) == '@') { stringType |= CS_STRING_VERBATIM; ++offset; } if (ctx.peek(offset) == '"') { stringType |= CS_STRING_STRING; pc.SetType(CT_STRING); for (int i = 0; i <= offset; ++i) { pc.Str().append(ctx.get()); } } else { stringType = CS_STRING_NONE; } return(stringType); } // parse_cs_string_start struct CsStringParseState { cs_string_t type; int braceDepth; CsStringParseState(cs_string_t stringType) { type = stringType; braceDepth = 0; } }; /** * C# strings are complex enough (mostly due to interpolation and nesting) that they need a custom parser. */ static bool parse_cs_string(tok_ctx &ctx, Chunk &pc) { cs_string_t stringType = parse_cs_string_start(ctx, pc); if (stringType == 0) { return(false); } // an interpolated string can contain {expressions}, which can contain $"strings", which in turn // can contain {expressions}, so we must track both as they are interleaved, in order to properly // parse the outermost string. std::stack parseState; // each entry is a nested string parseState.push(CsStringParseState(stringType)); log_rule_B("string_replace_tab_chars"); bool should_escape_tabs = options::string_replace_tab_chars(); while (ctx.more()) { if (parseState.top().braceDepth > 0) { // all we can do when in an expr is look for expr close with }, or a new string opening. must do this first // so we can peek and potentially consume chars for new string openings, before the ch=get() happens later, // which is needed for newline processing. if (ctx.peek() == '}') { pc.Str().append(ctx.get()); if (ctx.peek() == '}') { pc.Str().append(ctx.get()); // in interpolated string, `}}` is escape'd `}` } else { --parseState.top().braceDepth; } continue; } stringType = parse_cs_string_start(ctx, pc); if (stringType) { parseState.push(CsStringParseState(stringType)); continue; } } int lastcol = ctx.c.col; int ch = ctx.get(); pc.Str().append(ch); if (ch == '\n') { pc.SetType(CT_STRING_MULTI); pc.SetNlCount(pc.GetNlCount() + 1); } else if (ch == '\r') { pc.SetType(CT_STRING_MULTI); } else if (parseState.top().braceDepth > 0) { // do nothing. if we're in a brace, we only want the newline handling, and skip the rest. } else if ( (ch == '\t') && should_escape_tabs) { if (parseState.top().type & CS_STRING_VERBATIM) { if (!cpd.warned_unable_string_replace_tab_chars) { cpd.warned_unable_string_replace_tab_chars = true; log_rule_B("warn_level_tabs_found_in_verbatim_string_literals"); log_sev_t warnlevel = (log_sev_t)options::warn_level_tabs_found_in_verbatim_string_literals(); /* * a tab char can't be replaced with \\t because escapes don't * work in here-strings. best we can do is warn. */ LOG_FMT(warnlevel, "%s(%d): %s: orig line is %zu, orig col is %zu, Detected non-replaceable tab char in literal string\n", __func__, __LINE__, cpd.filename.c_str(), pc.GetOrigLine(), pc.GetOrigCol()); LOG_FMT(warnlevel, "%s(%d): Warning is given if doing tab-to-\\t replacement and we have found one in a C# verbatim string literal.\n", __func__, __LINE__); if (warnlevel < LWARN) { // TODO: replace the code ?? cpd.error_count++; } } } else { ctx.c.col = lastcol + 2; pc.Str().pop_back(); // remove \t pc.Str().append("\\t"); continue; } } else if ( ch == '\\' && !(parseState.top().type & CS_STRING_VERBATIM)) { // catch escaped quote in order to avoid ending string (but also must handle \\ to avoid accidental 'escape' seq of `\\"`) if ( ctx.peek() == '"' || ctx.peek() == '\\') { pc.Str().append(ctx.get()); } } else if (ch == '"') { if ( (parseState.top().type & CS_STRING_VERBATIM) && (ctx.peek() == '"')) { // in verbatim string, `""` is escape'd `"` pc.Str().append(ctx.get()); } else { // end of string parseState.pop(); if (parseState.empty()) { break; } } } else if (parseState.top().type & CS_STRING_INTERPOLATED) { if (ch == '{') { if (ctx.peek() == '{') { pc.Str().append(ctx.get()); // in interpolated string, `{{` is escape'd `{` } else { ++parseState.top().braceDepth; } } } } return(true); } // parse_cs_string static void parse_verbatim_string(tok_ctx &ctx, Chunk &pc) { pc.SetType(CT_STRING); // consume the initial """ pc.Str() = ctx.get(); pc.Str().append(ctx.get()); pc.Str().append(ctx.get()); // go until we hit a zero (end of file) or a """ while (ctx.more()) { size_t ch = ctx.get(); pc.Str().append(ch); if ( (ch == '"') && (ctx.peek() == '"') && (ctx.peek(1) == '"')) { pc.Str().append(ctx.get()); pc.Str().append(ctx.get()); break; } if ( (ch == '\n') || (ch == '\r')) { pc.SetType(CT_STRING_MULTI); pc.SetNlCount(pc.GetNlCount() + 1); } } } static bool tag_compare(const deque &d, size_t a_idx, size_t b_idx, size_t len) { if (a_idx != b_idx) { while (len-- > 0) { if (d[a_idx] != d[b_idx]) { return(false); } } } return(true); } static bool parse_cr_string(tok_ctx &ctx, Chunk &pc, size_t q_idx) { size_t tag_idx = ctx.c.idx + q_idx + 1; size_t tag_len = 0; ctx.save(); // Copy the prefix + " to the string pc.Str().clear(); int cnt = q_idx + 1; while (cnt--) { pc.Str().append(ctx.get()); } // Add the tag and get the length of the tag while ( ctx.more() && (ctx.peek() != '(')) { tag_len++; pc.Str().append(ctx.get()); } if (ctx.peek() != '(') { ctx.restore(); return(false); } pc.SetType(CT_STRING); while (ctx.more()) { if ( (ctx.peek() == ')') && (ctx.peek(tag_len + 1) == '"') && tag_compare(ctx.data, tag_idx, ctx.c.idx + 1, tag_len)) { cnt = tag_len + 2; // for the )" while (cnt--) { pc.Str().append(ctx.get()); } parse_suffix(ctx, pc); return(true); } if (ctx.peek() == '\n') { pc.Str().append(ctx.get()); pc.SetNlCount(pc.GetNlCount() + 1); pc.SetType(CT_STRING_MULTI); } else { pc.Str().append(ctx.get()); } } ctx.restore(); return(false); } // parse_cr_string /** * Count the number of characters in a word. * The first character is already valid for a keyword * * @param pc The structure to update, str is an input. * @return Whether a word was parsed (always true) */ static bool parse_word(tok_ctx &ctx, Chunk &pc, bool skipcheck) { static unc_text intr_txt("@interface"); // The first character is already valid pc.Str().clear(); pc.Str().append(ctx.get()); while (ctx.more()) { size_t ch = ctx.peek(); if (CharTable::IsKw2(ch)) { pc.Str().append(ctx.get()); } else if ( (ch == '\\') && (unc_tolower(ctx.peek(1)) == 'u')) { pc.Str().append(ctx.get()); pc.Str().append(ctx.get()); skipcheck = true; } else { break; } // HACK: Non-ASCII character are only allowed in identifiers if (ch > 0x7f) { skipcheck = true; } } pc.SetType(CT_WORD); if (skipcheck) { return(true); } // Detect pre-processor functions now if ( cpd.in_preproc == CT_PP_DEFINE && cpd.preproc_ncnl_count == 1) { if (ctx.peek() == '(') { pc.SetType(CT_MACRO_FUNC); } else { pc.SetType(CT_MACRO); log_rule_B("pp_ignore_define_body"); if (options::pp_ignore_define_body()) { /* * We are setting the PP_IGNORE preproc state because the following * chunks are part of the macro body and will have to be ignored. */ cpd.in_preproc = CT_PP_IGNORE; } } } else { // '@interface' is reserved, not an interface itself if ( language_is_set(LANG_JAVA) && pc.GetStr().startswith("@") && !pc.GetStr().equals(intr_txt)) { pc.SetType(CT_ANNOTATION); } else { // Turn it into a keyword now // Issue #1460 will return "COMMENT_CPP" pc.SetType(find_keyword_type(pc.Text(), pc.GetStr().size())); /* Special pattern: if we're trying to redirect a preprocessor directive to PP_IGNORE, * then ensure we're actually part of a preprocessor before doing the swap, or we'll * end up with a function named 'define' as PP_IGNORE. This is necessary because with * the config 'set' feature, there's no way to do a pair of tokens as a word * substitution. */ if ( pc.GetType() == CT_PP_IGNORE && !cpd.in_preproc) { pc.SetType(find_keyword_type(pc.Text(), pc.GetStr().size())); } else if (pc.GetType() == CT_COMMENT_CPP) // Issue #1460 { size_t ch; bool is_cs = language_is_set(LANG_CS); // read until EOL while (true) { int bs_cnt = 0; while (ctx.more()) { ch = ctx.peek(); if ( (ch == '\r') || (ch == '\n')) { break; } if ( (ch == '\\') && !is_cs) // backslashes aren't special in comments in C# { bs_cnt++; } else { bs_cnt = 0; } pc.Str().append(ctx.get()); } /* * If we hit an odd number of backslashes right before the newline, * then we keep going. */ if ( ((bs_cnt & 1) == 0) || !ctx.more()) { break; } if (ctx.peek() == '\r') { pc.Str().append(ctx.get()); } if (ctx.peek() == '\n') { pc.Str().append(ctx.get()); } pc.SetNlCount(pc.GetNlCount() + 1); cpd.did_newline = true; } // Store off the end column pc.SetOrigColEnd(ctx.c.col); } } } return(true); } // parse_word static size_t parse_attribute_specifier_sequence(tok_ctx &ctx) { size_t nested = 0; size_t offset = 0; size_t parens = 0; auto ch1 = ctx.peek(offset++); while (ch1) { auto ch2 = ctx.peek(offset++); while ( ch2 == ' ' || ch2 == '\n' || ch2 == '\r' || ch2 == '\t') { ch2 = ctx.peek(offset++); } if ( nested == 0 && ch2 != '[') { break; } if (ch1 == '(') { ++parens; ch1 = ch2; continue; } if (ch1 == ')') { if (parens == 0) { break; } --parens; ch1 = ch2; continue; } if ( ch1 != '[' && ch1 != ']') { ch1 = ch2; continue; } if (ch2 != ch1) { if (parens == 0) { break; } ch1 = ch2; continue; } if (ch1 == '[') { if ( nested != 0 && parens == 0) { break; } ++nested; } else if (--nested == 0) { return(offset); } ch1 = ctx.peek(offset++); } return(0); } // parse_attribute_specifier_sequence static bool extract_attribute_specifier_sequence(tok_ctx &ctx, Chunk &pc, size_t length) { pc.Str().clear(); while (length--) { pc.Str().append(ctx.get()); } pc.SetType(CT_ATTRIBUTE); return(true); } // extract_attribute_specifier_sequence static bool parse_whitespace(tok_ctx &ctx, Chunk &pc) { size_t nl_count = 0; size_t ch = 0; // REVISIT: use a better whitespace detector? while ( ctx.more() && unc_isspace(ctx.peek())) { int lastcol = ctx.c.col; ch = ctx.get(); // throw away the whitespace char switch (ch) { case '\r': if (ctx.expect('\n')) { // CRLF ending ++LE_COUNT(CRLF); } else { // CR ending ++LE_COUNT(CR); } nl_count++; pc.SetOrigPrevSp(0); break; case '\n': // LF ending ++LE_COUNT(LF); nl_count++; pc.SetOrigPrevSp(0); break; case '\t': pc.SetOrigPrevSp(pc.GetOrigPrevSp() + ctx.c.col - lastcol); break; case ' ': pc.SetOrigPrevSp(pc.GetOrigPrevSp() + 1); break; default: break; } } if (ch != 0) { pc.Str().clear(); pc.SetType(nl_count ? CT_NEWLINE : CT_WHITESPACE); pc.SetNlCount(nl_count); pc.SetAfterTab((ctx.c.last_ch == '\t')); return(true); } return(false); } // parse_whitespace static bool parse_bs_newline(tok_ctx &ctx, Chunk &pc) { ctx.save(); ctx.get(); // skip the '\' size_t ch; while ( ctx.more() && unc_isspace(ch = ctx.peek())) { ctx.get(); if ( (ch == '\r') || (ch == '\n')) { if (ch == '\r') { ctx.expect('\n'); } pc.SetType(CT_NL_CONT); pc.Str() = "\\"; pc.SetNlCount(1); return(true); } } ctx.restore(); return(false); } static bool parse_newline(tok_ctx &ctx) { ctx.save(); // Eat whitespace while ( (ctx.peek() == ' ') || (ctx.peek() == '\t')) { ctx.get(); } if ( (ctx.peek() == '\r') || (ctx.peek() == '\n')) { if (!ctx.expect('\n')) { ctx.get(); ctx.expect('\n'); } return(true); } ctx.restore(); return(false); } static void parse_pawn_pattern(tok_ctx &ctx, Chunk &pc, E_Token tt) { pc.Str().clear(); pc.SetType(tt); while (!unc_isspace(ctx.peek())) { // end the pattern on an escaped newline if (ctx.peek() == '\\') { size_t ch = ctx.peek(1); if ( (ch == '\n') || (ch == '\r')) { break; } } pc.Str().append(ctx.get()); } } static bool parse_off_newlines(tok_ctx &ctx, Chunk &pc) { size_t nl_count = 0; // Parse off newlines/blank lines while (parse_newline(ctx)) { nl_count++; } if (nl_count > 0) { pc.SetNlCount(nl_count); pc.SetType(CT_NEWLINE); return(true); } return(false); } static bool parse_macro(tok_ctx &ctx, Chunk &pc, const Chunk *prev_pc) { if (parse_off_newlines(ctx, pc)) { return(true); } if (parse_comment(ctx, pc)) // allow CT_COMMENT_MULTI within macros { return(true); } ctx.save(); pc.Str().clear(); if (prev_pc == nullptr) { return(false); } bool continued = ( prev_pc->Is(CT_NL_CONT) || prev_pc->Is(CT_COMMENT_MULTI)); while (ctx.more()) { size_t pk = ctx.peek(), pk1 = ctx.peek(1); bool nl = ( pk == '\n' || pk == '\r'); bool nl_cont = ( pk == '\\' && ( pk1 == '\n' || pk1 == '\r')); if ( ( nl_cont || ( continued && nl)) && pc.GetStr().size() > 0) { pc.SetType(CT_PP_IGNORE); return(true); } else if (nl) { break; } pc.Str().append(ctx.get()); } pc.Str().clear(); ctx.restore(); return(false); } // parse_macro static bool parse_ignored(tok_ctx &ctx, Chunk &pc) { if (parse_off_newlines(ctx, pc)) { return(true); } // See if the UO_enable_processing_cmt or #pragma endasm / #endasm text is on this line ctx.save(); pc.Str().clear(); while ( ctx.more() && (ctx.peek() != '\r') && (ctx.peek() != '\n')) { pc.Str().append(ctx.get()); } if (pc.GetStr().size() == 0) { // end of file? return(false); } // HACK: turn on if we find '#endasm' or '#pragma' and 'endasm' separated by blanks if ( ( ( (pc.GetStr().find("#pragma ") >= 0) || (pc.GetStr().find("#pragma ") >= 0)) && ( (pc.GetStr().find(" endasm") >= 0) || (pc.GetStr().find(" endasm") >= 0))) || (pc.GetStr().find("#endasm") >= 0)) { cpd.unc_off = false; ctx.restore(); pc.Str().clear(); return(false); } // Note that we aren't actually making sure this is in a comment, yet log_rule_B("enable_processing_cmt"); const auto &ontext = options::enable_processing_cmt(); if (!ontext.empty()) { bool found_enable_pattern = false; if ( ontext != UNCRUSTIFY_ON_TEXT && options::processing_cmt_as_regex()) { std::wstring pc_wstring(pc.GetStr().get().cbegin(), pc.GetStr().get().cend()); std::wregex criteria(std::wstring(ontext.cbegin(), ontext.cend())); found_enable_pattern = std::regex_search(pc_wstring.cbegin(), pc_wstring.cend(), criteria); } else { found_enable_pattern = (pc.GetStr().find(ontext.c_str()) >= 0); } if (!found_enable_pattern) { pc.SetType(CT_IGNORED); return(true); } } ctx.restore(); // parse off whitespace leading to the comment if (parse_whitespace(ctx, pc)) { pc.SetType(CT_IGNORED); return(true); } // Look for the ending comment and let it pass if ( parse_comment(ctx, pc) && !cpd.unc_off) { return(true); } // Reset the chunk & scan to until a newline pc.Str().clear(); while ( ctx.more() && (ctx.peek() != '\r') && (ctx.peek() != '\n')) { pc.Str().append(ctx.get()); } if (pc.GetStr().size() > 0) { pc.SetType(CT_IGNORED); return(true); } return(false); } // parse_ignored static bool parse_next(tok_ctx &ctx, Chunk &pc, const Chunk *prev_pc) { if (!ctx.more()) { return(false); } // Save off the current column pc.SetType(CT_NONE); pc.SetOrigLine(ctx.c.row); pc.SetColumn(ctx.c.col); pc.SetOrigCol(ctx.c.col); pc.SetNlCount(0); pc.SetFlags(PCF_NONE); // If it is turned off, we put everything except newlines into CT_UNKNOWN if (cpd.unc_off) { if (parse_ignored(ctx, pc)) { return(true); } } log_rule_B("disable_processing_nl_cont"); // Parse macro blocks if (options::disable_processing_nl_cont()) { if (parse_macro(ctx, pc, prev_pc)) { return(true); } } // Parse whitespace if (parse_whitespace(ctx, pc)) { return(true); } // Handle unknown/unhandled preprocessors if ( cpd.in_preproc > CT_PP_BODYCHUNK && cpd.in_preproc <= CT_PP_OTHER) { pc.Str().clear(); tok_info ss; ctx.save(ss); // Chunk to a newline or comment pc.SetType(CT_PREPROC_BODY); size_t last = 0; while (ctx.more()) { size_t ch = ctx.peek(); // Fix for issue #1752 // Ignoring extra spaces after ' \ ' for preproc body continuations if ( last == '\\' && ch == ' ') { ctx.get(); continue; } if ( (ch == '\n') || (ch == '\r')) { // Back off if this is an escaped newline if (last == '\\') { ctx.restore(ss); pc.Str().pop_back(); } break; } // Quit on a C or C++ comment start Issue #1966 if ( (ch == '/') && ( (ctx.peek(1) == '/') || (ctx.peek(1) == '*'))) { break; } last = ch; ctx.save(ss); pc.Str().append(ctx.get()); } if (pc.GetStr().size() > 0) { return(true); } } // Detect backslash-newline if ( (ctx.peek() == '\\') && parse_bs_newline(ctx, pc)) { return(true); } // Parse comments if (parse_comment(ctx, pc)) { return(true); } // Parse code placeholders if (parse_code_placeholder(ctx, pc)) { return(true); } if (language_is_set(LANG_CS)) { if (parse_cs_string(ctx, pc)) { return(true); } } if (language_is_set(LANG_CS | LANG_VALA)) { // check for non-keyword identifiers such as @if @switch, etc // Vala also allows numeric identifiers if prefixed with '@' if ( ctx.peek() == '@' && ( CharTable::IsKw1(ctx.peek(1)) || ( language_is_set(LANG_VALA) && CharTable::IsKw2(ctx.peek(1))))) { parse_word(ctx, pc, true); return(true); } } // handle VALA """ strings """ if ( language_is_set(LANG_VALA) && (ctx.peek() == '"') && (ctx.peek(1) == '"') && (ctx.peek(2) == '"')) { parse_verbatim_string(ctx, pc); return(true); } /* * handle C++(11) string/char literal prefixes u8|u|U|L|R including all * possible combinations and optional R delimiters: R"delim(x)delim" */ auto ch = ctx.peek(); if ( language_is_set(LANG_C | LANG_CPP) && ( ch == 'u' || ch == 'U' || ch == 'R' || ch == 'L')) { auto idx = size_t{}; auto is_real = false; if ( ch == 'u' && ctx.peek(1) == '8') { idx = 2; } else if ( unc_tolower(ch) == 'u' || ch == 'L') { idx++; } if ( language_is_set(LANG_C | LANG_CPP) && ctx.peek(idx) == 'R') { idx++; is_real = true; } const auto quote = ctx.peek(idx); if (is_real) { if ( quote == '"' && parse_cr_string(ctx, pc, idx)) { return(true); } } else if ( ( quote == '"' || quote == '\'') && parse_string(ctx, pc, idx, true)) { return(true); } } // PAWN specific stuff if (language_is_set(LANG_PAWN)) { if ( cpd.preproc_ncnl_count == 1 && ( cpd.in_preproc == CT_PP_DEFINE || cpd.in_preproc == CT_PP_EMIT)) { parse_pawn_pattern(ctx, pc, CT_MACRO); return(true); } // Check for PAWN strings: \"hi" or !"hi" or !\"hi" or \!"hi" if ( (ctx.peek() == '\\') || (ctx.peek() == '!')) { if (ctx.peek(1) == '"') { parse_string(ctx, pc, 1, (ctx.peek() == '!')); return(true); } if ( ( (ctx.peek(1) == '\\') || (ctx.peek(1) == '!')) && (ctx.peek(2) == '"')) { parse_string(ctx, pc, 2, false); return(true); } } // handle PAWN preprocessor args %0 .. %9 if ( cpd.in_preproc == CT_PP_DEFINE && (ctx.peek() == '%') && unc_isdigit(ctx.peek(1))) { pc.Str().clear(); pc.Str().append(ctx.get()); pc.Str().append(ctx.get()); pc.SetType(CT_WORD); return(true); } } // Parse strings and character constants //parse_word(ctx, pc_temp, true); //ctx.restore(ctx.c); if (parse_number(ctx, pc)) { return(true); } if (language_is_set(LANG_D)) { // D specific stuff if (d_parse_string(ctx, pc)) { return(true); } } else { // Not D stuff // Check for L'a', L"abc", 'a', "abc", strings ch = ctx.peek(); size_t ch1 = ctx.peek(1); if ( ( ( (ch == 'L') || (ch == 'S')) && ( (ch1 == '"') || (ch1 == '\''))) || (ch == '"') || (ch == '\'') || ( (ch == '<') && cpd.in_preproc == CT_PP_INCLUDE)) { parse_string(ctx, pc, unc_isalpha(ch) ? 1 : 0, true); if (cpd.in_preproc == CT_PP_INCLUDE) { pc.SetParentType(CT_PP_INCLUDE); } return(true); } if ( (ch == '<') && cpd.in_preproc == CT_PP_DEFINE) { if (Chunk::GetTail()->Is(CT_MACRO)) { // We have "#define XXX <", assume '<' starts an include string parse_string(ctx, pc, 0, false); return(true); } } /* Inside clang's __has_include() could be "path/to/file.h" or system-style */ Chunk *tail = Chunk::GetTail(); if ( (ch == '(') && (tail->IsNotNullChunk()) && ( tail->Is(CT_CNG_HASINC) || tail->Is(CT_CNG_HASINCN))) { parse_string(ctx, pc, 0, false); return(true); } } // Check for Vala string templates if ( language_is_set(LANG_VALA) && (ctx.peek() == '@')) { size_t nc = ctx.peek(1); if (nc == '"') { // literal string parse_string(ctx, pc, 1, true); return(true); } } // Check for Objective C literals if ( language_is_set(LANG_OC) && (ctx.peek() == '@')) { size_t nc = ctx.peek(1); if (nc == 'R') // Issue #2720 { if (ctx.peek(2) == '"') { if (parse_cr_string(ctx, pc, 2)) // Issue #3027 { return(true); } // parse string without escaping parse_string(ctx, pc, 2, false); return(true); } } if ( (nc == '"') || (nc == '\'')) { // literal string parse_string(ctx, pc, 1, true); return(true); } if ( (nc >= '0') && (nc <= '9')) { // literal number pc.Str().append(ctx.get()); // store the '@' parse_number(ctx, pc); return(true); } } // Check for pawn/ObjectiveC/Java and normal identifiers if ( CharTable::IsKw1(ctx.peek()) || ( (ctx.peek() == '\\') && (unc_tolower(ctx.peek(1)) == 'u')) || ( (ctx.peek() == '@') && CharTable::IsKw1(ctx.peek(1)))) { parse_word(ctx, pc, false); return(true); } // Check for C++11/14/17/20 attribute specifier sequences if ( language_is_set(LANG_CPP) && ctx.peek() == '[') { if ( !language_is_set(LANG_OC) || ( prev_pc != nullptr && !prev_pc->Is(CT_OC_AT))) { if (auto length = parse_attribute_specifier_sequence(ctx)) { extract_attribute_specifier_sequence(ctx, pc, length); return(true); } } } // see if we have a punctuator char punc_txt[7]; punc_txt[0] = ctx.peek(); punc_txt[1] = ctx.peek(1); punc_txt[2] = ctx.peek(2); punc_txt[3] = ctx.peek(3); punc_txt[4] = ctx.peek(4); punc_txt[5] = ctx.peek(5); punc_txt[6] = '\0'; const chunk_tag_t *punc; if ((punc = find_punctuator(punc_txt, cpd.lang_flags)) != nullptr) { int cnt = strlen(punc->tag); while (cnt--) { pc.Str().append(ctx.get()); } pc.SetType(punc->type); pc.SetFlagBits(PCF_PUNCTUATOR); return(true); } /* When parsing C/C++ files and running into some unknown token, * check if matches Objective-C as a last resort, before * considering it as garbage. */ int probe_lang_flags = 0; if (language_is_set(LANG_C | LANG_CPP)) { probe_lang_flags = cpd.lang_flags | LANG_OC; } if (probe_lang_flags != 0) { if ((punc = find_punctuator(punc_txt, probe_lang_flags)) != nullptr) { cpd.lang_flags = probe_lang_flags; int cnt = strlen(punc->tag); while (cnt--) { pc.Str().append(ctx.get()); } pc.SetType(punc->type); pc.SetFlagBits(PCF_PUNCTUATOR); return(true); } } // throw away this character pc.SetType(CT_UNKNOWN); pc.Str().append(ctx.get()); LOG_FMT(LWARN, "%s:%zu Garbage in col %zu: %x\n", cpd.filename.c_str(), pc.GetOrigLine(), ctx.c.col, pc.GetStr()[0]); exit(EX_SOFTWARE); } // parse_next int find_disable_processing_comment_marker(const unc_text &text, std::size_t start_idx) { log_rule_B("disable_processing_cmt"); const auto &offtext = options::disable_processing_cmt(); int idx = -1; if ( !offtext.empty() && start_idx < text.size()) { if ( offtext != UNCRUSTIFY_OFF_TEXT && options::processing_cmt_as_regex()) { std::wsmatch match; std::wstring pc_wstring(text.get().cbegin() + start_idx, text.get().cend()); std::wregex criteria(std::wstring(offtext.cbegin(), offtext.cend())); std::regex_search(pc_wstring.cbegin(), pc_wstring.cend(), match, criteria); if (!match.empty()) { idx = int(match.position() + start_idx); } } else { idx = text.find(offtext.c_str(), start_idx); if (idx >= 0) { idx += int(offtext.size()); } } /** * update the position to the start of the current line */ while ( idx > 0 && text[idx - 1] != '\n') { --idx; } } return(idx); } // find_disable_processing_comment_marker int find_enable_processing_comment_marker(const unc_text &text, std::size_t start_idx) { log_rule_B("enable_processing_cmt"); const auto &ontext = options::enable_processing_cmt(); int idx = -1; if ( !ontext.empty() && start_idx < text.size()) { if ( ontext != UNCRUSTIFY_ON_TEXT && options::processing_cmt_as_regex()) { std::wsmatch match; std::wstring pc_wstring(text.get().cbegin() + start_idx, text.get().cend()); std::wregex criteria(std::wstring(ontext.cbegin(), ontext.cend())); std::regex_search(pc_wstring.cbegin(), pc_wstring.cend(), match, criteria); if (!match.empty()) { idx = int(start_idx + match.position() + match.size()); } } else { idx = text.find(ontext.c_str(), start_idx); if (idx >= 0) { idx += int(ontext.size()); } } /** * update the position to the end of the current line */ if (idx >= 0) { while ( idx < int(text.size()) && text[idx] != '\n') { ++idx; } } } return(idx); } // find_enable_processing_comment_marker void tokenize(const deque &data, Chunk *ref) { tok_ctx ctx(data); Chunk chunk; Chunk *pc = nullptr; Chunk *rprev = nullptr; bool last_was_tab = false; size_t prev_sp = 0; int num_stripped = 0; // Issue #1966 cpd.unc_stage = unc_stage_e::TOKENIZE; while (ctx.more()) { chunk.Reset(); chunk.SetPpLevel(0); if (!parse_next(ctx, chunk, pc)) { LOG_FMT(LERR, "%s:%zu Bailed before the end?\n", cpd.filename.c_str(), ctx.c.row); exit(EX_SOFTWARE); } if ( language_is_set(LANG_JAVA) && chunk.GetType() == CT_MEMBER && !memcmp(chunk.Text(), "->", 2)) { chunk.SetType(CT_LAMBDA); } // Don't create an entry for whitespace if (chunk.GetType() == CT_WHITESPACE) { last_was_tab = chunk.GetAfterTab(); prev_sp = chunk.GetOrigPrevSp(); continue; } chunk.SetOrigPrevSp(prev_sp); prev_sp = 0; if (chunk.GetType() == CT_NEWLINE) { last_was_tab = chunk.GetAfterTab(); chunk.SetAfterTab(false); chunk.Str().clear(); } else if (chunk.GetType() == CT_NL_CONT) { last_was_tab = chunk.GetAfterTab(); chunk.SetAfterTab(false); chunk.Str() = "\\\n"; } else { chunk.SetAfterTab(last_was_tab); last_was_tab = false; } num_stripped = 0; // Issue #1966 and #3565 if (chunk.GetType() != CT_IGNORED) { // Issue #1338 // Strip trailing whitespace (for CPP comments and PP blocks) while ( (chunk.GetStr().size() > 0) && ( (chunk.GetStr()[chunk.GetStr().size() - 1] == ' ') || (chunk.GetStr()[chunk.GetStr().size() - 1] == '\t'))) { // If comment contains backslash '\' followed by whitespace chars, keep last one; // this will prevent it from turning '\' into line continuation. if ( (chunk.GetStr().size() > 1) && (chunk.GetStr()[chunk.GetStr().size() - 2] == '\\')) { break; } chunk.Str().pop_back(); num_stripped++; // Issue #1966 } } // Store off the end column chunk.SetOrigColEnd(ctx.c.col - num_stripped); // Issue #1966 and #3565 // Make the whitespace we disposed of be attributed to the next chunk prev_sp = num_stripped; // Add the chunk to the list rprev = pc; if (rprev != nullptr) { pc->SetFlagBits(rprev->GetFlags() & PCF_COPY_FLAGS); // a newline can't be in a preprocessor if (pc->Is(CT_NEWLINE)) { pc->ResetFlagBits(PCF_IN_PREPROC); } } if (ref != nullptr) { chunk.SetFlagBits(PCF_INSERTED); } else { chunk.ResetFlagBits(PCF_INSERTED); } pc = chunk.CopyAndAddBefore(ref); // A newline marks the end of a preprocessor if (pc->Is(CT_NEWLINE)) // || pc->Is(CT_COMMENT_MULTI)) { cpd.in_preproc = CT_NONE; cpd.preproc_ncnl_count = 0; } // Disable indentation when #asm directive found if (pc->Is(CT_PP_ASM)) { LOG_FMT(LBCTRL, "Found a directive %s on line %zu\n", "#asm", pc->GetOrigLine()); cpd.unc_off = true; } // Special handling for preprocessor stuff if (cpd.in_preproc != CT_NONE) { pc->SetFlagBits(PCF_IN_PREPROC); // Count words after the preprocessor if (!pc->IsCommentOrNewline()) { cpd.preproc_ncnl_count++; } // Disable indentation if a #pragma asm directive is found if (cpd.in_preproc == CT_PP_PRAGMA) { if (memcmp(pc->Text(), "asm", 3) == 0) { LOG_FMT(LBCTRL, "Found a pragma %s on line %zu\n", "asm", pc->GetOrigLine()); cpd.unc_off = true; } } // Figure out the type of preprocessor for #include parsing if (cpd.in_preproc == CT_PREPROC) { if ( pc->GetType() < CT_PP_DEFINE || pc->GetType() > CT_PP_OTHER) { pc->SetType(CT_PP_OTHER); } cpd.in_preproc = pc->GetType(); } else if (cpd.in_preproc == CT_PP_IGNORE) { if ( !pc->Is(CT_NL_CONT) && !pc->IsComment()) // Issue #1966 { pc->SetType(CT_PP_IGNORE); } } else if ( cpd.in_preproc == CT_PP_DEFINE && pc->Is(CT_PAREN_CLOSE) && options::pp_ignore_define_body()) { log_rule_B("pp_ignore_define_body"); // When we have a PAREN_CLOSE in a PP_DEFINE we should be terminating a MACRO_FUNC // arguments list. Therefore we can enter the PP_IGNORE state and ignore next chunks. cpd.in_preproc = CT_PP_IGNORE; } } else { // Check for a preprocessor start if ( pc->Is(CT_POUND) && ( rprev == nullptr || rprev->Is(CT_NEWLINE))) { pc->SetType(CT_PREPROC); pc->SetFlagBits(PCF_IN_PREPROC); cpd.in_preproc = CT_PREPROC; } } if (pc->Is(CT_NEWLINE)) { LOG_FMT(LGUY, "%s(%d): orig line is %zu, orig col is %zu, , nl is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetNlCount()); } else if (pc->Is(CT_VBRACE_OPEN)) { LOG_FMT(LGUY, "%s(%d): orig line is %zu, orig col is %zu, type is %s, orig col end is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->GetOrigColEnd()); } else { char copy[1000]; LOG_FMT(LGUY, "%s(%d): orig line is %zu, orig col is %zu, Text() '%s', type is %s, orig col end is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy), get_token_name(pc->GetType()), pc->GetOrigColEnd()); } } // Set the cpd.newline string for this file log_rule_B("newlines"); if ( options::newlines() == LE_LF || ( options::newlines() == LE_AUTO && (LE_COUNT(LF) >= LE_COUNT(CRLF)) && (LE_COUNT(LF) >= LE_COUNT(CR)))) { // LF line ends cpd.newline = "\n"; LOG_FMT(LLINEENDS, "Using LF line endings\n"); } else if ( options::newlines() == LE_CRLF || ( options::newlines() == LE_AUTO && (LE_COUNT(CRLF) >= LE_COUNT(LF)) && (LE_COUNT(CRLF) >= LE_COUNT(CR)))) { // CRLF line ends cpd.newline = "\r\n"; LOG_FMT(LLINEENDS, "Using CRLF line endings\r\n"); } else { // CR line ends cpd.newline = "\r"; LOG_FMT(LLINEENDS, "Using CR line endings\n"); } } // tokenize uncrustify-uncrustify-0.76.0/src/tokenize.h000066400000000000000000000035501434072136500210300ustar00rootroot00000000000000/** * @file tokenize.h * prototypes for tokenize.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef TOKENIZE_H_INCLUDED #define TOKENIZE_H_INCLUDED #include "uncrustify_types.h" /** * Test the input string to see if it satisfies the criteria * specified by the disable_processing_cmt option * @param text the string to which a match will be attempted * @param start_idx the starting index within the string from which the * search will be performed * @return returns a non-negative position index that points to the beginning * of the line containing the marker, if found */ int find_disable_processing_comment_marker(const unc_text &text, std::size_t start_idx = 0); /** * Test the input string to see if it satisfies the criteria * specified by the enable_processing_cmt option * @param text the string to which a match will be attempted * @param start_idx the starting index within the string from which the * search will be performed * @return returns a non-negative position index that points to the end * of the line containing the marker, if found */ int find_enable_processing_comment_marker(const unc_text &text, std::size_t start_idx = 0); /** * @brief Parse the text into chunks * * This function parses or tokenizes the whole buffer into a list. * It has to do some tricks to parse preprocessors. * * If output_text() were called immediately after, two things would happen: * - trailing whitespace are removed. * - leading space & tabs are converted to the appropriate format. * * All the tokens are inserted before ref. If ref is NULL, they are inserted * at the end of the list. Line numbers are relative to the start of the data. */ void tokenize(const std::deque &data, Chunk *ref); #endif /* TOKENIZE_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/tokenize_cleanup.cpp000066400000000000000000001423271434072136500231000ustar00rootroot00000000000000/** * @file tokenize_cleanup.cpp * Looks at simple sequences to refine the chunk types. * Examples: * - change '[' + ']' into '[]'/ * - detect "version = 10;" vs "version (xxx) {" * * @author Ben Gardner * @author Guy Maurel 2015, 2021 * @license GPL v2+ */ #include "tokenize_cleanup.h" #include "combine.h" #include "combine_skip.h" #include "flag_braced_init_list.h" #include "flag_decltype.h" #include "keywords.h" #include "prototypes.h" #include "punctuators.h" #include "space.h" #include "unc_ctype.h" using namespace uncrustify; /** * Mark types in a single template argument. * * @param start chunk to start check at * @param end chunk to end check at */ static void check_template_arg(Chunk *start, Chunk *end); /** * Mark types in template argument(s). * * @param start chunk to start check at * @param end chunk to end check at */ static void check_template_args(Chunk *start, Chunk *end); /** * If there is nothing but CT_WORD and CT_MEMBER, then it's probably a * template thingy. Otherwise, it's likely a comparison. * * @param start chunk to start check at */ static void check_template(Chunk *start, bool in_type_cast); /** * Convert '>' + '>' into '>>' * If we only have a single '>', then change it to CT_COMPARE. * * @param pc chunk to start at */ static Chunk *handle_double_angle_close(Chunk *pc); /** * Marks ObjC specific chunks in property declaration, by setting * parent types and chunk types. */ static void cleanup_objc_property(Chunk *start); /** * Marks ObjC specific chunks in property declaration (getter/setter attribute) * Will mark 'test4Setter'and ':' in '@property (setter=test4Setter:, strong) int test4;' as CT_OC_SEL_NAME */ static void mark_selectors_in_property_with_open_paren(Chunk *open_paren); /** * Marks ObjC specific chunks in property declaration ( attributes) * Changes all the CT_WORD and CT_TYPE to CT_OC_PROPERTY_ATTR */ static void mark_attributes_in_property_with_open_paren(Chunk *open_paren); static Chunk *handle_double_angle_close(Chunk *pc) { if (pc == nullptr) { pc = Chunk::NullChunkPtr; } Chunk *next = pc->GetNext(); if (next->IsNotNullChunk()) { if ( pc->Is(CT_ANGLE_CLOSE) && next->Is(CT_ANGLE_CLOSE) && pc->GetParentType() == CT_NONE && (pc->GetOrigColEnd() + 1) == next->GetOrigCol() && next->GetParentType() == CT_NONE) { pc->Str().append('>'); pc->SetType(CT_SHIFT); pc->SetOrigColEnd(next->GetOrigColEnd()); Chunk *tmp = next->GetNextNcNnl(); Chunk::Delete(next); next = tmp; } else { // bug #663 pc->SetType(CT_COMPARE); } } return(next); } void split_off_angle_close(Chunk *pc) { const chunk_tag_t *ct = find_punctuator(pc->Text() + 1, cpd.lang_flags); if (ct == nullptr) { return; } Chunk nc = *pc; pc->Str().resize(1); pc->SetOrigColEnd(pc->GetOrigCol() + 1); pc->SetType(CT_ANGLE_CLOSE); nc.SetType(ct->type); nc.Str().pop_front(); nc.SetOrigCol(nc.GetOrigCol() + 1); nc.SetColumn(nc.GetColumn() + 1); nc.CopyAndAddAfter(pc); } void tokenize_trailing_return_types() { // Issue #2330 // auto max(int a, int b) -> int; // Issue #2460 // auto f01() -> bool; // auto f02() noexcept -> bool; // auto f03() noexcept(true) -> bool; // auto f04() noexcept(false) -> bool; // auto f05() noexcept -> bool = delete; // auto f06() noexcept(true) -> bool = delete; // auto f07() noexcept(false) -> bool = delete; // auto f11() const -> bool; // auto f12() const noexcept -> bool; // auto f13() const noexcept(true) -> bool; // auto f14() const noexcept(false) -> bool; // auto f15() const noexcept -> bool = delete; // auto f16() const noexcept(true) -> bool = delete; // auto f17() const noexcept(false) -> bool = delete; // auto f21() throw() -> bool; // auto f22() throw() -> bool = delete; // auto f23() const throw() -> bool; // auto f24() const throw() -> bool = delete; for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { char copy[1000]; LOG_FMT(LNOTE, "%s(%d): orig line is %zu, orig col is %zu, Text() is '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy)); if ( pc->Is(CT_MEMBER) && (strcmp(pc->Text(), "->") == 0)) { Chunk *tmp = pc->GetPrevNcNnl(); Chunk *tmp_2; Chunk *open_paren; if (tmp->Is(CT_QUALIFIER)) { // auto max(int a, int b) const -> int; // auto f11() const -> bool; tmp = tmp->GetPrevNcNnl(); } else if (tmp->Is(CT_NOEXCEPT)) { // noexcept is present tmp_2 = tmp->GetPrevNcNnl(); if (tmp_2->Is(CT_QUALIFIER)) { // auto f12() const noexcept -> bool; // auto f15() const noexcept -> bool = delete; tmp = tmp_2->GetPrevNcNnl(); } else { // auto f02() noexcept -> bool; // auto f05() noexcept -> bool = delete; tmp = tmp_2; } } else if (tmp->Is(CT_PAREN_CLOSE)) { open_paren = tmp->GetPrevType(CT_PAREN_OPEN, tmp->GetLevel()); tmp = open_paren->GetPrevNcNnl(); if (tmp->Is(CT_NOEXCEPT)) { // noexcept is present tmp_2 = tmp->GetPrevNcNnl(); if (tmp_2->Is(CT_QUALIFIER)) { // auto f13() const noexcept(true) -> bool; // auto f14() const noexcept(false) -> bool; // auto f16() const noexcept(true) -> bool = delete; // auto f17() const noexcept(false) -> bool = delete; tmp = tmp_2->GetPrevNcNnl(); } else { // auto f03() noexcept(true) -> bool; // auto f04() noexcept(false) -> bool; // auto f06() noexcept(true) -> bool = delete; // auto f07() noexcept(false) -> bool = delete; tmp = tmp_2; } } else if (tmp->Is(CT_THROW)) { // throw is present tmp_2 = tmp->GetPrevNcNnl(); if (tmp_2->Is(CT_QUALIFIER)) { // auto f23() const throw() -> bool; // auto f24() const throw() -> bool = delete; tmp = tmp_2->GetPrevNcNnl(); } else { // auto f21() throw() -> bool; // auto f22() throw() -> bool = delete; tmp = tmp_2; } } else { LOG_FMT(LNOTE, "%s(%d): NOT COVERED\n", __func__, __LINE__); } } else { LOG_FMT(LNOTE, "%s(%d): NOT COVERED\n", __func__, __LINE__); } if ( tmp->Is(CT_FPAREN_CLOSE) && ( tmp->GetParentType() == CT_FUNC_PROTO || tmp->GetParentType() == CT_FUNC_DEF)) { pc->SetType(CT_TRAILING_RET); LOG_FMT(LNOTE, "%s(%d): set trailing return type for Text() is '%s'\n", __func__, __LINE__, pc->Text()); // Issue #3222 // TODO // https://en.cppreference.com/w/cpp/language/function // noptr-declarator ( parameter-list ) cv(optional) ref(optional) except(optional) attr(optional) -> trailing Chunk *next = pc->GetNextNcNnl(); if (next->Is(CT_DECLTYPE)) { // TODO } else if (next->Is(CT_WORD)) { next->SetType(CT_TYPE); // Issue #3222 next = next->GetNextNcNnl(); if (next->Is(CT_ARITH)) { if (next->GetStr()[0] == '*') { next->SetType(CT_PTR_TYPE); } else if (next->GetStr()[0] == '&') // Issue #3407 { next->SetType(CT_BYREF); } } } else { // TODO } } } } } // tokenize_trailing_return_types void tokenize_cleanup() { LOG_FUNC_ENTRY(); Chunk *prev = Chunk::NullChunkPtr; Chunk *next; bool in_type_cast = false; cpd.unc_stage = unc_stage_e::TOKENIZE_CLEANUP; /* * Since [] is expected to be TSQUARE for the 'operator', we need to make * this change in the first pass. */ Chunk *pc; for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if (pc->Is(CT_SQUARE_OPEN)) { next = pc->GetNextNcNnl(); if (next->Is(CT_SQUARE_CLOSE)) { // Change '[' + ']' into '[]' pc->SetType(CT_TSQUARE); pc->Str() = "[]"; /* * bug #664: The original m_origColEnd of CT_SQUARE_CLOSE is * stored at m_origColEnd of CT_TSQUARE. * pc->SetOrigColEnd(pc->GetOrigColEnd() + 1); */ pc->SetOrigColEnd(next->GetOrigColEnd()); Chunk::Delete(next); } } if ( pc->Is(CT_SEMICOLON) && pc->TestFlags(PCF_IN_PREPROC) && !pc->GetNextNcNnl(E_Scope::PREPROC)) { LOG_FMT(LNOTE, "%s(%d): %s:%zu Detected a macro that ends with a semicolon. Possible failures if used.\n", __func__, __LINE__, cpd.filename.c_str(), pc->GetOrigLine()); } } // change := to CT_SQL_ASSIGN Issue #527 for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl()) { if (pc->Is(CT_COLON)) { next = pc->GetNextNcNnl(); if (next->Is(CT_ASSIGN)) { // Change ':' + '=' into ':=' pc->SetType(CT_SQL_ASSIGN); pc->Str() = ":="; pc->SetOrigColEnd(next->GetOrigColEnd()); Chunk::Delete(next); } } } // We can handle everything else in the second pass pc = Chunk::GetHead(); next = pc->GetNextNcNnl(); while ( pc->IsNotNullChunk() && next->IsNotNullChunk()) { if ( pc->Is(CT_DOT) && language_is_set(LANG_ALLC)) { pc->SetType(CT_MEMBER); } if ( pc->Is(CT_NULLCOND) && language_is_set(LANG_CS)) { pc->SetType(CT_MEMBER); } // Determine the version stuff (D only) if (pc->Is(CT_D_VERSION)) { if (next->Is(CT_PAREN_OPEN)) { pc->SetType(CT_D_VERSION_IF); } else { if (next->IsNot(CT_ASSIGN)) { LOG_FMT(LERR, "%s(%d): %s:%zu: version: Unexpected token %s\n", __func__, __LINE__, cpd.filename.c_str(), pc->GetOrigLine(), get_token_name(next->GetType())); exit(EX_SOFTWARE); } pc->SetType(CT_WORD); } } // Determine the scope stuff (D only) if (pc->Is(CT_D_SCOPE)) { if (next->Is(CT_PAREN_OPEN)) { pc->SetType(CT_D_SCOPE_IF); } else { pc->SetType(CT_TYPE); } } /* * Change CT_BASE before CT_PAREN_OPEN to CT_WORD. * public myclass() : base() {} * -or- * var x = (T)base.y; */ if ( pc->Is(CT_BASE) && ( next->Is(CT_PAREN_OPEN) || next->Is(CT_DOT))) { pc->SetType(CT_WORD); } if ( pc->Is(CT_ENUM) && ( next->Is(CT_STRUCT) || next->Is(CT_CLASS))) { next->SetType(CT_ENUM_CLASS); } Chunk *next_non_attr = language_is_set(LANG_CPP) ? skip_attribute_next(next) : next; /* * Change CT_WORD after CT_ENUM, CT_UNION, CT_STRUCT, or CT_CLASS to CT_TYPE * Change CT_WORD before CT_WORD to CT_TYPE */ if (next_non_attr->Is(CT_WORD)) { if (pc->IsClassEnumStructOrUnion()) { next_non_attr->SetType(CT_TYPE); } if (pc->Is(CT_WORD)) { pc->SetType(CT_TYPE); } } /* * change extern to qualifier if extern isn't followed by a string or * an open parenthesis */ if (pc->Is(CT_EXTERN)) { if (next->Is(CT_STRING)) { // Probably 'extern "C"' } else if (next->Is(CT_PAREN_OPEN)) { // Probably 'extern (C)' } else { // Something else followed by a open brace Chunk *tmp = next->GetNextNcNnl(); if ( tmp->IsNullChunk() || tmp->IsNot(CT_BRACE_OPEN)) { pc->SetType(CT_QUALIFIER); } } } /* * Change CT_STAR to CT_PTR_TYPE if preceded by * CT_TYPE, CT_QUALIFIER, or CT_PTR_TYPE * or by a * CT_WORD which is preceded by CT_DC_MEMBER: '::aaa *b' */ if ( (next->Is(CT_STAR)) || ( language_is_set(LANG_CPP) && (next->Is(CT_CARET))) || ( language_is_set(LANG_CS | LANG_VALA) && (next->Is(CT_QUESTION)) && (strcmp(pc->Text(), "null") != 0))) { if ( pc->Is(CT_TYPE) || pc->Is(CT_QUALIFIER) || pc->Is(CT_PTR_TYPE)) { next->SetType(CT_PTR_TYPE); } } if ( pc->Is(CT_TYPE_CAST) && next->Is(CT_ANGLE_OPEN)) { next->SetParentType(CT_TYPE_CAST); in_type_cast = true; } if (pc->Is(CT_DECLTYPE)) { flag_cpp_decltype(pc); } // Change angle open/close to CT_COMPARE, if not a template thingy if ( pc->Is(CT_ANGLE_OPEN) && pc->GetParentType() != CT_TYPE_CAST) { /* * pretty much all languages except C use <> for something other than * comparisons. "#include" is handled elsewhere. */ if (language_is_set(LANG_OC | LANG_CPP | LANG_CS | LANG_JAVA | LANG_VALA)) { // bug #663 check_template(pc, in_type_cast); } else { // convert CT_ANGLE_OPEN to CT_COMPARE pc->SetType(CT_COMPARE); } } if ( pc->Is(CT_ANGLE_CLOSE) && pc->GetParentType() != CT_TEMPLATE) { if (in_type_cast) { in_type_cast = false; pc->SetParentType(CT_TYPE_CAST); } else { next = handle_double_angle_close(pc); } } if (language_is_set(LANG_D)) { // Check for the D string concat symbol '~' if ( pc->Is(CT_INV) && ( prev->Is(CT_STRING) || prev->Is(CT_WORD) || next->Is(CT_STRING))) { pc->SetType(CT_CONCAT); } // Check for the D template symbol '!' (word + '!' + word or '(') if ( pc->Is(CT_NOT) && prev->Is(CT_WORD) && ( next->Is(CT_PAREN_OPEN) || next->Is(CT_WORD) || next->Is(CT_TYPE) || next->Is(CT_NUMBER) || next->Is(CT_NUMBER_FP) || next->Is(CT_STRING) || next->Is(CT_STRING_MULTI))) { pc->SetType(CT_D_TEMPLATE); } // handle "version(unittest) { }" vs "unittest { }" if ( pc->Is(CT_UNITTEST) && prev->Is(CT_PAREN_OPEN)) { pc->SetType(CT_WORD); } // handle 'static if' and merge the tokens if ( pc->Is(CT_IF) && prev->IsString("static")) { // delete PREV and merge with IF pc->Str().insert(0, ' '); pc->Str().insert(0, prev->GetStr()); pc->SetOrigCol(prev->GetOrigCol()); pc->SetOrigLine(prev->GetOrigLine()); Chunk *to_be_deleted = prev; prev = prev->GetPrevNcNnl(); if (prev->IsNotNullChunk()) { Chunk::Delete(to_be_deleted); } } } if (language_is_set(LANG_CPP)) { // Change Word before '::' into a type if ( pc->Is(CT_WORD) && next->Is(CT_DC_MEMBER)) { prev = pc->GetPrev(); if (prev->IsNullChunk()) // Issue #3010 { pc->SetType(CT_TYPE); } else { if (prev->Is(CT_COLON)) { // nothing to do } else { pc->SetType(CT_TYPE); } } } // Set parent type for 'if constexpr' if ( prev->Is(CT_IF) && pc->Is(CT_QUALIFIER) && pc->IsString("constexpr")) { pc->SetType(CT_CONSTEXPR); } } // Change get/set to CT_WORD if not followed by a brace open if ( pc->Is(CT_GETSET) && next->IsNot(CT_BRACE_OPEN)) { if ( next->Is(CT_SEMICOLON) && ( prev->Is(CT_BRACE_CLOSE) || prev->Is(CT_BRACE_OPEN) || prev->Is(CT_SEMICOLON))) { pc->SetType(CT_GETSET_EMPTY); next->SetParentType(CT_GETSET); } else { pc->SetType(CT_WORD); } } /* * Interface is only a keyword in MS land if followed by 'class' or 'struct' * likewise, 'class' may be a member name in Java. */ if ( pc->Is(CT_CLASS) && !CharTable::IsKw1(next->GetStr()[0])) { if ( next->IsNot(CT_DC_MEMBER) && next->IsNot(CT_ATTRIBUTE)) // Issue #2570 { pc->SetType(CT_WORD); } else if ( prev->Is(CT_DC_MEMBER) || prev->Is(CT_TYPE)) { pc->SetType(CT_TYPE); } else if (next->Is(CT_DC_MEMBER)) { Chunk *next2 = next->GetNextNcNnlNet(); if ( next2->Is(CT_INV) // CT_INV hasn't turned into CT_DESTRUCTOR just yet || ( next2->Is(CT_CLASS) // constructor isn't turned into CT_FUNC* just yet && !strcmp(pc->Text(), next2->Text()))) { pc->SetType(CT_TYPE); } } } /* * Change item after operator (>=, ==, etc) to a CT_OPERATOR_VAL * Usually the next item is part of the operator. * In a few cases the next few tokens are part of it: * operator + - common case * operator >> - need to combine '>' and '>' * operator () * operator [] - already converted to TSQUARE * operator new [] * operator delete [] * operator const char * * operator const B& * operator std::allocator * * In all cases except the last, this will put the entire operator value * in one chunk. */ if (pc->Is(CT_OPERATOR)) { Chunk *tmp2 = next->GetNext(); // Handle special case of () operator -- [] already handled if (next->Is(CT_PAREN_OPEN)) { Chunk *tmp = next->GetNext(); if (tmp->Is(CT_PAREN_CLOSE)) { next->Str() = "()"; next->SetType(CT_OPERATOR_VAL); Chunk::Delete(tmp); next->SetOrigColEnd(next->GetOrigColEnd() + 1); } } else if ( next->Is(CT_ANGLE_CLOSE) && tmp2->Is(CT_ANGLE_CLOSE) && tmp2->GetOrigCol() == next->GetOrigColEnd()) { next->Str().append('>'); next->SetOrigColEnd(next->GetOrigColEnd() + 1); next->SetType(CT_OPERATOR_VAL); Chunk::Delete(tmp2); } else if (next->TestFlags(PCF_PUNCTUATOR)) { next->SetType(CT_OPERATOR_VAL); } else { next->SetType(CT_TYPE); /* * Replace next with a collection of all tokens that are part of * the type. */ tmp2 = next; Chunk *tmp; while ((tmp = tmp2->GetNext())->IsNotNullChunk()) { if ( tmp->IsNot(CT_WORD) && tmp->IsNot(CT_TYPE) && tmp->IsNot(CT_QUALIFIER) && tmp->IsNot(CT_STAR) && tmp->IsNot(CT_CARET) && tmp->IsNot(CT_AMP) && tmp->IsNot(CT_TSQUARE)) { break; } // Change tmp into a type so that space_needed() works right make_type(tmp); size_t num_sp = space_needed(tmp2, tmp); while (num_sp-- > 0) { next->Str().append(" "); } next->Str().append(tmp->GetStr()); tmp2 = tmp; } while ((tmp2 = next->GetNext()) != tmp) { Chunk::Delete(tmp2); } next->SetType(CT_OPERATOR_VAL); next->SetOrigColEnd(next->GetOrigCol() + next->Len()); } next->SetParentType(CT_OPERATOR); LOG_FMT(LOPERATOR, "%s(%d): %zu:%zu operator '%s'\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), next->Text()); } // Change private, public, protected into either a qualifier or label if (pc->Is(CT_ACCESS)) { // Handle Qt slots - maybe should just check for a CT_WORD? if ( next->IsString("slots") || next->IsString("Q_SLOTS")) { Chunk *tmp = next->GetNext(); if (tmp->Is(CT_COLON)) { next = tmp; } } if (next->Is(CT_COLON)) { next->SetType(CT_ACCESS_COLON); Chunk *tmp; if ((tmp = next->GetNextNcNnl())->IsNotNullChunk()) { tmp->SetFlagBits(PCF_STMT_START | PCF_EXPR_START); } } else { pc->SetType(( pc->IsString("signals") || pc->IsString("Q_SIGNALS")) ? CT_WORD : CT_QUALIFIER); } } // Look for 'EXEC' 'SQL' if ( ( pc->IsString("EXEC", false) && next->IsString("SQL", false)) || ( (*pc->GetStr().c_str() == '$') && pc->IsNot(CT_SQL_WORD) /* but avoid breaking tokenization for C# 6 interpolated strings. */ && ( !language_is_set(LANG_CS) || ( pc->Is(CT_STRING) && (!pc->GetStr().startswith("$\"")) && (!pc->GetStr().startswith("$@\"")))))) { Chunk *tmp = pc->GetPrev(); if (tmp->IsNewline()) { if (*pc->GetStr().c_str() == '$') { pc->SetType(CT_SQL_EXEC); if (pc->Len() > 1) { // SPLIT OFF '$' Chunk nc; nc = *pc; pc->Str().resize(1); pc->SetOrigColEnd(pc->GetOrigCol() + 1); nc.SetType(CT_SQL_WORD); nc.Str().pop_front(); nc.SetOrigCol(nc.GetOrigCol() + 1); nc.SetColumn(nc.GetColumn() + 1); nc.CopyAndAddAfter(pc); next = pc->GetNext(); } } tmp = next->GetNext(); if (tmp->IsString("BEGIN", false)) { pc->SetType(CT_SQL_BEGIN); } else if (tmp->IsString("END", false)) { pc->SetType(CT_SQL_END); } else { pc->SetType(CT_SQL_EXEC); } // Change words into CT_SQL_WORD until CT_SEMICOLON while (tmp->IsNotNullChunk()) { if (tmp->Is(CT_SEMICOLON)) { break; } if ( (tmp->Len() > 0) && ( unc_isalpha(*tmp->GetStr().c_str()) || (*tmp->GetStr().c_str() == '$'))) { tmp->SetType(CT_SQL_WORD); } tmp = tmp->GetNextNcNnl(); } } } // handle MS abomination 'for each' if ( pc->Is(CT_FOR) && next->IsString("each") && (next == pc->GetNext())) { // merge the two with a space between pc->Str().append(' '); pc->Str() += next->GetStr(); pc->SetOrigColEnd(next->GetOrigColEnd()); Chunk::Delete(next); next = pc->GetNextNcNnl(); // label the 'in' if (next->Is(CT_PAREN_OPEN)) { Chunk *tmp = next->GetNextNcNnl(); while ( tmp->IsNotNullChunk() && tmp->IsNot(CT_PAREN_CLOSE)) { if (tmp->IsString("in")) { tmp->SetType(CT_IN); break; } tmp = tmp->GetNextNcNnl(); } } } /* * ObjectiveC allows keywords to be used as identifiers in some situations * This is a dirty hack to allow some of the more common situations. */ if (language_is_set(LANG_OC)) { if ( ( pc->Is(CT_IF) || pc->Is(CT_FOR) || pc->Is(CT_WHILE)) && !next->Is(CT_PAREN_OPEN)) { pc->SetType(CT_WORD); } if ( pc->Is(CT_DO) && ( prev->Is(CT_MINUS) || next->Is(CT_SQUARE_CLOSE))) { pc->SetType(CT_WORD); } // Fix self keyword back to word when mixing c++/objective-c if ( pc->Is(CT_THIS) && !strcmp(pc->Text(), "self") && ( next->Is(CT_COMMA) || next->Is(CT_PAREN_CLOSE))) { pc->SetType(CT_WORD); } // Fix self keyword back to word when mixing c++/objective-c if ( pc->Is(CT_THIS) && !strcmp(pc->Text(), "self") && ( next->Is(CT_COMMA) || next->Is(CT_PAREN_CLOSE))) { pc->SetType(CT_WORD); } } // Vala allows keywords to be used as identifiers if (language_is_set(LANG_VALA)) { if ( find_keyword_type(pc->Text(), pc->Len()) != CT_WORD && ( prev->Is(CT_DOT) || next->Is(CT_DOT) || prev->Is(CT_MEMBER) || next->Is(CT_MEMBER) || prev->Is(CT_TYPE))) { pc->SetType(CT_WORD); } } // Another hack to clean up more keyword abuse if ( pc->Is(CT_CLASS) && ( prev->Is(CT_DOT) || next->Is(CT_DOT) || prev->Is(CT_MEMBER) // Issue #3031 || next->Is(CT_MEMBER))) { pc->SetType(CT_WORD); } // Detect Objective C class name if ( pc->Is(CT_OC_IMPL) || pc->Is(CT_OC_INTF) || pc->Is(CT_OC_PROTOCOL)) { if (next->IsNot(CT_PAREN_OPEN)) { next->SetType(CT_OC_CLASS); } next->SetParentType(pc->GetType()); Chunk *tmp = next->GetNextNcNnl(); if (tmp->IsNotNullChunk()) { tmp->SetFlagBits(PCF_STMT_START | PCF_EXPR_START); } tmp = pc->GetNextType(CT_OC_END, pc->GetLevel()); if (tmp->IsNotNullChunk()) { tmp->SetParentType(pc->GetType()); } } if (pc->Is(CT_OC_INTF)) { Chunk *tmp = pc->GetNextNcNnl(E_Scope::PREPROC); while ( tmp->IsNotNullChunk() && tmp->IsNot(CT_OC_END)) { if (get_token_pattern_class(tmp->GetType()) != pattern_class_e::NONE) { LOG_FMT(LOBJCWORD, "%s(%d): @interface %zu:%zu change '%s' (%s) to CT_WORD\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), tmp->Text(), get_token_name(tmp->GetType())); tmp->SetType(CT_WORD); } tmp = tmp->GetNextNcNnl(E_Scope::PREPROC); } } /* * Detect Objective-C categories and class extensions: * @interface ClassName (CategoryName) * @implementation ClassName (CategoryName) * @interface ClassName () * @implementation ClassName () */ if ( ( pc->GetParentType() == CT_OC_IMPL || pc->GetParentType() == CT_OC_INTF || pc->Is(CT_OC_CLASS)) && next->Is(CT_PAREN_OPEN)) { next->SetParentType(pc->GetParentType()); Chunk *tmp = next->GetNext(); if ( tmp->IsNotNullChunk() && tmp->GetNext()->IsNotNullChunk()) { if (tmp->Is(CT_PAREN_CLOSE)) { //tmp->SetType(CT_OC_CLASS_EXT); tmp->SetParentType(pc->GetParentType()); } else { tmp->SetType(CT_OC_CATEGORY); tmp->SetParentType(pc->GetParentType()); } } tmp = pc->GetNextType(CT_PAREN_CLOSE, pc->GetLevel()); if (tmp->IsNotNullChunk()) { tmp->SetParentType(pc->GetParentType()); } } /* * Detect Objective C @property: * @property NSString *stringProperty; * @property(nonatomic, retain) NSMutableDictionary *shareWith; */ if (pc->Is(CT_OC_PROPERTY)) { if (next->IsNot(CT_PAREN_OPEN)) { next->SetFlagBits(PCF_STMT_START | PCF_EXPR_START); } else { cleanup_objc_property(pc); } } /* * Detect Objective C @selector: * @selector(msgNameWithNoArg) * @selector(msgNameWith1Arg:) * @selector(msgNameWith2Args:arg2Name:) */ if ( pc->Is(CT_OC_SEL) && next->Is(CT_PAREN_OPEN)) { next->SetParentType(pc->GetType()); Chunk *tmp = next->GetNext(); if (tmp->IsNotNullChunk()) { tmp->SetType(CT_OC_SEL_NAME); tmp->SetParentType(pc->GetType()); while ((tmp = tmp->GetNextNcNnl())->IsNotNullChunk()) { if (tmp->Is(CT_PAREN_CLOSE)) { tmp->SetParentType(CT_OC_SEL); break; } tmp->SetType(CT_OC_SEL_NAME); tmp->SetParentType(pc->GetType()); } } } // Handle special preprocessor junk if (pc->Is(CT_PREPROC)) { pc->SetParentType(next->GetType()); } // Detect "pragma region" and "pragma endregion" if ( pc->Is(CT_PP_PRAGMA) && next->Is(CT_PREPROC_BODY)) { if ( (strncmp(next->GetStr().c_str(), "region", 6) == 0) || (strncmp(next->GetStr().c_str(), "endregion", 9) == 0)) // TODO: probably better use strncmp { pc->SetType((*next->GetStr().c_str() == 'r') ? CT_PP_REGION : CT_PP_ENDREGION); prev->SetParentType(pc->GetType()); } } // Change 'default(' into a sizeof-like statement if ( language_is_set(LANG_CS) && pc->Is(CT_DEFAULT) && next->Is(CT_PAREN_OPEN)) { pc->SetType(CT_SIZEOF); } if ( pc->Is(CT_UNSAFE) && next->IsNot(CT_BRACE_OPEN)) { pc->SetType(CT_QUALIFIER); } if ( ( pc->Is(CT_USING) || ( pc->Is(CT_TRY) && language_is_set(LANG_JAVA))) && next->Is(CT_PAREN_OPEN)) { pc->SetType(CT_USING_STMT); } // Add minimal support for C++0x rvalue references if ( pc->Is(CT_BOOL) && language_is_set(LANG_CPP) && pc->IsString("&&")) { if (prev->Is(CT_TYPE)) { // Issue # 1002 if (!pc->TestFlags(PCF_IN_TEMPLATE)) { pc->SetType(CT_BYREF); } } } /* * HACK: treat try followed by a colon as a qualifier to handle this: * A::A(int) try : B() { } catch (...) { } */ if ( pc->Is(CT_TRY) && pc->IsString("try") && next->Is(CT_COLON)) { pc->SetType(CT_QUALIFIER); } /* * If Java's 'synchronized' is in a method declaration, it should be * a qualifier. */ if ( language_is_set(LANG_JAVA) && pc->Is(CT_SYNCHRONIZED) && next->IsNot(CT_PAREN_OPEN)) { pc->SetType(CT_QUALIFIER); } // change CT_DC_MEMBER + CT_FOR into CT_DC_MEMBER + CT_FUNC_CALL if ( pc->Is(CT_FOR) && pc->GetPrev()->Is(CT_DC_MEMBER)) { pc->SetType(CT_FUNC_CALL); } // TODO: determine other stuff here prev = pc; pc = next; next = pc->GetNextNcNnl(); } } // tokenize_cleanup bool invalid_open_angle_template(Chunk *prev) { if (prev == nullptr) { return(false); } // A template requires a word/type right before the open angle return( prev->IsNot(CT_WORD) && prev->IsNot(CT_TYPE) && prev->IsNot(CT_COMMA) && prev->IsNot(CT_QUALIFIER) && prev->IsNot(CT_OPERATOR_VAL) && prev->GetParentType() != CT_OPERATOR); } static void check_template(Chunk *start, bool in_type_cast) { LOG_FMT(LTEMPL, "%s(%d): orig line %zu, orig col %zu:\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol()); Chunk *prev = start->GetPrevNcNnl(E_Scope::PREPROC); if (prev->IsNullChunk()) { return; } Chunk *end; Chunk *pc; if (prev->Is(CT_TEMPLATE)) { LOG_FMT(LTEMPL, "%s(%d): CT_TEMPLATE:\n", __func__, __LINE__); // We have: "template< ... >", which is a template declaration size_t level = 1; size_t parens = 0; for (pc = start->GetNextNcNnl(E_Scope::PREPROC); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl(E_Scope::PREPROC)) { LOG_FMT(LTEMPL, "%s(%d): type is %s, level is %zu\n", __func__, __LINE__, get_token_name(pc->GetType()), level); if ( (pc->GetStr()[0] == '>') && (pc->Len() > 1)) { if (pc->GetStr()[1] == '=') // Issue #1462 and #2565 { LOG_FMT(LTEMPL, "%s(%d): do not split '%s' at orig line %zu, orig col %zu\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); } else { LOG_FMT(LTEMPL, "%s(%d): {split '%s' at orig line %zu, orig col %zu}\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); split_off_angle_close(pc); } } if (pc->Is(CT_DECLTYPE)) { flag_cpp_decltype(pc); } else if (pc->Is(CT_PAREN_OPEN)) { ++parens; } else if (pc->Is(CT_PAREN_CLOSE)) { --parens; } if (parens == 0) { if (pc->IsString("<")) { level++; } else if (pc->IsString(">")) { if (level == 0) { fprintf(stderr, "%s(%d): level is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } level--; if (level == 0) { break; } } } } end = pc; } else { /* * We may have something like "a< ... >", which is a template where * '...' may consist of anything except a semicolon, unbalanced * parens, or braces (with one exception being braced initializers * embedded within decltypes). * * For example, braces may be encountered as such in the following * snippet of valid C++ code: * * template::type, * decltype (make_index_sequence<5> { })>::value>> * void foo(T &&arg) * { * * } * * Finally, if we are inside an 'if' statement and hit a CT_BOOL, * then it isn't a template. */ if (invalid_open_angle_template(prev)) { LOG_FMT(LTEMPL, "%s(%d): - after type %s + ( - Not a template\n", __func__, __LINE__, get_token_name(prev->GetType())); start->SetType(CT_COMPARE); return; } LOG_FMT(LTEMPL, "%s(%d): - prev->GetType() is %s -\n", __func__, __LINE__, get_token_name(prev->GetType())); // Scan back and make sure we aren't inside square parenthesis bool in_if = false; bool hit_semicolon = false; pc = start->GetPrevNcNnl(E_Scope::PREPROC); while (pc->IsNotNullChunk()) { if ( ( pc->Is(CT_SEMICOLON) && hit_semicolon) || pc->Is(CT_SQUARE_CLOSE)) { break; } if (pc->Is(CT_DECLTYPE)) { flag_cpp_decltype(pc); } if (pc->Is(CT_BRACE_OPEN)) { if ( !pc->TestFlags(PCF_IN_DECLTYPE) || !detect_cpp_braced_init_list(pc->GetPrev(), pc)) { break; } flag_cpp_braced_init_list(pc->GetPrev(), pc); } if ( pc->Is(CT_BRACE_CLOSE) && pc->GetParentType() != CT_BRACED_INIT_LIST && !pc->TestFlags(PCF_IN_DECLTYPE)) { break; } if ( pc->Is(CT_SEMICOLON) && !hit_semicolon) { hit_semicolon = true; } if ( ( ( pc->Is(CT_IF) || pc->Is(CT_RETURN) || pc->Is(CT_WHILE) || pc->Is(CT_WHILE_OF_DO)) && !hit_semicolon) || ( pc->Is(CT_FOR) && hit_semicolon)) { in_if = true; break; } pc = pc->GetPrevNcNnl(E_Scope::PREPROC); } /* * Scan forward to the angle close * If we have a comparison in there, then it can't be a template. */ const int max_token_count = 1024; E_Token tokens[max_token_count]; size_t num_tokens = 1; tokens[0] = CT_ANGLE_OPEN; for (pc = start->GetNextNcNnl(E_Scope::PREPROC); pc->IsNotNullChunk(); pc = pc->GetNextNcNnl(E_Scope::PREPROC)) { constexpr static auto LCURRENT = LTEMPL; LOG_FMT(LTEMPL, "%s(%d): pc orig line is %zu, orig col is %zu, type is %s, num_tokens is %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), num_tokens); log_rule_B("tok_split_gte"); if (pc->Is(CT_BRACE_OPEN)) // Issue #2886 { // look for the closing brace Chunk *A = pc->GetClosingParen(); LOG_FMT(LTEMPL, "%s(%d): A orig line is %zu, orig col is %zu, type is %s\n", __func__, __LINE__, A->GetOrigLine(), A->GetOrigCol(), get_token_name(A->GetType())); pc = A->GetNext(); } if ( (tokens[num_tokens - 1] == CT_ANGLE_OPEN) && (pc->GetStr()[0] == '>') && (pc->Len() > 1) && ( options::tok_split_gte() || ( ( pc->IsString(">>") || pc->IsString(">>>")) && ( num_tokens >= 2 || ( num_tokens >= 1 && in_type_cast))))) { LOG_FMT(LTEMPL, "%s(%d): {split '%s' at orig line %zu, orig col %zu}\n", __func__, __LINE__, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol()); split_off_angle_close(pc); } if (pc->IsString("<")) { if ( num_tokens > 0 && (tokens[num_tokens - 1] == CT_PAREN_OPEN) && invalid_open_angle_template(pc->GetPrev())) { pc->SetType(CT_COMPARE); // Issue #3127 } else { tokens[num_tokens] = CT_ANGLE_OPEN; num_tokens++; } } else if (pc->IsString(">")) { if (num_tokens > 0 && (tokens[num_tokens - 1] == CT_PAREN_OPEN)) { handle_double_angle_close(pc); } else if (--num_tokens <= 0) { break; } else if (tokens[num_tokens] != CT_ANGLE_OPEN) { break; // unbalanced parentheses } } else if ( in_if && ( pc->Is(CT_BOOL) || pc->Is(CT_COMPARE))) { break; } else if (pc->Is(CT_BRACE_OPEN)) { if ( !pc->TestFlags(PCF_IN_DECLTYPE) || !detect_cpp_braced_init_list(pc->GetPrev(), pc)) { break; } auto brace_open = pc->GetNextNcNnl(); auto brace_close = brace_open->GetClosingParen(); brace_open->SetParentType(CT_BRACED_INIT_LIST); brace_close->SetParentType(CT_BRACED_INIT_LIST); } else if ( pc->Is(CT_BRACE_CLOSE) && pc->GetParentType() != CT_BRACED_INIT_LIST && !pc->TestFlags(PCF_IN_DECLTYPE)) { break; } else if (pc->Is(CT_SEMICOLON)) { break; } else if (pc->Is(CT_PAREN_OPEN)) { if (num_tokens >= max_token_count - 1) { break; } tokens[num_tokens] = CT_PAREN_OPEN; num_tokens++; } else if ( pc->Is(CT_QUESTION) // Issue #2949 && language_is_set(LANG_CPP)) { break; } else if (pc->Is(CT_PAREN_CLOSE)) { if (num_tokens == 0) { fprintf(stderr, "%s(%d): num_tokens is ZERO, cannot be decremented, at line %zu, column %zu\n", __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol()); log_flush(true); exit(EX_SOFTWARE); } num_tokens--; if (tokens[num_tokens] != CT_PAREN_OPEN) { break; // unbalanced parentheses } } } end = pc; } if (end->Is(CT_ANGLE_CLOSE)) { pc = end->GetNextNcNnl(E_Scope::PREPROC); if ( pc->IsNullChunk() || pc->IsNot(CT_NUMBER)) { LOG_FMT(LTEMPL, "%s(%d): Template detected\n", __func__, __LINE__); LOG_FMT(LTEMPL, "%s(%d): from orig line %zu, orig col %zu\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol()); LOG_FMT(LTEMPL, "%s(%d): to orig line %zu, orig col %zu\n", __func__, __LINE__, end->GetOrigLine(), end->GetOrigCol()); start->SetParentType(CT_TEMPLATE); check_template_args(start, end); end->SetParentType(CT_TEMPLATE); end->SetFlagBits(PCF_IN_TEMPLATE); return; } } LOG_FMT(LTEMPL, "%s(%d): - Not a template: end = %s\n", __func__, __LINE__, (end != nullptr) ? get_token_name(end->GetType()) : ""); start->SetType(CT_COMPARE); } // check_template static void check_template_arg(Chunk *start, Chunk *end) { LOG_FMT(LTEMPL, "%s(%d): Template argument detected\n", __func__, __LINE__); LOG_FMT(LTEMPL, "%s(%d): from orig line %zu, orig col %zu\n", __func__, __LINE__, start->GetOrigLine(), start->GetOrigCol()); LOG_FMT(LTEMPL, "%s(%d): to orig line %zu, orig col %zu\n", __func__, __LINE__, end->GetOrigLine(), end->GetOrigCol()); // Issue #1127 // MyFoo foo1; // MyFoo<2*mySize * 2> foo1; // Issue #1346 // use it as ONE line: // typename std::enable_if::value, // QVector >::type dummy(const std::function& // pFunc, const QVector& pItems) // we need two runs // 1. run to test if expression is numeric bool expressionIsNumeric = false; Chunk *pc = start; while (pc != end) { Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); // a test "if (next == nullptr)" is not necessary pc->SetFlagBits(PCF_IN_TEMPLATE); if ( pc->Is(CT_DECLTYPE) || pc->Is(CT_SIZEOF)) { expressionIsNumeric = true; break; } if (next->IsNot(CT_PAREN_OPEN)) { if ( pc->Is(CT_NUMBER) || pc->Is(CT_ARITH) || pc->Is(CT_SHIFT)) { expressionIsNumeric = true; break; } } pc = next; } LOG_FMT(LTEMPL, "%s(%d): expressionIsNumeric is %s\n", __func__, __LINE__, expressionIsNumeric ? "TRUE" : "FALSE"); // 2. run to do the work if (!expressionIsNumeric) { pc = start; while (pc != end) { Chunk *next = pc->GetNextNcNnl(E_Scope::PREPROC); // a test "if (next == nullptr)" is not necessary pc->SetFlagBits(PCF_IN_TEMPLATE); Chunk *prev = pc->GetPrevNcNnl(E_Scope::PREPROC); Chunk *prev2 = prev->GetPrevNcNnl(E_Scope::PREPROC); if ( prev->Is(CT_ELLIPSIS) // Issue #3309 && prev2->Is(CT_TYPENAME)) { pc->SetType(CT_PARAMETER_PACK); } else { make_type(pc); } pc = next; } } } // check_template_arg static void check_template_args(Chunk *start, Chunk *end) { std::vector tokens; // Scan for commas Chunk *pc; for (pc = start->GetNextNcNnl(E_Scope::PREPROC); pc->IsNotNullChunk() && pc != end; pc = pc->GetNextNcNnl(E_Scope::PREPROC)) { switch (pc->GetType()) { case CT_COMMA: if (tokens.empty()) { // Check current argument check_template_args(start, pc); start = pc; } break; case CT_ANGLE_OPEN: case CT_PAREN_OPEN: tokens.push_back(pc->GetType()); break; case CT_ANGLE_CLOSE: if ( !tokens.empty() && tokens.back() == CT_ANGLE_OPEN) { tokens.pop_back(); } break; case CT_PAREN_CLOSE: if ( !tokens.empty() && tokens.back() == CT_PAREN_OPEN) { tokens.pop_back(); } break; default: break; } } // Check whatever is left check_template_arg(start, end); } // check_template_args static void cleanup_objc_property(Chunk *start) { assert(start->Is(CT_OC_PROPERTY)); Chunk *open_paren = start->GetNextType(CT_PAREN_OPEN, start->GetLevel()); if (open_paren->IsNullChunk()) { LOG_FMT(LTEMPL, "%s(%d): Property is not followed by opening paren\n", __func__, __LINE__); return; } open_paren->SetParentType(start->GetType()); Chunk *tmp = start->GetNextType(CT_PAREN_CLOSE, start->GetLevel()); if (tmp->IsNotNullChunk()) { tmp->SetParentType(start->GetType()); tmp = tmp->GetNextNcNnl(); if (tmp->IsNotNullChunk()) { tmp->SetFlagBits(PCF_STMT_START | PCF_EXPR_START); tmp = tmp->GetNextType(CT_SEMICOLON, start->GetLevel()); if (tmp->IsNotNullChunk()) { tmp->SetParentType(start->GetType()); } } } mark_selectors_in_property_with_open_paren(open_paren); mark_attributes_in_property_with_open_paren(open_paren); } static void mark_selectors_in_property_with_open_paren(Chunk *open_paren) { assert(open_paren->Is(CT_PAREN_OPEN)); Chunk *tmp = open_paren; while (tmp->IsNot(CT_PAREN_CLOSE)) { if ( tmp->Is(CT_WORD) && ( tmp->IsString("setter") || tmp->IsString("getter"))) { tmp = tmp->GetNext(); while ( tmp->IsNotNullChunk() && tmp->IsNot(CT_COMMA) && tmp->IsNot(CT_PAREN_CLOSE)) { if ( tmp->Is(CT_WORD) || tmp->IsString(":")) { tmp->SetType(CT_OC_SEL_NAME); } tmp = tmp->GetNext(); } } else { tmp = tmp->GetNext(); } } } static void mark_attributes_in_property_with_open_paren(Chunk *open_paren) { assert(open_paren->Is(CT_PAREN_OPEN)); Chunk *tmp = open_paren; while (tmp->IsNot(CT_PAREN_CLOSE)) { Chunk *next = tmp->GetNext(); if ( ( tmp->Is(CT_COMMA) || tmp->Is(CT_PAREN_OPEN)) && ( next->Is(CT_WORD) || next->Is(CT_TYPE))) { next->SetType(CT_OC_PROPERTY_ATTR); } tmp = next; } } uncrustify-uncrustify-0.76.0/src/tokenize_cleanup.h000066400000000000000000000012041434072136500225310ustar00rootroot00000000000000/** * @file tokenize_cleanup.h * prototypes for tokenize_cleanup.c * * @author Ben Gardner * @license GPL v2+ */ #ifndef TOKENIZ_CLEANUP_H_INCLUDED #define TOKENIZ_CLEANUP_H_INCLUDED #include "uncrustify_types.h" /** * @brief clean up tokens * * Change certain token types based on simple sequence. * Example: change '[' + ']' to '[]' * Note that level info is not yet available, so it is OK to do all * processing that doesn't need to know level info. (that's very little!) */ void tokenize_cleanup(); void tokenize_trailing_return_types(); void split_off_angle_close(Chunk *pc); #endif /* TOKENIZ_CLEANUP_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/unc_ctype.cpp000066400000000000000000000017321434072136500215240ustar00rootroot00000000000000#include "options.h" int unc_fix_ctype(int ch) { if ( ch >= -1 && ch <= 255) { return(ch); } return(0); // Issue #3025 } int unc_isspace(int ch) { if ( (ch == 12) // Issue #2386 && uncrustify::options::use_form_feed_no_more_as_whitespace_character()) { return(0); } else { return(isspace(unc_fix_ctype(ch))); } } int unc_isprint(int ch) { return(isprint(unc_fix_ctype(ch))); } int unc_isalpha(int ch) { return(isalpha(unc_fix_ctype(ch))); } int unc_isalnum(int ch) { return(isalnum(unc_fix_ctype(ch))); } int unc_toupper(int ch) { return(toupper(unc_fix_ctype(ch))); } int unc_tolower(int ch) { return(tolower(unc_fix_ctype(ch))); } int unc_isxdigit(int ch) { return(isxdigit(unc_fix_ctype(ch))); } int unc_isdigit(int ch) { return(isdigit(unc_fix_ctype(ch))); } int unc_isupper(int ch) { return( isalpha(unc_fix_ctype(ch)) && (unc_toupper(unc_fix_ctype(ch)) == ch)); } uncrustify-uncrustify-0.76.0/src/unc_ctype.h000066400000000000000000000022511434072136500211660ustar00rootroot00000000000000/** * @file unc_ctype.h * The ctype function are only required to handle values 0-255 and EOF. * A char is sign-extended when cast to an int. * With some C libraries, these values cause a crash. * These wrappers will properly handle all char values. * * @author Ben Gardner * @license GPL v2+ */ #ifndef UNC_CTYPE_H_INCLUDED #define UNC_CTYPE_H_INCLUDED #include "options.h" #include // to get std::tolower //! Test anything EOF (-1) to 0-255 int unc_fix_ctype(int ch); //! check if a character is a space int unc_isspace(int ch); //! check if a character is a printing character int unc_isprint(int ch); //! check if a character is an alphabetic character (a letter). int unc_isalpha(int ch); //! check if a character is an alphanumeric character. int unc_isalnum(int ch); //! convert a character to upper case int unc_toupper(int ch); //! convert a character to lower case int unc_tolower(int ch); //! check if a character is a hexadecimal digit int unc_isxdigit(int ch); //! check if a character is a decimal digit int unc_isdigit(int ch); //! check if a character is upper case int unc_isupper(int ch); #endif /* UNC_CTYPE_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/unc_text.cpp000066400000000000000000000344631434072136500213730ustar00rootroot00000000000000/** * @file unc_text.cpp * A simple class that handles the chunk text. * * @author Ben Gardner * @license GPL v2+ */ #include "unc_text.h" #include "unc_ctype.h" #include "unicode.h" // encode_utf8() #include #include using namespace std; static constexpr const int_fast8_t UTF8_BLOCKS = 6; // 6 -> max utf8 blocks per char static size_t fix_len_idx(size_t size, size_t idx, size_t len); //! converts \n and \r chars are into NL and CR UTF8 symbols before encode_utf8 is called static void toLogTextUtf8(int c, unc_text::log_type &container); /** * calculates the size a 'log_type' container needs to have in order to take * in values of a 'unc_text::value_type' up to idx * (without \0, with symbols for the converted \n and \r chars) * * throws if char is greater than 0x7fffffff */ static int getLogTextUtf8Len(unc_text::value_type &c0, size_t end); static int getLogTextUtf8Len(unc_text::value_type &c0, size_t start, size_t end); static int getLogTextUtf8Len(unc_text::value_type &c0, size_t start, size_t end) { size_t c1_idx = 0; for (size_t i = start; i < end; ++i) { auto ch = c0[i]; if (ch == '\n') { ch = 0x2424; // NL symbol } else if (ch == '\r') { ch = 0x240d; // CR symbol } if (ch < 0x80) // 1-byte sequence { c1_idx += 1; } else if (ch < 0x0800) // 2-byte sequence { c1_idx += 2; } else if (ch < 0x10000) // 3-byte sequence { c1_idx += 3; } else if (ch < 0x200000) // 4-byte sequence { c1_idx += 4; } else if (ch < 0x4000000) // 5-byte sequence { c1_idx += 5; } else if (ch <= 0x7fffffff) // 6-byte sequence { c1_idx += 6; } else { throw out_of_range(string(__func__) + ":" + to_string(__LINE__) + " - ch value too big, can't convert to utf8"); } } return(c1_idx); } // getLogTextUTF8Len static int getLogTextUtf8Len(unc_text::value_type &c0, size_t end) { return(getLogTextUtf8Len(c0, 0, end)); } static void toLogTextUtf8(int c, unc_text::log_type &container) { if (c == '\n') { c = 0x2424; // NL symbol } else if (c == '\r') { c = 0x240d; // CR symbol } encode_utf8(c, container); } static size_t fix_len_idx(size_t size, size_t idx, size_t len) { if (idx >= size) { return(0); } const size_t left = size - idx; return((len > left) ? left : len); } unc_text::unc_text() { m_logtext = log_type{ '\0' }; } unc_text::unc_text(const unc_text &ref) { set(ref); } unc_text::unc_text(const unc_text &ref, size_t idx, size_t len) { set(ref, idx, len); } unc_text::unc_text(const char *ascii_text) { set(ascii_text); } unc_text::unc_text(const std::string &ascii_text) { set(ascii_text); } unc_text::unc_text(const value_type &data, size_t idx, size_t len) { set(data, idx, len); } size_t unc_text::size() const { return(m_chars.size()); } unc_text &unc_text::operator=(int ch) { set(ch); return(*this); } unc_text &unc_text::operator=(const unc_text &ref) { set(ref); return(*this); } unc_text &unc_text::operator=(const std::string &ascii_text) { set(ascii_text); return(*this); } unc_text &unc_text::operator=(const char *ascii_text) { set(ascii_text); return(*this); } unc_text &unc_text::operator+=(int ch) { append(ch); return(*this); } unc_text &unc_text::operator+=(const unc_text &ref) { append(ref); return(*this); } unc_text &unc_text::operator+=(const std::string &ascii_text) { append(ascii_text); return(*this); } unc_text &unc_text::operator+=(const char *ascii_text) { append(ascii_text); return(*this); } const unc_text::value_type &unc_text::get() const { return(m_chars); } int unc_text::operator[](size_t idx) const { return((idx < m_chars.size()) ? m_chars[idx] : 0); } const int &unc_text::at(size_t idx) const { return(m_chars.at(idx)); } const int &unc_text::back() const { return(m_chars.back()); } void unc_text::push_back(int ch) { append(ch); } void unc_text::pop_back() { if (size() == 0) { return; } m_chars.pop_back(); update_logtext(); } void unc_text::pop_front() { if (size() == 0) { return; } m_chars.pop_front(); update_logtext(); } void unc_text::update_logtext() { // make a pessimistic guess at the size m_logtext.clear(); m_logtext.reserve(m_chars.size() * 3); for (int m_char : m_chars) { toLogTextUtf8(m_char, m_logtext); } m_logtext.push_back(0); } int unc_text::compare(const unc_text &ref1, const unc_text &ref2, size_t len, bool tcare) { const size_t len1 = ref1.size(); const size_t len2 = ref2.size(); const auto max_idx = std::min({ len, len1, len2 }); size_t idx = 0; for ( ; idx < max_idx; idx++) { // exactly the same character ? if (ref1.m_chars[idx] == ref2.m_chars[idx]) { continue; } int diff; // Issue #2091 if (tcare) { diff = ref1.m_chars[idx] - ref2.m_chars[idx]; } else { diff = unc_tolower(ref1.m_chars[idx]) - unc_tolower(ref2.m_chars[idx]); } if (diff == 0) { /* * if we're comparing the same character but in different case * we want to favor lower case before upper case (e.g. a before A) * so the order is the reverse of ASCII order (we negate). */ return(-(ref1.m_chars[idx] - ref2.m_chars[idx])); } // return the case-insensitive diff to sort alphabetically return(diff); } if (idx == len) { return(0); } // underflow save: return(len1 - len2); return((len1 > len2) ? (len1 - len2) : -static_cast(len2 - len1)); } // unc_text::compare bool unc_text::equals(const unc_text &ref) const { const size_t len = size(); if (ref.size() != len) { return(false); } for (size_t idx = 0; idx < len; idx++) { if (m_chars[idx] != ref.m_chars[idx]) { return(false); } } return(true); } const char *unc_text::c_str() const { return(reinterpret_cast(&m_logtext[0])); } void unc_text::set(int ch) { m_logtext.clear(); toLogTextUtf8(ch, m_logtext); m_logtext.push_back('\0'); m_chars.clear(); m_chars.push_back(ch); } void unc_text::set(const unc_text &ref) { m_chars = ref.m_chars; m_logtext = ref.m_logtext; } void unc_text::set(const unc_text &ref, size_t idx, size_t len) { const auto ref_size = ref.size(); if (len == ref_size) { m_chars = ref.m_chars; update_logtext(); return; } m_chars.resize(len); len = fix_len_idx(ref_size, idx, len); for (size_t di = 0; len > 0; di++, idx++, len--) { m_chars[di] = ref.m_chars[idx]; } update_logtext(); } void unc_text::set(const string &ascii_text) { const size_t len = ascii_text.size(); m_chars.resize(len); for (size_t idx = 0; idx < len; idx++) { m_chars[idx] = ascii_text[idx]; } update_logtext(); } void unc_text::set(const char *ascii_text) { const size_t len = strlen(ascii_text); m_chars.resize(len); for (size_t idx = 0; idx < len; idx++) { m_chars[idx] = *ascii_text++; } update_logtext(); } void unc_text::set(const value_type &data, size_t idx, size_t len) { m_chars.resize(len); len = fix_len_idx(data.size(), idx, len); for (size_t di = 0; len > 0; di++, idx++, len--) { m_chars[di] = data[idx]; } update_logtext(); } void unc_text::resize(size_t new_size) { if (size() == new_size) { return; } const auto log_new_size = getLogTextUtf8Len(m_chars, new_size); m_logtext.resize(log_new_size + 1); // one extra for \0 m_logtext[log_new_size] = '\0'; m_chars.resize(new_size); } void unc_text::clear() { m_logtext.clear(); m_logtext.push_back('\0'); m_chars.clear(); } void unc_text::insert(size_t idx, int ch) { if (idx >= m_chars.size()) { throw out_of_range(string(__func__) + ":" + to_string(__LINE__) + " - idx >= m_chars.size()"); } log_type utf8converted; utf8converted.reserve(UTF8_BLOCKS); toLogTextUtf8(ch, utf8converted); const auto utf8_idx = getLogTextUtf8Len(m_chars, idx); m_logtext.pop_back(); // remove '\0' m_logtext.insert(std::next(std::begin(m_logtext), utf8_idx), std::begin(utf8converted), std::end(utf8converted)); m_logtext.push_back('\0'); m_chars.insert(std::next(std::begin(m_chars), idx), ch); } void unc_text::insert(size_t idx, const unc_text &ref) { if (ref.size() == 0) { return; } if (idx >= m_chars.size()) { throw out_of_range(string(__func__) + ":" + to_string(__LINE__) + " - idx >= m_chars.size()"); } const auto utf8_idx = getLogTextUtf8Len(m_chars, idx); // (A+B) remove \0 from both containers, add back a single at the end m_logtext.pop_back(); // A m_logtext.insert(std::next(std::begin(m_logtext), utf8_idx), std::begin(ref.m_logtext), std::prev(std::end(ref.m_logtext))); // B m_logtext.push_back('\0'); m_chars.insert(std::next(std::begin(m_chars), idx), std::begin(ref.m_chars), std::end(ref.m_chars)); } void unc_text::append(int ch) { m_logtext.pop_back(); if ( ch < 0x80 && ch != '\n' && ch != '\r') { m_logtext.push_back(ch); } else { log_type utf8converted; utf8converted.reserve(UTF8_BLOCKS); toLogTextUtf8(ch, utf8converted); m_logtext.insert(std::end(m_logtext), std::begin(utf8converted), std::end(utf8converted)); } m_logtext.push_back('\0'); m_chars.push_back(ch); } void unc_text::append(const unc_text &ref) { if (ref.size() == 0) { return; } m_logtext.pop_back(); m_logtext.insert(std::end(m_logtext), std::begin(ref.m_logtext), std::end(ref.m_logtext)); m_chars.insert(m_chars.end(), ref.m_chars.begin(), ref.m_chars.end()); } void unc_text::append(const string &ascii_text) { unc_text tmp(ascii_text); append(tmp); } void unc_text::append(const char *ascii_text) { unc_text tmp(ascii_text); append(tmp); } void unc_text::append(const value_type &data, size_t idx, size_t len) { unc_text tmp(data, idx, len); append(tmp); } bool unc_text::startswith(const char *text, size_t idx) const { const auto orig_idx = idx; for ( ; ( idx < size() && *text); idx++, text++) { if (*text != m_chars[idx]) { return(false); } } return( idx != orig_idx && (*text == 0)); } bool unc_text::startswith(const unc_text &text, size_t idx) const { size_t si = 0; const auto orig_idx = idx; for ( ; ( idx < size() && si < text.size()); idx++, si++) { if (text.m_chars[si] != m_chars[idx]) { return(false); } } return( idx != orig_idx && (si == text.size())); } int unc_text::find(const char *search_txt, size_t start_idx) const { const size_t t_len = strlen(search_txt); // the length of 'text' we are looking for const size_t s_len = size(); // the length of the string we are looking in if ( s_len < t_len // search_txt longer than the string we are looking in || start_idx + t_len - 1 >= s_len) // starting position to high to find search_txt { return(-1); } const size_t end_idx = s_len - t_len; for (size_t idx = start_idx; idx <= end_idx; idx++) { bool match = true; for (size_t ii = 0; ii < t_len; ii++) { if (m_chars[idx + ii] != search_txt[ii]) { match = false; break; } } if (match) // 'text' found at position 'idx' { return(idx); } } return(-1); // 'text' not found } int unc_text::rfind(const char *search_txt, size_t start_idx) const { const size_t t_len = strlen(search_txt); // the length of 'text' we are looking for const size_t s_len = size(); // the length of the string we are looking in if ( s_len < t_len // search_txt longer than the string we are looking in || start_idx < t_len - 1) // starting position to low to find search_txt { return(-1); } const size_t end_idx = s_len - t_len; if (start_idx > end_idx) { start_idx = end_idx; } for (auto idx = static_cast(start_idx); idx >= 0; idx--) { bool match = true; for (size_t ii = 0; ii < t_len; ii++) { if (m_chars[idx + ii] != search_txt[ii]) { match = false; break; } } if (match) { return(idx); } } return(-1); } void unc_text::erase(size_t start_idx, size_t len) { if (len == 0) { return; } const size_t end_idx = start_idx + len - 1; if (end_idx >= m_chars.size()) { throw out_of_range(string(__func__) + ":" + to_string(__LINE__) + " - idx + len >= m_chars.size()"); } const auto pos_s = getLogTextUtf8Len(m_chars, start_idx); const auto pos_e = pos_s + getLogTextUtf8Len(m_chars, start_idx, end_idx); m_logtext.pop_back(); m_logtext.erase(std::next(std::begin(m_logtext), pos_s), std::next(std::begin(m_logtext), pos_e + 1)); m_logtext.push_back('\0'); m_chars.erase(std::next(std::begin(m_chars), start_idx), std::next(std::begin(m_chars), end_idx + 1)); } int unc_text::replace(const char *search_text, const unc_text &replace_text) { const size_t s_len = strlen(search_text); const size_t r_len = replace_text.size(); int rcnt = 0; int fidx = find(search_text); while (fidx >= 0) { rcnt++; erase(static_cast(fidx), s_len); (static_cast(fidx) >= m_chars.size()) ? append(replace_text) : insert(static_cast(fidx), replace_text); fidx = find(search_text, static_cast(fidx) + r_len); } return(rcnt); } uncrustify-uncrustify-0.76.0/src/unc_text.h000066400000000000000000000101211434072136500210210ustar00rootroot00000000000000/** * @file unc_text.h * A simple class that handles the chunk text. * At the start of processing, the entire file is decoded into a std::vector of ints. * This class is intended to hold sections of that large std::vector. * * @author Ben Gardner * @license GPL v2+ */ #ifndef UNC_TEXT_H_INCLUDED #define UNC_TEXT_H_INCLUDED #include "base_types.h" #include #include #include /** * abbreviations used: * - unc_text - uncrustify text */ class unc_text { public: typedef std::deque value_type; // double encoded list of int values typedef std::vector log_type; unc_text(); unc_text(const unc_text &ref); unc_text(const unc_text &ref, size_t idx, size_t len = 0); unc_text(const char *ascii_text); unc_text(const std::string &ascii_text); unc_text(const value_type &data, size_t idx = 0, size_t len = 0); ~unc_text() = default; void resize(size_t new_size); void clear(); //! grab the number of characters size_t size() const; void set(int ch); void set(const unc_text &ref); void set(const unc_text &ref, size_t idx, size_t len = 0); void set(const std::string &ascii_text); void set(const char *ascii_text); void set(const value_type &data, size_t idx = 0, size_t len = 0); unc_text &operator=(int ch); unc_text &operator=(const unc_text &ref); unc_text &operator=(const std::string &ascii_text); unc_text &operator=(const char *ascii_text); void insert(size_t idx, int ch); void insert(size_t idx, const unc_text &ref); void erase(size_t idx, size_t len = 1); //! Add a unc_text character to an unc_text void append(int ch); void append(const unc_text &ref); //! Add a string to an unc_text void append(const std::string &ascii_text); /** * Add a variable length string to an unc_text. * The variable length string format is similar as for printf * * @note the overall length of the string must not exceed 256 characters * * @param ascii_text a variable length string */ void append(const char *ascii_text); void append(const value_type &data, size_t idx = 0, size_t len = 0); unc_text &operator+=(int ch); unc_text &operator+=(const unc_text &ref); unc_text &operator+=(const std::string &ascii_text); unc_text &operator+=(const char *ascii_text); //! Returns the UTF-8 string for logging const char *c_str() const; /** * compares the content of two unc_text instances * * @param ref1 first instance to compare * @param ref2 second instance to compare * @param len number of character to compare * @param tcare take care of case (lower case/ upper case) Issue #2091 * * @retval == 0 both text elements are equal * @retval > 0 * @retval < 0 */ static int compare(const unc_text &ref1, const unc_text &ref2, size_t len = 0, bool tcare = false); bool equals(const unc_text &ref) const; //! grab the data as a series of ints for outputting to a file const value_type &get() const; int operator[](size_t idx) const; // throws an exception if out of bounds const int &at(size_t idx) const; //! returns the last element of the character list const int &back() const; void push_back(int ch); void pop_back(); void pop_front(); bool startswith(const unc_text &text, size_t idx = 0) const; bool startswith(const char *text, size_t idx = 0) const; /** * look for 'text', beginning with position 'sidx' * * @param text text to search for * @param idx position to start search * * @return == -1 if not found * @return >= 0 the position */ int find(const char *text, size_t idx = 0) const; int rfind(const char *text, size_t idx = 0) const; int replace(const char *oldtext, const unc_text &newtext); protected: void update_logtext(); value_type m_chars; //! this contains the non-encoded 31-bit chars log_type m_logtext; //! logging text, utf8 encoded - updated in c_str() }; #endif /* UNC_TEXT_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/unc_tools.cpp000066400000000000000000000324421434072136500215420ustar00rootroot00000000000000/** * @file unc_tools.cpp * This file contains lot of tools for debugging * * @author Guy Maurel * October 2015- 2021 * @license GPL v2+ */ #include "unc_tools.h" #include "args.h" #include "output.h" /* * the test suite Coveralls: https://coveralls.io * will complains because these functions are only * used at development time. * Don't worry about unused lines for the functions: * prot_the_line * prot_the_source * examine_Data * dump_out * dump_in */ static size_t counter = 0; static size_t tokenCounter; /* protocol of the line * examples: * prot_the_line(__func__, __LINE__, pc->GetOrigLine(), 0); * prot_the_line(__func__, __LINE__, 0, 0); * prot_the_line(__func__, __LINE__, 6, 5); * prot_the_source(__LINE__); * log_pcf_flags(LSYS, pc->GetFlags()); * * if actual_line is zero, use the option debug_line_number_to_protocol. * if the value is zero, don't make any protocol and return. * * if partNumber is zero, all the tokens of the line are shown, * if partNumber is NOT zero, only the token with this partNumber is shown. * * prot_the_line_pc(pc_sub, __func__, __LINE__, 6, 5); * to get a protocol of a sub branch, which begins with pc_sub */ void prot_the_line(const char *func_name, int theLine, unsigned int actual_line, size_t partNumber) { prot_the_line_pc(Chunk::GetHead(), func_name, theLine, actual_line, partNumber); } void prot_the_line_pc(Chunk *pc_sub, const char *func_name, int theLine, unsigned int actual_line, size_t partNumber) { if (actual_line == 0) { // use the option debug_line_number_to_protocol. actual_line = options::debug_line_number_to_protocol(); if (actual_line == 0) { // don't make any protocol. return; } } counter++; tokenCounter = 0; LOG_FMT(LGUY, "Prot_the_line:(%s:%d)(%zu)\n", func_name, theLine, counter); for (Chunk *pc = pc_sub; pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->GetOrigLine() == actual_line) { tokenCounter++; if ( partNumber == 0 || partNumber == tokenCounter) { LOG_FMT(LGUY, " orig line is %d, (%zu) ", actual_line, tokenCounter); if (pc->Is(CT_VBRACE_OPEN)) { LOG_FMT(LGUY, ", "); } else if (pc->Is(CT_NEWLINE)) { LOG_FMT(LGUY, "(new line count is %zu), ", pc->GetNlCount()); } else if (pc->Is(CT_VBRACE_CLOSE)) { LOG_FMT(LGUY, ", "); } else if (pc->Is(CT_VBRACE_OPEN)) { LOG_FMT(LGUY, ", "); } else if (pc->Is(CT_SPACE)) { LOG_FMT(LGUY, ", "); } else if (pc->Is(CT_IGNORED)) { LOG_FMT(LGUY, " "); } else { LOG_FMT(LGUY, "Text() '%s', ", pc->Text()); } LOG_FMT(LGUY, " column is %zu, pp level is %zu, type is %s, parent type is %s, orig col is %zu,", pc->GetColumn(), pc->GetPpLevel(), get_token_name(pc->GetType()), get_token_name(pc->GetParentType()), pc->GetOrigCol()); if (pc->Is(CT_IGNORED)) { LOG_FMT(LGUY, "\n"); } else { LOG_FMT(LGUY, " pc->GetFlags(): "); log_pcf_flags(LGUY, pc->GetFlags()); } if (pc->GetTrackingData() != nullptr) { LOG_FMT(LGUY, " Tracking info are: \n"); LOG_FMT(LGUY, " number of track(s) %zu\n", pc->GetTrackingData()->size()); for (size_t track = 0; track < pc->GetTrackingData()->size(); track++) { const track_list *A = pc->GetTrackingData(); const Track_nr B = A->at(track); size_t Bfirst = B.first; char *Bsecond = B.second; LOG_FMT(LGUY, " %zu, tracking number is %zu\n", track, Bfirst); LOG_FMT(LGUY, " %zu, rule is %s\n", track, Bsecond); } } } } } LOG_FMT(LGUY, "\n"); } // prot_the_line_pc void prot_all_lines(const char *func_name, int theLine) { counter++; tokenCounter = 0; size_t lineNumber = 1; LOG_FMT(LGUY, "Prot_all_lines:(%s:%d)(%zu)\n", func_name, theLine, counter); for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { tokenCounter++; LOG_FMT(LGUY, " orig line is %zu,%zu, pp level is %zu, ", lineNumber, tokenCounter, pc->GetPpLevel()); if (pc->Is(CT_VBRACE_OPEN)) { LOG_FMT(LGUY, ", "); } else if (pc->Is(CT_NEWLINE)) { LOG_FMT(LGUY, "(new line count is %zu), ", pc->GetNlCount()); tokenCounter = 0; lineNumber = lineNumber + pc->GetNlCount(); } else if (pc->Is(CT_VBRACE_CLOSE)) { LOG_FMT(LGUY, ", "); } else if (pc->Is(CT_VBRACE_OPEN)) { LOG_FMT(LGUY, ", "); } else if (pc->Is(CT_SPACE)) { LOG_FMT(LGUY, ", "); } else if (pc->Is(CT_IGNORED)) { LOG_FMT(LGUY, " "); } else { LOG_FMT(LGUY, "Text() '%s', ", pc->Text()); } LOG_FMT(LGUY, " column is %zu, type is %s\n", pc->GetColumn(), get_token_name(pc->GetType())); } } // prot_all_lines void prot_the_source(int theLine) { counter++; LOG_FMT(LGUY, "Prot_the_source:(%d)(%zu)\n", theLine, counter); output_text(stderr); } // examples: // examine_Data(__func__, __LINE__, n); void examine_Data(const char *func_name, int theLine, int what) { LOG_FMT(LGUY, "\n%s:", func_name); Chunk *pc; switch (what) { case 1: for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if ( pc->Is(CT_SQUARE_CLOSE) || pc->Is(CT_TSQUARE)) { LOG_FMT(LGUY, "\n"); LOG_FMT(LGUY, "1:(%d),", theLine); LOG_FMT(LGUY, "%s, orig col=%zu, orig col end=%zu\n", pc->Text(), pc->GetOrigCol(), pc->GetOrigColEnd()); } } break; case 2: LOG_FMT(LGUY, "2:(%d)\n", theLine); for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->GetOrigLine() == 7) { if (pc->Is(CT_NEWLINE)) { LOG_FMT(LGUY, "(%zu) col=%zu\n\n", pc->GetOrigLine(), pc->GetOrigCol()); } else { LOG_FMT(LGUY, "(%zu)%s %s, col=%zu, column=%zu\n", pc->GetOrigLine(), pc->Text(), get_token_name(pc->GetType()), pc->GetOrigCol(), pc->GetColumn()); } } } break; case 3: LOG_FMT(LGUY, "3:(%d)\n", theLine); for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->Is(CT_NEWLINE)) { LOG_FMT(LGUY, "(%zu) col=%zu\n\n", pc->GetOrigLine(), pc->GetOrigCol()); } else { LOG_FMT(LGUY, "(%zu)%s %s, col=%zu, column=%zu\n", pc->GetOrigLine(), pc->Text(), get_token_name(pc->GetType()), pc->GetOrigCol(), pc->GetColumn()); } } break; case 4: LOG_FMT(LGUY, "4:(%d)\n", theLine); for (pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { if (pc->GetOrigLine() == 6) { if (pc->Is(CT_NEWLINE)) { LOG_FMT(LGUY, "(%zu) col=%zu\n\n", pc->GetOrigLine(), pc->GetOrigCol()); } else { LOG_FMT(LGUY, "(%zu)%s %s, col=%zu, column=%zu\n", pc->GetOrigLine(), pc->Text(), get_token_name(pc->GetType()), pc->GetOrigCol(), pc->GetColumn()); } } } break; default: break; } // switch } // examine_Data void dump_out(unsigned int type) { char dumpFileName[300]; if (cpd.dumped_file == nullptr) { sprintf(dumpFileName, "%s.%u", cpd.filename.c_str(), type); } else { sprintf(dumpFileName, "%s.%u", cpd.dumped_file, type); } FILE *D_file = fopen(dumpFileName, "w"); if (D_file != nullptr) { for (Chunk *pc = Chunk::GetHead(); pc->IsNotNullChunk(); pc = pc->GetNext()) { fprintf(D_file, "[%p]\n", pc); fprintf(D_file, " type %s\n", get_token_name(pc->GetType())); fprintf(D_file, " orig line %zu\n", pc->GetOrigLine()); fprintf(D_file, " orig col %zu\n", pc->GetOrigCol()); fprintf(D_file, " orig col end %zu\n", pc->GetOrigColEnd()); if (pc->GetOrigPrevSp() != 0) { fprintf(D_file, " orig prev sp %zu\n", pc->GetOrigPrevSp()); } if (pc->GetColumn() != 0) { fprintf(D_file, " column %zu\n", pc->GetColumn()); } if (pc->GetColumnIndent() != 0) { fprintf(D_file, " column indent %zu\n", pc->GetColumnIndent()); } if (pc->GetNlCount() != 0) { fprintf(D_file, " nl_count %zu\n", pc->GetNlCount()); } if (pc->GetLevel() != 0) { fprintf(D_file, " level %zu\n", pc->GetLevel()); } if (pc->GetBraceLevel() != 0) { fprintf(D_file, " brace level %zu\n", pc->GetBraceLevel()); } if (pc->GetPpLevel() != 0) { fprintf(D_file, " pp level %zu\n", pc->GetPpLevel()); } if (pc->GetAfterTab() != 0) { fprintf(D_file, " after tab %d\n", pc->GetAfterTab()); } if (pc->IsNot(CT_NEWLINE)) { fprintf(D_file, " Text %s\n", pc->Text()); } } fclose(D_file); } } // dump_out void dump_in(unsigned int type) { char buffer[256]; bool aNewChunkIsFound = false; Chunk chunk; char dumpFileName[300]; if (cpd.dumped_file == nullptr) { sprintf(dumpFileName, "%s.%u", cpd.filename.c_str(), type); } else { sprintf(dumpFileName, "%s.%u", cpd.dumped_file, type); } FILE *D_file = fopen(dumpFileName, "r"); if (D_file != nullptr) { unsigned int lineNumber = 0; while (fgets(buffer, sizeof(buffer), D_file) != nullptr) { ++lineNumber; if (aNewChunkIsFound) { // look for the next chunk char first = buffer[0]; if (first == '[') { aNewChunkIsFound = false; // add the chunk in the list chunk.CopyAndAddBefore(Chunk::NullChunkPtr); chunk.Reset(); aNewChunkIsFound = true; continue; } // the line as the form // part value // Split the line const int max_parts_count = 3; char *parts[max_parts_count]; int parts_count = Args::SplitLine(buffer, parts, max_parts_count - 1); if (parts_count != 2) { exit(EX_SOFTWARE); } if (strcasecmp(parts[0], "type") == 0) { E_Token tokenName = find_token_name(parts[1]); chunk.SetType(tokenName); } else if (strcasecmp(parts[0], "orig line") == 0) { chunk.SetOrigLine(strtol(parts[1], nullptr, 0)); } else if (strcasecmp(parts[0], "orig col") == 0) { chunk.SetOrigCol(strtol(parts[1], nullptr, 0)); } else if (strcasecmp(parts[0], "orig col end") == 0) { chunk.SetOrigColEnd(strtol(parts[1], nullptr, 0)); } else if (strcasecmp(parts[0], "orig prev sp") == 0) { chunk.SetOrigPrevSp(strtol(parts[1], nullptr, 0)); } else if (strcasecmp(parts[0], "column") == 0) { chunk.SetColumn(strtol(parts[1], nullptr, 0)); } else if (strcasecmp(parts[0], "nl_count") == 0) { chunk.SetNlCount(strtol(parts[1], nullptr, 0)); } else if (strcasecmp(parts[0], "text") == 0) { if (chunk.GetType() != CT_NEWLINE) { chunk.Str() = parts[1]; } } else { fprintf(stderr, "on line=%d, for '%s'\n", lineNumber, parts[0]); log_flush(true); exit(EX_SOFTWARE); } } else { // look for a new chunk char first = buffer[0]; if (first == '[') { aNewChunkIsFound = true; chunk.Reset(); } } } // add the last chunk in the list chunk.CopyAndAddBefore(Chunk::NullChunkPtr); fclose(D_file); } else { fprintf(stderr, "FATAL: file not found '%s'\n", dumpFileName); log_flush(true); exit(EX_SOFTWARE); } } // dump_in size_t number = 0; size_t get_A_Number() { number = number + 1; return(number); } uncrustify-uncrustify-0.76.0/src/unc_tools.h000066400000000000000000000016631434072136500212100ustar00rootroot00000000000000/** * @file unc_tools.h * * @author Guy Maurel * October 2015, 2016, 2017, 2018, 2019, 2020, 2021 * @license GPL v2+ */ #ifndef UNC_TOOLS_H_INCLUDED #define UNC_TOOLS_H_INCLUDED #include "prototypes.h" #if defined DEBUG #define PROT_THE_LINE prot_the_line(__func__, __LINE__, 0, 0); #else #define PROT_THE_LINE /* do nothing */; #endif void prot_the_line(const char *func_name, int theLine, unsigned int actual_line, size_t partNumber); void prot_the_line_pc(Chunk *pc_sub, const char *func_name, int theLine, unsigned int actual_line, size_t partNumber); void prot_all_lines(const char *func_name, int theLine); void prot_the_source(int theLine); void examine_Data(const char *func_name, int theLine, int what); //! dump the chunk list to a file void dump_out(unsigned int type); //! create chunk list from a file void dump_in(unsigned int type); size_t get_A_Number(); #endif /* UNC_TOOLS_H_INCLUDED */ uncrustify-uncrustify-0.76.0/src/uncrustify.cpp000066400000000000000000002225001434072136500217440ustar00rootroot00000000000000/** * @file uncrustify.cpp * This file takes an input C/C++/D/Java file and reformats it. * * @author Ben Gardner * @license GPL v2+ */ #define DEFINE_CHAR_TABLE #include "uncrustify.h" #include "align.h" #include "align_nl_cont.h" #include "align_preprocessor.h" #include "align_trailing_comments.h" #include "args.h" #include "backup.h" #include "brace_cleanup.h" #include "braces.h" #include "change_int_types.h" #include "combine.h" #include "compat.h" #include "detect.h" #include "enum_cleanup.h" #include "indent.h" #include "keywords.h" #include "lang_pawn.h" #include "newlines.h" #include "output.h" #include "parameter_pack_cleanup.h" #include "parens.h" #include "parent_for_pp.h" #include "remove_duplicate_include.h" #include "remove_extra_returns.h" #include "rewrite_infinite_loops.h" #include "semicolons.h" #include "sorting.h" #include "space.h" #include "token_names.h" #include "tokenize.h" #include "tokenize_cleanup.h" #include "unc_ctype.h" #include "unc_tools.h" #include "uncrustify_version.h" #include "unicode.h" #include "universalindentgui.h" #include "width.h" #include #include #include #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_SYS_STAT_H #include #endif #ifdef HAVE_STRINGS_H #include // provides strcasecmp() #endif #ifdef HAVE_UTIME_H #include #endif // VS throws an error if an attribute newer than the requested standard level // is used; everyone else just ignores it (or warns) like they are supposed to #if __cplusplus >= 201703L #define NODISCARD [[nodiscard]] #elif defined (__has_cpp_attribute) #if __has_cpp_attribute(nodiscard) #define NODISCARD [[nodiscard]] #else #define NODISCARD #endif #else #define NODISCARD #endif constexpr static auto LCURRENT = LUNC; using namespace std; using namespace uncrustify; // Global data cp_data_t cpd; static size_t language_flags_from_name(const char *tag); /** * Find the language for the file extension * Defaults to C * * @param filename The name of the file * @return LANG_xxx */ static size_t language_flags_from_filename(const char *filename); static bool read_stdin(file_mem &fm); static void uncrustify_start(const deque &data); static bool ends_with(const char *filename, const char *tag, bool case_sensitive); /** * Does a source file. * * @param filename_in the file to read * @param filename_out nullptr (stdout) or the file to write * @param parsed_file nullptr or the filename for the parsed debug info * @param dump_file nullptr or the filename prefix for dumping formatting steps debug info * @param no_backup don't create a backup, if filename_out == filename_in * @param keep_mtime don't change the mtime (dangerous) */ static void do_source_file(const char *filename_in, const char *filename_out, const char *parsed_file, const char *dump_file, bool no_backup, bool keep_mtime); static void add_file_header(); static void add_file_footer(); static void add_func_header(E_Token type, file_mem &fm); static void add_msg_header(E_Token type, file_mem &fm); static void process_source_list(const char *source_list, const char *prefix, const char *suffix, bool no_backup, bool keep_mtime); static const char *make_output_filename(char *buf, size_t buf_size, const char *filename, const char *prefix, const char *suffix); //! compare the content of two files static bool file_content_matches(const string &filename1, const string &filename2); static string fix_filename(const char *filename); static bool bout_content_matches(const file_mem &fm, bool report_status); /** * Loads a file into memory * * @param filename name of file to load * * @retval true file was loaded successfully * @retval false file could not be loaded */ static int load_mem_file(const char *filename, file_mem &fm); /** * Try to load the file from the config folder first and then by name * * @param filename name of file to load * * @retval true file was loaded successfully * @retval false file could not be loaded */ static int load_mem_file_config(const std::string &filename, file_mem &fm); //! print uncrustify version number and terminate static void version_exit(); const char *path_basename(const char *path) { if (path == nullptr) { return(""); } const char *last_path = path; char ch; while ((ch = *path) != 0) // check for end of string { path++; // Check both slash types to support Linux and Windows if ( (ch == '/') || (ch == '\\')) { last_path = path; } } return(last_path); } int path_dirname_len(const char *filename) { if (filename == nullptr) { return(0); } // subtracting addresses like this works only on big endian systems return(static_cast(path_basename(filename) - filename)); } void usage_error(const char *msg) { if (msg != nullptr) { fprintf(stderr, "%s\n", msg); log_flush(true); } fprintf(stderr, "Try running with -h for usage information\n"); log_flush(true); } static void tease() { fprintf(stdout, "There are currently %zu options and minimal documentation.\n" "Try UniversalIndentGUI and good luck.\n", get_option_count()); } void usage(const char *argv0) { fprintf(stdout, "Usage:\n" "%s [options] [files ...]\n" "\n" "If no input files are specified, the input is read from stdin\n" "If reading from stdin, you should specify the language using -l\n" "or specify a filename using --assume for automatic language detection.\n" "\n" "If -F is used or files are specified on the command line,\n" "the output filename is 'prefix/filename' + suffix\n" "\n" "When reading from stdin or doing a single file via the '-f' option,\n" "the output is dumped to stdout, unless redirected with -o FILE.\n" "\n" "Errors are always dumped to stderr\n" "\n" "The '-f' and '-o' options may not be used with '-F' or '--replace'.\n" "The '--prefix' and '--suffix' options may not be used with '--replace'.\n" "\n" "Basic Options:\n" " -c CFG : Use the config file CFG, or defaults if CFG is set to '-'.\n" " -f FILE : Process the single file FILE (output to stdout, use with -o).\n" " -o FILE : Redirect stdout to FILE.\n" " -F FILE : Read files to process from FILE, one filename per line (- is stdin).\n" " --check : Do not output the new text, instead verify that nothing changes when\n" " the file(s) are processed.\n" " The status of every file is printed to stderr.\n" " The exit code is EXIT_SUCCESS if there were no changes, EXIT_FAILURE otherwise.\n" " files : Files to process (can be combined with -F).\n" " --suffix SFX : Append SFX to the output filename. The default is '.uncrustify'\n" " --prefix PFX : Prepend PFX to the output filename path.\n" " --replace : Replace source files (creates a backup).\n" " --no-backup : Do not create backup and md5 files. Useful if files are under source control.\n" " --if-changed : Write to stdout (or create output FILE) only if a change was detected.\n" #ifdef HAVE_UTIME_H " --mtime : Preserve mtime on replaced files.\n" #endif " -l : Language override: C, CPP, D, CS, JAVA, PAWN, OC, OC+, VALA.\n" " -t : Load a file with types (usually not needed).\n" " -q : Quiet mode - no output on stderr (-L will override).\n" " --frag : Code fragment, assume the first line is indented correctly.\n" " --assume FN : Uses the filename FN for automatic language detection if reading\n" " from stdin unless -l is specified.\n" "\n" "Config/Help Options:\n" " -h -? --help --usage : Print this message and exit.\n" " --version : Print the version and exit.\n" " --count-options : Print the number of available options and exit.\n" " --show-config : Print out option documentation and exit.\n" " --update-config : Output a new config file. Use with -o FILE.\n" " --update-config-with-doc : Output a new config file. Use with -o FILE.\n" " --universalindent : Output a config file for Universal Indent GUI.\n" " --detect : Detects the config from a source file. Use with '-f FILE'.\n" " Detection is fairly limited.\n" " --set