jmake - Online en la nube

PROGRAMA:

NOMBRE

jmake: un constructor genérico de archivos MAKE

SINOPSIS

jmake [ cpp opciones ]

DESCRIPCIÓN

jmake construye un archivo MAKE a partir de una descripción de alto nivel contenida en un jmakefile archivo.
El archivo generado es un Makefile.SH en lugar de un simple archivo MAKE, lo que significa que está listo
para ser utilizado en conjunción con metaconfig. En particular, parámetros como "dónde
instalar ejecutables "será determinado automáticamente por Configurar y solo lo necesario
se tendrán en cuenta los parámetros.

Para utilizar jmake tienes que escribir un jmakefile primero, que describe cómo deben ser las cosas
construido. Tu jmakefile se incluirá dentro de una plantilla genérica a través de la C pre
procesador. Esto significa que puede usar los comentarios habituales de C / ** /, pero no el shell #
comentarios. Los comentarios de C no aparecerán en el archivo generado. Makefile.SH pero las líneas comienzan
with; # finalmente aparecerá como comentarios de shell. Si tiene que escribir la cadena / * en el
generado Makefile.SH entonces tienes que escapar de él (de lo contrario jmake pensará en ello como el
comienzo de un comentario en C). Simplemente coloque un # delante del *, como en / # *.

Tiene un conjunto de macros a su disposición, y todas estas macros se enumeran en el índice
archivo, junto con el fragmento de código al que se expandirán. Por lo general, un jmakefile es bastante
pequeño y, por lo tanto, más fácil de mantener que un enorme Archivo Make. Algunos comandos internos poderosos
le permite escribir archivos MAKE portátiles fácilmente, sin tener que gastar muchos esfuerzos,
porque alguien más ya hizo el trabajo por ti :-).

Cuando desea generar su archivo MAKE, generalmente no ejecuta jmake pero usa el jmkmf
script que es un contenedor e invocará jmake con las opciones correctas.

Todo el conocimiento de jmake se mantiene en dos archivos: la plantilla jmake.tmpl y la macro
archivo de definición Jmake.reglas. El primer archivo incluye el segundo, junto con el
Jmakefile. A veces es necesario saber cómo funcionan las cosas para poder utilizar correctamente
todas las características proporcionadas. Por ejemplo, puede que tenga que escribir sus propias reglas para un
proyecto específico. Aunque no puede sobrescribir las reglas predefinidas, puede ampliar la
Jmake.reglas archivo o simplemente agregue sus macros en su Jmakefile. También puedes usar #incluir
declaraciones cuando desee compartir estas macros y no desee duplicar el código.

La sintaxis en Jmake.rules no es elegante en absoluto, pero:

- Es fácil de analizar (como archivos sendmail.cf o troff).
- Se supone que las reglas no cambian muy a menudo.
- Es lo suficientemente simple como para dominarlo en cinco minutos. :-)

Aquí hay una pequeña descripción:

1) Para hacer frente a varios cpp implementaciones:

· Final @! \ Significa: final de línea, la siguiente línea comienza en el margen izquierdo.
· Final @@ \ significa: fin de línea, la siguiente línea debe tener una sangría de una pestaña.

Siempre debe haber uno de @! \ O @@ \ al final de cada línea. El único
La excepción es para macros que se utilizarán como parte del cuerpo de una regla (p. ej.
Eliminar programa de destino). En ese caso, la primera línea (que contiene el #definir) debería
terminar con una sola barra invertida.

2) Definiciones de símbolos:

·> SÍMBOLO: define el símbolo.
·? SÍMBOLO: : mantiene si se define SÍMBOLO.
·% SÍMBOLO: : mantiene iff SYMBOL no está definido.

El? SYM se puede anidar (AND lógico), como en:

? SÍMBOLO:% TOKEN: texto

que mantendrá el texto si SYMBOL está definido y TOKEN no definido. Para implementar un
OR lógico, ver más abajo.

3) Pruebas de destino Makefile:

·?dirigidos?: : mantiene si dirigidos está definido.
·%dirigidos%: : mantiene si dirigidos no está definido.

Un archivo MAKE dirigidos se define como un objetivo independiente, por ejemplo, el
depende.local target, que se definiría como:

depende.local:

