flextool Download - flextool Source Téléchargement

Ajoutez des fonctionnalités personnalisées à la langue C ++, comme les métaclases, les traits de rouille, la réflexion et bien d'autres

Une solution puissante entièrement open source pour la modification et la génération du code source C ++. Réduisez la quantité de code passe-partout dans vos projets C ++.

Page principale du projet: https://blockspacer.github.io/flex_docs/

Tutoriels et exemples

Tutoriel
Usage
Plugins
Traçage et niveaux de journal

Plates-formes prises en charge

Testé sur Ubuntu 20.04.2 LTS.

Peut travailler sur d'autres plateformes avec des modifications mineures.

Avant l'installation: ajouter des télécommandes Conan

Pour pouvoir ajouter la liste des télécommandes de dépendance, veuillez taper la commande suivante:

cmake -E time conan config install conan/remotes/
# OR:
# cmake -E time conan config install conan/remotes_disabled_ssl/

Avant l'installation

Guide d'installation
packages conan

Remarque: s'accrocher à la construction de LLVM peut prendre quelques heures.

La commande ci-dessous utilise --profile clang12_compiler12_compiler .

Exemple de profil Conan ~/.conan/profiles/clang :

[ settings ]
# We are building in Ubuntu Linux
os_build=Linux
os=Linux
arch_build=x86_64
arch=x86_64

compiler=clang
compiler.version=10
compiler.libcxx=libstdc++11

[ env ]
CC=/usr/bin/clang-10
CXX=/usr/bin/clang++-10

[ build_requires ]
cmake_installer/3.15.5@conan/stable

Créer le profil Clang12_Compiler:

[settings]
# We are building in Ubuntu Linux

os_build=Linux
os=Linux
arch_build=x86_64
arch=x86_64

compiler=clang
compiler.version=12
compiler.libcxx=libstdc++11
compiler.cppstd=17

llvm_9:build_type=Release

[env]
CC=/usr/bin/clang-12
CXX=/usr/bin/clang++-12

[build_requires]
cmake_installer/3.15.5@conan/stable

Avant la création du fichier de profil Conan, voir: https://docs.conan.io/en/latest/using_packages/using_profiles.html.

Nous utilisons le script .cmake pour télécharger et installer des packages Conan.

git clone https://github.com/blockspacer/conan_github_downloader.git ~ /conan_github_downloader

cmake 
  -DSCRIPT_PATH= " $PWD /get_conan_dependencies.cmake " 
  -DENABLE_CLING=TRUE
  -DENABLE_LLVM=TRUE
  -DENABLE_LLVM_INSTALLER=FALSE
  -DEXTRA_CONAN_OPTS= " --profile;clang12_compiler 
;-s;build_type=Debug 
;-s;cling_conan:build_type=Release 
;-s;llvm_12:build_type=Release 
;--build;missing " 
  -P ~ /conan_github_downloader/conan_github_downloader.cmake

# clean build cache
conan remove " * " --build --force

Installation facile avec des plugins communs

Si vous souhaitez installer Flextool et ses plugins dans une commande unique, modifiez les options fournies en tools/buildConanThirdparty.cmake .

Remarque: tools/buildConanThirdparty.cmake effectuera une ré-construction complète; Cela peut prendre quelques heures.

La commande ci-dessous utilise --profile clang12_compiler12_compiler . Avant la création du fichier de profil Conan, voir: https://docs.conan.io/en/latest/using_packages/using_profiles.html.

Nous utilisons le script buildConanThirdparty.cmake pour télécharger et installer des packages Conan.

Remarque: set -DENABLE_CLING=FALSE si vous avez déjà installé un accès à l'aide tools/buildConanThirdparty.cmake ci-dessus.

git clone https://github.com/blockspacer/conan_github_downloader.git ~ /conan_github_downloader

cmake 
  -DSCRIPT_PATH= " $PWD /get_conan_dependencies.cmake " 
  -DENABLE_CLING=TRUE
  -DENABLE_LLVM=TRUE
  -DENABLE_LLVM_INSTALLER=FALSE
  -DENABLE_FLEXTOOL=TRUE 
  -DENABLE_BASIS_PLUGIN_HELPER=TRUE 
  -DENABLE_FLEX_REFLECT_PLUGIN=TRUE 
  -DENABLE_SQUARETS=TRUE 
  -DENABLE_FLEX_SQUARETS_PLUGIN=TRUE 
  -DENABLE_FLEX_PIMPL_PLUGIN=TRUE 
  -DENABLE_FLEX_TYPECLASS_PLUGIN=TRUE 
  -DENABLE_FLEX_META_PLUGIN=TRUE 
  -DENABLE_FLEX_META_DEMO=TRUE 
  -DEXTRA_CONAN_OPTS= " --profile;clang12_compiler 
;-s;build_type=Debug 
;-s;cling_conan:build_type=Release 
;-s;llvm_12:build_type=Release 
;--build;missing " 
  -P ~ /conan_github_downloader/conan_github_downloader.cmake

# clean build cache
conan remove " * " --build --force

Installation (sans plugins)

Utilisez la commande ci-dessous pour reconstituer Flextool (les plugins doivent être installés séparément).

La commande ci-dessous utilise --profile clang12_compiler12_compiler . Avant la création du fichier de profil Conan, voir: https://docs.conan.io/en/latest/using_packages/using_profiles.html

 export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10

# NOTE: change `build_type=Debug` to `build_type=Release` in production
# NOTE: use --build=missing if you got error `ERROR: Missing prebuilt package`
cmake -E time 
  conan create . conan/stable 
  -s build_type=Debug 
  -s cling_conan:build_type=Release 
  -s llvm_tools:build_type=Release 
  --profile clang12_compiler 
      -e flextool:enable_tests=True 
      -e flextool:enable_llvm_tools=True

# clean build cache
conan remove " * " --build --force

Remarque: Flextool n'est pas compatible avec `compile_commands.json`

Désactivez la génération de base de données de compilation lorsque vous utilisez Flextool.

Si vous utilisez CMake, définissez CMAKE_EXPORT_COMPILE_COMMANDS sur FALSE .

Si compile_commands.json existe dans le dossier de construction (ou dans le dossier parent), Flextool peut échouer.

Debout sur les épaules des géants

Ce projet est possible en raison de autoprogrammer de Flexferrum.

Articles sur autoprogrammer de Flexferrum dans les médias:

[RUS] (Article) Metaclasses https://habr.com/ru/article/448466/
[RUS] (Diapositives) C ++ 17 Metaclasses https://assets.ctfassets.net/oxjq45e8ilak/55bgdx2pnyzmrpm8rwcjce/791e7eee3236c2023e86e169faca8a0e/sergei_sadovnikov_metaclasses_in_c___dream_real

Build de dev (flux de conan local)

find . -type f -name " *_buildflags.h " -exec rm {} ;
find . -type f -name " *_buildflags.tmp " -exec rm {} ;

(rm -rf local_build || true)

export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10

export PKG_NAME=flextool/master@conan/stable

(CONAN_REVISIONS_ENABLED=1 
    conan remove --force $PKG_NAME || true)

# NOTE: use --build=missing if you got error `ERROR: Missing prebuilt package`
cmake -E time 
  conan install . 
  --install-folder local_build 
  -s build_type=Debug 
  -s cling_conan:build_type=Release 
  -s llvm_12:build_type=Release 
  -o openssl:shared=True 
  -e basis:enable_tests=True 
  -o chromium_base:shared=True 
  -e chromium_base:enable_tests=True 
  -o perfetto:is_hermetic_clang=False 
  --profile clang12_compiler 
  -e flexlib:enable_tests=True 
  -o flexlib:shared=False 
  -o perfetto:is_hermetic_clang=False 
  -o flexlib:enable_cling=True 
  -e flextool:enable_tests=True 
  -o flextool:enable_cling=True

(rm local_build/CMakeCache.txt || true)

cmake -E time 
  conan source . 
  --source-folder . 
  --install-folder local_build

# You can use `cmake --build . -- -j14` on second run.
cmake -E time 
  conan build . 
  --build-folder local_build 
  --source-folder . 
  --install-folder local_build

conan package . 
  --build-folder local_build 
  --package-folder local_build/package_dir 
  --source-folder . 
  --install-folder local_build

cmake -E time 
  conan export-pkg . conan/stable 
  --package-folder local_build/package_dir 
  -s build_type=Debug 
   --force 
  -s cling_conan:build_type=Release 
  -s llvm_12:build_type=Release 
  -o openssl:shared=True 
  -e basis:enable_tests=True 
  -o chromium_base:shared=True 
  -e chromium_base:enable_tests=True 
  -o perfetto:is_hermetic_clang=False 
  --profile clang12_compiler 
  -e flexlib:enable_tests=True 
  -o flexlib:shared=False 
  -o perfetto:is_hermetic_clang=False 
  -o flexlib:enable_cling=True 
  -e flextool:enable_tests=True 
  -o flextool:enable_cling=True

