makepp_command: en línea en la nube

PROGRAMA:

NOMBRE

makepp - Sintaxis de la línea de comandos para makepp

DESCRIPCIÓN

?: - ?, A: -UN,
--archivo de argumentos,
- archivo de argumentos,
--asume-nuevo,
- supuesto mayor, B: -B,
--construir-caché,
- verificación de construcción,
- método de verificación de construcción, C: -VS,
-C, D: - diferir-incluir,
--directorio,
--hacer construir,
--no construir,
--no leer,
- leer,
- corrida en seco,
--dump-makefile,
--dump-makeppfile, E: -mi,
- anulaciones del medio ambiente,
--env-anulaciones, F: -F,
-F,
--expediente,
--solo-reglas-finales,
--forzar-copiar-desde-bc,
- force-recan, G: --crédulo, H: -h,
--ayuda,
--híbrido,
--recursión híbrida,
- marca-recursiva-híbrida, I: -YO,
--carga-implícita-solo-makeppfile,
--incluir,
--incluir-dir,
--en-caja de arena,
- caja de arena interior, J: -j,
--trabajos,
- solo imprimir, K: -k,
--sigue adelante, L: - reglas-de-última-oportunidad,
--cargar-makefile,
--cargar-makeppfile,
--Iniciar sesión,
--archivo de registro,
--círculo, M: -metro,
--makefile,
$ MAKEFLAGS,
$ MAKEPP_CASE_SENSITIVE_FILENAMES,
--makeppfile,
$ MAKEPPFLAGS,
--md5-bc,
--md5-verificar-bc, N: -norte,
--archivo nuevo,
--no-reglas-integradas,
--no-cache-scaninfos,
- sin carga implícita,
--sin registro,
--no-rutas-ejecutables-dependencias,
--no-ruta-exe-dep,
--no-poblar-bc,
--no-directorio-de-impresión,
--no-remake-makefiles,
--no advertir, O: -Oh,
- archivo antiguo,
--fuera de la caja de arena,
--override-firma,
- método de anulación de firma, P: --poblar-bc-solo,
--perfil, Q: --tranquilo, R: -R,
-r,
--reconocimiento,
- eliminar-rancio,
- eliminar-archivos-obsoletos,
--repositorio,
--rm-rancio,
- directorio raíz,
--directorio raíz, S: -s,
--salvadera,
--sandbox-advertir,
- advertencia de caja de arena,
--firma,
- método de firma,
--silencio,
--parada,
- parada después de la carga,
--parada antes de la construcción,
- parada en carrera,
- carrera de parada,
--enlace simbólico en representante como archivo,
--enlace simbólico-en-repositorio-como-archivo, T: --tradicional,
--recursión-tradicional,
- marca-recursiva-tradicional, V: -V,
-v,
--verboso,
--versión,
- caja de arena virtual, W: -W,
--Y si

hacer pp [ opción ...] [ VAR = valor ] [ dirigidos ...]

mpp [ opción ...] [ VAR = valor ] [ dirigidos ...]

Makepp admite la mayoría de las opciones de línea de comandos y la sintaxis que otros hacen compatibles. los
los guiones entre las palabras son siempre opcionales y también se pueden reemplazar por un guión bajo.
Especifica una lista de objetivos para construir en la línea de comando. Si no especifica ninguna
objetivos, se construye el primer objetivo explícito en el archivo MAKE.

Puede asignar variables en la línea de comando que anularán cualquier asignación o
variable de entorno en cada Makefile cargado, por ejemplo,

makepp CFLAGS = -O2

Las opciones válidas son la mayoría de las opciones de marca estándar, además de algunas nuevas:

-A nombre de archivo
--args-file =nombre de archivo
--archivo-de-argumentos =nombre de archivo
Lea el archivo y analícelo como posiblemente entre comillas, espacios en blanco y / o separados por saltos de línea
.

-b directorio
--build-cache =directorio
Especifica la ruta a un caché de compilación. Consulte makepp_build_cache para obtener más detalles. La construcción
el caché ya debe existir; consulte "Cómo administrar un caché de compilación" en makepp_build_cache para
cómo hacerlo en primer lugar. Las memorias caché definidas en la línea de comandos pueden
anulado por una declaración build_cache en un archivo MAKE o un modificador de regla: build_cache.
Si trabaja con varias compilaciones diferentes, puede ser útil configurar el entorno
variable "MAKEPPFLAGS" para contener "--buil" "d-cache = / path / to / build / cache" para que todos
de sus compilaciones aprovecharán la caché de compilación de forma predeterminada.

--build-check =Método
--build-check-method =Método
El nombre de un método de verificación de compilación que se utilizará para decidir si es necesario reconstruir los archivos.
Los valores posibles son "target_newer", "exact_match". Consulte makepp_build_check para
información sobre métodos de verificación de compilación.

