CXXCTP
1.0.0
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 ++.
Ce référentiel sera migré vers https://github.com/blockspacer/flextool dès que possible
CXXCTP sera obsolète. Préférer Flextool
CXXCTP est un transpiler qui étend C ++ pour la nouvelle introspection, la réflexion et l'exécution en temps de compilation.
CXXCTP ne vise pas à créer un ensemble prédéfini de transformations de code source. Les utilisateurs peuvent partager des scripts C ++ pour la transformation du code source.
Supposons que quelqu'un partage des scripts utiles comme interface.cxx et enum_to_json.cxx à la communauté open-source. Vous pouvez les utiliser dans votre projet simplement en les plaçant dans le dossier ctp_scripts .
La métaprogrammation est un «art» de programmes d'écriture pour traiter d'autres programmes comme leurs données. Cela signifie qu'un programme pourrait générer, lire, analyser et transformer le code ou même lui-même pour obtenir une certaine solution.
Remarque: Ce projet est fourni tel qu'il est, sans aucune garantie (voir la licence).
Pourquoi n'étendre pas simplement Clang car il fournit également des fonctionnalités expérimentales (modules par exemple)?
Clang est un compilateur tandis que ce projet est un transpiler, qui transforme le code en code C ++ standardisé sans avoir besoin de modifier LLVM / Assembly.
Étant donné que la sortie de l'outil est le code C ++, vous pouvez compiler le code transpilé à l'aide d'EMScripten, utiliser des analyseurs de code statique, exécuter du code à l'intérieur de l'emblage, etc.
CXXCTP vous permet de créer et de partager des scripts pour
En développement, voir des exemples. Prend actuellement en charge uniquement Linux.
Notez que vous pouvez exécuter des conteneurs Linux sous Windows / Mac / etc.
// usage example from ReflShapeKind.hpp
enum class
$apply(
reflect_enum
)
ReflShapeKind0 : uint32_t {
Box = 3 ,
Sphere = 6 ,
}; // Usage example. NOTE: no inheritance & definition outside lib.
// in lib .h
struct drawable {
virtual void draw ( const char * arg1) const noexcept = 0;
};
struct printable {
virtual void print ( const char * arg1, const char * arg2) const noexcept = 0;
};
struct canvas3D {
std::string name3D;
};
struct canvas4D {
std::string name4D;
};
// in app .cpp
void draw<drawable>( const canvas3D& data, const char * arg1){
std::cout << " drawing to canvas3D name = " << data. name3D << std::endl;
}
void draw<drawable>( const canvas4D& data, const char * arg1){
std::cout << " drawing to canvas4D name = " << data. name4D << std::endl;
}
void print<printable>( const canvas3D& data, const char * arg1, const char * arg2){
std::cout << " printing to canvas3D name = " << data. name3D << std::endl;
}
void print<printable>( const canvas4D& data, const char * arg1, const char * arg2){
std::cout << " printing to canvas4D name = " << data. name4D << std::endl;
}
std::vector< _tc_combined_t <drawable>> vec {
canvas3D{},
canvas4D{},
};
_tc_combined_t <drawable, printable> CVS = canvas4D{};
CVS.draw( " " );
CVS.print( " " , " " );
canvas3D cvs3D;
CVS = std::move(cvs3D);
canvas4D cvs4D;
CVS = cvs4D; // copy
CVS = vec.at( 0 ); // <drawable> to <drawable, printable>$ export (
static int resultSomeInt = 2345 ;
)
$eval( " #include <optional> " )
$exec(
printf ( " execkjljlk n " );
printf ( " execasdasd n " );
)
$set_embed( " set_embed103 " ,
printf ( " set_embed101 n " );
printf ( " set_embed102 n " );
)
$embed(
[&clangMatchResult, &clangRewriter, &clangDecl]() {
printf ( " embed01 n " );
printf ( " embed02 n " );
return new llvm::Optional<std::string>{ " embed03 " };
}();
) class
$apply(make_interface;make_removefuncbody;make_reflect)
SomeInterfaceName {
virtual ~SomeInterfaceName () = 0 ;
/* int f ( ) { // {}
int i = 6;
{
// {
// }
}
return i;
}; */
int foo ();
virtual void foobar ( int & arg1) = 0 ;
virtual inline void zoobar ( int & arg2);
// int m_bar;
// int m_bar2 = 2;
};git submodule sync --recursive
git fetch --recurse-submodules
git submodule update --init --recursive --depth 100 --progress
# or
git submodule update --force --recursive --init --remoteInstaller et configurer Docker: https://medium.com/@saniaky/configure-docker-to-use-a-host-proxy-e88bd988c0aa
Code de clone (comme ci-dessus) et cd dans Dir cloné.
Remarque: vous pouvez créer une image docker avec --build-arg NO_SSL="False" . Lisez les commentaires dans Dockerfile.
# Give docker the rights to access X-server
sudo -E xhost +local:docker
# build Dockerfile
sudo -E docker build --no-cache
--build-arg GIT_WITH_OPENSSL= " "
--build-arg NO_SSL= " False "
-t cpp-docker-cxxctp .
# Now let’s check if our image has been created.
sudo -E docker images
# Run in container without leaving host terminal
sudo -E docker run -v " $PWD " :/home/u/cxxctp -w /home/u/cxxctp cpp-docker-cxxctp CXXCTP_tool -version --version
# Run a terminal in container
sudo -E docker run --rm -v " $PWD " :/home/u/cxxctp -w /home/u/cxxctp -it -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix cpp-docker-cxxctp
# type in container terminal
CXXCTP_tool -version --version # Run a terminal in container
sudo -E docker run --rm -v " $PWD " :/home/u/cxxctp -w /home/u/cxxctp -it -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix cpp-docker-cxxctp
# An example of how to build (with Makefile generated from cmake) inside the container
# Mounts $PWD to /home/u/cxxctp and runs command
mkdir build
sudo -E docker run --rm -v " $PWD " :/home/u/cxxctp -w /home/u/cxxctp/build cpp-docker-cxxctp cmake -DCONAN_AUTO_INSTALL=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=TRUE ..
# Run resulting app in host OS:
# ./build/<app> pip install --index-url=https://pypi.python.org/simple/ --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org wheel
&&
pip install --index-url=https://pypi.python.org/simple/ --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org virtualenv
&&
pip install --index-url=https://pypi.python.org/simple/ --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org conan
&&
pip install --index-url=https://pypi.python.org/simple/ --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org conan_package_tools
conan profile new default --detect
# conan profile update settings.compiler.libcxx=libstdc++11 default
conan remote list
conan search * boost * -r all Configurer les proxies et cacert_path dans ~/.conan/conan.conf , voir https://docs.conan.io/en/latest/reference/config_files/conan.conf.html#proxies
Configurer le profil Conan Clang pour ensuite utiliser --profile Clang:
/usr/bin/clang-6.0 -v
/usr/bin/clang++-6.0 -v
nano ~ /.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=6.0
compiler.libcxx=libstdc++11
[env]
CC=/usr/bin/clang-6.0
CXX=/usr/bin/clang++-6.0 Puis conan install ***** --profile clang
/usr/bin/gcc -v
/usr/bin/g++ -v
nano ~ /.conan/profiles/gcc
[settings]
# We are building in Ubuntu Linux
os_build=Linux
os=Linux
arch_build=x86_64
arch=x86_64
compiler=gcc
compiler.version=7
compiler.libcxx=libstdc++11
[env]
CC=/usr/bin/gcc
CXX=/usr/bin/g++Si vous souhaitez désactiver SSL (sous proxy, etc.):
# see https://docs.conan.io/en/latest/reference/commands/misc/remote.html#conan-remote
conan remote update conan-center https://conan.bintray.com False
conan search boost * -r=conan-center
conan remote add bincrafters https://api.bintray.com/conan/bincrafters/public-conan
conan remote update bincrafters https://api.bintray.com/conan/bincrafters/public-conan False
conan search boost * -r=bincraftersSi vous souhaitez définir Corp. CACERT:
CONAN_CACERT_PATH=/path/to/ca-bundle.crt
file $CONAN_CACERT_PATHLiens utiles:
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/ # NOTE: don't forget to re-run `conan install` after command below
# NOTE: change `build_type=Debug` to `build_type=Release` in production
cmake -DEXTRA_CONAN_OPTS= " --profile;clang;-s;build_type=Debug;--build;missing " -P tools/buildConanThirdparty.cmakeconan remote add Manu343726 https://api.bintray.com/conan/manu343726/conan-packages False
git clone http://github.com/foonathan/type_safe.git -b v0.2.1
cd type_safe
# NOTE: change `build_type=Debug` to `build_type=Release` in production
CONAN_REVISIONS_ENABLED=1
CONAN_VERBOSE_TRACEBACK=1
CONAN_PRINT_RUN_COMMANDS=1
CONAN_LOGGING_LEVEL=10
GIT_SSL_NO_VERIFY=true
conan create . conan/stable -s build_type=Debug --profile clang --build missing # NOTE: change `build_type=Debug` to `build_type=Release` in production
git clone http://github.com/mosra/corrade.git && cd corrade
CONAN_REVISIONS_ENABLED=1
CONAN_VERBOSE_TRACEBACK=1
CONAN_PRINT_RUN_COMMANDS=1
CONAN_LOGGING_LEVEL=10
GIT_SSL_NO_VERIFY=true
conan create . magnum/stable -s build_type=Debug --profile clang --build missing -tf package/conan/test_packagesudo apt-get install openmpi-bin openmpi-common libopenmpi-devsudo -E apt-get purge -y cmake
bash scripts/install_cmake.shInstallez la bibliothèque CXTPL https://github.com/blockspacer/cxtpl
Installez CXTPL_TOOL https://github.com/blockspacer/cxtplmp#how-to-build
BEFORE install_cling.sh:
sudo apt-get update && sudo apt-get upgrade
sudo apt-get install clang-6.0 libstdc++6 libstdc++-6-dev
sudo update-alternatives --config c++
sudo update-alternatives --config cc
sudo ldconfig
export CC=clang-6.0
export CXX=clang++-6.0 # Build Cling into `cling-build` folder
cd scripts
bash install_cling.shInstallez les DEP comme dans cxtpl https://github.com/blockspacer/cxtplmp#how-to-build
export CC=clang-6.0
export CXX=clang++-6.0
cmake -E remove_directory build
cmake -E make_directory build
cmake -E remove_directory resources/cxtpl/generated
cmake -E make_directory resources/cxtpl/generated
# NOTE: change `build_type=Debug` to `build_type=Release` in production
CONAN_REVISIONS_ENABLED=1
CONAN_VERBOSE_TRACEBACK=1
CONAN_PRINT_RUN_COMMANDS=1
CONAN_LOGGING_LEVEL=10
GIT_SSL_NO_VERIFY=true
cmake -E chdir build
cmake -E time
conan install
-s build_type=Debug
--build=missing
--profile clang
-o enable_tests=False
-o openssl:shared=True
..
cmake -E chdir build cmake -E time cmake -DCONAN_AUTO_INSTALL=OFF -DENABLE_CLING=TRUE -DBUILD_SHARED_LIBS=FALSE -DBUILD_EXAMPLES=FALSE -DALLOW_PER_PROJECT_CTP_SCRIPTS=TRUE -DBUNDLE_EXAMPLE_SCRIPTS=FALSE -DCMAKE_BUILD_TYPE=Debug -DENABLE_CXXCTP=TRUE ..
cmake -E chdir build cmake -E time cmake --build . -- -j6
# you can install CXXCTP_tool:
sudo cmake -E chdir build make install
# NOTE: You can also use the “-p” flag with CMAKE_EXPORT_COMPILE_COMMANDS. See https://variousburglarious.com/2018/02/18/include-paths-for-clang-tools/
# cmake -E chdir build ./tool/CXXCTP_tool -p=../example_compile_commands/
# NOTE: runs CXXCTP_tool on multiple files and adds include paths by `-extra-arg=-I`
cmake -E chdir build ./tool/CXXCTP_tool -L .=DBG9 -extra-arg=-I $PWD /include -extra-arg=-I../resources ../examples/built_in/for_codegen/example_make_reflect.cpp
# check generator output
file build/example_make_reflect.cpp.generated.cppOu sous GDB:
rm -rf * generated * ; clear && clear ; gdb ./CXXCTP -ex " run " -ex " bt " -ex " q " Utilisez partagé cxxctp_core en tant que bibliothèque partagée -DBUILD_SHARED_LIBS=TRUE .
Exécutez Bash Scripts / Install_folly.sh à partir de https://github.com/blockspacer/cxtpl ou patch folie manuellement pour la prise en charge de Clang (remplacer folly_use_jemalloc avec folly_assime_no_jemalloc) Facebook / folly # 976
Utilisez clang (pas gcc!) Avant la construction et -DENABLE_CLING=TRUE :
export CC=clang-6.0
export CXX=clang++-6.0
sudo rm -rf examples/ * /ctp_scripts/ * / * /generated/
cmake -E remove_directory build
cmake -E make_directory build
cmake -E remove_directory resources/cxtpl/generated
cmake -E make_directory resources/cxtpl/generated
# NOTE: clang profile!
# NOTE: change `build_type=Debug` to `build_type=Release` in production
CONAN_REVISIONS_ENABLED=1
CONAN_VERBOSE_TRACEBACK=1
CONAN_PRINT_RUN_COMMANDS=1
CONAN_LOGGING_LEVEL=10
GIT_SSL_NO_VERIFY=true
cmake -E chdir build
cmake -E time
conan install
-s build_type=Debug
--build=missing
--profile clang
-o enable_tests=False
-o openssl:shared=True
..
cmake -E chdir build cmake -E time cmake -DCONAN_AUTO_INSTALL=OFF -DENABLE_CLING=TRUE -DBUILD_SHARED_LIBS=TRUE -DALLOW_PER_PROJECT_CTP_SCRIPTS=TRUE -DBUILD_EXAMPLES=FALSE -DBUNDLE_EXAMPLE_SCRIPTS=FALSE -DCLEAN_CXXCTP_GEN=TRUE -DCMAKE_BUILD_TYPE=Debug -DENABLE_CXXCTP=TRUE ..
# OR cmake -E chdir build cmake -E time cmake -DCONAN_AUTO_INSTALL=OFF -DENABLE_CLING=TRUE -DBUILD_SHARED_LIBS=TRUE -DALLOW_PER_PROJECT_CTP_SCRIPTS=FALSE -DBUILD_EXAMPLES=FALSE -DBUNDLE_EXAMPLE_SCRIPTS=TRUE -DCLEAN_CXXCTP_GEN=TRUE -DCMAKE_BUILD_TYPE=Debug -DENABLE_CXXCTP=TRUE ..
cmake -E chdir build cmake -E time cmake --build . -- -j6
# you can install CXXCTP_tool:
sudo cmake -E chdir build make install
# check supported plugins
/usr/local/bin/CXXCTP_tool --pluginsSi vous avez installé CXXCTP_TOOL - vous pouvez exécuter des exemples:
# requires CXXCTP_tool
sudo cmake -E chdir build make install
# use -DBUILD_EXAMPLES=TRUE
rm ./build/examples/simple/CXXCTP_tool_for_CXXCTP_example.log
cmake -E chdir build cmake -E time cmake -DCONAN_AUTO_INSTALL=OFF -DENABLE_CLING=TRUE -DBUILD_SHARED_LIBS=TRUE -DBUILD_EXAMPLES=TRUE -DBUNDLE_EXAMPLE_SCRIPTS=FALSE -DALLOW_PER_PROJECT_CTP_SCRIPTS=TRUE -DCMAKE_BUILD_TYPE=Debug -DENABLE_CXXCTP=TRUE ..
cmake -E chdir build cmake -E time cmake --build . -- -j6
cat ./build/examples/simple/CXXCTP_tool_for_CXXCTP_example.log
Check that ` .log ` find doesn ` t contain errors
# run examples
build/bin/CXXCTP_example N'oubliez pas de définir que l'embling inclut les chemins par -extra-arg=-I$PWD/include et les chemins de bibliothèque par -extra-arg=-L$PWD/build et .so / .dll libs by -extra-arg=-lCXXCTP_core :
# NOTE: runs CXXCTP_tool on multiple files and adds include paths by `-extra-arg=-I`
cmake -E chdir build ./tool/CXXCTP_tool --ctp_scripts_paths= $PWD -L .=DBG9 -extra-arg=-I $PWD /include -extra-arg=-L $PWD /build -extra-arg=-lCXXCTP_core -extra-arg=-I../resources ../resources/ReflShapeKind.hpp ../resources/test_typeclass_base1.hpp ../resources/test_typeclass_instance1.hpp ../resources/test.cpp Utiliser l'option -extra-arg de CXXCTP_tool :
-extra-arg=-I $PWD /include -extra-arg=-I $PWD /include/foo -extra-arg=-DMY_DEFINITION=1 -extra-arg=-DONE_MORE_DEFINITION=1Exemple:
cmake -E chdir build ./tool/CXXCTP_tool --ctp_scripts_paths= $PWD -L .=DBG9 -extra-arg=-I $PWD /include -extra-arg=-I../resources ../resources/ReflShapeKind.hpp ../resources/test_typeclass_base1.hpp ../resources/test_typeclass_instance1.hpp ../resources/test.cppLes sections suivantes couvrent l'utilisation, les règles personnalisées et le débogage pour CXXCTP.
Vous pouvez écrire des scripts C ++ personnalisés pour la transformation du code source ou utiliser ceux existants.
CXXCTP charge tous les scripts C ++ du dossier CTP_Scripts dans l'ordre lexicographique.
Exemple de contenu de CTP_Scripts:
Les utils doivent se charger avant les scripts (liés à l'embris), nous avons donc ajouté 1_ , 2_ , ... avant les noms de dossiers (voir ci-dessus).
Vous pouvez utiliser #include , utiliser le système de fichiers, accéder à Internet, etc. dans les scripts C ++.
répertoire`
Installer avec -DENABLE_CLING=TRUE -DINSTALL_CLING=TRUE et définir LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/usr/local/lib/: $LD_LIBRARY_PATH
sudo ldconfigVous pouvez utiliser des annotations C ++ pour indiquer à CXXCTP quelles actions il doit exécuter.
Supposons que nous voulons transformer la classe en interface:
// Source
class SomeInterfaceName {
int foo1 () {
// ...
};
int foo ();
virtual void foobar ( int & arg1) = 0;
virtual void zoobar ( int & arg2);
virtual ~SomeInterfaceName () = 0 ;
};
// <== will be changed into ==>
// Result
class SomeInterfaceName {
virtual int foo1 () = 0;
virtual int foo () = 0;
virtual void foobar ( int & arg1) = 0;
virtual void zoobar ( int & arg2) = 0;
virtual ~SomeInterfaceName () = 0 ;
}; Nous pouvons utiliser funccall Action pour exécuter les scripts C ++ pour la transformation du code source. Supposons que les noms de scripts soient make_interface et make_removefuncbody (nom comme vous le souhaitez).
__attribute__ ((annotate( " {gen};{funccall};make_interface;make_removefuncbody " ))) {gen}; - Mot-clé utilisé dans chaque annotation CXXCTP.
{funccall}; - Mot-clé utilisé pour dire à CXXCTP ce qu'il doit exécuter des scripts C ++ avec l'embris.
make_interface;make_removefuncbody - deux scripts ce que cxxctp exécutera.
Les scripts seront exécutés à partir de gauche ( make_interface ) à droite ( make_removefuncbody ).
Habituellement, vous n'avez pas besoin d'écrire de longues annotations C ++, utilisez simplement C ++ #define (ou inclure l'en-tête intégré avec des définions communes):
# define $apply(...)
__attribute__ ((annotate( " {gen};{funccall}; " #__VA_ARGS__)))
class
$apply(make_interface;
make_removefuncbody)
SomeInterfaceName {
virtual ~SomeInterfaceName () = 0 ;
int foo ();
virtual void foobar ( int & arg1) = 0 ;
virtual void zoobar ( int & arg2);
}; À l'aide d'une approche similaire, vous pouvez appliquer plusieurs étapes de transformation de code source à la même class / struct / etc.
Créer des fichiers avec votre fonction dans ctp_scripts
Copier custom_plugins.cmake.example comme custom_plugins.cmake
Ajoutez vos chemins de script vers custom_plugins.cmake via add_ctp_plugin :
# first arg - typeclass_instance - script function name
# second arg - script source file
# third arg - script header file
# last arg - path to CMakeLists.txt used to generate script-related files
add_ctp_plugin(
" typeclass_instance "
${CMAKE_CURRENT_SOURCE_DIR} /examples/simple/ctp_scripts/2_scripts/typeclass_instance/typeclass_instance.cpp
${CMAKE_CURRENT_SOURCE_DIR} /examples/simple/ctp_scripts/2_scripts/typeclass_instance/typeclass_instance.hpp
${CMAKE_CURRENT_SOURCE_DIR} /examples/simple/ctp_scripts/2_scripts/typeclass_instance
) Vérifiez que le nom de votre fonction existe dans le fichier généré ctp_registry.cpp (peut être ignoré dans Cling / Dev-mode)
La signature de la fonction pour la transformation de code doit être compatible avec cxxctp_callback :
typedef std::function< const char *(
const cxxctp::parsed_func& func_with_args,
const clang::ast_matchers::MatchFinder::MatchResult& matchResult,
clang::Rewriter& rewriter,
const clang::Decl* decl,
const std::vector<cxxctp::parsed_func>& all_funcs_with_args)> cxxctp_callback;Signature de fonction détaillée:
all_funcs_with_args (voir ci-dessous)parsed_func - interface et foo_with_args . Considérez le nom de la fonction comme l'un des __VA_ARGS__
# define $apply(...)
__attribute__ ((annotate( " {gen};{funccall}; " #__VA_ARGS__))) Exemple où make_interface et make_removefuncbody - deux noms de fonction:
$apply(make_interface;
make_removefuncbody)Si vous avez besoin de génération de code:
.cxtpl ). Créez votre fichier à l'aide de CXTPL_TOOL https://github.com/blockspacer/cxtplstd::string cxtpl_output , qui stockera le résultat du rendu de modèle avec certains arguments..cxtpl ) à l'intérieur de votre fonction. .cxtpl .cxtpl est l'extension de fichier du moteur de modèle C ++ https://github.com/blockspacer/cxtpll
.cxtpl sur compilation-temps (cmake) Ajoutez votre fichier .cxtpl dans Codegen_files.cmake
Remarque: En mode Dev (comme le mode Cling), il peut être une bonne idée de générer des fichiers à partir de modèles à l'aide de CXTPL_TOOL https://github.com/blockspacer/cxtpl, vous pouvez ajouter des règles de génération dans Codegen_files.cmake plus tard dans la version de version.
Remarque: n'oubliez pas de fournir les fichiers .cxtpl et .cxtpl.h avec des règles CodeGen partagées (ajouter au système de contrôle de version).
.cxtpl à l'exécution avec l'essenceVous avez deux options:
.cxtpl , puis incluez-le dans le script C ++ Cling. Semblable à Compile-Time, mais vous pouvez générer ou modifier des fichiers sans recompilation du programme. Notez qu'il est possible de générer des fichiers et de les inclure dans votre script; Diviser le script en plusieurs incluses..cxtpl , puis exécutez-le dans un interprète alimentaire séparé. Dans la plupart des cas, vous utiliserez la première option. .cxtpl avec cxxctpPassez des données de réflexion dans le moteur de modèle.
Générez des fichiers à partir de modèles à l'aide de cxtpl_tool https://github.com/blockspacer/cxtpl
Dans le script cxxctp ( .cpp ):
// see ReflectAST.cpp
reflection::NamespacesTree m_namespaces;
// `node` from AST parser (libtooling)
reflection::ClassInfoPtr structInfo = reflector.ReflectClass(node, &m_namespaces);
// ...
stuct Arguments {
// any custom arguments here ...
std::string arg1 = " arg1... " ;
std::string arg2 = " arg2... " ;
// reflection data here (ClassInfoPtr) ...
};
// ...
std::map<std::string, std::any> cxtpl_params;
{
cxtpl_params[ " Arguments " ] =
std::make_any<Arguments>(Arguments{});
cxtpl_params[ " generator_path " ] =
std::make_any<std::string>( " enum_gen_hpp.cxtpl " );
cxtpl_params[ " generator_includes " ] =
std::make_any<std::vector<std::string>>(
std::vector<std::string>{});
std::string cxtpl_output;
# include " ../../resources/cxtpl/generated/enum_gen_hpp.cxtpl.cpp "
writeToFile (cxtpl_output, gen_hpp_name);
} Dans le modèle .cxtpl :
const auto arguments = std::any_cast<Arguments>(cxtpl_params.at( " Arguments " ));
std::cout << arguments.arg1; Voir resources/cxtpl/enum_gen_hpp.cxtpl comme exemple.
CXXCTP_TOOL ENRROPE LIBTOOLING Pour ajouter des options de ligne de commande personnalisées.
Options liées à libtooling (type -help ou - help):
Generic Options:
-help - Display available options (-help-hidden for more)
-help-list - Display list of available options (-help-list-hidden for more)
-version - Display the version of this program
Use override options:
-extra-arg= < string > - Additional argument to append to the compiler command line
-extra-arg-before= < string > - Additional argument to prepend to the compiler command line
-p= < string > - Build pathOptions liées à cxxctp_tool (type - help, pas -help):
ctp_scripts_paths - liste des chemins où le péage recherchera le sous-dossier CTP_Scripts
Remarque: ctp_scripts_paths requiert -DENABLE_CLING=TRUE
-L .=DBG9 est la configuration du journal au format https://github.com/facebook/folly/blob/master/folly/logging/docs/config.md
Exemple de configuration du journal qui écrit à la fois dans le flux de fichiers et de console:
./build/bin/CXXCTP_tool -L " .:=INFO:default:console; default=file:path=y.log,async=true,sync_level=DBG9;console=stream:stream=stderr " --srcdir pour modifier le chemin du système de fichiers actuel pour les fichiers d'entrée.
--resdir pour modifier le chemin du système de fichiers actuel pour les fichiers de sortie.
Exemple (Dir de sortie personnalisé):
# Remove old generated files
rm -rf gen
rm -rf build/ * generated *
` --version ` to get tool version
` -version ` to get clang version
# Build files to `gen/out` dir
mkdir -p gen/out
cmake -E chdir gen ../build/bin/CXXCTP_tool --resdir= $PWD /gen/out --ctp_scripts_paths= $PWD -L .=DBG9 -extra-arg=-I $PWD /include -extra-arg=-I../resources ../resources/ReflShapeKind.hpp ../resources/test_typeclass_base1.hpp ../resources/test_typeclass_instance1.hpp ../resources/test.cppctp_scriptsSupprimez les anciens artefacts de construction et les fichiers générés.
Regroupez vos scripts avec CXXCTP_tool via -DBUNDLE_EXAMPLE_SCRIPTS=TRUE .
Assurez-vous que vos scripts (plugins) sont ajoutés à CXXCTP_tool via custom_plugins.cmake.example .
Désactiver les scripts par-project -DALLOW_PER_PROJECT_CTP_SCRIPTS=FALSE .
Vérifiez que vos scripts (plugins) sont en build/tool/CXXCTP_tool --plugins
Vérifiez que la version installée par le système de CXXCTP_tool est la même que build/tool/CXXCTP_tool (par hachage de date / fichier)
Exécutez manuellement CXXCTP_tool sous gdb :
gdb -ex " r " -ex " bt " --args build/tool/CXXCTP_tool ......... Vérifiez que tous les chemins nécessaires sont dans -extra-arg= .
Faites un journal pour fichier en mode DBG9 et vérifiez les fichiers .log .
CXXCTP utilise LiBtooling pour analyser et modifier C ++.
Libtooling est une bibliothèque pour soutenir la rédaction d'outils autonomes basés sur Clang.
Liens utiles:
CXXCTP utilise Cling pour exécuter C ++ au moment de la compilation.
Vous pouvez utiliser l'adhésion pour le rechargement de code chaud / repla / Fast C ++ Prototyping / Scripting Engine / JIT / etc.
Liens utiles:
sudo apt install clang-format Exécutez en fonction du fichier .clang-format :
find . -regex ' .*.(cpp|hpp|cu|c|h) ' -exec clang-format -style=file -i {} ;Liens utiles:
.clang-format https://leimao.github.io/blog/clang-forat-quick-tutorial/Veuillez lire nos directives contributives avant de faire votre demande de traction.
Veuillez noter que ce projet est publié avec un code de conduite. En participant à ce projet, vous acceptez de respecter ses conditions.
Ce projet possible en raison de autoprogrammer de Flexferrum.
Articles sur autoprogrammer de Flexferrum dans les médias:
Tous les composants open source sont utilisés sous leurs licences open source associées.
Composants open source utilisés:
Voir les fichiers de licence
Les vérifications de style CMake Files Pass peuvent être corrigées en exécutant Run-Cmake-Format.py à partir de la racine du référentiel. Cela nécessite Python 3 et CMake_Format (Remarque: Cela ne fonctionne actuellement pas sur Windows)
Utilisez AutoForter cmake-format.py et run-cmake-format.py
pip3 install cmake_format
python3 run-cmake-format.pyPour utiliser CMake-Format sur un fichier CMakelists.txt spécifique dans la ligne de commande Exécuter
python3 -m cmake_format -c cmake-format.py -i CMakeLists.txtIl existe une extension officielle de Visual Studio, dont des détails peuvent être trouvés ici.
Suivez CMake StyleGuide https://github.com/ruslo/0
.cxtpl
