netbeans.apache.org/src/content/kb/docs/cnd/toolchain_pt_BR.asciidoc

// 
//     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.
//

= Usando o Descritor da Coleção de Ferramentas C/C++ - Tutorial do NetBeans IDE
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Usando o Descritor da Coleção de Ferramentas C/C++ - Tutorial do NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Usando o Descritor da Coleção de Ferramentas C/C++ - Tutorial do NetBeans IDE

_Contribuição de link:mailto:alexander.simon@oracle.com[+_Alexander Simon_+]
Março de 2014_ [Número da revisão: V8.0-1]


image::images/netbeans-stamp.png[title="O conteúdo desta página se aplica ao NetBeans IDE 8.0"]


*Para seguir este tutorial, você precisa do 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 8.0+] 

|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

Este tutorial demonstra como editar coleções de ferramentas existentes ou criar a versão personalizada de uma coleção no NetBeans IDE 8.0.

O exemplo mostrado se aplica à coleção de ferramentas GNU para Oracle Solaris e Linux, mas os conceitos também podem ser aplicados ao Windows e ao Mac. Usando estas informações, você pode aprender a fazer o seguinte:

* Alterar os flags do compilador que o IDE usa por default para compilar arquivos C/C++
* Adicionar um compilador que não é suportado pelo IDE


== Coleções de Ferramentas

Uma coleção de ferramentas é um conjunto de compiladores, um utilitário make e um depurador que é especificado no IDE por meio do _descritor de coleção da ferramenta_. Cada vez que você compila, executa ou depura seu código, o IDE executa um arquivo executável que é descrito no descritor de coleção de ferramentas para a coleção de ferramentas para a qual o projeto está configurado para usar. A funcionalidade Assistência ao Código inclui caminhos e macros obtidos do descritor da coleção de ferramentas.

O descritor da coleção de ferramentas é um arquivo XML localizado no módulo  ``_IDE_HOME_/cnd/modules/org-netbeans-modules-cnd-toolchain.jar``  na pasta  ``org/netbeans/modules/cnd/toolchain/resources/toolchaindefinition/`` . Você não deve editar estes arquivos XML do descritor de ferramentas do IDE original.

Este artigo informa como criar duplicações dos descritores da ferramenta em seu próprio diretório do usuário do NetBeans que você pode editar. Em seguida, o IDE usará as informações nos descritores de coleções de ferramentas localizados no diretório do usuário, em vez de nas versões originais.


== Coleções de Ferramentas de Contribuição da Comunidade

Alguns plug-ins para as coleções de ferramentas foram enviados pelos usuários da comunidade NetBeans:

* link:http://plugins.netbeans.org/plugin/36176/cuda-plugin[+Cuda+]
* link:http://plugins.netbeans.org/plugin/27033/msp430-toolchain[+TI msp430 microcontroller toolchain+]
* link:http://plugins.netbeans.org/plugin/42519/[+Visual Studio+]

Observe que esses plug-ins não são suportados oficialmente, mas são mencionados aqui, caso você os ache úteis na criação de seus próprios plug-ins.

Pode ser que os usuários do Windows também fiquem interessados em um artigo de um usuário da comunidade NetBeans: link:http://minghuasweblog.wordpress.com/2012/09/27/netbeans-setup-and-gnu-cross-toolchain-configuration-for-arm-developmen/[+NetBeans Setup and GNU Cross-Toolchain Configuration for ARM Development+].


== Editando os Descritores de Coleções de Ferramentas

A edição de um descritor da coleção de ferramentas é um pouco difícil, visto que o NetBeans IDE não oferece uma GUI para edição de descritores. Esta seção descreve como fazer cópias de "sombra" dos descritores de coleção da ferramenta que você pode editar, a fim de alterar a forma pela qual o IDE usa as ferramentas.

1. Saia do IDE se ele estiver em execução.
2. Edite o arquivo  ``_IDE-HOME_/etc/netbeans.conf`` , no qual  ``_IDE-HOME_``  é o diretório de instalação do NetBeans.
3. Adicione o seguinte flag à entrada  ``netbeans_default_options`` :

