makepp_variables – Online in der Cloud

PROGRAMM:

NAME/FUNKTION

makepp_variables – So verwenden Sie Variablen in makepp

BESCHREIBUNG

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAGS,
WIE, C: Gleichstrom,
CFLAGS,
„geänderte_Abhängigkeiten“,
geänderte_Eingaben,
CURDIR,
CXX,
CXXFLAGS, D: „Abhängigkeiten“,
"Abhängigkeit", F: F77,
FC,
"für jede", I: Eingang,
Eingänge, L: L.D.,
LEX,
LIBTOOL, M: MACHEN,
MAKECMDGOALS,
MAKEFLAGS,
MAKEINFO,
MAKEPP_DEBUG,
MAKEPPFLAGS,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
„makepp_percent_subdirs“,
„makepp_require_phony“,
makepp_signature_C_flat,
„makepp_simple_concatenation“,
MAKEPP_VERSION, O: "Ausgabe",
„Ausgänge“, P: PERL,
PWD, R: MRT,
WURZEL, S: HÜLSE,
„sortierte_Abhängigkeiten“,
sortierte_Eingaben,
"Stengel", T: Ziel,
Ziele, V: VPATH, Y: YACC

Makefiles verwenden normalerweise an vielen Stellen Variablen. Ein wichtiger Grund für die Verwendung
Variablen sollen sicherstellen, dass Informationen nur an einer Stelle im Makefile enthalten sind
dass bei einer Änderung keine Gefahr besteht, dass die beiden Kopien der Informationen herauskommen
synchronisieren

Bei Variablennamen muss die Groß-/Kleinschreibung beachtet werden. Theoretisch können viele Variablennamen gebildet werden
Zeichen, aber makepp wird es wahrscheinlich nicht verstehen können, wenn Sie etwas anderes tun als
alphanumerische Zeichen, „_“ und „-“.

Jedes Makefile hat seinen eigenen Satz von Variablen, und das Festlegen einer Variablen in einem Makefile wird dies tun
hat keinen Einfluss auf seinen Wert in anderen Makefiles. Wenn Sie Variablen festlegen möchten
Bei vielen Makefiles ist es am besten, wenn jedes Makefile eine gemeinsame Definition enthält
Datei (siehe Include-Anweisung) oder verwenden Sie „globale“ Variablen.

Variable Zuordnung
Eine Variable kann auf verschiedene Arten einen Wert annehmen:

· Eine Variable kann innerhalb eines Makefiles festgelegt werden. Es gibt verschiedene Möglichkeiten, dies zu tun
Das; siehe unten.

· Der Wert einer Variablen kann wie folgt in der Befehlszeile angegeben werden:

makepp CFLAGS=-O2 my_program

Wenn mehr als ein Makefile geladen wird, wird die CFLAGS-Variable an alle weitergegeben
Makefiles. In der Befehlszeile festgelegte Variablen überschreiben automatisch alle Einstellungen von
die Variable in einem der Makefiles.

Bei Bedarf muss das Makefile wiederum die Befehlszeileneinstellungen explizit überschreiben.
Die Absicht besteht nicht darin, die Anforderungen des Benutzers zu ignorieren, sondern darin, sie zu ändern.
Der Modifikator „override“ kann jeder Zuweisungsanweisung vorangestellt werden. Aber im Fall von
Bei Schlüsselwortanweisungen ist die Reihenfolge wichtig, weshalb es sich um die Override-Variante handelt
immer unten angezeigt. Der Modifikator „override“ gilt nur für alle Zuweisungen, bei denen er vorhanden ist
vorhanden ist und spätere Zuweisungen an die Variable nicht beeinflusst.

· Wenn eine Variable in der Umgebung festgelegt ist, kann sie als makepp-Variable referenziert werden.
Normalerweise überschreiben Zuweisungen an Variablen innerhalb eines Makefiles die Einstellungen aus dem
Umgebung, aber Sie können dies ändern, indem Sie „-e“ oder „--environment-overrides“ verwenden.
Befehlszeilenoption.

Variablen werden wie folgt mit einem von mehreren Zuweisungsausdrücken zugewiesen

X = 1
MODULE := abcd
CC ?= gcc
CFLAGS += -Wall
VAR definieren
var Zeile 1
var Zeile 2
enddef
export PATH := $(PWD):$(PATH)
global MYPROJECT.INFO = Informationen, die in allen Makefiles angezeigt werden

Führende und nachfolgende Leerzeichen um Werte herum werden immer entfernt.

Die verschiedenen Zuweisungsoperatoren haben etwas unterschiedliche Bedeutungen.

Einfacher Zuordnung Betreiber

=
VARIABLE = Textzeichenfolge
override VARIABLE = Textzeichenfolge

Dies ist die übliche Zuweisungsanweisung, die von allen Implementierungen unterstützt wird. Der
Der Ausdruck auf der rechten Seite wird erst ausgewertet, wenn der Wert von „$(VARIABLE)“ vorliegt
tatsächlich irgendwo verwendet. Wenn Sie also Folgendes tun:

X = 1
Y = $(X)
X = 2

Dann wird „$(Y)“ später im Makefile zu „2“ ausgewertet.

Im Allgemeinen möchten Sie normalerweise „:=" (siehe unten) anstelle von „=" verwenden, weil es
Bietet eine vorhersehbarere Variablenauswertung. Es gibt jedoch Zeiten, in denen Sie es brauchen
um die Variablenauswertung zu verschieben. Auch wenn Sie ein Makefile schreiben, muss dies der Fall sein
abwärtskompatibel mit einer anderen Make-Version als GNU Make, dann haben Sie keine
Wahl: Sie dürfen nur „=“ verwenden.