cmake -E time 
  conan test test_package 
  flextool/master@conan/stable 
  -s build_type=Debug 
  -s cling_conan:build_type=Release 
  -s llvm_12:build_type=Release 
  -o openssl:shared=True 
  -e basis:enable_tests=True 
  -o chromium_base:shared=True 
  -e chromium_base:enable_tests=True 
  -o perfetto:is_hermetic_clang=False 
  --profile clang12_compiler 
  -e flexlib:enable_tests=True 
  -o flexlib:shared=False 
  -o perfetto:is_hermetic_clang=False 
  -o flexlib:enable_cling=True 
  -e flextool:enable_tests=True 
  -o flextool:enable_cling=True

Pour les contributeurs: mode modifiable conan

Avec les packages modifiables, vous pouvez dire à Conan où trouver les en-têtes et les artefacts prêts à la consommation dans votre répertoire de travail local. Il n'est pas nécessaire d'exécuter conan create ou conan export-pkg .

Pour plus de détails, voir: https://docs.conan.io/en/latest/developing_packages/editable_packages.html

Construire localement:

 export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10

cmake -E time 
  conan install . 
  --install-folder local_build 
  -s build_type=Debug 
  -s cling_conan:build_type=Release 
  -s llvm_tools:build_type=Release 
  --profile clang12_compiler 
      -e flextool:enable_tests=True 
      -e flextool:enable_llvm_tools=True

cmake -E time 
  conan source . 
  --source-folder local_build 
  --install-folder local_build

conan build . 
  --build-folder local_build 
  --source-folder local_build 
  --install-folder local_build

conan package . 
  --build-folder local_build 
  --package-folder local_build/package_dir 
  --source-folder local_build 
  --install-folder local_build

Définir le package sur le mode modifiable:

conan editable add local_build/package_dir 
  flextool/master@conan/stable

Notez que conanfile.py est modifié pour détecter les versions locales via self.in_local_cache .

Après modifier la source dans le dossier local_build (Exécuter les commandes dans le dossier Package Source):

 conan build . 
  --build-folder local_build 
  --source-folder local_build 
  --install-folder local_build

conan package . 
  --build-folder local_build 
  --package-folder local_build/package_dir 
  --source-folder local_build 
  --install-folder local_build

Construisez votre projet de test.

Afin de réintégrer le mode modifiable, supprimez simplement le lien en utilisant:

conan editable remove 
  flextool/master@conan/stable

Pour les contributeurs: Conan Workspace

Permet de créer plusieurs projets à la fois; Il crée simplement CMakeLists.txt avec add_subdirectory pointant vers chaque dossier de package.

Remarque: vous pouvez ouvrir un espace de travail dans IDE comme d'habitude CMake Based Project (modifier le répertoire de construction en chemin WorkspaceProject)!

Pour plus de détails, voir: https://docs.conan.io/en/latest/developing_packages/workspaces.html

Par exemple, nous voulons construire Flextool et Flexlib en même temps (Flextool nécessite Flexlib).

 # change ~ to desired build folder
cd ~

# Replace paths to yours!
# Make sure each project in NOT in editable mode!
cat << EOF > ~/conanws.yml
editables:
    flexlib/master@conan/stable:
        path: /......../flexlib
    flextool/master@conan/stable:
        path: /......../flextool
layout: layout_flex
workspace_generator: cmake
root:
    - flextool/master@conan/stable
EOF

cat << EOF > ~/layout_flex
# This helps to define the location of CMakeLists.txt within package
[source_folder]
.

# This defines where the conanbuildinfo.cmake will be written to
[build_folder]
build/{{settings.build_type}}
EOF

mkdir build_flex

cd build_flex

cat << EOF > CMakeLists.txt
cmake_minimum_required(VERSION 3.0)

project(WorkspaceProject)

include( $ {CMAKE_BINARY_DIR}/conanworkspace.cmake)

list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flexlib_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flextool_SRC}/cmake")

conan_workspace_subdirectories()

add_dependencies(flextool flexlib)
EOF

# must contain `include(${CMAKE_BINARY_DIR}/conanworkspace.cmake)` without slash `` (slash added for bash cat command)
cat CMakeLists.txt

# combines options from all projects
conan workspace install 
  ../conanws.yml 
  --profile=clang 
  -s build_type=Debug 
  -s cling_conan:build_type=Release 
  -s llvm_tools:build_type=Release 
    -o openssl:shared=True 
    -o chromium_base:shared=True 
    -e basis:enable_tests=True 
    -e abseil:enable_llvm_tools=True 
    -o chromium_base:use_alloc_shim=True 
    -o chromium_tcmalloc:use_alloc_shim=True 
    -o perfetto:is_hermetic_clang=False 
    -e flextool:enable_tests=True 
    -e flextool:enable_llvm_tools=True 
    -o flexlib:shared=False 
    -o flexlib:enable_clang_from_conan=False 
    -e flexlib:enable_tests=True

Construire dans le dossier créé par conan workspace install :

 # NOTE: change `build_type=Debug` to `build_type=Release` in production
export build_type=Debug

# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)

# configure via cmake
cmake -E time cmake . 
  -DCMAKE_VERBOSE_MAKEFILE=TRUE 
  -DENABLE_TESTS=TRUE 
  -DBASE_NEED_GEN_BUILD_DATE=FALSE 
  -DENABLE_DOCTEST=ON 
  -DBUILD_SHARED_LIBS=FALSE 
  -DCONAN_AUTO_INSTALL=OFF 
  -DCMAKE_BUILD_TYPE= ${build_type}

# remove generated files
# change paths to yours
# rm ~/flex_typeclass_plugin/build/Debug/*generated*

# build code
cmake -E time cmake --build . 
  --config ${build_type} 
  -- -j8

# run unit tests for flexlib
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flexlib_run_all_tests

# run unit tests for flextool
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flextool_run_all_tests

Workspace permet d'apporter des modifications rapides dans les fichiers source existants.

Nous utilisons self.in_local_cache pour détecter le mode modifiable CONAN:

 # Local build
# see https://docs.conan.io/en/latest/developing_packages/editable_packages.html
if not self . in_local_cache :
    self . copy ( "conanfile.py" , dst = "." , keep_path = False )

Assurez-vous que toutes les cibles ont des noms uniques mondialement uniques.

Par exemple: vous ne pouvez pas avoir de cible dans chaque projet avec le même nom que "test". Vous pouvez résoudre ce problème en ajoutant le préfixe spécifique au projet au nom de chaque cible comme "$ {root_project_name} -test_main_gtest".

Parce que CMAKE_BINARY_DIR pointera vers le dossier créé par conan workspace install , assurez-vous que vous préférez CMAKE_CURRENT_BINARY_DIR à CMAKE_BINARY_DIR etc.

Pour les contributeurs: Conan Workspace avec plugins

Avant l'installation: les plugins nécessitent Flextool pré-construit (dans le même espace de travail). Vous devez construire un espace de travail sans plugins; Ce n'est qu'alors que vous pourrez le reconstruire avec des plugins.

Ajouter des plugins au fichier yml:

 editables :
    chromium_base/master@conan/stable :
        path : /........./chromium_base
    basis/master@conan/stable :
        path : /........./basis
    flex_support_headers/master@conan/stable :
        path : /........./flex_support_headers
    flexlib/master@conan/stable :
        path : /........./flexlib
    flextool/master@conan/stable :
        path : /........./flextool
    flex_reflect_plugin/master@conan/stable :
        path : /........./flex_reflect_plugin
    squarets/master@conan/stable :
        path : /........./squarets
    flex_squarets_plugin/master@conan/stable :
        path : /........./flex_squarets_plugin
    flex_typeclass_plugin/master@conan/stable :
        path : /........./flex_typeclass_plugin
    flex_pimpl_plugin/master@conan/stable :
        path : /........./flex_pimpl_plugin
    flex_meta_plugin/master@conan/stable :
        path : /........./flex_meta_plugin
    flex_meta_demo/master@conan/stable :
        path : /........./flex_meta_demo
layout : layout_flex
workspace_generator : cmake
root :
    - flex_reflect_plugin/master@conan/stable
    - squarets/master@conan/stable
    - flex_squarets_plugin/master@conan/stable
    - flex_typeclass_plugin/master@conan/stable
    - flex_pimpl_plugin/master@conan/stable
    - flex_meta_plugin/master@conan/stable
    - flex_meta_demo/master@conan/stable

Utilisez add_dependencies dans CMakeLists.txt :

mkdir build_flex

cd build_flex

cat << EOF > CMakeLists.txt
cmake_minimum_required(VERSION 3.0)

project(WorkspaceProject)

include( $ {CMAKE_BINARY_DIR}/conanworkspace.cmake)

list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_chromium_base_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_basis_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_support_headers_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flexlib_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_reflect_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_squarets_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_squarets_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_typeclass_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_meta_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_meta_demo_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flex_pimpl_plugin_SRC}/cmake")
list(PREPEND CMAKE_MODULE_PATH " $ {PACKAGE_flextool_SRC}/cmake")

conan_workspace_subdirectories()

