GNU Faça o tutorial

O GNU Make é uma ferramenta essencial para construir e gerenciar os projetos, especialmente onde o projeto contém arquivos diferentes que são construídos usando ferramentas diferentes. Nesse caso, o GNU faz localizar o makefile para esse projeto, pois o arquivo especifica as dependências necessárias entre vários arquivos no projeto especificado e os comandos necessários para construir o projeto.

GNU Make foi projetado para lidar com grandes projetos. Ele determina as seções de um programa que deve ser recompilado após uma determinada ação e oferece os comandos para recompilar as seções. A postagem de hoje fornece um guia prático para entender tudo sobre GNU Make.

Compreender um makefile

GNU Faça lê o makefile de um projeto para determinar o que deve fazer para construir e gerenciar o projeto. Um Makefile tem três componentes principais: alvo, pré -requisito e receita.

A alvo representa o arquivo que o “fazer”O comando pode gerar. O alvo pode depender dos pré -requisitos e também pode ser uma ação a ser realizada. Idealmente, o alvo destaca o arquivo a ser construído depois de executar o “fazer”Comando.

A Pré -requisito representa o arquivo a ser usado como entrada para criar o alvo. Um alvo pode depender de vários pré -requisitos.

A receita é uma ação ou comando que é realizado por “fazer”Para recomitar o alvo sempre que o pré -requisito muda. A receita pode conter comandos diferentes nas mesmas linhas diferentes ou diferentes. A espaço da guia Precede cada nova linha de receita, e o editor levanta um erro se você perder a adição do caractere da guia.

O receita Atua como uma série de comandos de shell começando com um personagem de guia. Aqui está um exemplo de um simples makefile que destaca o alvo, os pré -requisitos e a receita:

O makefile fornecido consiste em uma regra na receita. Observe que Make usa a primeira regra no Makefile como a regra padrão. Então, em tal makefile, “fazer”Usa o gcc -o bem -vindo ótimo.c Como regra para construir e gerenciar o projeto. A regra especifica que você faz o arquivo para gerar o Bem-vindo arquivo, devemos executar o comando que usa o ótimo.c como a entrada para criar o Bem-vindo arquivo.

Novamente, nem todas as regras têm um pré -requisito. Por exemplo, se você tiver um Makefile para excluir os arquivos intermediários criados ao criar um arquivo, essa regra não terá nenhum pré -requisito. Dê uma olhada no exemplo a seguir:

Nesse caso, a regra exclui todos os arquivos que contêm a *.o Extensão. Assim, um pré -requisito não é necessário em um caso como nenhuma recompilação do alvo é necessária.

Trabalhando com um Makefile

O primeiro exemplo é um projeto C simples com dois arquivos C e um arquivo de cabeçalho. Criamos uma função que imprime uma mensagem de boas -vindas e inclui um arquivo de cabeçalho externo em nosso projeto.

Aqui está a principal função:

Nossos arquivos de cabeçalho se parecem com o seguinte:

Agora, vamos criar um makefile que compila os arquivos do projeto para criar um arquivo executável no diretório atual. Idealmente, executamos o seguinte comando para construir o projeto:

$ GCC -O GREATMAK.C func1.c -i.

Na imagem a seguir, podemos observar como a compilação constrói com sucesso o projeto. Se executarmos o arquivo executável criado, obtemos a saída desejada.

Como podemos representar o mesmo e usar um makefile em vez disso? Aqui está a coisa: embora a compilação diretamente do projeto na linha de comando funcione bem, o problema entra quando você muda os computadores ou perde o código de compilação. Nesse caso, você deve recompilar o projeto. Novamente, sempre que você faz alterações em um arquivo, você deve recomitar manualmente o projeto para acomodar as alterações.

Todo esse aborrecimento pode ser excluído criando um simples makefile, conforme mostrado no seguinte:

O Makefile contém dois alvos: um com pré -requisitos e um comando e o outro apenas com o comando.

