makepp_builtins - Online nel cloud

PROGRAMMA:

NOME

makepp_builtins -- Comandi incorporati in makepp

DESCRIZIONE

A: awk, C: &gatto,
chgrp,
&chmod,
chown,
&cp,
cpp,
&tagliare, D: quando, E: &eco,
&espr, F: falso,
FMT, G: &grep, H: capo, I: &installare, L: &ln, M: m4,
&mkdir,
&mv, P: &perla,
&preelaborazione,
&printf, R: &rm,
rmdir, S: &sed,
&ordinare, T: coda,
&modello,
&tocco,
tr, U: &disinstalla,
&unico, Y: &sì

C'è una speciale possibilità simile a Shell per chiamare comandi incorporati in una regola. Il solo
i metacaratteri riconosciuti sono segni di commento, barre rovesciate, virgolette singole e doppie. Soltanto
può essere dato un comando per riga e il reindirizzamento I/O non è disponibile (vedi "-i" e "-o"
sotto invece).

Questi comandi iniziano con "&", che è il carattere della funzione in Perl e non un valido
primo carattere in Shell. Se non è possibile trovare alcun comando integrato con quel nome, anche questo è
la sintassi per chiamare uno script esterno all'interno dell'istanza Perl che esegue la regola.
Vedi "correre".

Questi comandi, così come quelli autodefiniti e gli script Perl possono anche essere chiamati come a
make, restituendo lo standard output. Ciò richiede che perl sia compilato per PerlIO.
Le nuove righe vengono convertite in spazi, tranne quando valutate all'interno di un'istruzione "define".

PRIME PAROLE ;= $(&cut -d' ' -f0 $(FILES))

Quando questi comandi non sono rientrati come azioni della regola, vengono eseguiti durante la lettura del
makefile. Puoi anche accedere a questi comandi da solo, ad esempio se hai bisogno di alcune funzionalità
non disponibile nella controparte Unix, tramite il comando makeppbuiltin.

Questi comandi sono principalmente basati sulla variante GNU. Ma molte opzioni (come --backup,
--interactive o --recursive) non hanno molto senso in un makefile. Quindi anche se
sarebbero facili da implementare in Perl, sono stati omessi. Anche molti comandi Unix
offrono una varietà di opzioni che coprono casi abbastanza complicati (ad es. campo di ordinamento
specifiche) pur essendo intrinsecamente limitato. Consentire l'accesso a Perl, che è
presente comunque, dà molto più potere qui.

Gli elenchi di nomi di file possono essere vuoti, il che rende sicuro chiamare questi comandi con un deselezionato
elenco. Le opzioni nella loro forma breve possono essere incollate insieme come in "-ab" invece di "-a -b".
Nella forma lunga gli argomenti possono essere dati incollati con un segno "=" o separatamente.
Nella forma breve possono essere forniti incollati direttamente o separatamente.

Standard Opzioni
Alcune opzioni sono comuni a diversi comandi incorporati, sebbene la forma breve sia talvolta nascosta da
l'opzione di un comando (come in "&cut -f"):

-A Nome del file
--args-file=Nome del file
--file-argomenti=Nome del file
Leggi il file e analizzalo come possibilmente separato da spazi bianchi e/o newline
opzioni.

-f
--vigore
Forza la creazione del file o dei file previsti dai parametri, anche se di tipo diverso
di file o directory vuota con quel nome esiste già. Questo deve precedere il "-o,
--output=nomefile" se deve avere qualche effetto su questo.

-i comando shell
--inpipe=comando shell
Avviare i comandi Shell e reindirizzare l'output nel builtin. Ci può facoltativamente
essere un "|" finale carattere, per indicare che si tratta di una pipe. Con questa opzione no
è necessario fornire i nomi dei file. Ma se vuoi eseguire il builtin su entrambi i file e
l'output della pipe, è necessario utilizzare "-" come nome file per l'output della pipe. Il tubo è
svuotato, ma, a meno che non si dia anche "--infail", il comando non è atteso, quindi
può terminare in parallelo. Questa opzione è necessaria perché non c'è reindirizzamento
sintassi.

-I
--fallire
Se un comando Shell "--inpipe" fallisce, anche il builtin corrente fallisce.
Attualmente non funziona su Strawberry e Win ActiveState, a causa del
modo svogliato in cui emulano fork/exec di Unix. Cygwin ha ragione però.

-o Nome del file
--uscita=Nome del file
Scrivi l'output su questo file, piuttosto che su stdout. Il nome del file può avere uno di questi
le forme:

Nome del file
>Nome del file
Scrivi semplicemente su file.

>>Nome del file
Aggiungi a (non necessariamente) file esistente.

+<Nome del file
Apri anche il file per l'input, consentendo la modifica sul posto. Con questa variante di opzione
non è necessario fornire nomi di file di input. Ma se vuoi eseguire il builtin su
più file, devi usare "-" come nome file di input per questo. In effetti il
l'output viene scritto in un file temporaneo che viene spostato in filename alla fine.

