metaconfig - Online en la nube

PROGRAMA:

NOMBRE

metaconfig - un generador de script de configuración

SINOPSIS

metaconfiguración [-dhkmosvwGMV ] [-L dir ]

DESCRIPCIÓN

Metaconfiguración es un programa que genera Configure scripts. Si no sabes lo que es
Configurar el script es, vaya al TUTORIAL sección de esta página de manual. Si quieres
una descripción completa (formal) de la forma de utilizar metaconfiguración y sus unidades, mire el
REFERENCIA sección. La siguiente es una introducción rápida y una referencia para los conocedores
usuarios.

Metaconfiguración opera desde un conjunto de unidades que que definen todo lo que conoce metaconfig
portabilidad. Cada unidad es autónoma y no tiene que estar registrada en ningún lugar.
excepto por la inclusión en el directorio U público o en su directorio U privado. Si
el paquete dist (del cual forma parte metaconfig) se instala en LIB, luego el U público
El directorio es LIB / dist / mcon / U. En esta máquina, el directorio LIB es / usr / share / dist. Tu
El directorio U privado, si tiene uno, está en el directorio de nivel superior de su paquete.
Antes de que puedas correr metaconfiguración debes hacer varias cosas:

· Cree un archivo .package en el directorio de nivel superior del paquete ejecutando empacar.
Este programa le preguntará sobre su paquete y recordará lo que le diga para que
todos los programas dist pueden ser inteligentes.

· Consulta el glosario (en LIB / dist / mcon) y escribe tus scripts de shell y programas C
en términos de los símbolos que metaconfig sabe definir. No necesitas decir
metaconfig qué símbolos usó, ya que metaconfig lo resolverá por usted.

· Genere los scripts .SH necesarios para escribir Makefiles o scripts de shell que dependerán
en los valores definidos por Configure. Hay un programa llamado hacer eso te ayudará
convertir un script simple en una plantilla script.SH; algunas ediciones todavía necesitarán ser
realizado en el archivo .SH resultante para mover la parte de configuración de la variable en el
parte superior del script (ver comentarios en línea generados por hacer dentro de su .SH
de archivo).

· Cree un archivo MANIFEST.new en su directorio de nivel superior que enumere todos los archivos en
tu equipaje. Este archivo seguirá siendo privado y no será parte de la final
distribución. (Para su comodidad, el archivo MANIFEST será utilizado por metaconfiguración if
todavía no hay un archivo MANIFEST.new.) El nombre del archivo debe ser el primer campo en cada
línea. Después de algunos espacios en blanco, puede agregar un breve comentario que describa su archivo. Solo
Los archivos de origen deben aparecer allí. El archivo especial nivel de parche.h (cual es
manejado y mantenido por las herramientas de parcheo - ver palmadita(1)) debe ser parte del
MANIFEST.nuevo archivo, pero algunas herramientas pueden ignorarlo en silencio. Como una regla de oro,
solo los archivos mantenidos por RCS deben aparecer allí, el nivel de parche.h archivo siendo
una excepción importante.

· Opcionalmente, es posible que desee crear un archivo MANIFEST, que será una versión exportada
de tu MANIFIESTO nuevo. Ese archivo debe formar parte de la versión, es decir, debe aparecer en ambos
su MANIFIESTO nuevo y se MANIFIESTA. Uno de los metaconfiguración las unidades saben sobre esto
archivo y obligará a Configure a realizar una verificación de versión, asegurando que todos los archivos
enumerados allí son parte de la distribución. Los archivos MANIFEST y MANIFEST.new deben
ser distintos, no enlaces.

· Copie los archivos .U que desee modificar en su directorio U privado. Cualquier archivo .U
en su directorio U privado se utilizará con preferencia al de la U pública
directorio. Por ejemplo, una forma de forzar la inclusión de cualquier unidad es copiar el End.U
archivo a su directorio .U y agregue el nombre de la unidad que desea como dependencia en
el final de la línea? MAKE :. Ciertas unidades SÓLO pueden forzarse de esta manera, a saber
los de la forma Warn _ *. U y Chk _ *. U. También puede personalizar ciertos valores predeterminados
Configure las variables copiando Myinit.U al directorio U privado de su paquete y
establecer las variables en esa unidad.

Ahora estás listo para correr metaconfiguración. Eso creará un Configurar archivo y, opcionalmente, un
config_h.SH archivo (si sus fuentes hacen uso de símbolos C). Los archivos generados
se agregará automáticamente a su MANIFEST.new si es necesario. No olvide actualizar su
Aunque archivo MANIFEST.

Para crear nuevas unidades, haga lo siguiente:

· Copie una unidad similar a un nuevo archivo .U. El nombre que elija debe ser el nombre de un
variable generada por la unidad, aunque esto es solo una conveniencia para usted, no una
requisito. Debe tener 12 caracteres o menos para evitar que se corten los nombres de archivo.
En realidad, probablemente debería ser 10 o menos para que aquellos que quieran usar RCS puedan tener
un .U, v en el extremo sin picar. Metaconfig usa el caso de la primera letra para
Determine si esta unidad realmente produce alguna variable, así que no capitalice su
nombre de la unidad si se supone que debe producir una variable de shell.

· Edita el nuevo archivo .U para hacer lo que quieras. La primera línea? MAKE: indica la
dependencias; antes de la lista final, dos puntos todas las variables que define esta unidad, y
después de los dos puntos finales todas las variables (u otras unidades) de las que depende esta unidad.
Es muy importante que estas listas sean precisas. Si una dependencia es opcional y una
Se puede usar el valor predeterminado, debe anteponer la dependencia con un signo '+'. El
la unidad correspondiente no se cargará para calcular el símbolo, a menos que sea realmente necesario
por otra unidad.

· En la medida de lo posible, parametrice su unidad en función de la variable de shell definida en
? INIT: líneas. Esto moverá las definiciones de variables a la unidad Init.U, donde
pueden ser anulados por definiciones en Myinit.U, que se incluye después de Init.U.

· Agregue la definición de cualquier símbolo C deseado como líneas? H:. Una línea que comienza con
? H:?% <: En el archivo .U se agregará al archivo config.h eventual si y solo si
metaconfig decide que esta unidad es necesaria. % <Representa el nombre de la unidad,
que resulta ser el nombre del archivo también (sin .U) si siguió el
convención. Siempre ponga un comentario en cada línea? H: en caso de que una de las variables
sustituciones anteriores en la línea comienza un comentario sin terminarlo. Cualquier caparazón
La variable que comienza con d_ puede hacer esto, así que tenga cuidado. Si omite?% <:, Entonces
metaconfig intentará intuir el símbolo cuya definición es necesaria antes de cualquier
inclusión en config.h.

· Agrega definiciones de glosario como? S: líneas para variables de shell y? C: líneas para C
variables del preprocesador. Consulte una unidad actual para ver ejemplos. Es MUY importante
comience cada entrada con un nombre de símbolo justificado a la izquierda y termine cada entrada con? C :. o
?S:. línea. El algoritmo que traduce las entradas de símbolo del preprocesador C para el
El glosario en comentarios para config.h depende de esto.

· Asegúrese de que el orden de todos sus? las líneas son correctas. El orden correcto es:

? RCS: y? X: básicamente solo comentarios
? HACER: dependencias de metaconfiguración
? Y: directiva de disposición de la unidad
? S: definiciones de shell del glosario
? C: glosario C definiciones
? H: definiciones de config.h
? M: definiciones de confmagic.h
? W: símbolos buscados
? V: símbolos visibles
? F: archivos creados por esta unidad
? T: símbolos de shell temporales utilizados
? D: valor predeterminado de dependencias opcionales
? O: utilizado para marcar unidades obsoletas
? PELUSA: pistas metálicas
? INIT: inicializaciones de símbolos de shell

A continuación, se muestra un ejemplo para mostrar el orden de las líneas y los distintos formatos permitidos:

? RCS: $ RCS-Id $
? RCS: información de copyright
? RCS: $ RCS-Log $
?X:
? X: Un ejemplo artificial
?X:
? HACER: d_uno dos: tres + cuatro Cinco
? HACER: -elija agregar $ @%
? Y: PREDETERMINADO
? S: d_one:
? S: primer símbolo de caparazón, define condicionalmente UNO.
?S:.
? S: dos:
? S: segundo símbolo de caparazón, valor para DOS.
?S:.
?CONO:
? C: primer símbolo C.
?C:.
? C: DOS:
? C: segundo símbolo C.
?C:.
? H: # $ d_one ONE / ** /
? H: #define DOS "$ dos"
? H: # $ d_one ONE_TWO "$ dos"
? H :.
? M: voltear: HAS_FLIP
? M: #ifndef HAS_FLIP
? M: #definir flip (x) flop (x)
? M: #endif
?METRO:.
? W:% <: uno_dos
? V: p_one p_two: p_three
? F: archivo ./ftest! Tmp
? T: tmp var
? D: dos = 'indef'
? LINT: cambia tres
? INIT: two_init = '2'
: sigue el código de shell que implementa la unidad
p_one = 'uno'
p_two = 'dos'
p_three = ""

Permítanme decirlo una vez más: la definición de unidad anterior es una falso uno solo para mostrar el
diferentes posibilidades. De todos modos, una unidad así no serviría para nada ...
Las funciones avanzadas no se describen aquí. por favor refiérase a REFERENCIA sección para más
información completa.

· Coloque la unidad en el directorio U público o privado, según corresponda.

· Volver a ejecutar metaconfiguración.

· Envíe su unidad a [email protected] (Raphael Manfredi) para su inclusión en la copia maestra,
si cree que es de interés general.

Para agregar un nuevo programa para ubicarlo:

· Edite Loc.U y agregue el nombre del programa a la línea? MAKE: (entre las
dos dos puntos) y a loclist o trylist (dependiendo de si el programa es
obligatorio o no).

· Vuelva a ejecutar la metaconfiguración.

· Envíeme su unidad para que la incluya en la copia maestra, si cree que es de carácter general
interés.

Notas para escribir archivos .U:

* Utilice siempre "rm -f" porque hay sistemas en los que rm es interactivo de forma predeterminada.

* No utilice "set - ..." porque '-' no funciona con todos los shell. Utilice "set x ...;
cambio".

* No utilice "ENV desarmado" ya que desarmar no es completamente portátil. En su lugar, diga "ENV = ''".

* Utilice siempre echo "" (con un espacio) debido a los sistemas Eunice.

* Uso único test con -r, -w, -fo -d ya que son los únicos conmutadores portátiles. En
en particular, evite "test -x".

* Use solo programas que vienen con V7, para que sepa que todos los tienen.

* Use $ contiene cuando desee grep condicionalmente, ya que no todos los greps devuelven un
estado razonable. Asegúrese de redirigir la salida a / dev / null, usando '> / dev / null
2> & 1 '.