-C directorio
--directory =directorio
Cd al directorio dado antes de cargar el archivo MAKE e intentar construir los destinos.
Esto es similar a especificar un directorio con "-F", excepto que la subsecuente "-C",
Las opciones "-f", "-F", "-I" y "-R" se interpretan en relación con el nuevo directorio,
en lugar del antiguo.

-c
--root-dir
--directorio raíz
Cd hasta el directorio que contiene un RootMakeppfile.

- diferir-incluir
Solución alternativa para la declaración de inclusión antes de la regla que crea el archivo de inclusión. Esta
sucede al pretender que las declaraciones de inclusión son las últimas en el archivo MAKE. De esa manera el
Incluir declaración es ejecutable, pero las anulaciones o modificaciones de variables aún pueden
fallar, en cuyo caso debe establecer los problemáticos en la línea de comando (mientras que
gmake ignora cualquier configuración de variable del archivo de inclusión que pueda influir en cómo
el archivo en sí se construye).

--dont-build =nombre de archivo
--do-build =nombre de archivo
No cree el archivo especificado o, si es un directorio, todo lo que hay debajo, incluso
aunque makepp cree que debería - o construye, anulando la especificación opuesta
desde un directorio superior. Esto es útil si creó un archivo específico a mano usando
diferentes opciones de compilación. Sin esta opción, si compila un módulo a mano
y luego ejecute makepp para compilar el resto del programa, makepp también recompilará el
módulo compilado a mano, porque makepp no ​​puede garantizar que la compilación sea correcta
si alguno de los archivos no se creó bajo su control. Con esta opción, le dices
makepp que realmente sabe lo que está haciendo en el caso de este archivo en particular y
prometes que está bien no reconstruirlo.

Por ejemplo,

% cc -g -DSPECIAL_DEBUG -c xc -o xo # Compilación especial a mano
% maquillaje
cc -g -O2 -c xc -o xo # ¡Makepp acaba de anular su compilación aquí!
cc xo yo -o my_program # Vuelve a vincular.
% cc -g -DSPECIAL_DEBUG -c xc -o xo # Hazlo de nuevo.
% makepp --dont-build xo # Dile a makepp que no reconstruya xo incluso si así lo desea.
cc xo yo -o my_program # Ahora se vuelve a vincular sin volver a compilar.

Si desea opciones de compilación especiales para un solo módulo, a menudo es más fácil de editar
el archivo MAKE que compilar a mano como en este ejemplo; consulte "Objetivo específico
asignaciones "en makepp_variables para una manera fácil de hacer esto.

Si pones un RootMakeppfile (.mk) en la raíz de su sistema de compilación, ese directorio y
todo lo que se encuentra debajo de él predeterminado es "--do-build", mientras que la raíz general de su archivo
el sistema predeterminado es "--dont-build". De esa forma, todo dentro de su sistema de compilación es
construido (si es necesario) pero no se intenta nada afuera. Si, en este escenario, desea
partes externas para que siempre se construyan según sea necesario, debe recogerlas explícitamente con
Declaraciones "load_makefile" en uno de los archivos MAKE dentro de su árbol.

Puede tener uno RootMakeppfile (.mk) cada uno, en árboles de construcción separados, y serán
cargado si un árbol tiene dependencias en otro. Pero no se te permite tener
RootMakeppfile (.mk) en directorios anidados, evitando efectos divertidos que tienden a surgir
cuando llama accidentalmente a "makepp --repository" de nuevo en un subdirectorio. Estas
los efectos incluyen reglas duplicadas a través de fuentes duplicadas o caché de compilación eterna
reimporta porque los archivos en caché tienen las firmas correctas pero el relativo incorrecto
caminos

Reemplaza "--dont-build" para el archivo o directorio especificado. Si tienes un
RootMakeppfile (.mk) en la raíz de su sistema de compilación, pero desea que makepp compile
algo fuera de su sistema de compilación solo por esta vez, debe marcarlo explícitamente como
"--do-construir". Si especifica "--do-build" para un archivo o directorio en un
RootMakeppfile (.mk), sin "--dont-build" para un directorio superior, luego la raíz (y
todo lo demás debajo de él) de su sistema de compilación por defecto es "--dont-build".

Para resolver conflictos entre "--dont-build" y "--do-build", el que tiene más
la ruta específica tiene prioridad independientemente del orden. Si se especifica la misma ruta
tanto con "--dont-build" como con "--do-build", gana el de la derecha.

Las opciones "--dont-build" y "--do-build" pueden ser peligrosas si se equivocan
sugerencias para makepp, ya que le está pidiendo a makepp que no realice las comprobaciones que necesita para garantizar una
construcción correcta. Pero dado que permiten reducir en gran medida el número de controles, pueden
Acelere dramáticamente sus compilaciones, como se explica en métodos de aceleración potencialmente inseguros.