[source,java]
----

-J-Dcnd.toolchain.personality.create_shadow=true
----

[start=4]
. Inicie o IDE, escolha Ferramentas > Opções e selecione C/C++ na parte superior do painel da janela Opções. 

O IDE cria um diretório que contém versões de "sombra" dos descritores da coleção de ferramentas no diretório do usuário NetBeans:

_userdir_

[source,java]
----

/config/CND/ToolChain
----

A localização de seu diretório de usuário do NetBeans varia de acordo com seu sistema operacional. Algumas possíveis localizações do diretório  ``_userdir_/config/CND/ToolChain``  incluem o seguinte:

* Windows:  ``C:\Documents and Settings\_username_\Application Data\NetBeans\_version_\config\CND\ToolChain`` 
* Mac:  ``/Users/_username_/Library/Application Support/NetBeans/_version_/config/CND/ToolChain`` 
* Linux e Solaris:  ``/home/_username_/.netbeans/_version_/config/CND/ToolChain`` 

A lista de descritores deve ser semelhante à seguinte:


[source,java]
----

CLang.xml                             SunStudio.xml
CLang_mac.xml                         SunStudio_10.xml
CLang_solaris.xml                     SunStudio_11.xml
Cygwin.xml                            SunStudio_12.1_solaris-sparc.xml
Cygwin_4.x.xml                        SunStudio_12.1_solaris-x86_linux.xml
GNU.xml                               SunStudio_12.2_linuxCompatGNU.xml
GNU_mac.xml                           SunStudio_12.2_solaris-sparc.xml
GNU_solaris.xml                       SunStudio_12.2_solaris-x86_linux.xml
Intel.xml                             SunStudio_12.3_linuxCompatGNU.xml
Interix.xml                           SunStudio_12.3_solaris-sparc.xml
MinGW.xml                             SunStudio_12.3_solaris-x86_linux.xml
MinGW_TDM.xml                         SunStudio_12.xml
OSS_linuxCompatGNU.xml                SunStudio_8.xml
OSS_solaris-sparc.xml                 SunStudio_9.xml
OSS_solaris-x86_linux.xml             WinAVR.xml
OracleSolarisStudio.xml

----

Você pode editar o descritor para a toolchain que você está usando. Por exemplo, se estiver usando GNU no Solaris, edite o arquivo  ``GNU_solaris.xml`` ; se você estiver usando MinGW no Windows, você deve editar o arquivo  ``MinGW.xml`` .

Para obter informações sobre as tags usadas nestes arquivos XML do descritor, consulte <<details,Detalhes do Arquivo XML da Coleção de Ferramentas>>. Você pode alterar os valores das tags para alterar o procedimento das ferramentas no IDE.

Os descritores deste diretório têm prioridade em relação às versões oficiais no diretório _IDE-HOME_. Você deve deletar os descritores de ferramenta que você não deseja que o IDE use, em seu diretório do usuário.


[start=5]
. Remova o flag  ``-J-Dcnd.toolchain.personality.create_shadow=true``  do  ``_IDE-HOME_/etc/netbeans.conf`` , de forma que o IDE não crie descritores de sombra novamente.

[start=6]
. Reinicie o IDE para usar o descritor de ferramentas modificado quando terminar de fazer as alterações.


== Criando uma Coleção de Ferramentas Personalizada

Esta seção mostra como criar uma coleção de ferramentas que é baseada na coleção de ferramentas GNU com algumas alterações para os flags do compilador para depuração. O exemplo mostra etapas para criar um novo módulo do NetBeans que contenha uma nova coleção de ferramentas para permitir que você compartilhe a coleção de ferramentas ou use-a em outras instâncias do IDE.

Para obter informações gerais sobre a criação de módulos NetBeans, consulte link:http://platform.netbeans.org/tutorials/nbm-google.html[+Início Rápido do Plug-in do NetBeans+].