* Utilice "si prueba" en lugar de "si [...]" ya que no todos los peces conocen la última construcción.

* Use el script myread para las entradas para que puedan hacer escapes de shell y por defecto
evaluación. La forma general es

caso "$ grimble" en
'') dflt = 452 ;;
*) dflt = "$ grimble" ;;
esac
rp = '¿Cuántos grimbles tienes?'
. ./milectura
grimble = "$ ans"

* Utilice el script getfile cuando solicite un nombre de ruta de archivo para tener opcional
~ Expansión de nombres y controles de cordura. Consulte la unidad Getfile.U para obtener una descripción completa.

* Pon siempre un

$ startsh

en la parte superior de cada script generado que va a ser lanzado o obtenido por
Configurar.

* Nunca asuma ismos UNIX comunes como el hecho de que un archivo de objeto termina con un .o y
que el nombre de una biblioteca termina con .a. Utilizar el $ _o y $ _a variables en su lugar (ver
Unix.U).

* Al hacer una prueba de compilación-enlace-ejecución, escríbalo siempre así:

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

porque algunos sistemas requieren que los indicadores de enlace se especifiquen antes de la compilación
target (con la excepción de las bibliotecas de enlaces finales).

* Emita mensajes importantes en el descriptor de archivo # 4, usando '> & 4' para redirigir la salida.
Solo esos mensajes aparecerán cuando el -s se le da el cambio a Configurar en
línea de comando (modo silencioso).

* Intente siempre determinar si una característica está presente de la forma más específica; no lo haga
diga "if bsd" cuando pueda grep libc. Existen muchos sistemas híbridos y
cada característica debe sostenerse o caerse por sí sola.

* Intente siempre determinar si una característica está presente de la forma más general, de modo que
otros paquetes pueden usar su unidad.

* En caso de duda, establezca un valor predeterminado y pregunte. No asumas nada.

* Si cree que el usuario está equivocado, tenga en cuenta el hecho de que puede tener razón. Para
Por ejemplo, podría estar ejecutando Configure en un sistema diferente al que va a usar.
el producto final en.

Metaconfig reserva los siguientes nombres en su directorio, y si usa tal nombre,
puede ser golpeado o tener otros efectos imprevistos:

.MONTE/*
Configurar
Querido
Obsoleto
configurar
config_h.SH
confmagic.h
U / *
MANIFEST.nuevo

Además, Configure puede bloquear estos nombres en el directorio en el que se ejecuta:

UU / *
config.sh
configuración.h

CAMPUS

Las siguientes opciones son reconocidas por metaconfiguración:

-d Activa el modo de depuración. No es realmente útil a menos que esté depurando metaconfiguración
misma.

-h Imprima el mensaje de ayuda y salga.

-k Mantenga el directorio temporal, de modo que pueda examinar los archivos de trabajo utilizados por
metaconfiguración para construir tu Configurar texto. Útil solo al depurar el
unidades.

-m Suponga mucha memoria y espacio de intercambio. Esto acelerará la búsqueda de símbolos en
archivos de origen por una cantidad significativa de tiempo, a expensas de la memoria
consumo...

-o Asigne símbolos obsoletos a otros nuevos. Utilice este interruptor si todavía tiene
símbolos obsoletos en su código fuente y no desea (o no puede) eliminar
ellos por ahora. Los símbolos obsoletos se ignoran por lo demás, aunque eso
te dará una advertencia de metaconfiguración.

-s Activa el modo silencioso.

-t Rastree los símbolos a medida que los encuentre.

-v Activa el modo detallado.

-w Suponga que el archivo buscado está actualizado. Esto omitirá el tiempo y la memoria.
fase consumidora de escaneo de código fuente, buscando símbolos conocidos. Usarlo
solo cuando sepa que su archivo fuente no ha cambiado con respecto a la
piscina de metaconfiguración símbolos utilizados.

-G También proporcione un GNU configurar-como el front-end para el generado Configurar
script, que también se incluirá en la distribución. Esto es solo un envoltorio
alrededor del Configurar guión de forma natural, pero permite a las personas familiarizadas con el
Herramienta GNU para no perderse ante una nueva distribución.

-L dir Anula la ubicación de la biblioteca predeterminada. Normalmente solo es útil para metaconfig.
mantenedores para utilizar localmente las unidades que se están desarrollando en lugar de la
los disponibles públicamente. los dir especificado es el que contiene las unidades
U directorio.

-M Permitir la producción de un confmagic.h archivo para reasignar automágicamente algunos
símbolos conocidos a alguna otra alternativa, como bcopia() siendo reasignado
de forma transparente a memcpy () cuando no está disponible. Esta opción está activada
automáticamente cuando un confmagic.h El archivo existe en el directorio de nivel superior.
Simplemente elimine ese archivo si desea desactivar esta opción de forma permanente.

-V Imprime el número de versión y sal.

TUTORIAL

Esta sección (larga) es una introducción a metaconfiguración, en el que aprenderemos todos los
lo esencial. Si ya sabes cómo usar metaconfiguración, puede pasar al siguiente
.

General
Por lo general, cuando desea obtener algún paquete fuente para compilarlo en una plataforma determinada, tiene
para editar el Makefile principal (¡asumiendo que hay uno!), elija un compilador de C, asegúrese de
tener las bibliotecas adecuadas, y luego disparar el para lograr mando. Si el paquete es razonablemente
bien escrito, se compilará (sin que una advertencia sea una opción :-). En sí mismo, el último
frase es una actuación real, ya que dada la variedad de plataformas UNIX disponibles en la actualidad
y la diversidad de sabores, eso significa que el autor del paquete ha profundizado
problemas para descubrir las opciones correctas dada una prueba estándar, adivinar y jugar
con el sistema incluye y tipos.

Sin embargo, a pesar de todo su talento, el autor no puede saber que algún sistema tiene un
llamada al sistema rota, o que alguna estructura del sistema carece de un campo estándar, o
simplemente si un archivo de inclusión dado existe o no. Y no estoy considerando lo implícito
supuestos, como el tipo devuelto por el malloc () función o la presencia del
rebautizar() llamada al sistema, por nombrar algunos. Pero ese conocimiento es necesario para lograr una verdadera
portabilidad.

Ahora no abusemos de nosotros mismos. Usar esa información requiere mayores habilidades, pero puede
conducir a programas más portátiles, ya que luego se escribe de una manera independiente del sistema
y se basa únicamente en el hecho de que alguna suposición es verdadera o falsa en un sistema en particular,
cada suposición no está relacionada entre sí. Es decir, no decimos: estamos en una
Sistema BSD o estamos en un sistema USG. De todos modos, eso es demasiado confuso hoy en día. No, queremos
decirle al código fuente: este sistema no tiene la rebautizar() llamada al sistema y malloc ()
devuelve un (vacío *) .

Metaconfig es una herramienta que le permitirá hacer precisamente eso, con el beneficio adicional de no
tener que editar manualmente el Makefile si todo va bien. Mediante la ejecución metaconfiguración, creas un
script de shell llamado Configurar. Se han dedicado muchos esfuerzos al script Configure
internos para garantizar que se ejecutará en el 99% de los caparazones existentes disponibles a partir de este
escribiendo. Configure probará el sistema de destino, haciendo preguntas en caso de duda y
recopilar todas las respuestas en un solo archivo de shell, que a su vez se puede utilizar para
Genera automáticamente Makefiles configurados y archivos C include.

Solo hay un conjunto limitado (pero bastante grande) de símbolos disponibles para sus scripts de shell
y programas C. Todos están documentados en el archivo Glosario. Todo lo que necesitas hacer es aprender
sobre ellos y comience a usarlos para abordar problemas de portabilidad y configuración. Entonces,
mediante la ejecución metaconfiguración, se generará un script de configuración adecuado para su paquete.

El script Configure se compone de varias unidades (más de 300), cada unidad
responsable de definir una pequeña cantidad de símbolos de shell y / o C. Las unidades están ensambladas
juntos en la etapa final, respetando el gráfico de dependencia (una unidad puede necesitar el resultado
de varias otras unidades que luego se colocan antes en el guión).

Símbolos
Los símbolos son lo más importante en el metaconfiguración mundo. Ellos son los mas pequeños
entidad reconocida, generalmente una palabra, y se le puede otorgar un valor al final de la configuración
ejecución. Por ejemplo, el símbolo del preprocesador C HAS_RENOMBRE es un metaconfiguración símbolo que
Se garantiza que se definirá si, y solo si, el rebautizar() la llamada al sistema está presente. Igualmente,
las $ ranlib La variable de shell se establecerá en ':' o 'ranlib' dependiendo de si el
llamar al ranlib Se necesita un programa para solicitar un archivo de biblioteca. Cómo funciona esto no es
importante por ahora, lo que es importante es comprender que a esos símbolos se les da una la vida
(es decir, un valor) sobre Configurar ejecución.

Usar símbolos es relativamente sencillo. En un archivo fuente C, simplemente usa el símbolo
value, como una directiva de preprocesador (por ejemplo, un: #ifdef HAS_RENOMBRE) o, si el símbolo
El valor es una cadena, directamente como usaría una macro en C. Y en un archivo de shell o un
Makefile, puede hacer referencia a un símbolo de shell directamente.

En realidad, estoy mintiendo, porque eso no es tan mágico como el párrafo anterior.
podría sonar. En un archivo C, debe incluir la configuración producida configuración.h archivo, y
debe envolver su script de shell o Makefile en un archivo .SH y puede hacer referencia al shell
símbolo sólo en la parte de sustitución de variable de ese archivo .SH. Más sobre esto más adelante.

Fuente archivos
Los símbolos solo pueden aparecer en un conjunto limitado de archivos de origen, porque metaconfiguración podría sólo
escanee esos cuando busque símbolos conocidos, tratando de averiguar qué unidades necesitará.
Puede utilizar símbolos C en archivos fuente C, es decir, archivos con un .c, .h, .y or .l extensión, y
Los símbolos de shell se buscan solo en archivos .SH.

Para obtener el valor de un símbolo, un archivo C debe incluir el especial configuración.h
archivo, que es producido por Configurar cuando los símbolos C están presentes. Y se ejecutan archivos .SH
a través de un shell, produciendo un nuevo archivo. Sin embargo, en la sección superior del archivo .SH, el
especial config.sh archivo (también producido ejecutando Configurar) se obtiene y es variable
se aplican sustituciones. Realmente, configuración.h se produce ejecutando el metaconfiguraciónproducido
config_h.SH archivo, nuevamente usando la sustitución de variables. Así que vamos a ver eso
un poco más de cerca, ya que este es el corazón de todo configuración esquema...

Variable Sustitución
Hay una construcción de shell llamada esta página documento que permite que un comando tome una entrada
especificado en el propio script. Esa entrada es interpretada por el shell como un doble
cadena entre comillas o una sola cadena entre comillas dependiendo de la forma del documento aquí
especificación.

Para especificar un documento aquí, se utiliza el token '<<', seguido de un único identificador. Desde
luego, las líneas de script restantes forman la entrada para el comando, hasta que aquí
el documento se encuentra en una línea por sí mismo. Sustitución de shell (incluida la variable de shell
sustituciones) se realiza a menos que el identificador esté entre comillas simples. Por ejemplo:

var = 'primero'
tar = 'segundo'
echo "-> primer documento aquí:"
gato <
var = '$ var'
tar = '$ tar'
MOE
echo "-> segundo aquí documento:"
gato << 'EOM'
echo $ var
echo $ tar
MOE
echo "-> fin".

producirá, cuando se ejecute a través de un shell:

-> primer documento aquí:
var = 'primero'
tar = 'segundo'
-> segundo aquí documento:
echo $ var
echo $ tar
-> fin.

El primer documento aquí tiene su contenido interpretado mientras que el segundo se emite como está.
Ambos son útiles en un script .SH, como veremos.

Usar .SH Scripts
Un script .SH generalmente se produce ejecutando el hacerSH script de otro archivo existente,
transformadora presentar post-extracción archivo.SH. Tomemos un solo ejemplo. Aquí hay un pequeño guión
(llamémoslo tamaño pequeño) que imprime un solo mensaje, el tamaño del int tipo de datos en C.
Desafortunadamente, tiene el valor cableado en él, así:

#!/ Bin / sh
intsize = '4'
echo "En esta máquina, el tipo int es $ intsize bytes"

Corramos hacer en él escribiendo 'hacer tamaño pequeño'. Obtenemos un sencillo intsize.SH archivar eso
Se ve como esto:

caso $ CONFIG en
'')
si prueba -f config.sh; luego TOP = .;
prueba elif -f ../config.sh; luego TOP = ..;
prueba elif -f ../../config.sh; luego TOP = ../ ..;
prueba elif -f ../../../config.sh; luego TOP = ../../ ..;
prueba elif -f ../../../../config.sh; luego TOP = ../../../ ..;
más
echo "No se puede encontrar config.sh."; salida 1
fi
. $ TOP / config.sh
;;
esac
: Esto obliga a los archivos SH a crear un destino en el mismo directorio que el archivo SH.
: Esto es para que make dependa siempre sepa dónde encontrar las derivadas SH.
caso "$ 0" en
* / *) cd `expr X $ 0: 'X \ (. * \) /'` ;;
esac
echo "Extrayendo intsize (con sustituciones de variables)"
: Esta sección del archivo tendrá sustituciones de variables realizadas.
: Mueva todo lo que necesite subs de configuración de! NO! SUBS! sección a! GRAN! ESTO !.
: Proteja los signos de dólar y las comillas inversas que no desee que se interpreten
: colocando una barra invertida al frente. Puede eliminar estos comentarios.
$ spitshell> intsize <
$ startsh
! Grito! ¡ESTO!

: En los siguientes dólares y comillas invertidas, no es necesaria la barra invertida adicional.
$ spitshell >> intsize << '! NO! SUBS!'
intsize = '4'
echo "En esta máquina, el tipo int es $ intsize bytes"
! NO! SUBS!
chmod 755 tamaño pequeño
$ eunicefix intsize

La primera parte de este guión (en el case declaración) está tratando de localizar el config.sh
archivo, para obtenerlo. El $ CONFIG La variable es falsa por defecto, por verdadera cuando
config.sh ya se ha obtenido (que sería el caso si este archivo se ejecutara desde
dentro de Configurar en sí mismo, pero no confundamos el problema aquí).

Una vez que la config.sh archivo ha sido fuentes, todos los símbolos de shell definidos por Configurar en
colocar. Sabemos llegar a una segunda declaración de caso, utilizada para cambiar el directorio actual si un
ruta se utilizará para llegar a este programa (por ejemplo, si dijimos 'sh ../scripts/intsize.SH', nosotros
primero correría 'cd ../guiones' Antes de continuar). Si no entiende esto, no
preocuparse por eso

Aquí viene lo interesante. Este script usa el $ spitshell variable, y no es
algo de lo que sabemos ... todavía. Si examina el archivo del glosario, verá que
esta es una variable conocida por metaconfiguración. Si hace que este archivo forme parte de su distribución
(incluyéndolo en el archivo MANIFEST.new, volveremos a eso más adelante) y ejecute
metaconfiguración, Entonces el Configurar El script determinará un valor adecuado para esta variable.
y se establecerá en config.sh. Lo mismo vale para $ startsh y el misterioso $ eunicefix at
el fin. En un sistema razonable, la parte relevante de config.sh se vería así:

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

¡Ah! Estamos llegando. Ahora parece familiar. Nos enfrentamos a un solo gato comando cuyo
La entrada proviene de un documento aquí interpolado por variables y cuya salida se redirige a
tamaño pequeño. El valor será el de $ startsh, es decir '#!/ Bin / sh'. Bien hasta ahora.

Luego llegamos a la segunda expansión del documento aquí, para obtener el resto del script. Esta
tiempo, el símbolo del documento aquí está rodeado de comillas simples, por lo que el contenido será
adjunto textualmente al tamaño pequeño Archivo. Entonces, corriendo 'sh intsize.SH', obtenemos el
siguiente salida:

Extrayendo intsize (con sustituciones de variables)

y al mirar el archivo intsize producido, vemos:

#!/ Bin / sh
intsize = '4'
echo "En esta máquina, el tipo int es $ intsize bytes"

que es exactamente lo que teníamos al principio. Hasta ahora, es un procedimiento sin operación ...
Pero, ¡qué maravilloso! Sucede (pura coincidencia, créeme!), Que metaconfiguración sabe
sobre la $ intsize símbolo de concha. Al mover la inicialización de intsize a la variable-
área interpolada del script .SH e inicializándola con el Configurar-valor calculado,
y eliminando los comentarios ahora inútiles agregados por hacer, obtenemos:

caso $ CONFIG en
'')
si prueba -f config.sh; luego TOP = .;
prueba elif -f ../config.sh; luego TOP = ..;
prueba elif -f ../../config.sh; luego TOP = ../ ..;
prueba elif -f ../../../config.sh; luego TOP = ../../ ..;
prueba elif -f ../../../../config.sh; luego TOP = ../../../ ..;
más
echo "No se puede encontrar config.sh."; salida 1
fi
. $ TOP / config.sh
;;
esac
caso "$ 0" en
* / *) cd `expr X $ 0: 'X \ (. * \) /'` ;;
esac
echo "Extrayendo intsize (con sustituciones de variables)"
$ spitshell> intsize <
$ startsh
intsize = '$ intsize'
! Grito! ¡ESTO!

$ spitshell >> intsize << '! NO! SUBS!'
echo "En esta máquina, el tipo int es $ intsize bytes"
! NO! SUBS!
chmod 755 tamaño pequeño
$ eunicefix intsize

Por supuesto, ejecutar este script a través de un shell volverá a generar el mismo script. Pero si
corremos Configurar en una máquina donde un int se almacena como una cantidad de 64 bits, config.sh seguirá
set tamaño pequeño a 8 y el tamaño pequeño El script tendrá el valor correcto y se imprimirá:

En esta máquina, el tipo int es de 8 bytes

cual es correcta. ¡Felicidades! ¡¡Acabamos de configurar un script de shell !!

Produciendo configuración.h
Ahora podemos echar un vistazo a la forma configuración.h se produce a partir de config_h.SH. Lo sabemos
correr Configurar produce un config.sh script (cómo se hace exactamente esto no es estrictamente
relevante aquí, pero para los curiosos, es otra sustitución de documentos aquí dentro
Configurar sí mismo). El config_h.SH sí mismo está construido por metaconfiguración al mismo tiempo
Configurar es decir, siempre que utilice al menos un símbolo C en sus fuentes.

Echemos un vistazo a algunos config_h.SH archivo para ver qué sucede realmente:

caso $ CONFIG en
'')
si prueba -f config.sh; luego TOP = .;
prueba elif -f ../config.sh; luego TOP = ..;
prueba elif -f ../../config.sh; luego TOP = ../ ..;
prueba elif -f ../../../config.sh; luego TOP = ../../ ..;
prueba elif -f ../../../../config.sh; luego TOP = ../../../ ..;
más
echo "No se puede encontrar config.sh."; salida 1
fi
. $ TOP / config.sh
;;
esac
caso "$ 0" en
* / *) cd `expr X $ 0: 'X \ (. * \) /'` ;;
esac
echo "Extrayendo config.h (con sustituciones de variables)"
sed < config.h -e 's! ^ # undef! / define!' -es! ^ # un-def! #undef! '
/*
* Este archivo se generó ejecutando el script config_h.SH, que
* obtiene sus valores de config.sh, que generalmente es producido por
* ejecutando Configure.
*
* Siéntase libre de modificar cualquiera de esto cuando surja la necesidad. Sin embargo, tenga en cuenta
* que ejecutar config.h.SH nuevamente borrará cualquier cambio que haya realizado.
* Para un cambio más permanente, edite config.sh y vuelva a ejecutar config.h.SH.
*/

/ * Tiempo de configuración: $ cf_time
* Configurado por: $ cf_by
* Sistema de destino: $ myuname
*/

#ifndef_config_h_
#definir _config_h_

/ * bcopy:
* Este símbolo está mapeado a memcpy si la rutina bcopy () no es
* disponible para copiar cadenas.
*/
/ * HAS_BCOPY:
* Este símbolo se define si la rutina bcopy () está disponible para
* copiar bloques de memoria. No debe usar este símbolo debajo
* circunstancias normales y use bcopy () directamente en su lugar, que
* se asignará a memcpy () si bcopy no está disponible.
*/
# $ d_bcopy HAS_BCOPY / ** /
#ifndef HAS_BCOPY
#ifdef bcopia
# un-def bcopy
#terminara si
#define bcopy (s, d, l) memcpy ((d), (s), (l)) / * asignado a memcpy * /
#terminara si

/ * HAS_DUP2:
* Este símbolo, si está definido, indica que la rutina dup2 está
* disponible para duplicar descriptores de archivos.
*/
# $ d_dup2 HAS_DUP2 / ** /

/ * I_STRING:
* Este símbolo, si está definido, indica al programa en C que debe
* incluir (Sistemas USG) en lugar de (Sistemas BSD).
*/
# $ i_string I_STRING / ** /

#terminara si
! Grito! ¡ESTO!

