metaconfig - Online na nuvem

PROGRAMA:

NOME

metaconfig - um gerador de script de configuração

SINOPSE

metaconfig [-dhkmostvwGMV ] [-L dir ]

DESCRIÇÃO

Metaconfiguração é um programa que gera scripts de configuração. Se você não sabe o que é
Configurar o script é, pule para o TUTORIAL seção desta página de manual. Se você quiser
uma descrição completa (formal) da maneira de usar metaconfig e suas unidades, por favor, olhe para o
REFERÊNCIA seção. O que se segue é uma introdução rápida e referência para conhecedores
usuários.

Metaconfiguração opera a partir de um conjunto de unidades que define tudo o que o metaconfig sabe sobre
portabilidade. Cada unidade é independente e não precisa ser registrada em nenhum lugar
diferente da inclusão no diretório U público ou no diretório U privado. Se
o pacote dist (do qual metaconfig faz parte) é instalado no LIB, então o U público
diretório é LIB / dist / mcon / U. Nesta máquina, o diretório LIB é / usr / share / dist. Sua
O diretório U privado, se houver, está no diretório de nível superior do seu pacote.
Antes que você possa correr metaconfig você deve fazer várias coisas:

· Crie um arquivo .package no diretório de nível superior do pacote executando empacotar.
Este programa irá perguntar sobre o seu pacote e lembrar o que você diz para que
todos os programas dist podem ser inteligentes.

· Consulte o Glossário (em LIB / dist / mcon) e escreva seus scripts de shell e programas C
em termos dos símbolos que o metaconfig sabe definir. Você não precisa dizer
metaconfig quais símbolos você usou, já que metaconfig descobrirá isso para você.

· Gere quaisquer scripts .SH necessários para escrever Makefiles ou scripts de shell que dependam
nos valores definidos pelo Configure. Existe um programa chamado fazerSH isso vai te ajudar
converter um script simples em um modelo de script.SH; alguma edição ainda precisará ser
executado no arquivo .SH resultante para mover a parte de configuração da variável no
parte superior do script (veja os comentários embutidos gerados por fazerSH dentro do seu .SH
arquivo).

· Crie um arquivo MANIFEST.new em seu diretório de nível superior que lista todos os arquivos em
seu pacote. Este arquivo permanecerá privado e não fará parte do arquivo final
distribuição. (Por conveniência, o arquivo MANIFEST será usado por metaconfig if
não há nenhum arquivo MANIFEST.new ainda.) O nome do arquivo deve ser o primeiro campo em cada
linha. Depois de alguns espaços em branco, você pode adicionar um pequeno comentário descrevendo seu arquivo. Somente
os arquivos de origem devem estar listados lá. O arquivo especial patchlevel.h (qual é
manuseado e mantido pelas ferramentas de patch - consulte pancadinha(1)) deve fazer parte do
MANIFEST.new arquivo, mas pode ser ignorado silenciosamente por algumas ferramentas. Como um princípio básico,
apenas os arquivos mantidos pelo RCS devem ser listados lá, o patchlevel.h arquivo sendo
uma exceção importante.

· Opcionalmente, você pode desejar criar um arquivo MANIFEST, que será uma versão exportada
do seu MANIFEST.new. Esse arquivo deve fazer parte do lançamento, ou seja, listado em ambos
seu MANIFESTO.novo e o próprio MANIFESTO. Um dos metaconfig unidades sabem sobre isso
arquivo e forçará o Configure a realizar uma verificação de liberação, garantindo todos os arquivos
listados lá fazem parte da distribuição. Os arquivos MANIFEST e MANIFEST.new devem
ser distinto, não links.

· Copie quaisquer arquivos .U que você deseja modificar para seu diretório U privado. Qualquer arquivo .U
em seu diretório U privado será usado em preferência ao do U público
diretório. Por exemplo, uma maneira de forçar a inclusão de qualquer unidade é copiar o End.U
arquivo ao seu diretório .U e adicione o nome da unidade que você deseja como uma dependência
o final da linha? MAKE :. Certas unidades SÓ podem ser forçadas desta forma, nomeadamente
aqueles da forma Warn _ *. U e Chk _ *. U. Você também pode personalizar determinados padrões
Configure as variáveis ​​copiando Myinit.U para o diretório U privado do seu pacote e
definir as variáveis ​​nessa unidade.

Agora você está pronto para correr metaconfig. Isso vai criar um configurar arquivo e, opcionalmente, um
config_h.SH arquivo (se suas fontes fizerem uso de símbolos C). Os arquivos gerados irão
será adicionado automaticamente ao MANIFEST.new, se necessário. Não se esqueça de atualizar seu
Arquivo MANIFEST embora.

Para criar novas unidades, faça o seguinte:

· Copie uma unidade semelhante para um novo arquivo .U. O nome que você escolher deve ser o nome de um
variável gerada pela unidade, embora seja apenas uma conveniência para você, não um
requerimento. Deve ter 12 ou menos caracteres para evitar a divisão do nome do arquivo.
Na verdade, provavelmente deve ser 10 ou menos para que aqueles que desejam usar o RCS possam ter
a .U, v no final sem cortar. Metaconfig usa o caso da primeira letra para
determinar se alguma variável é realmente produzida por esta unidade, portanto, não capitalize seu
nome da unidade se ela deve produzir uma variável de shell.

· Edite o novo arquivo .U para fazer o que você quiser. A primeira linha? MAKE: indica o
dependências; antes da lista final, dois pontos todas as variáveis ​​que esta unidade define, e
após os dois pontos finais, todas as variáveis ​​(ou outras unidades) das quais essa unidade depende.
É muito importante que essas listas sejam precisas. Se uma dependência for opcional e um
o valor padrão pode ser usado, você deve prefixar a dependência com um sinal '+'. o
unidade correspondente não será carregada para calcular o símbolo, a menos que seja realmente necessário
por outra unidade.

· Na medida do possível, parametrize sua unidade com base na variável shell definida em
? INIT: linhas. Isso moverá as definições de variáveis ​​até a unidade Init.U, onde
eles podem ser substituídos por definições em Myinit.U, que é incluído após Init.U.

· Adicione a definição de quaisquer símbolos C desejados como? H: linhas. Uma linha começando com
? H:?% <: No arquivo .U será adicionado ao arquivo config.h eventual se e somente se
metaconfig decide que esta unidade é necessária. O% <representa o nome da unidade,
que passa a ser o nome do arquivo também (sem .U) se você seguiu o
convenção. Sempre coloque um comentário em cada linha? H: no caso de uma das variáveis
as substituições anteriores na linha iniciam um comentário sem finalizá-lo. Qualquer concha
variável começando com d_ pode fazer isso, então tome cuidado. Se você omitir?% <:, então
metaconfig tentará intuir o símbolo cuja definição é necessária antes de qualquer
inclusão em config.h.

· Adicionar definições de glossário como? S: linhas para variáveis ​​shell e? C: linhas para C
variáveis ​​de pré-processador. Veja uma unidade atual para exemplos. É MUITO importante
comece cada entrada com um nome de símbolo justificado à esquerda e termine cada entrada com um? C :. ou
? S :. linha. O algoritmo que traduz as entradas de símbolo do pré-processador C para o
O glossário de comentários para config.h depende disso.

· Certifique-se do pedido de todos os seus? linhas está certo. A ordem correta é:

? RCS: e? X: basicamente apenas comentários
? MAKE: dependências metaconfig
? Y: diretiva de layout da unidade
? S: definições de shell do glossário
? C: definições do glossário C
? H: definições de config.h
? M: definições de confmagic.h
? W: símbolos procurados
? V: símbolos visíveis
? F: arquivos criados por esta unidade
? T: símbolos de shell temporários usados
? D: valor padrão das dependências opcionais
? O: usado para marcar unidades obsoletas
? LINT: dicas de metalint
? INIT: inicializações de símbolos de shell

Aqui está um exemplo para mostrar a ordem das linhas e os vários formatos permitidos:

? RCS: $ RCS-Id $
? RCS: Informações de direitos autorais
? RCS: $ RCS-Log $
? X:
? X: Um exemplo inventado
? X:
? FAÇA: d_one two: three + four Five
? FAÇA: - selecione adicionar $ @%
? Y: PADRÃO
? S: d_one:
? S: Primeiro símbolo de shell, define condicionalmente UM.
? S :.
? S: dois:
? S: Segundo símbolo de casca, valor para DOIS.
? S :.
?CONE:
? C: Primeiro símbolo C.
? C :.
? C: DOIS:
? C: Segundo símbolo C.
? C :.
? H: # $ d_one ONE / ** /
? H: #define DOIS "$ dois"
? H: # $ d_one ONE_TWO "$ two"
? H :.
? M: flip: HAS_FLIP
? M: #ifndef HAS_FLIP
? M: # define flip (x) flop (x)
? M: #endif
? M :.
? W:% <: one_two
? V: p_one p_two: p_three
? F: arquivo ./ftest! Tmp
? T: tmp var
? D: dois = 'undef'
? LINT: mudar três
? INIT: two_init = '2'
: código de shell que implementa a unidade segue
p_one = 'um'
p_two = 'dois'
p_three = ""

Deixe-me dizer mais uma vez: a definição de unidade acima é um falsificação um para mostrar apenas o
possibilidades diferentes. Tal unidade serviria a pouco propósito de qualquer maneira ... Um pouco mais
os recursos avançados não são descritos aqui. Por favor, consulte o REFERÊNCIA seção para mais
informação completa.

· Coloque a unidade no diretório U público ou privado, conforme apropriado.

· Executar novamente metaconfig.

· Envie sua unidade para [email protegido] (Raphael Manfredi) para inclusão na cópia master,
se você acha que é de interesse geral.

Para adicionar um novo programa a ser localizado:

· Edite Loc.U, e adicione o nome do programa à linha? MAKE: (entre as
dois dois pontos) e para loclist ou trylist (dependendo se o programa é
obrigatória ou não).

· Execute novamente o metaconfig.

· Envie sua unidade para mim para inclusão na cópia master, se você acha que é geral
interesse.

Notas para gravar arquivos .U:

* Sempre use "rm -f" porque há sistemas em que rm é interativo por padrão.

* Não use "set - ..." porque '-' não funciona com todos os shell. Use "definir x ...;
mudança".

* Não use "unset ENV" uma vez que unset não é totalmente portátil. Diga "ENV = ''" em vez disso.

* Sempre use echo "" (com um espaço) por causa dos sistemas Eunice.

* Use apenas teste com -r, -w, -f ou -d, pois esses são os únicos switches portáteis. No
em particular, evite "test -x".

* Use apenas programas que acompanham o V7, para que você saiba que todos os têm.