add_dependencies(basis chromium_base-static)
add_dependencies(flexlib basis)
add_dependencies(flextool flexlib basis flex_support_headers)
add_dependencies(flex_reflect_plugin flextool)
add_dependencies(flex_squarets_plugin squarets)
add_dependencies(flex_squarets_plugin flextool)
add_dependencies(flex_pimpl_plugin flextool)
add_dependencies(flex_pimpl_plugin flex_reflect_plugin)
add_dependencies(flex_pimpl_plugin flex_squarets_plugin)
add_dependencies(flex_typeclass_plugin flextool)
add_dependencies(flex_typeclass_plugin flex_squarets_plugin)
add_dependencies(flex_meta_demo flex_meta_plugin)
add_dependencies(flex_meta_demo flex_typeclass_plugin)
add_dependencies(flex_meta_demo flex_pimpl_plugin)
add_dependencies(flex_meta_demo flex_squarets_plugin)
EOF

Ajouter des options de plugins à conan workspace install :

 # combines options from all projects
conan workspace install 
  ../conanws.yml 
  --profile=clang 
  -s build_type=Debug 
    -s cling_conan:build_type=Release 
    -s llvm_tools:build_type=Release 
    -e basis:enable_tests=True 
    -o openssl:shared=True 
    -o chromium_base:shared=True 
    -o chromium_base:use_alloc_shim=True 
    -o perfetto:is_hermetic_clang=False 
    -o chromium_tcmalloc:use_alloc_shim=True 
    -e flextool:enable_tests=True 
    -e flextool:enable_llvm_tools=True 
    -o flexlib:shared=False 
    -o flexlib:enable_clang_from_conan=False 
    -e flexlib:enable_tests=True 
    -o flex_reflect_plugin:shared=True 
    -o flex_reflect_plugin:enable_clang_from_conan=False 
    -e flex_reflect_plugin:enable_tests=True 
    -o squarets:shared=False 
    -o squarets:enable_clang_from_conan=False 
    -e squarets:enable_tests=True 
    -o flex_squarets_plugin:shared=False 
    -o flex_squarets_plugin:enable_clang_from_conan=False 
    -e flex_squarets_plugin:enable_tests=True 
    -o flex_meta_plugin:shared=False 
    -o flex_meta_plugin:enable_clang_from_conan=False 
    -e flex_meta_plugin:enable_tests=True 
    -o flex_typeclass_plugin:shared=False 
    -o flex_typeclass_plugin:enable_clang_from_conan=False 
    -e flex_typeclass_plugin:enable_tests=True 
    -o flex_pimpl_plugin:shared=False 
    -o flex_pimpl_plugin:enable_clang_from_conan=False 
    -e flex_pimpl_plugin:enable_tests=True 
    -o flex_meta_demo:enable_clang_from_conan=False 
    -e flex_meta_demo:enable_tests=True

Construire et tester l'espace de travail:

 # NOTE: change `build_type=Debug` to `build_type=Release` in production
export build_type=Debug

# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)

# configure via cmake
cmake -E time cmake . 
  -DCMAKE_VERBOSE_MAKEFILE=TRUE 
  -DENABLE_TESTS=TRUE 
  -DBASE_NEED_GEN_BUILD_DATE=FALSE 
  -DENABLE_DOCTEST=ON 
  -DBUILD_SHARED_LIBS=FALSE 
  -DCONAN_AUTO_INSTALL=OFF 
  -DCMAKE_BUILD_TYPE= ${build_type}

# remove generated files
# change paths to yours
# rm ~/flex_typeclass_plugin/build/Debug/*generated*

# build code
cmake -E time cmake --build . 
  --config ${build_type} 
  -- -j8

# run unit tests for flexlib
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flexlib_run_all_tests

# run unit tests for flextool
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flextool_run_all_tests

# run unit tests for flex_reflect_plugin
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flex_reflect_plugin_run_all_tests

# run unit tests for squarets
cmake -E time cmake --build . 
  --config ${build_type} 
  --target squarets_run_all_tests

# run unit tests for flex_squarets_plugin
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flex_squarets_plugin_run_all_tests

# run unit tests for flex_squarets_plugin
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flex_meta_plugin_run_all_tests

# run unit tests for flex_squarets_plugin
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flex_typeclass_plugin_run_all_tests

# run unit tests for flex_squarets_plugin
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flex_pimpl_plugin_run_all_tests

# run unit tests for flex_squarets_plugin
cmake -E time cmake --build . 
  --config ${build_type} 
  --target flex_meta_demo_run_all_tests

Pour les contributeurs: CPPCHECK

Assurez-vous d'utiliser Debug Build avec -e flextool:enable_llvm_tools=True .

Installez CPPCHECK via Conan:

 cd /tmp

git clone -b testing/1.90 https://github.com/bincrafters/conan-cppcheck_installer.git

cd conan-cppcheck_installer

export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10

# NOTE: change `build_type=Debug` to `build_type=Release` in production
# NOTE: use --build=missing if you got error `ERROR: Missing prebuilt package`
cmake -E time 
  conan create . conan/stable 
  -s build_type=Release

# clean build cache
conan remove " * " --build --force

Utilisation (exécute Cmake avec -DENABLE_CPPCHECK=ON ):

 # creates local build in separate folder and runs cmake targets
# NOTE: -DCLEAN_OLD="OFF" to keep generated html report
cmake -DCPPCHECK= " ON " -DCLEAN_OLD= " OFF " -P tools/run_tool.cmake

 # `index.html` must exist
# find $PWD -name index.html

Ouvrez 'index.html' pour voir les résultats.

Pour les contributeurs: Vue UI

Application de bureau qui fournit un contexte unique pour gérer et exécuter plusieurs scripts.

Simplifie la configuration de l'environnement du développement local; Cela évite d'ouvrir beaucoup de terminaux de coquille.

Vous pouvez ajouter des commandes personnalisées dans package.json ou plugin/vue-cli-plugin/ui.js :

 # Before: Install Latest Node.js and NPM
# see https://tecadmin.net/install-latest-nodejs-npm-on-ubuntu/
node --version
npm --version

Construisez votre projet via NPM:

npm install

sudo npm install -g @vue/cli
sudo vue ui --dev --port 8061

Ouvrir http://localhost:8061/ .

Importer le répertoire du projet.

Sélectionnez Tasks , comme la construction / le test ...

Les tâches peuvent être modifiées dans package.json .

Remarque: nous utilisons package.json uniquement pour les tâches. Conan est contrôlé par un fichier appelé Conanfile.txt.

Liens utiles:

https://cli.vuejs.org/dev-guide/ui-api.html#ui files
https://github.com/dewep/gce
https://github.com/supnate/command-pad

Pour les contributeurs: gdbinit

Nous utilisons .gdbinit Ajouter «Add-Auto-charge-SAPE-PATH».

Pour plus de détails sur .gdbinit , lisez: https://metricpanda.com/tips-for-productive-debugging-with-gdb

Pour plus de détails sur gdb , lisez: http://www.yolinux.com/tutorials/gdb-commands.html

La session de débogage GDB peut être automatisée comme tel:

 # see https://gist.github.com/williballenthin/8bd6e29ad8504b9cb308039f675ee889
gdb 
  -ex " run " 
  -ex " set pagination off " 
  -ex " bt " 
  -ex " set confirm off " 
  -ex " quit " 
  --args 
  ${APP_EXE} 
  ${APP_CMD_ARGS}

Pour les contributeurs: Valgrind

Assurez-vous d'utiliser Debug Build avec -e flextool:enable_llvm_tools=True .

Pour plus de détails, voir:

https://www.jetbrains.com/help/clion/memory-profiling-with-valgrind.html
https://heeris.id.au/2016/valgrind-gdb/

Installez Valgrind:

sudo apt install valgrind  # Ubuntu, Debian, etc.
# OR
sudo yum install valgrind  # RHEL, CentOS, Fedora, etc.

Remarque: assurez-vous de définir use_alloc_shim=False et enable_valgrind=True (voir ci-dessous).

Exécutez Valgrind via Cmake:

 export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10

# NOTE: set `use_alloc_shim=False` and `enable_valgrind=True` for valgrind support
cmake -E time 
  conan install . 
  --install-folder local_build_valgrind 
  -s build_type=Debug 
  -s cling_conan:build_type=Release 
  -s llvm_tools:build_type=Release 
  --profile clang12_compiler 
      -o flextool:enable_valgrind=True 
      -e flextool:enable_tests=True 
      -e flextool:enable_llvm_tools=True 
      -e abseil:enable_llvm_tools=True 
      -o chromium_base:enable_valgrind=True 
      -e chromium_base:enable_llvm_tools=True 
      -o chromium_base:use_alloc_shim=False 
      -o perfetto:is_hermetic_clang=False 
      -o basis:enable_valgrind=True 
      -e basis:enable_llvm_tools=True 
      -o flexlib:enable_valgrind=True 
      -e flexlib:enable_llvm_tools=True 
      -o flexlib:enable_clang_from_conan=False 
      -o chromium_tcmalloc:use_alloc_shim=False 
      --build chromium_base 
      --build chromium_tcmalloc 
      --build basis 
      --build flexlib

cd ~ /flextool

# see section about `conan editable mode`
cd local_build_valgrind

# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)

