RPM-MACROS(7)          Miscellaneous Information Manual          RPM-MACROS(7)

NUME
       rpm-macros - procesor macrocomenzi RPM

SINOPSIS
   Definirea
       %NUME CORP

       %NUME([OP<?>IUNI]) CORP

   Expandarea
       %NUME

       %NUME [OP<?>IUNI] [ARGUMENTE]

       %{NUME}

       %{NUME [OP<?>IUNI] ARGUMENTE}

       %{NUME:ARGUMENT}

       %{?NUME}

       %{?NUME:VALOARE-DACA-DEFINITA}

       %{!?NUME:VALOARE-DACA-NU_ ESTE-DEFINITA}

       %(COMANDA-SHELL)

       %[EXPRESIE]

       %[EXPRESIE ? VALOARE-DACA-ADEVARAT : VALOARE-DACA-FALS]

       %{lua:COD-LUA}

DESCRIERE
       RPM are un procesor de macrocomenzi incorporat puternic. Utilizarile
       principale ale macrocomenzilor sunt configurarea <?>i alte func<?>ii
       utilitare pentru RPM in sine, precum <?>i ca ajutor pentru impachetare
       in fi<?>ierele spec.

       Pe langa simpla substituire a textului, procesorul de macrocomenzi
       accepta urmatoarele func<?>ii:
       o   func<?>ie de tip MACROCOMENZI PARAMETRICE cu op<?>iuni <?>i
           procesare de argumente <?>i macrocomenzi definite de utilizator
           <?>i automate cu domeniu de aplicare local
       o   Expansiune shell
       o   Expansiune expresie
       o   Expansiune Lua pentru procesarea Lua incorporata
       o   diverse MACROCOMENZI INTEGRATE pentru procesarea <?>irurilor de
           caractere <?>i interac<?>iunea cu sistemul de operare

       Sintaxa pentru definirea macrocomenzilor simple este:

           NUME CORP

       Toate spa<?>iile albe din jurul CORPULUI sunt eliminate. NUME poate fi
       compus din caractere alfanumerice <?>i din caracterul de subliniere (_)
       <?>i trebuie sa aiba cel pu<?>in doua caractere. Corpul este (re)extins
       la fiecare invocare a macrocomenzii. Numele macrocomenzilor <?>i
       op<?>iunile sunt sensibile la majuscule <?>i minuscule.

       Consulta<?>i MACROCOMENZI PARAMETRICE pentru varianta mai avansata de
       macrocomenzi cu procesarea op<?>iunilor <?>i argumentelor.

       Macrocomenzile pot fi definite prin fi<?>iere rpm-macrofile(5) <?>i
       gestionate integral cu ajutorul macrocomenzilor primitive %define,
       %global <?>i %undefine, linia de comanda RPM descrisa in rpm-common(8)
       <?>i API (C, Python, Lua).

       Cu excep<?>ia celor definite in macrocomenzile parametrice,
       macrocomenzile au intotdeauna domeniu global.

       Macrocomenzile RPM sunt stivuite, adica atunci cand se redefine<?>te o
       macrocomanda deja existenta, aceasta acopera defini<?>ia anterioara in
       loc sa o inlocuiasca, iar anularea defini<?>iei unei macrocomenzi
       elimina doar defini<?>ia de sus, activand astfel defini<?>ia
       macrocomenzii anterioare.

       Re<?>ine<?>i ca acest manual descrie doar motorul procesorului de
       microcomenzi in sine. Intr-un sistem normal bazat pe RPM, exista un
       numar mare de alte microcomenzi definite prin fi<?>iere
       rpm-macrofile(5) care nu vor fi abordate aici.

