Um makefile que descreve como recompilar um programa pode ser usado de várias maneiras. O uso mais simples é recompilar todos os arquivos que estão desatualizados (que precisam ser atualizados). Em geral, os makefiles são escritos de modo que, ao executar make sem nenhum argumento, ele faça exatamente isso.
No entanto, às vezes você quer atualizar apenas alguns arquivos. Ou pode querer usar um compilador diferente ou opções de compilação diferentes; ou ainda, sem alterar os próprios arquivos, apenas descobrir quais deles estão desatualizados.
Fornecendo argumentos ao executar make, você pode realizar essas e muitas outras coisas.
O status de saída do make é sempre um destes três valores:
0Quando o make é bem-sucedido, o status de saída é zero.
2Quando o make encontra algum erro, o status de saída é 2. Nesse caso, são exibidas mensagens que descrevem cada erro.
1Quando você usa o sinalizador ‘-q’ e o make determina que algum alvo ainda não está atualizado, o status de saída é 1. Consulte Em vez de executar receitas.
Para especificar o nome do makefile a ser usado, utilize a opção ‘-f’ ou ‘--file’ (‘--makefile’ também funciona). Por exemplo, ‘-f altmake’ indica que o arquivo altmake deve ser usado como makefile.
Se você usar o sinalizador ‘-f’ várias vezes, seguindo cada ‘-f’ de um argumento, todos os arquivos especificados serão usados em conjunto como makefiles.
Se você não usar o sinalizador ‘-f’ ou ‘--file’, o padrão é tentar GNUmakefile, makefile e Makefile, nessa ordem, e usar o primeiro destes três que existir ou que puder ser gerado (consulte Como escrever makefiles).
As metas são os alvos que o make deve, em última instância, tentar atualizar. Outros alvos também são atualizados quando aparecem como pré-requisitos (prerequisites) das metas, como pré-requisitos dos pré-requisitos das metas, e assim por diante.
Por padrão, a meta é o primeiro alvo do makefile (sem contar os alvos que começam com um ponto). Por isso, os makefiles geralmente são escritos de modo que o primeiro alvo seja a compilação do programa inteiro (ou dos vários programas) que descrevem. Se a primeira regra do makefile tiver vários alvos, apenas o primeiro alvo da regra se torna a meta padrão, e não a lista inteira. Você pode controlar a seleção da meta padrão dentro do seu makefile usando a variável .DEFAULT_GOAL (consulte Outras variáveis especiais).
Você também pode especificar uma ou mais metas diferentes por meio de argumentos de linha de comando para o make. Use o nome da meta como argumento. Se você especificar várias metas, o make processa cada uma delas por vez, na ordem em que foram nomeadas.
Qualquer alvo do makefile pode ser especificado como meta (a menos que comece com ‘-’ ou contenha um ‘=’, pois nesses casos será interpretado como uma opção ou uma definição de variável, respectivamente). Além disso, até alvos que não estejam no makefile podem ser especificados, desde que o make consiga encontrar regras implícitas que indiquem como gerá-los.
O make define a variável especial MAKECMDGOALS com a lista de metas que você especificou na linha de comando. Se nenhuma meta foi fornecida na linha de comando, essa variável fica vazia. Observe que essa variável só deve ser usada em circunstâncias especiais.
Um exemplo de uso apropriado é evitar incluir arquivos .d durante a execução da regra clean (consulte Gerar pré-requisitos automaticamente). Assim, evita-se o desperdício de o make gerar os arquivos .d apenas para removê-los logo em seguida:
sources = foo.c bar.c ifeq (,$(filter clean,$(MAKECMDGOALS)) include $(sources:.c=.d) endif
Um uso de especificar uma meta é quando você quer compilar apenas uma parte do programa, ou apenas um de vários programas. Especifique como meta cada arquivo que deseja refazer. Por exemplo, considere um diretório que contém vários programas, com um makefile que começa assim:
.PHONY: all all: size nm ld ar as
Se você está trabalhando no programa size, pode digitar ‘make size’ para que somente os arquivos desse programa sejam recompilados.
Outro uso de especificar uma meta é gerar arquivos que normalmente não são gerados. Por exemplo, pode haver um arquivo de saída de depuração, ou uma versão do programa compilada especialmente para testes, que tem uma regra no makefile mas não é pré-requisito da meta padrão.
Mais um uso de especificar uma meta é executar a receita associada a um alvo falso (phony) (consulte Alvos falsos (Phony)) ou a um alvo vazio (consulte Arquivos de alvo vazio para registrar eventos). Muitos makefiles contêm um alvo falso chamado clean que apaga tudo, exceto os arquivos fonte. Naturalmente, isso só é feito quando você o solicita explicitamente com ‘make clean’. A seguir, uma lista de nomes típicos de alvos falsos e vazios. Para uma lista detalhada de todos os nomes de alvos padrão usados pelos pacotes de software GNU, consulte Alvos padrão para usuários.
Gera todos os alvos de nível superior que o makefile conhece.
Apaga todos os arquivos que normalmente são criados pela execução do make.
Semelhante a ‘clean’, mas pode deixar de apagar alguns arquivos que normalmente não se deseja recompilar. Por exemplo, o alvo ‘mostlyclean’ do GCC não apaga libgcc.a, porque recompilá-lo raramente é necessário e leva muito tempo.
Qualquer um desses alvos pode ser definido para apagar mais arquivos do que ‘clean’ apaga. Por exemplo, apagar arquivos de configuração ou links que você normalmente cria como preparação para a compilação, mesmo que o próprio makefile não seja capaz de gerar esses arquivos.
Copia o arquivo executável para um diretório onde os usuários normalmente procuram comandos; e copia quaisquer arquivos auxiliares que o executável utilize para os diretórios onde ele os procurará.
Imprime a lista dos arquivos fonte que foram alterados.
Cria um arquivo tar dos arquivos fonte.
Cria um arquivo shell (arquivo shar) dos arquivos fonte.
Cria um arquivo de distribuição dos arquivos fonte. Pode ser um arquivo tar, um arquivo shar, uma versão compactada de um deles, ou ainda uma combinação de vários dos anteriores.
Atualiza uma tabela de tags para este programa.
Executa autotestes no programa que este makefile gera.
O makefile informa ao make como determinar se um alvo está atualizado e como atualizar cada alvo. Mas atualizar os alvos nem sempre é o que você quer. Algumas opções fazem o make realizar atividades diferentes da atualização.
“No-op” (não fazer nada). Faz o make exibir as receitas necessárias para deixar os alvos atualizados, mas sem executá-las de fato. Observe que algumas receitas ainda são executadas mesmo com esse sinalizador (consulte Como funciona a variável MAKE). Além disso, as receitas necessárias para atualizar makefiles incluídos também são executadas (consulte Como os makefiles são refeitos).
“Touch”. Marca os alvos como atualizados sem realmente alterá-los. Em outras palavras, o make finge atualizar os alvos, mas não muda de fato o conteúdo deles; apenas o horário de modificação é reescrito.
“Question” (pergunta). Verifica em silêncio se os alvos estão atualizados, mas não executa receitas. A necessidade de atualização é indicada pelo código de saída.
“What if” (e se). Cada sinalizador ‘-W’ é seguido de um nome de arquivo. Os horários de modificação dos arquivos indicados são registrados pelo make como sendo o horário atual, embora os horários de modificação reais permaneçam os mesmos. Você pode usar o sinalizador ‘-W’ em conjunto com o sinalizador ‘-n’ para ver o que aconteceria se você alterasse arquivos específicos.
Com o sinalizador ‘-n’, o make exibe a receita que normalmente executaria, mas na maioria dos casos não a executa.
Com o sinalizador ‘-t’, o make ignora as receitas das regras e usa (na prática) o comando touch em cada alvo que precisa ser refeito. O comando touch também é exibido, a menos que ‘-s’ ou .SILENT seja usado. Por questão de velocidade, o make não invoca de fato o programa touch; ele realiza o trabalho diretamente.
Com o sinalizador ‘-q’, o make não exibe nada e não executa nenhuma receita, mas retorna o código de status de saída zero somente quando os alvos considerados já estão atualizados. Se o status de saída for 1, então é necessário fazer alguma atualização. Quando o make encontra um erro, o status de saída é 2, de modo que você pode distinguir um erro de um alvo que não está atualizado.
É um erro usar mais de um destes três sinalizadores na mesma invocação do make.
As opções ‘-n’, ‘-t’ e ‘-q’ não afetam linhas de receita que começam com o caractere ‘+’ nem linhas que contêm as strings ‘$(MAKE)’ ou ‘${MAKE}’. Observe que, independentemente dessas opções, apenas a linha que contém o caractere ‘+’ ou as strings ‘$(MAKE)’ ou ‘${MAKE}’ é executada. As demais linhas da mesma regra não são executadas, a menos que elas próprias comecem com ‘+’ ou contenham ‘$(MAKE)’ ou ‘${MAKE}’ (consulte Como funciona a variável MAKE).
O sinalizador ‘-t’ impede que alvos falsos (phony) (consulte Alvos falsos (Phony)) sejam atualizados, exceto quando há linhas de receita que começam com ‘+’ ou que contêm ‘$(MAKE)’ ou ‘${MAKE}’.
O sinalizador ‘-W’ oferece dois recursos:
make faria se você alterasse algum arquivo.
make está de fato executando receitas, o sinalizador ‘-W’ pode fazer o make agir como se alguns arquivos tivessem sido modificados. Nesse caso, as receitas desses arquivos não são realmente executadas.
Observe que as opções ‘-p’ e ‘-v’ permitem obter outras informações sobre o próprio make ou sobre os makefiles em uso (consulte Resumo das opções).
Pode acontecer de você ter alterado um arquivo fonte mas não querer recompilar todos os arquivos que dependem dele. Por exemplo, suponha que você adicione uma macro ou uma declaração a um arquivo de cabeçalho do qual muitos outros arquivos dependem. Para ficar do lado seguro, o make presume que qualquer alteração no arquivo de cabeçalho exige a recompilação de todos os arquivos dependentes; mas você sabe que eles não precisam ser recompilados e prefere não perder tempo esperando a compilação terminar.
Se você prevê o problema antes de alterar o arquivo de cabeçalho, pode usar o sinalizador ‘-t’. Esse sinalizador instrui o make a não executar as receitas das regras e, em vez disso, marcar o alvo como atualizado reescrevendo sua data de última modificação. Siga este procedimento:
make, as alterações nos arquivos de cabeçalho não provocarão nenhuma recompilação.
Se você já alterou o arquivo de cabeçalho num momento em que alguns arquivos realmente precisam de recompilação, é tarde demais para isso. Nesse caso, você pode usar o sinalizador ‘-o file’, que marca o arquivo indicado como “antigo (old)” (consulte Resumo das opções). Isso significa que o próprio arquivo não será refeito e que nada mais será refeito por causa dele. Siga este procedimento:
Um argumento que contém ‘=’ especifica o valor de uma variável: ‘v=x’ define o valor da variável v como x. Se você especifica um valor dessa forma, todas as atribuições comuns da mesma variável no makefile são ignoradas; dizemos que elas foram sobrepostas (overridden) pelo argumento de linha de comando.
A forma mais comum de usar esse recurso é passar sinalizadores adicionais aos compiladores. Por exemplo, num makefile bem escrito, a variável CFLAGS é incluída em cada receita que executa o compilador C, de modo que um arquivo foo.c seria compilado mais ou menos assim:
cc -c $(CFLAGS) foo.c
Assim, qualquer valor que você defina para CFLAGS afeta cada compilação realizada. O makefile provavelmente especifica o valor usual de CFLAGS da seguinte forma:
CFLAGS=-g
Cada vez que executa o make, você pode sobrepor esse valor se quiser. Por exemplo, se você digitar ‘make CFLAGS='-g -O'’, cada compilação C será feita com ‘cc -c -g -O’. (Isso também ilustra como usar as aspas do shell para envolver espaços e outros caracteres especiais no valor de uma variável quando você a sobrepõe.)
A variável CFLAGS é apenas uma das muitas variáveis padrão que existem justamente para que você possa alterá-las dessa maneira. Para uma lista completa, consulte Variáveis usadas por regras implícitas.
Você também pode programar o makefile para consultar variáveis adicionais de sua autoria, dando ao usuário a capacidade de controlar outros aspectos do funcionamento do makefile por meio da alteração das variáveis.
Ao sobrepor uma variável com um argumento de linha de comando, você pode definir tanto uma variável de expansão recursiva quanto uma variável de expansão simples. Os exemplos mostrados acima criam uma variável de expansão recursiva; para criar uma variável de expansão simples, escreva ‘:=’ ou ‘::=’ em vez de ‘=’. Contudo, a menos que você queira incluir uma referência a variável ou uma chamada de função no valor que especifica, não faz diferença qual tipo de variável você cria.
Há uma única maneira de o makefile alterar uma variável que você sobrepôs: usar a diretiva override. Trata-se de uma linha com o seguinte formato: ‘override variable = value’ (consulte A diretiva override).
Normalmente, quando ocorre um erro durante a execução de um comando do shell, o make desiste imediatamente, retornando um status diferente de zero. A partir daí, nenhuma receita é executada para qualquer alvo. O erro implica que a meta não pode ser corretamente refeita, e por isso o make o reporta assim que toma conhecimento.
Quando você está compilando um programa que acabou de alterar, esse não é o comportamento desejado. Em vez disso, você prefere que o make tente compilar todos os arquivos possíveis, para mostrar o maior número possível de erros de compilação.
Nessas ocasiões, você deve usar o sinalizador ‘-k’ ou ‘--keep-going’. Ele instrui o make a continuar considerando os outros pré-requisitos dos alvos pendentes, refazendo-os se necessário, antes de desistir e retornar um status diferente de zero. Por exemplo, depois de um erro ao compilar um arquivo objeto, ‘make -k’ continuará compilando os outros arquivos objeto, mesmo já sabendo que vinculá-los será impossível. Além de continuar após comandos de shell que falham, ‘make -k’ continua o máximo possível depois de descobrir que não sabe como gerar um alvo ou um arquivo de pré-requisito. Isso sempre provoca uma mensagem de erro, mas, sem ‘-k’, seria um erro fatal (consulte Resumo das opções).
O comportamento usual do make pressupõe que seu objetivo é deixar as metas atualizadas; assim, quando o make descobre que isso é impossível, é melhor reportar a falha de imediato. O sinalizador ‘-k’ indica que o verdadeiro objetivo é testar o máximo possível das alterações feitas no programa, talvez para encontrar vários problemas independentes entre si, de modo que você possa corrigi-los todos de uma vez antes da próxima tentativa de compilação. É por isso que o comando M-x compile do Emacs passa o sinalizador ‘-k’ por padrão.
Em algumas situações, o make precisa criar seus próprios arquivos temporários. Esses arquivos não devem ser perturbados enquanto o make estiver em execução (incluindo todas as instâncias do make invocadas recursivamente).
Se a variável de ambiente MAKE_TMPDIR estiver definida, todos os arquivos temporários criados pelo make serão colocados ali.
Se MAKE_TMPDIR não estiver definida, será usado o local padrão de arquivos temporários do sistema operacional atual. Em sistemas POSIX, esse será o local definido na variável de ambiente TMPDIR ou, na falta dela, o local padrão do sistema (por exemplo, /tmp). No Windows, são verificadas primeiro TMP, depois TEMP, em seguida TMPDIR e, por fim, é usado o local padrão de arquivos temporários do sistema.
Observe que esse diretório deve existir previamente; caso contrário, o make falhará. O make não tenta criá-lo.
Essas variáveis não podem ser definidas de dentro de um makefile, pois o GNU make precisa ter acesso a esse local antes de começar a ler os makefiles.
A seguir, uma tabela de todas as opções que o make entende:
Essas opções são ignoradas para compatibilidade com outras versões do make.
Considera todos os alvos desatualizados. O GNU make passa a considerar os alvos e seus pré-requisitos pelos algoritmos normais; no entanto, todos os alvos assim considerados são sempre refeitos, independentemente do estado de seus pré-requisitos. Para evitar recursão infinita, se MAKE_RESTARTS (consulte Outras variáveis especiais) estiver definida com um número maior que 0, esta opção é desativada ao se considerar se os makefiles devem ser refeitos (consulte Como os makefiles são refeitos).
Muda para o diretório dir antes de ler os makefiles. Se várias opções ‘-C’ forem especificadas, cada uma é interpretada em relação à anterior: ‘-C / -C etc’ equivale a ‘-C /etc’. Isso é tipicamente usado em invocações recursivas do make (consulte Uso recursivo do make).
Exibe informações de depuração além do processamento normal. As informações de depuração indicam quais arquivos estão sendo considerados para refazimento, quais horários de arquivo estão sendo comparados e com que resultados, quais arquivos realmente precisam ser refeitos, quais regras implícitas são consideradas e quais são aplicadas — tudo o que há de interessante sobre como o make decide o que fazer. A opção -d equivale a ‘--debug=a’ (veja abaixo).
Exibe informações de depuração além do processamento normal. Vários níveis e tipos de saída podem ser escolhidos. Sem argumentos, exibe o nível “básico (basic)” de depuração. Os argumentos possíveis estão abaixo; apenas o primeiro caractere é considerado, e os valores devem ser separados por vírgula ou espaço.
a (all)Ativa todos os tipos de saída de depuração. Equivale a usar ‘-d’.
b (basic)Depuração básica. Exibe cada alvo que foi considerado desatualizado e se a geração foi bem-sucedida ou não.
v (verbose)Um nível acima de ‘basic’; inclui mensagens sobre quais makefiles foram analisados, pré-requisitos que não precisavam ser reconstruídos, etc. Esta opção também ativa as mensagens de ‘basic’.
i (implicit)Exibe mensagens que descrevem as buscas por regras implícitas para cada alvo. Esta opção também ativa as mensagens de ‘basic’.
j (jobs)Exibe mensagens que dão detalhes sobre a invocação de subcomandos específicos.
m (makefile)Por padrão, as mensagens acima não são ativadas enquanto se tenta refazer os makefiles. Esta opção ativa as mensagens também durante a reconstrução dos makefiles. Observe que a opção ‘all’ ativa esta opção. Esta opção também ativa as mensagens de ‘basic’.
p (print)Exibe a receita a ser executada, mesmo quando ela normalmente é silenciosa (por causa de .SILENT ou ‘@’). Também exibe o nome do makefile e o número da linha onde a receita foi definida.
w (why)Explica por que cada alvo precisa ser refeito, mostrando quais pré-requisitos são mais recentes que o alvo.
n (none)Desativa toda a depuração atualmente ativada. Se sinalizadores de depuração adicionais aparecerem depois disso, eles continuarão a ter efeito.
Dá às variáveis obtidas do ambiente precedência sobre as variáveis dos makefiles. Consulte Variáveis obtidas do ambiente.
Avalia string como sintaxe de makefile. Esta é a versão de linha de comando da função eval (consulte A função eval). A avaliação é realizada depois que as regras e variáveis padrão são definidas, mas antes de qualquer makefile ser lido.
Lê o arquivo chamado file como makefile. Consulte Como escrever makefiles.
Lembra você das opções que o make entende e, em seguida, encerra.
Ignora todos os erros nas receitas executadas para refazer arquivos. Consulte Erros nas receitas.
Especifica um diretório dir para buscar makefiles incluídos. Consulte Incluir outros makefiles. Se várias opções ‘-I’ forem usadas para especificar vários diretórios, eles serão buscados na ordem especificada. Se o diretório dir for um único traço (-), todos os diretórios já especificados até esse ponto (incluindo os caminhos de diretório padrão) serão descartados. Você pode examinar a lista atual de diretórios a serem buscados por meio da variável .INCLUDE_DIRS.
Especifica o número de receitas (tarefas, jobs) a executar simultaneamente. Sem argumento, o make executa o maior número possível de receitas ao mesmo tempo. Se houver mais de uma opção ‘-j’, a última prevalece. Para mais informações sobre como as receitas são executadas, consulte Execução paralela. Observe que esta opção é ignorada no MS-DOS.
Escolhe o estilo de jobserver a usar. Esta opção só tem efeito quando as construções paralelas estão ativadas (consulte Execução paralela). Em sistemas POSIX, style pode ser fifo (o padrão) ou pipe. No Windows, o único style aceito é sem (o padrão). Esta opção é útil quando você precisa usar uma versão mais antiga do GNU make ou outra ferramenta que exija um estilo específico de jobserver.
Continua o máximo possível após um erro. O alvo que falhou, e os alvos que dependem dele, não podem ser refeitos, mas os demais pré-requisitos desses alvos podem ser processados normalmente. Consulte Testar a compilação de um programa.
Especifica que nenhuma nova receita deve ser iniciada se houver outras receitas em execução e a média de carga (load average) for de pelo menos load (um número de ponto flutuante). Sem argumento, remove um limite de carga anterior. Consulte Execução paralela.
Em sistemas que suportam links simbólicos, esta opção faz o make considerar os carimbos de data/hora de quaisquer links simbólicos, além do carimbo do arquivo referenciado por esses links. Quando esta opção é fornecida, o carimbo mais recente entre o arquivo e os links simbólicos é adotado como horário de modificação desse arquivo de alvo.
Exibe a receita que seria executada, mas não a executa (exceto em certas circunstâncias). Consulte Em vez de executar receitas.
Não refaz o arquivo file, mesmo que ele seja mais antigo que seus pré-requisitos, e não refaz nada por causa de alterações em file. Em essência, o arquivo é tratado como muito antigo e suas regras são ignoradas. Consulte Evitar a recompilação de alguns arquivos.
Garante que toda a saída de cada receita seja exibida em uma sequência única e ininterrupta. Esta opção só é útil quando se usa a opção --jobs para executar várias receitas simultaneamente (consulte Execução paralela). Sem esta opção, a saída é exibida à medida que as receitas a geram.
Sem nenhum type ou com o type ‘target’, a saída de toda a receita de cada alvo é agrupada. Com o type ‘line’, a saída de cada linha da receita é agrupada. Com o type ‘recurse’, a saída de todo um make recursivo é agrupada. Com o type ‘none’, nenhuma sincronização de saída é realizada. Consulte Saída durante a execução paralela.
Exibe a base de dados (regras e valores de variáveis) resultante da leitura dos makefiles; em seguida, executa como de costume ou conforme especificado de outra forma. Isso também exibe as informações de versão dadas pela opção ‘-v’ (veja abaixo). Para exibir a base de dados sem tentar refazer nenhum arquivo, use ‘make -qp’. Para exibir a base de dados de regras e variáveis predefinidas, use ‘make -p -f /dev/null’. A saída da base de dados inclui informações de nome de arquivo e número de linha para as definições de receitas e variáveis, portanto pode ser uma ferramenta de depuração útil em ambientes complexos.
“Modo de pergunta (Question mode)”. Não executa nenhuma receita nem exibe nada; apenas retorna um status de saída zero se os alvos especificados já estão atualizados, 1 se alguma refeitura é necessária, ou 2 se um erro é encontrado. Consulte Em vez de executar receitas.
Elimina o uso das regras implícitas embutidas (consulte Como usar regras implícitas). Você ainda pode definir as suas próprias escrevendo regras de padrão (consulte Definir e redefinir regras de padrão). A opção ‘-r’ também limpa a lista padrão de sufixos para regras de sufixo (consulte Regras de sufixo à moda antiga). Mas você ainda pode definir seus próprios sufixos com uma regra para .SUFFIXES e, então, definir suas próprias regras de sufixo. Observe que apenas as regras são afetadas pela opção -r; as variáveis padrão continuam em vigor (consulte Variáveis usadas por regras implícitas); veja também a opção ‘-R’ abaixo.
Elimina o uso das variáveis embutidas específicas de regra (consulte Variáveis usadas por regras implícitas). Você ainda pode, é claro, definir as suas próprias. A opção ‘-R’ também ativa automaticamente a opção ‘-r’ (veja acima), pois não faz sentido ter regras implícitas sem nenhuma definição para as variáveis que elas usam.
Operação silenciosa; não exibe as receitas à medida que são executadas. Consulte Eco das receitas.
Cancela o efeito da opção ‘-k’. Isso quase nunca é necessário, exceto em um make recursivo em que ‘-k’ possa ter sido herdado do make de nível superior por meio de MAKEFLAGS (consulte Uso recursivo do make), ou se você definir ‘-k’ em MAKEFLAGS no seu ambiente.
Esta opção ativa uma forma de teste de robustez (fuzz-testing) das relações de pré-requisitos. Quando o paralelismo está ativado (‘-j’), a ordem em que os alvos são construídos torna-se menos determinística. Se os pré-requisitos não estão totalmente declarados no makefile, isso pode levar a falhas de construção intermitentes e difíceis de rastrear.
A opção ‘--shuffle’ força o make a reordenar deliberadamente as metas e os pré-requisitos, de modo que as relações alvo/pré-requisito continuem válidas, mas a ordem dos pré-requisitos de um dado alvo seja reordenada conforme descrito abaixo.
A ordem em que os pré-requisitos aparecem nas variáveis automáticas não é alterada por esta opção.
O pseudo-alvo .NOTPARALLEL desativa o embaralhamento para aquele makefile. Além disso, qualquer lista de pré-requisitos que contenha .WAIT não é embaralhada. Consulte Desativar a execução paralela.
A opção ‘--shuffle=’ aceita estes valores:
randomEscolhe uma semente (seed) aleatória para o embaralhamento. Este é o padrão se nenhum mode for especificado. A semente escolhida também é repassada aos comandos sub-make. A semente é incluída nas mensagens de erro, para que possa ser reutilizada em execuções futuras a fim de reproduzir o problema ou verificar que ele foi resolvido.
reverseInverte a ordem das metas e dos pré-requisitos, em vez de um embaralhamento aleatório.
seedUsa o embaralhamento ‘random’ inicializado com o valor de semente especificado. seed é um inteiro.
noneDesativa o embaralhamento. Isso anula quaisquer opções ‘--shuffle’ anteriores.
Toca os arquivos (marca-os como atualizados sem realmente alterá-los) em vez de executar suas receitas. Isso é usado para fingir que as receitas foram executadas, a fim de enganar invocações futuras do make. Consulte Em vez de executar receitas.
Mostra informações de rastreamento da execução do make. Usar --trace é uma forma abreviada de --debug=print,why.
Exibe a versão do programa make, além de um aviso de direitos autorais, uma lista de autores e uma nota informando que não há garantia; em seguida, encerra.
Exibe uma mensagem com o diretório de trabalho tanto antes quanto depois de executar o makefile. Isso pode ser útil para rastrear erros em hierarquias complicadas de comandos make recursivos. Consulte Uso recursivo do make. (Na prática, você raramente precisa especificar esta opção, pois ‘make’ o faz por você automaticamente; consulte A opção ‘--print-directory’.)
Desativa a exibição do diretório de trabalho sob -w. Esta opção é útil quando -w é ativado automaticamente, mas você não quer ver as mensagens extras. Consulte A opção ‘--print-directory’.
Finge que o alvo file acabou de ser modificado. Usado com o sinalizador ‘-n’, mostra o que aconteceria se você modificasse esse arquivo. Sem ‘-n’, é quase o mesmo que executar um comando touch no arquivo indicado antes de executar o make, exceto que o horário de modificação só muda na imaginação do make. Consulte Em vez de executar receitas.
Emite uma mensagem de aviso sempre que o make encontra uma referência a uma variável indefinida. Isso pode ser útil quando você está tentando depurar makefiles que usam variáveis de maneiras complexas.