# remove old build artifacts
rm -rf flextool
rm -rf bin
find . -iname ' *.o ' -exec rm {} ;
find . -iname ' *.a ' -exec rm {} ;
find . -iname ' *.dll ' -exec rm {} ;
find . -iname ' *.lib ' -exec rm {} ;

# NOTE: -DENABLE_VALGRIND=ON
cmake .. 
  -DCMAKE_VERBOSE_MAKEFILE=TRUE 
  -DENABLE_VALGRIND=ON 
  -DENABLE_TESTS=TRUE 
  -DBASE_NEED_GEN_BUILD_DATE=FALSE 
  -DENABLE_DOCTEST=ON 
  -DENABLE_VALGRIND_TESTS=TRUE 
  -DBUILD_SHARED_LIBS=FALSE 
  -DCONAN_AUTO_INSTALL=OFF 
  -DCMAKE_BUILD_TYPE=Debug

# NOTE: to run some tests under valgrind
# use `-DENABLE_VALGRIND_TESTS=TRUE`
cmake -E time cmake --build . 
  --target flextool-gmock_run_valgrind

# Cmake will print valgrind command that was executed.
# You can copy executed command and add custom command-line arguments:
#   --gtest_filter=ToolsSanityTest.DISABLED_ValgrindTest 
#   --gtest_also_run_disabled_tests

# search for valgrind log file
find $PWD -name * valgrind * .log

Pour trouver des fuites, vous pouvez seach pour definitely lost dans le fichier journal.

Remarque: vous pouvez ajouter des suppressions Valgrind dans cmake/valgrind.cfg .

Remarque: Compiler le programme avec un drapeau de débogage à exécuter sous Valgrind.

Remarque: Utilisez valgrind --tool=helgrind pour détecter les blocs de bloces et les races de données potentielles.

Remarque: Utilisez valgrind --tool=massif --massif-out-file=massif_file --stacks=true pour mesurer la taille du tas. Voir aussi: https://kde.org/applications/development/org.kde.massif-visualizer

Pour plus de détails, voir: https://stackoverflow.com/a/44989219

TODO: Essayez de construire avec Valgrind et Clang 10 https://stackoverflow.com/questions/40509986/valgrind-reportting-mismatched-free-delete-delete

TODO: Valgrind peut ne pas prendre en charge la base de chrome, FixMe. Et supprimer gtest_no_suite

Pour les contributeurs: Clang-tidy

Assurez-vous d'utiliser Debug Build avec -e flextool:enable_llvm_tools=True

Installer Clang-tidy:

sudo apt-get install clang-tidy  # Ubuntu, Debian, etc.
# OR
sudo yum install clang-tidy  # RHEL, CentOS, Fedora, etc.

Utilisation (exécute Cmake avec -DENABLE_CLANG_TIDY=ON ):

 # creates local build in separate folder and runs cmake targets
cmake -DCLANG_TIDY= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake

Pour les contributeurs: Scan-construction

Assurez-vous d'utiliser Debug Build avec -e flextool:enable_llvm_tools=True

Pour plus de détails, voir: https://chromium.googlesource.com/chromium/src.git/+/master/docs/clang_static_analyzer.md et https://clang-analyzer.llvm.org/scan-build.html

Le programme CCC-Analyzer agit comme un faux compilateur, transmettant ses arguments de ligne de commande au compilateur pour effectuer une compilation et un clang réguliers pour effectuer une analyse statique.

L'exécution de configuration génère généralement des makefiles qui ont des chemins câblés vers le compilateur, et en exécutant Configure via Scan-Build, ce chemin est défini sur CCC-Analyzer.

 # must exist
ccc-analyzer -v

# must exist
c++-analyzer -v

# must exist
scan-build -v

export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10

cmake -E time 
  conan install . 
  --install-folder local_build_scan_build 
  -s build_type=Debug 
  -s cling_conan:build_type=Release 
  -s llvm_tools:build_type=Release 
  --profile clang12_compiler 
      -e flextool:enable_tests=True 
      -e flextool:enable_llvm_tools=True

cmake -E time 
  conan source . 
  --source-folder local_build_scan_build 
  --install-folder local_build_scan_build

# see section about `conan editable mode`
cd local_build_scan_build

# NOTE: change `build_type=Debug` to `build_type=Release` in production
export build_type=Debug

# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)

# NOTE: changed CMAKE_C_COMPILER to ccc-analyzer (!!!)
# configure via cmake
scan-build 
  --use-cc=clang-10 
  --use-c++=clang++-10 
  -o ./scanbuildout/ 
  cmake .. 
  -DCMAKE_VERBOSE_MAKEFILE=TRUE 
  -DCMAKE_C_COMPILER=ccc-analyzer 
  -DCMAKE_CXX_COMPILER=c++-analyzer 
  -DENABLE_TESTS=FALSE 
  -DBASE_NEED_GEN_BUILD_DATE=FALSE 
  -DENABLE_DOCTEST=OFF 
  -DBUILD_SHARED_LIBS=FALSE 
  -DCONAN_AUTO_INSTALL=OFF 
  -DCMAKE_BUILD_TYPE= ${build_type}

# remove old build artifacts
(make clean || true)
rm -rf bin

# NOTE: requires project configured in debug build
# disable other static analyzers
# run from build directory
scan-build 
  -maxloop 8 
  -enable-checker alpha.security.taint.TaintPropagation 
  -enable-checker alpha.core.BoolAssignment 
  -enable-checker alpha.core.CastSize 
  -enable-checker alpha.core.DynamicTypeChecker 
  -enable-checker alpha.core.FixedAddr 
  -enable-checker alpha.core.IdenticalExpr 
  -enable-checker alpha.core.PointerArithm 
  -enable-checker alpha.core.PointerSub 
  -enable-checker alpha.core.SizeofPtr 
  -enable-checker alpha.core.TestAfterDivZero 
  -enable-checker alpha.deadcode.UnreachableCode 
  -enable-checker alpha.security.ArrayBoundV2 
  -enable-checker alpha.security.MallocOverflow 
  -enable-checker alpha.security.ReturnPtrRange 
  -enable-checker alpha.unix.PthreadLock 
  -enable-checker alpha.unix.Stream 
  -enable-checker alpha.unix.cstring.BufferOverlap 
  -enable-checker alpha.unix.cstring.NotNullTerminated 
  -enable-checker alpha.unix.cstring.OutOfBounds 
  -enable-checker nullability.NullableDereferenced 
  -enable-checker optin.performance.Padding 
  -enable-checker security.insecureAPI.rand 
  -enable-checker security.insecureAPI.strcpy 
  --use-cc=clang-10 
  --use-c++=clang++-10 
  -o ./scanbuildout/ 
  make 
  -j8

Ouvrez scanbuildout/...../index.html

Pour les contributeurs: CPPClean

Assurez-vous d'utiliser Debug Build avec -e flextool:enable_llvm_tools=True

Pour plus de détails, voir: https://github.com/myint/cppclean

Installation:

pip install --index-url=https://pypi.python.org/simple/ --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org --upgrade cppclean

Utilisation (exécute Cmake avec -DENABLE_CPPCLEAN=ON ):

 # creates local build in separate folder and runs cmake targets
cmake -DCPPCLEAN= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake

Remarque: CPPClean nécessite l'encodage des fichiers pour être: UTF-8 without BOM (ASCII)

Pour les contributeurs: iwyu

Assurez-vous d'utiliser Debug Build avec -e flextool:enable_llvm_tools=True

Inclure-What-You-Use (IWYU) est un projet destiné à optimiser les incluses.

Il calculera les en-têtes requis et ajoutera / supprimer les incluse le cas échéant.

Pour plus de détails, voir: https://include-what-you-use.org/

Utilisation (exécute Cmake avec -DENABLE_IWYU=ON ):

 # creates local build in separate folder and runs cmake targets
cmake -DIWYU= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake

Codestyle: utilisez // IWYU pragma: associated dans les fichiers source C ++.

Remarque: Lire sur Iwyu Pragmas: https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/iwyupragmas.md

Remarque: n'utilisez pas "Bits /" ou "/ Détails / *" inclut, ajoutez-les au fichier mappings (.Imp)

Pour plus de détails, voir:

https://llvm.org/devmtg/2010-11/silverstein-includewhatyouuse.pdf
https://github.com/include-what-you-use/include-what-you-use/tree/master/docs
https://github.com/hdclark/ygor/blob/master/artifacts/20180225_include-what-you-use/iwyu_how-tt.txt

Pour les contributeurs: ccache

Use -DUSE_CCACHE=ON

gcc -v
export CC=gcc
export CXX=g++
# NOTE: -DUSE_CCACHE=ON
cmake .. 
  -DCMAKE_VERBOSE_MAKEFILE=TRUE 
  -DUSE_CCACHE=ON 
  -DENABLE_TESTS=FALSE 
  -DBASE_NEED_GEN_BUILD_DATE=FALSE 
  -DENABLE_DOCTEST=OFF 
  -DBUILD_SHARED_LIBS=FALSE 
  -DCONAN_AUTO_INSTALL=OFF 
  -DCMAKE_BUILD_TYPE=Debug