*Para criar uma coleção de ferramentas personalizada:*

1. Certifique-se de que sua instalação do NetBeans inclua o módulo de Desenvolvimento de Plug-in do NetBeans.

Escolha Ferramentas > Plug-ins e clique na guia Instalados. Se o módulo Desenvolvimento de Plug-in do NetBeans não estiver instalado, clique na guia Plug-ins Disponíveis e instale o módulo. É possível encontrá-lo rapidamente digitando "plug-in" na caixa Pesquisar.

[start=2]
. Crie um novo módulo NetBeans escolhendo Arquivo > Novo Projeto. Na página Escolher Projeto do assistente de Novo Projeto, selecione a categoria Módulos NetBeans e o projeto Módulo na primeira etapa do assistente. Clique em Próximo.

[start=3]
. Na página Nome e Localização, digite o nome do projeto, por exemplo  ``mytoolchain``  e deixe todos os campos como estão. Clique em Próximo.

[start=4]
. Na página Configuração Básica do Módulo, digite  ``org.myhome.mytoolchain``  para Base do Nome do Código, que define a string exclusiva que identifica o módulo que você está criando. A base do nome do código também é usada como o pacote principal do módulo.

[start=5]
. Não marque a caixa de seleção "Gerar Pacote OSGi", pois você usará o sistema de módulos do NetBeans default, em vez do OSGi.

[start=6]
. Clique em Finalizar. O IDE cria um novo projeto chamado mytoolchain.

[start=7]
. Na guia Projetos, clique com o botão direito do mouse no nó do projeto mytoolchain e selecione Novo > Outros.

[start=8]
. No assistente Novo Arquivo, selecione a categoria Desenvolvimento do Módulo e o tipo de arquivo Camada XML. Em seguida, clique em Próximo e em Finalizar. 

O IDE cria  ``layer.xml``  no nó Pacotes de Código-fonte, no pacote principal  ``org.myhome.mytoolchain``  e abre  ``layer.xml``  no editor.

[start=9]
. Se o arquivo contiver uma tag  ``<filesystem/>`` , substitua-a pelas tags  ``filesystem``  de abertura e fechamento: ``<filesystem>`` 

[source,xml]
----


 ``</filesystem>`` 
----

[start=10]
. Copie e cole o texto seguinte dentro da tag  ``layer.xml``  na tag  ``filesystem`` :

[source,xml]
----

<folder name="CND">
        <folder name="Tool">
            <file name="GNU_tuned_flavor" url="toolchain/GNU_tuned_flavor.xml">
                <attr name="extends" stringvalue="GNU_flavor"/>
            </file>
            <file name="GNU_tuned_cpp" url="toolchain/GNU_tuned_cpp.xml">
                <attr name="extends" stringvalue="GNU_cpp"/>
            </file>
        </folder>
        <folder name="ToolChains">
            <folder name="GNU_tuned">
                <attr name="position" intvalue="5000"/>
                <attr name="SystemFileSystem.localizingBundle" stringvalue="org.myhome.mytoolchain.Bundle"/>
                <file name="flavor.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_tuned_flavor"/>
                </file>
                <file name="c.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_c"/>
                </file>
                <file name="cpp.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_tuned_cpp"/>
                </file>
                <file name="fortran.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_fortran"/>
                </file>
                <file name="assembler.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_assembler"/>
                </file>
                <file name="scanner.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_scanner"/>
                </file>
                <file name="linker.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_linker"/>
                </file>
                <file name="make.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_make"/>
                </file>
                <file name="debugger.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_debugger"/>
                </file>
                <file name="qmake.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_qmake"/>
                </file>
                <file name="cmake.shadow">
                    <attr name="originalFile" stringvalue="CND/Tool/GNU_cmake"/>
                </file>
            </folder>
        </folder>
    </folder>
    
----

[start=11]
. Abra o arquivo  ``Bundle.properties``  e adicione a seguinte string:
 ``CND/ToolChains/GNU_tuned=My GNU Tuned Tool Collection`` 