* Use $ contains quando quiser fazer um grep condicionalmente, uma vez que nem todos os greps retornam um
status razoável. Certifique-se de redirecionar a saída para / dev / null, usando '> / dev / null
2> & 1 '.

* Use "if test" ao invés de "if" [...] já que nem todo sh conhece a última construção.

* Use o script myread para entradas para que eles possam fazer escapes de shell e padrão
avaliação. A forma geral é

case "$ grimble" em
'') dflt = 452 ;;
*) dflt = "$ grimble" ;;
esac
rp = 'Quantos grimbles você tem?'
. ./minhaleitura
grimble = "$ ans"

* Use o script getfile ao solicitar um nome de caminho de arquivo para ter
~ expansão de nomes e verificações de sanidade. Veja a unidade Getfile.U para uma descrição completa.

* Sempre coloque um

$ startsh

no topo de cada script gerado que será lançado ou originado por
configurar.

* Nunca assuma UNIX-isms comuns como o fato de que um arquivo de objeto termina com um .o e
que o nome de uma biblioteca termina com .a. Use o $ _o e $ _a em vez disso (veja
Unix.U).

* Ao fazer um teste compilar-link-executar, sempre escreva assim:

$ cc $ ccflags $ ldflags try.c -o try $ libs

porque alguns sistemas exigem que os sinalizadores de ligação sejam especificados antes do compilado
destino (com exceção de bibliotecas de vinculação à direita).

* Emita mensagens importantes no descritor de arquivo # 4, usando '> & 4' para redirecionar a saída.
Apenas essas mensagens aparecerão quando o -s interruptor é dado a configurar na
linha de comando (modo silencioso).

* Sempre tente determinar se um recurso está presente da maneira mais específica - não
diga "if bsd" quando puder grep libc. Existem muitos sistemas híbridos por aí, e
cada recurso deve permanecer ou cair por si só.

* Sempre tente determinar se um recurso está presente da maneira mais geral, para que
outros pacotes podem usar sua unidade.

* Em caso de dúvida, defina um padrão e pergunte. Não assuma nada.

* Se você acha que o usuário está errado, considere o fato de que ele pode estar certo. Para
por exemplo, ele pode estar executando o Configure em um sistema diferente do que ele vai usar
o produto final em.

O Metaconfig reserva os seguintes nomes em seu diretório, e se você usar tal nome,
pode ser derrotado ou ter outros efeitos imprevistos:

.MT / *
configurar
Desejado
Obsoleto
configurar
config_h.SH
confmagic.h
VOCÊ/*
MANIFESTO.novo

Além disso, o Configure pode destruir esses nomes no diretório em que é executado:

UU / *
configuração.sh
configuração.h

OPÇÕES

As seguintes opções são reconhecidas por metaconfig:

-d Ative o modo de depuração. Não é realmente útil, a menos que você esteja depurando metaconfig
si.

-h Imprima a mensagem de ajuda e saia.

-k Mantenha o diretório temporário, para que você possa examinar os arquivos de trabalho usados ​​por
metaconfig para construir seu configurar roteiro. Útil apenas ao depurar o
unidades.

-m Assuma muita memória e espaço de troca. Isso irá acelerar a pesquisa de símbolo em
arquivos de origem por um período significativo de tempo, às custas de memória
consumo...

-o Mapeie símbolos obsoletos em novos. Use esta opção se você ainda tiver algum
símbolos obsoletos em seu código-fonte e não querem (ou não podem) remover
eles por agora. Os símbolos obsoletos são ignorados de outra forma, embora isso
vai te dar um aviso de metaconfig.

-s Ative o modo silencioso.

-t Rastreie os símbolos à medida que forem encontrados.

-v Ative o modo detalhado.

-w Suponha que o arquivo procurado está atualizado. Isso irá pular o tempo e a memória
fase consumidora da varredura do código-fonte, à procura de símbolos conhecidos. Use-o
apenas quando você sabe que seu arquivo de origem não mudou em relação ao
Conjunto de metaconfig símbolos usados.

-G Também forneça um GNU configurar-como front-end para o gerado configurar
script, a ser incluído na distribuição também. Este é apenas um invólucro
em volta do configurar script naturalmente, mas permite que as pessoas se familiarizem com o
Ferramenta GNU para não se perder ao enfrentar uma nova distribuição.

-L dir Substitua o local da biblioteca padrão. Normalmente útil apenas para metaconfig
mantenedores para usar localmente as unidades que estão sendo desenvolvidas em vez do
disponíveis publicamente. o dir especificado é aquele que contém as unidades
U diretório.

-M Permitir a produção de um confmagic.h arquivo para remapear automagicamente algum bem-
símbolos conhecidos para alguma outra alternativa, como bcópia() sendo remapeado
transparentemente para memcpy () quando não disponível. Esta opção está ativada
automaticamente quando um confmagic.h arquivo existe no diretório de nível superior.
Simplesmente remova esse arquivo se desejar desativar esta opção permanentemente.

-V Imprime o número da versão e sai.

TUTORIAL

Esta seção (longa) é uma introdução a metaconfig, em que aprenderemos todos os
Fundamentos. Se você já sabe como usar metaconfig, você pode pular com segurança para a próxima
seção.

Visão geral
Normalmente, quando você deseja obter algum pacote fonte para compilar em uma determinada plataforma, você tem
para editar o Makefile principal (assumindo que haja um!), escolha um compilador C, certifique-se de
ter as bibliotecas adequadas e, em seguida, acionar o fazer comando. Se o pacote for razoavelmente
bem escrito, ele irá compilar (sem um aviso sendo uma opção :-). Em si, o último
frase é um desempenho real, uma vez que dada a variedade de plataformas UNIX disponíveis hoje
e a diversidade de sabores, o que significa que o autor do pacote se aprofundou
dificuldade para descobrir as escolhas certas, dado algum teste padrão, adivinhação e bagunça
ao redor com inclusões e tipos de sistema.

No entanto, apesar de todo o seu talento, o autor não pode saber que algum sistema tem um
chamada de sistema interrompida, ou que alguma estrutura do sistema carece de um campo padrão, ou
simplesmente se um determinado arquivo de inclusão existe ou não. E eu não estou considerando o implícito
suposições, como o tipo retornado pelo malloc () função ou a presença do
renomear () chamada de sistema, para citar alguns. Mas esse conhecimento é necessário para alcançar o real
portabilidade.

Agora não vamos abusar de nós mesmos. Usar essa informação requer maiores habilidades, mas pode
levam a programas mais portáveis, uma vez que são escritos de forma independente do sistema
e se baseia apenas no fato de que alguma suposição é verdadeira ou falsa em um sistema particular,
cada suposição não está relacionada entre si. Ou seja, não dizemos: estamos em um
Sistema BSD ou estamos em um sistema USG. Isso é muito confuso hoje em dia. Não, nós queremos
diga ao código-fonte: este sistema não tem o renomear () chamada de sistema e malloc ()
retorna um (vazio *) valor.

Metaconfig é uma ferramenta que permitirá que você faça exatamente isso, com a vantagem adicional de não
ter que editar manualmente o Makefile se tudo correr bem. Correndo metaconfig, você cria um
script de shell chamado configurar. Muitos esforços foram dedicados ao script Configure
internos para garantir que funcionará em 99% dos shells existentes disponíveis a partir deste
escrita. O Configure investigará o sistema de destino, fazendo perguntas em caso de dúvida e
reunir todas as respostas em um único arquivo shell, que por sua vez pode ser usado para
gere automaticamente Makefiles configurados e arquivos de inclusão C.

Existe apenas um conjunto limitado (mas bastante grande) de símbolos disponíveis para seus scripts de shell
e programas C. Eles estão todos documentados no arquivo de glossário. Tudo que você precisa fazer é aprender
sobre eles e comece a usá-los para resolver problemas de portabilidade e configuração. Então,
Correndo metaconfig, um script Configure adequado será gerado para o seu pacote.

O script Configure é construído em várias unidades (mais de 300), cada unidade sendo
responsável por definir um pequeno número de símbolos shell e / ou C. As unidades são montadas
juntos no estágio final, honrando o gráfico de dependência (uma unidade pode precisar do resultado
de várias outras unidades que são colocadas antes no script).

Símbolos
Os símbolos são a coisa mais importante no metaconfig mundo. Eles são os menores
entidade reconhecida, geralmente uma palavra, e pode receber um valor no final do Configure
execução. Por exemplo, o símbolo do pré-processador C HAS_RENAME é um metaconfig símbolo que
tem a garantia de ser definido se, e somente se, o renomear () chamada de sistema está presente. Da mesma forma,
que o $ ranlib a variável do shell será definida como ':' ou 'ranlib' dependendo se o
ligue para o ranlib programa é necessário para solicitar um arquivo de biblioteca. Como isso funciona não é
importante por agora, o que é importante é entender que esses símbolos recebem um vida
(ou seja, um valor) após configurar execução.

Usar símbolos é relativamente simples. Em um arquivo de origem C, você simplesmente usa o símbolo
valor, como uma diretiva de pré-processador (por exemplo, um: #ifdef HAS_RENAME) ou, se o símbolo
valor é uma string, diretamente como você usaria uma macro em C. E em um arquivo de shell ou um
Makefile, você pode fazer referência a um símbolo de shell diretamente.

Na verdade, estou mentindo, porque isso não é tão mágico quanto o parágrafo anterior
poderia soar. Em um arquivo C, você precisa incluir o arquivo produzido pelo Configure configuração.h arquivo, e
você deve embrulhar seu script de shell ou Makefile em um arquivo .SH e você pode referenciar o shell
símbolo apenas na parte de substituição de variável desse arquivo .SH. Mais sobre isso mais tarde.

fonte Arquivos
Os símbolos podem aparecer apenas em um conjunto limitado de arquivos de origem, porque metaconfig Irá apenas
examine-os ao procurar símbolos conhecidos, tentando descobrir quais unidades serão necessárias.
Você pode usar símbolos C em arquivos de origem C, ou seja, arquivos com um .c, .h, .y or .l extensão, e
os símbolos do shell são procurados apenas em arquivos .SH.

Para obter o valor de um símbolo, um arquivo C precisa incluir o especial configuração.h
arquivo, que é produzido por configurar quando os símbolos C estão presentes. E os arquivos .SH são executados
através de um shell, produzindo um novo arquivo. No entanto, na seção superior do arquivo .SH, o
especial configuração.sh arquivo (também produzido executando configurar) é originado e variável
substituições se aplicam. Na realidade, configuração.h é produzido executando o metaconfig-produzido
config_h.SH arquivo, novamente usando a substituição de variável. Então, vamos olhar para que um
um pouco mais de perto, pois este é o coração de todo • Configuração esquema ...

Variável Substituição
Existe uma construção de shell chamada SUA PARTICIPAÇÃO FAZ A DIFERENÇA documento que permite que um comando receba uma entrada
especificado no próprio script. Essa entrada é interpretada pelo shell como um duplo
string entre aspas ou uma string entre aspas simples dependendo da forma do documento aqui
especificação.

Para especificar um documento here, o token '<<' é usado, seguido por um único identificador. A partir de
em seguida, as linhas de script restantes formam a entrada para o comando, até o aqui
documento é encontrado em uma linha por si só. Substituição de shell (incluindo variável de shell
substituições) é feito, a menos que o identificador esteja entre aspas simples. Por exemplo:

var = 'primeiro'
tar = 'segundo'
echo "-> primeiro aqui documento:"
gato <
var = '$ var'
tar = '$ tar'
MOE
echo "-> segundo aqui documento:"
gato << 'EOM'
echo $ var
echo $ tar
MOE
echo "-> fim."

irá produzir, quando executado através de um shell:

-> primeiro documento aqui:
var = 'primeiro'
tar = 'segundo'
-> segundo aqui documento:
echo $ var
echo $ tar
-> fim.

O primeiro documento aqui tem seu conteúdo interpretado, enquanto o segundo é produzido no estado em que se encontra.
Ambos são úteis em um script .SH, como veremos.

utilização .SH Scripts
Um script .SH geralmente é produzido executando o FaçaSH script outro arquivo existente,
transformando lima em uma arquivo.SH. Vamos dar um único exemplo. Aqui está um pequeno script
(vamos chamá-lo tamanho grande) que imprime uma única mensagem, o tamanho do int tipo de dados em C.
Infelizmente, ele tem o valor embutido nele, desta forma:

#!/ Bin / sh
intsize = '4'
echo "Nesta máquina, o tipo int é $ intsize bytes"

Vamos correr fazerSH nele digitando 'fazerSH tamanho grande'. Nós temos um único intsize.SH arquivar isso
se parece com isso:

case $ CONFIG em
'')
if test -f config.sh; então TOP = .;
elif test -f ../config.sh; então TOP = ..;
elif test -f ../../config.sh; então TOP = ../ ..;
elif test -f ../../../config.sh; então TOP = ../../ ..;
elif test -f ../../../../config.sh; então TOP = ../../../ ..;
outro
echo "Não foi possível encontrar config.sh."; saída 1
fi
. $ TOP / config.sh
;;
esac
: Isso força os arquivos SH a criarem o destino no mesmo diretório do arquivo SH.
: Isso é feito para que o make depend sempre saiba onde encontrar os derivados SH.
caso "$ 0" em
* / *) cd `expr X $ 0: 'X \ (. * \) /'` ;;
esac
echo "Extraindo intsize (com substituições de variáveis)"
: Esta seção do arquivo terá substituições de variáveis ​​feitas nela.
: Mova tudo o que precisa de subs de configuração de! NO! SUBS! seção para! GROK! THIS !.
: Proteja quaisquer cifrões e crases que você não deseja interpretar
: colocando uma barra invertida na frente. Você pode deletar esses comentários.
$ spitshell> intsize <
$ startsh
! GROK! ISSO!

: Nos seguintes dólares e crostas não precisa da barra invertida extra.
$ spitshell >> intsize << '! NÃO! SUBS!'
intsize = '4'
echo "Nesta máquina, o tipo int é $ intsize bytes"
! NÃO! SUBS!
chmod 755 tamanho
$ eunicefix intsize

A primeira parte deste script (no casas declaração) está tentando localizar o configuração.sh
arquivo, a fim de obtê-lo. o $ CONFIG variável é falsa por padrão, por verdadeiro quando
configuração.sh já foi fornecido (o que seria o caso se este arquivo fosse executado a partir de
dentro configurar em si, mas não vamos confundir a questão aqui).

Uma vez que o configuração.sh arquivo tem sido fontes, todos os símbolos de shell definidos por configurar e guarante que os mesmos estão
definir. Sabemos chegar a uma segunda declaração de caso, usada para alterar o diretório atual caso um
caminho ser usado para chegar a este programa (por exemplo, se dissermos 'sh ../scripts/intsize.SH', nós
iria primeiro correr 'cd ../scripts'antes de continuar). Se você não entende isso, não
preocupado com isso.

Aí vem o material interessante. Este script usa o $ spitshell variável, e não é
algo que sabemos ... ainda. Se você olhar o arquivo de glossário, verá que
esta é uma variável conhecida por metaconfig. Se você tornar este arquivo parte de sua distribuição
(incluindo-o no arquivo MANIFEST.new, voltaremos a isso mais tarde) e execute
metaconfig, Em seguida, o configurar o script irá determinar um valor adequado para esta variável
e será definido em configuração.sh. O mesmo vale para $ startsh e o misterioso $ eunicefix at
o fim. Em um sistema razoável, a parte relevante de configuração.sh ficaria assim:

spitshell = 'gato'
startsh = '#!/ Bin / sh'
eunicefix = ':'

Ah! Estamos chegando lá. Agora parece familiar. Estamos enfrentando um único gato comando de quem
entrada vem de um documento aqui interpolado variável e cuja saída é redirecionada para
tamanho grande. O valor será o de $ startsh, ou seja, '#!/ Bin / sh'. Tudo bem até agora.

Em seguida, chegamos à segunda expansão do documento aqui, para obter o restante do script. Esse
vez, o símbolo do documento aqui é cercado por aspas simples para que o conteúdo seja
anexado literalmente ao tamanho grande Arquivo. Então, executando 'sh intsize.SH', nós temos o
seguinte saída:

Extraindo intsize (com substituições de variáveis)

e olhando para o arquivo intsize produzido, vemos:

#!/ Bin / sh
intsize = '4'
echo "Nesta máquina, o tipo int é $ intsize bytes"

que é exatamente o que tínhamos no início. Até agora, é um procedimento sem operação ...
Mas, que maravilha! Acontece (pura coincidência, acredite!), Que metaconfig sabe
sobre as $ intsize símbolo da concha. Ao mover a inicialização de intsize para a variável-
área interpolada do script .SH e inicializando-o com o configurar- valor calculado,
e removendo os comentários agora inúteis adicionados por fazerSH, Nós temos:

case $ CONFIG em
'')
if test -f config.sh; então TOP = .;
elif test -f ../config.sh; então TOP = ..;
elif test -f ../../config.sh; então TOP = ../ ..;
elif test -f ../../../config.sh; então TOP = ../../ ..;
elif test -f ../../../../config.sh; então TOP = ../../../ ..;
outro
echo "Não foi possível encontrar config.sh."; saída 1
fi
. $ TOP / config.sh
;;
esac
caso "$ 0" em
* / *) cd `expr X $ 0: 'X \ (. * \) /'` ;;
esac
echo "Extraindo intsize (com substituições de variáveis)"
$ spitshell> intsize <
$ startsh
intsize = '$ intsize'
! GROK! ISSO!

$ spitshell >> intsize << '! NÃO! SUBS!'
echo "Nesta máquina, o tipo int é $ intsize bytes"
! NÃO! SUBS!
chmod 755 tamanho
$ eunicefix intsize

Obviamente, a execução desse script por meio de um shell produzirá novamente o mesmo script. Mas se
Nós corremos configurar em uma máquina onde um int é armazenado como uma quantidade de 64 bits, configuração.sh precisarão
conjunto tamanho grande para 8 e o tamanho grande o script terá o valor correto e imprimirá:

Nesta máquina, o tipo int é de 8 bytes

qual é correto. Parabéns! Acabamos de configurar um script de shell !!

Produtor configuração.h
Agora podemos dar uma olhada no caminho configuração.h é produzido fora de config_h.SH. Nós sabemos isso
corrida configurar produz um configuração.sh script (como exatamente isso é feito não é estritamente
relevante aqui, mas para os curiosos, é outra substituição de documento aqui dentro
configurar em si). o config_h.SH em si é construído por metaconfig ao mesmo tempo
configurar é, desde que você faça uso de pelo menos um símbolo C em suas fontes.

Vamos dar uma olhada em alguns config_h.SH arquivo para ver o que realmente acontece:

case $ CONFIG em
'')
if test -f config.sh; então TOP = .;
elif test -f ../config.sh; então TOP = ..;
elif test -f ../../config.sh; então TOP = ../ ..;
elif test -f ../../../config.sh; então TOP = ../../ ..;
elif test -f ../../../../config.sh; então TOP = ../../../ ..;
outro
echo "Não foi possível encontrar config.sh."; saída 1
fi
. $ TOP / config.sh
;;
esac
caso "$ 0" em
* / *) cd `expr X $ 0: 'X \ (. * \) /'` ;;
esac
echo "Extraindo config.h (com substituições de variáveis)"
sed < config.h -e 's! ^ # undef! / define!' -e 's! ^ # un-def! #undef!'
/*
* Este arquivo foi produzido executando o script config_h.SH, que
* obtém seus valores de config.sh, que geralmente é produzido por
* executando Configure.
*
* Sinta-se à vontade para modificar tudo isso conforme a necessidade. Observe, no entanto,
* se o config.h.SH for executado novamente, todas as alterações feitas serão apagadas.
* Para uma mudança mais permanente, edite config.sh e execute novamente config.h.SH.
*/

/ * Tempo de configuração: $ cf_time
* Configurado por: $ cf_by
* Sistema de destino: $ myuname
*/

#ifndef _config_h_
#define _config_h_

/ * bcopy:
* Este símbolo é mapeado para memcpy se a rotina bcopy () não for
* disponível para copiar strings.
*/
/ * HAS_BCOPY:
* Este símbolo é definido se a rotina bcopy () estiver disponível para
* copiar blocos de memória. Você não deve usar este símbolo sob
* circunstâncias normais e use bcopy () diretamente em vez disso, o que
* será mapeado para memcpy () se bcopy não estiver disponível.
*/
# $ d_bcopy HAS_BCOPY / ** /
#ifndef HAS_BCOPY
#ifdef bcopy
# un-def bcopy
#fim se
#define bcopy (s, d, l) memcpy ((d), (s), (l)) / * mapeado para memcpy * /
#fim se

/ * HAS_DUP2:
* Este símbolo, se definido, indica que a rotina dup2 é
* disponível para duplicar descritores de arquivo.
*/
# $ d_dup2 HAS_DUP2 / ** /

/ * I_STRING:
* Este símbolo, se definido, indica ao programa C que deve
* incluir (Sistemas USG) em vez de (Sistemas BSD).
*/
# $ i_string I_STRING / ** /

