cppinsights
v_17.0
O C ++ Insights é uma ferramenta baseada em Clang que faz uma transformação de origem a fonte. O objetivo dos insights C ++ é tornar as coisas visíveis que acontecem normalmente e intencionalmente nos bastidores. É sobre a mágica que o compilador faz para fazermos as coisas funcionarem.
Veja este código, por exemplo:
class Base {
};
class Derived : public Base {
};
int main () {
Derived d;
Derived d2 = d;
d2 = d;
Base& b = d;
}Nada de especial e, é claro, compila. Esta é a visão do compilador:
class Base
{
public:
// inline constexpr Base() noexcept = default;
// inline constexpr Base(const Base &) noexcept = default;
// inline constexpr Base & operator=(const Base &) noexcept = default;
};
class Derived : public Base
{
public:
// inline constexpr Derived() noexcept = default;
// inline constexpr Derived(const Derived &) noexcept = default;
// inline constexpr Derived & operator=(const Derived &) noexcept = default;
};
int main ()
{
Derived d;
Derived d2 = Derived (d);
d2. operator =(d);
Base & b = static_cast <Base&>(d);
return 0 ;
} Você pode ver todas as funções de membro especial fornecidas pelo compilador e o upcast de Derived para Base .
O C ++ Insights é uma ferramenta baseada em Clang que faz uma transformação de origem a fonte. O objetivo dos insights C ++ é tornar as coisas visíveis que acontecem normalmente e intencionalmente nos bastidores. É sobre a mágica que o compilador faz para fazermos as coisas funcionarem. Ou olhando através das classes de um compilador.
Em 2017, comecei a analisar algumas coisas novas que obtemos com C ++ 11, C ++ 14 e C ++ 17. Coisas incríveis, como lambdas, loops baseados em alcance e ligações estruturadas. Eu juntei em uma palestra. Você pode encontrar os slides e um vídeo online.
No entanto, toda essa pesquisa e parte do meu treinamento e ensino me fizeram começar a pensar em como seria se pudéssemos ver com os olhos do compilador. Claro, há um despejo AST, pelo menos para Clang. Podemos ver qual código o compilador gera a partir de um trecho de origem C ++ com ferramentas como o Compiler Explorer. No entanto, o que vemos é o assembler. Nem o AST nem a saída do Compiler Explorer estão no idioma que escrevo código. Portanto, não estou muito familiarizado com essa saída. Além disso, ao ensinar os alunos C ++, mostrando um AST e explicando que é tudo o que não foi muito satisfatório para mim.
Comecei a escrever uma ferramenta baseada em Clang que pode transformar um loop for-loop baseado em range na versão interna do compilador. Então, eu fiz o mesmo por ligações estruturadas e lambdas. No final, fiz muito mais do que o planejado inicialmente. Ele mostra onde os operadores são invocados e lugares em que o compilador faz algum elenco. Os insights C ++ podem deduzir o tipo por trás auto ou decltype . O objetivo é produzir código compilável. No entanto, isso não é possível em todos os lugares.
Você pode ver, por exemplo, a transformação de um lambda, alcance baseado em alcance ou automático. Obviamente, você pode transformar qualquer outro trecho de C ++.
Veja -se. C ++ Insights está disponível online: cppinsights.io.
Ainda assim, há trabalho a fazer.
Não afirmo acertar todas as coisas. Também estou trabalhando em recursos de suporte de novos padrões, como C ++ 20, no momento. Lembre -se de que o C ++ Insights é baseado em Clang e seu entendimento do AST.
Fiz algumas palestras sobre insights C ++ desde que liberei insights do C ++. Por exemplo, no C ++ agora. Aqui estão os slides e o vídeo.
Os insights C ++ podem ser construídos dentro ou fora da árvore de origem de Clang.
Consulte readme_windows.md
Para construir com extra/clang , use os seguintes sinalizadores extras: -DINSIGHTS_USE_SYSTEM_INCLUDES=off -DCLANG_LINK_CLANG_DYLIB=on -DLLVM_LINK_LLVM_DYLIB=on
Veja #186 para uma explicação de por que INSIGHTS_USE_SYSTEM_INCLUDES precisa ser desligado.
extra/clang e extra/llvm fornece /usr/lib/{libclangAST.so,libLLVM*.a,libLLVM.so} . libclangAST.so precisa de libLLVM.so e haveria um conflito se libLLVM*.a (em vez de libLLVM.so ) estivesse vinculado. Consulte https://bugs.archlinex.org/task/60512
Você precisa ter uma instalação de clang no caminho da pesquisa.
git clone https://github.com/andreasfertig/cppinsights.git
mkdir build && cd build
cmake -G"Ninja" ../cppinsights
ninja
O binário resultante (insights) pode ser encontrado na pasta build .
A maneira mais fácil de criar insights C ++ dentro da árvore de origem Clang é usar a opção LLVM_EXTERNAL_PROJECTS .
git clone https://github.com/llvm/llvm-project.git
git clone https://github.com/andreasfertig/cppinsights.git
mkdir build
cd build
cmake -G Ninja -D=CMAKE_BUILD_TYPE=Release -DLLVM_EXTERNAL_PROJECTS=cppinsights -DLLVM_EXTERNAL_CPPINSIGHTS_SOURCE_DIR=<PATH/TO/cppinsights> [INSIGHTS CMAKE OPTIONS] ../llvm-project/llvm
ninja
Existem algumas opções que podem ser ativadas com cmake:
| Opção | Descrição | Padrão |
|---|---|---|
| Insights_strip | Tira insight após a construção | SOBRE |
| Insights_static | Use link estático | DESLIGADO |
| Insights_Coverage | Ativar cobertura de código | DESLIGADO |
| Insights_use_libcpp | Use LIBC ++ para testes | DESLIGADO |
| DEPURAR | Ativar depuração | DESLIGADO |
Parece melhor fornecer a arquitetura durante a configuração:
cmake -DCMAKE_OSX_ARCHITECTURES=arm64 ../cppinsights
git clone https://github.com/andreasfertig/cppinsights.git
mkdir build_eclipse
cd build_eclipse
cmake -G"Eclipse CDT4 - Unix Makefiles" ../cppinsights/
Em seguida, no CEVOLN IMPORT -> GERAL -> Projeto existente no espaço de trabalho. Selecione build_eclipse . Desfrute de edição com o CEV.
O uso de insights C ++ é bastante simples:
insights <YOUR_CPP_FILE> -- -std=c++17
As coisas ficam complicadas quando se trata dos caminhos do sistema. Esses caminhos são codificados no binário, que parece vir dos insights do compilador C ++. Para ajudar com isso, consulte Scripts/getinclude.py. O script tenta coletar os caminhos do sistema do compilador. Sem uma opção, getinclude.py usa g++ . Você também pode passar por outro compilador como um primeiro argumento.
Aqui está um exemplo:
./scripts/getinclude.py
-isystem/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1 -isystem/usr/local/include -isystem/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/7.3.0/include -isystem/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include -isystem/usr/include
O script pode ser usado juntamente com insights C ++:
insights <YOUR_CPP_FILE> -- -std=c++17 `./scripts/getinclude.py`
Caso você tenha uma construção personalizada do compilador GCC, por exemplo, GCC-11.2.0, e não instalado no compilador no caminho padrão do sistema, depois de construir, Clang não encontra o caminho correto libstdc++ (STL do GCC). Se você se deparar com essa situação, poderá usar " --gcc-toolchain=/path/GCC-1x.xx/installed/path " para informar a CLANG/C ++ as informações da localização do STL:
./cppinsights Insights.cpp -- --gcc-toolchain=${GCC_11_2_0_INSTALL_PATH} -std=c++20
Aqui " ${GCC_11_2_0_INSTALL_PATH} " é o diretório de instalação do seu GCC personalizado. A opção para Clang é descrita aqui.
Há também outro projeto do GitHub que configura um contêiner do docker com a mais recente versão do C ++ Insights: C ++ Insights - Docker
Um plug -in para Vim está disponível aqui.
Um plugin para Neovim está disponível aqui.
Uma extensão para o código do Visual Studio está disponível no VS Code Marketplace: C ++ Insights - VSCode Extension.
Pelo menos para MacOS, você pode instalar informações de C ++ via Homebrew, graças a este formular:
brew install cppinsights
Eu pretendo o repositório para compilar com a versão mais recente do Clang e pelo menos a anterior. O site tenta ficar perto do último lançamento do CLANG. No entanto, devido a certos problemas (criando Clang para Windows), a versão do site geralmente é adiada por alguns meses.
Criei um canal no YouTube, onde lanço um novo vídeo todos os meses. Nesses vídeos, uso insights C ++ para mostrar e explicar certas construções de C ++ e, às vezes, explico as idéias C ++ também.
Veja TODO.
Se você gosta de apoiar o projeto, considere enviar um patch. Outra alternativa é se tornar um patrocinador do GitHub ou um apoiador do Patreon.