:=
VARIABLE := expr
VARIABLE überschreiben := expr

Dies ist dasselbe wie „VARIABLE = expr“, außer dass die rechte Seite ausgewertet wird
ein für alle Mal zum Zeitpunkt des Auftrags. Also wenn

X := 1
Y := $(X)
X := 2

dann wird „$(Y)“ später im Makefile zu „1“ ausgewertet, da „$(X)“ das war
als „$(Y)“ definiert wurde.

;=
VARIABLE ;= expr
VARIABLE überschreiben ;= expr

Dies ist dasselbe wie „VARIABLE := expr“, außer dass die rechte Seite ausgewertet wird
nur zum Zeitpunkt der ersten Verwendung und dann erinnert. Dies ist nützlich für teure
Befehle, die immer den gleichen Wert zurückgeben, die Sie aber wann nicht ausführen möchten
Aufbau unabhängiger Ziele:

VAR1 ;= $(Perl teure Berechnungen)
VAR2 ;= $(externer Shell-Befehl)

Beachten Sie, dass alte Makefiles hier normalerweise „:=" verwenden, um dies zumindest nur einmal zu tun.
Mit diesem Operator können Sie dies jedoch auch nicht tun, wenn Sie dies bereits nicht tun
brauche den Wert. Bei Werten, die in mehreren Verzeichnissen identisch sind, ist dies möglich
Optimieren Sie dies weiter mit „global“, wie unten erläutert.

Dies ist jedoch nicht als clevere Möglichkeit gedacht, die Reihenfolge der Bewertung zu erzwingen. Wenn ein
Eine so definierte Variable enthält den Wert einer anderen Variablen, und zwar dieser anderen
hat einen zielspezifischen Wert und die erste Erweiterung ist für dieses Ziel, dann die
Der zielspezifische Wert bleibt auch für alle anderen Kontexte bestehen. Das ist ein Fehler und
wird hoffentlich in Zukunft behoben.

+=
VARIABLE += Ausdruck
VARIABLE += Ausdruck überschreiben

Hängt die Zeichenfolge an den vorherigen Inhalt der Variablen an, getrennt durch ein Leerzeichen. Wenn
wurde die Variable zuvor mit „:=" belegt, dann wird die rechte Seite ausgewertet
vor dem Anhängen.

&=
VARIABLE &= Ausdruck
VARIABLE &= Ausdruck überschreiben

Stellt die Zeichenfolge dem vorherigen Inhalt der Variablen voran, getrennt durch ein Leerzeichen.
Wenn die Variable zuvor mit „:=“ zugewiesen wurde, dann ist dies die rechte Seite
vor dem Anhängen ausgewertet.

Zum Beispiel eine Möglichkeit, sicherzustellen, dass „CFLAGS“, was auch immer der Benutzer sonst noch eingibt,
Beginnt immer mit „-Wall“ sind diese beiden Zeilen:

CFLAGS = -O2 # Möglicherweise in der Befehlszeile überschrieben
überschreiben Sie CFLAGS &= -Wall # Bedingungslos vorangestellt

In alten Makefiles musste man normalerweise so etwas tun, was den Nebeneffekt hatte
Auswirkung des Erzwingens des Typs auf „:=", um eine endlose Rekursion zu verhindern:

VARIABLE := expr $(VARIABLE)

?=
VARIABLE ?= expr
override VARIABLE ?= expr # Nutzlos, aber legal

Legt den Wert der Variablen fest, jedoch nur, wenn die Variable nicht zuvor angegeben wurde
im Makefile, in der Befehlszeile oder in der Umgebung. Die obige Aufgabe lautet
genau äquivalent zu

ifndef VARIABLE
VARIABLE = Ausdruck
Endif

!=
VARIABLE != Shell-Befehl
Überschreiben Sie den Shell-Befehl VARIABLE !=

Führt den Shell-Befehl aus und legt die Variable so fest, dass sie die Standardausgabe des Befehls enthält.
Das entspricht genau

VARIABLE := $(Shell-Befehl)

Mehrzeilig Variablen

Die „define“-Anweisung ist das mehrzeilige Äquivalent der oben genannten einfachen Anweisungen. Der
Der Operator nach der Variablen ist optional. Wenn es fehlt, entspricht es „VARIABLE definieren“.
=". Die Operatoren „&=" und „+=" unterscheiden sich hier geringfügig darin, dass sie dies festhalten
den alten Wert mit einer neuen Zeile anstelle eines Leerzeichens. Es darf nichts anderes geben als a
Kommentar nach der Anweisung, dh der Wert beginnt in der nächsten Zeile.

VARIABLE definieren :=
erste Zeile des Variablenwerts
zweite Zeile des Variablenwerts
Dritte Zeile des Variablenwerts
Endef

Überschreiben Sie die Definition von VARIABLE
...
enddef

Schlüsselwörter vor „define“ können Kombinationen aus „export“ oder „global“ sein
„überschreiben“.

Wenn der Wert einer Variablen Zeilenumbrüche enthalten soll, müssen Sie die „define“-Anweisung als verwenden
angezeigt (oder Sie können den Wert direkt in Perl zuweisen). ("endef" wurde ausgewählt
Kompatibilität mit GNU make. Sie können auch „enddef“ verwenden.) Dies ist vor allem nützlich für
„vorgefertigte Befehlssequenzen“, z. B. etwa so:

Definieren Sie COMPILE_C_PROGRAM
@&echo „$(Eingabe) wird kompiliert“
@$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(Eingabe) -o $(Ausgabe)
Endef

Dann können Sie diese mehrzeilige Variable in mehreren Regeln verwenden, etwa so:

%.o : %.c
$(COMPILE_C_PROGRAM)

$(ARCH)/%.o : $(ARCH)/%.c
$(COMPILE_C_PROGRAM)

Beachten Sie, dass Sie oft den gleichen Effekt erzielen können, indem Sie ein Semikolon anstelle eines Zeilenumbruchs verwenden.
weil die Shell das auch als Befehlstrennzeichen interpretiert. Zum Beispiel,

COMPILE_C_PROGRAM = @echo „$(Eingabe) wird kompiliert“; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(Eingabe) -o $(Ausgabe)

hat den gleichen Effekt, außer dass das Semikolon Perl zwingt, es an die Shell zu übergeben.
anstatt den Befehl direkt und effizienter auszuführen. Sie müssen auch jeden angeben
eingebaut in einer eigenen Zeile, was bedeutet, dass Sie auf das externe Echo in der umschalten müssen
Semikolon-Fall.

Beim Erweitern innerhalb von „define“ gibt es eine Besonderheit, nämlich „define X :=" oder auf a
Variable, die bereits „:=", „define X &=" und „define X +=" war. In diesem Fall die
„$(Shell-Befehl ...)“ oder das integrierte „$(&command ...)“ werden nicht in Zeilenumbrüche umgewandelt
Räume.

Exportieren Variablen zu Teilprozesse

VAR exportieren ...
Export VAR = Wert
Export VAR += Wert überschreiben

Das erste Formular markiert die angegebenen Variablen für den Export in Unterprozesse, mit welchem ​​Wert auch immer
Die Variable hat dann. Die zweite Form gilt zusätzlich nur für eine Variable
weist sofort einen Wert zu. Es sind alle Zuordnungsvarianten zulässig.

Teilen Variablen über Makefiles

globaler VAR ...
globaler VAR = Wert
globalen VAR-Wert &= überschreiben

Das erste Formular markiert die angegebenen Variablen als global für alle Makefiles. Wenn einer von ihnen
bereits einen Wert hatte, wird dieser Wert von der lokalen Makefile-Variable in die globale Variable verschoben
eins. Wenn jedoch zu dem Zeitpunkt, an dem diese Anweisung angezeigt wird, bereits andere Makefiles eine hatten
Wert für einen von ihnen, dann sehen diese Makefiles den globalen nicht.

Die zweite Form, die nur für eine Variable gilt, weist zusätzlich ein Wertrecht zu
weg. Es sind alle Zuordnungsvarianten zulässig. Beachten Sie, dass „:=" sofort erweitert wird
zu den Werten im lokalen Makefile. Im Gegenteil: „=“-Variablen werden auf erweitert
Werte am Einsatzort.

Der Umgang mit globalen Variablen kann schwierig sein, da makepp Makefiles in beliebige laden kann
Reihenfolge, da die Notwendigkeit entsteht, ein Ziel zu erstellen, für das keine Regel oder Makefiles geladen sind.
Aus diesem Grund wird empfohlen, eine RootMakeppfile und alle explizit zu laden
andere, die die Variable mit „load-makefile“ ändern oder verwenden.

globale GLIBLIBS ;= $(shell pkg-config --libs glib-2.0)

Beachten Sie auch, dass Ihr Projekt eines Tages möglicherweise zusammen mit anderen Projekten erstellt wird. Dafür
Aus diesem Grund wird empfohlen, den Projektnamen immer als Teil eines globalen Variablennamens anzugeben.

Zielspezifisch Zuordnungen

Ziel: VARIABLE = Zeichenfolge
Ziel: VARIABLE := Zeichenfolge
Ziel: VARIABLE += String überschreiben

Legt einen zielspezifischen Wert der Variablen fest. Es gilt ein zielspezifischer Wert einzige
in einer Aktion, die das gegebene Ziel erzeugt. Dies wird hauptsächlich für Dinge verwendet wie
Dies:

CFLAGS := -O2

my_prog: file1.o file2.o spezielle_datei.o

spezielle_datei.o: CFLAGS:= -g

%.o: %.c
$(CC) $(CFLAGS) -c $(Eingabe) -o $(Ausgabe)

Hier werden alle „.c“-Dateien mit Optimierung („-O2“) kompiliert. ausgeschlossen
„special_file.c“, das im Debug-Modus („-g“) kompiliert wird. Dies ist eine bequeme Möglichkeit
Geben Sie für nur wenige Dateien unterschiedliche Kompilierungsoptionen an.

Zielspezifische Variablenzuweisungen wie diese gelten nur für die Aktionen der Regel; Sie
sind bei der Auswertung der Ziele oder Abhängigkeiten einer Regel nicht wirksam. Wenn eine Regel
Hat mehr als ein Ziel, werden zielspezifische Variablenzuweisungen nur aus dem übernommen
zuerst Ziel. Beachten Sie auch, dass die zielspezifischen Variablen von makepp leicht unterschiedlich sind
von GNU make's, da sie nur für die Regel für die eine genannte Datei gelten und nicht für
einer seiner Vorgänger.

Die Wildcard-Erweiterung wird auf dem Ziel durchgeführt, Sie können also etwa Folgendes tun:

test_*.o : CFLAGS += -DTEST

Aus Kompatibilitätsgründen mit GNU make kann „%“ anstelle von „*“ verwendet werden.