#fim se
! GROK! ISSO!

Na parte superior do arquivo, reconhecemos a construção padrão .SH que já temos
estudado em detalhes. Em seguida, vem a extração do próprio arquivo, por meio de um documento here com
substituições de variáveis. No entanto, aqui não usamos um plano gato mas um sede em vez disso, desde
precisamos fazer mais algumas edições em tempo real. Veremos porque mais tarde, então vamos esquecer
sobre isso agora.

Agora chegamos ao comentário principal, e o arquivo está marcado com o tempo de configuração, o
sistema de destino, etc ... (essas variáveis ​​provenientes do fornecedor configuração.sh arquivo foi
criado por configurar) Esse cabeçalho de comentário é seguido por uma proteção '#ifndef' para proteger
contra múltiplas inclusões deste arquivo. Então vem o coração do arquivo ...

Isso ajuda a saber que $ d_ * e $ i_ * as variáveis ​​são definidas como 'definir'ou'indefeso' de
configurar, dependendo se uma função ou um arquivo de inclusão está presente no sistema ou
não. Isso significa que:

# $ d_bcopy HAS_BCOPY / ** /

a linha será expandida para:

#define HAS_BCOPY / ** /

se a variável $ d_bcopy estiver configurada para 'definir' ou:

#undef HAS_BCOPY / ** /

if $ d_bcopy foi definido como 'undef', porque o recurso não estava lá. No entanto, isso não é
o que é escrito no configuração.h arquivo por causa do sede filtro que já vimos,
que irá transformar a segunda forma em:

/ * # define HAS_BCOPY / ** /

Esse é um formulário útil para a edição posterior de configuração.h porque você só precisa remover o
inicial '/ *' se você deseja substituir configurarescolha de. Da mesma forma, você pode adicionar um único
'/ *' no início de uma linha '#define' para evitar a definição de um símbolo específico.
É por isso que cada definição de símbolo é protegida por um final '/ ** /', para fechar o principal
comentário aberto por '/ *' (comentários não são aninhados em C).

Agora transformar '#undef' em '/ * # define' é bom, mas se quisermos realmente escrever um
'#undef', estamos presos ... a menos que escrevamos como '# un-def' e deixemos sede consertar para '#undef'
enquanto produzindo configuração.h, que é o que realmente é feito aqui.

O mesmo tipo de raciocínio se aplica a essas duas linhas:

# $ d_dup2 HAS_DUP2 / ** /
# $ i_string I_STRING / ** /

e assumindo configuração.sh define:

d_dup2 = 'definir'
i_string = 'undef'

vamos entrar no produzido configuração.h:

#define HAS_DUP2 / ** /
/ * # define I_STRING / ** /

Claro como água corrente? Boa!

Agora deve ser óbvio que, incluindo configuração.h em todos os seus arquivos de origem C, você começa a
sabe o que configurar adivinhou em seu sistema. Na verdade, ao usar esses símbolos, você está
escrever código C configurado, uma vez que metaconfig saberá que você precisa desses símbolos e
gerar um adequado config_h.SH arquivo, bem como todo o código necessário em configurar para
calcule um valor adequado para eles (atribuindo valores às variáveis ​​de shell associadas).

Corrida Metaconfiguração
Vamos nos concentrar no metaconfig programa por um tempo para entender como ele usa suas unidades e
seu código-fonte para produzir todos os arquivos de configuração necessários. Se você pretende escrever um novo
unidades, você deve ter um bom entendimento de todo o esquema.

Se não houver nenhum arquivo MANIFEST.new, metaconfig tentará usar o arquivo MANIFEST em vez disso,
Por conveniência. Onde quer que mencionemos MANIFEST.new, pode ser entendido como MANIFEST
desde que não haja nenhum arquivo MANIFEST.new encontrado na raiz do seu pacote.

Assumindo que seu arquivo MANIFEST.new está configurado corretamente e lista todos os arquivos de origem que você deseja
configurar, e que você executou embalar em seu diretório de origem para criar um
.pacote arquivo, você pode executar metaconfig e você obterá o seguinte:

$ metaconfig
Localizando unidades ...
Extraindo listas de dependências de 312 unidades ...
Extraindo nomes de arquivos (*. [Chyl] e * .SH) de MANIFEST.new ...
Construindo um arquivo procurado ...
Verificando arquivos. [Chyl] em busca de símbolos ...
Verificando arquivos .SH em busca de símbolos ...
Calculando o gráfico de dependência ideal ...
Construindo arquivo privado de criação ...
Determinando unidades carregáveis ​​...
Atualizando make file ...
Determinando a ordem correta das unidades ...
Criando Configure ...
Feito.

A primeira fase procura todos os arquivos de unidades (terminando com .U) no diretório público
primeiro, depois no seu privado. Se você copiar um arquivo público em seu diretório U privado
(ou seja, um diretório chamado U no nível superior do seu pacote), ele substituirá o público
versão. Uma vez que tem uma lista de todas as unidades disponíveis, ele as analisa e extrai todas
as linhas? MAKE: para saber sobre as dependências e os símbolos de shell conhecidos. Isso também
concentra-se nas linhas? H: para aprender sobre os símbolos C e quais símbolos de shell devem ser
calculado para obter um valor adequado para esse símbolo C (então temos outro nível de dependências
aqui).

Em seguida, os nomes de arquivo adequados são extraídos dos arquivos MANIFEST.new e um Desejado arquivo é
construído: esse arquivo lista todos os símbolos C e os símbolos shell necessários para aquele pacote. Nós
primeiro examine os arquivos do tipo C em busca de símbolos C e, em seguida, propague as dependências para seus
símbolos de shell associados (obtidos de? H: linhas). Em seguida, os arquivos .SH são verificados e, finalmente,
todos os símbolos de shell são conhecidos.

Um Makefile temporário é construído e o metaconfig tenta fazer todos os símbolos de concha para ver
quais comandos (listados no segundo? MAKE: linhas) são executados e, portanto, quais unidades são
realmente necessário. As unidades opcionais não exigidas de outra forma são removidas e um segundo Makefile é
gerado. Desta vez, conhecemos todas as unidades e seus respectivos pedidos, opcional
unidades foram removidas e os valores padrão calculados para seus símbolos de shell. o
configurar script pode então ser gerado, junto com config_h.SH. Foram realizadas.

Convenções
As convenções adequadas precisam ser seguidas para fazer com que todo o processo soe. Há um caso
convenção para unidades e uma convenção de nomenclatura de variável.

Todas as unidades devem ter sua primeira letra em caixa baixa, a menos que sejam unidades especiais. Por
especial, queremos dizer que eles realmente não definem novas variáveis ​​de shell que podem ser usadas pelo
usuário em seus arquivos .SH, mas sim unidades que produzem scripts ou variáveis ​​de shell que devem
ser usado internamente pelo configurar roteiro. Exemplos típicos são os Init.U arquivo que é
a inicialização da variável principal, ou Minha leitura.U que produz o minha leitura script usado quase
em todos os lugares em configurar quando uma pergunta deve ser feita ao usuário.

As unidades não especiais subdividem-se em dois grupos distintos: unidades que definem variáveis
associado a um símbolo C e unidades que definem variáveis ​​de shell próprias. O primeiro grupo
é ainda dividido em variáveis ​​relacionadas aos arquivos de inclusão (seus nomes começam com i_) e
variáveis ​​relacionadas a outras definições (nome começando com d_) O segundo grupo tem
nomes representando a si mesmos, por exemplo cc.U define o $ cc variável shell cujo valor é
o compilador C a ser usado.

As unidades especiais às vezes reservam-se algumas variáveis ​​predefinidas e retornam "resultados"
em outras variáveis ​​conhecidas. Por exemplo, o minha leitura script produzido por Myread.U
espera o prompt em $ rp, a resposta padrão em $ dflt e coloca a resposta do usuário em $ ans.
Isso não está documentado nesta página de manual: você tem que ir e olhar para a própria unidade para
entenda quais variáveis ​​são usadas e como a unidade deve ser usada.

utilização A Glossário
O arquivo de glossário é produzido automaticamente pelo fazer brilho script, que extrai o
informações de? S :,? C: e? MAKE: linhas e reformata-as em ordem alfabética
glossário classificado. É importante ler o Glossário para saber sobre os símbolos que você é
permitido usar. No entanto, o Glossário não dirá como usá-los. Normalmente, isso é
você decide.

Um dia, você provavelmente escreverá suas próprias unidades e saberá o suficiente sobre metaconfig
para fazer isso de forma rápida e eficiente. No entanto, nunca se esqueça de documentar adequadamente seu trabalho em
as linhas? S: e? C: ou outras pessoas não poderão reutilizá-lo. Lembre-se sobre o
vez em que você tinha apenas o Glossário e esta página de manual para começar.

Conclusão
Agora que você conhece o metaconfig noções básicas, você deve ler o DESCRIÇÃO seção, então
pule para o REFERÊNCIA seção para aprender sobre todos os detalhes sangrentos, como o permitido
sintaxe para linhas de controle de unidade (linhas começando com '?') ou os comandos MAKE distintos
você tem permissão para usar.

REFERÊNCIA

Esta seção documenta os aspectos internos de metaconfig, basicamente a sintaxe da unidade, o especial
unidades que você deve conhecer e os arquivos de dicas.

Geral Unidade Sintaxe
Uma unidade metaconfig é dividida em duas partes distintas. A seção do cabeçalho (linhas começando
com '?') e uma seção de shell (código a ser incluído no configurar roteiro). Isto é
possível adicionar comentários '? X:' em qualquer lugar dentro da unidade, mas o outro '?' linhas (também
chamado ao controle linhas) têm uma política de pedidos rígida.

Se uma linha de controle for muito longa, é possível usar uma continuação escapando do final
nova linha com uma barra invertida e continuando na próxima linha (que deve então ser indentada
por espaços ou tabulações).

A seguir está uma descrição formal de cada uma das linhas de controle. Salvo indicação
caso contrário, a ordem desta apresentação é a ordem a ser usada dentro da unidade.

? RCS: sem texto
Para ser usado para comentários RCS, na parte superior da unidade.

? X: qualquer texto
Comentários de uso geral. Pode aparecer em qualquer parte da unidade, mas deve ser deixado justificado.
Para comentários RCS, por favor use o? RCS: formulário de comentários.

