makepp_incompatibilidades: en línea en la nube

PROGRAMA:

NOMBRE

makepp_incompatibilidades: incompatibilidades entre makepp y GNU make

DESCRIPCIÓN

Makepp fue diseñado para estar lo más cerca posible de GNU make
(<http://www.gnu.org/software/make/manual/make.html>). Herramientas automáticas GNU
(<http://www.gnu.org/software/automake/manual/automake.html>), CMake
(<http://www.cmake.org/>), Premake (http://industriousone.com/premake> y ver comentario
a continuación) o los sistemas de compilación heredados hechos a mano deben poder compilarse con makepp. Es tan
puede migrar proyectos sin esfuerzo. O si no quieres disfrutar de todos
las ventajas de makepp (por ejemplo, para que otros puedan construir su proyecto con GNU make) mientras
Benefíciese de la ventaja de la fiabilidad para su desarrollo.

Sin embargo, debido a la diferencia en la filosofía, algunas marcas de GNU o POSIX
(<http://pubs.opengroup.org/onlinepubs/009695399/utilities/make.html>) las funciones no se pueden
soportado. Algunas no se han implementado porque no hemos tenido tiempo. La mayoría de
Las diferencias con GNU son bastante técnicas y rara vez causan problemas. Por desgracia el
Las soluciones para las deficiencias de las marcas tradicionales son cada vez más complejas,
y le están haciendo pasar un mal rato a makepp.

En pocas palabras, si no se construye fuera de la caja, intente:

makepp --no-warn makepp_simple_concatenation = 1 makepp_percent_subdirs = 1 \
--build-check = target_newer --last-chance-rules --no-remake-makefiles

Si tiene éxito, puede intentar eliminar esos argumentos uno por uno. Pero si eso falla
intente agregar:

--hacer-tradicional-recursivo

Si eso también falla, el sistema de compilación necesita algunos ajustes para cooperar con makepp. Incluso
si algunas de las opciones descritas aquí hacen que algo se pueda construir, aún se recomienda adaptar
las cosas ligeramente, por lo que se vuelven compatibles desde el primer momento con ambas marcas.

Obligar más, POSIX or GNU para lograr compatibilidad

A continuación, se muestran algunas posibilidades de la línea de comandos para que funcionen muchos sistemas de compilación heredados.
sin modificación. Hacen que makepp emule con precisión el comportamiento de make de GNU.

Compatibilidad vía las opción: "--build-check = target_newer"
De forma predeterminada, makepp intentará reconstruir todos los objetivos si alguna de las dependencias tiene
cambiado desde la última compilación, o si el comando ha cambiado (ver makepp_build_check para
detalles). Normalmente esto es lo que quieres. A veces, sin embargo, no quieres que el objetivo
para ser reconstruido si ha sido modificado aparte del control de makepp (por ejemplo, editando
o ejecutando un programa manualmente para crear el archivo). Puedes forzar a makepp a usar el
algoritmo de creación tradicional, que solo se reconstruye si alguno de los objetivos es más nuevo que el
dependencias, agregando esta opción a la línea de comando.

Compatibilidad vía las opción: "--dont-build = config.status"
Hay paquetes que intentan autoconfigurarse o hacer otras cosas, que gmake
ignora a menos que se le pida, como:

config.status: configure
./config.status --volver a comprobar

configurar: configure.in aclocal.m4
configuración automática

La mayoría de las personas ni siquiera tienen "autoconf" instalado, por lo que hacen todo concienzudamente
las reglas, como hace makepp, fallarán. Esta opción evita que, si averigua qué
no construir.

Compatibilidad vía las opción: "--reglas-de-última-oportunidad"
Las reglas predeterminadas (reglas de patrones sin dependencias de patrones) normalmente no son compatibles.
Makepp crea una instancia de todas las reglas basadas en los archivos existentes, de modo que esté al tanto de cada
archivo que podría generarse. Por desgracia, de esta manera no sabe cómo instanciar un patrón
regla sin dependencia de patrones. El mecanismo: last_chance soluciona parcialmente eso.
Cuando esto es lo suficientemente bueno para los archivos MAKE heredados, esta opción permite activarlo globalmente.

Compatibilidad vía las opción: "--no-advertir"
Éste no mejora el resultado. Makepp dará mensajes de advertencia para muchas cosas
que el Unix tradicional acepta sin inmutarse. Esto es porque hay
mejores formas de hacerlo con makepp. Si estas advertencias le molestan, puede desactivarlas
con esta opción.

Compatibilidad vía las opción: "--hybrid-recursive-make"
Las invocaciones recursivas de make a menudo se consideran una práctica insegura (consulte "Mejor
sistema para compilaciones jerárquicas "en makepp para más detalles), pero son extremadamente comunes en
archivos MAKE existentes. Makepp admite marca recursiva para compatibilidad con versiones anteriores; por nuevo
makefiles, es mucho mejor usar la sentencia "load_makefile", o la implícita de makepp
Mecanismo de carga de archivos MAKE.

Para poder usar repositorios para compilaciones variantes y para ayudar a hacer recursivas
invocaciones de hacer más seguro, makepp normalmente no se invoca a sí mismo de forma recursiva
incluso si se lo dices. En cambio, un subproceso se comunica con el proceso padre y
la construcción real la realiza el proceso padre.

Esto funciona en la mayoría de los casos, pero no puede invocar varios archivos MAKE desde el mismo
directorio, por ejemplo, lo siguiente no funcionará:

objetivo: dependencias
$ (MAKE) -f destinos de otros_makefile

En este caso, makepp se da cuenta de que está cargando un segundo archivo MAKE y se queja. Con esta opcion
en su lugar, recurrirá a la forma tradicional de compilar a partir de archivos MAKE adicionales en
un proceso makepp separado cada uno.

Nota: Técnicamente, cargar varios archivos MAKE no sería un problema, pero generalmente tienen la
mismos nombres de objetivos falsos. Mantener eso aparte significaría un rediseño completo de makepp
internos. Sin embargo, esto funcionará, pero no es equivalente:

objetivo: dependencias
cd subdir && $ (MAKE) -f otros destinos de archivo_make

Compatibilidad vía las opción: "--traditional-recursive-make"
A veces la opción anterior no es suficiente, especialmente si las invocaciones recursivas usan
opciones contradictorias. Makepp usa solo un conjunto de opciones globales, por lo que una submake no es
permitido modificarlos, ya que eso también pertenecería a otros archivos MAKE.

Agregar esta opción a la línea de comando tiene los siguientes efectos secundarios indeseables:

· Las marcas recursivas no se ejecutan internamente en paralelo, incluso si lo hace el padre.
A diferencia de gmake, no existe una coordinación general del número de procesos. Esta voluntad
no se implementará porque esta forma de trabajo no es un objetivo de diseño de makepp.

· Los procesos de make recursivo no saben nada de repositorios.

· Cada proceso de creación recursivo produce su propio archivo de registro, en el directorio en el que se invoca
en, en lugar de producir un archivo de registro para toda la compilación.

· Dado que makepp generalmente construye más de lo que tradicionalmente, make considera necesario, y dado que muchos
Los sistemas de compilación proporcionan llamadas recursivas en todas las direcciones, esto puede conducir a interminables
recursividad. Makepp tirará del freno después de 50 rondas y te dirá cómo aumentar
eso, en caso de que realmente tengas un anidamiento tan profundo.

Incluso con la opción "--traditional-recursive-make", las variables de entorno
"MAKEOVERRIDES" y "MFLAGS" no se configuran y se ignoran, por lo que los archivos MAKEOVERRIDES que dependen de
esos no funcionarán.

A prefabricado generado Makefile es solo un envoltorio divertido para una invocación de sub-marca en el mismo
directorio. Si tienes algún objetivo de proyecto XYZ tendrá una línea como

@ $ {MAKE} --no-print-directory -C. -f XYZ.make

En este caso, puede evitar la opción "--traditional-recursive-make" invocando directamente
makepp con eso "-f XYZ.make " .

Compatibilidad sin las opción: "--jobs =n"
Los archivos MAKE heredados a veces no enumeran todas las dependencias, dependiendo del orden de
ejecución para hacerlos a tiempo. En esta situación, makepp puede lograr llamar a una regla antes
todas sus dependencias se han hecho. Entonces los resultados pueden ser mejores con menos o incluso sin
ejecución paralela.

Compatibilidad vía las variable: "makepp_simple_concatenation = 1"
La sustitución de estilo rc es la forma predeterminada en que makepp realiza la sustitución de variables en el texto
cadenas porque rara vez rompe los archivos MAKE heredados y, a menudo, es útil en nuevos
makefiles. Sin embargo, introduce incompatibilidades ocasionales en la sustitución de
variables no rodeadas de espacios. Por ejemplo,

INCLUDE_PREFIX: = -I / some / include / dir -I
INCLUYE: = $ (INCLUDE_PREFIX) / other / include / dir

establecerá "INCLUYE" en "-I / algunos / incluir / dir / otros / incluir / dir -I / otros / incluir / dir" si rc-
la sustitución de estilo está habilitada, mientras que GNU make lo establecería en
"-I / algunos / incluir / dir -I / otros / incluir / dir". Por ejemplo, al compilar Redis 2.6.5 intenta
ejecute "printfgcc". Una concatenación tan divertida de dos comandos es una fuerte indicación de que
esta variable es necesaria para retroceder para hacer semántica.

También existe una incompatibilidad en el manejo de espacios en blanco en una variable:

nulo: =
T: = -o $ (nulo) # T contiene -o seguido de un espacio.
OUTFILE = $ (T) archivo de salida

establecerá "OUTFILE" en "-ooutfile" si la sustitución de estilo rc está habilitada, mientras que GNU make
lo establecería en "-o archivo de salida".

Ambas incompatibilidades se eliminan configurando "makepp_simple_concatenation"
variable. Sin embargo, tenga en cuenta que incluso con "makepp_simple_concatenation", makepp todavía
trata los espacios en blanco de manera incompatible en algunas situaciones:

T: = -o # No elimines este comentario.

GNU hace que los conjuntos "T" contengan "-o" seguido de un espacio, mientras que makepp elimina el
espacio final de todos modos. Si desea el espacio final, debe establecer
"makepp_simple_concatenation" y también establece "T" usando la técnica que involucra un maniquí
variable como "nulo", como se muestra arriba.

Solución opción "--no-remake-makefiles"
El código abierto típico requiere llamar a "configure" para crear los archivos MAKE. Pero entonces estos
Los archivos MAKE pueden contener reglas para rehacer el archivo MAKE, llamando a algún comando. Makepp lo hará
Cumplir felizmente y actualizarlo de acuerdo con la regla. Pero a veces esto es dañino, así que
simplemente omítalo.

Compatibilidad vía las variable: "makepp_percent_subdirs = 1"
De forma predeterminada, "%" en una regla de patrón no coincide con los directorios. Esto significa que una regla como
modo:

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (entrada) -o $ (salida)

no se aplicará a archivos como "../shared/xyz.c". Si desea que coincida con los archivos en
subdirectorios también, luego establezca la variable "makepp_percent_subdirs = 1" en la línea de comando
o cerca del comienzo de un archivo MAKE.

Compatibilidad vía las entorno variable: $ MAKEPP_IGNORE_OPTS
A veces, las invocaciones recursivas heredadas pasan opciones que makepp no ​​comprende.
Con suerte, la opción no es importante, pero evita que makepp se ejecute. Con este
variable de entorno, puede pedirle a makepp que ignore silenciosamente ciertas opciones. El valor
será una lista de opciones separada por espacios, que puede venir en 4 variantes:

--Corto=x
Una opción larga que espera una discusión. Este hecho debe declararse a través de los iguales.
signo, aunque el uso real también puede estar separado por espacios en blanco, ya sea "--long = bla" o
"- largo bla".

--Corto
Una opción larga sin argumento.

-sx Una opción corta que espera un argumento. Este hecho debe declararse agregando
algo directamente después de la opción, aunque el uso real también puede estar separado por
espacios en blanco, ya sea "-sbla" o "-s bla".

-s Una opción corta sin argumento.

Por ejemplo, anule la opción -R de makepp por uno sin un argumento y acepte la depuración de gmake
opción con un argumento:

exportar MAKEPP_IGNORE_OPTS = '- R --debug = x'

Incompatibilidades esa exigir Makefile cambios

· Los archivos Makefiles que llaman explícitamente a make evitan que makepp construya todo por sí mismo.
Alas, el propio "ExtUtils :: MakeMaker" de Perl confirma la segunda de las siguientes dos formas de
este error hasta la versión 6.56 (Perl 5.12.1):

subdirectorio:
cd subdir; fabricar

HACER = hacer

· Establecer la variable "VPATH" en algún valor llama implícitamente "vpath% value". "vpath"
Las declaraciones se emulan con el mecanismo de repositorio. Entonces, donde gmake sustituye
la ruta al archivo que se encuentra en vpath, makepp lo vinculará simbólicamente a
donde se necesita. Por lo tanto, makepp proporcionará una cadena sin modificar, que generalmente es
no es un problema.

No se admiten los destinos en una vpath. (Gmake los considera si son más nuevos que
sus dependencias, pero si no, el objetivo se volverá a crear en el directorio actual
- bastante inconsistente.) No se admite la desactivación de vpaths.

· Una regla de patrón presente más adelante en un archivo MAKE anula una que está presente antes.
Esto es al revés de GNU make.

· El conjunto de reglas implícitas incorporadas es algo diferente de las de GNU make,
aunque los nombres de las variables son en gran parte compatibles. Las reglas integradas deben
compilar con éxito programas C / C ++ / Fortran, y de hecho puede ser capaz de adivinar el
bibliotecas adecuadas en algunos casos también. Soporte para Modula-2 y RatFor y otros raros
lenguajes deliberadamente no está presente, porque seguí teniendo problemas con GNU
make cuando reutilicé accidentalmente las extensiones para esos idiomas.

· Un prefijo de acción de "+" se ignora silenciosamente.

· Los miembros del archivo no son compatibles y tampoco las variables automáticas asociadas.
$%, "$ (% D)" y "$ (% F)".

· No hay soporte SCCS.

· Los espacios en blanco iniciales y finales en las asignaciones de variables se ignoran (incluso si el
un espacio en blanco va seguido de un comentario). Para obtener más detalles sobre el manejo de espacios en blanco
incompatibilidades, consulte "Espacio en blanco en variables" en makepp_variables.

· Makepp no ​​intenta reconstruir los archivos incluidos con la declaración "incluir" a menos que
el archivo MAKE contiene una regla para construirlos antes de que se vea la declaración de inclusión.
(Sin embargo, intentará reconstruir el archivo MAKE en sí.) Esto se usa normalmente para
el manejo incluye dependencias de archivos, y no es tan útil con makepp ya que no
Necesito hacer eso de todos modos.

· La variable "SHELL" actualmente se ignora parcialmente. Makepp siempre usa / Bin / sh
a menos que / usr / xpg4 / bin / sh or / sbin / xpg4 / sh se encuentra oa menos que exporte el "SHELL"
variable en su archivo MAKE. Pero si lo hace, es posible que el analizador de comandos no
entienda lo que hace su comando de shell. En Windows Strawberry o ActiveState Perl
en su lugar, debe establecer su variable SHELL antes llamando a makepp.

· Las dependencias de cualquier cosa en el Makefile aún funcionan, pero generalmente son innecesarias.
Esto se usa generalmente para forzar una reconstrucción cuando cambian las opciones de compilación. Makepp sabe
cuando los comandos de compilación han cambiado sin nada especial en el archivo MAKE; almacena
esto sobre una base de archivo por archivo. Si cambia el archivo MAKE, sabrá exactamente qué
los archivos necesitan recompilarse.

· Los archivos intermedios no se eliminan. (Porque makepp insiste en tener todo el archivo
las fechas sean las mismas que en la última compilación, los archivos intermedios deben ser
presente o de lo contrario se producirán reconstrucciones.) No se concede un estatus especial a
archivos intermedios.

· El único objetivo especial que se admite es ".PHONY" y parcialmente ".SUFFIXES". El
restantes simplemente se ingieren.

Específicamente, GNU make tiene los siguientes objetivos especiales:

.SUFIJOS
Makepp ignora ".SUFFIXES" excepto en el caso especial de ".SUFFIXES" sin
dependencias, como esta:

.SUFIJOS:

que le dice que no cargue ninguna de sus reglas predeterminadas.

.INTERMEDIATO, .SECONDARIO, .PRECIOSO
No se concede un estatus especial a los archivos intermedios y, por lo tanto, estos objetivos no se
significativo.

.IGNORAR
Este objetivo se ignora. Si desea ignorar los errores, coloque la palabra "ignore_error"
(o un signo menos) delante del comando cuyo estado de salida debe ignorarse.

.SILENCIO
Este objetivo se ignora. Si quieres que los comandos no hagan eco, pon la palabra "noecho"
(o el carácter "@") delante del comando que se supone que no debe repetirse,
o use la opción "--silent" para makepp.

.DELETE_ON_ERROR
.EXPORTAR_TODAS_VARIABLES
.NOEXPORTAR
.POSIX
.DEFECTO
Estos objetivos no son compatibles y simplemente se ignoran.

· Las funciones de creación de GNU "eval", "sabor" y "valor" no son compatibles actualmente. Ustedes
puede lograr lo mismo que eval de una manera más sencilla con "$ [...]"
Expansión variable o función.

· Las reglas de dos puntos dobles no son totalmente compatibles. (No pueden ser: en el paradigma de makepp,
no puede haber más de una forma de actualizar un objetivo). Actualmente, cada sucesivo
La regla de dos puntos dobles para un objetivo determinado simplemente agrega su cadena de comando y dependencia
list a la cadena de comando y la lista de dependencias para este objetivo. Por ejemplo, si tu
escribe esto:

un :: b
& cat b -oa

# Más adelante en su archivo MAKE:
un :: c
& gato c -o >> a

es exactamente lo mismo que si hubieras escrito

a B C
& cat b -oa
& gato c -o >> a

Ciertamente, esto no es para lo que están destinadas las reglas de dos puntos, y no siempre
funciona, pero funciona para objetivos como "limpio" o para todas las cosas que
ExtUtils :: MakeMaker coloca en sus archivos MAKE. No cuentes con eso para nada más
que los archivos MAKE heredados.

· La función "$ (comodín)" no solo coincide con los archivos que existen, sino también con los archivos que
aún no existen, pero que tienen una regla que makepp ha visto en el momento en que
Se evalúa la función "$ (comodín)".

· La declaración "define" es compatible, pero el manejo de "@" que la precede está hecho
diferentemente. Actualmente en makepp, "@" delante de una variable que tiene varias líneas
El valor solo suprimirá el eco de la primera línea. Por ejemplo,

definir líneas de eco
& echo line1 -o $ @
& echo line2 -o >> $ @
endef

x:
@ $ (líneas de eco)

no suprimirá la impresión de "& echo line2" como lo hace en GNU make; solo lo hará
suprimir la impresión de "& echo line1".

· Makepp no ​​admite las siguientes variables de entorno (no las configura,
y simplemente los ignora):

CAMBIOS DE CAMBIO
MFLAGS

Incompatibilidades in solicite of expresión expansión
· En makepp, las acciones de las reglas se expanden antes de que se garantice que todas las dependencias
han sido construidos. Puede solucionar esto cambiando reglas como esta:

foo: barra
genfoo <$ (barra de gato de shell)

a esto:

foo: barra
genfoo <`barra de gato`

o esto, que hará que el archivo durante la expansión:

foo: barra
genfoo <$ (& cat $ (hacer barra))

Esto es preferible aquí, porque el archivo que aparece en de caramelos es también una dependencia de este
regla, y makepp ahora puede detectarlo al analizar léxicamente la redirección.

· Aunque no he visto esto usado, GNU make permite lo siguiente:

dos puntos =:
a $ (dos puntos) b
echo $ ^

Makepp expande "$ (dos puntos)" demasiado tarde para que esto funcione. Sin embargo, ofrece la
sintaxis alternativa "$ [dos puntos]", que puede hacer mucho más que GNU, porque es
ampliado muy temprano.

"$ (HACER)" podrían incluir espacios
En un makepp desinstalado o si la plataforma no parece admitir el inicio de un script Perl
por número mágico o con "--traditional-recursive-make" esta variable incluirá al menos
un espacio. Eso no es un problema cuando se usa como comando. Pero al pasarlo como un
parámetro sin comillas a un script (como lo hace el sistema de compilación Perl 5.14.0), lo romperá
separarlos en parámetros separados, lo que genera confusión. Por tanto, como parámetro es más seguro
cítelo como '$ (MAKE)'. que no rompe la compatibilidad con versiones anteriores.

Específico de destino asignaciones Rechazar propagar
Las variables específicas de destino de Makepp son ligeramente diferentes de las de GNU en que
solo se aplica a la regla para el archivo mencionado, y no a ninguno de sus predecesores; ver
Asignaciones específicas de destino.

Paréntesis or frenos Rechazar nido
Makepp termina las expresiones en el primer paréntesis o llave coincidente. En lugar de esto

$ (alguna función ... () ...) # GNU make style

debes usar cualquiera de estos

$ {alguna función ... () ...} # GNU hacer compatible
$ ((alguna función ... () ...)) # Extensión Makepp

Esto probablemente se solucionará en la versión 2.1, quizás opcionalmente.

Clasificacion "Minor" puntos
Las dependencias de patrones no coinciden con objetivos falsos
% .a:% .b; ...
$ (falso xb):; ... # no proporciona una forma de compilar xa

Los comentarios no tienen líneas de continuación
# Esto es \
NO es un comentario de 2 líneas

Comando línea incompatibilidades

Makepp admite algunas de las opciones de línea de comandos más útiles de make. Sin embargo, lo siguiente
no son compatibles:

-d o --debug
-f-
Los objetos internos de makefile de Makepp están vinculados a objetos de archivo, por lo que no puede manejar
entrada estándar

-i
-l o --carga-promedio o --máx-carga
-m La opción "-m" de Makepp tiene que ver con la selección del método de firma, mientras que GNU make
ignora -m.

-p o --print-base-de-datos
-q o - pregunta
-R o --no-variables-integradas
La opción "-R" de Makepp en realidad hace algo completamente diferente.

-S --no sigue adelante o --parada
La opción "--stop" detiene (pone a dormir) makepp después de aprender todas las reglas, por lo que
puede seguir editando.

-to --toque
-w o --print-directory
Esto sucede automáticamente.

--advertir-variables-indefinidas

Algunos de estos se pueden respaldar fácilmente si a alguien le importa.

Variable incompatibilidades

Makepp busca en $ PATH un comando coincidente para devolver variables como "$ (CC)" o
"$ (CXX)", mientras que GNU make tiene valores predeterminados estáticos. También makepp da preferencia a "gcc" y
"g ++" mientras que, sorprendentemente, GNU devuelve "cc" para el primero, pero lo mismo para el
último. Puede anularlos en el archivo MAKE, en la línea de comando o exportando un
variable del mismo nombre antes de invocar makepp.

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