--dont-read =nombre de archivo
--do-read =nombre de archivo
No lea el archivo especificado o, si es un directorio, todo lo que hay debajo, o
lea, anulando la especificación opuesta de un directorio superior. Generar un
error en lugar de leer archivos marcados como "--dont-read". Ver --sandbox. El sistema de archivos
root siempre tiene como valor predeterminado legible.

--dump-makefile =nombre de archivo
--dump-makeppfile =nombre de archivo
Volcar el contenido sin procesar de los archivos MAKE para el directorio actual (según lo determinado por
la posición de esta opción en relación con cualquier opción "-C") para nombre de archivo. Incluir archivos
se interpolan, los comentarios se eliminan y los "ifdef" se resuelven. "# línea
Los marcadores de "archivo" "se insertan según sea necesario. El valor final de cualquier
Los escalares en el paquete del archivo MAKE se imprimen siguiendo el archivo MAKE.

Esto es útil para depurar, pero (actualmente) no necesariamente podrá usar el
dump como un archivo MAKE equivalente, por ejemplo, porque contiene tanto el archivo include
declaración y el archivo interpolado.

-e
--env-anula
--ambiente-anulaciones
Hace que las variables del entorno anulen las definiciones en el archivo MAKE. Por
predeterminado, las asignaciones dentro del archivo MAKE anulan los valores de las variables que se importan
del medio ambiente

-F Archivo Makepp
--makeppfile =Archivo Makepp
Carga el Makefile especificado o, si especifica un directorio, el Makefile en esto,
en lugar del que está en el directorio actual: cualquier objetivo especificado a la derecha de
esta opción se interpreta en relación con el directorio que contiene el Makefile. Para el
detalles del caso del directorio y Archivo RootMakepp ver la explicación en el siguiente
.

Esta opción puede resultar útil si ejecuta makepp desde directorios impredecibles. Para
ejemplo, si compila desde emacs y tiene fuentes esparcidas por todo su
árbol de directorios, el directorio de trabajo actual para el comando de compilación será el
directorio en el que estaba el último archivo de origen que editó, que puede ser o no el superior
directorio de nivel para su compilación. Sin embargo, puede especificar su compilación
comando como

makepp -F / su / fuente / dir / top

y esto funcionará sin importar cuál sea su directorio actual.

Debido a que esta opción no afecta al directorio con respecto al cual "-C" subsiguiente,
Se especifican las opciones "-f", "-F", "-I" y "-R", puede hacer objetivos relativos a la
directorio actual como este:

makepp -F / foo / bar -C. mi objetivo

-f Makefile
--file =Makefile
--makefile =Makefile
Carga el Makefile especificado o, si especifica un directorio, el Makefile en esto,
en lugar del que está en el directorio actual. Si no especifica la opción "-f" o
la opción "-F", makepp busca primero un archivo en el directorio actual (o el
directorio especificado por la opción "-C" más a la derecha, si corresponde) llamado, entonces
RootMakeppfile.mk, Archivo Makepp, entonces Makeppfile.mk, entonces makefile, entonces Makefile.
Se pueden especificar varias opciones "-F" y "-f".

Los primeros dos (Archivo RootMakepp) son especiales (ya sea que se den explícitamente o se encuentren
implícitamente). Debe haber como máximo uno de esos dos en cualquier árbol de construcción dado en el que
makepp es operar. Pero puede haber varios si construye varios árboles separados en
Uno va. Esos dos se buscan no solo en el directorio antes mencionado, sino también
hacia arriba desde allí. Si se encuentra uno, se carga antes que cualquier otro.

--solo-reglas-finales
Ignore las dependencias y los objetivos implícitos de la regla, a menos que el objetivo sea falso.

--forzar-copiar-desde-bc
Cuando use memorias caché de compilación, siempre copie archivos dentro y fuera de la memoria caché, incluso si el origen
y el destino están en el mismo sistema de archivos. Esto es principalmente útil para probar (emular)
el caso en el que no lo son.

--forzar-rescanear
No utilice los resultados del análisis en caché de ejecuciones anteriores.

--crédulo
Cree que las reglas crean lo que declaran, en lugar de verificar. Este es
más rápido, pero no detecta errores en las reglas.

-?
-h
--ayuda
Imprima un breve resumen de las opciones.

--híbrido
--recursión híbrida
--Híbrido-recursivo-make
Esta opción está presente para permitir que makepp funcione con archivos MAKE antiguos que usan recursivo
hacer extensivamente, especialmente multiplicar en el mismo directorio. Por defecto, marca recursiva
es implementado por un subproceso que se comunica con el proceso padre; la construcción es
hecho realmente por el proceso padre. Esto permite algunas de las características agradables de makepp como
repositorios para trabajar con invocaciones de make recursivas. Sin embargo, esta técnica
no funciona si carga más de un archivo MAKE desde el mismo directorio. En ese caso
esta opción dice que se vuelva a iniciar otra instancia independiente de makepp. Si
esto falla, intente "--traditional-recursive-make".