Antes, observamos que “fazer”Usa o primeiro comando como o comando padrão para construir o projeto. Portanto, podemos digitar fazer no diretório do projeto para executar o comando para criar o projeto. O comando make gera o alvo que é Greatmake como o arquivo executável. Dê uma olhada no seguinte:

Agora, podemos executar confortavelmente o arquivo executável para ver a saída do projeto criado.

$ ./arquivo de saída

Suponha que usemos “fazer”Para executar outro comando em vez do padrão. Especifique o alvo que você deseja executar com o comando make.

$ Make Target

Vamos usar o mesmo makefile e usar o Hello Target:

Observe como conseguimos conseguir “fazer”Para executar o comando, pois nenhum pré -requisito é especificado com o alvo.

Se fizermos algumas alterações em um dos arquivos do projeto, executando o “fazer”O comando acomoda as mudanças sem a necessidade de recompilar o projeto manualmente.

Ainda assim, se você executar o “fazer”Comando sem novas mudanças,“fazer”Notifica que o arquivo executável está atualizado.

Suponha que você não tenha certeza das mudanças que fez ou o que o comando make faz quando executado. Você pode fazer uma corrida a seco adicionando a bandeira -n.

O primeiro exemplo na ilustração seguinte, a marca -n, mostra o comando que é executado com o comando padrão. No próximo caso, o make -n mostra as alterações que são adicionadas ao alvo do hello.

Se você se sentir confortável com as alterações, poderá executar o comando make para o alvo especificado para acomodar as alterações como no exemplo a seguir:

Como usar as variáveis ​​makefile

Até agora, entendemos como “fazer”Trabalha com um makefile. No entanto, nossa abordagem até agora não é a melhor para lidar com grandes projetos, especialmente onde alguns valores devem mudar com o tempo. Uma abordagem melhor envolve o uso de variáveis ​​de modo que, se você deseja alterar o compilador para o programa, você pode editar a variável em vez de alterar manualmente o código Makefile para o compilador.

Além disso, as variáveis ​​ajudam a alcançar um código makefile limpo que qualquer pessoa pode ler e entender.

Vamos ter um exemplo de uso das variáveis ​​para criar arquivos.

No Makefile, definimos uma variável nomeada arquivos que contém dois valores para os arquivos que criamos quando construímos o projeto:

Neste exemplo, vamos nos referir ao nosso exemplo anterior de compilação do programa C. Mas, neste caso, vamos adicionar algumas variáveis ​​que podemos mudar ao longo do programa.

Primeiro, especificamos o caminho que o compilador deve usar para localizar os arquivos do cabeçalho como o diretório atual (.). Uma abordagem melhor é especificar o caminho como uma variável. Você pode especificar a variável que deve ser usada pelo compilador usando o Cflags Constantes especiais que são usadas para se comunicar com o compilador.

Cflags = -i.

Use o $ (Cflags) espaço reservado variável no lugar do caminho.

Ainda assim, podemos definir o compilador de tipo para usar como uma variável, de modo que alguém que usa um compilador diferente possa alterar a variável para especificar um compilador para usar para o seu caso.

CC = GCC

Use o $ (CC) espaço reservado variável no lugar do compilador. Aqui está o Makefile final com as variáveis ​​adicionais:

Quando executamos o comando make, obtemos a mesma saída que fizemos anteriormente, apenas que nosso código Makefile agora é mais limpo e eliminamos qualquer redundância.

Ao criar o makefile, você pode criar uma macro Obj para representar os pré -requisitos necessários para criar um alvo. Dessa forma, você pode editar rapidamente os arquivos de objeto da macro sem adulterar com o outro Makefile. Por exemplo, podemos ter um Macro OBJ para o nosso alvo, como mostrado no seguinte:

Observe que substituímos os pré -requisitos pela variável de objeto.

Manuseio de dependências