EXPANDARE
       Pentru a extinde o macrocomanda, plasa<?>i % in fa<?>a acesteia. Sunt
       acceptate mai multe forme:

       %NUME
           Extinde macrocomanda NUME.

       %{NUME}
           Extinde macrocomanda NAME, permi<?>and plasarea langa alt text
           (similar cu ${ENV} in shell).

       %NUME [OP<?>IUNI] [ARGUMENTE]
           Extinde macrocomanda parametrica/incorporata NUME, utilizand
           op<?>iunile <?>i argumentele analizate pana la sfar<?>itul
           <?>irului sau pana la urmatorul caracter de linie noua.

           -- poate fi utilizat pentru a separa op<?>iunile de argumente.

       %{NUME [OP<?>IUNI] [ARGUMENTE]}
           Extinde macrocomanda parametrica/incorporata NUME, utilizand
           op<?>iunile <?>i argumentele analizate pana la inchiderea }.
           Permite utilizarea in vecinatatea altui text.

       %{NUME:ARGUMENT}
           Extinde macrocomanda parametrica/incorporata NUME, utilizand
           <?>irul de caractere dupa : ca argument unic. Permite utilizarea in
           vecinatatea altui text.

       Nota: Sintaxele pentru apelarea macrocomenzilor parametrice <?>i
       incorporate sunt in general interschimbabile in prezent, dar inainte de
       versiunea 4.18, sintaxa %{NUME:ARGUMENT} era exclusiva pentru
       macrocomenzile incorporate.

       Extinderea macrocomenzii poate fi evitata prin plasarea unui al doilea
       % in fa<?>a macrocomenzii, de exemplu %%{nume} ar fi extins la %{nume}.

       Incercarea de a extinde o macrocomanda nedefinita se extinde la
       invocarea literala, de exemplu %_undefined se extinde la %_undefined.
       Daca acest lucru nu este dorit, utiliza<?>i condi<?>ionale.

       Expansiunile macrocomenzii pot recurge pana la 64 de niveluri.

   Expansiune shell
       Extinderea shell-ului poate fi efectuata folosind %(comanda shell).
       comanda_shell este extinsa inainte de a fi executata cu /bin/sh, a
       carei ie<?>ire devine extinderea macrocomenzii. Caracterul de linie
       noua de la sfar<?>it este <?>ters.

       Exemplu:
           %(echo aa-bb-cc | tr '-' '.')

   Extindere condi<?>ionala
       Procesorul de macrocomenzi accepta testarea daca o macrocomanda este
       definita sau nu.

       %{?NUME:VALOARE}
           Se extinde la extinderea VALOARE daca NUME este definit, altfel la
           un <?>ir gol.

       %{!?NUME:VALOARE}
           Se extinde la extinderea VALoarE daca NUME nu este definit, altfel
           se extinde la un <?>ir gol.

       %{?NUME}
           Prescurtare pentru %{?NUME:%{NUME}}.

       Pentru teste mai complexe, utiliza<?>i Expansiune expresie sau
       Expansiune Lua. Re<?>ine<?>i ca %if, %ifarch <?>i altele similare nu
       sunt macrocomenzi, ci directive spec <?>i pot fi utilizate numai in
       acel context.

       Re<?>ine<?>i ca in RPM >= 4.17, condi<?>iile din macrocomenzile
       incorporate verifica pur <?>i simplu existen<?>a acelei macrocomenzi
       incorporate, la fel ca in cazul oricarei alte macrocomenzi. In
       versiunile mai vechi, comportamentul condi<?>iilor din macrocomenzile
       incorporate este nedefinit.

   Expansiune expresie
       Extinderea expresiei poate fi efectuata utilizand %[EXPRESIE]. O
       expresie este formata din termeni care pot fi combina<?>i utilizand
       operatori.

       RPM accepta trei tipuri de termeni:
       o   numere formate din cifre
       o   <?>iruri de caractere intre ghilimele duble (de exemplu, "vreun
           -<?>ir")
       o   versiuni intre ghilimele duble precedate de v (de exemplu,
           v"3:1.2-1")

       RPM va extinde macrocomenzile atunci cand evalueaza termenii.

       Pute<?>i utiliza operatorii standard pentru a combina termenii:
       o   operatori logici &&, ||, !
       o   operatori rela<?>ionali !=, ==, <, >, <=, >=
       o   operatori aritmetici +, -, /, *,
       o   operatorul ternar ? :
       o   paranteze

       De exemplu, %[ 3 + 4 * (1 + %two) ] se va extinde la 15 daca %two se
       extinde la 2. Termenii versiunii sunt compara<?>i folosind algoritmul
       de comparare a versiunii RPM ([epoch:]version[-release]), <?>i nu prin
       compararea obi<?>nuita a <?>irurilor de caractere.

       Re<?>ine<?>i ca expansiunea %[EXPRESIE] este diferita de macrocomanda
       %{expr:EXPRESIE}. In cazul celei din urma, macrocomenzile din expresie
       sunt mai intai expandate, iar apoi expresia este evaluata (fara a
       reexpanda termenii). Astfel

           rpm --define 'foo 1 + 2' --eval '%{expr:%foo}'

       va afi<?>a 3. Utilizarea %[%foo] va genera eroarea "1 + 2" nu este un
       numar.

       Efectuarea expansiunii macrocomenzii in timpul evaluarii termenilor are
       doua avantaje. In primul rand, permite RPM sa efectueze o procesare
       corecta a scurtcircuitelor in timpul evaluarii operatorilor logici. In
       al doilea rand, rezultatul expansiunii nu influen<?>eaza analizarea
       expresiei, de exemplu %[,,%file"] va func<?>iona chiar <?>i daca
       macrocomanda %file se extinde la un <?>ir care con<?>ine ghilimele
       duble.

       Adaugata: 4.16.0

   Expansiune Lua
       Cea mai puternica dintre metodele de expansiune a macrocomenzilor este
       utilizarea interpretului Lua incorporat in RPM:

       %{lua:COD-LUA}
           Executa<?>i LUA-CODE folosind interpretul Lua incorporat in RPM,
           extinzandu-l la codul print() <?>i afi<?>and rezultatul.

       Pentru detalii, consulta<?>i rpm-lua(7).

MACROCOMENZI PARAMETRICE
       Macrocomenzile parametrice sunt un mecanism puternic care permite
       crearea de macrocomenzi utilitare similare func<?>iilor, cu procesare
       op<?>ionala <?>i acceptarea unui numar variabil de argumente, similar
       instrumentelor shell obi<?>nuite.

       Sintaxa pentru definirea macrocomenzilor parametrice este:

           NUME([OP<?>IUNI]) CORP

       Daca sunt prezente, OP<?>IUNILE (adica <?>irul dintre paranteze) sunt
       transmise exact a<?>a cum sunt catre getopt(3) pentru procesarea
       argc/argv la inceputul invocarii macrocomenzii. Sunt acceptate numai
       op<?>iunile scurte.

       - ca singurul camp OP<?>IUNI dezactiveaza procesarea op<?>iunilor RPM.
       Acest lucru permite macrocomenzilor sa decida in totalitate modul de
       gestionare a intrarilor lor, de exemplu, daca argumentele macrocomenzii
       constau numai/in mare parte din elemente care incep cu -, procesarea
       implicita nu face decat sa incurce.

   Macrocomenzi automate
       In timpul extinderii unei macrocomenzi parametrizate, sunt disponibile
       urmatoarele macrocomenzi automate de tip shell:

       +-------------+--------------------------------------------------------+
       |Macrocomanda | Descriere                                              |
       +-------------+--------------------------------------------------------+
       |%0           | numele macrocomenzii care este invocata                |
       +-------------+--------------------------------------------------------+
       |%*           | toate argumentele (spre deosebire de shell, fara a     |
       |             | include niciun fanion procesat)                        |
       +-------------+--------------------------------------------------------+
       |%**          | toate argumentele (inclusiv orice fanioane procesate)  |
       +-------------+--------------------------------------------------------+
       |%#           | numarul de argumente                                   |
       +-------------+--------------------------------------------------------+
       |%{-f}        | daca este prezent la invocare, ultima apari<?>ie a     |
       |             | fanionului f (fanion <?>i argument)                    |
       +-------------+--------------------------------------------------------+
       |%{-f*}       | daca este prezent la invocare, argumentul pentru       |
       |             | ultima apari<?>ie a fanionului f                       |
       +-------------+--------------------------------------------------------+
       |%1, %2, ...  | argumentele in sine (dupa procesarea getopt(3))        |
       +-------------+--------------------------------------------------------+
       Daca procesarea op<?>iunilor incorporate a fost dezactivata cu - ca
       camp OP<?>IUNI , sunt disponibile numai urmatoarele macrocomenzi
       automate:

       +-------------+--------------------------------------------------------+
       |Macrocomanda | Descriere                                              |
       +-------------+--------------------------------------------------------+
       |%0           | numele macrocomenzii care este invocata                |
       +-------------+--------------------------------------------------------+
       |%*, %**      | toate argumentele                                      |
       +-------------+--------------------------------------------------------+
       |%#           | numarul de argumente                                   |
       +-------------+--------------------------------------------------------+
       |%1, %2, ...  | argumentele in sine                                    |
       +-------------+--------------------------------------------------------+
       Macrocomenzile automate sunt definite <?>i redefinite automat la
       intrarea <?>i ie<?>irea din macrocomanda parametrica.

   Accesarea op<?>iunilor
       In cadrul unei macrocomenzi parametrice, exista mai multe construc<?>ii
       care permit testarea prezen<?>ei parametrilor op<?>ionali. Cea mai
       simpla construc<?>ie este %{-f} care se extinde (literalmente) la -f
       daca -f a fost men<?>ionat atunci cand macrocomanda a fost invocata.
       Exista, de asemenea, prevederi pentru includerea textului daca era
       prezent un fanion folosind %{-f:X}. Aceasta macrocomanda se extinde la
       (extinderea lui) X daca fanionul era prezent. Forma negativa, %{!-f:Y},
       care se extinde la (extinderea lui)  Y daca -f nu era prezent, este de
       asemenea acceptata.

   Domeniul de aplicare <?>i vizibilitatea
       In general, macrocomenzile au o aplicabilitate globala, indiferent de
       locul <?>i modul in care au fost definite. Cu toate acestea,
       macrocomenzile definite in cadrul macrocomenzilor parametrice au o
       aplicabilitate non-globala, dupa cum urmeaza:
       o   macrocomenzile automate au domeniu de aplicare local, adica sunt
           vizibile numai la nivelul apelului macrocomenzii respective
       o   macrocomenzile locale definite de utilizator au un domeniu de
           aplicare imbricat, adica sunt vizibile la nivelul apelului
           macrocomenzii in sine <?>i la niveluri mai profunde.

       Adica, o macrocomanda parametrica nu poate vedea op<?>iunile sau
       argumentele altei macrocomenzi, dar o macrocomanda locala definita de
       utilizator intr-o macrocomanda de apel poate fi accesata in
       macrocomanda (macrocomenzile) apelata (apelate).

       Pentru a defini o macrocomanda globala in interiorul unei macrocomenzi
       parametrice, trebuie sa utiliza<?>i %global in loc de %define. De
       asemenea, re<?>ine<?>i ca, deoarece o astfel de macrocomanda poate face
       referire la alte macrocomenzi vizibile numai in domeniul curent,
       %global extinde corpul macrocomenzii o singura data in momentul
       definirii.

   Conven<?>ia de apelare
       Cand o macrocomanda parametrica este extinsa, se utilizeaza urmatoarea
       conven<?>ie de apelare:
       1.  orice argumente ale macrocomenzii sunt extinse la nivelul apelului
           destinatarului apelului
       2.  orice op<?>iuni pentru macrocomanda sunt procesate
       3.  macrocomenzile automate sunt configurate pentru op<?>iuni <?>i
           argumente
       4.  corpul macrocomenzii este extins recursiv
       5.  toate macrocomenzile definite la acest nivel de apel sunt eliminate

MACROCOMENZI INTEGRATE
       RPM accepta urmatoarele macrocomenzi incorporate pentru diverse
       opera<?>iuni. Macrocomenzile incorporate nu pot fi redefinite sau
       suprascrise.

       Nota: Stilul %{name:arg} este utilizat aici deoarece este cel mai
       compatibil cu versiunile anterioare <?>i nu necesita citarea
       spa<?>iilor albe, dar poate fi in general inlocuit <?>i cu alte forme
       de expansiune. Func<?>iile incorporate care accepta mai multe argumente
       trebuie sa utilizeze alte stiluri, dupa cum se indica mai jos.

   Manipularea macrocomenzilor
       Macrocomenzile primitive sunt utilizate pentru manipularea
       macrocomenzilor in fi<?>ierele spec <?>i in alte macrocomenzi.
       Re<?>ine<?>i ca toate acestea func<?>ioneaza pe numele macrocomenzii
       fara caracterul % precedent.

       %define NUME[([OP<?>IUNI])] CORP
           Acesta este modul principal de definire a macrocomenzilor. A
           %define este intotdeauna complet declarativ: nu are loc nicio
           expansiune a macrocomenzii <?>i nu are efecte secundare.
           Macrocomenzile definite cu acesta se afla in domeniul global, cu
           excep<?>ia cazului in care defini<?>ia apare in interiorul unei
           macrocomenzi parametrice.

           Exemplu:
               %define ruta-mea /usr/bin/mine

       %global NUME[([OP<?>IUNI])] CORP
           Primitiva %global are o sintaxa identica cu %define, dar prezinta
           doua diferen<?>e comportamentale extrem de importante: dupa cum
           sugereaza <?>i numele, o macro definita cu %global are intotdeauna
           un domeniu de aplicare global, indiferent de locul in care este
           utilizata.

           A doua diferen<?>a este ca CORPUL este extins o singura data in
           momentul definirii, iar extinderea devine corpul macrocomenzii
           propriu-zis. Astfel, atunci cand se utilizeaza %global, pot aparea
           execu<?>ii de cod arbitrar <?>i efecte secundare, in func<?>ie de
           con<?>inutul <?>i de celelalte macrocomenzi utilizate in CORP. Cea
           din urma poate fi utila pentru a evita extinderile macrocomenzii
           redundante <?>i posibil costisitoare daca valoarea nu se modifica,
           dar trebuie sa fi<?>i con<?>tien<?>i de efectele secundare.

           Re<?>ine<?>i ca, de<?>i %global accepta din punct de vedere tehnic
           un camp OP<?>IUNI, aceasta nu este potrivita pentru definirea
           macrocomenzilor parametrice din cauza comportamentului de
           expansiune al CORPULUI.

           Exemplu:
               %global snapver 0-0.48.20240616git

       %undefine NUME
           Re<?>ine<?>i ca %undefine doar scoate o defini<?>ie macro din
           stiva, astfel incat utilizarea sa nu garanteaza ca NAME este
           nedefinit dupa apelarea %undefine asupra acestuia. Macrocomenzile
           automate <?>i macrocomenzile incorporate nu pot fi nedefinite.

           Exemplu:
               %undefine ruta-mea

       %{load:FI<?>IER}
            Incarca un fi<?>ier rpm-macrofile(5). (Adaugata: 4.12.0)

           Exemplu:
               %{load:/vreun/dir/macros.foo}

   Extinderea macrocomenzii
       %{expand:CORP}
           Extinde CORPUL ca <?>i cum ar fi un corp al unei macrocomenzi. Util
           pentru o indirec<?>ie sporita, cum ar fi extinderea unui nume de
           macrocomanda construit din doua sau mai multe macrocomenzi.

           Exemplu:
               %{expand:%{foo_prefix}%{foo_suffix}}

       %{expr:EXPRESIE}
           Extinde EXPRESIA. Consulta<?>i Extinderea expresiei. (Adaugata in
           versiunea: 4.15.0)

           Exemplu:
               %{expr:5*1024}

       %{lua:COD-LUA}
           Extinde la ie<?>irea LUA-CODE folosind interpretul Lua incorporat.
           Consulta<?>i Extindere Lua.

           Exemplu:
               %{lua:for i=65,90 do print(<?>ir.char(i)) end}

       %{macrobody:NUME}
           Extinde la corpul literal al macrocomenzii NUME. (Adaugata in
           versiunea: 4.16.0)

           Exemplu:
               %{macrobody:_libdir}

   Opera<?>ii cu <?>iruri de caractere
       %dnl
           Ignora la linia urmatoare (fara a extinde nimic). %dnl este metoda
           recomandata pentru a comenta elementele din fi<?>ierele spec,
           deoarece func<?>ioneaza peste tot <?>i dezactiveaza procesarea
           macrocomenzii pentru linia respectiva. (Adaugata in versiunea:
           4.15.0)

           Exemplu:
               %dnl Acesta este un comentariu privind comportamentul %{mymacro}

       %{gsub <?>IR, MODEL, INLOCUIRE [,N]}
           Inlocuie<?>te toate apari<?>iile (sau primele N, daca sunt
           specificate) ale MODELULUI din <?>IR cu INLOCUIREA.

           Adaugata in versiunea: 4.19.0

           Exemplu:
               %{gsub aabbaacc aa dd 1}

       %{len:<?>IR}
           Extinde la lungimea <?>IRULUI. (Adaugata in versiunea: 4.19.0)

           Exemplu:
               %{len:9bf7da058a7c582878310e75be3d56a5a8b67f95}

       %{lower:<?>IR}
           Extinde la litere mici <?>IRUL. (Adaugata in versiunea: 4.19.0)

           Exemplu:
               %{lower:CamelCase}'

       %{quote:<?>ir}
           Citeaza argumentele pentru transmiterea <?>irurilor goale <?>i a
           <?>irurilor cu spa<?>ii albe incorporate ca argumente ale
           macrocomenzii parametrice. (Adaugata in versiunea: 4.14.0)

           Exemplu:
               %myzip -x %{quote:empty spaces.zip}

       %{rep <?>IR, N [,SEP]}
           Extinde la un <?>ir care este concatenarea a N copii ale <?>IR,
           separate prin SEP (daca este specificat).

           Adaugata in versiunea: 4.19.0

           Exemplu:
               %{rep a 5}

       %{reverse:<?>IR}
           Inverseaza un <?>ir. (Adaugata in versiunea: 4.19.0)

           Exemplu:
               %{reverse:tac}

       %{shescape:<?>IR}
           Citeaza simplu <?>IRUL cu caractere de eludare pentru utilizare in
           shell. (Adaugata in versiunea: 4.18.0)

           Exemplu:
               %{shescape:foo's}

       %{shrink:<?>IR}
           Elimina spa<?>iile albe din fa<?>a <?>i din spatele <?>IRULUI,
           reduce spa<?>iile albe intermediare la un singur spa<?>iu.
           (Adaugata in versiunea: 4.14.0)

           Exemplu:
               %{shrink:aa  bb   ccc   }

       %{span:<?>IR}
           <?>irul a<?>a cum este, util pentru incadrarea macrocomenzilor pe
           mai multe linii. (Adaugata in versiunea: 6.0.0)

           Exemplu:
               %{span:
                    %un lucru
                    %un alt lucru
               }

       %{sub <?>IR, I, [,J]}
           Extinde la sub<?>irul din <?>IR care incepe la I <?>i continua pana
           la J. I <?>i J pot fi negative pentru a indexa de la sfar<?>itul
           <?>irului. Daca J este absent, se presupune ca este egal cu -1
           (adica sfar<?>itul <?>irului).

           Adaugata in versiunea: 4.19.0

           Exemplu:
               *%{sub fi<?>ierul-meu.zip 3 6}*

       %{upper:<?>IR}
           Extinde la majuscule <?>IRUL. (Adaugata in versiunea: 4.19.0)

           Exemplu:
               %{upper:CamelCase}'

   Opera<?>ii cu fi<?>iere <?>i rute
       %{basename:RUTA}
           basename(1) macrocomanda analoaga.

           Exemplu:
               %{nume-bazae:/vreun/dir/fi<?>ier.suf}

       %{dirname:RUTA}
           dirname(1) macrocomanda analoaga.

           Exemplu:
               %{dirname:/vreun/dir/fi<?>ier.suf}

       %{exists:RUTA}
           Verifica existen<?>a fi<?>ierului, expandeaza la 1/0. (Adaugata in
           versiunea: 4.18.0)

           Exemplu:
               %{exists:%{builddir}/myflag.txt}

       %{suffix:RUTA}
           Expandeaza partea de sufix a unui nume de fi<?>ier.

           Exemplu:
               %{suffix:fi<?>ierul-meu.zip}

       %{url2path:URL}
           Converte<?>te adresa URL intr-o ruta locala.

           Exemplu:
               %{url2path:http://rpm.org/not/there}

       %{uncompress:RUTA}
           Extinde la o comanda pentru a afi<?>a argumentul RUTA la ie<?>irea
           standard, decomprimand dupa cum este necesar.

           Exemplu:
               %{uncompress /sursa/mea.tar.gz}

       %{xdg:TIP}
           Extinde la rutele directorului de baza XDG. Valorile acceptate
           pentru TIP sunt:
           o   cache: date neesen<?>iale specifice utilizatorului (stocate in
               cache)
           o   config: fi<?>iere de configurare specifice utilizatorului
           o   data: fi<?>iere de date specifice utilizatorului
           o   state: date de stare specifice utilizatorului

           Adaugata: 6.0.0

           Exemplu:
               %{xdg config}

   Informa<?>ii despre mediu
       %getncpus
           Extinde la numarul de CPU-uri disponibile. (Adaugata in versiunea:
           4.15.0)

       %{getncpus:TIP}
           Extinde la numarul de CPU-uri disponibile, valorile acceptate
           pentru TIP sunt
           o   total: numarul total de CPU-uri disponibile (la fel ca
               %getncpus)
           o   proc: numarul de CPU-uri disponibile pentru procese
           o   thread: numarul de CPU-uri disponibile pentru fire de
               execu<?>ie

           proc <?>i thread contabilizeaza memoria disponibila, inclusiv
           limitarile spa<?>iului de adrese pentru firele de execu<?>ie.

           Adaugata: 4.19.0.

           Exemplu:
               %{getncpus proc}

       %getconfdir
           Extinde la directorul ,,home" RPM (de obicei ,,/usr/lib/rpm").

       %{getenv:NUME}
           getenv(1) macrocomanda analoaga.

           Exemplu:
               %{getenv:HOME}

       %rpmversion
           Extinde la versiunea RPM in execu<?>ie.

   Ie<?>ire
       %{echo:<?>IR}
           Imprima <?>IRUL pentru a procesa ie<?>irea standard.

           Exemplu:
               %{echo:Construirea cu foo}

       %{warn:<?>IR}
           Imprima <?>IRUL precedat de ,,warning: " pentru a procesa ie<?>irea
           de eroare standard.

           Exemplu:
               %{warning:Foo este depreciat}

       %{error:<?>IR}
           Imprima <?>IRUL prefixat cu ,,error:" pentru a procesa eroarea
           standard <?>i a semnaliza o eroare in procesorul macrocomenzii.

           Exemplu:
               %{error:Argument nevalid}

       %verbose
           Expandeaza la 1/0 indiferent daca RPM este in modul descriptiv sau
           nu. (Adaugata in versiunea: 4.17.1)

       %{verbose:<?>IR}
           Extinde la <?>IR daca RPM este in modul descriptiv, <?>irul gol
           daca nu este. (Adaugata in versiunea: 4.17.1)

           Exemplu:
               %{verbose:-x}

   Macrocomenzi specifice spec
       %{S:NUMAR}
           Extinde la numele fi<?>ierului sursei specificate NUMAR. %{S:n}
           este echivalent cu %{SOURCEn}.

       %{P:NUMAR}
           Extinde la numele fi<?>ierului patch-ului specificat NUMAR. %{P:n}
           este echivalent cu %{PATCHn}.

   Diagnosticare
       %trace
           Comuta afi<?>area informa<?>iilor de depanare inainte/dupa
           extindere.

       %dump
           Imprima tabelul de macrocomenzi active (adica neacoperite).

       %__nume_fi<?>ier
           Extinde la numele fi<?>ierului curent (daca se analizeaza un
           fi<?>ier). (Adaugata in versiunea: 4.15)

       %__fi<?>ier_nr.linie
           Extinde<?>i la numarul liniei curente din fi<?>ierul curent (daca
           se analizeaza un fi<?>ier). (Adaugata in versiunea: 4.15)

EXEMPLE
   Exemplul 1. Defini<?>i o macrocomanda simpla
       Defini<?>i macrocomanda mylib ca o ruta relativa la macrocomanda
       %{_libdir} intr-un fi<?>ier spec:

           %define mylib %{_libdir}/mine

   Exemplul 2. Defini<?>i o macrocomanda parametrica
       Defini<?>i macrocomanda parametrica myhelper care executa programul
       specificat de %myprog cu primul argument al acestuia <?>i trecand
       intotdeauna op<?>iunea --some-opt catre acesta, precum <?>i op<?>iunea
       --xtra daca a primit op<?>iunea -x:

           %define myhelper(x) %{myprog} --vreo-op<?>iune %{?-x:--xtra} %{1}

   Exemplul 3. Defini<?>i o macrocomanda utilizand expansiunea shell-ului
       Defini<?>i macrocomanda %today care se extinde la data curenta in
       formatul AALLZZ apeland ustensila  shell date(1). Re<?>ine<?>i ca este
       necesara a doua macrocomanda % pentru a eluda argumentele catre
       date(1):

           %define today %(date +%%y%%m%%d)

   Exemplul 4. Defini<?>i o macrocomanda condi<?>ionala
       Defini<?>i macrocomanda mypath daca nu a fost definita anterior:

           %{!?mypath: %define mypath /vreun/loc}

   Exemplul 5. Expansiune conditionala
       Expandeaza la 1 daca use_foo este definit <?>i 0 in caz contrar:

           %{?use_foo:1}%{!?use_foo:0}

   Exemplul 6. Expresii
       Calculeaza 5 * 1024:

           %[5 * 1024]

       Extinde la literalul true sau false in func<?>ie de o condi<?>ie:

           %[1 < 2 ? "true" : "false"]

       Compara versiunile, extinzand la 1 sau 0 pentru true/false:

           %[ v"3.1.0-1" < v"1.0~alpha-2" ? 1 : 0]

       Expandeaza la 1 daca %aa se extinde la 5, altfel se extinde la 2:

           %[ "%{aa}" == "5" ? 1 : 2]

DEPANAREA
       Cateva instrumente utile pentru lucrul cu macrocomenzi <?>i depanarea
       acestora:

       rpm --eval "VALOARE"
           Extinde VALOAREA in linia de comanda.

       rpm --define "aa 11" --eval "%aa"
           Define<?>te <?>i evaueaza o macrocomanda in linia de comanda.

       rpm --eval "%global unamer %(uname -r)" --eval "%{macrobody:unamer}"
           Define<?>te <?>i examineaza corpul macrocomenzii folosind %global
           in linia de comanda.

       rpm --eval "%define unamer %(uname -r)" --eval "%{macrobody:unamer}"
           Define<?>te <?>i examineaza corpul macrocomenzii folosind %define
           in linia de comanda.

       rpmlua
           Ruleaza un shell interactiv in mediul Lua incorporat.

       rpmlua -e 'print(macros.defined("_libdir"))'
           Folosind interpretul Lua incorporat in forma autonoma, afi<?>eaza
           1/0 indiferent daca macrocomanda _libdir este definita sau nu.

       rpmspec --shell
           Ruleaza un shell interactiv in mediul macrocomenzii.

       rpmspec --shell telnet.spec
           Ruleaza un shell interactiv in mediul macrocomenzii dupa analizarea
           telnet.spec.

CONSULTA<?>I <?>I
       rpm(8) rpm-common(8) rpm-macrofile(5) rpm-config(5) rpm-lua(7)
       rpmspec(1) rpmlua(1)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

RPM 6.0.1                       8 ianuarie 2026                  RPM-MACROS(7)