makeppreplay - Online nel cloud

PROGRAMMA:

NOME

makeppreplay -- Ripetitore veloce di azioni makepp selezionate

DESCRIZIONE

?: -?, A: -UN,
--args-file,
--file-argomenti, C: -C,
-C, D: --directory,
--funzionamento a secco, H: -H,
--aiuto, I: -IO,
--includere,
--include-dir, J: --solo-stampa, K: -K,
--Continua così, L: --tronco d'albero,
--file di registro, M: -M,
$MAKEPPREPLAYFLAGS,
--modulo, N: -N,
--no-log,
--no-directory-di-stampa,
--no-avvertire, P: --profilo, R: --ricognizione,
--root-dir,
--root directory, S: -S,
--sed, T: -T,
--temporaneo, V: -V,
--versione

trucco [ opzione ...] [ VAR=valore ] [ bersaglio ...]

mppr [ opzione ...] [ VAR=valore ] [ bersaglio ...]

Makeppreplay cerca di fare le stesse cose che ha fatto makepp. Lo fa esclusivamente in base al
ha ricordato le informazioni sulla build, risparmiando molto tempo non leggendo i makefile, non analizzando i comandi,
non scansionare i file e non guardare ogni file del repository, per vedere se si adatta. Ma
a differenza di makepp, riutilizza tutti i collegamenti al repository che trova.

Non sa di obiettivi fasulli o predefiniti, quindi devi dargli file reali o
directory, come scorciatoia per tutti i file che makepp ha creato al loro interno. Di default si costruisce
tutti i file makepp creati nella directory corrente o scelta.

Questo approccio è corretto solo quando non ci sono cambiamenti strutturali, ovvero non è diverso
moduli da collegare, nessun file spostato, nessuna diversa istruzione "#include", che dovrebbe
probabilmente hanno causato la (ri)creazione di quei file. Dopo l'aggiornamento dal controllo della versione, oppure
quando costruisci su un repository, dove altri potrebbero aver causato tali modifiche, dovresti
chiama makepp una volta dopo potenziali cambiamenti (ad es. al mattino dopo una notte)
aggiornamento del repository), per essere sicuri che le informazioni sulla build siano aggiornate.

Non leggere i makefile significa che non conoscerà alcun sub (funzioni Perl) definito in essi.
Per questo dovresti mettere tutte le tue funzioni in un modulo esterno. Inoltre non lo saprà
su qualsiasi impostazione variabile, che è un problema solo se il tuo codice Perl vi accede
(perché nelle azioni delle regole sono già state espanse).

TUTTO

Questo è ancora sperimentale e imperfetto.

· Costruisci un albero delle dipendenze completo partendo dai target dati e decidi quali
di loro da costruire in base ai loro metodi di controllo della build. Ciò richiede che il metodo sia
ricordato nelle informazioni sulla build.

· Dopo aver implementato il precedente punto elenco, accetta più opzioni makepp, come "-j" o
"--non-costruire".

· Consenti build cache con implicito "--no-populate-bc" (perché makeppreplay non
garantire una corretta costruzione). Makepp potrebbe in seguito pubblicare nella cache di build qualsiasi cosa
mantiene.

· Fai in modo che makepp ricordi le informazioni sulla build per tutti i comandi non riusciti e per quelli che non lo sono stati
tentativo perché le loro dipendenze non sono riuscite. Questo è solo parzialmente possibile, perché
le dipendenze possono essere scoperte solo dopo aver creato i file che le richiedono. Che cosa
dovrebbe succedere con (a non ha informazioni sulla build):

un: b
avanti Cristo
cmd_produce_a_and_b

VERSIONI

Le opzioni includono alcune delle opzioni makepp, più due nuove, per caricare i moduli che
verrebbe normalmente caricato da un makefile.

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

-C elenco
--directory=elenco
Cd nella directory data prima di caricare il makefile e provare a costruire i target.
Questo è più o meno equivalente a specificare una directory con "-F", tranne che
le successive opzioni "-C", "-f", "-F", "-I" e "-R" vengono interpretate rispetto al nuovo
directory, piuttosto che quella vecchia.

-c
--root-dir
--root directory
Cd fino alla directory contenente un file RootMakepp.

-I elenco
--include=elenco
--include-dir=elenco
Aggiungi elenco al percorso di caricamento Perl @INC.

-?
-h
--Aiuto
Stampa un breve riepilogo delle opzioni.

-k
--Continua così
Crea il maggior numero possibile di file, anche se alcuni di essi contengono errori. Per impostazione predefinita, makepp
si ferma quando incontra il primo errore, anche se ci sono altri file che devono
essere costruito che non dipenda dal file errato.

--log=nomefile di log
--file-log=nomefile di log
Modifica il nome del file di registro con il nome indicato. Per impostazione predefinita, il file di registro è
detto .makepp/log. Questo file è leggibile con makepplog, mppl.

-M modulo[=arg,...]
--modulo=modulo[=arg,...]
Carica il modulo e importa tutte le funzioni che esporta.

-n
--funzionamento a secco
--solo-stampa
--ricognizione
Stampa i comandi senza eseguirli effettivamente.

--no-log
Non preoccuparti di scrivere una descrizione dettagliata di ciò che è stato fatto sul file di registro.

--no-directory-di-stampa
Disattiva i messaggi in entrata o in uscita dalla rubrica.

--profilo
Emetti timestamp non elaborati prima e dopo ogni azione.

-s perl-espressione
--sed=perl-espressione
Esegui l'espressione perl contro il comando prima di eseguirlo, come per il preprocessore
"-s 's/ -c / -E /; s/\.o\b/.i/g'". Questo trasformerebbe un comando di compilazione ("-c")
in un'invocazione del preprocessore ("-E"), cambiando il .o suffisso a .i, Che è un
suffisso convenzionale per C preelaborato. Oppure potresti voler aggiungere un output di debug a
il tuo linker. Se hai un solo comando nella regola, puoi farlo con
sostituendolo nel primo spazio: "-s 's/ / -Wl,-t /'".

Quando il comando viene modificato, non viene ricordato nulla di ciò, ad esempio makepp penserà
hai modificato manualmente il file, provocando una ricostruzione.

Nota che (a differenza di makepp) makeppreplay non analizza il comando, quindi non se ne accorge
che il nome del file di destinazione è stato modificato. Quindi devi comunque richiedere il .o bersaglio, anche
anche se a .i Sarà costruito. E makeppclean non saprà rimuoverlo.

-t
--temporaneo
Makeppreplay modifica le informazioni di build di tutti i file che ha toccato e di tutte le dipendenze
ha trovato modificato. Li segna in modo tale che makepp sa comunque che
deve eseguire nuovamente la scansione di questi file. Ma con questa opzione puoi prevenirli
modifiche, in modo che makepp consideri semplicemente tutti i file makeppreplay creati come
errato.

-V
--versione
Stampa il numero di versione.

--non avvisare
Non stampare alcun messaggio di avviso.

ESEMPI

Probabilmente l'uso più comune è ricollegare un programma o una libreria dopo aver modificato a
file sorgente:

makeppreplay sottodirectory/foo.o bin/bar
mppr sottodir/foo.o lib/libbar.so

AMBIENTE

Makeppreplay esamina la seguente variabile d'ambiente:

$MAKEPPREPLAYFLAGS
Tutte le opzioni che potresti voler passare sempre.

Usa makeppreplay online utilizzando i servizi onworks.net