?FAÇO:símbolo Lista: dependência Lista [+ opcional]
Esta é a primeira linha de dependência. O primeiro símbolo Lista deve listar todos os símbolos
construída por esta unidade (ou seja, cujo valor é calculado pela seção da casca da unidade).
Os símbolos devem ser separados por espaço. Se um símbolo definido for apenas para uso interno e
não deve aparecer no gerado configuração.sh arquivo, então deve ser precedido por um
'+' (não deve ser confundido com dependências opcionais definidas a seguir). O segundo
parte da lista (após o meio ':') é a dependência da unidade. Deve listar todos
as unidades especiais necessárias, bem como todos os símbolos usados ​​pelo shell
implementação. Se um símbolo é incorporado, mas seu valor de configuração não é crítico, ele
pode ser precedido por um '+', caso em que é chamado de dependência condicional: seu
unidade correspondente será carregada se, e somente se, esse símbolo for realmente diferente
procurado; caso contrário, o valor padrão será usado.

?FAÇO:aba comando
Pode haver uma ou mais linhas de comando após as linhas de dependência iniciais. Aqueles
os comandos serão executados quando a unidade for desejada para carregá-los no configurar. Ver
o parágrafo sobre comandos make para mais informações. Observe que o principal aba
personagem é necessário antes de comando.

? Y:traçado
Declare uma diretiva de layout para esta unidade. Essa diretiva pode ser uma das strings
topo, omissão or fundo (maiúsculas e minúsculas não importa, o estilo recomendado é explicá-las por extenso
maiúsculas). Se omitido, omissão é assumido.

Esta diretiva é necessária apenas se você deseja forçar uma unidade na parte superior ou inferior
do gerado configurar script, conforme as dependências da unidade o permitirem. Importante
perguntas podem, portanto, ser forçadas no início. Dentro da mesma classe de layout, unidades
são classificados em ordem alfabética com dois casos especiais para unidades d_ * e i_ *, forçados
respectivamente na parte superior e inferior de suas classes (mas estas devem pertencer ao
classe padrão).

Se você forçar no topo uma unidade cujas dependências exigem que todas as outras unidades
precedê-lo, você não alcançará nada de interessante. Portanto, essa diretiva deve realmente
ser usado para aumentar a prioridade de algumas unidades interativas que não dependem de muitos
outros símbolos visíveis ao usuário, como perguntas relacionadas ao caminho.

? S:nome_símbolo [(obsoleto símbolo Lista)]:
Apresenta um símbolo de concha. Esta primeira linha nomeia o símbolo, opcionalmente seguido por um
lista entre parênteses e dando o equivalente obsoleto. Aqueles obsoletos
os símbolos serão remapeados para o novo nome_símbolo se o -o opção é dada a
metaconfig.

? S:qualquer texto, para Glossário
Basicamente, um comentário que descreve o símbolo do shell, que será extraído por fazer brilho
no arquivo de glossário.

? S :. Fecha o comentário do símbolo do shell.

? C:nome_símbolo [~ aliás] [(obsoleto símbolo Lista)]:
Apresenta um novo símbolo C. o aliás nome é o nome sob o qual o símbolo C irá
ser controlado, ou seja, se o aliás o símbolo é desejado, então esse símbolo C será escrito
no config_h.SH Arquivo. Normalmente, o alias é apenas '% <' (representa o nome da unidade)
e também há uma linha? W: mapeando um símbolo C para o aliás. Também as partes relevantes
das linhas? H: são explicitamente protegidas por uma condição '?% <'. Veja o símbolo
aliasing parágrafo para mais detalhes. O restante da linha é o opcional
obsoleto símbolo Lista, que lista os antigos equivalentes para os novos nome_símbolo.

? C:qualquer texto, para Glossário e config_h.SH
Basicamente, um comentário que descreve o símbolo C, que será extraído por fazer brilho
no arquivo de glossário e por metaconfig no config_h.SH arquivo se o símbolo for
queria (ou se seu apelido é desejado quando o apelido de símbolo é usado).

? C :. Fecha o comentário do símbolo C.

? H :?símbolo:config_h.SH coisas
Este é o pedido de inclusão geral em config_h.SH. A linha só é escrita quando
a guarda símbolo é realmente desejado. Esta forma geral é necessária quando o símbolo C
aliasing foi usado. Caso contrário, se você usar um dos outros formulários "padrão", o
a proteção é feita automaticamente por metaconfig si.

? H: #$ d_var VAR "$ var"
Define condicionalmente o VAR Símbolo C em $ var quando é definido como 'definir'. Implica um
'?VAR: 'condição de proteção, e metaconfig links automaticamente VAR para suas duas conchas
dependências de variáveis ​​(ou seja, ambos $ d_var e $ var será sinalizado como querido if VAR is
usado em fontes C).

? H: #define VAR [opcional texto]
Sempre define o VAR Símbolo C para algum valor. Implica um '?VAR: 'condição de proteção.
Uma dependência de shell automática é feita para a própria unidade.

? H: #define VAR (x, y, z) $ var
Sempre define a macro VAR ser o valor do $ var variável. Depende do
unidade para garantir $ var tem um valor sensato. Uma dependência automática entre o C
macro VAR e a variável shell é estabelecida, e toda a linha é protegida por um
implícito '?VAR: '.

? H: #$ d_var VAR
Define condicionalmente VAR if $ d_var está configurado para 'definir'. Implica um '?VAR: 'guardando
doença. Uma dependência de shell automática é gerada para $ d_war.

? H: #define VAR "$ var"
Atribui um valor configurado para o VAR Símbolo C. Implica um '?VAR: 'condição gurading.
Uma dependência de shell automática é gerada para vincular VAR e $ var.

? H :. Fecha o config_h.SH pedidos de inclusão.

? M:C símbolo: C dependências
Apresenta a definição mágica sobre o símbolo C, para confmagic.h, e define o
símbolo de proteção para o restante? M: definições. Esta linha silenciosamente implica
'? W:% <:C símbolo', ou seja, a unidade será carregada no Configure se o símbolo C aparecer
dentro das fontes C, seja a magia usada ou não. As dependências C são ativadas
quando a magia é usada, a fim de forçar sua definição em config_h.SH. No entanto, se
magia é não usado, mas o símbolo C aparece na fonte sem o C necessário
dependências, você será avisado toda vez que o arquivo Wanted for compilado, uma vez que pode ser
um problema de portabilidade (e também porque a unidade é incondicionalmente carregada em
Configure sempre que o símbolo C for usado, independentemente das outras linhas? C: do
unidade).

? M:cpp defesas
Define o mapeamento cpp mágico a ser introduzido em confmagic.h sempre que o interessado
símbolo é usado. Existe um implícito '?sym'guardando onde sym é o nome do símbolo
definido pela linha principal? M :.

? M :. Fecha o confmagic.h pedido de inclusão.

?C:concha símbolo Lista:C símbolo Lista
Vincula o destino dos símbolos de concha com o dos símbolos C: se algum dos C
os símbolos listados são desejados, então todos os símbolos de shell são marcados como desejados. Útil para
forçar a inclusão de uma unidade (lista de símbolos de shell definida como '% <') quando a presença de algum C
símbolo é detectado. A lista de símbolos de shell pode ser deixada vazia, para se beneficiar do lado
efeito da localização do símbolo C dentro do pré-processador embutido (símbolo sendo definido
para esse pré-processador, se localizado na fonte). Para procurar padrões com um espaço
neles, você precisa citar os símbolos C entre aspas simples, como em 'struct
fuso horário'.

? V:somente leitura símbolos:leitura e gravação símbolos
Isto é um metalint dica e deve ser usado apenas em unidades especiais exportando algum shell
variáveis. As variáveis ​​antes do meio ':' são exportadas somente leitura (alterando-as
irá emitir um aviso), enquanto outros símbolos podem ser lidos e alterados livremente.

? F:arquivos criado
Esta linha tem dois propósitos: é um metalint dica, e também um espaço reservado para
futuro jmake usar. Deve listar três tipos de arquivos: o temporário que é
criados para um teste, os UU privados criados no diretório UU para posterior
leitura e os públicos deixados no diretório raiz do pacote. Temporário
os arquivos devem ser listados com um '!' caractere (significando "não! eles não são reutilizados
mais tarde! "), os arquivos UU privados devem ser precedidos por um './' (significando: para usá-los, digamos
./Arquivo, Não apenas lima), e os públicos devem ser nomeados no estado em que se encontram.

? T:concha temporários
Outro metalint dica. Esta linha lista todas as variáveis ​​de shell usadas como temporárias
dentro da seção shell desta unidade.

? D:símbolo='valor'
Valor de inicialização para símbolos usados ​​como dependências condicionais. Se não? D: linha é
encontrado, então um valor nulo é usado. o metalint programa irá avisá-lo se um
símbolo é usado pelo menos uma vez como uma dependência condicional e não tem uma
? D: inicialização. É uma boa prática adicionar essas linhas mesmo para um nulo
inicialização, uma vez que enfatiza a natureza possivelmente opcional de um símbolo.

? O:qualquer mensagem Você queremos
Esta diretiva indica que esta unidade está obsoleta como um todo. Sempre que o uso de qualquer
de seus símbolos é feito (ou uso indireto por meio de dependências), a mensagem é emitida em
a tela (no stderr). Você pode colocar uma ou mais linhas, caso em que cada linha irá
ser impresso, em ordem.

? LINT:metalint dicas
veja a metalint página do manual para uma explicação das dicas distintas que podem ser
usava.

?INICIAR:inicialização código
O código de inicialização especificado por esta linha será carregado na parte superior do
configurar script, desde que a unidade seja necessária.

C Símbolo Aliasing
Às vezes não é possível contar com metaconfigprópria seleção padrão para config_h.SH
comentários e definição do símbolo C. É aí que o aliasing entra em jogo. Uma vez que é bastante
difícil de explicar, estudaremos um exemplo para entender o mecanismo subjacente.

A unidade d_const.U tenta determinar se o seu compilador C sabe ou não sobre o const
palavra-chave. Caso contrário, queremos remapear essa palavra-chave para uma string nula, a fim de permitir que o
compilar o programa. Além disso, queremos acionar automaticamente o teste quando o const palavra
é usado.

Aqui estão as partes relevantes da unidade d_const.U:

? MAKE: d_const: cat ccflags Setvar
? FAÇA: - selecione adicionar $ @%
? S: d_const:
? S: Esta variável define condicionalmente o símbolo HASCONST, que
? S: indica ao programa C que este compilador C sabe sobre o
? S: tipo const.
? S :.
? C: HASCONST ~% <:
? C: Este símbolo, se definido, indica que este compilador C conhece
? C: o tipo const. Não há necessidade de realmente testar esse símbolo
? C: em seus programas. O mero uso da palavra-chave "const" irá
? C: aciona os testes necessários.
? C :.
? H:?% <: # $ D_const HASCONST / ** /
? H:?% <: # Ifndef HASCONST
? H:?% <: # Define const
? H:?% <: # Endif
? H :.
? W:% <: const
? LINT: definir d_const
? LINT: const conhecido
: verificar a palavra-chave const
echo ""
echo 'Verificando se o seu compilador C conhece "const" ...'> & 4
/ bin / cat > const.c << 'EOCP'
a Principal()
{
const char * foo;
}
EOCP
if $ cc -c $ ccflags const.c> / dev / null 2> & 1; então
val = "$ define"
echo "Sim, é verdade."
outro
val = "$ undef"
echo "Não, não faz."
fi
definir d_const
eval $ setvar