[start=12]
. Crie um subpacote  ``toolchain``  clicando com o botão direito do mouse no pacote  ``org.myhome.mytoolchain``  em Pacotes de Código-fonte e selecionando Novo > Pacote Java. Substitua o nome do pacote default  ``newpackage``  por  ``toolchain``  e clique em Finalizar. O IDE cria o subpacote  ``org.myhome.mytoolchain.toolchain`` .

[start=13]
. Crie um novo arquivo, clicando com o botão direito do mouse no subpacote  ``org.myhome.mytoolchain.toolchain``  e selecionando Novo > Arquivo Vazio. Chame o projeto de  ``GNU_tuned_flavor.xml``  e clique em Finalizar.

Se você não visualizar Arquivo Vazio como uma opção, selecione Outros e, no assistente Novo Arquivo, selecione a categoria Outros e o tipo de arquivo Arquivo Vazio e clique em Próximo.

Este arquivo é o descritor de coleção de ferramentas para a nova coleção de ferramentas.


[start=14]
. Copie e cole o texto seguinte em  ``GNU_tuned_flavor.xml`` :

[source,xml]
----

<?xml version="1.0" encoding="UTF-8"?>
<toolchaindefinition xmlns="https://netbeans.org/ns/cnd-toolchain-definition/1">
    <toolchain name="GNU_tuned_flavor" display="GNU_tuned" family="GNU" qmakespec="${os}-g++"/>
    <platforms stringvalue="linux,sun_intel,sun_sparc"/>
</toolchaindefinition>

----

[start=15]
. Crie outro arquivo novo, clicando com o botão direito do mouse no subpacote  ``org.myhome.mytoolchain.toolchain``  e selecionando Novo > Arquivo Vazio. Chame o projeto de  ``GNU_tuned_cpp.xml``  e clique em Próximo.

[start=16]
. Copie e cole o texto seguinte em  ``GNU_tuned_cpp.xml`` :

[source,xml]
----

<?xml version="1.0" encoding="UTF-8"?>
<toolchaindefinition xmlns="https://netbeans.org/ns/cnd-toolchain-definition/1">
    <cpp>
        <compiler name="g++"/>
        <development_mode>
            <fast_build flags=""/>
            <debug flags="-g3 -gdwarf-2" default="true"/>
            <performance_debug flags="-g -O"/>
            <test_coverage flags="-g"/>
            <diagnosable_release flags="-g -O2"/>
            <release flags="-O2"/>
            <performance_release flags="-O3"/>
        </development_mode>
    </cpp>
</toolchaindefinition>

----

Observe que os flags de depuração estão definidos como -g3 e -gdwarf-2, que são diferentes dos flags definidos na descrição da coleção de ferramentas GNU default.

A árvore do projeto deve ter uma aparência semelhante à seguinte:

image::images/project.png[title="Árvore do projeto"]

As pastas Teste de Unidade talvez não exista.


[start=17]
. Na janela Projetos, clique com o botão direito do mouse no nó do projeto  ``mytoolchain``  e escolha Executar. O módulo é construído e instalado em uma nova instância do IDE, que é a plataforma de destino default dos módulos. A plataforma de destino se abre, de modo que você possa experimentar o novo módulo.

[start=18]
. No módulo em execução, escolha Ferramentas > Opções, selecione C/C++ na parte superior do painel da janela Opções e selecione a guia Ferramentas de Construção.

[start=19]
. Se a nova coleção de ferramentas (GNU_tuned) não for exibida, clique em Restaurar Default. Clique em Sim para continuar quando solicitado para verificar novamente seu ambiente.

O IDE mostra a nova coleção de ferramentas:

image::images/options.png[title="Painel Opções"]

[start=20]
. Crie um novo projeto C/C++ de amostra  ``Bem-Vindo``  selecionando Arquivo > Novo Projeto > Amostras > C/C++ > Bem-Vindo.