Variable Substitution
Die Variablensubstitutionsregeln von Makepp ähneln denen anderer Marken, nur in gewisser Weise
stärker. Wie bei allen Marken repräsentieren „$(CC)“ oder „${CC}“ beide den Wert des
Variable CC. Wenn Sie ein wörtliches Dollarzeichen benötigen, geben Sie ein doppeltes Dollarzeichen ($$) ein, z
Dies:

Ziel: dep1 dep2 dep3 dep4
&rm -f $(Ausgabe)
für Datei in $(Eingaben); do cat $$file >> $(output); Erledigt

Darüber hinaus verfügt makepp über eine „$[VARIABLE]“-Syntax, die das Gleiche bewirkt wie die anderen
zwei, aber bevor Makepp noch etwas anderes grokt. Dies ermöglicht die Verwendung für vollständige Regeln
und/oder Bedingungen:

definiere Bracket_rule =
ifdef SOME_VAR
Halterung:
&echo das ist eine Regel -o $(Ausgabe)
Endif
enddef

$[bracket_rule]

RC-Stil Substitution

Standardmäßig verwendet makepp die Substitution im RC-Stil (so genannt, weil sie von entwickelt wurde
RC-Shell). Dies lässt sich am besten anhand eines Beispiels veranschaulichen:

MODULE = abcd

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(Abhängigkeiten) -o $(Ziel)

In MODULES wird jedem Wort das Präfix „module_dir/“ und das Suffix „.o“ vorangestellt
an jedes Wort angehängt.

Sie können die Substitution im rc-Stil auch verwenden, ohne die Wortliste überhaupt in a einzufügen
Variable; Die Syntax lautet „$( Wort1 Wort2)“. Beachten Sie das Leerzeichen zwischen der Klammer und dem
erstes Wort. Das obige Beispiel hätte also wie folgt geschrieben werden können:

mylib.a: module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(Abhängigkeiten) -o $(Ziel)

Eine Variable führt nur dann eine Substitution im RC-Stil durch, wenn sie mehr als ein Wort enthält.
Mit einem Wort ist es wie bei traditioneller Herstellung. Leider gibt es eine, wenn die Variable leer ist
Konflikt. Herkömmliche Methoden erweitern es einfach auf die leere Zeichenfolge. Aber wenn man darüber nachdenkt
Wenn Sie es als Liste verwenden, möchten Sie, dass „-I$(DIRLIST)“ verschwindet und kein einsames „-I“ entsteht. Der
Die Lösung besteht darin, es in eine Liste einzuschließen, die mit einem Leerzeichen beginnt: „-I$( $(DIRLIST))“ gibt Ihnen
genau so viele Optionen, wie es Wörter in der Liste gibt.

Wenn Sie mehrere Variablen in dasselbe Wort einfügen, die sich zu Wortarrays im RC-Stil erweitern
Die Substitution nimmt tatsächlich das kartesische Produkt, Sie können also so etwas tun, wenn
Sie wollen:

DIRS = s1 s2
MODULE = abc
SUFFIXE = .o .c
DATEIEN := $(DIRS)/$(MODULE)$(SUFFIXES)

und FILES enthalten die Zeichenfolge

s1/ao s1/ac s1/bo s1/bc s1/co s1/cc s2/ao s2/ac s2/bo s2/bc s2/co s2/cc

Abgesehen von Leerzeichen stoppt die Ersetzung im rc-Stil bei jedem Anführungszeichen, egal ob rund, geschweift oder eckig
Klammern und beliebige von „, : ; = # @“. Beachten Sie, dass dies überraschend und erneut erforderlich sein kann
eine explizite Liste. Angenommen, Sie möchten in allen Verzeichnissen nach Headern per Platzhalter suchen
beginnend mit einem Großbuchstaben:

BAD := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
GUT := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Wenn die Ersetzung im RC-Stil im Weg ist oder wenn Sie einen Vor- oder Nachlauf benötigen
Wenn Sie in Ihren Make-Variablen Leerzeichen einfügen, können Sie die Ersetzung im RC-Stil durch Setzen deaktivieren
die Variable „makepp_simple_concatenation=1“. Sie können es mit dem Befehl global deaktivieren
Zeile oder als Umgebungsvariable. Oder auf Makefile-Basis, indem Sie die Variable festlegen
Ihr Makefile. Sie sollten dies am oberen Rand des Makefiles tun, sonst könnten Sie darauf stoßen
Lustige Situationen, in denen für einige Auswertungen eine Substitution im RC-Stil verwendet wird und für andere nicht.
(Alle vor der Zuweisung ausgewerteten Ausdrücke verwenden Ersetzungen im RC-Stil und alle
Ausdrücke, die danach ausgewertet werden, werden nicht ausgeführt. Seit der Bewertung von Ausdrücken in
Makefiles sind kompliziert und aus der Reihenfolge der Anweisungen im nicht immer ersichtlich
makefile, es ist am besten, „makepp_simple_concatenation“ so früh wie möglich festzulegen.) Sie können
sogar nur für ein Ziel festlegen:

Ziel: makepp_simple_concatenation = 1
Ziel:
&echo before_first$(LIST)after_last -o $(output)

Da „$[VARIABLE]“ früher ausgewertet wird als „$(VARIABLE)“, kombiniert die Kombination der beiden in rc-
Die Ersetzung führt nicht zu dem erwarteten Ergebnis, es sei denn, Sie schließen sie explizit ein
Liste:

A = ab
N = 1 2
SCHLECHT := $(A)$[N]
GUT := $(A)$( $[N])