Si usa esta opción, obtendrá archivos de registro en cada directorio de la reserva.
ocurrió en. Para deshacerse de ellos solo use "makeppclean --logs --recurse" o "mppc
-lr ".

-I directorio
--include =directorio
--include-dir =directorio
Busque en el directorio dado los archivos MAKE incluidos.

--carga-implícita-solo-makeppfile
Si la carga implícita de archivos MAKE está habilitada, cargue automáticamente solo un archivo
, que son Archivo RootMakepp, RootMakeppfile.mk, Archivo Makeppo Makeppfile.mky no
makefile or Makefile. Esto es útil si makepp tiene dependencias generadas por
algún otro tipo de make, y makepp no ​​puede leer los archivos MAKE de ese tipo en general.
(Desea evitar esta situación si es posible, pero tiende a surgir mientras está en
el proceso de portar un sistema de compilación heredado a makepp.) Esto no tiene ningún efecto si
la carga implícita está deshabilitada.

-j n
--jobs =n
Interpreta el argumento n como el número de comandos de shell que se pueden ejecutar en
paralelo. De forma predeterminada, makepp no ​​ejecuta comandos en paralelo.

A diferencia de otras versiones de make, cuando los trabajos se ejecutan en paralelo, makepp dirige
su salida a un archivo y solo muestra la salida cuando los comandos han finalizado.
Esto evita que la salida de varios comandos diferentes se mezclen en el
pantalla, pero significa que es posible que deba esperar un poco más para ver la
salida, y los mensajes stderr aparecerán normalmente antes de las cosas stdout, a diferencia de
salida terminal.

Perls nativos de Windows (es decir, Strawberry y ActiveState), porque no admiten
el paradigma de bifurcación / ejecutivo de Unix, no permita esta opción (¡Cygwin funciona bien!). Como un
reemplazo parcial, puede usar la opción --sandbox allí, aunque esto es mucho menos
cómoda.

-k
--sigue adelante
Cree tantos archivos como sea posible de forma segura, incluso si algunos comandos tienen errores. Por
predeterminado, makepp se detiene cuando encuentra el primer error, incluso si hay otros
archivos que deben construirse y que no dependen del archivo erróneo.

--las-reglas-de-la-última-oportunidad
Active el manejo especial limitado para las reglas de patrones con '%' solo en el lado objetivo.
Esto es necesario porque normalmente, a diferencia de las marcas tradicionales, makepp instancia todas las
reglas con todos los archivos disponibles de abajo hacia arriba, lo que le permite encontrar todos los creables
dependencias.

--load-makefile =Makefile
--load-makeppfile =Makefile
Carga el archivo MAKE especificado antes cualquier otro archivo MAKE, excepto Archivo RootMakeppo
RootMakeppfile.mk por encima de él, pero no considere esta opción a los efectos de
determinar el objetivo predeterminado. Si no se especifica ningún otro archivo MAKE, se busca uno
utilizando las reglas habituales. Si el archivo MAKE especificado es el mismo archivo MAKE que se encuentra
utilizando las reglas habituales, esta opción no tiene ningún efecto.

--log =nombre de archivo de registro
--log-file =nombre de archivo de registro
Cambia el nombre del archivo de registro por el nombre indicado. De forma predeterminada, el archivo de registro es
, que son .makepp / log. Este archivo se puede leer con makepplog, mppl.

--círculo
--parada
--parada antes de la construcción
- detener después de la carga
Makepp se detendrá repetidamente (se irá a dormir), antes de analizar y compilar
cualquier cosa, para que lo despiertes cuando estés listo. Te dirá algunos comandos para
elige entre para despertarlo de nuevo. Si lo hace en un Shell, obtendrá el mensaje y
a continuación, puede anteponerlo o ponerlo en segundo plano. Si lo hace dentro de un IDE, simplemente dormirá y
puedes despertarlo desde otro Shell. Dependiendo de donde lo empieces, cerrando eso
La ventana puede o no terminar makepp, así que verifique cómo hacer frente a esto en su
ambiente.

La intención es que puedas iniciar makepp de esta manera antes de terminar de editar
algunos archivos. Dependiendo de la estructura y el tamaño de su proyecto, esto puede permitir que makepp
obtenga una ventaja inicial de muchos segundos de trabajo cuando haya terminado. Entonces cada
puede editar más y volver a activarlo, a menos que cambie algo en su
Makefile, que pasará desapercibido hasta que inicie una nueva instancia de makepp. Lo mismo
se aplica a los repositorios, que nunca deben cambiar mientras se ejecuta makepp.

Si usa "prebuild" o "$ (make)", en la primera ronda se detendrá cuando llegue a
ese punto.