En la parte superior del archivo, reconocemos la construcción estándar .SH que ya tenemos
estudiado en detalle. Luego viene la extracción del archivo en sí, a través de un documento aquí con
sustituciones variables. Sin embargo, aquí no usamos un simple gato pero una SED en cambio, ya que
necesitamos hacer algunas ediciones adicionales sobre la marcha. Veremos por qué más adelante, así que olvidemos
sobre eso ahora mismo.

Ahora llegamos al comentario principal, y el archivo está etiquetado con la hora de configuración, el
sistema de destino, etc ... (aquellas variables que provienen del origen config.sh archivo ha sido
establecido por Configurar). Ese encabezado de comentario va seguido de una protección '#ifndef' para proteger
contra múltiples inclusiones de este archivo. Luego viene el corazón del archivo ...

Ayuda saber que $ d_ * y $ i_ * las variables se establecen en 'definir"O"undef'por
Configurar, dependiendo de si una función o un archivo de inclusión está presente en el sistema o
no. Eso significa:

# $ d_bcopy HAS_BCOPY / ** /

La línea se expandirá a:

#define HAS_BCOPY / ** /

si la variable $ d_bcopy se establece en 'definir' o:

#undef HAS_BCOPY / ** /

si $ d_bcopy se estableció en 'undef', porque la función no estaba allí. Sin embargo, eso no es
lo que se escribe en el configuración.h archivo debido a la SED filtro que ya hemos visto,
que transformará la segunda forma en:

/ * # define HAS_BCOPY / ** /

Es un formulario útil para editar posteriormente configuración.h porque solo necesitas quitar el
inicial '/ *' si desea anular Configurarelección de. Asimismo, puede agregar un solo
'/ *' al comienzo de una línea '#define' para evitar la definición de un símbolo en particular.
Esta es la razón por la que cada definición de símbolo está protegida por un '/ ** /' al final, para cerrar el
comentario abierto por '/ *' (los comentarios no están anidados en C).

Ahora transformar '#undef' en '/ * # define' es bueno, pero si queremos escribir un
'#undef', estamos atascados ... a menos que lo escribamos como '# un-def' y dejemos SED arregla eso en '#undef'
mientras produce configuración.h, que es lo que realmente se hace aquí.

El mismo tipo de razonamiento se aplica a esas dos líneas:

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

y asumiendo config.sh define:

d_dup2 = 'definir'
i_string = 'undef'

entraremos en el producido configuración.h:

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

¿Limpio como el agua corriente? ¡Bien!

Ahora debería ser obvio que al incluir configuración.h en todos sus archivos fuente C, puede
saber que Configurar ha adivinado en su sistema. En efecto, al usar esos símbolos,
escribir código C configurado, ya que metaconfiguración sabrá que necesita esos símbolos y
generar un adecuado config_h.SH archivo, así como todo el código necesario en Configurar a
calcular un valor adecuado para ellos (asignando valores a las variables de shell asociadas).

Correr Metaconfiguración
Centrémonos en el metaconfiguración programa durante un tiempo para comprender cómo utiliza sus unidades y
su código fuente para producir todos los archivos de configuración necesarios. Si tiene la intención de escribir nuevo
unidades, debe tener un buen conocimiento de todo el esquema.

Si no hay ningún archivo MANIFEST.new, metaconfiguración intentará utilizar el archivo MANIFEST en su lugar,
por conveniencia. En todas partes mencionamos MANIFEST. Nuevo, puede entenderse como MANIFIESTO
siempre que no se encuentre un archivo MANIFEST.new en la raíz de su paquete.

Suponiendo que su archivo MANIFEST.new está configurado correctamente y enumera todos los archivos fuente que desea
configurar, y que ha ejecutado paquete en su directorio de origen raíz para crear un
.paquete archivo, puede ejecutar metaconfiguración y obtendrás lo siguiente:

$ metaconfiguración
Ubicando unidades ...
Extrayendo listas de dependencia de 312 unidades ...
Extrayendo nombres de archivo (*. [Chyl] y * .SH) de MANIFEST.new ...
Construyendo un archivo Wanted ...
Escaneando archivos. [Chyl] en busca de símbolos ...
Escaneando archivos .SH en busca de símbolos ...
Cálculo del gráfico de dependencia óptima ...
Construyendo un archivo make privado ...
Determinación de las unidades cargables ...
Actualizando archivo make ...
Determinación del orden correcto de las unidades ...
Creando Configurar ...
Hecho.

La primera fase busca todos los archivos de unidades (que terminan con .U) en el directorio público
primero, luego en tu privado. Si copia un archivo público en su directorio U privado
(es decir, un directorio llamado U en el nivel superior de su paquete), anulará el público
versión. Una vez que tiene una lista de todas las unidades disponibles, las analiza y extrae todas
las líneas? MAKE: para conocer las dependencias y los símbolos de shell conocidos. También
se centra en las líneas? H: para aprender sobre los símbolos C y qué símbolos de shell deben ser
calculado para obtener un valor adecuado para ese símbolo C (por lo que tenemos otro nivel de dependencias
aquí).

A continuación, se extraen los nombres de archivo adecuados de los archivos MANIFEST.new y Querido archivo es
construido: ese archivo enumera todos los símbolos de C y los símbolos de shell necesarios para ese paquete. Nosotros
primero escanee los archivos de tipo C en busca de símbolos C, luego propague las dependencias a sus
símbolos de shell asociados (recopilados de las líneas? H:). A continuación, se escanean los archivos .SH y finalmente
se conocen todos los símbolos de la cáscara.

Se crea un Makefile temporal y la metaconfig intenta para lograr todos los símbolos de concha para ver
¿Qué comandos (enumerados en el segundo? MAKE: líneas) se ejecutan y, por lo tanto, qué unidades se
realmente necesario. Las unidades opcionales que no se requieren de otro modo se eliminan y se coloca un segundo Makefile.
generado. En esta ocasión, conocemos todas las unidades y sus respectivos pedidos, opcional
las unidades han sido eliminadas y los valores predeterminados calculados para sus símbolos de caparazón. El
Configurar luego se puede generar el script, junto con config_h.SH. Hemos terminado.

Convenciones
Es necesario seguir las convenciones adecuadas para que todo el proceso sea correcto. Hay un caso
convención para unidades y una convención de nomenclatura de variables.

Todas las unidades deben tener su primera letra en minúscula, a menos que sean unidades especiales. Por
especial, queremos decir que realmente no definen nuevas variables de shell que puedan ser utilizadas por el
usuario en sus archivos .SH, sino más bien unidades que producen scripts o variables de shell que deben
ser utilizado internamente por el Configurar texto. Ejemplos típicos son los Init.U archivo que es
la inicialización de la variable principal, o Milectura.U que produce el mi lectura script usado casi
en todas partes en Configurar cuando se va a formular una pregunta al usuario.

Las unidades no especiales luego se subdividen en dos grupos distintos: unidades que definen variables
asociado a un símbolo C y unidades que definen sus propias variables de shell. El primer grupo
se divide en variables relacionadas con los archivos de inclusión (su nombre comienza con i_) y
variables relacionadas con otras definiciones (el nombre comienza con d_). El segundo grupo tiene
nombres que se representan a sí mismos, por ejemplo cc.u define el $ cc variable de shell cuyo valor es
el compilador de C que se utilizará.

Las unidades especiales a veces se reservan alguna variable predefinida y devuelven "resultados"
en otras variables conocidas. Por ejemplo, el mi lectura guión producido por Myread.U
espera el aviso en $ rp, la respuesta predeterminada en $ dflt y coloca la respuesta del usuario en $ ans.
Esto no está documentado en esta página de manual: debe ir y mirar la unidad en sí para
comprender qué variables se utilizan y cómo se utilizará la unidad.

Usar El Glosario
El archivo de glosario es generado automáticamente por el hacer brillar script, que extrae el
información de las líneas? S :,? C: y? MAKE: y las reformatea en orden alfabético
glosario ordenado. Es importante leer el Glosario para conocer los símbolos que está
permitido usar. Sin embargo, el glosario no le indicará cómo utilizarlos. Por lo general, eso es
Depende de usted.

Un día, probablemente escribirás tus propias unidades y sabrás lo suficiente sobre metaconfiguración
para hacerlo de forma rápida y eficaz. Sin embargo, nunca olvide documentar adecuadamente su trabajo en
las líneas? S: y? C: u otras personas no podrán reutilizarlo. Recuerda el
tiempo en el que solo tenía el glosario y esta página de manual para comenzar.

Conclusión
Ahora que sabes el metaconfiguración conceptos básicos, deberías leer el DESCRIPCIÓN sección, luego
saltar al REFERENCIA sección para conocer todos los detalles sangrientos, como los permitidos
sintaxis para las líneas de control de la unidad (líneas que comienzan con un '?') o los distintos comandos MAKE
se le permite usar.

REFERENCIA

Esta sección documenta los aspectos internos de metaconfiguración, básicamente la sintaxis de la unidad, la especial
unidades que debe conocer y los archivos de sugerencias.

General Unidad Sintaxis
Una unidad de metaconfiguración se divide en dos partes distintas. La sección de encabezado (líneas que comienzan
con '?') y una sección de shell (el código se incluirá en el Configurar texto). Está
es posible agregar comentarios '? X:' en cualquier lugar dentro de la unidad, pero el otro '?' lineas (tambien
, que son control líneas) tienen una política de pedidos estricta.

Si una línea de control es demasiado larga, es posible utilizar una continuación escapando del final
nueva línea con una barra invertida y continuando en la siguiente línea (que luego debe tener sangría
por espacios o tabulaciones).

La siguiente es una descripción formal de cada una de las líneas de control. A menos que se indique
de lo contrario, el orden de esta presentación es el orden que se utilizará dentro de la unidad.

? RCS: gratuita, texto
Se utilizará para comentarios RCS, en la parte superior de la unidad.

?X: cualquier texto
Comentarios de propósito general. Puede aparecer en cualquier lugar de la unidad, pero debe dejarse justificado.
Para comentarios de RCS, utilice el formulario de comentarios? RCS :.

?FABRICAR:símbolo lista: dependencia lista [+ opcional]
Esta es la primera línea de dependencia. La primera símbolo lista debería enumerar todos los símbolos
construido por esta unidad (es decir, cuyo valor es calculado por la sección de carcasa de la unidad).
Los símbolos deben estar separados por espacios. Si un símbolo definido es solo para uso interno y
no debe aparecer en el generado config.sh archivo, debe ir precedido de un
'+' (no debe confundirse con las dependencias opcionales definidas a continuación). El segundo
parte de la lista (después del medio ':') es la dependencia de la unidad. Debería enumerar todo
las unidades especiales necesarias, así como todos los símbolos utilizados por el shell
implementación. Si un símbolo está integrado pero su valor de configuración no es crítico,
puede ir precedido de un '+', en cuyo caso se denomina dependencia condicional: su
la unidad correspondiente se cargará si, y solo si, ese símbolo es realmente
querido; de lo contrario, se utilizará el valor predeterminado.