Die letzten Zeilen werden gelesen als

SCHLECHT := $(A)1 2 # a1 b1 2
GUT := $(A)$( 1 2) # a1 a2 b1 b2

Substitution Bibliographie

Eine Ersetzungsreferenz hat die Form „$(VAR:A=B)“, wobei A ein zu vergleichendes Muster und B ein Muster ist
ein Muster, durch das es ersetzt werden kann. Substitutionsreferenzen sind eine Abkürzung für
„patsubst“-Funktion. Zum Beispiel:

source_files = ac bc cc dc
object_files = $(source_files:%.c=%.o)

setzt „$(object_files)“ auf „ao bo co do“. Das „%“ ist ein passendes Sonderzeichen
jede beliebige Zeichenfolge. Wenn sowohl A als auch B mit „%“ beginnen, ist dies ein häufiger Fall beim Ersetzen
Suffixe, sie können weggelassen werden:

object_files = $(source_files:.c=.o)
object_files = $(source_files:c=o) # gleich, weil . ist nichts Besonderes

Leerzeichen in Variablen

Wenn Sie den Leerraum in einer Variablen steuern müssen, müssen Sie (derzeit) rc-style deaktivieren
Substitution (durch Setzen von „makepp_simple_concatenation=1“) und verwenden Sie dann eine Syntax wie diese:

null =
T = -o $(null)

oder, mit einer leeren Auswertung:

T = -o $()

Wenn Sie dies tun, enthält die Variable „T“ „-o“, gefolgt von einem Leerzeichen.

Eine solche Technik zur Behandlung von Leerzeichen wird nicht empfohlen. Wenn Sie Variablen benötigen
Wenn Sie in Ihrem Makefile Leerzeichen enthalten, sollten Sie ernsthaft darüber nachdenken, was Sie tun.
Wenn Sie mit Leerzeichen umgehen müssen, ist es normalerweise viel besser, Perl-Code in Ihr Programm einzufügen
makefile, um sich darum zu kümmern (mithilfe der „perl_begin“- oder „sub“-Anweisungen) oder damit umzugehen
in Shell-Anweisungen in den Aktionen von Regeln.

Diese Fälle treten typischerweise dann auf, wenn Menschen versuchen, dieselben Regeln für unterschiedliche Zwecke anzuwenden
Architekturen, die nicht die typische Unix-Befehlssyntax verwenden. ZB sieht man manchmal
Dinge wie diese in Makefiles:

ifeq ($(ARCH),weirdarch)
O := /OUTPUT=
sonst
null :=
O := -o $(null)
Endif

%.o : %.c
$(COMPILER) $(Eingabe) $(O)$(Ausgabe)

Sie können dies mit makepp tun, wenn Sie es wirklich möchten, aber Sie werden es wahrscheinlich finden
Makefiles sind wesentlich besser lesbar, wenn Sie weniger komplizierte Variablen haben
Substitution, z. B.

ifeq ($(ARCH),weirdarch)
%.o : %.c
$(WEIRD_COMPILER) $(Eingabe) /OUTPUT=$(Ausgabe)
sonst
%.o : %.c
$(CC) -c $(Eingabe) -o $(Ausgabe)
Endif

Leerzeichen sind in Variablennamen niemals zulässig, sondern nur in ihren Werten. Das ist anders
von einigen Make-Implementierungen.

automatische Variablen
Automatische Variablen sind Variablen, die je nach Regel unterschiedliche Werte annehmen
Sie werden in ausgewertet. Makepp unterstützt die meisten automatischen Variablen, die andere haben
Versionen von make verwenden. Darüber hinaus gibt es für die meisten von ihnen weniger kryptische, längere Namen
die Sie stattdessen verwenden können. (Für ältere Makefiles, die diese Namen zufällig neu definieren, gilt die
Die Definition im Makefile überschreibt die Standardbedeutung. Zum Beispiel, wenn Sie sagen
„target = abc“ in Ihrem Makefile, dann wird „$(target)“ immer zu „abc“ erweitert und nicht
nicht mehr äquivalent zu $@ sein.)

Im Folgenden finden Sie eine vollständige Liste aller automatischen Variablen, die makepp unterstützt:

Ausgabe
Ziel
$@ Das Ziel der aktuellen Regel. Tatsächlich unterstützt makepp mehrere Ziele für
Jede Regel, das ist die zuerst Ziel. Zum Beispiel in der folgenden Regel

y.tab.c y.tab.h : parser.y
$(YACC) -o $(Ausgabe) $(YFLAGS) $(Eingabe)

„$(output)“ enthält den Wert y.tab.c. Da diese magischen Variablen tatsächlich sind
Funktionen können Sie auch einen Index als Argument übergeben. Dies zählt von 1 oder rückwärts
von -1. „$(output 2)“ oder „$(output -1)“ enthält also den Wert y.tab.h.

Obwohl alle drei Formen dieser Variablen den gleichen Wert haben, gibt es einen Unterschied
Interpretation für Multitarget-Regeln. Wenn Sie den altmodischen kryptischen Namen $@ verwenden,
makepp interpretiert dies als einen Regelsatz alten Stils und nicht als einen modernen Regelsatz
erzeugt alle diese Ziele auf einmal:

ab: # eigentlich: je eine Regel für a und b
Berühre $@

cd: # Fehler: mpp beschwert sich, dass d nicht erstellt wurde
Berühre $(Ausgabe)

