| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| |
| = Verificação da Dependência de Make |
| :jbake-type: tutorial |
| :jbake-tags: tutorials |
| :jbake-status: published |
| :icons: font |
| :syntax: true |
| :source-highlighter: pygments |
| :toc: left |
| :toc-title: |
| :description: Verificação da Dependência de Make - Apache NetBeans |
| :keywords: Apache NetBeans, Tutorials, Verificação da Dependência de Make |
| |
| Contribuição de Alexey Vladykin |
| Março de 2014 [Número da revisão: V8.0-1] |
| |
| Este tutorial mostra como ativar o NetBeans IDE para verificar as dependências do arquivo em seus projetos durante a criação. A verificação de dependência é executada pelo utilitário ``make`` por meio de instruções em ``Makefile`` . |
| |
| |
| image::images/netbeans-stamp-80-74-73.png[title="O conteúdo desta página se aplica ao NetBeans IDE 7.3, 7.4 e 8.0"] |
| |
| |
| |
| == Requisitos |
| |
| *Para seguir este tutorial, são necessários os recursos e o software a seguir.* |
| |
| |=== |
| |Software |Versão Necessária |
| |
| |NetBeans IDE (incluindo o suporte ao C/C++) |link:https://netbeans.org/downloads/index.html[+versão 7.3, 7.4 ou 8.0 do NetBeans com o plug-in C/C+++] |
| |
| |Java Development Kit (JDK) |link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+versão 7 ou 8+] |
| |=== |
| |
| |
| Consulte as link:../../../community/releases/80/install.html[+Instruções de Instalação do NetBeans IDE+] e a link:../../../community/releases/80/cpp-setup-instructions.html[+ Configuração do NetBeans IDE para o C/C++/Fortran+] |
| para obter informações sobre o download e a instalação do software necessário. |
| |
| |
| == Introdução |
| |
| Grandes projetos C/C++ consistem em milhares de arquivos. Por exemplo, o kernel Linux tem cerca de 20.000 arquivos. Se estiver desenvolvendo um projeto e quiser recriá-lo após uma pequena alteração, por exemplo, correção de uma linha, há duas opções. |
| |
| * Recriação integral (ação Limpar e Construir). É menor, mas garante um resultado de construção consistente. |
| * Reconstrução incremental (ação Construir). É mais rápida, mas recriará corretamente tudo que deve ser recriado? |
| |
| O maior problema da recriação incremental é a presença de diretivas ``#include`` , que incluem o conteúdo de um arquivo em outro arquivo. O arquivo incluído é conhecido como dependência de arquivo. A modificação do arquivo incluído deve ser tratada como modificação de todos os arquivos que o incluem. As inclusões indiretas (A inclui B, B inclui C => A inclui C) tornam o problema até mais difícil. |
| |
| O NetBeans IDE suporta verificação automática das dependências do arquivo e faz seu melhor para tornar o trabalho de construção incremental correto. Se você alterar um arquivo do cabeçalho que estiver incluído em algum de seus arquivos de código-fonte e, em seguida, clicar em Construir, o IDE recriará somente estas partes do projeto que realmente dependem do cabeçalho alterado. Esta funcionalidade economiza tempo e garante resultados de construção consistentes. |
| |
| |
| === Ativando a Verificação de Dependência de um Projeto |
| |
| A verificação de dependência pode ser controlada para cada projeto específico. Talvez você queira certificar-se de que ela está ativada. |
| |
| *Para ativar a verificação de dependência para um projeto:* |
| |
| 1. clique com o botão direito do mouse no projeto na janela Projetos e escolha Propriedades. |
| 2. Na caixa de diálogo Propriedades do Projeto, selecione o nó Construir na lista Categorias. |
| 3. Nas propriedades de construção, marque a caixa de seleção Ativar Verificação de Dependência de Make. |
| |
| |
| image::images/project-checkbox.png[] |
| |
| |
| === Ativando a Verificação de Dependência por Default para Novos Projetos |
| |
| Você pode definir um estado default para verificação de dependência, de forma que novos projetos que você criar sejam ativados automaticamente para verificação de dependência de make. |
| |
| *Para ativar a verificação de dependência para todos os novos projetos criados no IDE:* |
| |
| 1. Escolha Ferramentas > Opções no menu principal do IDE. |
| 2. Clique no botão C/C++ no painel superior. |
| 3. Clique na guia Opções do Projeto. |
| 4. Marque a caixa de seleção para Ativar verificação de dependência nos makefiles gerados |
| |
| |
| image::images/global-checkbox.png[] |
| |
| |
| === Observações |
| |
| * A verificação de dependência automática trabalha para projetos C/C++ que foram criados no IDE (projetos gerenciados). O IDE cria lógica de verificação de dependência para o ``Makefile`` gerado. Para projetos criados com os códigos-fonte existentes você pode contar com a lógica de verificação de dependência (se houver) no ``Makefile`` existente. |
| * A verificação de dependência requer suporte de sua coleção de ferramentas ( ``make`` e compiladores). Ela foi testada com a coleção de ferramentas do Oracle Solaris Studio e as coleções de ferramentas GNU, incluindo Cygwin e MinGW. |
| * A verificação de dependência funciona quando os compiladores do Oracle Solaris Studio são usados com o ``make`` do Oracle Solaris e quando os compiladores GNU são usados com ``gmake`` de GNU. A mistura de ``make`` do Oracle Solaris com os compiladores GNU e vice-versa não é suportada. |
| |
| O restante do artigo é para os usuários avançados que querem saber o que acontece nos bastidores do IDE. |
| |
| |
| == Processo de Construção (make e makefiles) |
| |
| O processo de construção de cada projeto C/C++ no NetBeans é descrito em um ``Makefile`` , um arquivo de formato especial conhecido pelo utilitário ``make`` . Quando você constrói ou limpa seu projeto do GUI, o IDE chama ``make`` , que executa o Makefile. Esta abordagem permite que você construa facilmente seu projeto fora do IDE usando ``make`` : vá para seu diretório de projeto e digite ``make help`` para obter instruções. |
| |
| Os Makefiles usados pelo NetBeans IDE para um projeto C/C++ são mostrados abaixo. |
| |
| image::images/makefiles.png[] |
| |
| O ``Makefile`` mestre é gerado uma vez e você pode editá-lo manualmente. Os makefiles no diretório ``nbproject`` não são destinados para edição manual; eles são atualizados automaticamente pelo IDE. O arquivo ``Makefile-_CONF_.mk`` na ilustração representa vários arquivos para todas as configurações de seu projeto, como ``Makefile-Release.mk`` , ``Makefile-Debug.mk`` etc. |
| |
| Para um projeto gerenciado, o IDE gera todos os makefiles e insere instruções adequadas para a verificação de dependência. Para um projeto criado dos códigos de origem existentes, a verificação de dependência funcionará só se o ``Makefile`` contiver tais instruções, porque o NetBeans IDE não altera o ``Makefile`` existente. |
| |
| |
| == Conceitos Básicos sobre a Geração de Dependência |
| |
| Se quiser que o ``make`` verifique as dependências do arquivo incluídas durante a construção, então insira as informações de dependência no ``Makefile`` . Infelizmente não há nenhuma forma conveniente de fazer isso para todos os utilitários e compiladores de ``make`` . Primeiro, você deve detectar qual ``make`` está sendo executado e, em seguida, gerar as instruções de verificação de dependência correspondentes. |
| |
| O ``make`` do Oracle Solaris tem uma solução muito simples. Uma regra especial ``.KEEP_STATE:`` no ``Makefile`` instrui ``make`` para consultar o compilador sobre as dependências de arquivo e as armazena em um arquivo temporário. Na próxima vez que o projeto for reconstruído, o ``make`` carrega esse arquivo temporário, analisa as dependências armazenadas lá e determina quais cabeçalhos foram alterados e quais arquivos de objetos devem ser recompilados. |
| |
| Para ``make`` de GNU (chamado ``gmake`` ) a solução é muito mais complexa. Você deve solicitar explicitamente ao compilador para gerar as informações de dependência e, em seguida, incluí-la no ``Makefile`` . A ideia é informar flags especiais para o compilador, de forma que o compilador gere informações de dependência para cada arquivo do código-fonte compilado. Na próxima vez que o projeto for recriado, as informações de dependência serão coletadas e incluídas no ``Makefile`` . |
| |
| |
| == Implementação |
| |
| O código a seguir é adicionado ao ``nbproject/Makefile-impl.mk`` . Ele detecta qual ``make`` está sendo executado e coloca o código de verificação de dependência correspondente no arquivo ``.dep.inc`` . O ``make`` de GNU detectou a presença da variável ``MAKE_VERSION`` . Se ``MAKE_VERSION`` não for definida, então as instruções específicas de ``make`` do Solaris são geradas. |
| |
| |
| [source,java] |
| ---- |
| |
| # dependency checking support |
| .depcheck-impl: |
| @echo "# This code depends on make tool being used" >.dep.inc |
| @if [ -n "${MAKE_VERSION}" ]; then \ |
| echo "DEPFILES=\$$(wildcard \$$(addsuffix .d, \$${OBJECTFILES}))" >>.dep.inc; \ |
| echo "ifneq (\$${DEPFILES},)" >>.dep.inc; \ |
| echo "include \$${DEPFILES}" >>.dep.inc; \ |
| echo "endif" >>.dep.inc; \ |
| else \ |
| echo ".KEEP_STATE:" >>.dep.inc; \ |
| echo ".KEEP_STATE_FILE:.make.state.\$${CONF}" >>.dep.inc; \ |
| fi |
| ---- |
| |
| O código a seguir é adicionado ao ``nbproject/Makefile-${CONF}.mk`` . Ele instruiu ``make`` para ler o ``.dep.inc`` gerado anteriormente e executa instruções dele. |
| |
| |
| [source,java] |
| ---- |
| |
| # Enable dependency checking |
| .dep.inc: .depcheck-impl |
| |
| include .dep.inc |
| ---- |
| |
| A regra ``.dep.inc: .depcheck-impl`` é adicionada para evitar a falha de construção quando ``.dep.inc`` não existe. Há apenas um caso em que isso ocorre: quando você compila o arquivo único da janela Projetos. Neste caso, ``make`` executa o arquivo ``nbproject/Makefile-${CONF}.mk`` diretamente. |
| |
| |
| == Referências |
| |
| 1. link:http://en.wikipedia.org/wiki/Make_%28software%29[+Artigo da Wikipédia sobre ``make`` +] |
| 2. link:http://make.paulandlesley.org/autodep.html[+Geração de Dependência Automática Avançada+] |
| |
| |
| == Consulte Também |
| |
| Consulte a link:https://netbeans.org/kb/trails/cnd.html[+Trilha do Aprendizado C/C+++] para obter mais artigos sobre o desenvolvimento com C/C++/Fortran no NetBeans IDE. |
| |
| link:mailto:users@cnd.netbeans.org?subject=Feedback:%20Make%20Dependency%20Checking%20-%20NetBeans%20IDE%208.0%20Tutorial[+Enviar Feedback neste Tutorial+] |
