makepp_incompatibilities - Online în cloud

PROGRAM:

NUME

makepp_incompatibilities -- Incompatibilități între makepp și GNU make

DESCRIERE

Makepp a fost conceput pentru a fi cât mai aproape posibil de GNU
(<http://www.gnu.org/software/make/manual/make.html>). Instrumente automate GNU
(<http://www.gnu.org/software/automake/manual/automake.html>), CMake
(<http://www.cmake.org/>), Prefake (http://industriousone.com/premake> și vezi observație
de mai jos) sau sistemele de construcție vechi artizanale ar trebui să fie construite cu makepp. Așa este
puteți fie migra proiecte fără efort. Sau dacă nu vrei să te bucuri de tot
avantajele makepp (de exemplu, pentru ca alții să vă poată construi proiectul cu GNU make) în timp ce dvs
profitați de avantajul fiabilității pentru dezvoltarea dvs.

Cu toate acestea, din cauza diferenței de filozofie, unele dintre mărcile GNU sau POSIX
(<http://pubs.opengroup.org/onlinepubs/009695399/utilities/make.html>) caracteristicile nu pot fi
sprijinit. Câteva nu au fost implementate pentru că nu am avut timp. Cele mai multe dintre
diferențele față de GNU make sunt destul de tehnice și doar rareori cauzează probleme. Vai de
soluțiile pentru deficiențele modelului tradițional devin din ce în ce mai complexe,
și îi dă greu lui makepp.

Pe scurt, dacă nu se construiește din cutie, încercați:

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

Dacă acest lucru reușește, puteți încerca să eliminați acele argumente unul câte unul. Dar dacă asta eșuează,
incearca sa adaugi:

--traditional-recursive-make

Dacă și asta eșuează, sistemul de compilare are nevoie de unele ajustări pentru a coopera cu makepp. Chiar
dacă unele opțiuni descrise aici fac ceva construibil, se recomandă totuși adaptarea
lucrurile ușor, astfel încât să devină compatibile cu ambele mărci.

Forțând mai mult POSIX or GNU face compatibilitate

Iată câteva posibilități de linie de comandă pentru a face funcționarea multor sisteme vechi
fara modificare. Ele fac makepp să emuleze exact comportamentul lui GNU make.

Compatibilitate de il opţiune: „--build-check=target_newer”
În mod implicit, makepp va încerca să reconstruiască toate țintele dacă există vreuna dintre dependențe
schimbat de la ultima versiune sau dacă comanda s-a schimbat (consultați makepp_build_check pentru
Detalii). În mod normal, asta este ceea ce îți dorești. Uneori, însă, nu vrei ținta
să fie reconstruit dacă a fost modificat în afară de controlul makepp (de exemplu, prin editare
sau rulând un program manual pentru a crea fișierul). Puteți forța makepp să folosească
algoritmul tradițional make, care se reconstruiește numai dacă vreuna dintre ținte este mai nouă decât
dependențe, prin adăugarea acestei opțiuni la linia de comandă.

Compatibilitate de il opţiune: „--dont-build=config.status”
Există pachete care încearcă să se autoconfigureze sau fac alte lucruri, pe care le fac
ignoră dacă nu i se cere, cum ar fi:

config.status : configure
./config.status --reverificare

configure : configure.in aclocal.m4
autoconf

Majoritatea oamenilor nici măcar nu au „autoconf” instalat, așa că fac totul cu conștiință
regulile, așa cum face makepp, vor eșua. Această opțiune împiedică acest lucru, dacă vă dați seama ce
să nu construiască.

Compatibilitate de il opţiune: „--reguli-ultimei-șanse”
Regulile implicite (reguli de model fără dependențe de model) nu sunt acceptate în mod normal.
Makepp instanțează toate regulile pe baza fișierelor existente, astfel încât să fie conștient de fiecare
fișier care ar putea fi generat. Din păcate, în acest fel, nu știe cum să instanțieze un model
regulă fără dependență de model. Mecanismul :last_chance remedia parțial asta.
Acolo unde acest lucru este suficient de bun pentru fișierele make vechi, această opțiune permite activarea acesteia la nivel global.

Compatibilitate de il opţiune: "--nu-avertizam"
Acesta nu îmbunătățește rezultatul. Makepp va da mesaje de avertizare pentru multe lucruri
pe care Unix-ul tradițional îl acceptă fără să tresară. Asta pentru că există
modalități mai bune de a le face cu makepp. Dacă aceste avertismente vă enervează, le puteți dezactiva
cu această opțiune.

Compatibilitate de il opţiune: „--hibrid-recursiv-make”
Invocările recursive ale make sunt adesea considerate a fi o practică nesigură (vezi „Mai bine
system for ierarhic builds" în makepp pentru detalii), dar sunt extrem de comune în
fișierele makefile existente. Makepp acceptă make-ul recursiv pentru compatibilitate inversă; pentru nou
makefiles, este mult mai bine să folosiți declarația „load_makefile” sau implicitul makepp
mecanism de încărcare makefile.

Pentru a putea folosi depozitele pentru variante de construcție și pentru a ajuta la crearea recursive
invocări de make safer, makepp în mod normal nu se invocă recursiv
chiar dacă îi spui. În schimb, un subproces comunică cu procesul părinte și
construirea efectivă este realizată de procesul părinte.

Acest lucru funcționează în majoritatea cazurilor, dar este posibil să nu invocați mai multe fișiere make din același
director, de exemplu, următoarele nu vor funcționa:

țintă: dependențe
$(MAKE) -f alte ținte_makefile

În acest caz, makepp observă că încarcă un al doilea makefile și se plânge. Cu această opțiune
în schimb, va reveni la modul tradițional de a construi din fișiere makefile suplimentare în
un proces makepp separat fiecare.

Notă: încărcarea tehnic a mai multor fișiere make nu ar fi o problemă, dar de obicei au
aceleași nume false de țintă. Menținerea asta în afară ar însemna o reproiectare completă a makepp
interne. Cu toate acestea, acest lucru va funcționa, dar nu este echivalent:

țintă: dependențe
cd subdir && $(MAKE) -f alte ținte_makefile

Compatibilitate de il opţiune: „--fabricarea-tradițională-recursivă”
Uneori, opțiunea anterioară nu este suficientă, mai ales dacă se folosesc invocări recursive
opțiuni contradictorii. Makepp folosește un singur set de opțiuni globale, deci un submake nu este
permis să le modifice, deoarece asta ar fi valabil și pentru alte fișiere make.

Adăugarea acestei opțiuni la linia de comandă are următoarele efecte secundare nedorite:

· Efectele recursive nu se execută intern în paralel, chiar dacă părintele o face.
Spre deosebire de gmake, nu există o coordonare generală a numărului de procese. Asta va
nu poate fi implementat deoarece acest mod de lucru nu este un obiectiv de design al makepp.

· Procesele de realizare recursive nu știu nimic despre depozite.

· Fiecare proces recursiv de realizare produce propriul său fișier jurnal, în directorul în care este invocat
în, în loc să producă un fișier jurnal pentru întreaga construcție.

· Deoarece makepp de obicei construiește mai mult decât tradiționalul consideră necesar și din moment ce multe
sistemele de construcție oferă apeluri recursive în toate direcțiile, acest lucru poate duce la nesfârșite
recursiunea. Makepp va trage frâna după 50 de runde și vă va spune cum să creșteți
asta, în cazul în care chiar ai cuibări atât de adânci.

Chiar și cu opțiunea „--traditional-recursive-make”, variabilele de mediu
„MAKEOVERRIDES” și „MFLAGS” nu sunt configurate și ignorate, deci makefiles care depind de
astia nu vor functiona.

A Prefabricat generată makefile este doar un înveliș amuzant pentru o invocare sub-facă în același
director. Dacă aveți o țintă de proiect XYZ va avea o linie ca

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

În acest caz, puteți evita opțiunea „--traditional-recursive-make” prin invocarea directă
makepp cu acel „-f XYZ.make" opțiune.

Compatibilitate fără il opţiune: „--locuri de muncă=n"
Fișierele moștenite nu vor enumera uneori toate dependențele, bazându-se pe ordinea
execuție pentru a le face la timp. În această situație, makepp poate reuși să apeleze o regulă înainte
dependențele sale au fost toate făcute. Atunci rezultatele pot fi mai bune cu mai puțin, sau chiar nu
executie paralela.

Compatibilitate de il variabilă: „makepp_simple_concatenation=1”
Substituția în stilul Rc este modul implicit în care makepp efectuează înlocuirea variabilelor în text
șiruri de caractere, deoarece rupe foarte rar fișierele make vechi și este adesea util în noile
makefiles. Cu toate acestea, introduce incompatibilități ocazionale în înlocuirea
variabile care nu sunt înconjurate de spații. De exemplu,

INCLUDE_PREFIX := -I/unele/include/dir -I
INCLUDE := $(INCLUDE_PREFIX)/altele/include/dir

va seta „INCLUDE” la „-I/some/include/dir/other/include/dir -I/other/include/dir” dacă rc-
substituirea stilului este activată, în timp ce GNU make ar seta
„-I/unii/include/dir -I/altele/include/dir”. De exemplu, la compilarea Redis 2.6.5 încearcă
rulați „printfgcc”. O astfel de concatenare amuzantă a două comenzi este un indiciu puternic că
această variabilă este necesară pentru a se retrage pentru a face semantică.

Există, de asemenea, o incompatibilitate în gestionarea spațiilor albe într-o variabilă:

nul :=
T := -o $(null) # T conține -o urmat de un spațiu.
OUTFIILE = $(T)fișier de ieșire

va seta „OUTFILE” la „-ooutfile” dacă substituția în stil rc este activată, în timp ce GNU make
l-ar seta la „-o outfile”.

Ambele aceste incompatibilități sunt eliminate prin setarea „makepp_simple_concatenation”
variabil. Rețineți, totuși, că chiar și cu „makepp_simple_concatenation”, makepp încă
tratează spațiile albe în mod incompatibil în unele situații:

T := -o # Nu șterge acest comentariu.

GNU face seturile „T” să conțină „-o” urmat de un spațiu, în timp ce makepp elimină
oricum spatiu tras. Dacă doriți spațiul final, trebuie să setați
„makepp_simple_concatenation” și, de asemenea, setați „T” folosind tehnica care implică un manechin
variabilă precum „null”, așa cum se arată mai sus.

Soluție opțiune „--no-remake-makefiles”
O sursă deschisă tipică necesită apelarea „configure” pentru a crea fișierele make. Dar apoi acestea
fișierele make pot conține reguli pentru a reface fișierul make, apelând o comandă. Makepp va
respectați cu plăcere și actualizați-l conform regulii. Dar uneori acest lucru este dăunător, deci
sari peste el.

Compatibilitate de il variabilă: „makepp_percent_subdirs=1”
În mod implicit, „%” dintr-o regulă de tipar nu se potrivește cu directoarele. Aceasta înseamnă că o regulă ca
acest:

%.o: %.c
$(CC) $(CFLAGS) -c $(intrare) -o $(ieșire)

nu va fi aplicat fișierelor precum „../shared/xyz.c”. Dacă doriți să se potrivească fișierele în
și subdirectoarele, apoi setați variabila „makepp_percent_subdirs=1” pe linia de comandă
sau aproape de începutul unui makefile.

Compatibilitate de il mediu inconjurator variabilă: $MAKEPP_IGNORE_OPTS
Uneori, invocările recursive moștenite trec opțiuni pe care makepp nu le înțelege.
Sperăm că opțiunea nu este importantă, dar împiedică rularea makepp. Cu asta
variabilă de mediu, puteți cere makepp să ignore în tăcere anumite opțiuni. Valoarea
va fi o listă de opțiuni separate prin spații, care poate fi în 4 variante:

--lung=x
O opțiune lungă care așteaptă o ceartă. Acest fapt trebuie declarat prin egali
semn, deși utilizarea reală poate, de asemenea, separată prin spații albe, fie „--long=bla” fie
„--bla lung”.

--lung
O opțiune lungă fără argumente.

-sx O opțiune scurtă care așteaptă un argument. Acest fapt trebuie declarat prin adăugare
ceva direct după opțiune, deși utilizarea reală poate, de asemenea, separată de
spații albe, fie „-sbla” fie „-s bla”.

-s O varianta scurta fara argument.

De exemplu, suprascrieți opțiunea -R a lui makepp câte una fără argument și acceptați depanarea lui gmake
opțiune cu un argument:

export MAKEPP_IGNORE_OPTS='-R --debug=x'

Incompatibilități acea necesita makefile schimbari

· Makefiles care apelează explicit make împiedică makepp să construiască totul în sine.
Din păcate, propriul „ExtUtils::MakeMaker” al lui Perl comite a doua dintre următoarele două forme de
această greșeală până la versiunea 6.56 (Perl 5.12.1):

subdir:
subdir cd; face

MAKE = face

· Setarea variabilei „VPATH” la o anumită valoare apelează implicit „vpath % value”. "vpath"
instrucțiunile sunt emulate cu mecanismul de depozit. Deci, unde gma face înlocuitori
calea către fișierul găsit în vpath, makepp îl va conecta simbolic la
unde este nevoie. Astfel makepp va furniza un șir nemodificat, care este de obicei
nici o problema.

Țintele într-un vpath nu sunt acceptate. (Gmake le consideră dacă sunt mai noi decât
dependențele lor, dar dacă nu, ținta va fi recreată în directorul curent
-- destul de inconsecvent.) Dezactivarea vpaths nu este acceptată.

· O regulă de tipar prezentă mai târziu într-un fișier make îl înlocuiește pe una care este prezentă mai devreme.
Acest lucru este invers de la GNU make.

· Setul de reguli implicite încorporate este oarecum diferit de cele pentru GNU make,
deși numele variabilelor sunt în mare măsură compatibile. Regulile încorporate ar trebui
compila cu succes programe C/C++/Fortran și, de fapt, poate fi capabil să ghicească
biblioteci adecvate și în unele cazuri. Suport pentru Modula-2 și RatFor și altele rare
Limbile nu este în mod deliberat prezent, pentru că am continuat să întâmpin probleme cu GNU
regulile make când am reutilizat din greșeală extensiile pentru acele limbi.

· Un prefix de acțiune de „+” este ignorat în tăcere.

· Membrii arhivei nu sunt acceptați și nici variabilele automate asociate
$%, „$(%D)” și „$(%F)”.

· Nu există suport SCCS.

· Spațiile albe de început și de sfârșit în asignările variabile sunt ignorate (chiar dacă
spațiile albe sunt urmate de un comentariu). Pentru mai multe detalii despre gestionarea spațiilor albe
incompatibilități, vezi „Spațiu alb în variabile” în makepp_variables.

· Makepp nu încearcă să reconstruiască fișierele incluse în declarația „include” decât dacă
makefile-ul conține o regulă pentru construirea lor înainte ca instrucțiunea include să fie văzută.
(Totuși, va încerca să reconstruiască fișierul makefile în sine.) Acest lucru este utilizat în mod normal pentru
gestionarea include dependențele de fișiere și nu este la fel de utilă cu makepp, deoarece nu o faci
trebuie să faci asta oricum.

· Variabila „SHELL” este în prezent ignorată parțial. Makepp folosește întotdeauna / Bin / sh
dacă nu /usr/xpg4/bin/sh or /sbin/xpg4/sh este găsit sau dacă nu exportați „SHELL”
variabilă din makefile. Dar dacă o faci, analizatorul de comenzi s-ar putea să nu fie complet
înțelegeți ce face comanda dvs. shell. Pe Windows Strawberry sau ActiveState Perl
trebuie să setați variabila SHELL înainte sunând pe makepp.

· Dependențele de orice de pe Makefile încă funcționează, dar sunt de obicei inutile.
Acesta este de obicei folosit pentru a forța o reconstrucție atunci când opțiunile de compilare se modifică. Makepp știe
când comenzile de compilare s-au schimbat fără nimic special în makefile; se stochează
asta pe bază de fișier cu fișier. Dacă schimbați makefile-ul, acesta știe exact care
fișierele necesită recompilare.

· Fișierele intermediare nu sunt șterse. (Pentru că makepp insistă să aibă tot fișierul
datele să fie aceleași ca la ultima versiune, fișierele intermediare trebuie să fie toate
prezent sau altfel vor avea loc reconstrucţii.) Nu se acordă statut special
fișiere intermediare.

· Singura țintă specială care este acceptată este „.PHONY” și parțial „.SUFFIXES”. The
rămase sunt pur și simplu ingored.

Mai exact, GNU make are următoarele obiective speciale:

.SUFIXE
Makepp ignoră „.SUFFIXES” cu excepția cazului special „.SUFFIXES” cu nr
dependențe, astfel:

.SUFIXE:

care îi spune să nu încarce niciuna dintre regulile sale implicite.

.INTERMEDIAR, .SECUNDAR, .PRECIOS
Nu se acordă niciun statut special fișierelor intermediare și, prin urmare, aceste ținte nu sunt
plin de înțeles.

.IGNORA
Această țintă este ignorată. Dacă doriți să ignorați erorile, puneți cuvântul „ignore_error”
(sau un semn minus) în fața comenzii a cărei stare de ieșire trebuie ignorată.

.TĂCUT
Această țintă este ignorată. Dacă doriți ca comenzile să nu facă ecou, ​​puneți cuvântul „noecho”
(sau caracterul „@”) în fața comenzii care nu ar trebui să fie ecou,
sau utilizați opțiunea „--silent” pentru a facepp.

.DELETE_ON_ERROR
.EXPORT_ALL_VARIABLES
.NOEXPORT
.POSIX
.MOD IMPLICIT
Aceste obiective nu sunt acceptate și sunt pur și simplu ignorate.

· Funcțiile GNU make „eval”, „flavor” și „value” nu sunt acceptate în prezent. Tu
poate realiza același lucru ca eval într-un mod mai simplu cu „$[...]”
extinderea variabilă sau a funcției.

· Regulile două puncte nu sunt acceptate în totalitate. (Nu pot fi: în paradigma lui makepp,
nu poate exista mai mult de o modalitate de a actualiza o țintă.) În prezent, fiecare succesiv
regula două două puncte pentru o anumită țintă adaugă pur și simplu șirul de comandă și dependența
listă la șirul de comandă și lista de dependențe pentru această țintă. De exemplu, dacă tu
scrie asta:

a :: b
&cat b -oa

# Mai târziu în makefile:
a :: c
&cat c -o >>a

este exact la fel ca si cand ai fi scris

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

Cu siguranță nu este scopul pentru care sunt destinate regulile două puncte și nu va fi întotdeauna
funcționează, dar funcționează pentru ținte precum „curat” sau pentru toate lucrurile care
ExtUtils::MakeMaker pune în fișierele sale makefile. Nu conta pe ea pentru nimic altceva
decât fișierele moștenite.

· Funcția „$(wildcard )” corespunde nu numai fișierelor care există, ci și fișierelor care
nu există încă, dar care au o regulă pe care makepp a văzut-o la momentul respectiv
Funcția „$(wildcard )” este evaluată.

· Declarația „define” este acceptată, dar manipularea „@” care o precede este făcută
diferit. În prezent, în makepp, „@” în fața unei variabile care are o linie multiplă
valoarea va suprima doar ecoul primei linii. De exemplu,

definiți linii de ecou
&echo line1 -o $@
&echo line2 -o>>$@
endef

x:
@$(linii ecou)

nu va suprima tipărirea „&echo line2” așa cum o face în GNU make; va fi numai
suprimați imprimarea „&echo line1”.

· Makepp nu acceptă următoarele variabile de mediu (nu le setează,
și pur și simplu le ignoră):

MAKEOVERRIDES
MFLAGS

Incompatibilități in comandă of expresie expansiune
· În makepp, acțiunile regulilor sunt extinse înainte ca toate dependențele să fie garantate
au fost construite. Puteți rezolva acest lucru schimbând reguli precum aceasta:

foo: bar
genfoo < $(shell cat bar)

la această:

foo: bar
genfoo < `cat bar`

sau aceasta, care va face fișierul în timpul expansiunii:

foo: bar
genfoo < $(&cat $(face bara))

Acest lucru este de preferat aici, deoarece fișierul listat în bar este și o dependență de aceasta
regula, iar makepp o poate prinde acum atunci când analizează lexical redirecționarea.

· Deși nu am văzut acest lucru folosit, GNU make permite următoarele:

colon = :
a$(colon) b
ecou $^

Makepp extinde „$(colon)” prea târziu pentru ca acest lucru să funcționeze. Cu toate acestea, oferă
Sintaxă alternativă „$[colon]”, care poate face mult mai mult decât GNU, pentru că este
extins foarte devreme.

„$(FACEȚI)” Mai include spații
Într-un makepp dezinstalat sau dacă platforma nu pare să accepte pornirea unui script Perl
prin număr magic sau cu „--traditional-recursive-make” această variabilă va include cel puțin
un singur spatiu. Nu este o problemă atunci când îl folosiți ca comandă. Dar când îl trecem drept un
parametru necotat la un script (cum face sistemul de compilare Perl 5.14.0), îl va rupe
separat în parametri separați, ceea ce duce la confuzie. Deci, ca parametru, este mai sigur
citați-l ca „$(MAKE)”. care nu încalcă compatibilitatea inversă.

Specific țintei misiuni nu face propaga
Variabilele specifice țintei lui Makepp sunt ușor diferite de cele ale mărcii GNU prin faptul că ele
se aplică regulii doar pentru un singur dosar menționat, și nu pentru oricare dintre predecesorii acestuia; vedea
Misiuni specifice țintei.

Paranteze or bretele nu face cuib
Makepp termină expresiile la prima paranteză sau acolade potrivite. In loc de asta

$(somefunction ... ( ) ...) # GNU make style

trebuie să utilizați oricare dintre acestea

${somefunction ... ( ) ...} # GNU make compatible
$((o anumită funcție ... ( ) ...)) # Extensie Makepp

Acest lucru va fi probabil remediat în versiunea 2.1, poate opțional.

Minor puncte
Dependențele de model nu se potrivesc cu ținte false
%.a: %.b; ...
$(xb fals): ; ... # nu oferă o modalitate de a construi xa

Comentariile nu au rânduri de continuare
# Aceasta este \
NU un comentariu pe 2 rânduri

Comandă linie incompatibilități

Makepp acceptă câteva dintre opțiunile de linie de comandă mai utile ale make. Următoarele, însă,
nu sunt suportate:

-d sau --debug
-f -
Obiectele makefile interne ale Makepp sunt legate de obiecte fișier, deci nu se poate gestiona
stdin.

-i
-l sau --load-average sau --max-load
-m Opțiunea „-m” a lui Makepp are legătură cu selecția metodei semnăturii, în timp ce GNU make
ignoră -m.

-p sau --print-data-base
-q sau --întrebare
-R sau --no-variabile-încorporate
Opțiunea „-R” a lui Makepp face de fapt ceva complet diferit.

-S --nu-a continua sau --oprește-te
Opțiunea „--stop” oprește (pune la somn) makepp după ce a învățat toate regulile, așa că tu
pot continua editarea.

-t sau --atingeți
-w sau --print-directory
Acest lucru se întâmplă automat.

--warn-undefined-variables

Unele dintre acestea pot fi susținute cu ușurință dacă îi pasă cuiva.

Variabil incompatibilități

Makepp caută în $PATH o comandă potrivită pentru a reveni pentru variabile precum „$(CC)” sau
„$(CXX)”, în timp ce GNU make are valori implicite statice. De asemenea, makepp dă preferință „gcc” și
„g++”, în timp ce, în mod surprinzător, GNU face returnări „cc” pentru primul, dar același lucru pentru cel
din urmă. Le puteți suprascrie în fișierul make, pe linia de comandă sau exportând un
variabilă cu același nume înainte de a invoca makepp.

Utilizați makepp_incompatibilities online folosind serviciile onworks.net