Ausgänge
Ziele
Alle Ziele der aktuellen Regel. Identisch mit „$(target)“, es sei denn, es gibt mehr als eines
Ziel. Im obigen Beispiel ist „$(outputs)“ y.tab.c y.tab.h. Sie können eine übergeben
Indexliste, also ist „$(outputs 2 1)“ y.tab.h y.tab.c.

Abhängigkeit
Eingabe
$< Die erste explizite Abhängigkeit der Regel. Zum Beispiel in dieser Regel

%.o : %.c
$(CC) $(CFLAGS) -c $(Eingabe) -o $(Ausgabe)

„$(input)“ ist der Name des .c Datei, egal was .h Dateien makepp
entdeckt. Wenn Sie mehr als eine Abhängigkeit angeben, können Sie diese durch Übergabe von an erhalten
index: „$(input $(INDEX))“ ist die INDEXth-Abhängigkeit.

Abhängigkeiten
Eingänge
$^ Alle expliziten Abhängigkeiten des Ziels, außer .h Dateien entdeckt von
makepp_scanning für Includes.

Beispielsweise in der Regel

myprog.o : *.o
$(CC) $(CFLAGS) $(Eingänge) -o $(Ausgabe)

„$(inputs)“ sind alle .o-Dateien im Verzeichnis. Sie können nur diejenigen auswählen, die Sie benötigen
wollen, indem Sie eine Indexliste übergeben. Wenn Sie explizit verschiedene Arten von Dateien angeben,
Sie können sie wie in „$(inputs 2 3 4)“ auswählen (mit einem Platzhalter ist dies jedoch nicht der Fall).
vielversprechend).

sortierte_Abhängigkeiten
sortierte_Eingaben
$+ Alle Abhängigkeiten des Ziels in sortierter Reihenfolge, wobei Duplikate entfernt wurden.
Entspricht „$(sort $(inputs))“.

geänderte_Abhängigkeiten
geänderte_Eingaben
$? Die Abhängigkeiten des Ziels, die sich geändert haben. Dies schließt nur explizit ein
Abhängigkeiten (also solche, die Sie im Makefile auflisten) werden nicht implizit entdeckt
Abhängigkeiten vom Scannen (z. B. .h-Dateien).

Dies wird häufig in Befehlen wie diesem verwendet:

libmine.a : $(MODULES) : build_checkignore_action
$(AR) ru $@ $?

dh, ar wird angewiesen, nur die Module zu ersetzen, die sich geändert haben. (Beachten Sie das
Build-Prüfregel „ignore_action“. Wenn Sie dies nicht angeben, erzwingt makepp dies
Aktion, die bei jeder Änderung ausgeführt werden soll. Wenn sich keine Abhängigkeiten geändert haben, wird die
Die Aktionszeichenfolge lautet „ar ru libmine.a“, was sich wahrscheinlich von dem unterscheidet, was sie war
Als Sie es das letzte Mal ausgeführt haben, wird Makepp es ohne „ignore_action“ ausführen. In diesem
In diesem Fall ist es harmlos, aber bei anderen Befehlen könnte es ein Problem sein. Sehen
makepp_build_check für Details zu „ignore_action“.)

Der Aufbau solcher Archive ist keine gute Idee, da Ihre Builds dadurch weniger werden
zuverlässig. Das Problem dabei ist, dass Sie eines davon entfernen, wenn Sie das Archiv erstellen
Wenn Sie die Module aus der Liste der MODULE entfernen, befinden sich die Module weiterhin im Archiv und
machenpp

