makepp_builtins - Online en la nube

PROGRAMA:

NOMBRE

makepp_builtins: comandos integrados en makepp

DESCRIPCIÓN

A: awk, C: &gato,
chgrp,
& chmod,
chown,
& cp,
cpp,
&Corte, D: datos, E: &eco,
& expr, F: false,
fmt, G: & grep, H: cabeza, I: &Instalar en pc, L: & ln, M: m4,
& mkdir,
& mv, P: & perl,
& preproceso,
& printf, R: & rm,
rmdir, S: & sed,
&clasificar, T: cola,
&plantilla,
&tocar,
tr, U: & desinstalar,
& uniq, Y: &sí

Existe una posibilidad especial similar a Shell para llamar a comandos integrados en una regla. El único
Los metacaracteres reconocidos son signos de comentario, barras invertidas, comillas simples y dobles. Solamente
se puede dar un comando por línea y la redirección de E / S no está disponible (consulte "-i" y "-o"
a continuación en su lugar).

Estos comandos comienzan con "&", que es el carácter de función en Perl y no es un
primer personaje en Shell. Si no se puede encontrar un comando incorporado con ese nombre, esto también es
la sintaxis para llamar a un script externo dentro de la instancia de Perl que ejecuta la regla.
Ver "ejecutar".

Estos comandos, así como los que usted mismo definió y los scripts de Perl, también se pueden llamar como
hacer la función, devolviendo la salida estándar. Esto requiere que perl esté construido para PerlIO.
Las nuevas líneas se convierten en espacios, excepto cuando se evalúan dentro de una declaración "definir".

PRIMERAS-PALABRAS; = $ (& cut -d '' -f0 $ (ARCHIVOS))

Cuando estos comandos no están sangrados como acciones de reglas, se ejecutan mientras se lee el
makefile. También puede acceder a estos comandos de forma independiente, por ejemplo, si necesita algunas funciones
no disponible en la contraparte de Unix, a través del comando makeppbuiltin.

Estos comandos se basan principalmente en la variante GNU. Pero muchas opciones (como --backup,
--interactive o --recursive) realmente no tienen sentido en un archivo MAKE. Así que aunque
serían fáciles de implementar en Perl, se han omitido. También muchos comandos de Unix
ofrecen una variedad de opciones que cubren casos bastante complicados (por ejemplo, ordenar campo
especificaciones) sin dejar de ser inherentemente limitado. Permitir el acceso a Perl, que es
presente de todos modos, da mucho más poder aquí.

Las listas de nombres de archivos pueden estar vacías, por lo que es seguro llamar a estos comandos sin marcar
lista. Las opciones en su forma abreviada se pueden pegar juntas como en "-ab" en lugar de "-a -b".
En la forma larga, los argumentos se pueden dar pegados con un signo "=" o por separado.
En su forma abreviada, pueden darse pegados directamente o por separado.

Estándar opciones
Algunas opciones son comunes a varias incorporaciones, aunque la forma corta a veces está oculta por
la propia opción de un comando (como en "& cut -f"):

-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
.

-f
--fuerza
Forzar la creación de los archivos previstos por los parámetros, incluso si son de un tipo diferente
de archivo o directorio vacío con ese nombre ya existe. Debe preceder al "-o,
--output = filename "opción si va a tener algún efecto sobre eso.

-i comando shell
--inpipe =comando shell
Inicie los comandos de Shell y canalice la salida al archivo incorporado. Opcionalmente puede
ser un "|" final carácter, para indicar que se trata de una tubería. Con esta opción no
es necesario proporcionar los nombres de archivo. Pero si desea realizar la función incorporada en ambos archivos y
la salida de la tubería, debe utilizar "-" como nombre de archivo para la salida de la tubería. La pipa es
vaciado, pero, a menos que también dé "--infail", el comando no se espera, por lo que
puede terminar en paralelo. Esta opción es necesaria porque no hay redirección
sintaxis.

-I
--infalar
Si un comando de Shell "--inpipe" falla, eso también hace que falle el incorporado actual.
Actualmente, esto no funciona en Strawberry y Win ActiveState, debido a la
forma poco entusiasta en que emulan el fork / exec de Unix. Sin embargo, Cygwin lo hace bien.

-o nombre de archivo
--salida =nombre de archivo
Escriba la salida en este archivo, en lugar de stdout. El nombre de archivo puede tener alguno de estos
formas:

nombre de archivo
>nombre de archivo
Simplemente escriba en el archivo.

>>nombre de archivo
Anexar a (no necesariamente) archivo existente.

+<nombre de archivo
También abra el archivo para la entrada, lo que permite la edición en el lugar. Con esta variante de opción
no es necesario proporcionar nombres de archivo de entrada. Pero si desea realizar lo incorporado en
más archivos, debe utilizar "-" como nombre de archivo de entrada para este. De hecho el
la salida se escribe en un archivo temporal que se mueve al nombre de archivo al final.

|comando shell
Canalice la salida incorporada a los comandos de Shell.

Esta opción es necesaria porque no hay sintaxis de redirección.