-m Método
--firma =Método
--signature-method =Método
Especifica el método de firma predeterminado que se utilizará para las reglas que no tienen la
Modificador ": firma" en archivos MAKE que no tienen una declaración de "firma". Lo hace
no anular la elección hecha por analizadores de comandos, por ejemplo, compiladores C / C ++. Posible
los valores son "md5", "C" o "c_compilation_md5", "xml" y "xml-space". Para más
detalles, consulte makepp_signatures.

--md5-bc
--md5-verificar-bc
Al importar desde un caché de compilación, rechace los objetivos almacenados en caché a menos que MD5_SUM esté presente
y coincide con el objetivo importado. Al llenar un caché de compilación, calcule y almacene
MD5_SUM en la información de compilación si aún no está allí. Esto es más lento y conduce a
más reconstrucciones, pero garantiza que los objetivos importados y los archivos de información de compilación se correspondan
exactamente.

-n
- corrida en seco
- solo imprimir
--reconocimiento
Imprima comandos sin ejecutarlos realmente, de manera poco confiable donde los comandos dependen
sobre resultados anteriores. Esto le permite ver lo que hará makepp, sin realmente
cambiar cualquier archivo.

Más precisamente, makepp ejecuta todos los comandos make recursivos de forma normal (pero con suerte
no se está usando cualquier parte recursiva maquillaje!). Otros comandos son simplemente imprimen sin
ser ejecutado. Incluso los comandos que tienen el prefijo "@" o "noecho" se imprimen
después de quitar la "@" o "noecho". Sin embargo, los comandos con el prefijo "+" deben
ser ejecutados, pero actualmente no lo son.

Advertencia: Los comandos que ejecuta makepp con "-n" no son necesariamente los mismos
lo que hará sin "-n". Las firmas de archivos no cambian en absoluto con "-n", que
significa que makepp no ​​puede realizar exactamente las mismas pruebas de compilación que hace cuando el
las firmas están cambiando. En ocasiones, esto marcará la diferencia si está utilizando
Firmas MD5 (que es el valor predeterminado para los comandos de compilación) o si tiene shell
comandos que pueden cambiar o no la fecha.