eindämmen
$* Der Stamm in einer Musterregel (dh, was auch immer das „%“ übereinstimmt). Alternativ, wenn dies
ist keine Musterregel, gibt den Dateinamen ohne die Erweiterung zurück (d. h. es ist
äquivalent zu „$(basename $(input))“.

Dies dient hauptsächlich der Abwärtskompatibilität. Zum Beispiel in alten Versionen von make the
Die einzige Möglichkeit, ihm zu sagen, wie man welche kompiliert .c Datei in die entsprechende .o Datei war wie
Dies:

.co:
$(CC) $(CFLAGS) -c $*.c -o $*.o

Das ist eine miese Art, die Regel zu schreiben. Es ist viel klarer, den GNU-make-Stil zu verwenden
Musterregeln wie diese:

%.o : %.c
$(CC) $(CFLAGS) -c $(Eingabe) -o $(Ausgabe)

foreach
Der aktuelle Dateiname aus der „foreach“-Klausel. „foreach“-Klauseln werden selten verwendet,
Sie sind jedoch die allgemeinste Art von Musterregel, die makepp unterstützt. Für
Beispiel

#
# Erstellen Sie .c-Dateien mit einer Art speziellem Präprozessor:
#
%.c : %.k
$(Präprozessor) $(Eingabe) > $(Ausgabe)

#
# Kompilieren Sie .c-Dateien in .o-Dateien:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(Eingabe) -o $(Ausgabe)

#
# Spezielle alternative Kompilierungsflags für abgeleitete .c-Dateien
# aus .k-Dateien:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(Eingabe) -o $(Ausgabe)

Weitere Einzelheiten und Beispiele finden Sie in der Dokumentation zur foreach-Klausel in Regeln.

$/ Dies ist im Wesentlichen eine Konstante, entweder „/“ oder unter nativem Windows „\“. Sie brauchen es, wenn
Sie möchten ein Programm portabel starten, z. B. eines, das Sie im aktuellen Verzeichnis erstellt haben:

meineAusgabe:
.$/myprog >$(Ausgabe)

Für Dateinamen, die als Argumente übergeben werden, ist dies nicht unbedingt erforderlich, da Windows mit Unix umgehen kann
Syntax dort.

Option Variablen
Sie können diese auf alle oben erläuterten Arten (sofern nicht anders angegeben) modifizieren
das Verhalten von makepp. Standardmäßig sind sie alle undefiniert.

MAKEPP_DEBUG
Wenn Sie dies mit einem wahren Wert exportieren, bevor Sie makepp aufrufen, erhalten Sie mehr Debugging
die Info. Dies ist die „RULE_SOURCE“ der Dateien, die erstellt wurden, während dies in Kraft ist
makeppinfo, mppi und Details zur Variablenerweiterung und Regelanpassung unten
makepplog, mppl. Dies zeigt Ihnen auch an, ob makepp nicht mehr über genügend Speicher verfügt oder hängen bleibt.
weil es die gleichen Variablen endlos erweitert:

A = $A # verzögerte Auswertung, Bedarf :=
B = $C
C = $B

MAKEPP_LN_CP
Siehe den Hinweis unter &ln.

makepp_percent_subdirs
Setzen Sie dies auf einen echten Wert (z. B. 1), damit „%“ in Zielen oder Abhängigkeiten übereinstimmt
über mehr als ein Verzeichnis hinweg.

makepp_require_phony
Setzen Sie dies auf einen wahren Wert (z. B. 1), um implizite Fälschungen zu verhindern (z. B. wenn eine Regel
gelingt, ohne sein Ziel zu erreichen). Diese Variable sollte standardmäßig „true“ sein
Verhindern Sie unterbrochene Abhängigkeitsketten, aber das würde die Abwärtskompatibilität beeinträchtigen
schlampige Makefiles.

makepp_signature_C_flat
Dies ist eine Option für Signatur C. Setzen Sie dies auf einen echten Wert (z. B. 1), um Ihre zu behandeln
Quellen werden abgeflacht, d. h. alle Zeilenumbrüche (außer um Präprozessoranweisungen herum) sind abgeflacht
werden wie Leerzeichen behandelt und „#line“-Direktiven werden ignoriert.

makepp_simple_concatenation
Setzen Sie dies auf einen echten Wert (z. B. 1), um eine „RC-artige Ersetzung“ zu verhindern.

PERL
Sie können dies auf genau das Perl einstellen, das Sie zum Ausführen der Skripte im makepp verwenden
Suite herunterladen und exportieren. Dies kann hilfreich sein, um Unterskripte mit demselben Perl auszuführen. Das ist
vor allem nützlich für die Testsuite, die Installation und für rekursive Builds.

VPATH
Wenn Sie diese Variable auf einen Wert setzen, wird implizit „vpath % value“ aufgerufen.

Vordefiniert Variablen
Makepp definiert einige Variablen vor, die Sie überschreiben können:

AR Standard: „ar“.

ARFLAGS
Standard: „rv“.

AS Standard: "als".

CC Standard: Die ersten finden sich unter „gcc“, „egcc“, „pgcc“, „c89“ oder „cc“ oder unter Windows
zusätzlich „cl“ oder „bcc32“.

CFLAGS
Standard: Wenn „$(CC)“ ein GNU-Compiler ist, „-g -Wall“, wenn es sich um eines der beiden Windows handelt
Compiler nichts, sonst „-g“.

CURDIR
Das Verzeichnis, in dem sich das aktuelle Makefile befindet.

CXX Standard: Das erste, das unter „g++“, „c++“, „pg++“, „cxx“, „C“, „C“ oder „aCC“ oder weiter zu finden ist
Windows zusätzlich „cl“ oder „bcc32“.

CXXFLAGS
Standard: Wenn „$(CXX)“ ein GNU-Compiler ist, „-g -Wall“, wenn es sich um eines der beiden Windows handelt
Compiler nichts, sonst „-g“.

F77 Standard: Die ersten finden sich unter „f77“, „g77“ oder „fort77“.

FC Standard: „$(F77)“.

LD Standard: „ld“.

LEX Standard: Das erste, das unter „lex“ oder „flex“ zu finden ist.

LIBTOOL
Standard: „libtool“.

MACHEN
Diese Variable hat zwei verschiedene Werte, abhängig davon, ob sie vorhanden ist oder nicht
„--traditional-recursive-make“. Makepp erkennt, wann diese Variable verwendet wird und
schaltet einige Funktionen aus, noch bevor die Rekursion tatsächlich stattfindet. Das kann sein
unerwünscht, während Sie es nach und nach beseitigen, also wandeln Sie die Anrufe zunächst in a um
makepp-spezifisches „$((MAKE))“, wodurch Funktionen nicht deaktiviert werden. Sie sollten es nicht einstellen
weil das unsere intelligente Rekursionsumgehung zunichte macht.

MAKECMDGOALS
Diese Variable wird von makepp gesetzt, aber nicht verwendet. Sie können es nur abfragen, um etwas zu tun, wenn
ein bestimmtes Ziel wurde angefordert.

Standard: Was auch immer die expliziten Ziele des Benutzers (oder ein rekursiver Aufruf) sind.
Leer, wenn implizit ein Standardziel erstellt wird.

ifneq $(filter spezielles Ziel, $(MAKECMDGOALS))
# Spezialziel ist eines der aktuellen expliziten Ziele
sonst ifeq $(MAKECMDGOALS)
# keine expliziten Ziele
Endif

MAKEFLAGS (exportiert)
Die Standardoptionen, mit denen makepp aufgerufen wurde. Diejenigen, die einen einzelnen Buchstaben haben
form werden am Anfang ohne führendes „-“ kombiniert (der Himmel weiß, warum gmake das gewählt hat).
das „-“ weglassen).

