RPM-MACROS(7) Miscellaneous Information Manual RPM-MACROS(7) BEZEICHNUNG rpm-macros - RPM-Makroprozessor UBERSICHT Definieren %NAME TEXTKORPER %NAME([OPTIONEN]) TEXTKORPER Expandieren %NAME %NAME [OPTIONEN] [ARGUMENTE] %{NAME} %{NAME [OPTIONEN] ARGUMENTE} %{NAME:ARGUMENT} %{?NAME} %{?NAME:WERT-FALLS-DEFINIERT} %{!?NAME:WERT-FALLS-NICHT-DEFINIERT} %(SHELL-BEFEHL) %[AUSDRUCK] %[AUSDRUCK ? WERT-FALLS-WAHR : WERT-FALLS-FALSCH] %{lua:LUA-CODE} BESCHREIBUNG RPM verfugt uber einen leistungsstarken integrierten Makroprozessor. Makros werden hauptsachlich fur die Konfiguration und andere Dienstprogrammfunktionen von RPM selbst sowie als Paketierungshilfe in Spec-Dateien verwendet. Neben der einfachen Textersetzung unterstutzt der Makroprozessor die folgenden Funktionen: o funktionsahnliche PARAMETRISCHE MAKROS mit Optionen und Argumentverarbeitung sowie lokal begrenzten automatischen und benutzerdefinierten Makros o Shell-Expansion o Ausdrucksexpansion o Lua-Expansion fur die eingebettete Lua-Verarbeitung o verschiedene EINGEBAUTE MAKROS fur die Verarbeitung von Zeichenketten und Interaktion mit dem Betriebssystem Die Syntax zum Definieren einfacher Makros lautet: NAME TEXTKORPER Jeglicher Leerraum um den TEXTKORPER wird entfernt. Der NAME kann aus alphanumerischen Zeichen und dem Unterstrich (_) bestehen und muss mindestens zwei Zeichen lang sein. Der Textkorper wird bei jedem Makroaufruf (erneut) expandiert. Bei Makronamen und -optionen wird die Gross- und Kleinschreibung beachtet. Siehe PARAMETRISCHE MAKROS fur die fortgeschrittene Makrovariante mit Options- und Argumentverarbeitung. Makros konnen uber rpm-macrofile(5)-Dateien definiert und vollstandig mit den Makroprimitiven %define, %global und %undefine, der RPM-Befehlszeile (beschrieben in rpm-common(8)) und der API (C, Python, Lua) verwaltet werden. Mit Ausnahme derjenigen, die in parametrischen Makros definiert sind, haben Makros immer einen globalen Gultigkeitsbereich. RPM-Makros werden gestapelt, das heisst, wenn ein bereits vorhandenes Makro neu definiert wird, wird die vorherige Definition lediglich uberdeckt, anstatt sie zu ersetzen. Beim Aufheben der Definition eines Makros wird nur die oberste Definition entfernt, wodurch die vorherige Makrodefinition wieder aktiviert wird. Beachten Sie, dass diese Handbuchseite nur die Makroprozessor-Engine selbst beschreibt. Auf einem normalen RPM-basierten System gibt es eine Vielzahl weiterer Makros, die uber rpm-macrofile(5)-Dateien definiert sind und hier nicht behandelt werden. EXPANSION Um ein Makro zu expandieren, stellen Sie ein % voran. Es werden mehrere Formen unterstutzt: %NAME Expandieren des Makros NAME. %{NAME} Expandieren des Makros NAME, wobei die Platzierung neben anderem Text erlaubt ist (ahnlich wie in ${ENV} in der Shell). %NAME [OPTIONEN] [ARGUMENTE] Expandieren des parametrischen/eingebauten Makros NAME, wobei Optionen und Argumente bis zum Ende der Zeichenkette oder dem nachsten Zeilenvorschub eingelesen werden. -- kann dazu verwendet werden, Optionen von Argumenten zu trennen. %{NAME [OPTIONEN] [ARGUMENTE]} Expandieren des parametrischen/eingebauten Makros NAME, wobei Optionen und Argumente bis zur schliessenden geschweiften Klammer } eingelesen werden. Dies ermoglicht die Verwendung neben anderem Text. %{NAME:ARGUMENT} Expandieren des parametrischen/eingebauten Makros NAME, wobei die Zeichenkette nach dem Doppelpunkt : als einziges Argument verwendet wird. Dies ermoglicht die Verwendung neben anderem Text. Hinweis: Die Syntax fur den Aufruf parametrischer und eingebauter Makros ist jetzt generell austauschbar, aber vor Version 4.18 war die Syntax %{NAME:ARGUMENT} auf eingebaute Makros beschrankt. Die Makroexpansion kann durch Platzieren eines zweiten % vor dem Makro vermieden werden. Beispielsweise wurde %%{name} zu %{name} expandiert. Der Versuch, ein undefiniertes Makro zu expandieren, fuhrt zum wortlichen Aufruf, z.B. wird %_undefined zu %_undefined. Wenn dies nicht erwunscht ist, verwenden Sie Bedingungen. Makro-Expansionen konnen bis zu 64 Ebenen rekursiv sein. Shell-Expansion Die Shell-Expansion kann mit %(Shell-Befehl) durchgefuhrt werden. Der Shell_Befehl wird expandiert, bevor er mit /bin/sh ausgefuhrt wird, dessen Ausgabe die Expansion des Makros darstellt. Der abschliessende Zeilenumbruch wird geloscht. Beispiel: %(echo aa-bb-cc | tr '-' '.') Bedingte Expansion Der Makroprozessor unterstutzt das Testen, ob ein Makro definiert ist oder nicht. %{?NAME:WERT} Wird auf die Expansion des WERTES expandiert, wenn der NAME definiert ist, anderenfalls auf eine leere Zeichenkette. %{!?NAME:WERT} Wird auf die Expansion des WERTES expandiert, wenn der NAME nicht definiert ist, anderenfalls auf eine leere Zeichenkette. %{?NAME} Kurzel fur %{?NAME:%{NAME}}. Fur komplexere Tests verwenden Sie die Expansion von Ausdrucken oder die Lua-Expansion. Beachten Sie, dass %if, %ifarch und ahnliche keine Makros, sondern Spec-Datei-Direktiven und nur in diesem Kontext verwendbar sind. Beachten Sie, dass in RPM >= 4.17 Bedingungen fur integrierte Makros lediglich die Existenz des integrierten Makros prufen, genau wie bei allen anderen Makros. In alteren Versionen ist das Verhalten von Bedingungen fur integrierte Makros undefiniert. Expansion von Ausdrucken Ausdrucke konnen in der Form %[AUSDRUCK] expandiert werden. Ein Ausdruck besteht aus Termen, die mittels Operatoren kombiniert werden konnen. RPM unterstutzt drei Arten von Termen: o Zahlen, bestehend aus Ziffern o in hochgestellte doppelte Anfuhrungszeichen eingeschlossene Zeichenketten (z.B. "Zeichenkette") o in hochgestellte doppelte Anfuhrungszeichen eingeschlossene Versionen, denen ein v vorangestellt ist (z.B. v"3:1.2-1") RPM expandiert Makros, wenn Terme ausgewertet werden. Sie konnen die Standard-Operatoren verwenden, um Terme zu verknupfen: o die logischen Operatoren &&, ||, ! o die relationalen Operatoren !=, ==, <, >, <=, >= o die arithmetischen Operatoren +, -, /, *, o den ternaren Operator ? : o Klammern Beispielsweise wird %[ 3 + 4 * (1 + %two) ] zu 15 expandiert, wenn %two zu 2 expandiert wird. Versionsterme werden mit dem RPM-Versionsvergleichsalgorithmus ([Epoche:]Version[-Veroffentlichung]) verglichen, nicht mit einem regularen Zeichenkettenvergleich. Beachten Sie, dass sich die Expansion der Form %[AUSDRUCK] vom Makro %{expr:AUSDRUCK} unterscheidet. Bei Letzterem werden zuerst die Makros im Ausdruck expandiert und dann der Ausdruck ausgewertet (ohne die Terme erneut zu expandieren). Somit wird rpm --define 'foo 1 + 2' --eval '%{expr:%foo}' 3 ausgeben. Wenn Sie stattdessen %[%bla] verwenden, wird eine Fehlermeldung ausgegeben, dass >>1 + 2<< keine Zahl ist. Die Makroexpansion bei der Auswertung der Terme durchzufuhren hat zwei Vorteile. Erstens ermoglicht sie RPM eine korrekte verkurzte Verarbeitung bei der Auswertung von logischen Operatoren. Zweitens beeinflusst das Expansionsergebnis nicht die Auswertung von Ausdrucken. Beispielsweise funktioniert %["%file"] selbst dann, wenn das Makro %file zu einer Zeichenkette mit doppelten englischen Anfuhrungszeichen expandiert wird. Hinzugefugt: 4.16.0 Lua-Expansion Die leistungsstarkste Methode zur Makroexpansion ist die Verwendung des in RPM eingebetteten Lua-Interpreters: %{lua:LUA-CODE} Fuhren Sie LUA-CODE mit dem eingebetteten Lua-Interpreter von RPM aus und expandieren Sie ihn zur print()-Ausgabe des Codes. Weitere Details finden Sie in rpm-lua(7). PARAMETRISCHE MAKROS Parametrische Makros sind ein leistungsstarker Mechanismus, der die Erstellung funktionsahnlicher Dienstprogramm-Makros mit Optionsverarbeitung und der Annahme einer variablen Anzahl von Argumenten ermoglicht, ahnlich wie bei gangigen Shell-Werkzeugen. Ein parametrisches Makro wird nach folgender Syntax definiert: NAME([OPTIONEN]) TEXTKORPER Falls vorhanden, werden die OPTIONEN (das heisst, die Zeichenkette in Klammern) genau so an getopt(3) zur argc/argv-Verarbeitung zu Beginn eines Makroaufrufs ubergeben. Es werden nur kurze Optionen unterstutzt. - als einziges OPTIONEN-Feld deaktiviert die Optionsverarbeitung von RPM. Dadurch konnen Makros vollstandig entscheiden, wie sie mit ihren Eingaben umgehen. Wenn zum Beispiel die Argumente des Makros ausschliesslich oder hauptsachlich aus Elementen bestehen, die mit - beginnen, ist die Standardverarbeitung nur hinderlich. Automatische Makros Wahrend ein parametrisiertes Makro expandiert wird, stehen die folgenden Shell-ahnlichen automatischen Makros zur Verfugung: +------------+---------------------------------------------------------+ |Makro | Beschreibung | +------------+---------------------------------------------------------+ |%0 | der Name des aufgerufenen Makros | +------------+---------------------------------------------------------+ |%* | alle Argumente (im Gegensatz zur Shell, ohne | | | verarbeitete Schalter) | +------------+---------------------------------------------------------+ |%** | alle Argumente (einschliesslich aller verarbeiteten | | | Schalter) | +------------+---------------------------------------------------------+ |%# | die Anzahl der Argumente | +------------+---------------------------------------------------------+ |%{-f} | falls beim Aufruf vorhanden, das letzte Vorkommen des | | | Schalters f (Schalter und Argument) | +------------+---------------------------------------------------------+ |%{-f*} | falls beim Aufruf vorhanden, das Argument fur das | | | letzte Vorkommen des Schalters f | +------------+---------------------------------------------------------+ |%1, %2, | die Argumente selbst (nach der Verarbeitung mit | | | getopt(3)) | +------------+---------------------------------------------------------+ Wenn die integrierte Optionsverarbeitung mit - als OPTIONEN-Feld deaktiviert wurde, sind nur die folgenden automatischen Makros verfugbar: +------------+---------------------------------------------------------+ |Makro | Beschreibung | +------------+---------------------------------------------------------+ |%0 | der Name des aufgerufenen Makros | +------------+---------------------------------------------------------+ |%*, %** | alle Argumente | +------------+---------------------------------------------------------+ |%# | die Anzahl der Argumente | +------------+---------------------------------------------------------+ |%1, %2, | die Argumente selbst | +------------+---------------------------------------------------------+ Automatische Makros werden beim Ein- und Ausstieg aus parametrischen Makros automatisch definiert und undefiniert. Zugriff auf Optionen Im Textkorper eines parametrischen Makros gibt es mehrere Konstrukte, die das Testen auf das Vorhandensein optionaler Parameter ermoglichen. Das einfachste Konstrukt ist %{-f}, das (wortlich) zu -f expandiert wird, wenn -f beim Aufruf des Makros ubergeben wurde. Es gibt auch Moglichkeiten, Text einzufugen, wenn ein Schalter vorhanden ist, indem %{-f:X} verwendet wird. Dieses Makro expandiert zu (der Expansion von) X, wenn der Schalter vorhanden war. Die negierte Form %{!-f:Y}, die zu (der Expansion von) Y expandiert, wenn -f nicht vorhanden war, wird ebenfalls unterstutzt. Bereich und Sichtbarkeit Im Allgemeinen haben Makros einen globalen Gultigkeitsbereich, unabhangig davon, wo und wie sie definiert wurden. Makros, die innerhalb parametrischer Makros definiert sind, haben jedoch einen nicht-globalen Gultigkeitsbereich, und zwar wie folgt: o Automatische Makros haben einen lokalen Gultigkeitsbereich, das heisst, sie sind nur auf der Aufrufebene des Makros selbst sichtbar. o Benutzerdefinierte lokale Makros haben einen verschachtelten Gultigkeitsbereich, das heisst, sie sind auf der Aufrufebene des Makros selbst und tiefer sichtbar. Das heisst, ein parametrisches Makro kann die Optionen oder Argumente eines anderen nicht sehen, aber auf ein benutzerdefiniertes lokales Makro in einem aufrufenden Makro kann in den aufgerufenen Makros zugegriffen werden. Um ein globales Makro innerhalb eines parametrischen Makros zu definieren, mussen Sie %global anstelle von %define verwenden. Beachten Sie ausserdem, dass %global den Makrokorper zum Zeitpunkt der Definition einmal expandiert, da ein solches Makro moglicherweise auf andere Makros verweist, die nur im aktuellen Bereich sichtbar sind. Aufrufkonvention Beim Expandieren eines parametrischen Makros wird die folgende Aufrufkonvention verwendet: 1. alle Argumente des Makros werden auf der Aufrufebene des Aufrufenden expandiert 2. alle Optionen des Makros werden verarbeitet 3. automatische Makros werden fur die Optionen und die Argumente eingerichtet 4. der Makrokorper wird rekursiv expandiert 5. alle auf dieser Aufrufebene definierten Makros werden verworfen EINGEBAUTE MAKROS RPM verfugt uber die in der nachfolgenden Liste aufgefuhrten eingebauten Makros fur verschiedene Aktionen. Eingebaute Makros konnen nicht undefiniert oder ausser Kraft gesetzt werden. Hinweis: Der Stil %{Name:Argument} wird hier verwendet, da er am abwartskompatibelsten ist und keine Anfuhrungszeichen fur Leerraum erfordert. Er kann aber grundsatzlich auch durch die anderen Expandierungsformen ersetzt werden. Integrierte Funktionen mit mehreren Argumenten mussen andere Stile verwenden, wie nachfolgend angegeben. Manipulation von Makros Die Makroprimitive werden zur Makromanipulation in Spec-Dateien und anderen Makros verwendet. Beachten Sie, dass alle diese auf dem Makronamen ohne das vorangehende %-Zeichen arbeiten. %define NAME[([OPTIONEN])] TEXTKORPER Dies ist die primare Methode zum Definieren von Makros. Ein %define ist immer vollstandig deklarativ: Es findet keine Makroexpansion statt und es gibt keine Nebeneffekte. Damit definierte Makros haben einen globalen Gultigkeitsbereich, es sei denn, die Definition erfolgt innerhalb eines parametrischen Makros. Beispiel: %define meinpfad /usr/bin/mein %global NAME[([OPTIONEN])] TEXTKORPER Das Primitiv %global ist in der Syntax zu %define identisch, verhalt sich jedoch in zweierlei Hinsicht signifikant anders: Wie der Name schon andeutet, hat ein mit %global definiertes Makro immer einen globalen Gultigkeitsbereich, unabhangig davon, wo es verwendet wird. Der zweite Unterschied besteht darin, dass der TEXTKORPER bei der Definition einmalig expandiert wird und die Expansion zum eigentlichen Makrokorper wird. Daher kann es bei Verwendung von %global je nach Inhalt und den anderen im TEXTKORPER verwendeten Makros zu beliebiger Codeausfuhrung und Nebeneffekten kommen. Dass die Expansion zum eigentlichen Makrokorper wird, kann praktisch sein, um, falls sich der Wert nicht andert, redundante, moglicherweise aufwandige Makroexpansionen zu vermeiden. Beachten Sie jedoch die Nebeneffekte. Beachten Sie, dass %global zwar technisch gesehen ein OPTIONEN-Feld akzeptiert, es jedoch aufgrund des TEXTKORPER-Expansionsverhaltens nicht fur die Definition parametrischer Makros geeignet ist. Beispiel: %global snapver 0-0.48.20240616git %undefine NAME Beachten Sie, dass %undefine nur eine Makrodefinition aus dem Stapel entfernt. Daher garantiert die Verwendung nicht, dass der NAME nach dem Aufruf von %undefine undefiniert ist. Automatische Makros und eingebaute Makros konnen nicht undefiniert werden. Beispiel: %undefine mein_Pfad %{load:DATEI} Eine Makrodatei laden. (siehe rpm-macrofile(5); hinzugefugt: 4.12.0) Beispiel: %{load:/irgendein/verzeichnis/makros.foo} Makro-Expansion %{expand:TEXTKORPER} Expandiert den angegebenen TEXTKORPER, als ware er ein Makrotext. Nutzlich fur erweiterte Indirektion, zum Beispiel um einen Makronamen zu expandieren, der aus zwei oder mehr Makros besteht. Beispiel: %{expand:%{foo_prafix}%{foo_suffix}} %{expr:AUSDRUCK} Expandiert den angegebenen AUSDRUCK. Siehe Expansion von Ausdrucken. (Hinzugefugt: 4.15.0) Beispiel: %{expr:5*1024} %{lua:LUA-CODE} Expandiert die Ausgabe von LUA-CODE mithilfe des eingebetteten Lua-Interpreters. Siehe Lua-Expansion. Beispiel: %{lua:for i=65,90 do print(string.char(i)) end} %{macrobody:NAME} Expandiert zum unveranderten Textkorper des Makros NAME. (Hinzugefugt: 4.16.0) Beispiel: %{macrobody:_libdir} Zeichenkettenaktionen %dnl Verwirft und zur wechselt zur nachsten Zeile (ohne etwas zu expandieren). %dnl ist die empfohlene Methode zum Auskommentieren von Elementen in Spec-Dateien, da sie uberall funktioniert und die Makroverarbeitung fur diese Zeile deaktiviert. (Hinzugefugt: 4.15.0) Beispiel: %dnl Dies ist ein Kommentar zum Verhalten von %{mymacro} %{gsub ZEICHENKETTE, MUSTER, ERSETZUNG [,N]} Ersetzt alle (oder die N ersten, falls angegeben) Vorkommen des angegebenen MUSTERS in der ZEICHENKETTE durch die ERSETZUNG. Hinzugefugt: 4.19.0 Beispiel: %{gsub aabbaacc aa dd 1} %{len:ZEICHENKETTE} Expandiert auf die Lange der ZEICHENKETTE. (Hinzugefugt: 4.19.0) Beispiel: %{len:9bf7da058a7c582878310e75be3d56a5a8b67f95} %{lower:ZEICHENKETTE} Expandiert zur ZEICHENKETTE in Kleinschreibung. (Hinzugefugt: 4.19.0) Beispiel: %{lower:CamelCase}' %{quote:ZEICHENKETTE} Maskiert Argumente in englischen hochgestellten Anfuhrungszeichen fur die Ubergabe von leeren Zeichenketten und Zeichenketten mit eingebettetem Leerraum als Argumente fur parametrische Makros. (Hinzugefugt: 4.14.0) Beispiel: %myzip -x %{quote:empty spaces.zip} %{rep ZEICHENKETTE, N [,TRENNER]} Expandiert zu einer Zeichenkette, die die Verkettung von N Kopien der angegebenen ZEICHENKETTE ist, getrennt durch einen TRENNER (falls angegeben). Hinzugefugt: 4.19.0 Beispiel: %{rep a 5} %{reverse:ZEICHENKETTE} Kehrt eine Zeichenkette um. (Hinzugefugt: 4.19.0) Beispiel: %{reverse:tac} %{shescape:ZEICHENKETTE} ZEICHENKETTE in einfachen hochgestellten englischen Anfuhrungszeichen mit Maskierungszeichen zur Verwendung in der Shell. (Hinzugefugt: 4.18.0) Beispiel: %{shescape:foo's} %{shrink:ZEICHENKETTE} Entfernt fuhrenden und angehangten Leerraum von der ZEICHENKETTE und reduziert dazwischenliegenden Leerraum auf ein einzelnes Leerzeichen. (Hinzugefugt: 4.14.0) Beispiel: %{shrink:aa bb ccc } %{span:ZEICHENKETTE} Unveranderte Zeichenkette, praktisch zum Umschliessen mehrzeiliger Makros. (Hinzugefugt: 6.0.0) Beispiel: %{span: %one thing %another thing } %{sub ZEICHENKETTE, I, [,J]} Expandiert zu einer Teilzeichenkette der ZEICHENKETTE, die bei I beginnt und bis J fortgesetzt wird. I und J konnen negativ sein, um vom Ende der Zeichenkette aus zu indizieren. Fehlt J, wird angenommen, dass es gleich -1 ist (d.h. das Ende der Zeichenkette). Hinzugefugt: 4.19.0 Beispiel: *%{sub meinedatei.zip 3 6}* %{upper:ZEICHENKETTE} Expandiert zur ZEICHENKETTE in Grossschreibung. (Hinzugefugt: 4.19.0) Beispiel: %{upper:CamelCase}' Datei- und Pfadaktionen %{basename:PFAD} Makro analog zu basename(1). Beispiel: %{basename:/ein/verzeichnis/datei.endung} %{dirname:PFAD} Makro analog zu dirname(1). Beispiel: %{dirname:/ein/verzeichnis/datei.endung} %{exists:PFAD} Testet das Vorhandensein einer Datei; expandiert zu 1/0. (Hinzugefugt: 4.18.0) Beispiel: %{exists:%{builddir}/meinschalter.txt} %{suffix:PFAD} Expandiert zum Endungs-Teil eines Dateinamens. Beispiel: %{suffix:meinedatei.zip} %{url2path:URL} Wandelt eine URL in einen lokalen Pfad um. Beispiel: %{url2path:http://rpm.org/nicht/dort} %{uncompress:PFAD} Expandiert zu einem Befehl zur Ausgabe des Arguments PFAD in die Standardausgabe, wobei dekomprimiert wird, falls erforderlich. Beispiel: %{uncompress /meine/quelldatei.tar.gz} %{xdg:ART} Expandiert zu den Basisverzeichnispfaden des XDG-Standards. Folgende Werte werden fur ART unterstutzt: o cache: benutzerspezifische nicht wesentliche (zwischengespeicherte) Daten o config: benutzerspezifische Konfigurationsdateien o data: benutzerspezifische Datendateien o state: benutzerspezifische Statusdateien Hinzugefugt: 6.0.0 Beispiel: %{xdg config} Infos zur Umgebung %getncpus Expandiert zu der Anzahl der verfugbaren CPUs. (Hinzugefugt: 4.15.0) %{getncpus:ART} Expandiert zu der Anzahl der verfugbaren CPUs. Fur ART werden folgende Werte unterstutzt: o total: Gesamtanzahl der verfugbaren CPUs (gleichbedeutend mit %getncpus) o proc: Anzahl der fur Prozesse verfugbaren CPUs o thread: Anzahl der fur Threads verfugbaren CPUs proc und thread berucksichtigen den verfugbaren Speicher, einschliesslich Adressraumbeschrankungen fur Threads. Hinzugefugt: 4.19.0. Beispiel: %{getncpus proc} %getconfdir Expandiert zum >>Home<<-Verzeichnis von RPM (typischerweise /usr/lib/rpm). %{getenv:NAME} Makro analog zu getenv(3). Beispiel: %{getenv:HOME} %rpmversion Wird zu der laufenden RPM-Version expandiert. Ausgabe %{echo:ZEICHENKETTE} Schreibt die ZEICHENKETTE in die Standardausgabe des Prozesses. Beispiel: %{echo:Building with foo} %{warn:ZEICHENKETTE} Schreibt die ZEICHENKETTE in die Standardfehlerausgabe des Prozesses und stellt >>warning: << voran. Beispiel: %{warning:Foo is deprecated} %{error:ZEICHENKETTE} Schreibt die ZEICHENKETTE in die Standardfehlerausgabe des Prozesses und stellt >>error: << voran und lost einen Fehler im Makroprozessor aus. Beispiel: %{error:Invalid argument} %verbose Expandiert zu 1/0, je nachdem, ob RPM im ausfuhrlichen Modus ausgefuhrt wird oder nicht. (Hinzugefugt: 4.17.1) %{verbose:ZEICHENKETTE} Expandiert zur ZEICHENKETTE, falls RPM im ausfuhrlichen Modus ausgefuhrt wird, und gibt eine leere Zeichenkette aus, falls nicht. (Hinzugefugt: 4.17.1) Beispiel: %{verbose:-x} Spec-spezifische Makros %{S:NUMMER} Expandiert zum Dateinamen der angegebenen Quelle (>>Source*<<) NUMMER. %{S:n} ist gleichbedeutend mit %{SOURCEn}. %{P:NUMMER} Expandiert zum Dateinamen des angegebenen Patches (>>Patch*<<) NUMMER. %{P:n} ist gleichbedeutend mit %{PATCHn}. Diagnostik %trace Schaltet die Ausgabe von Debugging-Informationen vor bzw. nach der Expansion um. %dump Gibt die aktive (das heisst, nicht uberdeckte) Makrotabelle aus. %__file_name Wird zum aktuellen Dateinamen expandiert (falls eine Datei ausgewertet wird). (Hinzugefugt: 4.15) %__file_lineno Wird zur aktuellen Zeilennummer in der aktuellen Datei expandiert (falls eine Datei ausgewertet wird). Hinzugefugt: 4.15. BEISPIELE Beispiel 1: Definieren eines einfachen Makros Das Makro mylib in einer Spec-Datei auf einen Pfad relativ zum %{_libdir}-Makro setzen: %define mylib %{_libdir}/mein Beispiel 2: Ein parametrisches Makro definieren Das parametrische Makro myhelper definieren, das das durch %myprog angegebene Programm mit seinem ersten Argument ausfuhrt und ihm immer die Option --some-opt ubergibt, sowie zusatzlich die Option --xtra, wenn es selbst die Option -x erhalten hat: %define myhelper(x) %{myprog} --some-opt %{?-x:--xtra} %{1} Beispiel 3: Ein Makro mittels Shell-Expansion definieren Definieren des Makros %today, das mithilfe des Shell-Dienstprogramms date(1) zum aktuellen Datum im Format JJMMTT expandiert. Beachten Sie das zweite %, das zum Maskieren der Argumente fur date(1) benotigt wird: %define today %(date +%%y%%m%%d) Beispiel 4: Ein bedingtes Makro definieren Das Makro mypath definieren, sofern es nicht bereits zuvor definiert wurde: %{!?mypath: %define mypath /ir/gend/wo} Beispiel 5: Bedingte Expansion Expandiert zu 1, falls use_foo definiert ist, anderenfalls zu 0: %{?use_foo:1}%{!?use_foo:0} Beispiel 6 - Ausdrucke 5 * 1024 berechnen: %[5 * 1024] Zu wortlichem true oder false expandieren, abhangig von einer Bedingung: %[1 < 2 ? "true" : "false"] Versionen vergleichen; zu 1 (wahr) oder 0 (falsch) expandieren: %[ v"3.1.0-1" < v"1.0~alpha-2" ? 1 : 0] Zu 1 expandieren, falls %aa zu 5 expandiert, anderenfalls zu 2 expandieren: %[ "%{aa}" == "5" ? 1 : 2] DEBUGGING Einige nutzliche Werkzeuge zum Arbeiten mit Makros und zur Fehlerbehebung: rpm --eval "WERT" Expandiert den angegebenen WERT in der Befehlszeile. rpm --define "aa 11" --eval "%aa" Definiert und berechnet ein Makro in der Befehlszeile. rpm --eval "%global unamer %(uname -r)" --eval "%{macrobody:unamer}" Definiert und untersucht den Makro-Textkorper mit %global in der Befehlszeile. rpm --eval "%define unamer %(uname -r)" --eval "%{macrobody:unamer}" Definiert und untersucht den Makro-Textkorper mit %define in der Befehlszeile. rpmlua Fuhrt eine interaktive Shell in der eingebetteten Lua-Umgebung aus. rpmlua -e 'print(macros.defined("_libdir"))' Mit dem eingebetteten eigenstandigen Lua-Interpreter wird >>1/0<< ausgegeben, abhangig davon, ob das Makro _libdir definiert ist oder nicht. rpmspec --shell Eine interaktive Shell in der Makro-Umgebung ausfuhren. rpmspec --shell telnet.spec Nach dem Auswerten von telnet.spec eine interaktive Shell in der Makroumgebung ausfuhren. SIEHE AUCH rpm(8), rpm-common(8), rpm-macrofile(5), rpm-config(5), rpm-lua(7), rpmspec(1), rpmlua(1) UBERSETZUNG Die deutsche Ubersetzung dieser Handbuchseite wurde von Mario Blattermann erstellt. Diese Ubersetzung ist Freie Dokumentation; lesen Sie die GNU General Public License Version 3 oder neuer bezuglich der Copyright-Bedingungen. Es wird KEINE HAFTUNG ubernommen. Wenn Sie Fehler in der Ubersetzung dieser Handbuchseite finden, schicken Sie bitte eine E-Mail an die Mailingliste der Ubersetzer: . RPM 6.0.1 8. Januar 2026 RPM-MACROS(7)