?FABRICAR:de la pestaña. comando
Puede haber una o más líneas de comando siguiendo las líneas de dependencia iniciales. Aquellos
Los comandos se ejecutarán cuando la unidad desee cargarlos en Configurar. Vea
el párrafo sobre comandos de creación para obtener más información. Tenga en cuenta que el líder de la pestaña.
se requiere el carácter antes de la comando.

? Y:diseño
Declare una directiva de diseño para esta unidad. Esa directiva puede ser una de las cadenas
parte superior, tu préstamo estudiantil or fondo (el caso no importa, el estilo recomendado es deletrearlos
en mayúsculas). Si se omite, tu préstamo estudiantil se supone.

Esta directiva solo es necesaria si desea forzar una unidad en la parte superior o inferior
de lo generado Configurar script, según lo permitan las dependencias de la unidad. Importante
Por tanto, las preguntas pueden ser forzadas al principio. Dentro de la misma clase de diseño, las unidades
se ordenan alfabéticamente con dos casos especiales para las unidades d_ * e i_ *, forzado
respectivamente en la parte superior e inferior de sus clases (pero estos deben pertenecer a la
clase predeterminada).

Si fuerza en la parte superior una unidad cuyas dependencias requieren que todas las demás unidades
precederlo, no logras nada interesante. Por tanto, esta directiva debería
utilizarse para aumentar la prioridad de algunas unidades interactivas que no dependen de muchas
otros símbolos visibles para el usuario, como preguntas relacionadas con la ruta.

?S:símbolo_nombre [(obsoleto símbolo lista)]:
Introduce un símbolo de concha. Esta primera línea nombra el símbolo, seguido opcionalmente por un
lista encerrada entre paréntesis y dando el equivalente obsoleto. Los obsoletos
los símbolos se reasignarán al nuevo símbolo_nombre si el -o se da la opción a
metaconfiguración.

?S:cualquier texto, para Glosario
Básicamente un comentario que describe el símbolo de la cáscara, que será extraído por hacer brillar
en el archivo Glosario.

?S:. Cierra el comentario del símbolo de shell.

?C:símbolo_nombre [~ alias] [(obsoleto símbolo lista)]:
Introduce un nuevo símbolo C. El alias nombre es el nombre bajo el cual el símbolo C
ser controlado, es decir, si el alias se desea el símbolo, entonces ese símbolo C se escribirá
existentes config_h.SH Archivo. Por lo general, el alias es solo '% <' (representa el nombre de la unidad)
y también hay una línea? W: mapeando un símbolo C al alias. También las partes relevantes
de las líneas? H: están explícitamente protegidas por una condición '?% <'. Ver el símbolo
párrafo de aliasing para más detalles. El resto de la línea es el opcional
obsoleto símbolo lista, que enumera los equivalentes antiguos del nuevo símbolo_nombre.

?C:cualquier texto, para Glosario y config_h.SH
Básicamente un comentario que describe el símbolo C, que será extraído por hacer brillar
en el archivo Glosario y por metaconfiguración en el config_h.SH archivo si el símbolo es
deseado (o si se desea su alias cuando se usa el alias de símbolo).

?C:. Cierra el comentario del símbolo C.

? H :?símbolo:config_h.SH cosas
Esta es la solicitud de inclusión general en config_h.SH. La línea solo se escribe cuando
la guardia símbolo es realmente querido. Esta forma general es necesaria cuando el símbolo C
se utilizó aliasing. De lo contrario, si utiliza uno de los otros formularios "estándar", el
la protección se realiza automáticamente por metaconfiguración misma.

? H: #$ d_var VAR "$ var"
Define condicionalmente el VAR Símbolo C en $ var cuando se establece en 'definir'. Implica un
'?VAR: 'condición de protección, y metaconfiguración enlaces automáticamente VAR a sus dos conchas
dependencias variables (es decir, ambas $ d_var y $ var será marcado como deseado if VAR is
utilizado en fuentes C).

? H: #define VAR [opcional texto]
Siempre define el VAR Símbolo C a algún valor. Implica un '?VAR: 'condición de protección.
Se realiza una dependencia automática de shell a la propia unidad.

? H: #define VAR (x, y, z) $ var
Siempre define la macro VAR ser el valor de la $ var variable. Depende de la
unidad para asegurar $ var tiene un valor sensato. Una dependencia automática entre el C
macro VAR y la variable de shell está establecida, y toda la línea está protegida por un
implícito '?VAR: '.

? H: #$ d_var VAR
Define condicionalmente VAR if $ d_var se establece en 'definir'. Implica un '?VAR: 'custodiando
condición. Se genera una dependencia de shell automática hacia $ d_war.

? H: #define VAR "$ var"
Asigna un valor configurado al VAR Símbolo C. Implica un '?VAR: 'condición de gurading.
Se genera una dependencia de shell automática para vincular VAR y $ var.

? H :. Cierra el config_h.SH solicitudes de inclusión.

?METRO:C símbolo: C dependencias
Introduce una definición mágica sobre el símbolo C, por confmagic.h, y define el
símbolo de protección para el resto? M: definiciones. Esta línea implica silenciosamente
'? W:% <:C símbolo', es decir, la unidad se cargará en Configurar si aparece el símbolo C
dentro de las fuentes C, ya sea que se use magia o no. Las dependencias C están activadas
cuando se usa magia, para forzar su definición en config_h.SH. Sin embargo, si
la magia es no utilizado, pero el símbolo C aparece en la fuente sin la C necesaria
dependencias, se le advertirá cada vez que se compile el archivo Wanted, ya que puede ser
un problema de portabilidad (y también porque la unidad se carga incondicionalmente en
Configurar siempre que se utilice el símbolo C, independientemente del otro? C: líneas del
unidad).

?METRO:cpp defensas
Define el mapeo cpp mágico que se introducirá en confmagic.h siempre que el
se utiliza el símbolo. Hay un implícito '?sym'cuidando donde sym es el nombre del símbolo
definido por la línea? M: inicial.

?METRO:. Cierra el confmagic.h solicitud de inclusión.

? W:shell símbolo lista:C símbolo lista
Vincula el destino de los símbolos de caparazón con el de los símbolos C: si alguno de los C
los símbolos enumerados son deseados, entonces todos los símbolos de shell se marcan como deseados. Útil para
forzar la inclusión de una unidad (lista de símbolos de shell establecida en '% <') cuando la presencia de C
se detecta el símbolo. La lista de símbolos de concha puede dejarse vacía, para beneficiarse del lado
efecto de la ubicación del símbolo C dentro del preprocesador incorporado (el símbolo es se define
para ese preprocesador si se encuentra en la fuente). Para buscar patrones con un espacio
en ellos, debe citar los símbolos C entre comillas simples, como en 'struct
zona horaria'.

? V:sólo lectura símbolos:lectura-escritura símbolos
Esto es una metalint sugerencia y debe usarse solo en unidades especiales que exportan algún shell
variables. Las variables antes del medio ':' se exportan como de solo lectura (cambiándolas
emitirá una advertencia), mientras que otros símbolos se pueden leer y cambiar libremente.

?F:archivos creado
Esta línea tiene dos propósitos: es un metalint sugerencia, y también un marcador de posición para
futuras jmake usar. Debe enumerar tres tipos de archivos: el temporal que son
creado para una prueba, los UU privados creados en el directorio UU para más tarde
detenidamente, y los públicos que quedan en el directorio raíz del paquete. Temporal
los archivos deben estar listados con un '!' carácter (que significa "¡no! no se reutilizan
¡más tarde! "), los archivos UU privados deben estar precedidos por un './' (que significa: para usarlos, digamos
./expediente, No sólo presentar), y los públicos deben nombrarse tal cual.

? T:shell temporales
Otra metalint insinuación. Esta línea enumera todas las variables de shell utilizadas como temporales
dentro de la sección de carcasa de esta unidad.

?D:símbolo='propuesta de'
Valor de inicialización para símbolos utilizados como dependencias condicionales. Si no? D: la línea es
encontrado, en su lugar se utiliza un valor nulo. El metalint El programa le advertirá si un
El símbolo se usa al menos una vez como una dependencia condicional y no tiene un
? D: inicialización. Es una buena práctica agregar esas líneas incluso para un nulo
inicialización, ya que enfatiza la naturaleza posiblemente opcional de un símbolo.

? O:cualquier mensaje Usted quieres
Esta directiva indica que esta unidad está obsoleta en su conjunto. Siempre que el uso de cualquier
de sus símbolos (o uso indirecto a través de dependencias), el mensaje se emite en
la pantalla (en stderr). Puede poner una o más líneas, en cuyo caso cada línea
imprimirse, en orden.

?HILAS:metalint consejos
Consulte las metalint página de manual para una explicación de las distintas sugerencias que se pueden
usado.

?EN ESO:inicialización código
El código de inicialización especificado por esta línea se cargará en la parte superior de la
Configurar script siempre que se necesite la unidad.

C Símbolo Aliasing
A veces no es posible confiar en metaconfiguraciónpropia selección predeterminada para config_h.SH
comentarios y definición del símbolo C. Ahí es donde entra en juego el aliasing. Ya que es bastante
difícil de explicar, estudiaremos un ejemplo para comprender el mecanismo subyacente.

La unidad d_const.U intenta determinar si su compilador de C conoce o no la const
palabra clave. Si no es así, queremos reasignar esa palabra clave a una cadena nula, para permitir que el
compilar el programa. Además, queremos activar automáticamente la prueba cuando el const por el temor
se utiliza.

Aquí están las partes relevantes de la unidad d_const.U:

? MAKE: d_const: cat cc ccflags Setvar
? HACER: -elija agregar $ @%
? S: d_const:
? S: Esta variable define condicionalmente el símbolo HASCONST, que
? S: indica al programa en C que este compilador de C conoce la
? S: tipo const.
?S:.
? C: HASCONST ~% <:
? C: Este símbolo, si se define, indica que este compilador de C conoce
? C: el tipo constante. No hay necesidad de probar ese símbolo.
? C: dentro de sus programas. El mero uso de la palabra clave "const"
? C: activar las pruebas necesarias.
?C:.
? H:?% <: # $ D_const HASCONST / ** /
? H:?% <: # Ifndef HASCONST
? H:?% <: # Define const
? H:?% <: # Endif
? H :.
? W:% <: const
? LINT: establecer d_const
? LINT: const conocida
: compruebe la palabra clave const
eco " "
echo 'Comprobando para ver si su compilador de C sabe acerca de "const" ...'> & 4
/ papelera / gato > const.c << 'EOCP'
principal()
{
const char * foo;
}
EOCP
if $ cc -c $ ccflags const.c> / dev / null 2> & 1; entonces
val = "$ definir"
echo "Sí, lo hace".
más
val = "$ undef"
echo "No, no lo hace".
fi
establecer d_const
eval $ setvar