[start=21]
. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades. Na caixa de diálogo Propriedades do Projeto, selecione o nó Construir, defina a Coleção de Ferramentas como a coleção de ferramentas GNU_tuned e clique em OK.

[start=22]
. Construa o projeto. Observe que o compilador tem os flags  ``-g3 -gdwarf-2`` 

[source,java]
----

g++ -c -g3 -gdwarf-2 -MMD -MP -MF build/Debug/GNU_tuned-Solaris-x86/welcome.o.d -o build/Debug/GNU_tuned-Solaris-x86/welcome.o welcome.cc
----

[start=23]
. Na caixa de diálogo Propriedades do Projeto, selecione a coleção de ferramentas GNU e clique em OK.

[start=24]
. Construa o projeto novamente e compare a linha compilada na janela de saída:

[source,java]
----

g++ -c -g -MMD -MP -MF build/Debug/GNU-Solaris-x86/welcome.o.d -o build/Debug/GNU-Solaris-x86/welcome.o welcome.cc
----

Você verá que a coleção de ferramentas GNU_tuned tem diferentes flags do compilador para depuração, Modo de Desenvolvimento para o compilador GNU.

Se quiser usar o novo módulo para a coleção de ferramentas GNU_tuned no seu IDE habitual, você pode criar um binário (um arquivo .nbm) e adicioná-lo como um plug-in:

1. Clique com o botão direito do mouse no projeto do módulo mytoolchain e selecione Criar NBM. O arquivo .nbm é criado no subdiretório de construção do projeto, o qual pode ser visto na guia Arquivos.
2. Selecione Ferramentas > Plug-ins e clique na guia Submetido a Download na caixa de diálogo Plug-ins.
3. Clique em Adicionar Plug-ins, vá até o diretório de construção, selecione o módulo do arquivo .nbm e clique em Abrir. O módulo de plug-in é adicionado à lista na guia Submetido a Download.
4. Clique na caixa de seleção para selecionar o módulo na guia Submetido a Download e clique no botão Instalar. O Instalador de Plug-in do NetBeans e aberto.
5. Clique em Próximo para avançar pelo instalador e continuar até que a instalação seja finalizada.
6. Reinicie o IDE, em seguida, escolha Ferramentas > Opções, selecione C/C++ na parte superior do painel da janela Opções e selecione a guia Ferramentas de Construção.
7. Se a nova coleção de ferramentas (GNU_tuned) não for exibida, clique em Restaurar Defaults. Clique em Sim para continuar quando solicitado para verificar novamente seu ambiente.


=== Detalhes do Arquivo XML da Coleção de Ferramentas

Trata-se de uma descrição das tags mais importantes do arquivo xml da coleção de ferramentas.

Para obter um esquema de todas as tags e atributos suportados dos arquivos xml de toolchain, você pode pesquisar o arquivo  ``toolchaindefinition.xsd``  na link:http://hg.netbeans.org/cnd-main[+árvore do código-fonte do NetBeans IDE+].


==== Tags de definição da coleção de ferramentas

|===
|Tags |Atributos |Descrição 

|toolchain |Nome da coleção de ferramentas 

|nome |Nome da coleção de ferramentas 

|exibição |Nome de exibição da coleção de ferramentas 

|família |Nome do grupo da coleção de ferramentas 

|plataformas |Plataformas suportadas 

|stringvalue |Lista das plataformas suportadas separadas por vírgula.
Os valores possíveis são:

* linux
* unix
* sun_intel
* sun_sparc
* windows
* mac
* none
 

|makefile_writer |Escritor de makefile personalizado. 

|classe |Nome da classe do escritor de makefile personalizado. Deve implementar
org.netbeans.modules.cnd.makeproject.spi.configurations.MakefileWriter. 

|drive_letter_prefix |Prefixo especial para nomes de arquivos 

|stringvalue |"/" para unix
"/cygdrive/" para cygwin no Windows 

|base_folders |Contêiner das tags base_folder. 
Uma ou mais tags base_folder estão contidas em uma tag base_folders. 

