CXXCTP
1.0.0
Una solución de código completamente abierto y potente para la modificación y generación del código fuente C ++. Reduzca la cantidad de código de horarios en sus proyectos C ++.
Este repositorio se migrará a https://github.com/blockspacer/fxxteol lo antes posible
CXXCTP estará en desuso. Prefiere FLEXTOOL
CXXCTP es un transpilador que extiende C ++ para una nueva introspección, reflexión y ejecución de tiempo de compilación.
CXXCTP no tiene como objetivo crear un conjunto predefinido de transformaciones de código fuente. Los usuarios pueden compartir scripts C ++ para la transformación del código fuente.
Supongamos que alguien compartió scripts útiles como interface.cxx y enum_to_json.cxx a la comunidad de código abierto. Puede usarlos en su proyecto simplemente colocándolos en la carpeta ctp_scripts .
Metaprogramming es un "arte" de los programas de escritura para tratar otros programas como sus datos. Esto significa que un programa podría generar, leer, analizar y transformar el código o incluso en sí mismo para lograr una determinada solución.
Nota: Este proyecto se proporciona tal como es, sin ninguna garantía (ver licencia).
¿Por qué no extenderías Clang ya que también proporciona algunas características experimentales (módulos, por ejemplo)?
Clang es un compilador, mientras que este proyecto es un transpilador, que transforma el código en código C ++ estandarizado sin la necesidad de modificar LLVM/ensamblaje.
Debido a que la salida de la herramienta es el código C ++, puede compilar el código transpilado usando Emscripten, usar analizadores de código estático, ejecutar código dentro de la adhesión, etc.
CXXCTP le permite crear y compartir scripts para
En desarrollo, ver ejemplos. Actualmente admite solo Linux.
Tenga en cuenta que puede ejecutar contenedores de Linux en 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 --remoteInstale y configure Docker: https://medium.com/@saniaky/configure-docker-to-use-a-host-proxy-e88bd988c0aa
Código clon (como arriba) y cd en Dir clonado.
Nota: Es posible que desee construir una imagen Docker con --build-arg NO_SSL="False" . Lea los comentarios en 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 Configurar proxies & cacert_path en ~/.conan/conan.conf , ver https://docs.conan.io/en/latest/reference/config_files/conan.conf.html#proxies
Configure el perfil de Conan Clang para usar -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 Y luego 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 desea deshabilitar SSL (bajo 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 quieres establecer Corp. Cacert:
CONAN_CACERT_PATH=/path/to/ca-bundle.crt
file $CONAN_CACERT_PATHEnlaces útiles:
Para poder agregar la lista de remotos de dependencia, escriba el siguiente comando:
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.shInstale la biblioteca cxtpl https://github.com/blockspacer/cxtpl
Instale cxtpl_tool https://github.com/blockspacer/cxtpl#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.shInstale Deps como en Cxtpl https://github.com/blockspacer/cxtpl#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.cppO bajo GDB:
rm -rf * generated * ; clear && clear ; gdb ./CXXCTP -ex " run " -ex " bt " -ex " q " Use cxxctp_core compartido como biblioteca compartida -DBUILD_SHARED_LIBS=TRUE .
Ejecute scripts de bash/install_folly.sh desde https://github.com/blockspacer/cxtpl o parche la locura manualmente para el soporte de clang (reemplace folly_use_jemalloc con folly_assume_no_jemalloc) Facebook/Folly#976
Use Clang (no GCC!) Antes de Build y -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 instaló cxxctp_tool, puede ejecutar ejemplos:
# 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 No olvide establecer la aferración de las rutas de -extra-arg=-I$PWD/include y rutas de la biblioteca por -extra-arg=-L$PWD/build y .so/.dll libs por -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 Use la opción -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=1Ejemplo:
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.cppLas siguientes secciones cubren el uso, las reglas personalizadas y la depuración para CXXCTP.
Puede escribir scripts C ++ personalizados para la transformación del código fuente o usar los existentes.
CXXCTP Carga todos los scripts C ++ de la carpeta CTP_Scripts en orden lexicográfico.
Ejemplo de contenido de ctp_scripts:
Los utilizados deben cargarse antes de los scripts (relacionado con la adherencia), por lo que agregamos 1_ , 2_ , ... antes de los nombres de la carpeta (ver arriba).
Puede usar #include , usar archivos del sistema, acceder a Internet, etc. en scripts C ++.
directorio
Instalar con -DENABLE_CLING=TRUE -DINSTALL_CLING=TRUE y establecer LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/usr/local/lib/: $LD_LIBRARY_PATH
sudo ldconfigPuede usar anotaciones C ++ para decirle a CXXCTP qué acciones debe ejecutar.
Supongamos que queremos transformar la clase en la interfaz:
// 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 ;
}; Podemos usar la acción funccall para ejecutar scripts C ++ para la transformación del código fuente. Supongamos que los nombres de script son make_interface y make_removefuncbody (nombre como desee).
__attribute__ ((annotate( " {gen};{funccall};make_interface;make_removefuncbody " ))) {gen}; - Palabra clave utilizada en cada anotación CXXCTP.
{funccall}; - Palabra clave utilizada para decirle a CXXCTP qué debe ejecutar scripts de C ++ con aferrado.
make_interface;make_removefuncbody : dos scripts lo que CXXCTP ejecutará.
Los scripts se ejecutarán desde la izquierda ( make_interface ) a la derecha ( make_removefuncbody ).
Por lo general, no necesita escribir anotaciones largas de C ++, solo use C ++ #define (o incluya encabezado incorporado con define común):
# 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);
}; Usando un enfoque similar, puede aplicar múltiples pasos de transformación del código fuente a la misma class / struct / etc.
Cree archivos con su función en ctp_scripts
Copiar custom_plugins.cmake.example como custom_plugins.cmake
Agregue sus rutas de script a custom_plugins.cmake a través de 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
) Verifique que el nombre de su función exista en el archivo generado ctp_registry.cpp (se puede omitir en el cierre / mod-mod)
La firma de la función para la transformación del código debe ser compatible con 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;Firma de la función detallada:
all_funcs_with_args (ver más abajo)parsed_func - interface y foo_with_args . Piense en el nombre de la función como uno de __VA_ARGS__ desde
# define $apply(...)
__attribute__ ((annotate( " {gen};{funccall}; " #__VA_ARGS__))) Ejemplo donde make_interface y make_removefuncbody - dos nombres de funciones:
$apply(make_interface;
make_removefuncbody)Si necesita generación de código:
.cxtpl ). Construya su archivo usando cxtpl_tool https://github.com/blockspacer/cxtplstd::string cxtpl_output , que almacenará el resultado de la representación de plantillas con algunos argumentos..cxtpl ) dentro de su función. .cxtpl .cxtpl es la extensión del archivo para el motor de plantilla C ++ https://github.com/blockspacer/cxtpl
.cxtpl en tiempo de compilación (cmake) Agregue su archivo .cxtpl en Codegen_files.cmake
Nota: En el modo Dev (como el modo de cierre) puede ser una buena idea generar archivos a partir de plantillas que usan cxtpl_tool https://github.com/blockspacer/cxtpl puede agregar reglas de generación a Codegen_files.cmake más tarde en la compilación de la versión.
Nota: No olvide proporcionar archivos .cxtpl y .cxtpl.h con reglas de código compartido (Agregar al sistema de control de versiones).
.cxtpl en tiempo de ejecución con aferrarseTienes dos opciones:
.cxtpl , luego incluya en el script C ++ aferrado. Similar al tiempo de compilación, pero puede volver a generar o cambiar archivos sin la recompilación del programa. Tenga en cuenta que es posible generar archivos e incluirlos en su script; Solo divide el script en múltiples incluye..cxtpl , luego ejecutarla en un intérprete de cierre separado. En la mayoría de los casos, usará la primera opción. .cxtpl con cxxctpPase los datos de reflexión al motor de plantilla.
Genere archivos a partir de plantillas usando cxtpl_tool https://github.com/blockspacer/cxtpl
En 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);
} En la plantilla .cxtpl :
const auto arguments = std::any_cast<Arguments>(cxtpl_params.at( " Arguments " ));
std::cout << arguments.arg1; Consulte resources/cxtpl/enum_gen_hpp.cxtpl como ejemplo.
CXXCTP_Tool envuelve libtooling para agregar opciones de línea de comandos personalizadas.
Opciones relacionadas con LBTOOLING (tipo -Help o --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 pathOpciones relacionadas con cxxctp_tool (type -help, no -help):
ctp_scripts_paths - Lista de rutas donde el peaje buscará subcarpeta CTP_SCRIPTS
NOTA: ctp_scripts_paths requiere -DENABLE_CLING=TRUE
-L .=DBG9 es configuración de registro en formato https://github.com/facebook/folly/blob/master/folly/logging/docs/config.md
Ejemplo de configuración de registro que escribe tanto en el archivo como en la transmisión de la consola:
./build/bin/CXXCTP_tool -L " .:=INFO:default:console; default=file:path=y.log,async=true,sync_level=DBG9;console=stream:stream=stderr " --srcdir para cambiar la ruta del sistema de archivos actual para archivos de entrada.
--resdir para cambiar la ruta del sistema de archivos actual para archivos de salida.
Ejemplo (Dir de salida personalizado):
# 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_scriptsElimine los artefactos de compilación antiguos y los archivos generados.
Punte sus scripts con CXXCTP_tool a través de -DBUNDLE_EXAMPLE_SCRIPTS=TRUE .
Asegúrese de que sus scripts (complementos) se agregan a CXXCTP_tool a través de custom_plugins.cmake.example .
Desactivar los scripts por proyecto -DALLOW_PER_PROJECT_CTP_SCRIPTS=FALSE .
Verifique que sus scripts (complementos) estén en build/tool/CXXCTP_tool --plugins
Verifique que la versión instalada del sistema de CXXCTP_tool sea la misma que build/tool/CXXCTP_tool (por fecha/archivo hash)
Ejecute CXXCTP_tool manualmente bajo gdb :
gdb -ex " r " -ex " bt " --args build/tool/CXXCTP_tool ......... Verifique que todas las rutas necesarias estén en -extra-arg= .
Haga un registro para archivar en modo DBG9 y verifique los archivos .log .
CXXCTP utiliza libbTooling para analizar y modificar C ++.
Libbtooling es una biblioteca para admitir herramientas independientes basadas en Clang.
Enlaces útiles:
CXXCTP usa ASPARK para ejecutar C ++ en el tiempo de compilación.
Puede usar el cierre para el código de Hot Code Reload / Repl / Fast C ++ Prototyping / Scripting Engine / JIT / etc.
Enlaces útiles:
sudo apt install clang-format Ejecutar basado en el archivo .clang-format :
find . -regex ' .*.(cpp|hpp|cu|c|h) ' -exec clang-format -style=file -i {} ;Enlaces útiles:
.clang-format https://leimao.github.io/blog/clang-format-quick-tutorial/Lea nuestras pautas de contribución antes de hacer su solicitud de extracción.
Tenga en cuenta que este proyecto se lanza con un código de conducta. Al participar en este proyecto, usted acepta cumplir con sus términos.
Ese proyecto posible debido al autoprogrammer de FlexFerrum.
Artículos sobre autoprogrammer de FlexFerrum en los medios:
Todos los componentes de código abierto se utilizan bajo sus licencias de código abierto asociadas.
Se utilizaron componentes de código abierto:
Ver archivos de licencia
Los archivos Cmake pasan las verificaciones de estilo, se pueden solucionar ejecutando run-cmake-format.py desde la raíz del repositorio. Esto requiere Python 3 y CMake_Format (nota: esto actualmente no funciona en Windows)
Use autoformatoria cmake-format.py y run-cmake-format.py
pip3 install cmake_format
python3 run-cmake-format.pyPara usar cmake-formato en un archivo cmakelists.txt específico en la línea de comando ejecutar
python3 -m cmake_format -c cmake-format.py -i CMakeLists.txtHay una extensión oficial de Visual Studio, cuyos detalles se pueden encontrar aquí.
Siga a Cmake StyleGuide https://github.com/ruslo/0
.cxtpl