Primero notamos el uso de una línea? W:, que básicamente dice: "Esta unidad es deseada cuando el
const la palabra clave se utiliza en un archivo C. ". Para reasignar condicionalmente const a un nulo
encadenar configuración.h, Elegí definir condicionalmente HASCONST vía $ d_const.

Sin embargo, esto plantea un problema, porque el HASCONST El símbolo no se utilizará en el
fuentes, solo las const token es. ¿Y la línea? H: definiendo HASCONST es implícitamente
guardado por '? HASCONST'. Por lo tanto, debemos agregar la restricción explícita '?% <' Para decir
metaconfiguración que esas líneas deben incluirse en config_h.SH siempre que el símbolo '% <'
se busca (% <se refiere al nombre de la unidad, aquí d_const).

Eso es casi perfecto, porque la línea? W: querrá d_const cuando const se usa, entonces
las líneas? H: se incluirán en el config_h.SH Archivo. Sin embargo, el comentario principal (? C:
líneas) adjunto a HASCONST en sí mismo también está protegido a través de HASCONST, es decir, tiene un implícito
Restricción '? HASCONST'. De ahí la necesidad de aliasing las HASCONST símbolo a '% <'.

La parte restante de la unidad (la parte de la carcasa) es realmente sencilla. Es simplemente
intenta compilar un programa de muestra en C usando el const palabra clave. Si puede, entonces lo hará
definir $ d_const mediante el $ setvar función (definida por el Setvar.U unidad). Ver el párrafo
sobre unidades especiales para más detalles.

Haz Comandos
En la línea de comando? MAKE :, puede escribir un comando de shell para que se ejecute tal cual o
especial -recoger comando que está atrapado por metaconfiguración y analizado para ver lo que debería ser
hecho. El '-' principal solo está ahí para prevenir para lograr de fallar cuando el comando regresa
un estado distinto de cero - no es realmente necesario ya que usamos 'para lograr -n'para resolver el
dependencias, pero le aconsejo que lo guarde en caso de que sea obligatorio en versiones futuras.
La sintaxis del recoger comando es:

-recoger cmd $@ archivo de destino

donde $@ es la macro estándar dentro de Makefiles que representa el objetivo actual (el nombre
de la unidad que se está construyendo, con la extensión .U final despojada). El cmd parte es la
real metaconfiguración comando a ejecutar, y el archivo de destino es otro parámetro más, cuyo
La interpretación depende de la cmd sí mismo. También tiene su extensión .U final despojada y
normalmente se refiere a un archivo de unidad, a menos que comience con './' en cuyo caso hace referencia a uno
de las metaconfiguración archivos de control en el '.MONTE directorio.

Los comandos disponibles son:

agregar Agrega el archivo de destino a Configurar.

agregar.Config_sh
Rellena esa parte de Configurar produciendo el config.sh Archivo. Solo usado
se agregan variables, las condicionales (de dependencias condicionales) son
omitido.

add.Null Agrega la sección que inicializa todas las variables de shell utilizadas en una cadena vacía.

c_h_weed Produce el config_h.SH Archivo. Solo se imprimen las líneas necesarias.

cm_h_weed Produce el confmagic.h Archivo. Solo se imprimen las líneas necesarias. Esta
El comando solo está habilitado cuando el -M se da el interruptor, o cuando un confmagic.h presentar
ya existe.

cerrar.Config_sh
Agrega el símbolo 'EOT' final en una línea para terminar el documento aquí
constructo que produce el config.sh archivo.

anteponer Antepone el contenido del destino al archivo de destino si ese archivo no está vacío.

weed Agrega la unidad a Configurar como el add comando, pero haga algunas pruebas adicionales
para eliminar el '?símbolo' y '%símbolo'líneas del archivo de destino si el simbolo
no se desea ni se desea condicionalmente. La forma '%' solo se usa internamente por
metaconfiguración mientras produce sus propios archivos .U en el '.MONTE'directorio.

limpiar Igual que add realmente, pero realiza una sustitución de macro adicional. El
macros disponibles se describen en el Cableado Macros párrafo.

Como nota al margen, metaconfiguración genera un segundo comando internamente para tratar con condicional
dependencias. No debe usarlo usted mismo, pero lo verá si escanea el
generado Makefile existentes .MONTE directorio.

Cableado Macros
Las siguientes macros son reconocidas por el limpiar comando y sustituido antes de la inclusión en
Configurar:

El número de revisión base del paquete, derivado de .paquete.

La fecha actual.


La dirección de correo electrónico del mantenedor de este paquete, derivada de su
.paquete.


El nombre del paquete, derivado de su .paquete archivo.


El nivel de parche del metaconfiguración programa (en desuso a favor de ).


El nivel de revisión SVN del metaconfiguración .

El número de versión del metaconfiguración .

Estas macros se utilizan principalmente para identificar metaconfiguración versión que generó un
particular Configurar script y para qué paquete se hizo. La dirección de correo electrónico del
mantenedor está integrado en las instrucciones principales que Configurar imprime al comenzar.

Entradas recientes metaconfiguración las versiones comprenden una sintaxis mucho más general de la forma:

<$ variable>

que se reemplaza en el momento de la generación de configuración por el valor de variable tomado de tu
.paquete Archivo. Eventualmente, el antiguo formato de macro cableado desaparecerá y <$ baserev>
reemplazará en todas las unidades suministradas.

Especiales Unidades
Las siguientes unidades especiales se utilizan para factorizar el código y proporcionar un nivel superior
funcionalidades. Producen un script de shell que se puede obtener o un shell
variable que puede ser eval'ed. El paso de parámetros se realiza a través de variables conocidas, ya sea
con nombre o anónimo como $ 1, $ 2, etc. (que se puede configurar fácilmente a través del shell set
operador). Cuándo Configurar ejecuta, crea y entra en un UU directorio, por lo que cada
El script producido se encuentra allí y no interfiere con los archivos de su paquete.

Aquí están las unidades especiales que debe conocer y la forma de usarlas.

Cppsym.U
Esta unidad produce un script de shell llamado cppsym, que se puede utilizar para determinar
si algún símbolo en una lista está definido por el preprocesador de C o el compilador de C que tiene
especificado. Puede determinar el estado de cualquier símbolo, aunque los símbolos en
(lista de atributos) se determinan más fácilmente.

Csym.U
Esto establece la variable de shell $ csym, utilizada internamente por Configurar para comprobar si un
dado el símbolo C está definido o no. Un uso típico es:

establecer resultado de símbolo [-fva] [anterior]
eval $ csym

Eso establecerá el resultado variable a 'verdadero' si la función [-f], variable [-v] o
array [-a] está definido, 'falso' en caso contrario. Si se da un valor anterior y el -r
se proporcionó interruptor a Configurar (Véase el Configurar Opciones párrafo), entonces eso
El valor se reutiliza sin cuestionarlo.

La forma en que se realiza este cálculo depende de la respuesta que el usuario dé a la pregunta.
Configurar le preguntará si debe realizar una nm extracción o no. Si el
Se realizó la extracción, la unidad simplemente mira a través de la lista de símbolos, de lo contrario
realiza una prueba de enlace de compilación, a menos que -r fue dado para reutilizar el calculado previamente
valor, naturalmente ...

Fin.U
Al copiar esta unidad en su U directorio y agregando dependencias en el
? MAKE: line, puede forzar la carga de una unidad dada en Configurar incluso si no es
de lo contrario deseado. Algunas unidades solo pueden ser forzadas a Configurar de esa manera.

Fileexp.U
Esta unidad produce un script de shell fileexp que expandirá los nombres de archivo que comienzan con
tildes. Un uso típico es:

exp_name = `. / filexp $ nombre`

para asignar el nombre de archivo expandido en nombre_exp.

Findhdr.U
Esta unidad produce un encontrarhdr script que se utiliza para localizar los archivos de encabezado en
$ usrinc u otros lugares extraños que utilizan capacidades de cpp. El guión se le da una
incluya el nombre base del archivo como 'stdio.h' o 'sys / file.h' y devuelve la ruta completa de
el archivo incluido y un estado cero si se encuentra, o una cadena vacía y un estado distinto de cero
si no se pudo localizar el archivo.

Obtener archivo.U
Esta unidad produce un poco de código de shell que debe obtenerse para obtener un archivo
nombrar y hacer algunas comprobaciones de cordura. Opcionalmente, se realiza una expansión de ~ nombre.

Para usar esta unidad, $ rp y $ dflt debe contener la pregunta y la respuesta predeterminada, que
se pasará tal cual a la mi lectura guión (ver de próxima publicación Milectura.U). La $ fn
variable controla la operación y el resultado se devuelve a $ ans.

Para ubicar un archivo o directorio, ponga 'f' o 'd' en f ~ /. Si aparece un '~', entonces ~ nombre
se permite la sustitución. Si aparece una '/', solo se aceptan nombres de ruta absolutos y
~ Las sustituciones de nombres siempre se expanden antes de regresar. Si se especifica '+',
se omiten las comprobaciones de existencia. Si aparece 'n' dentro $ fn, entonces el usuario puede
responda 'ninguno'.

Por lo general, a menos que haya solicitado la portabilidad, ~ la sustitución de nombre se produce cuando se solicita.
Sin embargo, hay ocasiones en las que desea evitar la portabilidad y forzar la
sustitución. Puede usar la letra 'e' (expandir) para hacer eso.

Si se usa el tipo especial 'l' (ubicar), entonces el $ fn la variable debe terminar con un ':',
seguido de un nombre de base de archivo. Si la respuesta es un directorio, el nombre base del archivo será
adjunto antes de probar la existencia del archivo. Esto es útil en preguntas de estilo de localización.
Me gusta esto:

dflt = '~ noticias / lib'
: no es necesario especificar 'd' o 'f' cuando se usa 'l'
fn = 'l ~: activo'
rp = '¿Dónde está el archivo activo?'
. ./Obtener el archivo
active = "$ ans"

Además, la letra 'p' (ruta) se puede usar junto con 'l' para indicar
Obtener el archivo que una respuesta sin una '/' debe aceptarse, asumiendo que será
estar en el PATH de todos en el momento en que se necesite este valor.

También es útil la posibilidad de especificar una lista de respuestas que deben aceptarse.
palabra por palabra, pasando por alto todos los controles. Esta lista debe estar entre paréntesis y elementos
deben estar separados por comas, sin espacios entrelazados. No olvide citar el
cadena resultante, ya que los paréntesis son significativos para el shell. Por ejemplo:

dflt = '/ bin / install'
fn = '/ fe ~ (instalar,. / instalar)'
rp = '¿Qué programa de instalación usa?'
. ./Obtener el archivo
install = "$ ans"