|base_folder |Descrição do diretório-base dos compiladores.
Este tag pode conter as seguintes tags: 

|regestry |Chave de registro do Windows da ferramenta. Observe que a tag XML deve ser escrita "regestry" embora seja um erro ortográfico. 

|pattern |Expressão regular que permite que o NetBeans IDE localize o compilador no registro 

|suffix |Pasta com os arquivos executáveis 

|path_patern |Expressão regular que permite que o NetBeans IDE localize o compilador examinando os caminhos. Observe que a tag XML deve ser escrita "path_patern" embora seja um erro ortográfico. 

|command_folders |Contêiner das tags command_folder. 
Uma ou mais tags commander_folder estão contidas em uma tag command_folders. 

|command_folder |Descreve o diretório no qual se encontram os comandos do tipo UNIX.
Necessários somente para compiladores MinGW no Windows. A tag command_folder pode conter as seguintes tags: 

|regestry |Chave de comandos de registro do Windows. Observe que a tag XML deve ser escrita "regestry" embora seja um erro ortográfico. 

|pattern |Expressão regular que permite que o NetBeans IDE localize a pasta de comandos no registro 

|suffix |Pasta com os arquivos executáveis 

|path_patern |Expressão regular que permite que o NetBeans IDE localize os comandos. Observe que a tag XML deve ser escrita "path_patern" embora seja um erro ortográfico. 

|scanner |Nome do serviço de parser de erros, consulte <<errorhandler,Criando um Handler de Erros Personalizado para o Compilador>> 

|id |Nome do serviço de parser de erros 
|===


==== Flags do Compilador

Esta tabela lista as tags usadas para descrever os compiladores e especificar os flags do compilador para toolchain.

|===
|Tags |Descrição |Exemplo de compilador GNU 

|c,cpp |O conjunto de flags do compilador está localizado nos subnós a seguir 

|reconhecedor |Expressão regular que permite que o IDE localize o compilador |Para GNU em cygwin no Windows
.*[\\/].*cygwin.*[\\/]bin[\\/]?$ 

|compilador |Nome do compilador (nome do arquivo executável) |gcc ou g++ 

|versão |Flag de versão |--version 

|system_include_paths |Flags para obter caminhos de inclusão do sistema |-x c -E -v 

|system_macros |Flags para obter as macros do sistema |-x c -E -dM 

|user_include |Flag para adicionar caminho de inclusão do usuário |-I 

|user_file |Flag para incluir o conteúdo de _file_ antes de outros arquivos |-include _file_ 

|user_macro |Flag para adicionar macro do usuário |-D 

|development_mode |Grupos de flags para diferentes modos de desenvolvimento 

|warning_level |Grupos de flags para diferentes níveis de advertência 

|architecture |Grupos de flags para diferente arquitetura 

|strip |Flag para informações de depuração de faixa |-s 

|c_standard |Especifica os flags para usar os padrões C. Use com as tags c89, c99 e c11. |c89 flags="-std=c89"
c99 flags="-std=c99"
c11 flags="-std=c11" 

|cpp_standard |Especifica os flags para usar os padrões C++. Use com as tags cpp98 e cpp11. |cpp98 flags="-std=c++98"
cpp11 flags="-std=c++11"
cpp11 flags="-std=gnu++0x" 

|output_object_file |Flags para especificar o arquivo do objeto |-o _(deve ter o seguinte espaço -o)_ 

|dependency_generation |Flags de geração de dependência |-MMD -MP -MF $@.d 

|precompiled_header |Flag do cabeçalho pré-compilado |-o $@ 