MAKEINFO
Standard: „makeinfo“.

MAKEPPFLAGS (exportiert)
Dies wird auf denselben Wert wie MAKEFLAGS gesetzt, jedoch nur, wenn diese Variable in vorhanden ist
makepps Umgebung.

_MAKEPPFLAGS (exportiert)
Die für die POSIX/gmake-Kompatibilität erforderlichen makepp-spezifischen Optionen, mit denen makepp
hieß. Diese befinden sich in einer separaten Variablen, sodass ein Legacy-Makefile nicht beschädigt werden kann
Kompatibilität durch Deaktivieren von MAKEFLAGS. Dies wird nur mit eingestellt
„--traditional-recursive-make“.

MAKEPP_VERSION
Die Version von makepp, mit der Sie arbeiten. Wenn es sich um eine Beta-Version handelt, wird sie eine haben
Bindestrich gefolgt von JJMMTT und einigen weiteren internen Daten. Sie können dies für „ifdef“ verwenden.
um makepp-spezifische Konstrukte vor anderen Marken zu verbergen.

Standard: Derselbe Wert, der von „makepp --version“ angezeigt wird

PWD Ein Alias ​​für „CURDIR“.

RM Standard: „rm -f“. Dies ist für ältere Makefiles gedacht. Für neue vorzugsweise verwenden
den integrierten &rm-Befehl direkt. Wenn Sie eine falsche Clean-Regel schreiben möchten, schauen Sie sich an
stattdessen den Befehl „makeppclean -r“.

ROOT
Der relative Pfad zum Stammverzeichnis Ihres Build-Systems, also dem Verzeichnis weiter oben
wofür Sie ein „RootMakeppfile(.mk)“ haben. Wenn Sie keine haben, ist diese Variable
leer.

SHELL
Diese Variable wird nur berücksichtigt, wenn Sie sie „exportieren“. In diesem Fall ist es die Shell
die zum Ausführen nicht integrierter Aktionen mit einem Sonderzeichen (einfach) verwendet wird
diejenigen, die direkt ausgeführt werden). Unter Windows Strawberry oder ActiveState Perl, falls vorhanden
Wenn Sie eine Unix-ähnliche Shell verwenden, müssen Sie stattdessen Ihre SHELL-Variable auf einen Wert setzen, der mit „sh“ endet.
oder „sh.exe“ Bevor Aufruf von makepp.

Standard: Das erste gefunden unter „/usr/xpg4/bin/sh“ (z. B. Solaris) oder „/sbin/xpg4/sh“
(z. B. Reliant Unix) oder „/ Bin / sh".

YACC
Standard: Die ersten finden sich unter „bison -y“ oder „yacc“.

Variablen und Perl
Variablenwerte werden als gewöhnliche Perl-Skalare gespeichert, sodass Sie direkt darauf zugreifen können
Perl-Code, wenn Sie komplizierte Manipulationen damit durchführen müssen; siehe makepp_extending
für weitere Einzelheiten.

Der Zugriff auf globale Variablen von Perl aus wird durch das Präfix „Mpp::global“ erreicht.
Paket. Tatsächlich jede Variable, die im aktuellen Makefile noch nicht vorhanden ist und die Sie
„assign to“ in diesem Paket wird von da an global sein, als ob Sie gerade „das“ ausgegeben hätten
„globale“ Aussage dafür.

Dieser direkte Zugriff ist jedoch fehleranfällig! Möglicherweise hat der Benutzer diese Variablen überschrieben
über die Befehlszeile oder über die Umgebung. Zuvor wurde ein anderes Makefile geladen
Möglicherweise hat man die Variable global oder zielspezifisch gemacht. In diesen Fällen würden Sie das nicht tun
Ermitteln Sie den Wert der Variablen oder nehmen Sie bei der Zuweisung möglicherweise ihre Eigenschaft weg
(Entspricht einem „Override“-Modifikator, mit Ausnahme von Zielspezifikationen.)

Mit dem Direktzugriff umgehen Sie auch die Erweiterung dieser Variablen, sofern diese vom Typ sind
„=“ oder „;=“. Spezielle Variablen wie „$(CC)“ beginnen als Funktionen, bis sie es sind
Zugewiesen an. In vielen Fällen werden Sie ihren Wert daher nicht erkennen.

Aus diesen Gründen ist es besser, makepp den korrekten Wert ermitteln zu lassen. Du kannst den ... benutzen
„makeperl“-Variante, bei der die Variable ausgewertet wurde, bevor der Perl-Code abgerufen wird
interpretiert:

makeperl { $$current_value = '$(MAKEFILE_VAR)' }

Wenn Sie eine Variable in Makefile-Perl-Blöcken benötigen, wird dies über die Perl-Variable erreicht
$makefile wie folgt:

perl { $current_value = $makefile->expand_variable( 'MAKE_VAR' ) }

Funktionen erhalten immer das Makefile-Objekt, das als zweites Argument $_[1] übergeben wird:

sub f_f { $current_value = $_[1]->expand_variable( 'MAKE_VAR' ) }

Befehle sollen innerhalb einer Regelaktion dort aufgerufen werden, wo sich das Makefile-Objekt befindet
zugänglich über „$Mpp::Subs::rule->{MAKEFILE}“:

sub c_cmd { $current_value = $Mpp::Subs::rule->{MAKEFILE}->expand_variable( 'MAKE_VAR' ) }

Verwenden Sie makepp_variables online über die Dienste von onworks.net