Primeiro, notamos o uso de uma linha? W :, que basicamente diz: "Esta unidade é desejada quando o
const palavra-chave é usada em um arquivo C. ". Para remapear condicionalmente const para um nulo
corda em configuração.h, Eu escolhi definir condicionalmente HASCONST via $ d_const.

No entanto, isso levanta um problema, porque o HASCONST símbolo não vai ser usado no
fontes, apenas o const token é. E a linha? H: definindo HASCONST é implicitamente
guardado por '? HASCONST'. Portanto, devemos adicionar a restrição explícita '?% <' Para dizer
metaconfig que essas linhas devem ser incluídas em config_h.SH sempre que o símbolo '% <'
é desejado (% <refere-se ao nome da unidade, aqui d_const).

Isso é quase perfeito, porque a linha? W: vai querer d_const sempre que const é usado, então
as linhas? H: serão incluídas no config_h.SH Arquivo. No entanto, o comentário principal (? C:
linhas) anexadas a HASCONST também é protegido por meio de HASCONST, ou seja, tem um implícito
Restrição '? HASCONST'. Daí a necessidade de aliasing que o HASCONST símbolo para '% <'.

A parte restante da unidade (a parte da casca) é realmente simples. É simplesmente
tenta compilar um programa C de amostra usando o const palavra-chave. Se puder, então
definir $ d_const via $ setvar fonction (definido pelo Setvar.U unidade). Veja o parágrafo
sobre unidades especiais para mais detalhes.

Realizar comandos
Na linha de comando? MAKE :, você pode escrever um comando shell para ser executado no estado em que se encontra ou
especial -escolher comando que é preso por metaconfig e analisado para ver o que deveria ser
feito. O principal '-' existe apenas para prevenir fazer de falhar quando o comando retornar
um status diferente de zero - não é realmente necessário, pois usamos 'fazer -n'para resolver o
dependências, mas aconselho mantê-lo para o caso de se tornar obrigatório em versões futuras.
A sintaxe do escolher o comando é:

-escolher cmd $@ Arquivo de destino

onde $@ é a macro padrão dentro dos Makefiles que representam o alvo atual (o nome
da unidade que está sendo construída, com a extensão .U final retirada). o cmd parte é o
real metaconfig comando a ser executado, e o Arquivo de destino é mais um parâmetro, cujo
a interpretação depende do cmd em si. Ele também tem sua extensão final .U removida e
normalmente se refere a um arquivo de unidade, a menos que comece com './', caso em que faz referência a um
da metaconfig arquivos de controle no '.MT diretório.

Os comandos disponíveis são:

add Adiciona o Arquivo de destino para configurar.

add.Config_sh
Preenche essa parte de configurar produzindo o configuração.sh Arquivo. Usado apenas
variáveis ​​são adicionadas, as condicionais (de dependências condicionais) são
pulado.

add.Null Adiciona a seção inicializando todas as variáveis ​​de shell usadas para uma string vazia.

c_h_weed produz o config_h.SH Arquivo. Apenas as linhas necessárias são impressas.

cm_h_weed produz o confmagic.h Arquivo. Apenas as linhas necessárias são impressas. Esse
comando só é habilitado quando o -M opção é dada, ou quando um confmagic.h lima
já existe.

fechar.Config_sh
Adiciona o símbolo 'EOT' final em uma linha por si só para encerrar o documento aqui
construir produzindo o configuração.sh arquivo.

prefixar precede o conteúdo do alvo ao Arquivo de destino se esse arquivo não estiver vazio.

erva daninha Adiciona a unidade a configurar como o adicionar comando, mas faça alguns testes adicionais
para remover o '?símbolo' e '%símbolo'linhas do Arquivo de destino se o símbolo
não é desejado ou condicionalmente desejado. O formulário '%' só é usado internamente por
metaconfig ao produzir seus próprios arquivos .U no '.MT'diretório.

limpe o mesmo que adicionar realmente, mas executa uma substituição de macro adicional. o
as macros disponíveis são descritas no Conectados Macros parágrafo.

Como uma nota rodapé, metaconfig gera um -cond. comando internamente para lidar com condicional
dependências. Você não deve usá-lo sozinho, mas verá se digitalizar o
gerado Makefile no .MT diretório.

Conectados Macros
As seguintes macros são reconhecidas pelo Limpar comando e substituído antes da inclusão em
configurar:

O número de revisão base do pacote, derivado de .pacote.

A data atual.


O endereço de e-mail do mantenedor deste pacote, derivado de seu
.pacote.


O nome do pacote, conforme derivado de seu .pacote arquivo.


O nível de patch do metaconfig programa (preterido em favor de )


O nível de revisão SVN do metaconfig .

O número da versão do metaconfig .

Essas macros são usadas principalmente para identificar o metaconfig versão que gerou um
particular configurar script e para qual pacote foi feito. O endereço de e-mail do
o mantenedor está programado nas instruções principais que configurar imprime ao iniciar.

Publicações recentes metaconfig as versões entendem uma sintaxe muito mais geral do formulário:

<$ variável>

que é substituído no tempo de geração de Configuração pelo valor de variável tirado do seu
.pacote Arquivo. Eventualmente, o antigo formato de macro conectado desaparecerá, e <$ baserev>
Irá substituir em todas as unidades fornecidas.

Destaque Unidades
As seguintes unidades especiais são usadas para fatorar o código e fornecer um nível superior
funcionalidades. Eles produzem um script de shell que pode ser originado ou um shell
variável que pode ser avaliação'ed. A passagem de parâmetros é feita por meio de variáveis ​​bem conhecidas,
nomeado ou anônimo como $ 1, $ 2, etc ... (que pode ser facilmente definido através do shell conjunto
operador). Quando configurar executa, ele cria e entra em um UU diretório, então todo
o script produzido está lá e não interfere nos arquivos do seu pacote.

Aqui estão as unidades especiais que você deve conhecer e como usá-las.

Cppsym.U
Esta unidade produz um script de shell chamado Cppsym, que pode ser usado para determinar
se algum símbolo em uma lista é definido pelo pré-processador C ou compilador C que você tem
Especificadas. Ele pode determinar o status de qualquer símbolo, embora os símbolos em
(lista de atributos) são mais facilmente determinados.

Csym.U
Isso define a variável shell $ csym, usada internamente por configurar para verificar se um
dado símbolo C é definido ou não. Um uso típico é:

definir resultado do símbolo [-fva] [anterior]
eval $ csym

Isso vai definir o resultar variável para 'verdadeiro' se a função [-f], variável [-v] ou
array [-a] é definido, caso contrário, 'false'. Se um valor anterior for fornecido e o -r
interruptor foi fornecido para configurar (Ver a configurar Opções parágrafo), então isso
o valor é reutilizado sem questionamento.

A forma como este cálculo é feito depende da resposta que o usuário dá à pergunta
configurar irá perguntar se deve realizar um nm extração ou não. Se o
a extração foi realizada, a unidade simplesmente olha a lista de símbolos, caso contrário
ele executa um teste de link de compilação, a menos que -r foi dado para reutilizar o previamente calculado
valor, naturalmente ...

Fim.U
Ao copiar esta unidade em seu privado U diretório e dependências anexas no
? MAKE: linha, você pode forçar uma determinada unidade a ser carregada em configurar mesmo que não seja
caso contrário, queria. Algumas unidades só podem ser forçadas a configurar dessa maneira.

Filex.U
Esta unidade produz um script de shell arquivoexp que irá expandir nomes de arquivos começando com
tiles. Um uso típico é:

exp_name = `. / filexp $ name`

para atribuir o nome do arquivo expandido em nome_exp.

Findhdr.U
Esta unidade produz um encontrarhdr script que é usado para localizar os arquivos de cabeçalho em
$ usrinc ou outros lugares estranhos usando recursos cpp. O script recebe um
inclui o nome da base do arquivo como 'stdio.h' ou 'sys / file.h' e retorna o caminho completo de
o arquivo inlcude e um status zero se encontrado, ou uma string vazia e um status diferente de zero
se o arquivo não puder ser localizado.

Obter arquivo.U
Esta unidade produz um código de shell que deve ser fornecido para obter um arquivo
nome e faça algumas verificações de sanidade. Opcionalmente, uma expansão de ~ nome é executada.

Para usar esta unidade, $ rp e $ dflt deve conter a pergunta e a resposta padrão, que
será passado como está para o minha leitura script (veja a seguir Minha leitura.U). O $ fn
variável controla a operação e o resultado é retornado para $ ans.

Para localizar um arquivo ou diretório, coloque 'f' ou 'd' em f ~ /. Se um '~' aparecer, então ~ nome
a substituição é permitida. Se um '/' aparecer, apenas nomes de caminho absolutos são aceitos e
As substituições de ~ nome são sempre expandidas antes de retornar. Se '+' for especificado,
as verificações de existência são ignoradas. Se 'n' aparecer dentro de $ fn, então o usuário tem permissão para
responda 'nenhum'.

Normalmente, a menos que você solicite portabilidade, a substituição do nome ocorre quando solicitada.
No entanto, às vezes você deseja ignorar a portabilidade e forçar o
substituição. Você pode usar a letra 'e' (expandir) para fazer isso.

Se o tipo especial 'l' (localizar) for usado, o $ fn variável deve terminar com um ':',
seguido por um nome de base de arquivo. Se a resposta for um diretório, o nome de base do arquivo será
anexado antes de testar a existência do arquivo. Isso é útil em questões do tipo localizar
como isso:

dflt = '~ news / lib'
: não há necessidade de especificar 'd' ou 'f' quando 'l' é usado
fn = 'l ~: ativo'
rp = 'Onde está o arquivo ativo?'
. ./getfile
ativo = "$ ans"

Além disso, a letra 'p' (caminho) pode ser usada em conjunto com 'l' para indicar
obter arquivo que uma resposta sem '/' deve ser aceita, assumindo que será
estar no PATH de todos no momento em que esse valor for necessário.

