makepp_incompatibilities - Online nel cloud

PROGRAMMA:

NOME

makepp_incompatibilities -- incompatibilità tra makepp e GNU make .;

DESCRIZIONE

Makepp è stato progettato per essere il più vicino possibile a GNU make
(<http://www.gnu.org/software/make/manual/make.html>). Strumenti automatici GNU
(<http://www.gnu.org/software/automake/manual/automake.html>), CMake
(<http://www.cmake.org/>), Premake (http://industriousone.com/premake> e vedi commento
sotto) o i sistemi di compilazione legacy fatti a mano dovrebbero essere compilabili con makepp. Questo è così
puoi migrare i progetti senza sforzo. O se non vuoi goderti tutto
i vantaggi di makepp (ad esempio così altri possono ancora creare il tuo progetto con GNU make) mentre tu
approfitta del vantaggio di affidabilità per il tuo sviluppo.

Tuttavia, a causa della differenza di filosofia, alcuni marchi GNU o POSIX fanno
(<http://pubs.opengroup.org/onlinepubs/009695399/utilities/make.html>) le caratteristiche non possono essere
supportato. Alcuni non sono stati implementati perché non abbiamo avuto tempo. La maggior parte della
le differenze rispetto a GNU make sono piuttosto tecniche e solo raramente causano problemi. Ahimè il
soluzioni alternative per le carenze della fabbricazione tradizionale stanno diventando sempre più complesse,
e stanno dando problemi a makepp.

In poche parole, se non si costruisce fuori dalla scatola, prova:

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

Se ha successo, puoi provare a eliminare quegli argomenti uno per uno. Ma se fallisce,
prova ad aggiungere:

--tradizionale-ricorsivo-make

Se anche questo fallisce, il sistema di compilazione necessita di alcune modifiche per cooperare con makepp. Persino
se alcune opzioni descritte qui rendono qualcosa di costruibile, si consiglia comunque di adattare
cose leggermente, quindi diventano compatibili con entrambe le marche.

forzatura Scopri di più POSIX or GNU make compatibilità

Ecco alcune possibilità della riga di comando per far funzionare molti sistemi di compilazione legacy
senza modifiche. Fanno in modo che makepp emuli esattamente il comportamento di GNU make.

Compatibilità via , il opzione: "--build-check=target_newer"
Per impostazione predefinita, makepp tenterà di ricostruire tutte le destinazioni se una delle dipendenze ha
cambiato dall'ultima build, o se il comando è cambiato (vedi makepp_build_check per
particolari). Questo è normalmente quello che vuoi. A volte, però, non vuoi il bersaglio
da ricostruire se è stato modificato a parte il controllo di makepp (ad esempio, modificando
esso, o eseguendo manualmente un programma per creare il file). Puoi forzare makepp a usare il
algoritmo make tradizionale, che ricostruisce solo se uno dei target è più recente del
dipendenze, aggiungendo questa opzione alla riga di comando.

Compatibilità via , il opzione: "--dont-build=config.status"
Ci sono pacchetti che cercano di autoconfigurarsi o fare altre cose, che gmake
ignora a meno che non gli venga chiesto, ad esempio:

config.status: configura
./config.status --ricontrolla

configure: configure.in aclocal.m4
autoconf

La maggior parte delle persone non ha nemmeno "autoconf" installato, quindi fare tutto coscienziosamente con
le regole, come fa makepp, falliranno. Questa opzione lo impedisce, se capisci cosa
non costruire.

Compatibilità via , il opzione: "--regole-ultima possibilità"
Le regole predefinite (regole modello senza dipendenze da modello) non sono normalmente supportate.
Makepp istanzia tutte le regole in base ai file esistenti, in modo che sia a conoscenza di ogni
file che potrebbe essere generato. Purtroppo in questo modo non sa come istanziare un modello
regola senza dipendenza dal modello. Il meccanismo :last_chance risolve parzialmente questo problema.
Laddove questo è abbastanza buono per i makefile legacy, questa opzione consente di attivarlo a livello globale.

Compatibilità via , il opzione: "--no-avvertire"
Questo non migliora il risultato. Makepp darà messaggi di avviso per molte cose
che il tradizionale Unix fa accetta senza batter ciglio. Questo perché ci sono
modi migliori per farli con makepp. Se questi avvisi ti infastidiscono, puoi disattivarli
con questa opzione.

Compatibilità via , il opzione: "--ibrido-recursivo-make"
Le invocazioni ricorsive di make sono spesso considerate una pratica non sicura (vedi "Meglio
system for gerarchical build" in makepp per i dettagli), ma sono estremamente comuni in
makefile esistenti. Makepp supporta la creazione ricorsiva per la compatibilità con le versioni precedenti; per nuovo
makefile, è molto meglio usare l'istruzione "load_makefile" o l'implicito di makepp
meccanismo di caricamento del makefile.

Per poter utilizzare i repository per le build di varianti e per aiutare a rendere ricorsivo
invocazioni di rendere più sicuro, makepp normalmente in realtà non si invoca in modo ricorsivo
anche se lo dici tu. Invece, un sottoprocesso comunica con il processo padre e
la build effettiva viene eseguita dal processo padre.

Funziona nella maggior parte dei casi, ma non puoi invocare diversi makefile dallo stesso
directory, ad esempio, quanto segue non funzionerà:

obiettivo: dipendenze
$(MAKE) -f other_makefile target

In questo caso makepp nota che sta caricando un secondo makefile e si lamenta. Con questa opzione
invece ricadrà al modo tradizionale di costruire da makefile aggiuntivi in
un processo makepp separato ciascuno.

Nota: tecnicamente caricare diversi makefile non sarebbe un problema, ma di solito hanno il
stessi nomi di target fasulli. Tenerlo a parte significherebbe una riprogettazione completa di makepp
interni. Tuttavia, questo funzionerà, ma non è equivalente:

obiettivo: dipendenze
cd subdir && $(MAKE) -f other_makefile target

Compatibilità via , il opzione: "--tradizionale-ricorsivo-make"
A volte l'opzione precedente non è sufficiente, specialmente se le invocazioni ricorsive usano
opzioni contraddittorie. Makepp utilizza solo un set di opzioni globali, quindi un submake non lo è
permesso di modificarli, poiché ciò riguarderebbe anche altri makefile.

L'aggiunta di questa opzione alla riga di comando ha i seguenti effetti collaterali indesiderati:

· I make ricorsivi non vengono eseguiti internamente in parallelo, anche se lo fa il genitore.
A differenza di gmake, non esiste un coordinamento generale del numero di processi. Questo sarà
non essere implementato perché questo modo di lavorare non è un obiettivo progettuale di makepp.

· I processi di creazione ricorsivi non sanno nulla dei repository.

· Ogni processo di make ricorsivo produce il proprio file di log, nella directory in cui viene invocato
in, invece di produrre un file di registro per l'intera build.

· Dal momento che makepp di solito costruisce più di quanto il make tradizionale ritenga necessario, e poiché molti
i sistemi di build forniscono chiamate ricorsive in tutte le direzioni, questo può portare a infinite
ricorsione. Makepp tirerà il freno dopo 50 round e ti dirà come aumentare
quello, nel caso tu abbia davvero un annidamento così profondo.

Anche con l'opzione "--traditional-recursive-make", le variabili d'ambiente
"MAKEOVERRIDES" e "MFLAGS" non sono impostati e ignorati, quindi i makefile che dipendono da
quelli non funzioneranno.

A Prefazione generato Makefile è solo un divertente wrapper per un'invocazione di sub-make nello stesso
directory. Se hai qualche obiettivo di progetto XYZ avrà una linea come

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

In questo caso puoi evitare l'opzione "--traditional-recursive-make" invocando direttamente
makepp con quel "-f XYZ.make" opzione.

Compatibilità senza , il opzione: "--jobs=n"
I makefile legacy a volte non elencheranno tutte le dipendenze, basandosi sull'ordine di
esecuzione per farli in tempo. In questa situazione makepp potrebbe riuscire a chiamare una regola prima
le sue dipendenze sono state tutte create. Quindi i risultati potrebbero essere migliori con meno, o addirittura no
esecuzione parallela.

Compatibilità via , il variabili: "makepp_simple_concatenation=1"
La sostituzione in stile Rc è il modo predefinito in cui makepp esegue la sostituzione delle variabili nel testo
strings perché molto raramente rompe i makefile legacy ed è spesso utile in new
makefile. Tuttavia, introduce occasionali incompatibilità nella sostituzione di
variabili non circondate da spazi. Per esempio,

INCLUDE_PREFIX := -I/alcuni/include/dir -I
INCLUDE := $(INCLUDE_PREFIX)/altro/include/dir

imposterà "INCLUDE" su "-I/some/include/dir/other/include/dir -I/other/include/dir" se rc-
la sostituzione dello stile è abilitata, mentre GNU make la imposterebbe su
"-io/alcuni/includo/dir -io/altro/includo/dir". Ad esempio, durante la compilazione Redis 2.6.5 tenta di
eseguire "printfgcc". Una concatenazione così divertente di due comandi è una forte indicazione che
questa variabile è necessaria per ricorrere alla semantica.

C'è anche un'incompatibilità nella gestione degli spazi bianchi in una variabile:

nullo :=
T := -o $(null) # T contiene -o seguito da uno spazio.
FILE OUT = $(T)file di uscita

imposterà "OUTFILE" su "-ooutfile" se la sostituzione in stile rc è abilitata, mentre GNU make
lo imposterebbe su "-o outfile".

Entrambe queste incompatibilità vengono rimosse impostando "makepp_simple_concatenation"
variabile. Nota, tuttavia, che anche con "makepp_simple_concatenation", makepp still
tratta gli spazi bianchi in modo incompatibile in alcune situazioni:

T := -o # Non cancellare questo commento.

GNU make imposta "T" per contenere "-o" seguito da uno spazio, mentre makepp elimina il
spazio finale comunque. Se vuoi lo spazio finale, devi impostare
"makepp_simple_concatenation" e imposta anche "T" usando la tecnica che coinvolge un manichino
variabile come "null", come mostrato sopra.

Soluzione opzione "--no-remake-makefiles"
L'open source tipico richiede di chiamare "configure" per creare i makefile. Ma poi questi
i makefile possono contenere regole per rifare il makefile, chiamando qualche comando. Makepp lo farà
felice di rispettarlo e aggiornarlo secondo la regola. Ma a volte questo è dannoso, quindi
saltalo e basta.

Compatibilità via , il variabili: "makepp_percent_subdirs=1"
Per impostazione predefinita, "%" in una regola modello non corrisponde alle directory. Ciò significa che una regola come
Questo:

%.o: %.c
$(CC) $(CFLAGS) -c $(ingresso) -o $(uscita)

non verrà applicato a file come "../shared/xyz.c". Se vuoi che corrisponda ai file in
anche le sottodirectory, quindi imposta la variabile "makepp_percent_subdirs=1" sulla riga di comando
o vicino all'inizio di un makefile.

Compatibilità via , il ambiente variabili: $MAKEPP_IGNORE_OPTS
A volte le chiamate ricorsive legacy passano opzioni che makepp non comprende.
Si spera che l'opzione non sia importante, ma impedisce l'esecuzione di makepp. Con questo
variabile d'ambiente puoi chiedere a makepp di ignorare silenziosamente determinate opzioni. Il valore
deve essere un elenco di opzioni separato da spazi, che può essere disponibile in 4 varianti:

--lungo=x
Un'opzione lunga che prevede un argomento. Questo fatto deve essere dichiarato attraverso gli uguali
segno, sebbene l'uso effettivo possa anche essere separato da spazi bianchi, "--long=bla" o
"--lungo bla".

--lungo
Un'opzione lunga senza argomenti.

-sx Un'opzione breve che prevede un argomento. Questo fatto deve essere dichiarato aggiungendo
qualcosa subito dopo l'opzione, sebbene l'uso effettivo possa anche essere separato da
spazi bianchi, "-sbla" o "-s bla".

-s Un'opzione breve senza argomenti.

Ad esempio, sovrascrivi l'opzione -R di makepp di uno senza un argomento e accetta il debug di gmake
opzione con un argomento:

esporta MAKEPP_IGNORE_OPTS='-R --debug=x'

incompatibilità che richiedere Makefile i cambiamenti

· I makefile che chiamano esplicitamente make impediscono a makepp di creare tutto da solo.
Ahimè, "ExtUtils::MakeMaker" di Perl esegue il commit della seconda delle due seguenti forme di
questo errore fino alla versione 6.56 (Perl 5.12.1):

sottodirectory:
sottocartella cd; fare

FARE = ​​fare

· L'impostazione della variabile "VPATH" su un valore chiama implicitamente "vpath % value". "percorso"
le istruzioni vengono emulate con il meccanismo del repository. Quindi, dove sostituisce gmake
il percorso del file trovato nel vpath, makepp lo collegherà invece simbolicamente a
dove è necessario. Quindi makepp fornirà una stringa non modificata, che di solito è
non è un problema.

Le destinazioni in un vpath non sono supportate. (Gmake li considera se sono più recenti di
le loro dipendenze, ma in caso contrario, il target verrà ricreato nella directory corrente
-- piuttosto incoerente.) L'annullamento dell'impostazione di vpath non è supportato.

· Una regola modello presente in seguito in un makefile sovrascrive quella presente in precedenza.
Questo è indietro rispetto a GNU make.

· L'insieme delle regole implicite incorporate è in qualche modo diverso da quelle per GNU make,
sebbene i nomi delle variabili siano ampiamente compatibili. Le regole integrate dovrebbero
compilare con successo programmi C/C++/Fortran, e in effetti potrebbe essere in grado di indovinare il
biblioteche adeguate in alcuni casi anche. Supporto per Modula-2 e RatFor e altri rari
le lingue non è volutamente presente, perché continuavo a riscontrare problemi con GNU
le regole di make quando ho riutilizzato accidentalmente le estensioni per quelle lingue.

· Un prefisso di azione di "+" viene ignorato silenziosamente.

· I membri dell'archivio non sono supportati e nemmeno le variabili automatiche associate
$%, "$(%D)" e "$(%F)".

· Non c'è supporto SCCS.

· Gli spazi iniziali e finali nelle assegnazioni di variabili vengono ignorati (anche se il
gli spazi sono seguiti da un commento). Per maggiori dettagli sulla gestione degli spazi bianchi
incompatibilità, vedere "Spazi bianchi nelle variabili" in makepp_variables.

· Makepp non tenta di ricostruire i file inclusi con l'istruzione "include" a meno che
il makefile contiene una regola per compilarli prima che venga visualizzata l'istruzione include.
(Cercherà comunque di ricostruire il makefile stesso.) Questo è normalmente usato per
la gestione include le dipendenze dei file e non è così utile con makepp poiché non lo fai
bisogno di farlo comunque.

· La variabile "SHELL" è attualmente parzialmente ignorata. Makepp usa sempre /bin/sh
salvo che /usr/xpg4/bin/sh or /sbin/xpg4/sh viene trovato o a meno che non esporti la "SHELL"
variabile nel tuo makefile. Ma se lo fai, il parser dei comandi potrebbe non essere completamente
capire cosa fa il tuo comando shell. Su Windows Strawberry o ActiveState Perl
devi invece impostare la tua variabile SHELL prima chiamando makepp.

· Le dipendenze di qualsiasi cosa dal Makefile funzionano ancora, ma di solito non sono necessarie.
Di solito viene utilizzato per forzare una ricostruzione quando cambiano le opzioni di compilazione. Makepp lo sa
quando i comandi di compilazione sono cambiati senza nulla di speciale nel makefile; memorizza
questo file per file. Se cambi il makefile, sa esattamente quale
i file devono essere ricompilati.

· I file intermedi non vengono eliminati. (Perché makepp insiste per avere tutto il file
le date siano le stesse dell'ultima build, i file intermedi devono essere tutti
presente, altrimenti si verificheranno delle ricostruzioni.) Non è stato accordato uno status speciale a
file intermedi.

· L'unico obiettivo speciale supportato è ".PHONY" e parzialmente ".SUFFIXES". Il
rimanenti sono semplicemente ingored.

Nello specifico, GNU make ha i seguenti obiettivi speciali:

.SUFFISSI
Makepp ignora ".SUFFIXES" ad eccezione del caso speciale di ".SUFFIXES" con no
dipendenze, in questo modo:

.SUFFISSI:

che gli dice di non caricare nessuna delle sue regole predefinite.

.INTERMEDIO, .SECONDARIA, .PREZIOSO
Nessuno status speciale è accordato ai file intermedi e quindi questi obiettivi non lo sono
significativo.

.IGNORARE
Questo obiettivo viene ignorato. Se vuoi ignorare gli errori, metti la parola "ignore_error"
(o un segno meno) davanti al comando il cui stato di uscita deve essere ignorato.

.SILENZIOSO
Questo obiettivo viene ignorato. Se vuoi che i comandi non echeggino, metti la parola "noecho"
(o il carattere "@") davanti al comando che non dovrebbe essere ripetuto,
o usa l'opzione "--silent" per makepp.

.DELETE_ON_ERROR
.EXPORT_ALL_VARIABILI
.NO ESPORTAZIONE
.POSIX
.PREDEFINITO
Questi obiettivi non sono supportati e vengono semplicemente ignorati.

· Le funzioni GNU make "eval", "flavor" e "value" non sono attualmente supportate. Voi
può ottenere la stessa cosa di eval in un modo più diretto con "$[...]"
espansione variabile o funzione.

· Le regole sui due punti non sono completamente supportate. (Non possono essere: nel paradigma di makepp,
non può esserci più di un modo per aggiornare un target.) Attualmente, ogni successivo
la regola dei due punti per un determinato target aggiunge semplicemente la sua stringa di comando e la dipendenza
list alla stringa di comando e all'elenco delle dipendenze per questa destinazione. Ad esempio, se tu
Scrivi questo:

a :: b
&cat b -oa

# Più avanti nel tuo makefile:
AC
&cat c -o >>a

è di preciso come se avessi scritto

a : bc
&cat b -oa
&cat c -o >>a

Questo non è certamente lo scopo delle regole sui due punti, e non sempre lo sarà
funziona, ma funziona per obiettivi come "pulito" o per tutte le cose che
ExtUtils::MakeMaker inserisce nei suoi makefile. Non contarci per altro
rispetto ai makefile legacy.

· La funzione "$(carattere jolly )" trova non solo i file che esistono, ma anche i file che
non esistono ancora, ma che hanno una regola che makepp ha visto al momento del
Viene valutata la funzione "$(carattere jolly )".

· L'istruzione "define" è supportata, ma la gestione di "@" che la precede è completata
diversamente. Attualmente in makepp, "@" davanti a una variabile che ha una multilinea
value sopprimerà solo l'eco della prima riga. Per esempio,

definire le eco-linee
&echo riga1 -o $@
&echo riga2 -o>>$@
fine

x:
@$(eco-linee)

non sopprimerà la stampa di "&echo line2" come fa in GNU make; sarà solo
sopprimere la stampa di "&echo riga1".

· Makepp non supporta le seguenti variabili d'ambiente (non le imposta,
e semplicemente li ignora):

SOSTITUZIONI
MFLAG

incompatibilità in minimo of espressione espansione
· In makepp, le azioni delle regole vengono espanse prima che tutte le dipendenze siano garantite a
sono stati costruiti. Puoi aggirare questo problema modificando regole come questa:

pippo: bar
genfoo < $(shell cat bar)

a questo:

pippo: bar
genfoo < `bar per gatti`

o questo, che renderà il file durante l'espansione:

pippo: bar
genfoo < $(&cat $(make bar))

Questo è preferibile qui, perché il file elencato in bar è anche una dipendenza di questo
regola e makepp ora può catturarlo durante l'analisi lessicale del reindirizzamento.

· Anche se non l'ho visto usato, GNU make consente quanto segue:

due punti = :
a$(due punti) b
eco $^

Makepp espande "$(due punti)" troppo tardi perché funzioni. Tuttavia offre il
sintassi alternativa "$[colon]", che può fare molto di più di GNU, perché è
ampliato molto presto.

"$(FARE)" può includere spazi
In un makepp disinstallato o se la piattaforma non sembra supportare l'avvio di uno script Perl
per numero magico o con "--traditional-recursive-make" questa variabile includerà almeno
uno spazio. Questo non è un problema quando lo si utilizza come comando. Ma quando lo passa come un
parametro non quotato a uno script (come fa il sistema di compilazione Perl 5.14.0), lo strapperà
a parte in parametri separati, portando a confusione. Quindi come parametro è più sicuro
citarlo come '$(MAKE)'. che non infrange la retrocompatibilità.

Specifico per l'obiettivo assegnazioni non propagare
Le variabili specifiche del target di Makepp sono leggermente diverse da quelle di GNU make in quanto
si applicano solo alla regola per l'unico file menzionato e non a nessuno dei suoi predecessori; vedere
Assegnazioni mirate.

parentesi or bretelle non nido
Makepp termina le espressioni alla prima parentesi o parentesi graffa corrispondente. Invece di questo

$(qualche funzione ... ( ) ...) # GNU make style

devi usare uno di questi

${una funzione ... ( ) ...} # GNU rende compatibile
$((qualche funzione ... ( ) ...)) # Estensione Makepp

Questo sarà probabilmente risolto nella versione 2.1, forse facoltativamente.

Minore punti
Le dipendenze dai pattern non corrispondono a obiettivi fasulli
%.a: %.b; ...
$(falso xb): ; ... # non fornisce un modo per costruire xa

I commenti non hanno righe di continuazione
# Questo è \
NON un commento di 2 righe

Comando linea incompatibilità

Makepp supporta alcune delle opzioni della riga di comando più utili di make. Quanto segue, invece,
non sono supportati:

-d o --debug
-F -
Gli oggetti makefile interni di Makepp sono collegati agli oggetti file, quindi non può gestire
standard.

-i
-l o --load-media o --max-load
-m L'opzione "-m" di Makepp ha a che fare con la selezione del metodo della firma, mentre GNU make
ignora -m.

-p o --print-data-base
-q o --domanda
-R o --no-variabili-incorporate
L'opzione "-R" di Makepp in realtà fa qualcosa di completamente diverso.

-S --no-keep-going o --stop
L'opzione "--stop" interrompe (mette a dormire) makepp dopo aver appreso tutte le regole, quindi tu
può continuare a modificare.

-t o --touch
-w o --print-directory
Questo accade automaticamente.

--warn-variabili-indefinite

Alcuni di questi possono essere facilmente supportati se a qualcuno interessa.

Variabile incompatibilità

Makepp cerca in $PATH un comando corrispondente da restituire per variabili come "$(CC)" o
"$(CXX)", mentre GNU make ha valori predefiniti statici. Anche makepp dà la preferenza a "gcc" e
"g++" mentre sorprendentemente GNU restituisce "cc" per il primo, ma lo stesso per il
quest'ultimo. Puoi sovrascriverli nel makefile, sulla riga di comando o esportando a
variabile con lo stesso nome prima di invocare makepp.

Usa makepp_incompatibilities online utilizzando i servizi onworks.net