permitiría que el usuario solo especifique rutas completamente calificadas que se refieran a archivos existentes,
pero aún permita las respuestas especiales "instalar" y "./instalar" tal cual (asumiendo que
Por supuesto, algo se ocupará de ellos especialmente más adelante en la cadena, ya que lo hacen
no se ajusta al marco general esperado).

Si la respuesta a la pregunta es 'ninguna', entonces se omiten las comprobaciones de existencia y
se devuelve la cadena vacía. Tenga en cuenta que desde Obtener el archivo llamadas mi lectura internamente, todo
las funciones disponibles con mi lectura aplicar aquí a.

Si se necesita un valor completamente expandido (por ejemplo, en un Makefile), puede usar
las $ ansexp variable que siempre está configurada correctamente por Obtener el archivo como el expandido
versión de $ ans. Por supuesto, no se expandirá ~ name si no lo permitiste en el
primer lugar en el $ fn variable.

Inhdr.U
Esta unidad produce el $ inhdr variable de shell, utilizada internamente por Configurar verificar
si existe un conjunto de encabezados o no. Un uso típico es:

establecer encabezado i_header [header2 i_header2 ...]
eval $ inhdr

Eso imprimirá un mensaje, diciendo si el encabezado se encontró o no y establecerá el
i_encabezado variable en consecuencia. Si se especifica más de un encabezado y el primero
no se encuentra el encabezado, intentamos el siguiente, hasta que la lista esté vacía o se encuentre uno.

Inlibc.U
Esta unidad produce el $ inlibc variable de shell, utilizada internamente por Configurar verificar
si una función C dada está definida o no. Un uso típico es:

establecer la función d_func
eval $ inlibc

Eso imprimirá un mensaje, diciendo si la función se encontró o no y se configuró
$ d_func respectivamente. Internamente, utilizó el $ csym rutina.

Loc.U
Esta importante unidad produce un script de shell loc que se puede utilizar para averiguar dónde
en una lista de directorios se encuentra un archivo determinado. El primer argumento especifica el archivo a
ubicarse, el segundo argumento es lo que se devolverá si la búsqueda falla, y el
Los argumentos de reevaluación son una lista de directorios donde se buscará el archivo. Para
ejemplo:

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

establecería $ dflt a X si no enviarcorreo.cf el archivo se encontró en los directorios enumerados,
o algo así como /usr/lib/sendmail.cf en algunos sistemas. Ver también Obtener archivo.U.

CorreoAutor.U
Esta unidad debe incluirse en la línea? MAKE: de su propio End.U privado para hacer
en Configurar. Ofrece al usuario registrarse al autor, opcionalmente
recibir notificaciones cuando lleguen nuevos parches o recibirlos automáticamente cuando se publiquen.
Necesitas instalar agente de correo para hacer esto (al menos la versión 3.0).

Lista de correo.U
Esta unidad debe incluirse en la línea? MAKE: de su propio End.U privado para hacer
en Configurar. Ofrece al usuario suscribirse o darse de baja a una lista de correo.
donde se está llevando a cabo la discusión relacionada con el paquete. Necesitas correr empacar
y responda las preguntas relacionadas con la lista de correo para configurar las variables adecuadas en su
.paquete antes de que esta unidad entre en funcionamiento.

Myinit.U
Copie esta unidad en su privado U directorio para agregar sus propios valores predeterminados a algunos
variables internas. Esta unidad se carga en Configurar después de todo lo predeterminado
Se han realizado las inicializaciones.

Milectura.U
Esta unidad produce el mi lectura script de shell que debe obtenerse para realizar una
leer. Permite escapes de shell, asignación predeterminada y evaluación de parámetros, como
documentado en la unidad Instruct.U. También permite la configuración dinámica de la -d opción,
que se utilizará para el resto de la ejecución del script.

Para usar esta unidad, $ rp debe contener la pregunta y $ dflt debe contener el valor predeterminado
respuesta. La pregunta será impresa por el propio script y se devuelve el resultado.
existentes $ ans variable.

Aquí hay un uso típico:

dflt = 'y'
rp = 'Pregunta?'
. ./milectura
valor = "$ ans"

Consulte la unidad en sí para obtener más información.

Oldconfig.U
¿Esta unidad debe ser parte de su dependencia? MAKE: line cuando algunas de sus unidades lo intentan
para reutilizar un valor de símbolo antiguo. Esta unidad es responsable de obtener las respuestas anteriores.
en config.sh o proporcionar sugerencias útiles cuando se ejecuta en una plataforma determinada para el
primera vez. Ver el Configurar Sugerencias párrafo para obtener más información sobre sugerencias.

Prefijo.U
El propósito de esta unidad es detectar cambios en el directorio de prefijo de instalación para
volver a calcular automáticamente los valores predeterminados adecuados de las respuestas anteriores. Se basa en el
valor de la $ prefijo antiguo variable que contiene el directorio de prefijo anterior cuando
cambiado, y está vacío en caso contrario. Por ejemplo, si el prefijo se cambió de / opt a
/ usr / local, entonces el directorio de instalación binario anterior se cambiará de
/ opt / bin a / usr / local / bin, o permanecerá sin cambios si fuera, digamos, /compartimiento.

Necesitas llamar set antes de emitir un eval on $ prefixit, como:

establecer dflt var [dir]
eval $ prefijo

que establecería $ dflt a $ var or $ prefijo / dir dependiendo de si el prefijo se mantuvo
lo mismo o no. Si dir es la cuerda ninguna, un valor de espacio único en $ dflt se mantiene como-
es, incluso cuando cambia el prefijo. Si dir se omite, entonces $ dflt se establece en un vacío
cadena si el prefijo cambió, a $ var de otra manera.

Prefixup.U
La intención de esta unidad es similar a la de Prefixit.U, es decir, ayuda a arreglar el
cadena predeterminada para adaptarse a los cambios de prefijo. Sin embargo, la variable de shell $ prefijo,
cuando se evalúa, solo restaurará ~ expansiones de nombres, si el prefijo usa tal escape
mecanismo. Úselo como:

establecer dflt
eval $ prefijo

antes de preguntar a través de Obtener el archivo por ejemplo. Si el prefijo no utiliza ~ nombre
expansión, entonces lo anterior será una operación no en el y variable, naturalmente.

Typedef.U
Esta unidad produce el $ typedef variable de shell, utilizada internamente por Configurar verificar
si existe un typedef o no. Un uso típico es:

establecer typedef val_t predeterminado [incluye]
eval $ typedef

Esto establecerá la variable valor_t al valor de tu préstamo estudiantil si no se encontró el typedef
entre los archivos de inclusión enumerados, o para typedef si se encuentra. Si no hay archivos de inclusión
especificado, la unidad se ve en solo. Si especifica algunos incluye, solo
esos se miran.

Unix.U
El propósito de esta unidad es definir algunos de los UNIX-isms más comunes a través de variables
que se puede modificar desde la línea de comandos o mediante archivos de sugerencias adecuados. En particular,
$ _exe, $ _o y $ _a se establecen. Todas las unidades deben referirse a $ _o y no a .o .
El '.' es parte de estas variables.

Setvar.U
Esta unidad produce la variable, que es utilizada internamente por Configurar establecer un
definir/ undef valor a un símbolo dado, emitiendo una advertencia cuando cambia repentinamente
de un valor anterior. Por ejemplo:

val = "$ definir"
establecer d_variable
eval $ setvar

Si el anterior $ d_variable el valor no era nulo y $ val es diferente, un "whoa"
se emite una advertencia.

Whoa.U
Esta unidad produce el Whoa script, que emite una advertencia cuando el propuesta de en variable
cuyo nombre es $ var no es el mismo que su antiguo valor anterior mantenido en $ era. Sobre
regreso, $ td y $ tu mantener el valor adecuado para definir or undef La variable. Ver
ejemplos en Inlibc.U.

incorporado Preprocesador
Cada unidad que se incluirá en Configurar se ejecuta a través de un preprocesador incorporado. Pre-
Las sentencias del procesador son introducidas por el carácter '@' ('#' es el comentario del shell
personaje). Funciona simplemente como lo hace el preprocesador de C, pero permite shell y perl
escapa. Estas son las funciones disponibles:

@Si expresión
If expresión es verdadero, continúe cargando código hasta @end, @elsif o @else.

@elsif expresión
Opción alternativa. Si expresión es cierto, continúe cargando código hasta @end,
otro @elsif o @else.

@else Código predeterminado que se cargará si el @if expresión era falso y ninguno de los
@elsif opcional emparejado. Cargar hasta el final.

@end Cierra la declaración de carga condicional abierta por @if.

@definir símbolo
Le dice al preprocesador que símbolo se define a partir de ahora.