Também útil é a possibilidade de especificar uma lista de respostas que devem ser aceitas
literalmente, ignorando todas as verificações. Esta lista deve estar entre parênteses e itens
deve ser separado por vírgulas, sem espaços intercalados. Não se esqueça de citar o
string resultante, pois os parênteses são significativos para o shell. Por exemplo:

dflt = '/ bin / install'
fn = '/ fe ~ (instalar,. / instalar)'
rp = 'Usar qual programa de instalação?'
. ./getfile
install = "$ ans"

permitiria ao usuário especificar apenas caminhos totalmente qualificados referindo-se aos arquivos existentes,
mas ainda permite as respostas especiais "instalar" e "./install" como estão (assumindo que
claro que algo vai lidar com eles especialmente mais tarde na cadeia, uma vez que eles fazem
não está em conformidade com o quadro geral esperado).

Se a resposta à pergunta for 'nenhuma', as verificações de existência serão ignoradas e
a string vazia é retornada. Observe que desde obter arquivo chamadas minha leitura internamente, todos
os recursos disponíveis com minha leitura aplique aqui para.

Se um valor completamente expandido for necessário (por exemplo, em um Makefile), você pode usar
que o $ ansexp variável que é sempre configurada corretamente por obter arquivo como o expandido
versão do $ ans. Claro, não irá expandir ~ name se você não permitir isso no
primeiro lugar no $ fn variável.

Inhdr.U
Esta unidade produz o $ inhdr variável shell, usada internamente por configurar checar
se um conjunto de cabeçalhos existe ou não. Um uso típico é:

definir cabeçalho i_header [header2 i_header2 ...]
eval $ inhdr

Isso irá imprimir uma mensagem, dizendo se o cabeçalho foi encontrado ou não e definir o
i_header variável em conformidade. Se mais de um cabeçalho for especificado e o primeiro
cabeçalho não for encontrado, tentamos o próximo, até que a lista esteja vazia ou um seja encontrado.

Inlibc.U
Esta unidade produz o $ inlibc variável shell, usada internamente por configurar checar
se uma determinada função C está definida ou não. Um uso típico é:

definir função d_func
eval $ inlibc

Isso irá imprimir uma mensagem, dizendo se a função foi encontrada ou não e configurada
$ d_func adequadamente. Internamente, ele usou o $ csym rotina.

Loc.U
Esta unidade importante produz um script de shell loc que pode ser usado para descobrir onde
em uma lista de diretórios encontra-se um determinado arquivo. O primeiro argumento especifica o arquivo para
ser localizado, o segundo argumento é o que será retornado se a pesquisa falhar, e o
argumentos reamining são uma lista de diretórios onde o arquivo deve ser pesquisado. Por
instância:

dflt = `. / loc sendmail.cf X / usr / lib / var / lib / sendmail / lib`

definiria $ dflt para X se não sendmail.cf arquivo foi encontrado nos diretórios listados,
ou algo parecido /usr/lib/sendmail.cf em alguns sistemas. Veja também Obter arquivo.U.

MailAutor.U
Esta unidade precisa ser incluída na linha? MAKE: de seu próprio End.U privado para fazer
isso em configurar. Oferece ao usuário o cadastro junto ao autor, opcionalmente
ser notificado quando novos patches chegarem ou recebê-los automaticamente quando emitidos.
Você precisa instalar agente postal para fazer isso (pelo menos versão 3.0).

Lista de correio.U
Esta unidade precisa ser incluída na linha? MAKE: de seu próprio End.U privado para fazer
isso em configurar. Ele oferece ao usuário se inscrever ou cancelar a inscrição em uma lista de discussão
onde a discussão relacionada ao pacote está ocorrendo. Você precisa correr empacotar
e responda às perguntas relacionadas à lista de e-mails para configurar as variáveis ​​adequadas em seu
.pacote antes que esta unidade se torne operacional.

Meuinit.U
Copie esta unidade em seu privado U diretório para adicionar seus próprios valores padrão a alguns
variáveis ​​internas. Esta unidade é carregada em configurar depois de todo o padrão
as inicializações foram feitas.

Minha leitura.U
Esta unidade produz o minha leitura script de shell que deve ser fornecido para fazer um
ler. Ele permite escapes de shell, atribuição padrão e avaliação de parâmetros, como
documentado na unidade Instruct.U. Também permite a configuração dinâmica do -d opção,
que será usado para o restante da execução do script.

Para usar esta unidade, $ rp deve segurar a questão e $ dflt deve conter o padrão
responder. A pergunta será impressa pelo próprio script, e o resultado será retornado
no $ ans variável.

Aqui está um uso típico:

dflt = 'y'
rp = 'Pergunta?'
. ./minhaleitura
valor = "$ ans"

Consulte a própria unidade para obter mais informações.

Oldconfig.U
Esta unidade deve fazer parte da sua dependência? MAKE: linha quando alguma de suas unidades tentar
para reutilizar um valor de símbolo antigo. Esta unidade é responsável por obter as respostas antigas
da configuração.sh ou fornecer dicas úteis ao executar em uma determinada plataforma para o
primeira vez. Veja o configurar Dicas parágrafo para obter mais informações sobre dicas.

Prefixo.U
O objetivo desta unidade é detectar mudanças no diretório do prefixo de instalação para
recompute automaticamente os padrões adequados de respostas anteriores. Depende do
valor do $ oldprefix variável que contém o diretório de prefixo anterior quando
alterado e está vazio caso contrário. Por exemplo, se o prefixo foi alterado de / opt para
/ usr / local, então o diretório de instalação binário anterior será alterado de
/ opt / bin para / usr / local / bin, ou permanecerá inalterado se fosse, digamos, / bin.

Você precisa ligar conjunto antes de emitir um avaliação on $ prefixit, Tais como:

definir dflt var [dir]
eval $ prefixit

que definiria $ dflt para $ var or $ prefix / dir dependendo se o prefixo permaneceu
o mesmo ou não. Se dir é a corda Nenhum, um único valor de espaço em $ dflt é mantido como-
é, mesmo quando o prefixo muda. Se dir é omitido, então $ dflt está definido como vazio
string se o prefixo mudou, para $ var de outra forma.

Prefixo.U
A intenção desta unidade é semelhante à de Prefixit.U, ou seja, ajuda a corrigir o
string padrão para acomodar alterações de prefixo. No entanto, a variável shell $ prefixup,
quando avaliado, irá restaurar apenas expansões de ~ nome, deve usar o prefixo de tal escape
mecanismo. Use-o como:

definir dflt
eval $ prefixup

antes de solicitar via obter arquivo por exemplo. Se o prefixo não fizer uso de ~ name
expansão, então o acima será um ambiente autônomo no y variável, naturalmente.

Typedef.U
Esta unidade produz o $ typedef variável shell, usada internamente por configurar checar
se um typedef existe ou não. Um uso típico é:

definir typedef val_t default [inclui]
eval $ typedef

Isso irá definir a variável val_t ao valor de omissão se o typedef não foi encontrado
entre os arquivos de inclusão listados, ou para typedef se encontrado. Se nenhum arquivo de inclusão for
especificado, a unidade procura em só. Se você especificar alguns includes, apenas
aqueles são olhados.

Unix.U
O objetivo desta unidade é definir alguns dos UNIX-ismos mais comuns por meio de variáveis
que pode ser alterado na linha de comando ou por meio de arquivos de dicas apropriados. Em particular,
$ _exe, $ _o e $ _a estão prontos. Todas as unidades devem se referir a $ _o e não para .o diretamente.
O '.' faz parte dessas variáveis.

Setvar.U
Esta unidade produz a variável, que é usada internamente por configurar para definir um
definir/ undef valor para um determinado símbolo, emitindo um aviso quando muda repentinamente
de um valor anterior. Por exemplo:

val = "$ define"
definir d_variable
eval $ setvar

Se o anterior $ d_variable valor não era nulo e $ val é diferente, um "uau"
aviso é emitido.

Uau
Esta unidade produz o Uau script, que emite um aviso quando o valor em variável
de quem é o nome $ var não é o mesmo que seu antigo valor anterior mantido em $ era. Sobre
Retorna, $ td e $ tu mantenha o valor adequado para definir or indefeso a variável. Ver
exemplos em Inlibc.U.

builtin Pré-processador
Cada unidade a ser incluída em configurar é executado por meio de um pré-processador embutido. Pré-
as instruções do processador são introduzidas pelo caractere '@' ('#' é o comentário do shell
personagem). Ele funciona apenas como o pré-processador C, mas permite shell e perl
escapes. Aqui estão as funções disponíveis:

@E se expressão
If expressão for verdadeiro, continue carregando o código até @end, @elsif ou @else.

@elsif expressão
Escolha alternativa. Se expressão for verdadeiro, continue carregando o código até @end,
outro @elsif ou @else.

@else Código padrão a ser carregado se o @if expressão era falso e nenhum dos
opcional @elsif correspondido. Carregue até o final.

@end Fecha a instrução de carregamento condicional aberta por @if.

@definir símbolo
Diz ao pré-processador que símbolo é definido a partir de agora.