Pour plus de détails, voir: https://www.virag.si/2015/07/use-ccache-with-cmake-for-faster-compilation/

Pour tirer le meilleur parti de CCache, mettez quelque chose comme ça: ~/.ccache/ccache.conf :

max_size = 50.0G  # or whatever cache size you prefer; default is 5G; 0 means unlimited
base_dir = /home/yourname  # or wherever you keep your source files

Remarque: base_dir est requis pour que CCACE partage des compiles en cache du même fichier sur différents référentiels / chemins; Il ne le fera que pour les chemins sous base_dir . Cette option est donc requise pour une utilisation efficace de CCACH avec GIT Worktrees (décrit ci-dessous).

Vous ne devez pas définir base_dir sur "/", ou n'importe où qui contient des en-têtes système (selon les documents CCache).

Pour les contributeurs: Gold Linker

Installation:

sudo apt-get install ccache

# On OS X use homebrew:
# brew install ccache

ccache --version

Utiliser -DUSE_LD_GOLD=ON

gcc -v
export CC=gcc
export CXX=g++
# NOTE: -DUSE_LD_GOLD=ON
cmake .. 
  -DCMAKE_VERBOSE_MAKEFILE=TRUE 
  -DUSE_LD_GOLD=ON 
  -DENABLE_TESTS=FALSE 
  -DBASE_NEED_GEN_BUILD_DATE=FALSE 
  -DENABLE_DOCTEST=OFF 
  -DBUILD_SHARED_LIBS=FALSE 
  -DCONAN_AUTO_INSTALL=OFF 
  -DCMAKE_BUILD_TYPE=Debug

Pour plus de détails, voir: https://cristianadam.eu/20170709/speeding-ulp-cmake/

Remarque: l'or non fileté par défaut, configurez avec "- les passages"

Remarque: LLD est fileté par défaut, peut être plus rapide que l'or

Pour les contributeurs: Oclint

Assurez-vous d'utiliser Debug Build avec -e flextool:enable_llvm_tools=True

Pour plus de détails, voir: https://oclint-docs.readthedocs.io/en/stable/devel/codingstandards.html

Installation:

 cd ~
wget --no-check-certificate https://github.com/oclint/oclint/releases/download/v0.13.1/oclint-0.13.1-x86_64-linux-4.4.0-112-generic.tar.gz
# mirror 1: http://github.strcpy.cn/oclint/oclint/releases/download/v0.13.1/oclint-0.13.1-x86_64-linux-4.4.0-112-generic.tar.gz
# mirror 2: http://archives.oclint.org/releases/0.8/oclint-0.8.1-x86_64-linux-3.13.0-35-generic.tar.gz
tar -xzvf oclint-0.13.1-x86_64-linux-4.4.0-112-generic.tar.gz
rm -rf oclint-0.13.1-x86_64-linux-4.4.0-112-generic.tar.gz
export OCLINT_HOME= ~ /oclint-0.13.1
export PATH= $OCLINT_HOME /bin: $PATH
oclint -version

Utilisation (exécute cmake avec -DENABLE_OCLINT=ON ):

 # NOTE: -DCLEAN_OLD="OFF" to keep generated html report
# creates local build in separate folder and runs cmake targets
cmake -DOCLINT= " ON " -DCLEAN_OLD= " OFF " -P tools/run_tool.cmake

 # `report.html` must exist
# find $PWD -name report.html

Open Report.html

Voir le tutoriel OCLINT: http://docs.oclint.org/en/stable/intro/tutorial.html

Voir la liste des règles d'Oclint sur: https://oclint-docs.readthedocs.io/en/stable/rules/

Remarque: vous pouvez supprimer les avertissements d'Oclint http://docs.oclint.org/en/stable/howto/suppress.html#oclint-omment

Pour les contributeurs: Clang-Format

Pour plus de détails, voir: https://clang.llvm.org/docs/clangformat.html

Utilisation (exécute Cmake avec -DENABLE_CLANG_FORMAT=ON ):

 # creates local build in separate folder and runs cmake targets
cmake -DCLANG_FORMAT= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake

Nous utilisons le fichier .clang-format . Pour plus de détails, voir: https://clang.llvm.org/docs/clangformatstyleoptions.html

Remarque: Nous utilisons DisableFormat , de sorte que Clang-Format changera uniquement l'inclusion de la commande basée sur SortIncludes .

Malheureusement, clang-format n'est pas suffisamment configurable, il peut donc être utilisé uniquement pour trier. Voir: https://stackoverflow.com/a/32191189

Pour les contributeurs: non-crutiful

Nous utilisons la non-crustify Bacause Clang-Format et Astyle ne prennent pas en charge beaucoup d'options.

Pour plus de détails, voir: https://patrickhenson.com/2018/06/07/uncrustify-configuration.html

Installation:

 cd ~
git clone https://github.com/uncrustify/uncrustify.git
cd uncrustify
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build .
export UNCRUSTIFY_HOME= ~ /uncrustify/build
export PATH= $UNCRUSTIFY_HOME : $PATH
# OR sudo make install

uncrustify --version

Utilisation (exécute Cmake avec -DENABLE_UNCRUSTIFY=ON ):

 # creates local build in separate folder and runs cmake targets
cmake -DUNCRUSTIFY= " ON " -DCLEAN_OLD= " ON " -P tools/run_tool.cmake

Nous utilisons un fichier uncrustify.cfg . Pour plus de détails, voir: https://patrickhenson.com/2018/06/07/uncrustify-configuration.html

Pour obtenir une liste de toutes les options disponibles à utiliser:

uncrustify --show-config

Uncustify a beaucoup d'options configurables. Vous aurez probablement besoin d'une interface graphique universelle (dans la réponse de Konstantin) pour la configurer: http://universalindent.sourceforge.net/

Utilisez des commentaires contenant /* *INDENT-OFF* */ et /* *INDENT-ON* */ pour désactiver le traitement des parties du fichier source.

Voir disable_processing_cmt à partir de uncrustify.cfg :

 # Specify the marker used in comments to disable processing of part of the
# file.
# The comment should be used alone in one line.
#
# Default:  *INDENT-OFF*
disable_processing_cmt          = " *INDENT-OFF* "      # string

# Specify the marker used in comments to (re)enable processing in a file.
# The comment should be used alone in one line.
#
# Default:  *INDENT-ON*
enable_processing_cmt           = " *INDENT-ON* "     # string

Vous pouvez intégrer uncrustify avec IDE:

Créateur QT: https://doc.qt.io/qtcreator/creator-beautifier.html
Code Visual Studio: https://marketplace.visualstudio.com/items?itemname=laurentTreguier.uncrustify

Comment construire avec des désinfeurs

Voir https://github.com/blockspacer/llvm_9_installer#how-to-use-with-sanitizers

Pour les contributeurs: construire en utilisant Clang 10 de Conan

Nécessite enable_llvm_tools=True , compile_with_llvm_tools=True et llvm_tools:build_type=Release :

-s llvm_tools:build_type=Release 
  -e flextool:enable_llvm_tools=True 
  -e flextool:compile_with_llvm_tools=True 
  -o llvm_tools:include_what_you_use=True 
  ...

enable_llvm_tools installe Clang 10 de Conan
compile_with_llvm_tools Définit les variables cmake requises pour utiliser Clang 10 de Conan

Exécutez conan install ou conan create avec:

 # OR create conan profile https://docs.conan.io/en/latest/reference/profiles.html
-s compiler=clang 
  -s compiler.version=10 
  -s compiler.libcxx=libc++

Remarque: le changement de compilateur peut nécessiter une reconstruction de tous les DEP ( --build=missing ).

Exemple en cas de construction locale:

 export CC= $( find ~ /.conan/data/llvm_tools/master/conan/stable/package/ -path " *bin/clang " | head -n 1 )

export CXX= $( find ~ /.conan/data/llvm_tools/master/conan/stable/package/ -path " *bin/clang++ " | head -n 1 )

export VERBOSE=1
export CONAN_REVISIONS_ENABLED=1
export CONAN_VERBOSE_TRACEBACK=1
export CONAN_PRINT_RUN_COMMANDS=1
export CONAN_LOGGING_LEVEL=10

# NOTE: NO `--profile` argument cause we use `CXX` env. var
# NOTE: you may want to re-build `cling_conan` with clang 10
cmake -E time 
  conan install . 
  --install-folder local_build_clang_10 
  -s build_type=Debug 
  -s cling_conan:build_type=Release 
  -s llvm_tools:build_type=Release 
      --build missing 
      --build cascade 
      -s cling_conan:compiler=clang 
      -s cling_conan:compiler.version=10 
      -s cling_conan:compiler.libcxx=libstdc++11 
      -o llvm_tools:include_what_you_use=True 
      -s llvm_tools:compiler=clang 
      -s llvm_tools:compiler.version=10 
      -s llvm_tools:compiler.libcxx=libstdc++11 
      -e flextool:enable_tests=True 
      -e flextool:enable_llvm_tools=True 
      -e flextool:compile_with_llvm_tools=True 
      -e boost:enable_llvm_tools=True 
      -e boost:compile_with_llvm_tools=True 
      -s compiler=clang 
      -s compiler.version=10 
      -s compiler.libcxx=libc++