También tenga en cuenta que solo es válido para objetivos definidos so muchos en el generado
makefile. No es un predicado que pueda usarse para probar objetivos que
eventualmente se definirá más adelante en la generación.

4) Comandos:

Los comandos se pueden pasar a jmake. Empiezan con un "|" inicial. Comandos disponibles
son:

· | Sufijo : agrega a la lista .SUFFIXES: en el archivo MAKE.

· | Regla: : agrega a la sección de reglas de construcción.

· | Regla: : igual que antes, con una pestaña inicial.

· | Skip: salta el texto hasta que se encuentra una línea que comienza con '-skip'.

· | Subst: comienza la sección donde las líneas estarán sujetas a sustitución de variables,
hasta que se encuentre '-subst'. Esto significa que cuando se ejecuta Makefile.SH, todos
instancias de $ var dentro del subst la sección será sustituida por el shell.

· | Shell: emite la sección hasta que coincida con '-shell' tal cual en el generado
Makefile.SH. Esto puede ser útil para preparar | caso secciones. No lo es
permitido anidar shell .

· | Caso: este comando debe ir seguido de un nombre de variable de shell (sin su
inicial '$') y un patrón de estilo de caso, por ejemplo, la cadena "var en
f * ". Generará la prueba de" caso "correspondiente en el Makefile.SH en
el valor "$ var" y solo si esta prueba es verdadera, la sección hasta que
'-case' coincidente se generará en el Makefile cuando se ejecute Makefile.SH. Eso
es posible anidar case secciones libremente.

· | Expandir : expanda líneas hasta '-expand' con . Una completa
A continuación se muestra un ejemplo.

· | Una vez : el texto hasta '-una vez' aparece solo la primera vez.

El '|' los comandos no se pueden anidar, a menos que se indique lo contrario. En particular, debido a
la simple implementación de | saltar, es imposible poner | saltar dentro de un saltado
parte. Sin embargo, un | una vez la sección puede tener | saltar secciones. Está permitido anidar
| caso secciones a voluntad.

Aquí hay una forma de implementar un OR lógico:

/ * Implementa SYMBOL o no TOKEN * /
? SÍMBOLO: texto / * Mantiene el texto si SÍMBOLO * /
% SYMBOL: | saltar
% TOKEN: texto / * Mantiene el texto si no es TOKEN * /
-saltar

En realidad, esto es feo, porque el texto tiene que aparecer dos veces. Afortunadamente, lo hice
no use esa construcción. :-)

De hecho, como seguramente ya habrá adivinado, la mejor manera de implementar un OR lógico
es utilizar la Ley de De Morgan:

no (p o q) <=> no py no q

/ * Implementa SYMBOL o no TOKEN (intento # 2) * /
% SYMBOL:? TOKEN: | saltar
texto / * Si SÍMBOLO o no TOKEN * /
-saltar

¿Quién dijo que no les importaba la lógica? ;-)

La expansión se realiza con el expandir mando. Se ha proporcionado para evitar algunos
escrituras engorrosas en archivos MAKE cuando tienes que repetir algunas líneas tontas que solo
difieren en los nombres de los archivos, por ejemplo. Primero veamos un ejemplo:

| expandir una! barra de! foo! b! si no!
!un::
echo! a,! b
-expandir

Entonces se imprimirán dos reglas, y los valores de (a, b) para la primera serán (foo,
sí), para el segundo (barra, no). La sustitución está controlada por el '!' personaje.
Si la palabra a sustituir es parte de otra, separe con el constructo ^^
como en:! b ^^ c. Es posible utilizar macros Makefile en el , y ellos
será expandido por jmake. Si esto no es lo que desea, evite el primer signo '$'
(este es un escape Makefile, es decir, debe doblar el '$', no precederlo con un
barra invertida). A // representa el valor de sustitución nulo.
La construcción ^^^ se comporta como ^^, es decir, se elimina, pero también elimina cualquier
siguiente espacio en blanco después de ^^^. Si antepone algo a un argumento macro,
y ese argumento macro se escribió con espacios antes, entonces esto le permitirá
concatenar algo justo antes del valor final de ese argumento.

Aquí hay otro ejemplo que muestra cómo se puede utilizar la macro Expandir. Está
definido en Jmake.reglas como:

#define Expand (regla, patrón) @! \
| expandir patrón @! \
regla @! \
-expandir

Entonces podemos escribir en el jmakefile:

| saltar
A = barra de foo
-saltar

#define Rule @! \
$ (DIR) /! A ^^. O:! A ^^. O @@ \
$ (CC) -c! A ^^. C @@ \
$ (MV)! A ^^. O $ (DIR)

Expandir (Regla, a! $ (A)!)

que generará en Makefile.SH:

$ (DIR) /foo.o: foo.o
$ (CC) -c foo.c
$ (MV) foo.o $ (DIR)

$ (DIR) /bar.o: bar.o
$ (CC) -c bar.c
$ (MV) bar. O $$ (DIR)

La declaración 'A' ha estado rodeada de omitir, para que no aparezca en el
Makefile.SH generado, pero será tenido en cuenta por jmake para
sustitución en el patrón.

El número de expansiones está determinado por el número de valores posibles para el
first parámetro. Si otros parámetros tienen menos valores de sustitución, obtendrán
los nulos.

Es posible agregar una expresión regular al final de '-expand'. Este regular
La expresión se eliminará del conjunto final de expansión al final de cada línea.
También es posible hacer sustituciones en el elemento expandido, utilizando la sintaxis
(si 'f' es la variable expandida)! f:= donde y son dos regulares
expresiones (sin espacios). El patrón será reemplazado por el patrón
(solo se reemplazará la primera aparición).

Finalmente, puede referirse en la sección ampliada a las variables cuyo valor se calcula
a través de otra expansión, lo que facilita la definición de genéricos Jmakefiles.

Ejemplo:

SRC = foo.c bar.c
OBJ = \
| expandir f! $ (SRC)!
! f: \. c = \. o \
-expandir \\
INC = \
| expandir f! $ (OBJ)!
! f: \. o = \. h \
-expandir \\

que generará en Makefile.SH:

SRC = foo.c bar.c
OBJ = \
foo.o \
bar.o
INC = \
foo.h\
bar.h

No olvide proteger los caracteres especiales en sus expresiones regulares, como
barra invertida, punto, etc.

El una vez El comando está etiquetado con un nombre. La primera vez que aparece el nombre, una vez
La construcción se ignora y el texto hasta '-una vez' se copiará en el archivo generado
Makefile.SH. Sin embargo, se ignorarán las apariciones futuras del mismo nombre (una vez
se comportará como omitir).

Ejemplo:

| una vez this_is_a_name

-una vez

El shell El comando se puede usar para generar un fragmento de shell en Makefile.SH. Para
ejemplo, la siguiente sección en el Jmakefile:

| concha
caso "$ d_usegtk1" en
definir) glib = 1; gtk = 1 ;;
esac
-cáscara

causará la generación del fragmento adjunto en el Makefile.SH para calcular
los valores de la fácil y gtk variables basadas en la variable de configuración
d_usegtk1 establecido ejecutando Configure.

A su vez, esto se puede utilizar en posteriores case secciones para activar partes del
Makefile solo cuando se compila para GTK1 usando glib-1.x:

| caso simplista en 1
monitor:
echo "Construyendo para glib-1.x"
-caso

Esta sección generará algo como esto en Makefile.SH:

! NO! SUBS!
caso "$ glib" en
1)
$ spitshell >> Makefile << '! NO! SUBS!'
monitor:
echo "Construyendo para glib-1.x"
! NO! SUBS!
;;
esac
$ spitshell >> Makefile << '! NO! SUBS!'

Y al ejecutar Makefile.SH, la regla de "visualización" anterior solo aparecerá cuando
edificio para glib-1.x. La forma de la final Makefile por lo tanto, puede depender de la
opciones de configuración elegidas cuando Configurar fue corrido.

5) Inicializaciones:

· + : Coloca toda la línea en la sección de inicialización.
· ++ SÍMBOLO : Agrega a la macro SYMBOL.

6) Variables definidas por el usuario:

El usuario puede definir CFLAGS, LDFLAGS o DPFLAGS como banderas adicionales que se utilizarán en C
compilación, fase de vinculación o destino dependiente. Por lo tanto, es posible agregar algunos extra
banderas como -I o bibliotecas para Makefiles en subdirectorios específicos.

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