O condicional expressão pode incluir nomes de símbolo (o valor é verdadeiro se o símbolo for desejado ou
definido via @definir ou escapes de shell / perl. Esses átomos podem ser combinados usando o
operadores booleanos tradicionais '!' para negação, '&&' para e lógico, e '||' para lógico
ou.

O texto entre colchetes simples é um teste de casca, enquanto o texto entre os travões duplos é
um teste de perl. A saber, as expressões:

{ concha texto }
{{ perl texto }}

são traduzidos em:

if concha texto > / dev / null 2> & 1; então saia 0; senão saia 1; fi
if (perl texto) {saída 0;} else {saída 1;}

e o status de saída é usado da maneira padrão para obter um valor booleano, ou seja, 0 é verdadeiro e
tudo o mais é falso. Observe que apenas condições simples podem ser expressas em perl, até
algum código complexo pode ser carregado dentro metaconfig e executado.

O pré-processador embutido pode ser usado para afinar algumas unidades (veja d_gethname.U para uma
exemplo complexo) dependendo dos símbolos realmente usados ​​pelo programa ou os arquivos
presentes na distribuição. Por exemplo, o Oldconfig.U usa um teste como:

@if {teste -d ../hints}

e configurar conterá código dependente de dica apenas se houver um dicas diretório no
diretório de nível superior do pacote. Observe que os testes são executados de dentro do '.MT'diretório,
portanto, o necessário '../' no teste.

O pré-processador também pode ser usado para evitar colocar código inútil quando um símbolo não é
definiram. As unidades que definem mais de um símbolo podem ser protegidas dessa forma (uma vez que a unidade é
carregado como um todo) reunindo o código dependente do símbolo em um par de extremidades @ if / @. Por
instância:

@if_TIME || I_SYS_TIME || I_SYS_TIME_KERNEL
need_time_h = 'true'
@senão
need_time_h = 'false'
@fim

irá testar se o código-fonte faz uso de um dos três símbolos que controlam
que o hora.h or sys / time.h inclusão e definir o símbolo da concha de acordo. Isso dá
configurar um feedback sobre o que as fontes precisam e evitar a desvantagem de ter corrigido
unidades congeladas.

Através das linhas '? W:', você pode obter combinações interessantes. Por exemplo, o i_time.U unidade
precisa saber se as fontes C fazem algum uso do struct fuso horário modelo. Portanto,
a linha:

? W :: fuso horário

é usado por seu efeito colateral de definir o símbolo fuso horário para o pré-processador. O
o código da unidade pode então dizer:

@if fuso horário
para s_timezone em '-DS_TIMEZONE' ''; Faz
@senão
s_timezone = ''
@fim

... código usando s_timezone ...

@if fuso horário
feito
@fim

e tem um loop extra tentando dois valores sucessivos para o s_fuso horário variável, mas apenas
se necessário.

Obsoleto Símbolos
Os símbolos obsoletos são preservados para facilitar a transição com os antigos metaconfig unidades. A menos que
que o -o interruptor é passado para metaconfig eles serão ignorados. No entanto, um Obsoleto arquivo vai
ser gerado, informando quais arquivos estão fazendo uso desses símbolos obsoletos e quais
são os novos símbolos a serem usados.

O tempo de vida para símbolos obsoletos é uma revisão completa, ou seja, eles serão removidos quando o
a próxima revisão de base é emitida (atualizações de patch não contam, é claro). Portanto, é
É aconselhável traduzir suas fontes e começar a usar os novos símbolos o mais rápido possível.

configurar Dicas
Pode acontecer que a lógica de configuração interna faça escolhas erradas. Por
por exemplo, em alguma plataforma, o vfork () chamada de sistema está presente, mas interrompida, por isso deve
não ser usado. Não é possível incluir esse conhecimento nas próprias unidades, pois
isso pode ser um problema temporário que o fornecedor eventualmente consertará, ou algo que
foi introduzido por uma nova atualização do sistema operacional.

De qualquer forma, para todos aqueles pequenos problemas que são muito específicos do sistema, metaconfig
fornece suporte a arquivos de dicas. Para usá-lo, você precisa criar um dicas diretório no
diretório de nível superior do pacote, e tenha-o quando você executar metaconfig. Isso vai carregar o
parte relacionada à dica de Oldconfig.U.

A partir de então, você pode predefinir algumas das variáveis ​​do shell configurar usa em um sistema operacional específico
arquivo .sh. Existe um código em Oldconfig.U que tenta adivinhar quais arquivos de dicas são necessários para
computar um nome padrão com base no nome do sistema operacional, o nome do kernel, a versão
número, etc ... Como essa informação provavelmente mudará rapidamente, não estou documentando
aqui. Você tem que fazer engenharia reversa do código de Oldconfig.U.

Ao lançar o pacote pela primeira vez, o diretório do arquivo de dicas deve estar vazio. Se o
os usuários do seu pacote reclamam que têm problemas com configurar padrões em um
sistema particular, você tem que ver se este é um problema específico da plataforma ou um
geral. No primeiro caso, é hora de introduzir um novo arquivo de dica, enquanto no
posteriormente, a unidade correspondente deve ser revisada.

Por exemplo, os sistemas SGI são conhecidos por terem uma falha vfork () chamada de sistema, a partir deste
escrevendo. E o nome do arquivo de dica correspondente é sgi.sh. Então, tudo que você precisa fazer é criar
a dicas / sgi.sh arquivo no qual você escreve:

d_vfork = "$ define"

que sempre remapeará garfo on garfo (Vejo d_vfork.U) Quando executado em sistemas SGI para o
primeira vez, configurar irá detectar que existe um dicas / sgi.sh arquivo, e que estamos
uma máquina IRIX (o nome do kernel é frequentemente / irix), portanto, ele irá propor sgi como um
possível dica. Se o usuário aceita, e desde o $ d_vfork o valor é modificado por meio do
$ setvar ligar, um Uau! será emitido para avisar que estamos prestes a substituir o valor
calculado por configurar.

Observe que você não precisa fornecer todos os as dicas conhecidas por Oldconfig.U. Se um arquivo de dica for
faltando, não será proposta como uma escolha possível. Os testes heurísticos foram executados para calcular
os possíveis candidatos de dica são instáveis. Se você tiver novos valores ou testes diferentes, por favor
Mande-os para mim...

Substituindo Escolhas
Se você criar um config.over arquivo no diretório de nível superior, configurar vai te perguntar se você
deseja carregá-lo para substituir os valores padrão. Isso é feito antes da criação do
configuração.sh arquivo, então dá a você a chance de corrigir os valores armazenados nele.

Isso é diferente da abordagem de dicas, pois é um arquivo local, que o usuário é
livre para criar para seu próprio uso. Você não deve fornecer esse tipo de arquivo sozinho, mas deixe que o
o usuário sabe sobre esta possibilidade.

configurar Opções
A configurar script pode ser chamado com algumas opções especificadas na linha de comando, para
modifique ligeiramente seu comportamento. Aqui estão as opções permitidas:

-d Use padrões para todas as respostas.

-e Continue sem questionar além da produção de configuração.sh.

-f lima Use o arquivo especificado como uma configuração padrão. Se esta opção não for usada,
a configuração é tirada de configuração.sh, quando presente.

-h Imprima a mensagem de ajuda e saia.

-r Reutilize o valor dos símbolos C, se possível. Isso vai pular o caro nm símbolo
Extração. Se usado pela primeira vez (sem arquivo de configuração anterior),
configurar tentará compilar e vincular um pequeno programa para saber sobre
a presença ou ausência de um símbolo.

-s Modo silencioso. Apenas strings impressas no descritor de arquivo # 4 serão vistas no
tela (essas são as mensagens importantes). Não é possível desligar completamente
qualquer saída, mas você pode usar 'configurar - anciãos > / dev / null 2> e 1'ter um completo
lote executado sem saída e nenhuma interação do usuário necessária.

-D símbolo = valor
Pré-define símbolo para suportar o especificado valor. Também é possível usar '-D
símbolo'que usará um valor padrão de' definir '.

-E Pare no final das questões de configuração, após ter produzido um
configuração.sh. Isso não vai realizar nenhum 'fazer depender'ou extração de arquivos .SH.

-K Usuário experiente. Quando você usa esta opção, você sabe o que está fazendo e
Portanto, o configuração.sh arquivo sempre será tratado como se fosse destinado a ser
reutilizado, embora possa ter sido gerado em um sistema estranho. Isso também
impede o aborto quando configurar detecta um compilador C inutilizável ou um conjunto errado
de sinalizadores C. Outros atalhos podem ser ativados por esta opção também no
futuro. Esta opção está documentada no configurar mensagem de uso, para nos lembrar
sobre sua existência, mas espera-se que a descrição dada seja bastante enigmática.
:-)

-O Permitir valores especificados por meio de um -D or -U para substituir as configurações de qualquer
arquivo de configuração. Este não é o comportamento padrão, pois a substituição irá
não ser propagado para variáveis ​​derivadas daquelas que você está alterando no momento.
Naturalmente, sem -O, a configuração só é feita quando nenhum arquivo de configuração é
carregado, o que é seguro, pois as variáveis ​​derivadas ainda não foram calculadas ...

-S Execute a substituição de variável em todos os arquivos .SH. Você pode combiná-lo com o
-f mude para propagar qualquer configuração que desejar.

-U símbolo =
Pré-conjuntos símbolo para ter um valor vazio. Também é possível usar '-U símbolo'
que vai definir símbolo para 'undef'.

-V Imprima o número da versão do metaconfig que gerou isso configurar escrita
e sair.

Corrida Meio Ambiente
Ao iniciar, configurar cria um local UU diretório e é executado a partir daí. O diretório
é removido quando o Configure termina, mas isso significa que você deve executar o script de um lugar onde
você pode escrever, ou seja, não a partir de um sistema de arquivos somente leitura.

Você pode correr configurar remotamente, como em:

../pacote/Configurar

para configurar fontes que não estão presentes localmente. Todos os arquivos gerados serão colocados em
o diretório de onde você está executando o script. Essa mágica é feita graças ao src.U
unidade, que está definindo o $ src e $ rsrc variáveis ​​para apontar para as fontes do pacote. que
o caminho é completo ou relativo, dependendo se configurar foi invocado por meio de um completo ou
caminho relativo.

De dentro do UU subdiretório, você pode usar $ rsrc para acessar os arquivos fonte (unidades
referências de link de arquivos de origem devem sempre usar este mecanismo e não assumir o
arquivo está presente no diretório pai). Todos os Makefiles devem usar a variável $ src
como um ponteiro para as fontes do topo do diretório de compilação (onde configurar é executado),
diretamente ou por meio de uma configuração VPATH.

Quando correr configurar remotamente, os arquivos .SH são extraídos no diretório de compilação, não
na árvore de origem. No entanto, requer algum tipo de fazer suporte para ser capaz de compilar
coisas em um diretório de construção enquanto os fontes estão em outro lugar.

utilização mágica Redefinições
Fazendo uso do -M switch, alguns remapeamentos mágicos podem ocorrer dentro de um confmagic.h
Arquivo. Esse arquivo precisa ser incluído após configuração.h, é claro, mas também depois de todo o
outros necessários incluem arquivos. Nomeadamente:

#include "config.h"
...
... de outros inclusões ...
...
#include "confmagic.h"

Tipicamente, confmagic.h tentará remapear bcopy () on memcpy () se não bcopy () is
disponível localmente, ou transformar garfo para dentro garfo quando necessário, tornando-o inútil para
incomodar-se com o HAS_VFORK símbolo.

Esta configuração mágica está documentada no arquivo de Glossário.

Unidade Modelos
Há um conjunto de modelos de unidade no metaconfig diretório de origem, que se destina a
ser usado por um programa (ainda não escrito) para produzir rapidamente novas unidades para vários tipos de
situações. Nenhuma documentação para este projeto inacabado, mas pensei em mencioná-lo
na página de manual, caso deseje fazê-lo você mesmo e, em seguida, contribuir ...

AUTORES

Larry Wall[email protegido]> para a versão 2.0.
Harlan Stenn[email protegido]> para extensões de unidade importantes.
Raphael Manfredi[email protegido]>.
Muitos outros contribuidores para o metaconfig unidades. Veja o arquivo de crédito para uma lista.

Use metaconfig online usando serviços onworks.net