cmake -E time 
  conan source . 
  --source-folder local_build_clang_10 
  --install-folder local_build_clang_10

# remove old CMakeCache
(rm local_build_clang_10/CMakeCache.txt || true)

# see section about `conan editable mode`
conan build . 
  --build-folder local_build_clang_10 
  --source-folder local_build_clang_10 
  --install-folder local_build_clang_10

Effectuer des chèques:

 # check that `libcpp` symbol exists
nm -an EXECUTABLE_PATH | grep libcpp

# list linked dynamic libs
ldd EXECUTABLE_PATH

Pour les contributeurs: doxygen

MCSS_ROOT_DIR_FOR_DOCS doit pointer des sources m.css comme ci-dessous:

 cd ~

git clone https://github.com/mosra/m.css.git

pip3 install jinja2 Pygments

sudo apt install 
    texlive-base 
    texlive-latex-extra 
    texlive-fonts-extra 
    texlive-fonts-recommended

sudo apt-get install doxygen

sudo apt install python3-pip

# /usr/bin/python must point to python3
/usr/bin/python --version

# NOTE: switch to python3 for doxygen or use -DPYTHON_EXECUTABLE=/usr/bin/python3
alias python= ' /usr/bin/python3 '

# You may need sudo here
pip3 install jinja2 Pygments

sudo apt install 
    texlive-base 
    texlive-latex-extra 
    texlive-fonts-extra 
    texlive-fonts-recommended

Utilisez CMake Build avec '--Target doxydoc' et -DBUILD_DOXY_DOC=ON

 cd ~ /flextool

# see section about `conan editable mode`
cd local_build_clang_10

# optional
# remove old CMakeCache
(rm CMakeCache.txt || true)

# remove old build artifacts
rm -rf flextool
rm -rf bin
find . -iname ' *.o ' -exec rm {} ;
find . -iname ' *.a ' -exec rm {} ;
find . -iname ' *.dll ' -exec rm {} ;
find . -iname ' *.lib ' -exec rm {} ;

# remove old build docs
rm -rf doc-mcss
rm -rf docs

cmake -E make_directory " doc-mcss "

# NOTE: you can change python version like so: -DPYTHON_EXECUTABLE=/usr/bin/python3
cmake .. 
  -DCMAKE_VERBOSE_MAKEFILE=TRUE 
  -DMCSS_ROOT_DIR_FOR_DOCS= $HOME /m.css 
  -DPYTHON_EXECUTABLE=/usr/bin/python3 
  -DENABLE_TESTS=TRUE 
  -DBASE_NEED_GEN_BUILD_DATE=FALSE 
  -DENABLE_DOCTEST=ON 
  -DBUILD_DOXY_DOC=ON 
  -DBUILD_SHARED_LIBS=FALSE 
  -DCONAN_AUTO_INSTALL=OFF 
  -DCMAKE_BUILD_TYPE=Debug 
  -DDOXY_ROOT_DIR= $PWD /doc-mcss 
  -DDOXY_DOC_COMMON_IMG_PATH= $PWD /.. 
  -DPROJECT_SOURCES_DIR_FOR_DOCS= $PWD /../src

cmake -E time cmake --build . 
  --target doxyDoc_notheme

cmake -E time cmake --build . 
  --target doxyDoc

# Use to find index.html
find $PWD -name * .html

Ouvrir DOXYDOC / HTML / INDEX.HTML

Remarque: Document Namespaces dans Docs / Namespaces.Dox

Remarque: les fichiers, répertoires et symboles sans documentation ne sont pas du tout présents dans la sortie

Style de commentaires utilisés:

/ **
 * @brief Path utils
 *
 * Example usage:
 *
 * @code{.cpp}
 * const ::fs::path workdir = storage::getThisBinaryDirectoryPath ();
 * @endcode
 ** /

Voir:

DOXYGEN CHRYSHEET
style de codage doxygen

Pour les contributeurs: fuzzing avec afl

Pour plus de détails, voir: https://afl-1.readthedocs.io/en/latest/index.html

lcamtuf.coredump.cx/afl : préférez github.com/google/afl ou aflplus.pl

Fuzzing est une technique de test de logiciels de boîte noire.

Fuzzing consiste à trouver des bogues d'implémentation en utilisant l'injection de données mal formée / semi-malformée de manière automatisée.

Fuzzer essaie de modifier l'entrée afin qu'elle puisse atteindre autant de lignes du code du programme que possible.

Par conséquent, le fuzzing permet la découverte de vulnérabilités se trouvant dans des chemins de code difficiles à atteindre par utilisation normale.

Installez + compilez le code source à l'aide des commandes suivantes:

 # optional
# sudo apt-get update

# optional
# sudo apt-get -y install autoconf automake bison build-essential 
ca-certificates llvm-dev libtool libtool-bin 
libglib2.0-dev make nasm wget

# Tested with clang 10 and gcc 7
sudo apt-get -y install clang-10 g++-7 gcc-7

export CXX=g++-7
export CC=gcc-7
export PATH=/usr/bin/: $PATH
$CC -v


# llvm-config binary that coresponds to the same clang you are using to compile
export LLVM_CONFIG=/usr/bin/llvm-config-10
$LLVM_CONFIG --cxxflags

cd ~
git clone -b v2.56b https://github.com/google/AFL.git --recursive

# NOTE: original AFL not updated since November 2017,
# so prefer `google/AFL.git` to `lcamtuf.coredump.cx/afl`
# wget http://lcamtuf.coredump.cx/afl/releases/afl-latest.tgz
# tar -xf afl-latest.tgz
# rm afl-latest.tgz
# cd afl*

cd AFL
make
# build llvm using the sample compiler as afl code uses
# see https://groups.google.com/forum/#!topic/afl-users/1WqZpGXvYY0
make 
  -C llvm_mode 
  LLVM_CONFIG= $LLVM_CONFIG 
  CC=clang-10 
  CXX=clang++-10
#
# optional
# cd qemu_mode
# ./build_qemu_support.sh
# cd ..
#
make 
  -C libdislocator
make 
  -C libtokencap
sudo make install

# OR add to PATH via export PATH=$PATH:...

# do not forget to reset CC and LLVM_CONFIG
unset CXX
unset CC
unset LLVM_CONFIG

Nous compilons le code à l'aide du compilateur AFL: -DCMAKE_C_COMPILER=afl-clang-fast , -DCMAKE_CXX_COMPILER=afl-clang-fast++ et -DCMAKE_LINKER=afl-clang-fast .

Pour vérifier si le binaire utilise le compilateur AFL: nm BINARY_PATH | grep afl

Pour créer une application avec certains désinfectants et les informations de débogage activées: ( -DENABLE_ASAN=ON etc.):

Remarque: il y a certaines choses à considérer lors de l'utilisation du désinfectant d'adresse. Même si ASAN trouve une violation d'accès à la mémoire, il ne plante pas automatiquement l'application. C'est un problème lors de l'utilisation d'outils de fuzzing automatisés, car ils essaient généralement de détecter les segfaults en vérifiant le code de retour. Nous pouvons cependant forcer ASAN à écraser les logiciels lorsqu'une erreur se produit avec la variable d'environnement ASAN_OPTIONS AVANT FUZZING: export ASAN_OPTIONS='abort_on_error=1'

Remarque: Désactivez les fonctions d'allocation de mémoire personnalisées. Cela peut masquer les bogues d'accès à la mémoire et empêcher la détection des erreurs d'accès à la mémoire.

 # see https://afl-1.readthedocs.io/en/latest/instrumenting.html

# Setting AFL_HARDEN automatically adds code hardening options
# when invoking the downstream compiler.
# This includes -D_FORTIFY_SOURCE=2 and -fstack-protector-all.
# NOTE: _FORTIFY_SOURCE not compatible with ASAN
# export AFL_HARDEN=1

# see https://aflplus.plus/docs/env_variables/
export AFL_EXIT_WHEN_DONE=1

# By default, the wrapper appends -O3 to optimize builds.
export AFL_DONT_OPTIMIZE=1

# or AFL_USE_MSAN, etc.
# READ https://aflplus.plus/docs/notes_for_asan/
NOTE: if you run several slaves only one should run the
# target compiled with ASAN (and UBSAN, CFISAN),
# the others should run the target with no sanitizers compiled in.
export AFL_USE_UBSAN=1
export AFL_USE_ASAN=1

# AFL_PRELOAD causes AFL to set LD_PRELOAD for the target binary
# without disrupting the afl-fuzz process itself.
# This is useful, among other things, for bootstrapping libdislocator.so.

# see __AFL_LOOP
# export AFL_PERSISTENT=1

# make sure you compile app with `-fsanitize=address` or `-fsanitize=memory` etc.

Remarque: utilisez AFL_DONT_OPTIMIZE=1 ; Lire: http://moyix.blogspot.com/2016/07/fuzzing-with-afl-is-an-art.html

Pour plus de détails, voir: Utilisation d'Asan avec AFL

