makepp_incompatibilities - Online in de cloud

PROGRAMMA:

NAAM

makepp_incompatibilities -- Incompatibiliteit tussen makepp en GNU make

PRODUCTBESCHRIJVING

Makepp is ontworpen om zo dicht mogelijk bij GNU make te komen
(<http://www.gnu.org/software/make/manual/make.html>). GNU-autotools
(<http://www.gnu.org/software/automake/manual/automake.html>), CMake
(<http://www.cmake.org/>), Voorbereiding (http://industriousone.com/premake> en zie opmerking
hieronder) of handgemaakte legacy build-systemen moeten kunnen worden gebouwd met makepp. Dit is zo
u kunt projecten moeiteloos migreren. Of als je niet van alles wilt genieten
makepp's voordelen (bijv. zodat anderen uw project nog steeds kunnen bouwen met GNU make) terwijl u
profiteer van het betrouwbaarheidsvoordeel voor uw ontwikkeling.

Echter, vanwege het verschil in filosofie, zijn sommige GNU make's of POSIX make's
(<http://pubs.opengroup.org/onlinepubs/009695399/utilities/make.html>) functies kunnen niet worden
ondersteund. Een paar zijn niet uitgevoerd omdat we geen tijd hebben gehad. Meeste van de
verschillen met GNU maken zijn vrij technisch en veroorzaken slechts zelden problemen. helaas de
tijdelijke oplossingen voor de tekortkomingen van traditionele make-up worden steeds complexer,
en maken het makepp moeilijk.

In een notendop, als het niet uit de doos bouwt, probeer dan:

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

Als dat lukt, kun je proberen die argumenten een voor een weg te werken. Maar als dat niet lukt,
probeer toe te voegen:

--traditionele-recursieve-make

Als dat ook niet lukt, heeft het bouwsysteem wat aanpassingen nodig om samen te werken met makepp. Ook al
als sommige hier beschreven opties iets bouwbaar maken, is het toch aan te raden om aan te passen
dingen een beetje, zodat ze uit de doos compatibel worden met beide merken.

Dwingen meer POSIX or GNU maken verenigbaarheid

Hier zijn enkele opdrachtregelmogelijkheden om veel legacy build-systemen te laten werken
zonder wijziging. Ze zorgen ervoor dat makepp het gedrag van GNU make nauwkeurig nabootst.

Compatibiliteit via de optie: "--build-check=target_newer"
Standaard zal makepp proberen om alle doelen opnieuw op te bouwen als een van de afhankelijkheden:
gewijzigd sinds de laatste build, of als de opdracht is gewijzigd (zie makepp_build_check voor
details). Dit is normaal gesproken wat je wilt. Soms wil je het doelwit echter niet
om opnieuw te worden opgebouwd als het is gewijzigd buiten de controle van makepp (bijv. door te bewerken
het, of door een programma handmatig uit te voeren om het bestand te maken). U kunt makepp dwingen om de . te gebruiken
traditioneel make-algoritme, dat alleen opnieuw wordt opgebouwd als een van de doelen nieuwer is dan de
afhankelijkheden, door deze optie toe te voegen aan de opdrachtregel.

Compatibiliteit via de optie: "--dont-build=config.status"
Er zijn pakketten die zichzelf automatisch proberen te configureren, of andere dingen doen, die gmake
negeert tenzij daarom wordt gevraagd, zoals:

config.status: configureren
./config.status --opnieuw controleren

configureren: configureren.in aclocal.m4
autoconfiguratie

De meeste mensen hebben niet eens "autoconf" geïnstalleerd, dus ze doen alles gewetensvol door
de regels, zoals makepp doet, zullen falen. Deze optie voorkomt dat, als je erachter komt wat
niet te bouwen.

Compatibiliteit via de optie: "--laatste-kans-regels"
Standaardregels (patroonregels zonder patroonafhankelijkheden) worden normaal gesproken niet ondersteund.
Makepp instantieert alle regels op basis van de bestaande bestanden, zodat het op de hoogte is van elke
bestand dat kan worden gegenereerd. Helaas weet het op deze manier niet hoe het een patroon moet instantiëren
regel zonder patroonafhankelijkheid. Het :last_chance-mechanisme verhelpt dat gedeeltelijk.
Waar dit goed genoeg is voor oudere makefiles, maakt deze optie het mogelijk om het wereldwijd aan te zetten.

Compatibiliteit via de optie: "--geen-waarschuwing"
Deze verbetert het resultaat niet. Makepp zal voor veel dingen waarschuwingsberichten geven
die het traditionele Unix-merk zonder aarzelen accepteert. Dit komt omdat er
betere manieren om ze te doen met makepp. Als deze waarschuwingen u irriteren, kunt u ze uitschakelen
met deze optie.

Compatibiliteit via de optie: "--hybride-recursieve-make"
Recursieve aanroepingen van make worden vaak als een onveilige praktijk beschouwd (zie "Better
systeem voor hiërarchische builds" in makepp voor details), maar ze zijn zeer gebruikelijk in
bestaande makefiles. Makepp ondersteunt recursieve make-up voor achterwaartse compatibiliteit; voor nieuw
makefiles, is het veel beter om de instructie "load_makefile" te gebruiken, of de impliciete
makefile laadmechanisme.

Om repositories te kunnen gebruiken voor variantbuilds en om recursief te helpen
aanroepen van maken veiliger, makepp roept zichzelf normaal gesproken niet recursief aan
zelfs als je het zegt. In plaats daarvan communiceert een subproces met het bovenliggende proces, en
de daadwerkelijke build wordt gedaan door het bovenliggende proces.

Dit werkt in de meeste gevallen, maar u mag niet meerdere makefiles van hetzelfde oproepen
directory, bijvoorbeeld, het volgende zal niet werken:

doel: afhankelijkheden
$(MAKE) -f other_makefile doelen

In dit geval merkt makepp dat het een 2e makefile laadt en klaagt. Met deze optie
in plaats daarvan zal het terugvallen op de traditionele manier van bouwen vanuit extra makefiles in
elk een afzonderlijk makepp-proces.

Opmerking: Technisch gezien zou het geen probleem zijn om meerdere makefiles te laden, maar ze hebben meestal de
dezelfde valse doelnamen. Dat uit elkaar houden zou een compleet herontwerp van makepp betekenen
binnenwerk. Dit zal echter werken, maar het is niet equivalent:

doel: afhankelijkheden
cd submap && $(MAKE) -f other_makefile doelen

Compatibiliteit via de optie: "--traditionele-recursieve-make"
Soms is de vorige optie niet genoeg, vooral als de recursieve aanroepingen
tegenstrijdige opties. Makepp gebruikt slechts één set globale opties, dus een submake is dat niet
toegestaan ​​om ze te wijzigen, aangezien dat ook zou gelden voor andere makefiles.

Het toevoegen van deze optie aan de opdrachtregel heeft de volgende ongewenste neveneffecten:

· Recursieve make-up wordt niet intern parallel uitgevoerd, zelfs niet als de parent dat wel doet.
In tegenstelling tot gmake is er geen algemene coördinatie van het aantal processen. Dit zal
niet worden geïmplementeerd omdat deze manier van werken geen ontwerpdoel van makepp is.

· Recursieve make-processen weten niets van repositories af.

· Elk recursief maakproces produceert zijn eigen logbestand, in de map waarin het wordt aangeroepen
in, in plaats van één logbestand voor de hele build te produceren.

· Aangezien makepp meestal meer bouwt dan traditioneel nodig acht, en aangezien veel
build-systemen bieden recursieve oproepen in alle richtingen, dit kan leiden tot eindeloze
herhaling. Makepp trekt na 50 ronden aan de rem en vertelt je hoe je kunt verhogen
dat, voor het geval je echt zo'n diep nest hebt.

Zelfs met de optie "--traditional-recursive-make" kunnen de omgevingsvariabelen
"MAKEOVERRIDES" en "MFLAGS" zijn niet ingesteld en genegeerd, dus makefiles die afhankelijk zijn van
die zullen niet werken.

A Voorbereiding gegenereerde Makefile is slechts een grappige omslag voor een aanroep van een submerk in hetzelfde
map. Als je een projectdoel hebt: XYZ het zal een regel hebben zoals

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

In dit geval kunt u de optie "--traditional-recursive-make" vermijden door rechtstreeks een beroep te doen op
makepp met die "-f XYZ.merk" optie.

Compatibiliteit zonder de optie: "--jobs=n"
Legacy makefiles geven soms niet alle afhankelijkheden weer, afhankelijk van de volgorde van:
uitvoering om ze op tijd te maken. In deze situatie kan makepp eerder een regel aanroepen
de afhankelijkheden zijn allemaal gemaakt. Dan kunnen de resultaten beter zijn met minder, of zelfs geen
parallelle uitvoering.

Compatibiliteit via de variabele: "makepp_simple_concatenation=1"
Rc-stijl substitutie is de standaard manier waarop makepp variabele substitutie in tekst uitvoert
strings omdat het zeer zelden legacy makefiles breekt en vaak handig is in new
make-bestanden. Het introduceert echter af en toe onverenigbaarheden bij de vervanging van
variabelen niet omgeven door spaties. Bijvoorbeeld,

INCLUDE_PREFIX := -I/sommige/include/dir -I
OMVAT := $(INCLUDE_PREFIX)/other/include/dir

zal "INCLUDES" instellen op "-I/some/include/dir/other/include/dir -I/other/include/dir" als rc-
stijlvervanging is ingeschakeld, terwijl GNU make dit zou instellen op
"-I/some/include/dir -I/other/include/dir". Bij het compileren van Redis 2.6.5 probeert het bijv
voer "printfgcc" uit. Zo'n grappige aaneenschakeling van twee commando's is een sterke aanwijzing dat:
deze variabele is nodig om terug te vallen om semantiek te maken.

Er is ook een incompatibiliteit in de verwerking van witruimte in een variabele:

nul :=
T := -o $(null) # T bevat -o gevolgd door één spatie.
OUTFILE = $(T)uitbestand

zal "OUTFILE" instellen op "-ooutfile" als vervanging in rc-stijl is ingeschakeld, terwijl GNU make
zou het op "-o outfile" zetten.

Beide incompatibiliteiten worden verwijderd door de "makepp_simple_concatenation" in te stellen
variabel. Merk echter op dat zelfs met "makepp_simple_concatenation", makepp nog steeds
behandelt witruimte in sommige situaties incompatibel:

T := -o # Verwijder deze reactie niet.

GNU make stelt "T" in om "-o" te bevatten gevolgd door een spatie, terwijl makepp de . verwijdert
achterstallige ruimte in ieder geval. Als u de volgruimte wilt, moet u instellen
"makepp_simple_concatenation" en stel ook "T" in met behulp van de techniek met een dummy
variabele zoals "null", zoals hierboven weergegeven.

Workaround optie "--geen-remake-makefiles"
Typische open source vereist het aanroepen van "configure" om de makefiles te maken. Maar dan deze
makefiles kunnen regels bevatten om de makefile opnieuw te maken, door een commando aan te roepen. Makepp zal
graag voldoen en bijwerken volgens de regel. Maar soms is dit schadelijk, dus
sla het gewoon over.

Compatibiliteit via de variabele: "makepp_percent_subdirs=1"
Standaard komt "%" in een patroonregel niet overeen met mappen. Dit betekent dat een regel als
deze:

%.o: %.c
$(CC) $(CFLAGS) -c $(invoer) -o $(uitvoer)

wordt niet toegepast op bestanden zoals "../shared/xyz.c". Als u wilt dat het overeenkomt met bestanden in
subdirectories, stel dan de variabele "makepp_percent_subdirs=1" in op de opdrachtregel
of in de buurt van het begin van een makefile.

Compatibiliteit via de milieu variabele: $MAKEPP_IGNORE_OPTS
Soms geven legacy recursieve aanroepingen opties door die makepp niet begrijpt.
Hopelijk is de optie niet belangrijk, maar het voorkomt dat makepp wordt uitgevoerd. Hiermee
omgevingsvariabele kunt u makepp vragen bepaalde opties stilzwijgend te negeren. De waarde
zal een door spaties gescheiden lijst met opties zijn, die in 4 varianten kan komen:

--lang=x
Een lange optie die een argument verwacht. Dit feit moet worden verklaard via de gelijken
teken, hoewel het daadwerkelijke gebruik ook kan worden gescheiden door witruimte, ofwel "--long=bla" of
"--lang bla".

--lang
Een lange optie zonder argument.

-sx Een korte optie die een argument verwacht. Dit feit moet worden verklaard door toe te voegen
iets direct na de optie, hoewel het daadwerkelijke gebruik ook kan worden gescheiden door
witruimte, ofwel "-sbla" of "-s bla".

-s Een korte optie zonder argument.

Overschrijf bijvoorbeeld makepp's -R optie met één zonder een argument en accepteer gmake's debug
optie met een argument:

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

onverenigbaarheden dat vereisen Makefile veranderingen

· Makefiles die make expliciet aanroepen, voorkomen dat makepp alles zelf bouwt.
Helaas voert Perl's eigen "ExtUtils::MakeMaker" de tweede van de volgende twee vormen van
deze fout tot versie 6.56 (Perl 5.12.1):

submap:
cd-submap; maken

MAKEN = maken

· Het instellen van de variabele "VPATH" op een bepaalde waarde roept impliciet "vpath % value" aan. "vpad"
statements worden geëmuleerd met het repository-mechanisme. Dus, waar gmake vervangt
het pad naar het bestand gevonden in het vpath, zal makepp het in plaats daarvan symbolisch koppelen aan
waar het nodig is. Dus makepp zal een ongewijzigde string leveren, wat meestal is
geen probleem.

Doelen in een vpath worden niet ondersteund. (Gmake beschouwt ze als ze nieuwer zijn dan
hun afhankelijkheden, maar als dat niet het geval is, wordt het doel opnieuw gemaakt in de huidige map
-- nogal inconsistent.) Het uitschakelen van vpaths wordt niet ondersteund.

· Een patroonregel die later in een makefile aanwezig is, overschrijft een eerder aanwezige patroonregel.
Dit is achterwaarts van GNU make.

· De set ingebouwde impliciete regels verschilt enigszins van die voor GNU make,
hoewel de namen van variabelen grotendeels compatibel zijn. De ingebouwde regels moeten
succesvol C/C++/Fortran-programma's compileren, en in feite in staat zijn om de
in sommige gevallen ook goede bibliotheken. Ondersteuning voor Modula-2 en RatFor en andere zeldzame
talen is bewust niet aanwezig, omdat ik steeds tegen problemen aanliep met GNU
make's regels wanneer ik per ongeluk de extensies voor die talen opnieuw heb gebruikt.

· Een actievoorvoegsel van "+" wordt stilzwijgend genegeerd.

· Archiefleden worden niet ondersteund, en de bijbehorende automatische variabelen ook niet
$%, "$(%D)" en "$(%F)".

· Er is geen SCCS-ondersteuning.

· Voorloop- en volgspaties in variabele toewijzingen worden genegeerd (zelfs als de
witruimte wordt gevolgd door een opmerking). Voor meer details over het omgaan met witruimte
onverenigbaarheden, zie "Witruimte in variabelen" in makepp_variables.

· Makepp probeert geen bestanden opnieuw op te bouwen die zijn opgenomen in de "include"-instructie, tenzij
de makefile bevat een regel om ze te bouwen voordat de include-instructie wordt gezien.
(Het zal echter proberen de makefile zelf opnieuw op te bouwen.) Dit wordt normaal gesproken gebruikt voor:
afhandeling omvat bestandsafhankelijkheden, en is niet zo handig met makepp omdat u dat niet doet
moet dat sowieso doen.

· De variabele "SHELL" wordt momenteel gedeeltelijk genegeerd. Makepp gebruikt altijd / Bin / sh
tenzij /usr/xpg4/bin/sh or /sbin/xpg4/sh is gevonden of tenzij u de "SHELL" exporteert
variabele in je makefile. Maar als u dat doet, is de opdrachtparser mogelijk niet volledig
begrijpen wat uw shell-commando doet. Op Windows Strawberry of ActiveState Perl
je moet in plaats daarvan je SHELL-variabele instellen vaardigheden makepp bellen.

· Afhankelijkheden van alles op de Makefile werken nog steeds, maar zijn meestal niet nodig.
Dit wordt meestal gebruikt om het opnieuw opbouwen te forceren wanneer de compilatie-opties veranderen. Makepp weet het
wanneer build-commando's zijn gewijzigd zonder iets speciaals in de makefile; het slaat op
dit per bestand. Als je de makefile verandert, weet het precies welke
bestanden moeten opnieuw worden gecompileerd.

· Tussenbestanden worden niet verwijderd. (Omdat makepp erop staat alle bestanden te hebben)
datums zijn hetzelfde als bij de laatste build, tussenliggende bestanden moeten allemaal
aanwezig is, anders vindt herbouw plaats.) Er is geen speciale status toegekend aan
tussenliggende bestanden.

· Het enige speciale doel dat wordt ondersteund is ".PHONY" en gedeeltelijk ".SUFFIXES". De
resterende zijn gewoon ingegoten.

Specifiek heeft GNU make de volgende speciale doelen:

.SUFFIXEN
Makepp negeert ".SUFFIXES" behalve het speciale geval van ".SUFFIXES" met no
afhankelijkheden, zoals deze:

.ACHTERGRONDEN:

die hem vertelt om geen van zijn standaardregels te laden.

.TUSSENTIJDS, .SECUNDAIR, .KOSTBAAR
Er wordt geen speciale status toegekend aan tussenbestanden en dus ook niet aan deze doelen
zinvol.

.NEGEREN
Dit doel wordt genegeerd. Als u fouten wilt negeren, plaatst u het woord "ignore_error"
(of een minteken) voor het commando waarvan de uitgangsstatus moet worden genegeerd.

.STIL
Dit doel wordt genegeerd. Als je wilt dat commando's niet echoën, zet je het woord "noecho"
(of het "@"-teken) voor het commando dat niet mag worden herhaald,
of gebruik de "--silent" optie om makepp.

.DELETE_ON_ERROR
.EXPORT_ALL_VARIABLES
.GEEN EXPORT
.POSIX
.STANDAARD
Deze doelen worden niet ondersteund en worden gewoon genegeerd.

· De GNU make-functies "eval", "flavour" en "value" worden momenteel niet ondersteund. Jij
kan hetzelfde bereiken als eval op een meer eenvoudige manier met "$[...]"
variabele of functie-uitbreiding.

· Dubbele dubbele puntregels worden niet volledig ondersteund. (Ze kunnen niet zijn: in het paradigma van makepp,
er kan niet meer dan één manier zijn om een ​​doel bij te werken.) Momenteel is elke opeenvolgende
dubbele dubbele puntregel voor een bepaald doel voegt eenvoudig zijn opdrachtreeks en afhankelijkheid toe
list naar de opdrachtreeks en afhankelijkheidslijst voor dit doel. Als je bijvoorbeeld
Schrijf dit:

een :: b
&cat b -oa

# Later in je makefile:
een :: c
&cat c -o >>a

het is precies hetzelfde alsof je had geschreven

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

Dit is zeker niet waar dubbele dubbele puntregels voor bedoeld zijn, en dat zal ook niet altijd het geval zijn
werkt, maar het werkt wel voor doelen zoals "schoon" of voor alle dingen die
ExtUtils::MakeMaker plaatst in zijn makefiles. Reken er voor niets anders op
dan legacy makefiles.

· De functie "$(wildcard )" komt niet alleen overeen met bestanden die bestaan, maar ook met bestanden die
nog niet bestaan, maar die een regel hebben die makepp heeft gezien op het moment dat de
De functie "$(wildcard )" wordt geëvalueerd.

· De "define"-instructie wordt ondersteund, maar de verwerking van "@" die eraan voorafgaat, is voltooid
anders. Momenteel in makepp, "@" voor een variabele met meerdere regels
waarde onderdrukt alleen de echo van de eerste regel. Bijvoorbeeld,

definieer echo-lijnen
&echo lijn1 -o $@
&echo lijn2 -o>>$@
einde

x:
@$(echolijnen)

zal het afdrukken van "&echo line2" niet onderdrukken zoals bij GNU make; het zal alleen
onderdrukken afdrukken van "&echo regel1".

· Makepp ondersteunt de volgende omgevingsvariabelen niet (het stelt ze niet in,
en het negeert ze gewoon):

MAKE-OVERRIJDEN
MFLAGS

onverenigbaarheden in bestellen of uitdrukking uitbreiding
· In makepp worden regelacties uitgebreid voordat alle afhankelijkheden gegarandeerd zijn
is gebouwd. U kunt dit omzeilen door regels zoals deze te wijzigen:

foe: bar
genfoo < $(schelpkattenreep)

deze:

foe: bar
genfoo < `kattenbar`

of dit, waardoor het bestand tijdens de uitbreiding:

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

Dit verdient hier de voorkeur, omdat het bestand in bars is hier ook een afhankelijkheid van
regel, en makepp kan het nu opvangen bij het lexicaal analyseren van de omleiding.

· Hoewel ik dit niet heb gebruikt, staat GNU make het volgende toe:

dubbele punt = :
a$(dubbele punt) b
echo $^

Makepp breidt "$(colon)" te laat uit om dit te laten werken. Het biedt echter de
alternatieve "$[colon]"-syntaxis, die veel meer kan dan GNU maken, want het is
zeer vroeg uitgebreid.

"$(MAAK)" mogen omvatten ruimten
In een niet-geïnstalleerde makepp of als het platform het starten van een Perl-script niet lijkt te ondersteunen
op magisch getal of met "--traditional-recursive-make" bevat deze variabele ten minste
één ruimte. Bij gebruik als commando is dat geen probleem. Maar bij het doorgeven als een
parameter zonder aanhalingstekens toe te voegen aan een script (zoals het Perl 5.14.0-buildsysteem doet), zal het het verscheuren
apart in afzonderlijke parameters, wat tot verwarring leidt. Dus als parameter is het veiliger om
citeer het als '$(MAKE)'. wat de achterwaartse compatibiliteit niet verbreekt.

Doelspecifiek opdrachten niet propageren
De doelspecifieke variabelen van Makepp verschillen enigszins van die van GNU make omdat ze:
alleen van toepassing zijn op de regel voor het ene genoemde bestand, en niet op een van zijn voorgangers; zien
Doelspecifieke opdrachten.

Haakjes or bretels niet nest
Makepp beëindigt uitdrukkingen bij het eerste overeenkomende haakje of accolade. In plaats van dit

$(een functie ... ( ) ...) # GNU maakt stijl

je moet een van deze gebruiken

${somefunction ... ( ) ...} # GNU compatibel maken
$((een functie ... ( ) ...)) # Makepp-extensie

Dit zal waarschijnlijk worden opgelost in versie 2.1, misschien optioneel.

Minder punten
Patroonafhankelijkheden komen niet overeen met nepdoelen
%.a: %.b; ...
$(nep xb): ; ... # biedt geen manier om xa . te bouwen

Opmerkingen hebben geen vervolgregels
# Dit is \
GEEN 2-regelige opmerking

commando lijn onverenigbaarheden

Makepp ondersteunt enkele van make's meer bruikbare commandoregelopties. Het volgende echter
worden niet ondersteund:

-d of --debug
-F -
Makepp's interne makefile-objecten zijn gekoppeld aan bestandsobjecten, dus het kan niet overweg
standaard.

-i
-l of --load-gemiddelde of --max-load
-m De "-m" optie van Makepp heeft te maken met de selectie van de handtekeningmethode, terwijl GNU make
negeert -m.

-p of --print-database
-q of --vraag
-R of --geen-ingebouwde-variabelen
Makepp's "-R" optie doet eigenlijk iets heel anders.

-S --niet doorgaan of --stop
De optie "--stop" stopt makepp (in slaapstand) nadat je alle regels hebt geleerd, zodat je
kan doorgaan met bewerken.

-t of --touch
-w of --print-directory
Dit gebeurt automatisch.

--warn-undefined-variabelen

Sommige hiervan kunnen gemakkelijk worden ondersteund als iemand erom geeft.

Veranderlijk onverenigbaarheden

Makepp zoekt in $PATH naar een overeenkomend commando om te retourneren voor variabelen zoals "$(CC)" of
"$(CXX)", terwijl GNU make statische standaarden heeft. Ook geeft makepp de voorkeur aan "gcc" en
"g++" terwijl verrassend genoeg GNU retourneert "cc" voor de eerste, maar hetzelfde voor de
laatstgenoemd. U kunt deze overschrijven in de makefile, op de opdrachtregel of door a . te exporteren
variabele met dezelfde naam voordat makepp wordt aangeroepen.

Gebruik makepp_incompatibilities online met onworks.net-services