-O
--superar
Si falla un comando de Shell "--output", eso también hace que falle el incorporado actual.

-r número
--record-size =número
Establece localmente $ / para el builtin actual. Esto divide la entrada en registros de longitud
número en lugar de línea por línea. Si número es cero, cada archivo de entrada en su conjunto es uno
registro.

-s cadena
--separator =cadena
Establece localmente $ / para el builtin actual. Esto divide la entrada en cadena en lugar de línea
nombre del autor.

-S
--sincronizaciones
Generar "# línea""NO""" ""EXPEDIENTE""" "y" # línea ""NO" líneas, entendidas por muchos como C
idiomas.

-v
--verboso
Documente los cambios en el sistema de archivos. Esto debe preceder a otras opciones si se desea
documentar su efecto. Si pasas esta opción al propio makepp, es como si tuvieras
dado para cada comando incorporado.

incorporado comandos
Hay dos motivaciones para tener comandos integrados en makepp. El primero es ofrecer una
conjunto de utilidades, que, a diferencia de los comandos de Shell, están garantizados para funcionar de la misma manera
en todas partes, como "& echo -n" o "& mkdir -p", y te ahorra la molestia de encontrar el camino
para instalar y descubrir sus variadas opciones. En un entorno de compilación,
es útil tener la opción "--synclines", que normalmente solo proporciona "m4" en todos
filtros.

La otra es una cuestión de eficiencia. En general, se deben evitar costosas bifurcaciones / ejecutivos
donde sea razonablemente posible. En emulaciones Unix como Cygwin o BS2000 / Posix, esto se convierte en un
victoria notable. Pero, incluso en Linux, cuando el conjunto de pruebas de makepp se convirtió de
comandos externos a incorporados, hubo un ahorro general del 3% del uso de CPU del usuario y del 15%
uso de la CPU del sistema. (Las pruebas son, por supuesto, pesadas en acciones primitivas y difícilmente llaman a la
compilador.)

La consistencia también es un problema, aunque no vamos a reformar Unix. Normalmente comandos
tienen varios matices de expresiones regulares. Y muchos inventan una especie de lenguajes, cada uno
diferente, por supuesto, para hacer algo (por ejemplo, "expr", "sed" ...), u opciones complejas para
especificando campos, delimitadores, columnas (por ejemplo, "cortar", "ordenar" ...).

Aquí, en cambio, cualquier cosa elegante simplemente es manejada por Perl, dando consistencia a ambos
todos los comandos y mucho más poder que un montón de opciones. Mejor aún, cualquiera código perl
estos comandos se ejecutan por usted, se ejecutan en el paquete del Makefile. Entonces, en lugar de
Introduzca el código Perl en la acción de la regla, puede definir funciones y variables y usarlas
dentro de los comandos:

sub mi_filtro {
# Devuelve verdadero si es deseable $ _
}
% .out:% .in Makeppfile
& grep & my_filter $ (entrada) -o $ (salida)

Si usa funciones o variables de Perl en sus comandos, makepp no ​​reconoce esto como
una dependencia. Por lo general, es más seguro decirle todo a makepp, por lo que las reglas que usan Perl
Los elementos deben depender del archivo MAKE o módulo que proporciona esos elementos, como se muestra en la
ejemplo anterior.

Por otro lado, la ignorancia puede ser deseable si tiene un programa que mezcla programática
y aspectos de configuración en un solo archivo. Un ejemplo sería un archivo WSDL que contiene un
definición de la interfaz del servicio web y una dirección IP. Puede preprocesar este archivo con
el comando & template para parchear en la configuración, pero no dejar que makepp se dé cuenta.

&gato [opción ...] nombre de archivo ...
Concatena todos los archivos en uno solo.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -i,
--inpipe = shellcommand, -I, --infail, -o, --output = nombre de archivo, -O, --outfail, -S,
--synclines, -v, --verbose "

& chmod [opción ...] modo nombre de archivo ...
Sets modo para todos los archivos dados. El modo debe ser una cadena octal.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -v, --verbose"

& cp [opción ...] archivo fuente archivo de destino
& cp [opción ...] archivo fuente
& cp [opción ...] archivo fuente ... destino
Copiar archivo fuente a archivo de destino, un experto archivo fuente al directorio actual o múltiples
archivo fuentepara destino con el mismo nombre

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -v,
--verboso"

-l
--Enlace
Intente vincular los archivos. Si eso falla, intente el enlace simbólico, si eso también es
solicitado, de lo contrario copia.

-s
--simbólico
- enlace simbólico
--enlace simbólico
Intente vincular simbólicamente los archivos. Si eso falla, copie.

Vea la nota debajo de & ln.

&Corte [opción ...] nombre de archivo ...
Imprima partes seleccionadas de líneas de cada archivo o líneas seleccionadas, contando en todos
archivos. La salida está separada por el delimitador que por defecto es TAB para los campos y
cadena vacía para caracteres.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, --force, -i,
--inpipe = shellcommand, -I, --infail, -o, --output = nombre de archivo, -O, --outfail, -r,
--record-size = número, --separator = cadena, -S, --synclines, -v, --verbose "

-c lista
--caracteres =lista
Imprime todos los caracteres especificados por lista. Lista puede ser cualquier expresión de Perl
devolviendo una lista de números enteros. Los números enteros pueden ser positivos, comenzando en
cero para contar desde el principio, o negativo para contar desde el final. A diferencia de Unix
"cortar", se respeta el pedido que solicitas.

A diferencia del operador de corte de Perl, donde un rango ".." debe ser positivo o
negativo, & cut permite comenzar con un positivo y terminar con un negativo. Pero
esto solo está disponible si su expresión consta solo de números, comas y
"..". Por ejemplo, "1 ..- 2" significa todo menos el primero (0) y el último (-1).

La expresión de lista puede mirar toda la línea en $ _. Los cambios a eso serán
ignorado, sin embargo, porque cuando se evalúa esta expresión, la línea ya ha
se ha dividido en la variable de división automática de Perl @ :: F. Los números que devuelve son de hecho
índices a esa lista.

-d cadena
--delimiter =cadena
Establezca un nuevo delimitador para los campos de entrada y la salida. A diferencia del "corte" de Unix, esto puede tener
cualquier longitud.

-E
--no hay escapatoria
Trate "\" como literales normales para "-p, --printf = formato".

-f lista
--fields =lista
Imprime todos los grupos especificados por lista. Lista es como se describe en "-c,
--characters = list ". Tenga en cuenta que esto oculta la opción estándar" -f ", que debe ser
dado como "--force".

-l lista
--lines =lista
Imprime todas las líneas especificadas por lista. Lista es como se describe en "-c,
--characters = list "con una diferencia importante: la primera línea tiene el número 1, allí
no es la línea 0. Esto definitivamente es ineficaz para archivos grandes, si tiene una mezcla
rango positivo a negativo en su lista, ya que lee todo en la memoria.
De lo contrario, Perl podría optimizar esto, pero no sé si lo hace.

-m
--pareo
Imprima solo líneas coincidentes, es decir, aquellas que tengan suficientes caracteres o campos. Esta
implica "--only-delimited", por lo que se perderán las líneas de un solo campo con
"--fields = 0".

-p formato
--printf =formato
Aplicar formato (con \ escapes) a todos los campos o caracteres.

-s
--sólo delimitado
Imprime solo las líneas que contienen delimitadores.

& cortar -c 10-20, -5,25- $ (entrada)
& cut -c 'grep $$ _% 3, 0..99' $ (entrada) # Las primeras 1 columnas no son múltiplos de 100
& cut -d: --fields 0,4 --printf = '% 10s es% s \ n' / Etc / passwd

&eco [opción ...] cadena ...
& printf [opción ...] formato argumento ...
&sí [opción ...] cadena ...
Escribe todas las cadenas en stdout o en el archivo de salida dado. Ambos & echo y & yes agregan una nueva línea
al final. Las cadenas, o para & printf el formato, pueden contener escapes "\", ya que
se conocen de C o Unix moderno o Shell "echo". Sin embargo, son como en Perl doble
comillas, lo que significa algunas diferencias, como que no se permite una sola "\" al final.
Perl tiene algunos escapes más interesantes, pero los que podría esperar que hicieran algo
diferentes son:

\ cA Es un carácter de control ^ A.

\ u Reemplaza la siguiente letra.

\ U Sube el resto, o hasta la siguiente "\ E" o "\ L" si se encuentra.

\xHH, \X{Hhhh}
Es el valor de carácter del código hexadecimal dado. Tenga en cuenta que los códigos numéricos no
portátil a plataformas EBCDIC!

A diferencia de Unix "yes", & yes es exactamente como & echo, excepto que repite la salida para
siempre que pueda, normalmente hasta un "--output '| mando'" termina. Y, si y si
no tiene argumentos, por defecto es "y".

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -o,
--output = nombre de archivo, -O, --outfail, -v, --verbose "

-E
--no hay escapatoria
Trate "\" como literales normales.

-n
--sin nueva línea
No agregue una nueva línea después de la última cadena. (No entendido por & printf.)

& expr [opción ...] código perl ...
Imprime el valor escalar de perlcode, que puede escribirse como uno o varios argumentos.
Tenga en cuenta que los comandos integrados no son analizados por el Shell, por lo que "*", "(" o ">" no son
especial. Pero las comillas de cadena son analizadas por makepp, por lo que las cadenas de Perl deben estar entre comillas
dos veces, a menos que desee utilizar palabras clave. Si el valor es falso, esto falla. Nota
que, a diferencia de "expr" de Unix, la función de índice de Perl comienza en 0 (falso) y devuelve
-1 (verdadero) por falla.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -o,
--output = nombre de archivo, -O, --outfail, -v, --verbose "

-n
--sin nueva línea
No agregue una nueva línea después de la salida.

& expr ($ (VAR) - 3) * 2 <1 && -1 || 1
& expr "$ (VAR) - 3 * 2 <1? 'alegría': 'tristeza'" -o $ (salida)
- & expr $ (VAR) - 3 * 2 -o >> $ (salida)

& grep [opción ...] código perl nombre de archivo ...
y perl [opción ...] código perl nombre de archivo ...
& sed [opción ...] código perl nombre de archivo ...
Todos los archivos se leen línea por línea (a menos que haya dado una opción "--separator"), y
código perl se evalúa para cada línea, antes de que se imprima. & sed es similar a
"perl -pe", mientras que & grep solo genera aquellas líneas para las que código perl devuelve un verdadero
valor. & perl es similar a "perl -ne", solo genera lo que imprime explícitamente
en la sección de código perl. El contenido de la línea está disponible en $ _, que puede modificarse.

De estos tres, solo & grep fallará si no genera nada. Tenga en cuenta que no hay
opción ignorar mayúsculas y minúsculas, ya que lo haría con "/regexp / i ".

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -i,
--inpipe = shellcommand, -I, --infail, -o, --output = nombre de archivo, -O, --outfail, -r,
--record-size = número, -s, --separator = string, -S, --synclines, --verbose "

La opción "--synclines" solo tiene sentido con & perl si usa & Mpp :: Cmds :: print to
salida $ _. Solo & grep tiene opciones adicionales:

-c
--contar
Suprime la salida normal; en su lugar, imprima un recuento de líneas coincidentes. Con la "-v,
Opción --invert-match "(ver más abajo), cuenta las líneas que no coinciden.

-l
--lista
--archivos-con-coincidencias
Genere solo el nombre de los archivos con coincidencias. Cuando se combina con "-v,
--invert-match ", genera el nombre de los archivos con líneas que no coinciden (un poco
absurdamente pero compatible con Unix -vl). Cuando esto se combina con un doble
"-vv", muestra el nombre de los archivos sin coincidencias.

-v
--viceversa
--revertir-partido
--invertir partido
Invierta el sentido de coincidencia para seleccionar líneas que no coincidan. Tenga en cuenta que esto se esconde
la opción estándar "-v" que se debe dar como "--verbose".

-w nombre de archivo
--waste-file =nombre de archivo
Una papelera opcional para recoger las líneas rechazadas. Esto no es solo para
depurando su código de selección, sino también para dividir su entrada en dos. Al igual que con
la salida normal, puede modificar $ _ antes de devolver falso.

& sed s / foo / bar / f1 f2 f3 -o outfile # como sed s / foo / bar / f1 f2 f3> outfile
& sed '$$ _ = uc' f1 f2 f3 -o archivo de salida # como tr '[: inferior:]' '[: superior:]' f1 f2 f3
& grep '$$. % 3 'f1 f2 f3 -o outfile # eliminar cada tercera línea
& grep -c / match / i f1 f2 f3 # cuente las líneas que coinciden con 'match' con STDOUT

Sin presionarlo para generar accesores en masa, así es como puede hacerlo simplemente
poner un comentario de RO o RW entre cada tipo y el nombre de la variable deseada, todo en uno
línea. Los métodos getter y, opcionalmente, setter generados van al siguiente encontrado
sección pública o protegida:

# Cree el método get y quizás set desde "type / * R [OW] * / member;".
sub cxx_accesorios {
$ acc || = ''; # Candidato para el estado 5.10.0
if (m! ^ \ s * (. +?) \ s * / \ * \ s * R ([OW]) \ s * \ * / \ s * (. +?) \ s *;!) {
$ acc. = "#line $. \ n"; # Dile a C ++ de dónde vino esto
$ acc. = "conjunto vacío \ u $ 3 (const $ 1 & __ tmp) {$ 3 = __tmp;}"
si $ 2 eq 'W';
$ acc. = "const $ 1 & get \ u $ 3 () const {return $ 3;} \ n";
} elsif (/ ^ \ s * (?: público | protegido) \ s *: /) {
$ _. = $ acc;
$ acc = '';
}
}

% .cc:% .cc.in # Use & sed para el manejo de E / S
& sed --sync-lines & cxx_accessors $ (entrada) -o $ (salida)

&Instalar en pc [opción ...] archivo fuente archivo de destino
&Instalar en pc [opción ...] archivo fuente ... destino
& instalar --directory [opción ...] directorio ...
Mover o renombrar archivo fuente a archivo de destino, o múltiples archivo fuentepara destino con el
mismo nombre. Esta es la forma preferida de transferir los resultados de la compilación a su
ubicaciones de instalación.

Cada modificación del sistema de archivos realizada por & install se registra al final del
archivo al que apunta la variable de entorno $ INSTALL_LOG, o, si no está establecido, pero
estamos bajo un directorio con un RootMakeppfile (.mk), a un archivo de .install_log en eso
directorio, o bien a ese archivo en el directorio actual. Es posible que desee eliminar el
logfile antes de una serie de invocaciones de & install.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -v, --verbose"

-c
--Copiar
Copie los archivos en lugar de moverlos. Esto es preferible, ya que no fuerza
makepp para reconstruir el archivo la próxima vez. Pero no es el predeterminado, ya que
compatibilidad con otros programas de instalación.

-d
--directorio
En la tercera forma de este comando, cree todos los directorios dados y cualquier
directorios principales necesarios.

-g grupo de XNUMX
--group =grupo de XNUMX
Cambie la propiedad del grupo de los archivos de destino. El grupo puede estar dado por
nombre o numéricamente.

-l
--Enlace
Intente vincular los archivos. Si eso falla, copie.

--log =nombre de archivo
--logfile =nombre de archivo
Use nombre de archivo en lugar del archivo de registro normal.

-m modo
--mode =modo
Sets modo para todos los archivos o directorios de destino. El modo debe ser una cadena octal.

-o propietario
--owner =propietario
Cambie la propiedad de los archivos de destino. El propietario puede darse por nombre o
numéricamente.

-r
--resolver
--resolver-simbólico
--resolver-enlace-simbólico
--resolver-enlace simbólico
-S
--simbólico
- enlace simbólico
--enlace simbólico
Crea enlaces simbólicos en lugar de moverse. Estas opciones se pasan a & ln y se
descrito allí.

-s
--banda
Llama a la utilidad "strip", que debe estar en $ PATH, en los archivos de destino.

& ln [opción ...] archivo fuente archivo de destino
& ln [opción ...] archivo fuente
& ln [opción ...] archivo fuente ... destino
Enlace archivo fuente a archivo de destino, un experto archivo fuente al directorio actual o múltiples
archivo fuentepara destino con el mismo nombre

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -v,
--verboso"

-r
--resolver
--resolver-simbólico
--resolver-enlace-simbólico
--resolver-enlace simbólico
Esto es lo que siempre quisiste que hiciera "ln -s". Crea simbólico en lugar de duro
enlaces, no a las cadenas especificadas, sino realmente a los archivos dados.

-s
--simbólico
- enlace simbólico
--enlace simbólico
Cree enlaces simbólicos en lugar de duros.

Nota: En varios archivos o sistemas operativos, esta operación no es compatible. O es
es, por ejemplo, de Cygwin, pero no lo entienden los compiladores nativos de Windows, si usa uno.
Para un archivo MAKE que no puede cambiar, para obtener al menos algún tipo de resultado, & ln y "& cp -l
-s "puede copiar los archivos por usted (aunque no directorios). Para lograr esto,
Necesito exportar la siguiente variable antes de llamar a makepp:

exportar MAKEPP_LN_CP = 1
& ln --resolve o --symbolic copiará los archivos en lugar de crear un símbolo
.

exportar MAKEPP_LN_CP = 2
& ln copiará los archivos en lugar de crear un vínculo físico.

exportar MAKEPP_LN_CP = 3
Todas las invocaciones de & ln copiarán los archivos en lugar de crear cualquier tipo de
.

& mkdir [opción ...] directorio ...
Crea los directorios.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -v,
--verboso"

-m modo
--mode =modo
Sets modo para todos los directorios creados, independientemente de la umask. El modo debe ser un
cadena octal.

-p
--padre
También cree los directorios principales necesarios. Ignorar el error de creación del directorio
debido al directorio ya existente (incluso si fue creado al mismo tiempo por
otro proceso).

& mv [opción ...] archivo fuente archivo de destino
& mv [opción ...] archivo fuente
& mv [opción ...] archivo fuente ... destino
Mover o renombrar archivo fuente a archivo de destino, un experto archivo fuente al directorio actual o múltiples
archivo fuentepara destino con el mismo nombre

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -v,
--verboso"

y preproceso [opción ...] variable = definición ... nombre de archivo ...
Esto preprocesa los archivos exactamente de la misma manera que makepp lo hace con los archivos MAKE. Este es
más potente que & template, pero sintácticamente no se adapta a archivos con muchos
"$": signos, como Makefiles o scripts.

Las declaraciones condicionales, así como las declaraciones "incluir" / "_ incluir" (que aquí
ni compilar el archivo ni buscar hacia arriba), "perl" / "makeperl" / "perl_begin" o
Se procesan "sub" / "makesub", o cualquier declaración que defina dentro del archivo. Vacío
y se eliminan las líneas de comentarios.

Pero, en lugar de aprender las reglas de compilación, generará todas las líneas restantes después
Expansión de expresión "$ (...)". Para evitar que la declaración sea reconocida como tal,
puede precederlos con una expresión vacía "$ ()". Lo mismo se aplica a las líneas que
desea permanecer vacío o que debe conservar un signo de comentario principal. Asimismo, si un
la barra diagonal inversa final no es unir una línea con la siguiente, poner "$ ()" después de ella.

Una línea normal obtiene salida tal cual.
Una línea con $ (MAKEEXPRESSIONS) se expande y genera.
ifdef WANTTHIS # no obtiene salida ya sea que esté definido o no
puede que no obtenga salida
terminara si
incluir algunos archivos
_incluyen algunos archivos que pueden no existir # o -incluyen
$ () incluir una expresión vacía evita que se reconozca la palabra clave.
# Las líneas de comentario y las líneas vacías se tragan.

$ () # A menos que estén enmascarados con una expresión vacía.
PS
La expresión vacía evita \ $ ()
continuación de la barra invertida para que no se reconozca.

podría dar:

Una línea normal obtiene salida tal cual.
Una línea con lo que sea que se expanda y genere.
mucho contenido sorbido aquí ...
incluir expresión vacía evita que se reconozca la palabra clave.
# A menos que se enmascaren con una expresión vacía.

La expresión vacía evita \
continuación de la barra invertida para que no se reconozca.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -o,
--output = nombre de archivo, -O, --outfail, -S, --synclines, -v, --verbose "

-a
--asignación
También trate las asignaciones dentro de los archivos como lo haría makepp. Por desgracia, esas líneas no pueden ser
enmascarado con un "$ ()" vacío, porque es legal construir nombres de variables con
Expresiones Esto además reconoce las declaraciones "definir",
"exportar" / "no exportar" y "anular" (estos se pueden enmascarar con "$ ()").

-h\\%hachís
--hashref = \\%hachís
Esto permite la preasignación de los valores de las variables, incluidos los largos, que no es fácil
pasado en un comando. La expresión pasada puede ser cualquier código Perl que devuelva un
referencia hash. Esto se fusiona con cualquier otra variable pasada al comando,
incluso desde otra opción "--hashref".

& rm [opción ...] nombre de archivo ...
Elimine archivos si tiene permiso de escritura en el directorio. Esto es lo que Unix "rm -f" haría
eliminar, ya que tiene una protección especial para uso interactivo que no es necesaria en un
Archivo Make.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -v, --verbose"

-f
--fuerza
Esto evita quejarse de archivos inexistentes. Ese es un efecto secundario este
tiene en Unix, y la única que tiene sentido aquí.

-m
--metainfo
Además de los archivos dados, esto también elimina la metainformación makepp
almacena sobre ellos en el directorio .makepp. Así makepp olvida todo lo que alguna vez supo
sobre los archivos dados. Si el directorio .makepp queda vacío después de esto, también
esta borrado.

Esto también eliminará los directorios dados, pero solo si están vacíos. Facilitar
esto, eliminará los directorios en último lugar, en orden de profundidad descendente. Así que puedes
utilice expresiones "**" para eliminar jerarquías completas. Aquí hay un ejemplo que se puede encontrar en
muchos archivos make de nivel superior. Tenga en cuenta que existe una utilidad "makeppclean" que puede hacer
esto de manera más eficiente.

$ (falso cleanold):
& rm -fm $ (solo obsoleto ** / *)

$ (falso limpio): cleanold
& rm -f $ (comodín ** / *. [ao])

$ (falso distclean): limpio
& rm -fm $ (solo objetivos ** / *)

&clasificar [opción ...] nombre de archivo ...
Ordena todos los archivos juntos en orden lexicográfico. Esto es ineficaz para bastante grandes
archivos, porque ocurre completamente en la memoria. Fallará si el tamaño combinado de
todos los archivos exceden la memoria a la que tiene derecho.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -i,
--inpipe = shellcommand, -I, --infail, -o, --output = nombre de archivo, -O, --outfail,
--record-size = número, -s, --separator = string, -v, --verbose "

-c código perl
--compare =código perl
código perl representa un bloque de clasificación de Perl, con los dos candidatos de clasificación en $ ay
$ b.

-n
--numérico
- ordenación numérica
Este ordena ordena numéricamente al comienzo de los registros. El espacio en blanco principal es
omitido. Puede utilizar "--transform" y "--detransform" si los números no están en
el principio.

-r
--contrarrestar
Imprima los resultados en orden inverso. Tenga en cuenta que esto oculta la opción estándar
"-r" que se debe dar como "--record-size".

-t código perl
--transform =código perl
-d código perl
--detransform =código perl
Si tiene un código complejo, la clasificación se vuelve cada vez más cara en proporción a
el número de registros n, porque el código se llama O (n Iniciar sesión(n)) veces. Para evitar
que, puede permitir que Perl se concentre en la ordenación, modificando primero el
cadenas, de modo que la extracción complicada de criterios de búsqueda se produce una vez por registro,
y volver a modificarlos, una vez clasificados.

Si se dan estas opciones, el "--transform" código perl se asigna a los registros
en $ _ uno tras otro, pudiendo modificarlos. Después de ordenar, el "--detransform"
código perl se asigna a los registros modificados en $ _ uno tras otro, y puede
modificarlos de nuevo. Por lo general, utilizará ninguna de estas opciones o ambas, a menos que
desea generar líneas modificadas.

Convertir las cadenas en una estructura de criterios de clasificación extraídos, que su
"--comparar" código perl puede recoger se conoce como la Transformada de Schwartzian (ST).
Empacar todo en la propia cadena, de modo que ningún "--compare" código perl is
necesario, lo que permite que se lleve a cabo toda la clasificación sin realizar el costoso Perl
código, se conoce como Transformada de Guttmann-Rosler (GRT). Puedes encontrar consejos por
buscando esos nombres en la web.

# Ordene las expresiones numéricas por valor de manera costosa ($$ protege $ de la expansión de makepp)
& sort --compare 'eval ($$ a) <=> eval ($$ b)' $ (entrada) -o >> $ (salida)

# ST para clasificación que no distingue entre mayúsculas y minúsculas
& sort -t '[lc, $$ _]' -c '$$ a -> [0] cmp $$ b -> [0]' -d '$$ _-> [1]' $ (entrada) - o >> $ (salida)

# GRT usando funciones de modificación definidas en otra parte del Makeppfile
& sort -t & transform -d & detransform $ (entrada) -o >> $ (salida)

-u
--uniq
--único
Después de ordenar, elimine los duplicados. Estas son lneas idnticas, o si el
Se da la opción "--compare", las que código perl informes como equivalentes.

&plantilla [opción ...] macro = definición ... nombre de archivo ...
Este es un preprocesador de macros, no tan poderoso como el preprocesador de C o "m4".
Vea y preprocese para una alternativa más poderosa. Se inspiró en la macro de automake.
reemplazo en Makefile.am y Makefile.in. Pero va más allá de eso. Cualquier texto normal
pasa sin cambios. Las construcciones especiales están delimitadas por defecto con "@". Ellos
debe caber en una línea a menos que pase uno de "-r, --record-size" o "--separator".

@# comentario @
Tenga en cuenta que a pesar de tomar prestado de la sintaxis de comentario de fin de línea "#" del script, este es
un comentario en línea.

@MACRO@
Esta construcción se reemplaza por el valor de la MACRO. Los nombres de macro deben comenzar con
una letra o guión bajo, seguido de cualquier número de letras, guiones bajos, menos o
puntos. A diferencia de los nombres de makepp, el subrayado y el signo menos no son equivalentes.

@MACRO(arg1, arg2...) @
Como el primero, pero parametrizado. Los argumentos reemplazan $ 1 a $ 9 o
PSnúmero}" en el valor. O, si el valor es una función de Perl, se pasan como
parámetros normales. Luego, el resultado reemplaza la construcción completa. Un nivel de
El anidamiento macro es posible porque los argumentos entre paréntesis pueden contener
Invocaciones "@ MACRO @", como en "@f (@x @) @", donde "@ x @" se expande antes de ser
reemplazado en el cuerpo de "f".

@incluir(nombre de archivo)@
Ésta es la única macro predefinida. Es reemplazado por el & template-procesado
contenido del archivo nombrado. Como todas las macros, esto puede ocurrir en medio de una
línea. Por desgracia, debido a eso, "-S, --synclines" ignora la inclusión del archivo, lo que hace
todo parece provenir del archivo incluido.

@MACRO=definición@
@MACRO?=definición@
Esto define una macro dentro del archivo. Esto es reemplazado por nada. El segundo
El formulario solo tiene efecto si la macro no se definió, presumiblemente en el comando
la línea.

@MACRO { código perl }@
Esto también define una macro, cuyo cuerpo es un sub Perl. Los argumentos, si
hay alguno, se pasa como @_.

@{ código perl }@
Esto ejecuta el código perl inmediatamente y se reemplaza por el valor de retorno.

Hasta ahora, solo hemos visto una sintaxis para incrustar elementos especiales. Hay otro
sintaxis multilínea, y ambos permiten una variación para suprimir una nueva línea. Estos son los
sintaxis incorporadas (que se pueden configurar mediante las opciones siguientes). Aquí SPECIAL representa
cualquiera de las construcciones que se muestran arriba:

@SPECIAL@
@SPECIAL@\
Esto puede aparecer multiplicado en cualquier lugar de una línea. La variante seguida inmediatamente por
"\" solo funciona al final de la línea. También reemplaza el siguiente salto de línea.

@@SPECIAL@@ Normal texto @@
@@SPECIAL@@ Normal texto @@ \
Este es como el anterior. Sin embargo, el texto normal, que también se reemplaza,
puede abarcar varias líneas. Puede poner las partes especiales en líneas de comentarios alrededor
código fuente que solo se necesita en un script desinstalado, para ser eliminado o
reemplazado durante el proceso de instalación:

# @@ # las siguientes 2 líneas desaparecerán @@
echo Está ejecutando la versión desinstalada de este script
#@@
# @@ REPLAMCENT @@
echo Algo más estará aquí
#@@

Un ejemplo sin sentido que muestra las diversas posibilidades:

@ m1 = alguna definición @ \
@ m2 = foo $ 1 barra @ \
@ middle_of_arg = iddl @ \
@ m1 @ @ m2 (m @ middle_of_arg @ e) @
@@ m2 (muchas líneas) @@
...
@@ texto sin formato 1 + 2 = @ {1 + 2} @

se convierte en

alguna definición foo barra intermedia
foo muchas líneas barra texto plano 1 + 2 = 3

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -i,
--inpipe = shellcommand, -I, --infail, -o, --output = nombre de archivo, -O, --outfail, -r,
--record-size = número, --separator = cadena, -S, --synclines, -v, --verbose "

-d
--definido
Reemplace solo las instancias de macros que estén realmente definidas. Sin esta opcion
los indefinidos no serán reemplazados por nada.

-h\\%hachís
--hashref = \\%hachís
Esto permite la preasignación de los valores macro, incluidos los largos, que no son fáciles
pasado en un comando. La expresión pasada puede ser cualquier código Perl que devuelva un
referencia hash. Esto se fusiona con cualquier otra macros pasada al comando,
incluso desde otra opción "--hashref". Un valor hash también puede ser un código
referencia, en ese caso se llama a la función, como con "@macro { código perl } @ "
definiciones.

-s /prefijo sufijo/
--simple =/prefijo sufijo/
Use prefijo y sufijo antes y después SPECIAL respectivamente en lugar de "@". los
El primer carácter es el separador y no es necesario que sea una barra. Estos valores son Perl
expresiones regulares. No debe introducir agrupaciones como "(...)", pero "(?: ...)" está bien.

-m / prefijo / sufijo / prefijo / [aftersuffix /]
--multiline =/ prefijo / sufijo / prefijo / [aftersuffix /]
Use prefijo, sufijo y prefijo antes y después SPECIAL y al final del
bloque respectivamente en lugar de "@@". Si sufijo posterior también se da, el nombre de la macro
debe repetirse antes. El primer carácter es el separador y no es necesario
una barra. Por ejemplo, un XML-ish, al que debe agregar "--defined" si desea
preservar otras etiquetas, no definidas por usted:

--definido --simple = | <| /> | --multiline = | <|> | |

O, mejor, utilice las instrucciones de procesamiento " ", destinado a tal fin:

--defined --simple = '| <\? | \?> |'

O, si desea combinar esto con "& entidad;" sintaxis para la macro simple
reemplazos (conservando las entidades numéricas "☺" que no son comentarios):

--definido - simple = '_ (?: & (?! #) | <\?) _ (?:; | \?>) _'

&tocar [opción ...] nombre de archivo ...
Actualiza las marcas de tiempo de modificación y acceso de cada archivo a ahora. Si el archivo
no existe, se crea.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -v, --verbose"

& desinstalar [opción ...] [nombre del archivo ...]
Desinstale los archivos previamente instalados por & install. los nombre de archivos son archivos de registro escritos
por & install. Si no se proporciona ninguno, ni una opción "--inpipe", lee el archivo de registro predeterminado
de & instalar.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -i,
--inpipe = shellcommand, -I, --infail, -v, --verbose "

& uniq [opción ...] nombre de archivo ...
Descarte todas menos una de las sucesivas líneas iguales.

"Opciones estándar": "-A, --args-file, --arguments-file = nombre de archivo, -f, --force, -i,
--inpipe = shellcommand, -I, --infail, -o, --output = nombre de archivo, -O, --outfail, -r,
--record-size = número, -s, --separator = string, -S, --synclines, -v, --verbose "

-c código perl
--compare =código perl
Este código perl obtiene las líneas anterior y actual en $ ay $ b y devolverá
verdadero si considera que las dos líneas son iguales.

& uniq --compare = 'lc ($$ a) eq lc $$ b' $ (entradas) -o $ (salida)

Emulable comandos
Varias cosas no están integradas, pero se pueden lograr con otros comandos:

awk Utilice & sed.

chgrp
chown
¡Estos comandos en su mayoría no son portátiles! O no harán nada silenciosamente o fallarán,
dependiendo del sistema. Generalmente, solo root puede realizar estas operaciones, que es
por qué solo están disponibles a través del comando & install.

cpp Use & preprocess o & template.

datos
Cualquiera de estos parcialmente hace lo mismo:

& expr localtime
& expr gmtime

false
Utilice & expr sin argumento o 0.

cabeza
cola
Puede lograr el mismo resultado con & grep o "& cut --lines":

& grep 1..10 file # primeras diez líneas
& grep 10..eof file # todas las líneas desde el décimo en adelante
& cortar --líneas -10 ..- 1 archivo # últimas diez líneas

Tenga en cuenta que 1..10 en & grep es el operador flip-flop de número de línea de Perl, que
comienza en 1. No comience en 0, o el flip-flop nunca se hará realidad.

fmt Esto se menciona aquí ya que Perl proporciona una funcionalidad relacionada. Sin embargo tuve
problemas al usar la declaración de "formato" en un archivo MAKE. Lo que funciona es el
función "formline" subyacente. Por ejemplo, para transformar un archivo csv que consta de nombres y
precios a formato tabular:

subcsv2txt {
formline "\ @ <<<<<<<<<<<<<<< ^ ###########. ## \ n", split ',';
$ _ = $ ^ A;
$ ^ A = '';
}

% .txt:% .csv
& sed & csv2txt $ (entrada) -o $ (salida)

m4 Use & preprocess o & template.

rmdir
Utilice & rm.

tr Utilice & sed.

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