O "incluir”Os arquivos dependem do“.c”Arquivos no projeto. Ao trabalhar com um grande projeto e você edita o “incluir” arquivo, "Make" não recompilará o ".c" arquivos. Este erro significa que seu projeto não será recompilado corretamente, a menos que façamos o makefile observar as dependências existentes entre o “.c" e ".h" arquivos.

Nesse caso, precisamos usar a constante especial Deps Para criar uma macro para lidar com essas dependências. Podemos representar os DEPS em regra, como mostrado no seguinte:

A regra anterior primeiro cria um Deps Macro cujo valor é o arquivo de cabeçalho nos arquivos do projeto. Em seguida, instrui “fazer"Que antes de gera o".o”Arquivo, ele deve primeiro compilar o“.c”Arquivo usando o compilador especificado. Em seguida, o sinalizador -c indica o compilador para gerar um arquivo de objeto enquanto o -O $@ Instrui ““fazer”Para colocar a saída compilada à esquerda do cólon.

Com esta regra, lidamos com todas as dependências de modo que sempre que alteramos qualquer arquivo, “fazer”Acomoda quando recompilar o projeto.

Adicionando outros makefiles

Ao trabalhar com um Makefile, é possível incluir os outros makefiles. Dessa forma, o atual makefile pode ler a partir dos makefiles incluídos para apoiar a compilação.

Para incluir outros makefiles, adicione o incluir palavra -chave que instrui “fazer”Para pausar a leitura do atual makefile e ler o outro incluído makefiles.

incluir nomes de arquivos

Você também pode incluir outros tipos de arquivo com a palavra -chave incluir, desde que você adicione o espaçamento entre os nomes de arquivos.

Dividindo longas filas em makefiles

Embora "fazer”Não tem limite de quanto tempo pode ter uma declaração, as frases longas rapidamente se tornam ilegíveis e são um estilo de formatação ruim. GNU “fazer”Acomoda a divisão de frases longas, adicionando o personagem de barra de barragem.

Obj = mainfunc.C \
func1.c

Neste exemplo, “fazer”Lê a linha anterior como Obj = mainfunc.C func1.c e ignorar o barragem.

Na imagem fornecida, dividimos a linha de receita com uma barra de barra.

Suponha que você queira representar uma palavra sem adicionar um espaço em branco. Substitua a barra de barriga por um sinal de dólar, uma barra de barriga e uma nova linha.

Aqui está um exemplo:

Quando "fazer”Lê o Makefile, ele primeiro ignora a barra de barragem para uma nova linha. Em seguida, ele lê o sinal de dólar como um espaço que representa uma variável com um personagem.

Portanto, eventualmente trata suas linhas divididas como uma palavra sem espaço em branco. Quando usamos “fazer”Para ler o Makefile, não recebemos erro desde“fazer”Trata as linhas divididas na variável como uma palavra.

Limpando um diretório

Depois de compilar um programa usando “fazer”, Pode ser necessário limpar arquivos desnecessários que são gerados como saída. Embora a criação de um alvo limpo seja possível, essa não é a abordagem recomendada, como mostrado no seguinte:

A imagem anterior instrui "fazer" Para excluir todos os arquivos de texto e “.o”Arquivos de extensão criados no diretório atual.

Para lidar com as situações imprevistas, é melhor criar uma regra mais precisa e garantir que você não a adicione como a regra padrão (primeiro) no Makefile.

Ao executar a regra limpa, use o “Faça limpo”Comando.

Conclusão

GNU “Make” é uma ferramenta útil para construir e gerenciar projetos pequenos e grandes. Saber como usá -lo é uma vantagem adicional, pois ajuda você a ler suas makefiles e compilar seus projetos com cuidado. Aprendemos a usar o GNU “fazer”Defuso. Felizmente, este guia lançou uma base para aprimorar sua GNU faz habilidades para lidar com seus projetos.