NAME

       clang-modernize - manual page for clang-modernize 3.4

DESCRIPTION

       USAGE: clang-modernize [options] [<sources>...]

       OPTIONS:

       Formatting Options:

       -format                    - Enable formatting of code changed by applying replacements.
              Use -style to choose formatting style.

       -style=<string>            - Coding style, currently supports:
              LLVM, Google, Chromium, Mozilla, WebKit.

              Use  -style=file to load style configuration from .clang-format file located in one
              of the parent directories of the source file (or current directory for stdin).  Use
              -style="{key: value, ...}" to set specific parameters, e.g.:

              -style="{BasedOnStyle: llvm, IndentWidth: 8}"

       -style-config=<string>     - Path to a directory containing a .clang-format file
              describing a formatting style to use for formatting code when -style=file.

       Inclusion/Exclusion Options:

       -exclude=<string>          - Comma-separated list of paths that can not be transformed

       -exclude-from=<filename>   - File containing a list of paths that can not be transformed

       -include=<string>          - Comma-separated list of paths to consider to be transformed

       -include-from=<filename>   - File containing a list of paths to consider to be transformed

       Modernizer Options:

       -final-syntax-check        - Check for correct syntax after applying transformations

       -for-compilers=<string>    - Select transforms targeting the intersection of
              language  features  supported by the given compilers.  Takes a comma-separated list
              of <compiler>-<version>.

              <compiler> can be any of: clang, gcc, icc, msvc <version> is <major>[.<minor>]

       -help                      - Display available options (-help-hidden for more)

       -help-list                 - Display list  of  available  options  (-help-list-hidden  for
              more)

       -perf=<directory  name>      - Capture performance data and output to specified directory.
              Default: ./migrate_perf

       -risk                      - Select a maximum risk level:

       =safe  -   Only safe transformations

       =reasonable
              -   Enable transformations that might change semantics (default)

       =risky -   Enable transformations that are likely to change semantics

       -summary                   - Print transform summary

       -version                   - Display the version of this program

       Serialization Options:

       -serialize-dir=<string>    - Path to an existing directory in which to write
              serialized replacements. Default behaviour is to write to a temporary directory.

       -serialize-replacements    - Serialize translation unit replacements to  disk  instead  of
              changing files.

       Transforms:

       -add-override              - Make use of override specifier where possible

       -loop-convert              - Make use of range-based for loops where possible

       -pass-by-value             - Pass parameters by value where possible

       -replace-auto_ptr            -   Replace  std::auto_ptr  (deprecated)  by  std::unique_ptr
              (EXPERIMENTAL)

       -use-auto                  - Use of 'auto' type specifier

       -use-nullptr               - Make use of nullptr keyword where possible

       Transforms' options:

       -override-macros           - Detect and use macros that expand to the 'override' keyword.

       -user-null-macros=<string> - Comma-separated list of user-defined macro names that  behave
              like NULL

       -p <build-path> is used to read a compile command database.

              For   example,   it  can  be  a  CMake  build  directory  in  which  a  file  named
              compile_commands.json exists (use -DCMAKE_EXPORT_COMPILE_COMMANDS=ON  CMake  option
              to   get   this   output).   When   no  build  path  is  specified,  a  search  for
              compile_commands.json will be attempted through all parent paths of the first input
              file . See: http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html for an example
              of setting up Clang Tooling on a source tree.

       <source0> ... specify the paths of source files. These paths are

              looked up in the compile command database. If the path of a file  is  absolute,  it
              needs  to  point  into  CMake's  source  tree. If the path is relative, the current
              working directory needs to be in the CMake source tree and the file must  be  in  a
              subdirectory  of the current working directory. "./" prefixes in the relative files
              will be automatically removed, but the rest of a relative path must be a suffix  of
              a path in the compile command database.

       EXAMPLES:

       Apply all transforms on a file that doesn't require compilation arguments:

              clang-modernize file.cpp

       Convert for loops to ranged-based for loops for all files in the compilation database that
       belong in a project subtree and then reformat the code automatically using the LLVM style:

              clang-modernize -p build/path -include project/path -format -loop-convert

       Make use of both nullptr and the override specifier, using git ls-files:

              git ls-files '*.cpp' | xargs -I{} clang-modernize -p build/path \

       -use-nullptr -add-override -override-macros {}

       Apply all transforms supported by both clang >= 3.0 and gcc >=  4.7  to  foo.cpp  and  any
       included headers in bar:

              clang-modernize -for-compilers=clang-3.0,gcc-4.7 foo.cpp \

       -include bar -- -std=c++11 -Ibar

SEE ALSO

       The full documentation for clang-modernize is maintained as a Texinfo manual.  If the info
       and clang-modernize programs are properly installed at your site, the command

              info clang-modernize

       should give you access to the complete manual.