Avant de fuzzing le programme, nous pouvons nécessiter un passage à l'utilisateur racine pour organiser le Core_Pattern. Connectez-vous comme racine et tapez la commande suivante:

 # see https://afl-1.readthedocs.io/en/latest/tips.html#check-os-configuration
sudo su
# disable core dumps and CPU frequency scaling on your system (AFL will warn you if you should do this)
echo core > /proc/sys/kernel/core_pattern
# afl-fuzz will usually complain that you should change your `CPUFREQ` settings to performance because the automatic frequency scaling by the Linux kernel doesn't work well with afl.
echo performance | tee /sys/devices/system/cpu/cpu * /cpufreq/scaling_governor
exit

Remarque: n'exécutez pas le fuzzer avec un accès racine

Remarque: Obtenez un environnement solide pour le Fuzzer; N'utilisez jamais le Fuzzer sur des hyperviseurs à faible configuration.

afl-fuzz est utilisé pour exécuter AFL. La syntaxe réelle est la suivante:

 # see https://afl-1.readthedocs.io/en/latest/fuzzing.html#fuzzing-binaries
# -i is a directory of files to use as fuzz input "seeds"
# -o is a directory to write the results (including inputs that provoke crashes or hangs)
# -m is the memory allowed to use. Example: -m500
# You can use -m none to disable memory limit
# -t is the maximum time that a run is allowed to take before being declared a "hang"
# Timeout of 10 seconds:  -t 10000
# @@ is fuzzer input file name
# if you skip @@ it will pass the fuzzed file on the standard input
AFL_PERSISTENT=1 afl-fuzz -i [TESTCASE DIR] -o [RESULT_DIR] [TARGET_BINARY] [BINARY_PARAMS] @@

# Example 1: runs `tar` with arguments `xfJ @@ -C fuzz-garbage/ --force-local`
# where @@ is fuzzer input file name
 ./afl-1.56b/afl-fuzz -i fuzz-input/ -o fuzz-state/ -t 10000 ~ /tar-1.28/src/tar xfJ @@ -C fuzz-garbage/ --force-local

# Example 2: server is dual core, so we can run one AFL instance per core
AFL_PERSISTENT=1 afl-fuzz -i inputs -o multi_sync -M master ./fuzz_capstone
# In another terminal
AFL_PERSISTENT=1 afl-fuzz -i inputs -o multi_sync -S slave1 ./fuzz_capstone

Pour comprendre l'écran d'état AFL, lisez: https://afl-1.readthedocs.io/en/latest/user_guide.html#status-screen

Remarque: Si total paths reste à 1, vous avez probablement configuré quelque chose de mal.

Remarque: préfère -m none . Nous utilisons AddressSanitizer; Cela mappe beaucoup de pages pour la mémoire de l'ombre, nous devons donc supprimer la limite de mémoire pour la faire fonctionner.

Remarque: avec -m none , votre logiciel Fuzzed peut en fait essayer d'allouer et d'utiliser beaucoup de mémoire en raison de vos échantillons floues. Cela peut entraîner des collisions aléatoires dans votre système. Vous ne devriez pas faire de travail important en le faisant.

Remarque: vous pouvez essayer ASAN_OPTIONS=hard_rss_limit_mb=2000 pour éviter -m none . Voir: https://countuponsecurity.com/category/fuzzing/

Vous pouvez écrire un binaire personnalisé qui s'exécutera à l'aide afl-fuzz . Il peut envelopper la fonction que vous souhaitez tester comme tel:

 // harness is simply a C program that makes use of certain methods from
// a library, allowing you to indirectly fuzz it

# include < cstdio >
# include < cstdlib >
# include < string >
# include < iostream >
# include < ifstream >

int main ( int argc, char *argv[]) {
{
  // init resources here
  if (argc > 1 ) {
    std::ifstream fin;
    fin. open (argv[ 1 ]);
    parse (fin); // custom logic
  } else {
    // / note requires AFL_PERSISTENT=1
    // __AFL_LOOP is the way that we have to tell AFL
    // that we want persistent mode.
    // Each fuzzing iteration,
    // instead of to fork and re-execute the target with a different input,
    // is just an execution of this loop.
    // Force AFL to run 1000 times,
    // with 1000 different inputs fed to the library.
    // After that, the process is restarted by AFL.
    // This ensures we regularly replace the process to avoid memory leaks.
    // see https://toastedcornflakes.github.io/articles/fuzzing_capstone_with_afl.html
    while ( __AFL_LOOP ( 1000 )) {
      parse (std::cin); // custom logic
    }
  }
  // free resources here
  return 0 ;
}

Remarque: __afl_loop () permet à AFL d'effectuer le fuzzing du binaire en procédure via une magie de mémoire, au lieu de démarrer un nouveau processus pour chaque nouveau testcase que nous souhaitons tester. Nécessite AFL_PERSISTENT=1 .

Par défaut, AFL fournit un processus à chaque fois qu'il teste une entrée différente. Nous pouvons contrôler l'AFL pour exécuter plusieurs cas de fuzz dans une seule instance du programme, plutôt que de ramener l'état du programme pour chaque échantillon de test. Cela réduira le temps passé dans l'espace du noyau et améliorera la vitesse de fuzzing. C'est ce qu'on appelle le mode afl_persistent. Nous pouvons le faire en incluant la macro __afl_loop (1000) dans notre harnais de test.

Remarque: vous pouvez être intéressé par __afl_init; Voir pour les détails: https://robertheaton.com/2019/07/08/how-to-write-an-afl-wrapper-for-any-language/

Laissez le Fuzzer fonctionner pendant quelques heures ou jours car il génère des chemins d'exécution de code maximaux en fonction des cas de test fournis.

Arrêtez de fuzzing émettre ctrl+c' observing les chemins totaux and les accidents UNIQ in the section Résultats globaux «de l'écran de statistiques AFL.

Créer un dictionnaire qui prend toutes les constantes et chaînes trouvées dans le programme binaire et les ajoute au dictionnaire. Voir pour le code du script: http: //moyix.blogspot.com/2016/07/fuzzing-with-afl-is-an-art.html

 #! /bin/bash

# see http://moyix.blogspot.com/2016/07/fuzzing-with-afl-is-an-art.html

objdump -d " ${1} " | grep -Eo ' $0x[0-9a-f]+ ' | cut -c 2- | sort -u | while read const ; do echo $const | python -c ' import sys, struct; sys.stdout.write("".join(struct.pack("<I" if len(l) <= 11 else "<Q", int(l,0)) for l in sys.stdin.readlines())) ' > testcases/ $const ; done
i=0 ; strings " ${1} " | while read line ; do echo -n " $line " > testcases/string_ ${i} ; i=$[ $i + 1 ] ; done

Vous devez créer un dictionnaire dans l'un des deux formats discutés dans les dictionnaires / readme.Dictionaries, puis le pointer du flou via l'option -x dans la ligne de commande. Lire: https://afl-1.readthedocs.io/en/latest/fuzzing.html#fuzzing-binaries et https://github.com/mirrorer/afl/blob/master/dictionaries/readme.dictionaries

Vous pouvez également utiliser libtokencap pour créer un dictionnaire; Voir: https://github.com/mirrorer/afl/blob/master/libtokencap/readme.tokencap

Nous pouvons trouver les cas de test qui provoquent le crash dans le dossier results que nous avons créé. En naviguant vers les results du dossier, nous observons que peu de dossiers sont générés.

Remarque: Gardez les fichiers de données d'entrée petits; moins de 1 Ko est idéal.

Utilisez afl-cmin pour minimiser le nombre de fichiers de données d'entrée.

Utilisez afl-tmin pour minimiser chaque fichier de données d'entrée (supprime les octets qui n'affectent pas les chemins de code pris).

Utilisez afl-ptmin pour exécuter afl-tmin en parallèle. Pour plus de détails, voir: https://foxglovesecurity.com/2016/03/15/fuzzing-workflows-a-fuzz-job-from-start-to-finish/