|comando shell
Convogliare l'output del built-in ai comandi Shell.

Questa opzione è necessaria perché non esiste una sintassi di reindirizzamento.

-O
--fallimento
Se un comando Shell "--output" fallisce, anche l'attuale built-in fallisce.

-r numero
--dimensione-record=numero
Imposta localmente $/ per il builtin corrente. Questo divide l'input in record di lunghezza
numero piuttosto che riga per riga. Se numero è zero, ogni file di input nel suo insieme è uno
record.

-s stringa
--separatore=stringa
Imposta localmente $/ per il builtin corrente. Questo divide l'input su stringa piuttosto che linea
per linea.

-S
--sincline
Genera "#linea""NO"" """FILE"""" e "#riga""NO" linee, comprese da molti C-like
le lingue.

-v
--verboso
Documentare le modifiche al file system. Questo deve precedere altre opzioni se deve
documentare il loro effetto. Se passi questa opzione a makepp stesso, è come se avessi
dato per ogni singolo comando incorporato.

incorporato comandi
Ci sono due motivazioni per avere comandi incorporati in makepp. Il primo è quello di offrire a
insieme di utilità, che, a differenza dei comandi Shell, sono garantiti per funzionare allo stesso modo
ovunque, come "&echo -n" o "&mkdir -p", e risparmiandoti il ​​fastidio di trovare il percorso
per &installare e capire le sue opzioni estremamente variabili. In un ambiente di compilazione,
è utile avere l'opzione "--synclines", che normalmente solo "m4" fornisce, su tutti
filtri.

L'altra è una questione di efficienza. In generale dovrebbero essere evitati costosi fork/exec
ove ragionevolmente possibile. Su emulazioni Unix come Cygwin o BS2000/Posix, questo diventa un
vittoria notevole. Ma, anche su Linux, quando la suite di test makepp è stata convertita da
comandi esterni ai builtin, si è registrato un risparmio complessivo del 3% sull'utilizzo della CPU dell'utente e del 15%
utilizzo della CPU del sistema. (I test sono ovviamente pesanti sulle azioni primitive e difficilmente chiamano il
compilatore.)

Anche la coerenza è un problema, anche se non riformeremo Unix. Normalmente comandi
hanno varie sfumature di espressioni regolari. E molti inventano lingue, ciascuno
diverso ovviamente, per fare qualcosa (ad esempio "expr", "sed" ...), o opzioni complesse per
specificando campi, delimitatori, colonne (es "cut", "sort" ...).

Qui invece, tutto ciò che è stravagante viene semplicemente gestito da Perl, conferendo coerenza ad entrambi
tutti i comandi e molta più potenza di un intero gruppo di opzioni. Meglio ancora, qualsiasi Codice Perl
questi comandi vengono eseguiti per te, vengono eseguiti nel pacchetto del Makefile. Quindi, piuttosto che
inserisci il codice Perl nell'azione della regola, puoi definire funzioni e variabili e usarle
all'interno dei comandi:

sub mio_filtro {
# Restituisce vero se $_ è desiderabile
}
%.out: %.in Makeppfile
&grep &mio_filtro $(input) -o $(output)

Se usi funzioni o variabili Perl nei tuoi comandi, makepp non lo riconosce come
una dipendenza. In genere è più sicuro dire tutto a makepp, quindi le regole che usano Perl
gli elementi dovrebbero dipendere dal makefile o dal modulo che fornisce quegli elementi, come mostrato in
esempio sopra.

D'altra parte l'ignoranza può essere desiderabile se si dispone di un programma che mescola il programmatico
e aspetti di configurazione in un unico file. Un esempio potrebbe essere un file WSDL contenente sia a
definizione dell'interfaccia del servizio Web e un indirizzo IP. Puoi preelaborare questo file con
il comando &template per correggere la configurazione, ma non lasciare che makepp se ne accorga.

&gatto [opzione ...] Nome del file ...
Concatena tutti i file in uno solo.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=nomefile, -O, --outfail, -S,
--sincline, -v, --verbose"

&chmod [opzione ...] modo Nome del file ...
Set modo per tutti i file dati. La modalità deve essere una stringa ottale.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -v, --verbose"

&cp [opzione ...] file sorgente file di destinazione
&cp [opzione ...] file sorgente
&cp [opzione ...] file sorgente ... destinazione
Copia file sorgente a file di destinazione, uno file sorgente nella directory corrente o multiple
file sorgentes alla destinazione con lo stesso nome.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -v,
--verboso"

-l
--collegamento
Prova a collegare i file. Se fallisce, prova il collegamento simbolico, se anche questo lo è
richiesto, altrimenti copia.

-s
--simbolico
--link-simbolico
--link simbolico
Prova a collegare simbolicamente i file. Se fallisce, copia.

Vedere la nota in &ln.

&tagliare [opzione ...] Nome del file ...
Stampa parti di righe selezionate da ciascun file o righe selezionate, contando su tutto
File. L'output è separato dal delimitatore che per impostazione predefinita è TAB per i campi e
stringa vuota per i caratteri.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=nomefile, -O, --outfail, -r,
--record-size=numero, --separator=stringa, -S, --synclines, -v, --verbose"

-c stratagemma
--caratteri=stratagemma
Stampa tutti i caratteri specificati da stratagemma. Lista può essere qualsiasi espressione Perl
restituendo un elenco di numeri interi. Gli interi possono essere positivi, a partire da
zero per contare dall'inizio o negativo per contare dalla fine. A differenza di Unix
"taglia", l'ordine da te richiesto viene rispettato.

A differenza dell'operatore slice di Perl in cui un intervallo ".." deve essere positivo o
negativo, &cut consente di iniziare con un positivo e finire con un negativo. Ma
questo è disponibile solo se la tua espressione consiste solo di numeri, virgole e
"..". Es. "1..-2" significa tutto tranne il primo (0) e l'ultimo (-1).

L'espressione list può esaminare l'intera riga in $_. Le modifiche a ciò saranno
ignorato, tuttavia, perché quando questa espressione viene valutata la riga è già
stato suddiviso nella variabile autosplit di Perl @::F. I numeri che restituisci sono in effetti
indici a tale elenco.

-d stringa
--delimitatore=stringa
Imposta un nuovo delimitatore per i campi di input e output. A differenza del "taglio" di Unix, questo potrebbe avere
qualsiasi lunghezza.

-E
--nessuna via d'uscita
Tratta "\" come normali letterali per "-p, --printf=format".

-f stratagemma
--campi=stratagemma
Stampa tutti i gruppi specificati da stratagemma. Lista è come descritto in "-c,
--characters=list". Nota che questo nasconde l'opzione standard "-f" che deve essere
dato come "--forza".

-l stratagemma
--linee=stratagemma
Stampa tutte le righe specificate da stratagemma. Lista è come descritto in "-c,
--characters=list" con una grande differenza: la prima riga ha il numero 1, lì
non è la riga 0. Questo è decisamente inefficiente per i file di grandi dimensioni, se si dispone di un misto
intervallo da positivo a negativo nella tua lista, poiché legge tutto nella memoria.
Altrimenti Perl potrebbe ottimizzarlo, ma non so se lo fa.

-m
--corrispondenza
Stampa solo le righe corrispondenti, cioè quelle che hanno abbastanza caratteri o campi. Questo
implica "--only-delimited", motivo per cui ti mancheranno le linee a campo singolo con
"--campi=0".

-p formato
--printf=formato
Applica il formato (con \escapes) a tutti i campi o caratteri.

-s
--solo-delimitato
Stampa solo le righe che contengono delimitatori.

&cut -c 10-20,-5,25- $(input)
&cut -c 'grep $$_ % 3, 0..99' $(input) # prime 1 colonne non multiple di 100
&cut -d: --fields 0,4 --printf='%10s è %s\n' /etc/passwd

&eco [opzione ...] stringa ...
&printf [opzione ...] formato argomento ...
&sì [opzione ...] stringa ...
Scrive tutte le stringhe nello stdout o nel file out specificato. Sia &echo che &yes aggiungono una nuova riga
alla fine. Le stringhe, o per &printf il formato, possono contenere caratteri di escape "\", in quanto
sono conosciuti dal C o dal moderno Unix o Shell "echo". Sono comunque come in Perl double-
virgolette, il che significa alcune differenze, come il fatto che un singolo "\" finale non è consentito.
Perl ha alcune fughe più interessanti, ma quelle che potresti aspettarti facciano qualcosa
diversi sono:

\cA È un carattere di controllo ^A.

\u Mette in maiuscolo la seguente lettera.

\U In maiuscolo il resto, o fino al successivo "\E" o "\L" se trovato.

\xHH, \X{Hhhh}
È il valore del carattere del codice esadecimale specificato. Si noti che i codici numerici non lo sono
portabile su piattaforme EBCDIC!

A differenza di Unix "yes", &yes è esattamente come &echo, tranne per il fatto che ripete l'output per
finché può, in genere fino a quando un "--output '| comando'" termina. E, se &sì
non ha argomenti, il valore predefinito è "y".

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -o,
--output=nomefile, -O, --outfail, -v, --verbose"

-E
--nessuna via d'uscita
Tratta "\" come letterali normali.

-n
--nessuna riga
Non aggiungere una nuova riga dopo l'ultima stringa. (Non compreso da &printf.)

&espr [opzione ...] codice perl ...
Stampa il valore scalare di perlcode, che può essere scritto come uno o più argomenti.
Nota che i comandi incorporati non vengono analizzati dalla Shell, quindi "*", "(" o ">" non lo sono
speciale. Ma le virgolette delle stringhe vengono analizzate da makepp, quindi le stringhe Perl devono essere virgolette
due volte, a meno che tu non voglia usare bareword. Se il valore è falso, questo fallisce. Nota
che -- a differenza di Unix "expr" -- la funzione indice di Perl inizia da 0 (false) e ritorna
-1 (vero) per errore.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -o,
--output=nomefile, -O, --outfail, -v, --verbose"

-n
--nessuna riga
Non aggiungere una nuova riga dopo l'output.

&espr ($(VAR) - 3) * 2 < 1 && -1 || 1
&expr "$(VAR) - 3 * 2 < 1 ? 'gioia' : 'dolore'" -o $(output)
-&expr $(VAR) - 3 * 2 -o >>$(output)

&grep [opzione ...] codice perl Nome del file ...
&perl [opzione ...] codice perl Nome del file ...
&sed [opzione ...] codice perl Nome del file ...
Tutti i file vengono letti riga per riga (a meno che tu non abbia fornito un'opzione "--separator") e
codice perl viene valutato per ogni riga, prima di essere stampato. &sed è simile a
"perl -pe", mentre &grep emette solo quelle righe per le quali codice perl restituisce un vero
valore. &perl è simile a "perl -ne", emette solo ciò che stampi esplicitamente
nel codice perl. Il contenuto della riga è disponibile in $_, che può essere modificato.

Di questi tre, solo &grep fallirà se non emette nulla. Nota che non c'è
ignore-case, poiché lo faresti con "/espressione regolare/i".

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=nomefile, -O, --outfail, -r,
--record-size=numero, -s, --separator=stringa, -S, --synclines, --verbose"

L'opzione "--synclines" ha senso con &perl solo se usi &Mpp::Cmds::print to
uscita $_. Solo &grep ha opzioni extra:

-c
--contare
Sopprimere l'uscita normale; stampa invece un conteggio delle righe corrispondenti. Con il "-v,
--invert-match" (vedi sotto), conta le linee non corrispondenti.

-l
--elenco
--file-con-corrispondenze
Emetti solo il nome di quei file con corrispondenze. Quando questo è combinato con "-v,
--invert-match", emette il nome dei file con righe che non corrispondono (un po'
assurdamente ma compatibile con Unix -vl). Quando questo è combinato con un raddoppiato
"-vv", emette il nome dei file senza corrispondenze.

-v
--vice versa
--ripristina-corrispondenza
--invertire la corrispondenza
Invertire il senso di corrispondenza, per selezionare le linee non corrispondenti. Nota che questo nasconde
l'opzione standard "-v" che deve essere data come "--verbose".

-w Nome del file
--file-rifiuti=Nome del file
Un cestino opzionale per la raccolta delle linee scartate. Questo non è solo per
debugging del codice di selezione, ma anche per dividere in due l'input. come con
l'output normale, puoi modificare $_ prima di restituire false.

&sed s/pippo/bar/ f1 f2 f3 -o outfile # come sed s/pippo/bar/ f1 f2 f3 >outfile
&sed '$$_ = uc' f1 f2 f3 -o outfile # come tr '[:lower:]' '[:upper:]' f1 f2 f3
&grep '$$. % 3' f1 f2 f3 -o outfile # elimina ogni 3a riga
&grep -c /match/i f1 f2 f3 # conta le righe che corrispondono a 'match' a STDOUT

Senza spingerti a generare in massa accessori, ecco come potresti farlo semplicemente
inserendo un commento di RO o RW tra ogni tipo e il nome della variabile desiderata, tutto su uno
linea. I metodi getter generati e facoltativamente setter vanno nel successivo found
sezione pubblica o protetta:

# Crea un metodo get e magari set da "type /* R[OW] */ member;".
sub cxx_accessori {
$acc ||= ''; # Candidato per lo stato 5.10.0
if( m!^\s*(.+?)\s*/\*\s*R([OW])\s*\*/\s*(.+?)\s*;! ) {
$acc .= "#riga $.\n"; # Dì a C++ da dove viene questo
$acc .= "void set\u$3( const $1 &__tmp ) { $3 = __tmp; }"
se $2 eq 'W';
$acc .= "const $1 &get\u$3() const { return $3; }\n";
} elsif( /^\s*(?:pubblico|protetto)\s*:/ ) {
$_ .= $ acc;
$acc = '';
}
}

%.cc: %.cc.in # Usa &sed per la gestione dell'I/O
&sed --sync-lines &cxx_accessors $(input) -o $(output)

&installare [opzione ...] file sorgente file di destinazione
&installare [opzione ...] file sorgente ... destinazione
&installa --directory [opzione ...] elenco ...
Sposta o rinomina file sorgente a file di destinazione, o multiplo file sorgentes alla destinazione con la
stesso nome. Questo è il modo preferito per trasferire i risultati della build al loro finale
luoghi di installazione.

Ogni modifica al file system eseguita da &install viene registrata alla fine del
file puntato dalla variabile d'ambiente $INSTALL_LOG, o, se non è impostato ma
siamo in una directory con a RootMakeppfile (.mk), in un file di .install_log In ciò
directory, oppure a quel file nella directory corrente. Potresti voler eliminare il
logfile prima di una serie di chiamate di &install.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -v, --verbose"

-c
--copia
Copia i file invece di spostarli. Questo è preferibile, in quanto non forza
makepp per ricostruire il file la prossima volta. Ma non è l'impostazione predefinita, perché
compatibilità con altri programmi di installazione.

-d
--directory
Nella terza forma di questo comando crea tutte le directory date e qualsiasi
directory padre necessarie.

-g gruppo
--gruppo=gruppo
Modificare la proprietà del gruppo dei file di destinazione. Il gruppo può essere dato da
nome o numericamente.

-l
--collegamento
Prova a collegare i file. Se fallisce, copia.

--log=Nome del file
--file di registro=Nome del file
Usa il Nome del file invece del normale file di registro.

-m modo
--modalità=modo
Set modo per tutti i file o le directory di destinazione. La modalità deve essere una stringa ottale.

-o proprietario
--proprietario=proprietario
Modificare la proprietà dei file di destinazione. Il proprietario può essere indicato per nome o
numericamente.

-r
--risolvere
--risolvere-simbolico
--resolve-link-simbolico
--resolve-link simbolico
-S
--simbolico
--link-simbolico
--link simbolico
Crea collegamenti simbolici invece di spostarsi. Queste opzioni vengono passate a &ln e sono
lì descritto.

-s
--striscia
Richiama l'utilità "strip", che deve essere nel $PATH, sui file di destinazione.

&ln [opzione ...] file sorgente file di destinazione
&ln [opzione ...] file sorgente
&ln [opzione ...] file sorgente ... destinazione
Link file sorgente a file di destinazione, uno file sorgente nella directory corrente o multiple
file sorgentes alla destinazione con lo stesso nome.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -v,
--verboso"

-r
--risolvere
--risolvere-simbolico
--resolve-link-simbolico
--resolve-link simbolico
Questo è ciò che hai sempre voluto che "ln -s" facesse. Crea simbolico piuttosto che difficile
collegamenti, non alle stringhe specificate, ma realmente ai file dati.

-s
--simbolico
--link-simbolico
--link simbolico
Crea collegamenti simbolici piuttosto che reali.

Nota: Su vari file o sistemi operativi, questa operazione non è supportata. oppure
è, ad esempio da Cygwin, ma non compreso dai compilatori nativi di Windows, se ne usi uno.
Per un makefile che non puoi cambiare, per ottenere almeno una sorta di risultato, &ln e "&cp -l
-s" può invece copiare i file per te (non le directory però). Per ottenere ciò, tu
è necessario esportare la seguente variabile prima di chiamare makepp:

esporta MAKEPP_LN_CP=1
&ln --resolve o --symbolic copierà i file invece di creare un simbolico
collegamento.

esporta MAKEPP_LN_CP=2
&ln copierà i file invece di creare un collegamento reale.

esporta MAKEPP_LN_CP=3
Tutte le chiamate di &ln copieranno i file invece di creare entrambi i tipi di
collegamento.

&mkdir [opzione ...] elenco ...
Crea le directory.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -v,
--verboso"

-m modo
--modalità=modo
Set modo per tutte le directory create, indipendentemente dall'umask. La modalità deve essere an
stringa ottale.

-p
--genitore
Crea anche tutte le directory principali necessarie. Ignora l'errore di creazione della directory
a causa della directory già esistente (anche se è stata creata contemporaneamente da
altro processo).

&mv [opzione ...] file sorgente file di destinazione
&mv [opzione ...] file sorgente
&mv [opzione ...] file sorgente ... destinazione
Sposta o rinomina file sorgente a file di destinazione, uno file sorgente nella directory corrente o multiple
file sorgentes alla destinazione con lo stesso nome.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -v,
--verboso"

&preelaborazione [opzione ...] variabile=definizione ... Nome del file ...
Questo preprocessa i file esattamente allo stesso modo di makepp per i makefile. Questo è
più potente di &template ma sintatticamente non adatto a file con un sacco di
Segni "$", come Makefile o script.

Dichiarazioni condizionali, così come le dichiarazioni "include"/"_include" (che qui
non creare il file né cercare in alto), "perl"/"makeperl"/"perl_begin" o
Vengono elaborati "sub"/"makesub" o qualsiasi istruzione definita all'interno del file. Vuoto
e le righe di commento vengono eliminate.

Ma, invece di apprendere le regole di compilazione, emetterà tutte le righe rimanenti dopo
Espansione dell'espressione "$(...)". Per evitare che la dichiarazione venga riconosciuta come tale,
puoi precederli con un'espressione vuota "$()". Lo stesso vale per le linee che tu
vogliono rimanere vuoti o che devono mantenere un segno di commento iniziale. Allo stesso modo, se a
la barra rovesciata finale non è quella di unire una riga con la successiva, metti "$()" dopo di essa.

Una linea normale viene emessa così com'è.
Una riga con $(MAKEEXPRESSIONS) viene espansa e generata.
ifdef WANTTHIS # non ottiene l'output indipendentemente dal fatto che sia definito o meno
potrebbe non ottenere l'output
endif
includi alcuni file
_include alcuni file che potrebbero non esistere # o -include
$() include espressione vuota impedisce il riconoscimento della parola chiave.
# Le righe di commento e le righe vuote vengono inghiottite.

$()# A meno che non vengano mascherati con un'espressione vuota.
$ ()
L'espressione vuota impedisce \$()
continuazione della barra rovesciata dall'essere riconosciuto.

potrebbe dare:

Una linea normale viene emessa così com'è.
Una linea con tutto ciò che viene espanso e prodotto.
un sacco di contenuti divorati qui...
includi espressione vuota impedisce il riconoscimento della parola chiave.
# A meno che non vengano mascherati con un'espressione vuota.

L'espressione vuota impedisce \
continuazione della barra rovesciata dall'essere riconosciuto.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -o,
--output=nomefile, -O, --outfail, -S, --synclines, -v, --verbose"

-a
--Incarico
Tratta anche le assegnazioni all'interno dei file come farebbe makepp. Ahimè tali linee non possono essere
mascherato con un "$()" vuoto, perché è legale costruire nomi di variabili con
espressioni. Questo riconosce inoltre le affermazioni "definire",
"export"/"unexport" e "override" (questi possono essere mascherati con "$()").

-H \\%hash
--hashref=\\%hash
Questo permette la preallocazione dei valori delle variabili, anche lunghi non facilmente
passato in un comando. L'espressione passata può essere qualsiasi codice Perl che restituisce a
riferimento hash. Questo viene unito a qualsiasi altra variabile passata al comando,
incluso da un'altra opzione "--hashref".

&rm [opzione ...] Nome del file ...
Elimina i file se disponi dei permessi di scrittura nella directory. Questo è ciò che Unix "rm -f" farebbe
eliminare, poiché ha una protezione speciale per l'uso interattivo non necessaria in a
Makefile.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -v, --verbose"

-f
--vigore
Ciò impedisce di lamentarsi di file inesistenti. Questo è un effetto collaterale questo
opzione ha in Unix, e l'unica che ha senso qui.

-m
--metainfo
Oltre ai file forniti, questo elimina anche le meta informazioni makepp
memorizza su di loro nella directory .makepp. Così makepp dimentica tutto ciò che ha mai saputo
sui file dati. Se la directory .makepp diventa vuota dopo questo, anche lei
viene eliminato.

Questo cancellerà anche determinate directory, ma solo se sono vuote. Per facilitare
questo, eliminerà le directory per ultime, in ordine di profondità decrescente. Così puoi
usa le espressioni "**" per eliminare intere gerarchie. Ecco un esempio da trovare in
molti file make di livello superiore. Nota che esiste un'utilità "makeppclean" che può fare
questo in modo più efficiente.

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

$(falso pulito): cleanold
&rm -f $(carattere jolly **/*.[ao])

$(distclean fasullo): clean
&rm -fm $(solo-bersagli **/*)

&ordinare [opzione ...] Nome del file ...
Ordina tutti i file insieme in ordine lessicografico. Questo è inefficiente per piuttosto grandi
file, perché avviene completamente in memoria. Fallirà se la dimensione combinata di
tutti i file superano la memoria a cui hai diritto.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=nomefile, -O, --outfail,
--record-size=numero, -s, --separator=stringa, -v, --verbose"

-c codice perl
--confronta=codice perl
codice perl rappresenta un blocco di ordinamento Perl, con i due candidati di ordinamento in $a e
$ b.

-n
--numerico
--ordinamento-numerico
Questo ordina numericamente all'inizio dei record. Lo spazio bianco principale è
saltato. Puoi usare "--transform" e "--detransform" se i numeri non sono a
l'inizio.

-r
--inversione
Emetti i risultati nell'ordine inverso. Nota che questo nasconde l'opzione standard
"-r" che deve essere dato come "--record-size".

-t codice perl
--trasformare=codice perl
-d codice perl
--detrasformare=codice perl
Se hai un codice complesso, l'ordinamento diventa sempre più costoso in proporzione a
il numero di record n, perché il codice viene chiamato O(n tronco d'albero(n)) volte. Evitare
che, puoi consentire a Perl di concentrarsi sull'ordinamento, modificando prima il
stringhe, in modo che l'estrazione complicata dei criteri di ricerca avvenga una volta per record,
e modificandoli di nuovo, una volta ordinati.

Se vengono fornite queste opzioni, il "--transform" codice perl viene mappato ai record
in $_ uno dopo l'altro e può modificarli. Dopo l'ordinamento, il "--detransform"
codice perl viene mappato uno dopo l'altro ai record modificati in $_ e può
modificarli di nuovo. Di solito non utilizzerai nessuna o entrambe queste opzioni, a meno che
si desidera visualizzare le righe modificate.

Trasformare le stringhe in una struttura di criteri di ordinamento estratti, che il tuo
"--confrontare" codice perl può raccogliere è noto come la trasformata di Schwartzian (ST).
Impacchettare tutto nella stringa stessa, in modo che nessun "--compare" codice perl is
necessario, consentendo l'intero smistamento senza eseguire costosi Perl
codice, è noto come trasformata di Guttmann-Rosler (GRT). Puoi trovare consigli da
cercando quei nomi sul web.

# Ordina in modo costoso le espressioni numeriche per valore ($$ protegge $ dall'espansione di makepp)
&sort --compare 'eval( $$a ) <=> eval( $$b )' $(input) -o >>$(output)

# ST per l'ordinamento senza distinzione tra maiuscole e minuscole
&sort -t '[lc, $$_]' -c '$$a->[0] cmp $$b->[0]' -d '$$_->[1]' $(input) - o >>$(uscita)

# GRT usando funzioni di modifica definite altrove nel Makeppfile
&ordina -t &trasforma -d &detrasforma $(input) -o >>$(output)

-u
--uniq
--unico
Dopo l'ordinamento, eliminare i duplicati. Queste sono linee identiche, o se il
Viene data l'opzione "--compare", quelle che codice perl rapporti come equivalenti.

&modello [opzione ...] macro=definizione ... Nome del file ...
Questo è un preprocessore di macro, non così potente come il preprocessore C o "m4".
Vedere &preprocess per un'alternativa più potente. È stato ispirato dalla macro di automake
sostituzione in Makefile.am e a Makefile.in. Ma va oltre. Qualsiasi testo normale
passa invariato. Per impostazione predefinita, i costrutti speciali sono delimitati da "@". Essi
deve stare su una riga a meno che non passi uno tra "-r, --record-size" o "--separator".

@# commento @
Si noti che nonostante il prestito dalla sintassi del commento di fine riga dello script "#", questo è
un commento in linea.

@MACRO@
Questo costrutto è sostituito dal valore di MACRO. I nomi delle macro devono iniziare con
una lettera o un trattino basso, seguito da un numero qualsiasi di lettere, trattini bassi, meno o
punti. A differenza dei nomi makepp, il carattere di sottolineatura e il segno meno non sono equivalenti.

@MACRO(arg1, arg2...) @
Come il primo, ma parametrizzato. Gli argomenti sostituiscono da $ 1 a $ 9 o
"${numero}" nel valore. Oppure, se il valore è una funzione Perl, vengono passati come
parametri normali. Il risultato quindi sostituisce l'intero costrutto. Un livello di
l'annidamento delle macro è possibile in quanto gli argomenti tra parentesi possono contenere plain
Invocazioni "@MACRO@", come in "@f(@x@)@", dove "@x@" viene espanso prima di essere
sostituito nel corpo di "f".

@includere(Nome del file)@
Questa è l'unica macro predefinita. Viene sostituito da &template-processed
contenuto del file indicato. Come tutte le macro, questo può verificarsi nel mezzo di a
linea. Purtroppo, per questo motivo, "-S, --synclines" ignora l'inclusione del file, rendendo
tutto sembra provenire dal file incluso.

@MACRO=definizione@
@MACRO?=definizione@
Questo definisce una macro all'interno del file. Questo è sostituito da niente. Il secondo
ha effetto solo se la macro non è stata definita, presumibilmente sul comando
linea.

@MACRO { Codice Perl }@
Questo definisce anche una macro, il cui corpo è un sub Perl. Gli argomenti, se
ce ne sono, fatti passare come @_.

@{ Codice Perl }@
Questo esegue il file Codice Perl immediatamente e viene sostituito dal valore restituito.

Finora abbiamo visto solo una sintassi per incorporare cose speciali. Ce n'è un altro
sintassi multilinea ed entrambi consentono a una variazione di sopprimere una nuova riga. Queste sono le
sintassi incorporate (che possono essere configurate dalle opzioni seguenti). Qui SPECIALE sta per
uno dei costrutti mostrati sopra:

@SPECIALE@
@SPECIALE@\
Questo può apparire moltiplicato ovunque su una linea. La variante subito seguita da
"\" funziona solo alla fine della riga. Sostituisce anche la seguente interruzione di riga.

@@SPECIALE@@ Normale testo @@
@@SPECIALE@@ Normale testo @@\
Questo è come il precedente. Tuttavia il testo normale, che viene anche sostituito,
può estendersi su più righe. Puoi mettere le parti speciali nelle righe di commento in giro
codice sorgente che è necessario solo in uno script disinstallato, da eliminare o
sostituito durante il processo di installazione:

# @@# le prossime 2 righe scompariranno @@
echo Stai eseguendo la versione disinstallata di questo script
#@@
# @@SOSTITUZIONE@@
echo Qualcos'altro sarà qui
#@@

Un esempio insignificante che mostra le varie possibilità:

@m1=qualche definizione@\
@m2=pippo $1 bar@\
@middle_of_arg=iddl@\
@m1@ @m2(m@medio_di_arg@e)@
@@m2(molte righe)@@
...
@@ testo normale 1 + 2 = @{ 1 + 2 }@

diventa

qualche definizione foo middle bar
troppe righe escludono testo in chiaro 1 + 2 = 3

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=nomefile, -O, --outfail, -r,
--record-size=numero, --separator=stringa, -S, --synclines, -v, --verbose"

-d
--definito
Sostituisci solo le istanze di macro che sono effettivamente definite. Senza questa opzione
quelli indefiniti saranno tutti sostituiti da niente.

-H \\%hash
--hashref=\\%hash
Questo permette la preallocazione dei valori macro, anche lunghi non facilmente
passato in un comando. L'espressione passata può essere qualsiasi codice Perl che restituisce a
riferimento hash. Questo viene unito a qualsiasi altra macro passata al comando,
incluso da un'altra opzione "--hashref". Un valore hash può anche essere un codice
riferimento, in tal caso la funzione viene chiamata, come con "@macro { Codice Perl }@"
definizioni.

-s /prefisso suffisso/
--semplice=/prefisso suffisso/
Usa il prefisso e a suffisso prima e dopo SPECIALE rispettivamente invece di "@". Il
il primo carattere è il separatore e non è necessario che sia una barra. Questi valori sono Perl
espressioni regolari. Non devi introdurre raggruppamenti come "(...)", ma "(?:...)" va bene.

-m /prefisso/suffisso/dopoprefisso/[doposuffisso/]
--multilinea=/prefisso/suffisso/dopoprefisso/[doposuffisso/]
Usa il prefisso, suffisso e a post-prefisso prima e dopo SPECIALE e alla fine del
blocco rispettivamente invece di "@@". Se doposuffisso viene anche dato il nome della macro
deve essere ripetuto prima. Il primo carattere è il separatore e non è necessario che lo sia
un taglio. Ad esempio un XML-ish, a cui devi aggiungere "--defined" se vuoi
conserva altri tag, non definiti da te:

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

O, meglio, usa le istruzioni di lavorazione" ", destinati a tale scopo:

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

Oppure, se vuoi combinare questo con "&entity;" sintassi per la semplice macro
sostituzioni (preservando entità numeriche "☺" che non sono commenti):

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

&tocco [opzione ...] Nome del file ...
Aggiorna la modifica e i timestamp di accesso di ciascun file ad ora. Se il file
non esiste, viene creato.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -v, --verbose"

&disinstalla [opzione ...] [nome del file ...]
Disinstalla i file precedentemente installati da &install. Il Nome del filesono file di log scritti
da &install. Se non viene fornito nessuno, né un'opzione "--inpipe", legge il file di registro predefinito
di &installa.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -i,
--inpipe=shellcommand, -I, --infail, -v, --verbose"

&unico [opzione ...] Nome del file ...
Scarta tutte le righe uguali successive tranne una.

"Opzioni standard": "-A, --args-file, --arguments-file=nomefile, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=nomefile, -O, --outfail, -r,
--record-size=numero, -s, --separator=stringa, -S, --sincline, -v, --verbose"

-c codice perl
--confronta=codice perl
Si Codice Perl ottiene le righe precedenti e correnti in $a e $b e deve restituire
vero se considera le due linee uguali.

&uniq --compare='lc( $$a ) eq lc $$b' $(input) -o $(output)

emulabile comandi
Varie cose non sono integrate, ma possono essere ottenute con altri comandi:

awk Usa &sed.

chgrp
chown
Questi comandi per lo più non sono portatili! o non faranno nulla o falliranno,
a seconda del sistema. Generalmente solo root può eseguire queste operazioni, il che è
perché sono disponibili solo tramite il comando &install.

cpp Usa &preprocess o &template.

quando
Uno di questi fa in parte la stessa cosa:

&expr ora locale
&expr gmtime

falso
Usa &expr senza argomenti o 0.

capo
coda
Puoi ottenere lo stesso risultato con &grep o "&cut --lines":

&grep 1..10 file # prime dieci righe
&grep 10..eof file # tutte le righe dal decimo in poi
&cut --lines -10..-1 file # ultime dieci righe

Nota che 1..10 in &grep è l'operatore flip-flop del numero di riga di Perl, che fastidiosamente
inizia da 1. Non iniziare da 0, o il flip-flop non si avvererà mai.

fmt Questo è menzionato qui poiché Perl fornisce una funzionalità correlata. Comunque ho avuto
problemi con l'utilizzo della dichiarazione "format" in un makefile. Quello che funziona è il
sottostante funzione "formline". Ad esempio per trasformare un file CSV composto da nomi e
prezzi in formato tabellare:

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

%.txt: %.csv
&sed &csv2txt $(input) -o $(output)

m4 Usa &preprocesso o &modello.

rmdir
Usa &rm.

tr Usa &sed.

Usa makepp_builtins online usando i servizi onworks.net