Por ejemplo, suponga que genera una .h archivo a través de algún tipo de preprocesador. Esta
puede suceder de muchas formas diferentes. Para concreción, suponga que automáticamente
generar una lista de prototipos para las funciones definidas en cada módulo C (ver
<http://cproto.sourceforge.net/> para saber cómo funciona la aplicación "cproto" o
<http://www.lemoda.net/c/cfunctions/> para funciones similares).

prototypes.h: * .c
cproto $ (CPPFLAGS) $ (entradas)> $ (salida)

Entonces cada .c el archivo incluirá prototipos.h. El propósito de esto es mantener la
reenviar declaraciones para todas las funciones automáticamente, por lo que si cambia una función
firma o agrega una nueva función, nunca tienes que presentar o extern
declaraciones en cualquier lugar. Ni siquiera tiene que declarar la dependencia de sus archivos .o
en este, makepp verá la declaración de inclusión y verá automáticamente si necesita
para (re) ejecutar cproto.

Ahora suponga que cambia solo uno .c expediente. ¿Qué sucede cuando ejecutas makepp con "-n"?
en este caso es que se da cuenta de que prototipos.h necesita ser rehecho. En todo
probabilidad, rehacer prototipos.h no afectará a su firma: el contenido del archivo
probablemente sea idéntico porque no se han cambiado los argumentos de la función, por lo que la mayoría de los
tiempo, nada que dependa de prototipos.h en realidad tiene que volver a compilarse. Pero makepp
no lo sabe a menos que realmente se le permita ejecutar los comandos. Entonces asume
que todo lo que depende de prototipos.h también tendrá que volver a compilarse. Así en
este ejemplo, cambiando uno .c archivo hará que "makepp -n" piense que cada
.c el archivo debe recompilarse, aunque lo más probable es que el comando makepp normal
en realidad no ejecutará todos esos comandos.

Esta situación no es tan común y solo puede ocurrir si (a) usa una firma
método que depende del contenido del archivo en lugar de la fecha, como la compilación predeterminada
el método de firma lo hace, o (b) si tiene comandos de shell que no siempre cambian el
fecha. Por ejemplo, con una implementación tradicional de make que solo mira las fechas
en lugar de firmas de archivos, a veces la gente escribe comandos como este:

prototypes.h: $ (comodín * .c) # Técnica pirateada no necesaria para makepp
cproto $ (CPPFLAGS) $ (entradas)> junk.h
si cmp -s basura.h prototipos.h; entonces
rm chatarra.h;
más
mv basura.h prototipos.h;
fi

Por lo tanto, si volver a ejecutar cproto en todos los archivos produce exactamente el mismo contenido de archivo, el
la fecha del archivo no se actualiza. Esto tendrá exactamente el mismo problema que el anterior.
ejemplo con "makepp -n": no se sabe si la fecha en prototipos.h cambios
a menos que el comando se ejecute realmente, por lo que "makepp -n" no puede ser 100% exacto.
(Tenga en cuenta que el uso del tradicional "make -n" también tendrá exactamente el mismo problema en
este ejemplo.)

"makepp -n" siempre debería imprimir más comandos que una invocación normal de makepp,
no menos. Si imprime menos comandos, significa que makepp no ​​conoce
cierta dependencia; algún archivo está cambiando que no espera cambiar en base a
de lo que sabe acerca de los archivos a los que afecta cada regla. Esto significa que su archivo MAKE
tiene un error.

--no-cache-scaninfos
No registre los resultados del escaneo, lo que obligará a que se vuelva a realizar la próxima vez que makepp
carreras.

- sin carga implícita
No cargue automáticamente los archivos MAKE de los directorios a los que se hace referencia (consulte "Carga implícita"
en makepp_build_algorithm). De forma predeterminada, makepp carga automáticamente un archivo MAKE desde
cualquier directorio que contenga una dependencia de algún objetivo que necesite construir, y desde
cualquier directorio escaneado por un comodín. A veces, sin embargo, esto causa una
problema, ya que los archivos MAKE deben cargarse con diferentes variables de línea de comando o
opciones, y si se cargan implícitamente antes de que se carguen explícitamente por un
invocación recursiva de make o la declaración "load_makefile", makepp aborta con un
error. También puede desactivar la carga de archivos MAKE directorio por directorio mediante
usando la instrucción "no_implicit_load" en uno de sus archivos MAKE.

--sin registro
No se moleste en escribir una descripción detallada de lo que se hizo en el archivo de registro. Por
Por defecto, makepp escribe una explicación de cada archivo que intentó construir, y
por qué lo construyó o no, a un archivo llamado .makepp / log, legible con
makepplog, MPPL. Esto puede ser extremadamente valiosa para la depuración de un archivo MAKE - makepp
le dice lo que pensó que eran todas las dependencias, y cuál (s) pensó (s)
cambió. Sin embargo, requiere un poco más de tiempo de CPU y es posible que no quiera molestarse.

--no-ruta-exe-dep
--no-rutas-ejecutables-dependencias
No agregue dependencias implícitas en ejecutables recogidos de la búsqueda de comandos
sendero. Si se especifica esta opción, makepp asume que cualquier ejecutable cuyo
El comportamiento puede cambiar con una nueva versión se especificará con un nombre que contenga un
barra oblicua.

Esto es útil para programas como grep y diff, que siempre hacen básicamente lo mismo
algo incluso si cambia su implementación, aunque es mejor usar el
comandos para grep. También puede necesitarlo para repositorios en clústeres NFS, donde el
Es posible que los mismos comandos no tengan la misma marca de tiempo en todas partes, lo que
se reconstruye dependiendo de la máquina en la que trabaje alguien.

--no-poblar-bc
No llene la caché de compilación, pero aún así importe desde ella cuando sea posible. Este es
útil cuando el entorno puede hacer que los objetivos se generen de manera diferente, pero
makepp no ​​conoce tales dependencias. También es útil para evitar golpear el
caché de la estructura con un gran número de escritores concurrentes que podrían interferir con uno
otra.

--no-directorio-de-impresión
Desactive la entrada o salida de mensajes de directorio.

--no-remake-makefiles
Normalmente, makepp carga cada archivo MAKE en, luego mira para ver si hay una regla
que especifica cómo actualizar el archivo MAKE. Si lo hay, y el archivo MAKE debe ser
reconstruido, se ejecuta el comando y se vuelve a leer el archivo MAKE. Esto a menudo causa
problemas con los archivos MAKE producidos para la utilidad make estándar de Unix, porque (en mi
experiencia) a menudo las reglas de creación para actualizar los archivos MAKE son inexactas:
omite con frecuencia los objetivos que se modifican. Esto puede hacer que makepp rehaga muchos
archivos innecesariamente. A menudo, puede resolver este problema simplemente evitando makepp
de actualizar el archivo MAKE automáticamente (pero debe recordar actualizarlo
mano).

--no advertir
No imprima ningún mensaje de advertencia en stderr, solo en el archivo de registro. La mayoría de los mensajes de advertencia
se tratan de construcciones que puede ver en los archivos MAKE heredados que makepp considera
peligroso, pero algunos de ellos se refieren a posibles errores en su archivo MAKE.

-o nombre de archivo
--assume-old =nombre de archivo
--old-file =nombre de archivo
Finge que el archivo especificado no ha cambiado, incluso si lo ha hecho. Cualquier objetivo que
dependen de este archivo no se reconstruirán debido a este archivo, aunque pueden ser
reconstruido si alguna otra dependencia también ha cambiado. El archivo en sí puede o no
ser reconstruido, dependiendo de si está desactualizado con respecto a sus dependencias.
(Para evitar eso, use "--dont-build".)

--override-signature =Método
--override-signature-method =Método
Igual que "--signature-method", pero incluso anula la elección realizada por los analizadores de comandos.

--out-of-sandbox =nombre de archivo
Genere un error en lugar de escribir archivos fuera de la "caja de arena". Como --no construir,
las rutas más específicas anulan las rutas menos específicas. La raíz del sistema de archivos por defecto es
out-of-sandbox si hay alguna opción "--sandbox".

El propósito de la caja de arena es permitir que múltiples procesos makepp concurrentes para
operar en partes separadas del sistema de archivos. Para que esto funcione de manera confiable,
Los sandboxes concurrentes no deben superponerse, y cada proceso debe marcar el sandbox de cada
otro proceso makepp concurrente para --dont-read. Ver particionamiento en sandboxes.

--poblar-bc-solo
No importe desde el caché de compilación. Esto es útil cuando desea donar objetivos a
el caché, pero no desea confiar en el contenido del caché (por ejemplo, para la misión-
compilaciones críticas).

--perfil
Imprima marcas de tiempo sin procesar antes y después de cada acción.

-R directorio
--repository =directorio
Especifique el directorio dado como repositorio (consulte makepp_repositories para obtener más detalles).
Los repositorios se agregan en el orden especificado en la línea de comando, por lo que el primero
que especifique tiene prioridad. Todos los archivos del directorio (y todos sus subdirectorios)
están vinculados automáticamente al directorio actual (y subdirectorios) si están
necesario.

Si solo especifica un directorio después de "-R", su contenido se vincula al actual
directorio. Puede vincular su contenido en cualquier lugar arbitrario en el sistema de archivos mediante
especificar la ubicación antes de un signo igual, por ejemplo,
"-R subdir1 / subdir2 = / users / joe / joes_nifty_library".

-r
--no-reglas-integradas
No cargue los conjuntos de reglas predeterminados. Si no se especifica esta opción y la variable
"makepp_no_builtin" no está definido en el archivo MAKE, entonces un conjunto de reglas para compilar
El código C, C ++ y Fortran se carga para cada directorio.

--rm-rancio
- eliminar-rancio
--eliminar-archivos-obsoletos
Ignore los archivos obsoletos en lugar de tratarlos como nuevos archivos de origen, eliminándolos si
necesario para evitar que sean leídos por un comando de compilación. Esto no es
el predeterminado porque elimina cosas, pero a menudo es necesario para
Edificio incremental para que funcione correctamente.

Por ejemplo, suponga que hay un xc archivo que se ve así:

#include "xh"
int main () {return X; }

Considere este archivo MAKE:

$ (falso predeterminado): x
xh:
& echo "#define X 1" -o $ @

En algún momento, cambia el archivo MAKE para que se vea así:

CFLAGS: = -Idir
$ (falso predeterminado): x
dir / xh:
& mkdir -p $ (dir $ @)
& echo "#define X 2" -o $ @

Ahora, si construyes desde limpio, x sale con el estado 2, pero si construye mientras el viejo
./xh el archivo todavía existe y no especifica "--rm-stale", entonces x salidas con estado
1, porque la directiva include recoge el archivo de encabezado generado obsoleto.

Si compila con "--rm-stale", ./xh se elimina, y el resultado es el mismo que
el de una construcción limpia, que casi siempre es algo bueno.

Tenga en cuenta que si crea en un repositorio, primero debe dar esta opción allí,
porque el makepp de importación no sabe qué podría estar obsoleto en el repositorio.

Los archivos MAKE heredados a veces ponen la regla para generar un archivo de inclusión después de incluir
declaración. Mpp funciona alrededor de eso como gmake, recargando al final del archivo Make
si es necesario. Pero esto significa que en una reconstrucción parece obsoleto en el punto donde está
necesario y será eliminado. Por tanto, esta opción desactiva este tipo de recarga.

-s
--tranquilo
--silencio
No repita los comandos y no imprima mensajes informativos como "Escaneando" o "Cargando
makefile ".

--sandbox =directorio
--in-sandbox =directorio
--inside-sandbox =directorio
Restrinja esta instancia de makepp a un subárbol de un árbol de construcción normalmente más grande. Ver
particionando en cajas de arena.

--sandbox-advertir
--sandbox-advertencia
Reducir las violaciones de "en la zona de pruebas" y "no leer" a advertencias en lugar de errores.
Ver particionamiento en sandboxes.

- carrera de parada
--parada en carrera
Salir por error en lugar de solo advertir sobre una colisión de acceso a la caché de compilación que podría
ser arreglado

--enlace simbólico en representante como archivo
--symlink-en-repositorio-como-archivo
Si un repositorio contiene un enlace simbólico, por defecto ese enlace simbólico es
importado como un enlace, lo que quiere decir que el destino del enlace importado no necesita ser
idéntico al destino del enlace simbólico en el repositorio. Si el
Se especifica la opción "--symlink-in-repository-as-file", luego el enlace simbólico es
importado como su archivo de destino, lo que quiere decir que el enlace importado apunta al mismo
archivo de destino como enlace simbólico en el repositorio. Esto es útil si el simbólico
El enlace en el repositorio estaba destinado a tener la semántica de tiempo de compilación de una copia.

--tradicional
--recursión-tradicional
--hacer-tradicional-recursivo
Esta opción está presente para permitir que makepp funcione con archivos MAKE antiguos que usan recursivo
hacer mucho, especialmente con diferentes opciones. Por defecto, la marca recursiva es
implementado por un subproceso que se comunica con el proceso padre; la construcción es
hecho realmente por el proceso padre. Esto permite algunas de las características agradables de makepp como
repositorios para trabajar con invocaciones de make recursivas. Sin embargo, esta técnica
no funciona si usa diferentes opciones de línea de comando en diferentes invocaciones de
marca recursiva. Antes de usar esto, intente "--hybrid-recursive-make".

La opción "--traditional-recursive-make" hace que makepp haga recursive hace de la misma manera que
la creación tradicional, lo que permite que funcionen más archivos MAKE, pero luego los repositorios y
las compilaciones paralelas no funcionan correctamente. Rara vez se necesita esta opción, y
makepp le dirá si se encuentra con una construcción que lo requiera.

Si usa esta opción, los archivos de registro se acumularán en los distintos directorios.
esto cambia a. Para deshacerse de solo ellos, use "makeppclean --logs --recurse" o "mppc
-lr ".

-v
--verboso
Modo detallado. Explica qué está intentando crear y por qué se está creando cada archivo.
Esto puede resultar útil si cree que un archivo se está reconstruyendo con demasiada frecuencia.

Esta opción realmente toma lo que se escribiría en el archivo de registro y lo muestra en
la pantalla. Por lo general, es más fácil ejecutar makepp y luego mirar la salida de
makepplog, que permite varias selecciones y algunas reescrituras.

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

- caja de arena virtual
No reescriba información de compilación de archivos que no fueron creados por este proceso de makepp. Ver
particionando en cajas de arena.

-W nombre de archivo
--asume-nuevo =nombre de archivo
--nuevo-archivo =nombre de archivo
- qué-si =nombre de archivo
Pretende que el archivo especificado ha cambiado, de modo que cualquier objetivo que dependa de ese archivo
será reconstruido. El archivo en sí no se modifica necesariamente (podría o no ser
reconstruido, dependiendo de si está actualizado con respecto a sus dependencias), pero
todo lo que depende de ella piensa que ha cambiado. Esto puede ser útil para
depurar un archivo MAKE.

MEDIO AMBIENTE

Makepp busca hacia arriba un archivo llamado .makepprc al empezar y de nuevo después de cada
Opción "-C" o "-c". Cada vez que encuentre un archivo de este tipo, pero solo una vez por archivo, leerá
el archivo y analizarlo como posibles opciones entre comillas en una o varias líneas. A diferencia del
opción "-A", las opciones se analizarán en relación con el directorio donde reside el archivo.

Makepp analiza las siguientes variables de entorno:

$ MAKEFLAGS
Cualquier marca en esta variable de entorno se interpreta como opciones de línea de comando antes
cualquier opción explícita. Todos los argumentos de la línea de comando se colocan en esta variable

Tenga en cuenta que la marca tradicional también usa esta variable, por lo que si tiene que usar ambas
make y makepp, es posible que desee considerar el uso de "MAKEPPFLAGS".

$ MAKEPPFLAGS
Lo mismo que "MAKEFLAGS" en lo que respecta a makepp. Si esta variable no está en blanco,
entonces "MAKEFLAGS" se ignora. A veces, esto es útil en lugar de "MAKEFLAGS" si
tienes que usar tanto make como makepp, y debes mantener las opciones separadas.

$ MAKEPP_CASE_SENSITIVE_FILENAMES
Makepp intentará determinar si su directorio predeterminado distingue entre mayúsculas y minúsculas mediante
creando un archivo y luego accediendo a él con un caso diferente. Por lo general, esto funciona bien,
siempre que todos los archivos a los que acceda estén en el mismo sistema de archivos que el predeterminado
directorio, por lo que rara vez necesitará utilizar esta opción.

Si esta variable está presente en el entorno, su valor (0 o cadena vacía para
falso, cualquier otra cosa por verdadero) anulará la elección de makepp. Esta variable es principalmente
útil en Windows, si desea anular la configuración predeterminada de makepp. Si no lo haces
tratar los nombres de archivo como sensibles a mayúsculas y minúsculas, luego makepp convierte todos los nombres de archivo a minúsculas,
que causa dificultades ocasionales. (Por ejemplo, emacs puede abrir varios búferes para
el mismo archivo.)

Makepp no ​​admite actualmente una compilación en varios sistemas de archivos, si uno es
distingue entre mayúsculas y minúsculas y el otro no distingue entre mayúsculas y minúsculas.

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