Pour reproduire Crash Found, vous pouvez utiliser crashwalk (c'est le plugin GDB), voir: https://ritcsec.wordpress.com/2018/05/10/vulnerabilité-discovery-by-fuzzing/

apt-get install gdb golang
mkdir src
cd src
git clone https://github.com/jfoote/exploitable.git
cd && mkdir go
export GOPATH= ~ /go
# crashwalk installed in $GOPATH/bin/
go get -u github.com/bnagy/crashwalk/cmd/...

# USAGE
~ /go/bin/cwtriage -root syncdir/fuzzer1/crashes/ -match id -- ~ /parse @@

Lorsque vous ne pouvez pas reproduire un crash trouvé par AFL-Fuzz, la cause la plus probable est que vous ne définissez pas la même limite de mémoire que celle utilisée par l'outil. Lire: https://afl-1.readthedocs.io/en/latest/fuzzing.html#fuzzing-binaries

Remarque: vous pouvez utiliser afl-cov pour quantifier dans quelle mesure vous exercez les chemins de code disponibles dans le binaire. Pour plus de détails, voir: https://foxglovesecurity.com/2016/03/15/fuzzing-workflows-a-fuzz-job-from-start-to-finish/

Remarque: En mettant le répertoire de travail AFL sur un disque RAM, vous pouvez potentiellement gagner une vitesse supplémentaire et éviter de porter les disques en même temps. Pour plus de détails, voir: https://bananafia.dev/post/gb-fuzz/

 # Fuzzing involves billions of reads and writes to the filesystem (!!!)
# Use RAMdisks for input since, we don't want to destroy harddrives
# Make a 1GB ramdisk file from which AFL can read input
sudo mkdir -p /mnt/inputfiles
sudo chown -R $USER : $( id -gn $USER ) /mnt/inputfiles
sudo mount -t tmpfs -o size=1024M tmpfs /mnt/inputfiles/

Remarque: - Le drapeau -fvisibility-inlines-hidden peut casser l'instrumentation AFL

AFL fournit un script d'exploration de crash dans experimental/crash_triage/triage_crashes.sh

Lors de l'exécution, le script de triage parcourera chaque fichier de crash dans le répertoire /out/crashes et imprimera les données de crash résultantes à l'écran.

triage_crashes UTILISATION: ./triage_crashes.sh ~/targets/out/ ~/targets/target-app/target-app_binary Pour plus de détails, voir: https://research.aurainfosec.io/hunting-for-bugs-101/

Remarque: instrument avec AFL juste les bibliothèques que vous souhaitez réellement tester en ce moment, une à la fois. Laissez le programme utiliser des bibliothèques non instrumentées à l'échelle du système pour toutes les fonctionnalités que vous ne souhaitez pas réellement fuzz.

Remarque: vous pouvez activer crash exploration mode via -C ; Voir: https://lcamtuf.blogspot.com/2014/11/afl-fuzz-crash-exploration-mode.html

Remarque: AFL détecte les défauts en vérifiant le premier processus engendré en train de mourir en raison d'un signal (sigsegv, sigabrt, etc.). Les programmes qui installent des gestionnaires personnalisés pour ces signaux peuvent avoir besoin de faire commenter le code pertinent.

Pour plus de détails, voir:

https://github.com/mykter/afl-training
https://www.loginsoft.com/blog/2018/02/02/discovering-vulnerabilities-with-afl-fuzzer/
https://www.youtube.com/watch?v=vzfhhjnycne
https://gamozolabs.github.io/fuzzing/2018/09/16/scaling_afl.html
https://ritcsec.wordpress.com/2018/05/10/vulnerabilité-discovery-by-fuzzing/
https://github.com/dor1s/libfuzzer-workshop/blob/master/lesons/01/modern_fuzzing_of_c_c%2b%2b_projects_slides_1-23.pdf
https://github.com/hbowden/nextgen/blob/master/cmakelists.txt#l92
https://foxglovesecurity.com/2016/03/15/fuzzing-workflows-a-fuzz-job-from-start-to-finish/
https://cs.anu.edu.au/courses/csprojects/19s1/reports/U6759601_Report.pdf
https://www.fastly.com/blog/how-fuzz-server-american-fuzzy-lop

Pour les contributeurs: fuzzing avec libfuzzer

Libfuzzer fait partie du projet d'infrastructure du compilateur LLVM et est intégré au compilateur Clang.

Ensuite, Libfuzzer peut être lié au pilote souhaité en passant -fsanitize=fuzzer pendant l'étape de liaison.

Remarque: -fsanitize=fuzzer dans le symbole main () de LibFuzzer.

Remarque: Dans la plupart des cas, vous voudrez peut-être combiner Libfuzzer avec Addresssanitizer (ASAN), UndefinedBehaviorsanitizer (UBSan), ou les deux. Vous pouvez également construire avec MemorySanitizer (MSAN), mais le support est expérimental: -fsanitize=undefined,address,fuzzer .

Exécutable appelle à plusieurs reprises la fonction suivante:

 extern " C " int LLVMFuzzerTestOneInput ( const uint8_t *Data, size_t Size ) {
  // DoStuffWithYourAPI(Data, Size);
  return 0 ;
}

Utilisez -fsanitize=address,fuzzer . Notez que vous pouvez modifier le désinfectant (adresse, mémoire, thread, etc.).

Remarque: Si vous soupçonnez des fuites de mémoire dans votre cible, vous devez exécuter libfuzzer avec -runs=N ou -max_total_time=N . Si votre cible a des fuites massives, vous finirez par manquer de RAM. Pour protéger votre machine de la mort OOM, vous pouvez utiliser: ASAN_OPTIONS=hard_rss_limit_mb=2000 (avec AddressSanitizer).

Libfuzzer a besoin de corpus de semences. Pour plus de détails, voir: https://github.com/google/fuzzing/blob/master/tutorial/libfuzzertutorial.md

Pour plus de détails, voir:

https://llvm.org/docs/libfuzzer.html
https://medium.com/@levwalkin/compile-llvm-clang-libfuzzer-b61e82718430
https://github.com/dor1s/libfuzzer-workshop
https://github.com/google/fuzzing/blob/master/tutorial/libfuzzertutorial.md

Pour les contributeurs: préfèrent le clang à gcc

Clang prend en charge les annotations de sécurité des threads (Guarded_By)
1. Activer -Wthread-safety-analysis
2. Utilisez base/thread_annotations.h https://github.com/chromium/chromium/blob/master/base/thread_annotations.h pour plus de détails, voir:
- http://clang.llvm.org/docs/threadsafetyanalysis.html
- Voir https://github.com/isocpp/cppcoreguidelines/blob/master/docs/lifetime.pdf
- https://insights.sei.cmu.edu/sei_blog/2014/10/thread-safety-analysis-in-c-and-c.html
Clang Fas Support de première classe pour les désinfections. Voir les détails sur MSAN, ASAN, TSAN, etc. dans Docs.
Clang peut être construit avec un profil à vie:
1. Construisez la branche spéciale de Clang https://github.com/mgehre/llvm-project
2. Activer -Wlifetime pour plus de détails, voir:
- https://pspdfkit.com/blog/2020/the-cpp-lifetime-profile/
- https://herbutter.com/2018/09/20/lifetime-profile-v1-0-posted/

Licence pour les composants open source

Tous les composants open source sont utilisés sous leurs licences open source associées.

Composants open source utilisés:

USI
cède
booster
harfbuzz
boost.Orcome
chrome (base)
libevent
modp_b64
tcmalloc
xdg_mime
XDG_USER_DIRS
dynamic_annotations
(Facebook) Folie
(Microsoft) GSL

Voir les fichiers de licence

LICENCE

la licence MIT

Voir la licence pour le contenu complet des licences.

Clause de non-responsabilité

Ce projet open source basé sur le projet Google Chromium.

Ce n'est pas un produit Google officiel.

Portions Copyright (c) Google Inc.

Voir les fichiers de licence.

Liste des contributeurs: Exemple de profil

Je suis un exemple que vous pouvez copier, si vous voulez :)
Je travaille sur beaucoup de choses comme ...
Mes passe-temps incluent ...

Liste des contributeurs

UN

Anindita Basu

Rédacteur
Twitter Github

Anna Hayhurst

Développeur junior
github

C

Cassio Espindola

Développeur analyste
github

D

Denis Trofimov

Développeur C ++
github
github
liendin

M

Mohib Qureshi

Espace de développement de logiciels
github

Y

Yousif Alebyary

Développeur Web / mobile.
github

Yves mancera

Ingénieur logiciel
github

Développer

flextool

Ajoutez des fonctionnalités personnalisées à la langue C ++, comme les métaclases, les traits de rouille, la réflexion et bien d'autres

Tutoriels et exemples

Plates-formes prises en charge

Avant l'installation: ajouter des télécommandes Conan

Avant l'installation

Installation facile avec des plugins communs

Installation (sans plugins)

Remarque: Flextool n'est pas compatible avec compile_commands.json

Debout sur les épaules des géants

Build de dev (flux de conan local)

Pour les contributeurs: mode modifiable conan

Pour les contributeurs: Conan Workspace

Pour les contributeurs: Conan Workspace avec plugins

Pour les contributeurs: CPPCHECK

Pour les contributeurs: Vue UI

Pour les contributeurs: gdbinit

Pour les contributeurs: Valgrind

Pour les contributeurs: Clang-tidy

Pour les contributeurs: Scan-construction

Pour les contributeurs: CPPClean

Pour les contributeurs: iwyu

Pour les contributeurs: ccache

Pour les contributeurs: Gold Linker

Pour les contributeurs: Oclint

Pour les contributeurs: Clang-Format

Pour les contributeurs: non-crutiful

Comment construire avec des désinfeurs

Pour les contributeurs: construire en utilisant Clang 10 de Conan

Pour les contributeurs: doxygen

Pour les contributeurs: fuzzing avec afl

Pour les contributeurs: fuzzing avec libfuzzer

Pour les contributeurs: préfèrent le clang à gcc

Licence pour les composants open source

LICENCE

Clause de non-responsabilité

Liste des contributeurs: Exemple de profil

Liste des contributeurs

UN

Anindita Basu

Anna Hayhurst

C

Cassio Espindola

D

Denis Trofimov

M

Mohib Qureshi

Y

Yousif Alebyary

Yves mancera

Remarque: Flextool n'est pas compatible avec `compile_commands.json`