|important_flags |Expressão regular que especifica quais flags do compilador alteram os caminhos de inclusão e as macros predefinidas do sistema padrão para assistência de código |-O1|-O2|-O3|-O4|-O5|-Ofast|-Og|-Os|-ansi|-fPIC|-fPIE|-fasynchronous-unwind-tables|-fbuilding-libgcc|-fexceptions|-ffast-math|-ffinite-math-only|-ffreestanding|-fgnu-tm|-fhandle-exceptions|-fleading-underscore|-fno-exceptions|-fno-rtti|-fnon-call-exceptions|-fnon-call-exceptions|-fopenmp|-fpic|-fpie|-fsanitize=address|-fshort-double|-fshort-wchar|-fsignaling-nans|-fstack-protector(\W|$|-)|-fstack-protector-all|-funsigned-char|-funwind-tables|-g(\W|$|-)|-ggdb|-gsplit-dwarf|-gtoggle|-m128bit-long-double|-m3dnow|-m64|-mabm|-madx|-maes|-march=.*|-mavx|-mavx2|-mbmi|-mbmi2|-mf16c|-mfma(\W|$|-)|-mfma4|-mfsgsbase|-mlong-double-64|-mlwp|-mlzcnt|-mpclmul|-mpopcnt|-mprfchw|-mrdrnd|-mrdseed|-mrtm|-msse3|-msse4(\W|$|-)|-msse4.1|-msse4.2|-msse4a|-msse5|-mssse3|-mtbm|-mtune=.*|-mx32|-mxop|-mxsave|-mxsaveopt|-pthreads|-std=.*|-xc($|\+\+$) 

|multithreading |Grupos de flags de suporte a multithreading |Só para a coleção de ferramentas do Oracle Solaris Studio; não usado para as coleções de ferramentas com base em GNU 

|standard |Grupos de flags para diferentes padrões de linguagem |Só para a coleção de ferramentas do Oracle Solaris Studio; não usado para as coleções de ferramentas com base em GNU 

|language_extension |Grupos de flags para diferentes extensões de linguagem |Só para a coleção de ferramentas do Oracle Solaris Studio; não usado para as coleções de ferramentas com base em GNU 
|===


== Criando um Provedor de Compilador Personalizado

O NetBeans IDE possui um provedor de compilador default:
org.netbeans.modules.cnd.toolchain.compilers.MakeProjectCompilerProvider 
Este provedor funciona bastante bem na maioria dos toolchains, mas você pode criar seu próprio provedor.

*Para criar seu próprio provedor de compilador:*

* amplie a classe abstrata org.netbeans.modules.cnd.api.compilers.CompilerProvider
* defina a classe como serviço e coloque-a antes do provedor default:

[source,java]
----

@org.openide.util.lookup.ServiceProvider(service = org.netbeans.modules.cnd.spi.toolchain.CompilerProvider.class,
position=500)
public class CustomCompilerProvider extends CompilerProvider {
...
}

----
O atributo position=500 garante que o provedor personalizado será chamado antes do provedor default. O provedor personalizado deveria retornar "Tool" não-nula no método "createCompiler()" para a ferramenta que deveria ser substituída.


== Criando um Handler de Erros Personalizado para o Compilador

O NetBeans IDE possui dois handlers de erros do compilador default.

* para compilador GNU
* para compilador Sun Studio

O handler do compilador GNU funciona bastante bem em qualquer compilador GNU, mas, se quiser, pode definir seus próprios handlers de erros do compilador.

*Para criar seu próprio handler de erro do compilador: *

* estenda a classe abstrata org.netbeans.modules.cnd.api.compilers.CompilerProvider
* defina a classe como serviço:

[source,java]
----

@org.openide.util.lookup.ServiceProvider(service = org.netbeans.modules.cnd.spi.toolchain.CompilerProvider.class)
      public class CustomCompilerProvider extends ErrorParserProvider {
          ...
          @Override
          public String getID() {
      	return "MyParser";  // NOI18N
          }
      }
----
* vincule o scanner de erros e a descrição da coleção de ferramentas usando o ID:

[source,xml]
----

</scanner id="MyParser">
...
  </scanner>
----


== 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:Using%20the%20C/C++%20Tool%20Collection%20Descriptors%20-%20NetBeans%20IDE%208.0%20Tutorial[+Enviar Feedback neste Tutorial+]