El condicional expresión puede incluir nombres de símbolos (el valor es verdadero si se desea el símbolo o
definido a través de @definir o escapes de shell / perl. Esos átomos se pueden combinar usando el
operadores booleanos tradicionales '!' para negación, '&&' para lógico y, y '||' por lógica
o.

El texto encerrado entre corchetes simples es una prueba de shell, mientras que el texto entre corchetes dobles es
una prueba de perl. A saber, las expresiones:

{ shell texto }
{{ perl texto }}

se traducen a:

if shell texto > / dev / null 2> & 1; luego salga 0; de lo contrario, salga 1; fi
if (perl texto) {salida 0;} más {salida 1;}

y el estado de salida se usa de la manera estándar para obtener un valor booleano, es decir, 0 es verdadero y
todo lo demás es falso. Tenga en cuenta que solo las condiciones simples se pueden expresar en perl, hasta
se puede cargar un código complejo dentro de metaconfiguración y ejecutado

El preprocesador incorporado se puede utilizar para ajustar con precisión algunas unidades (consulte d_gethname.U para agendar una
ejemplo complejo) dependiendo de los símbolos realmente utilizados por el programa o los archivos
presente en la distribución. Por ejemplo, el Oldconfig.U usa una prueba como:

@if {prueba -d ../hints}

y Configurar contendrá código dependiente de la pista solo si hay un consejos directorio en el
directorio de nivel superior del paquete. Tenga en cuenta que las pruebas se ejecutan desde el '.MONTE'directorio,
de ahí el "../" necesario en la prueba.

El preprocesador también se puede utilizar para evitar poner código inútil cuando un símbolo no está
definido. Las unidades que definen más de un símbolo se pueden proteger de esa manera (ya que la unidad es
cargado como un todo) mediante la recopilación de código dependiente del símbolo dentro de un par @ if / @ end. Para
ejemplo:

@si YO_TIEMPO || I_SYS_TIME || I_SYS_TIME_KERNEL
need_time_h = 'verdadero'
@demás
need_time_h = 'falso'
@fin

probará si el código fuente hace algún uso de uno de los tres símbolos que controlan
las tiempo.h or sys / time.h inclusión y defina el símbolo de la cáscara en consecuencia. Eso da
Configurar una retroalimentación sobre lo que necesitan las fuentes y evitar el inconveniente de haber arreglado
Unidades congeladas.

A través de las líneas '? W:', puede obtener combinaciones interesantes. Por ejemplo, el i_time.U unidad
necesita saber si las fuentes de C hacen uso de la struct zona horaria escribe. Por lo tanto,
la línea:

? W :: zona horaria

se utiliza por su efecto secundario de definir el símbolo zona horaria para el preprocesador. El
el código de la unidad puede decir entonces:

@if zona horaria
para s_timezone en '-DS_TIMEZONE' ''; hacer
@demás
s_timezone = ''
@fin

... código usando s_timezone ...

@if zona horaria
hecho
@fin

y tener un ciclo extra probando dos valores sucesivos para el s_zona horaria variable, pero solo
si es necesario.

Obsoleto Símbolos
Los símbolos obsoletos se conservan para facilitar la transición con metaconfiguración unidades. A no ser que
las -o se pasa el interruptor a metaconfiguración serán ignorados. Sin embargo, un Obsoleto archivo será
generarse, indicándole qué archivos están haciendo uso de esos símbolos obsoletos y qué
son los nuevos símbolos que se utilizarán.

La vida útil de los símbolos obsoletos es una revisión completa, es decir, se eliminarán cuando
se emite la siguiente revisión base (las actualizaciones de parches no cuentan, por supuesto). Por tanto, es
Es prudente traducir sus fuentes y comenzar a usar los nuevos símbolos lo antes posible.

Configurar Sugerencias
Puede suceder que la lógica de configuración interna tome decisiones incorrectas. Para
ejemplo, en alguna plataforma, el vfork () La llamada al sistema está presente pero rota, por lo que debería
no ser utilizado. No es posible incluir ese conocimiento en las propias unidades, porque
que podría ser un problema temporal que el proveedor eventualmente solucionará, o algo que
fue introducido por una nueva actualización del sistema operativo.

De todos modos, para todos esos pequeños problemas que son demasiado específicos del sistema, metaconfiguración
proporciona soporte para archivos de pistas. Para usarlo, necesita crear un consejos directorio en el
directorio de nivel superior del paquete, y téngalo cuando ejecute metaconfiguración. Eso cargará el
parte relacionada con la pista de Oldconfig.U.

A partir de ese momento, puede preestablecer algunas de las variables de shell Configurar utiliza en un sistema operativo específico
Archivo .sh. Hay un código en Oldconfig.U que intenta adivinar qué archivos de pistas son necesarios para
calcular un nombre estándar basado en el nombre del sistema operativo del sistema, el nombre del kernel, la versión
número, etc ... Dado que es probable que esta información cambie rápidamente, no la estoy documentando
aquí. Tienes que aplicar ingeniería inversa al código de Oldconfig.U.

Cuando lanza su paquete por primera vez, su directorio de archivos de sugerencias debe estar vacío. Si el
los usuarios de su paquete se quejan de que tienen problemas con Configurar valores predeterminados en un
sistema particular, tiene que ver si se trata de un problema específico de la plataforma o un
uno general. En el primer caso, es hora de introducir un nuevo archivo de sugerencias, mientras que en el
En último lugar, conviene revisar la unidad correspondiente.

Por ejemplo, se sabe que los sistemas SGI tienen un vfork () llamada al sistema, a partir de este
escribiendo. Y el nombre del archivo de sugerencia correspondiente es sgi.sh. Entonces todo lo que necesitas hacer es crear
a sugerencias / sgi.sh archivo en el que escribe:

d_vfork = "$ definir"

que siempre se reasignará horquilla on tenedor (consulta: d_vfork.U). Cuando se ejecuta en sistemas SGI para
primera vez, Configurar detectará que hay un sugerencias / sgi.sh archivo, y que estamos en
una máquina IRIX (el nombre del núcleo es a menudo / irix), por lo que propondrá sgi como herramienta de edición del
posible pista. Si el usuario lo acepta, y dado que el $ d_vfork El valor se modifica mediante el
$ setvar llamar, un whoa! se emitirá para advertir que estamos a punto de anular el valor
calculado por Configurar.

Tenga en cuenta que no tiene que proporcionar todos las pistas conocidas por Oldconfig.U. Si un archivo de sugerencia es
faltante, no se propondrá como una posible opción. Las pruebas heurísticas se ejecutaron para calcular
los posibles candidatos a pistas son inusuales. Si tiene nuevos valores o pruebas diferentes, por favor
mándamelas ...

Primordial CHOICES
Si crea un config.over archivo en el directorio de nivel superior, Configurar te preguntará si tu
desea cargarlo para anular los valores predeterminados. Esto se hace antes de la creación del
config.sh archivo, por lo que le da la oportunidad de parchear los valores almacenados allí.

Esto es distinto del enfoque de sugerencias en que es un archivo local, que el usuario es
libre de crear para su propio uso. No debe proporcionar ese archivo usted mismo, pero deje que el
el usuario conoce esta posibilidad.

Configurar Opciones
El Configurar El script puede ser llamado con algunas opciones especificadas en la línea de comando, para
modificar ligeramente su comportamiento. Estas son las opciones permitidas:

-d Utilice valores predeterminados para todas las respuestas.

-e Continuar sin cuestionar más allá de la producción de config.sh.

-f presentar Utilice el archivo especificado como configuración predeterminada. Si este interruptor no se usa,
la configuración se toma de config.sh, cuando está presente.

-h Imprima el mensaje de ayuda y salga.

-r Reutilice el valor de los símbolos C si es posible. Esto evitará los costosos nm símbolo
extracción. Si se usa por primera vez (sin un archivo de configuración anterior),
Configurar intentará compilar y vincular un pequeño programa para conocer
la presencia o ausencia de un símbolo.

-s Modo silencioso. Solo las cadenas impresas en el descriptor de archivo # 4 se verán en el
pantalla (esos son los mensajes importantes). No es posible apagar completamente
cualquier salida, pero puede usar 'Configurar -ders > / dev / null 2> y 1'tener un completo
ejecución por lotes sin salida y sin necesidad de interacción del usuario.

-D símbolo = valor
Predefine símbolo para llevar el especificado propuesta de. También es posible utilizar '-D
símbolo'que utilizará un valor predeterminado de' definir '.

-E Deténgase al final de las preguntas de configuración, después de haber producido un
config.sh. Esto no realizará ningún 'para lograr depender'o extracción de archivos .SH.

-K Usuario informado. Cuando usa esta opción, sabe lo que está haciendo y
Por lo tanto, los config.sh El archivo siempre se manejará como si estuviera destinado a ser
reutilizado, a pesar de que podría haber sido generado en un sistema alienígena. También
evita abortar cuando Configurar detecta un compilador de C inutilizable o un conjunto incorrecto
de banderas C. Esta opción también puede activar más atajos en el
futuro. Esta opción está documentada en el Configurar mensaje de uso, para recordarnos
acerca de su existencia, pero se espera que la descripción dada sea lo suficientemente críptica.
:-)

-O Permitir valores especificados mediante un -D or -U para anular la configuración de cualquier cargado
archivo de configuración. Este no es el comportamiento predeterminado ya que la anulación
no se propague a variables derivadas de las que está modificando actualmente.
Naturalmente, sin -O, la configuración solo se realiza cuando no hay ningún archivo de configuración
cargado, lo cual es seguro ya que las variables derivadas aún no se han calculado ...

-S Realice la sustitución de variables en todos los archivos .SH. Puedes combinarlo con el
-f cambie para propagar cualquier configuración que desee.

-U símbolo =
Preajustes símbolo para tener un valor vacío. También es posible utilizar '-U símbolo'
que establecerá símbolo a 'undef'.

-V Imprima el número de versión del metaconfiguración que generó esto Configurar guión
y salir

Correr Entorno
Al comenzar, Configurar crea un local UU directorio y se ejecuta desde allí. El directorio
se elimina cuando Configure termina, pero esto significa que debe ejecutar el script desde un lugar donde
puede escribir, es decir, no desde un sistema de archivos de solo lectura.

Tu puedes correr Configurar aunque de forma remota, como en:

../paquete/Configurar

para configurar fuentes que no están presentes localmente. Todos los archivos generados se colocarán en
el directorio desde donde está ejecutando el script. Esta magia se hace gracias al src.U
unidad, que está configurando el $ src y $ rsrc variables para apuntar a las fuentes del paquete. Ese
La ruta es completa o relativa, dependiendo de si Configurar fue invocado a través de un completo o
camino relativo.

Desde dentro del UU subdirectorio, puede utilizar $ rsrc para acceder a los archivos fuente (unidades
referirse a los archivos de origen, las sugerencias de enlace siempre deben usar este mecanismo y no asumir la
archivo está presente en el directorio principal). Todos los Makefiles deben usar la variable $ src
como un puntero a las fuentes desde la parte superior del directorio de compilación (donde Configurar se ejecuta),
ya sea directamente o mediante un ajuste VPATH.

Cuando se ejecuta Configurar de forma remota, los archivos .SH se extraen en el directorio de compilación, no
en el árbol de origen. Sin embargo, requiere algún tipo de para lograr soporte para poder compilar
cosas en un directorio de compilación, mientras que las fuentes se encuentran en otra parte.

Usar Simétrica Redefiniciones
Haciendo uso de la -M cambiar, algunas reasignaciones mágicas pueden tener lugar dentro de un confmagic.h
Archivo. Ese archivo debe incluirse después configuración.h, por supuesto, pero también después de todo el
otros archivos de inclusión necesarios. A saber:

#include "config.h"
...
... otros inclusiones ...
...
#include "confmagic.h"

Típicamente, confmagic.h intentará reasignar bcopy () on memcpy () si no bcopy () is
disponible localmente, o transformar horquilla dentro tenedor cuando sea necesario, por lo que es inútil
preocuparse por el HAS_VFORK símbolo.

Esta magia de configuración está documentada en el archivo Glosario.

Unidad Plantillas
Hay un conjunto de plantillas de unidades en el metaconfiguración directorio de origen, que están destinados a
ser utilizado por un programa (aún no escrito) para producir rápidamente nuevas unidades para varios tipos de
situaciones. No hay documentación para este proyecto inacabado, pero pensé en mencionarlo.
en la página del manual en caso de que desee hacerlo usted mismo y luego contribuir ...

AUTORES

Larry Wall[email protected]> para la versión 2.0.
Harlan Stenn[email protected]> para extensiones importantes de la unidad.
Rafael Manfredi[email protected]>.
Muchos otros colaboradores de la metaconfiguración unidades. Consulte el archivo de crédito para obtener una lista.

Use metaconfig en línea usando los servicios de onworks.net