gpp - Online in de cloud

PROGRAMMA:

NAAM

GPP - Generieke preprocessor

KORTE INHOUD

gpp [-{o|O} uitbestand] [-L/include/pad] [-NSnaam=val ​
[-z|+z] [-x] [-m] [-C|-T|-H|-X|-P|-U ... [-M ...]]
[-n|+n] [+c str1 str2] [+s str1 str2 c]
[-C str1] [--nostdinc] [--nocurinc]
[--curdirinclast] [--waarschuwingsniveau n]
[--inclusief markering str] [--erbij betrekken filet]
[in bestand]

gp --help

gpp --versie

PRODUCTBESCHRIJVING

GPP is een preprocessor voor algemeen gebruik met aanpasbare syntaxis, geschikt voor een breed scala
van voorbewerkingstaken. De onafhankelijkheid van elke programmeertaal maakt het veel meer
veelzijdiger dan cpp, terwijl de syntaxis lichter en flexibeler is dan die van m4.

GPP is gericht op alle gangbare voorbewerkingstaken waarbij cpp niet geschikt is en waar nee
Er zijn zeer geavanceerde functies nodig. Om even efficiënt te kunnen verwerken
tekstbestanden of broncode in verschillende talen, de syntaxis die door GPP wordt gebruikt, is volledig
aanpasbaar. Vooral de verwerking van opmerkingen en tekenreeksen is geavanceerd.

In eerste instantie begrijpt GPP slechts een minimale set ingebouwde macro's, de zogenaamde meta-macro's.
Deze meta-macro's maken de definitie mogelijk van gebruiker macro's evenals enkele basisbewerkingen
vormt de kern van het voorverwerkingssysteem, inclusief voorwaardelijke tests en rekenkunde
evaluatie, jokertekenmatching (globbing) en syntaxisspecificatie. Alle gebruikersmacro's
definities zijn mondiaal -- dat wil zeggen, ze blijven geldig totdat ze expliciet worden verwijderd; meta-macro's
kan niet opnieuw worden gedefinieerd. Bij elke gebruikersmacrodefinitie houdt GPP de overeenkomstige bij
syntaxisspecificatie zodat een macro veilig kan worden aangeroepen, ongeacht eventuele daaropvolgende macro's
verandering in bedrijfsmodus.

Naast macro's begrijpt GPP ook opmerkingen en tekenreeksen, waarvan de syntaxis en het gedrag dat wel kunnen
op grote schaal worden aangepast om aan een bepaald doel te voldoen. Intern zijn opmerkingen en tekenreeksen
dezelfde constructie, dus alles wat voor commentaar geldt, geldt ook voor strings.

OPTIES

GPP herkent de volgende opdrachtregelopties en opties. Merk op dat de -nostdinc,
-nocurinc, -curdirinclast, -warninglevel en -includemarker opties uit versie 2.1 en
eerder zijn verouderd en mogen niet worden gebruikt. Gebruik in plaats daarvan de varianten met de "lange optie".
(--nostdinc, enz.).

-h --help
Druk een kort hulpbericht af.

--versie
Informatie over de afdrukversie.

-o uitbestand
Geef een bestand op waarnaar alle uitvoer moet worden verzonden (standaard wordt alles verzonden
naar standaarduitvoer).

-O uitbestand
Geef een bestand op waarnaar alle uitvoer moet worden verzonden; uitvoer wordt tegelijkertijd verzonden
stevig.

-I/include/pad
Geef een pad op waar de #include meta-macro zal zoeken naar include-bestanden als ze
zijn niet aanwezig in de huidige map. De standaardwaarde is / Usr / include zo nee - ik
optie is opgegeven. Er kunnen meerdere -I-opties worden opgegeven om in meerdere te kijken
directories.

-Dnaam=val
Definieer de gebruikersmacro naam gelijk aan golf. Dit is strikt hetzelfde als gebruiken
the #define meta-macro, maar maakt het mogelijk om macro's te definiëren vanuit de opdracht-
lijn. Als golf verwijst naar argumenten of andere macro's waaraan het moet voldoen
de syntaxis van de modus die op de opdrachtregel is opgegeven. Vanaf versie 2.1,
Het benoemen van macroargumenten is toegestaan ​​op de opdrachtregel. De syntaxis is als volgt:
-Dmacro(arg1,...)=definitie. De argumenten worden gespecificeerd in de syntaxis van C-stijl,
zonder enige witruimte, maar de definitie moet nog steeds voldoen aan de syntaxis van
de modus die op de opdrachtregel is opgegeven.

+z Stel de tekstmodus in op Unix-modus (LF-terminator). Elk CR-teken in de invoer is
systematisch weggegooid. Dit is de standaard onder Unix-systemen.

-z Stel de tekstmodus in op de DOS-modus (CR-LF-terminator). In deze modus zijn alle CR-tekens beschikbaar
verwijderd uit de invoer en alle uitvoer-LF-tekens worden geconverteerd naar CR-LF. Dit
is de standaardwaarde als GPP wordt gecompileerd met de WIN_NT-optie.

-x Schakel het gebruik van de #exec meta-macro. Sinds #exec omvat de uitvoer van een
willekeurige shell-opdrachtregel, kan dit een potentiële bedreiging voor de veiligheid veroorzaken, en dat is dan ook het geval
uitgeschakeld, tenzij deze optie is opgegeven.

-m Schakel automatische modusoverschakeling naar de cpp-compatibiliteitsmodus in als de naam van een
het opgenomen bestand eindigt op `.h' of `.c'. Dit maakt het mogelijk om een ​​C-header op te nemen
bestanden met slechts kleine wijzigingen.

-n Voorkom dat nieuweregel- of witruimtetekens uit de invoer worden verwijderd wanneer
ze komen voor als het einde van een macro-oproep of van een opmerking. Standaard is dit het geval wanneer een newline
of een witruimteteken vormt het einde van een macro of een opmerking en wordt als onderdeel ervan geparseerd
van de macro-oproep of opmerking en daarom verwijderd uit de uitvoer. Gebruik de optie -n
om het laatste teken in de invoerstroom te behouden als het witruimte of een nieuwe regel is.
Dit wordt geactiveerd in de cpp- en Prolog-modi.

+n Het tegenovergestelde van -n. Dit is de standaard in alle modi behalve cpp en Prolog. Opmerking
dat +n geplaatst moet worden na -C of -P om enig effect te hebben.

-U arg1 ... arg9
Door de gebruiker gedefinieerde modus. Er wordt aangenomen dat de negen volgende opdrachtregelargumenten zijn
respectievelijk de macro-startsequentie, de macro-eindsequentie voor een oproep zonder
argumenten, de startvolgorde van het argument, het argumentscheidingsteken, het argumenteinde
reeks, de lijst met tekens die moeten worden gestapeld voor argumentbalancering, de lijst met
tekens die moeten worden ontstapeld, de tekenreeks die moet worden gebruikt om naar een argument te verwijzen
nummer en ten slotte het aanhalingsteken (als dat er niet is, zou er een lege string moeten zijn
mits). Deze instellingen zijn zowel van toepassing op gebruikersmacro's als op metamacro's, tenzij de
-M optie wordt gebruikt om andere instellingen voor metamacro's te definiëren. Zie het gedeelte over
syntaxisspecificatie voor meer details.

-M arg1 ... arg7
Door de gebruiker gedefinieerde modusspecificaties voor meta-macro's. Deze optie kan alleen worden gebruikt
samen met -M. Er wordt aangenomen dat de zeven volgende opdrachtregelargumenten zijn
respectievelijk de macro-startsequentie, de macro-eindsequentie voor een oproep zonder
argumenten, de startvolgorde van het argument, het argumentscheidingsteken, het argumenteinde
reeks, de lijst met tekens die moeten worden gestapeld voor het balanceren van argumenten, en de lijst met
karakters om te ontstapelen. Zie hieronder voor meer details.

(standaard modus)
De standaardmodus is een vaag cpp-achtige modus, maar verwerkt geen opmerkingen, en
vertoont verschillende onverenigbaarheden met cpp. Typische meta-macro's en gebruikersmacro's
er uitzien als dit:

#definieer xy
macro(arg,...)

Deze modus is gelijk aan

-U "" "" "(" "," ")" "(" ")" "#" "\\"
-M "#" "\n" " " " " "\n" "(" ")"

-C cpp-compatibiliteitsmodus. Dit is de modus waarin het gedrag van GPP het dichtst in de buurt komt
die van cpp. Anders dan in de standaardmodus vindt de uitbreiding van meta-macro's alleen plaats in de
begin van regels, en C-opmerkingen en tekenreeksen worden begrepen. Deze modus is
gelijkwaardig

-n -U "" "" "(" "," ")" "(" ")" "#" ""
-M "\n#\w" "\n" " " " " "\n" "" ""
+c "/*" "*/" +c "//" "\n" +c "\\\n" ""
+s "\"" "\"" "\\" +s "'" "'" "\\"

-T TeX-achtige modus. In deze modus zien typische meta-macro's en gebruikersmacro's er als volgt uit:

\definieer{x}{y}
\macro{arg}{...}

Er worden geen opmerkingen begrepen. Deze modus is gelijk aan

-U "\\" "" "{" "}{" "}" "{" "}" "#" "@"

-H HTML-achtige modus. In deze modus zien typische meta-macro's en gebruikersmacro's er als volgt uit:

<#define x|y>
<#macroarg|...>

Er worden geen opmerkingen begrepen. Deze modus is gelijk aan

-U "<#" ">" "\B" "|" ">" "<" ">" "#" "\\"

-X XHTML-achtige modus. In deze modus zien typische meta-macro's en gebruikersmacro's er als volgt uit:

<#define x|y/>
<#macroarg|.../>

Er worden geen opmerkingen begrepen. Deze modus is gelijk aan

-U "<#" "/>" "\B" "|" "/>" "<" ">" "#" "\\"

-P Prolog-compatibele cpp-achtige modus. Deze modus verschilt van de cpp-compatibiliteitsmodus
door de omgang met opmerkingen, en is gelijk aan

-n -U "" "" "(" "," ")" "(" ")" "#" ""
-M "\n#\w" "\n" " " " " "\n" "" ""
+ccss "\!o/*" "*/" +ccss "%" "\n" +ccii "\\\n" ""
+s "\"" "\"" "" +s "\!#'" "'" ""

+c str1 str2
Geef opmerkingen op. Elke niet-geciteerde gebeurtenis van str1 zal worden geïnterpreteerd als de
begin van een opmerking. Alle invoer tot de eerste volgende gebeurtenis van str2 wil
worden weggegooid. Deze optie kan meerdere keren worden gebruikt om verschillende typen te specificeren
scheidingstekens voor opmerkingen. De optionele parameter kan worden opgegeven om de
gedrag van de opmerking en, bv, verander het in een string of laat het negeren onder
bepaalde omstandigheden, zie hieronder.

-c str1
Maak de specificatie van opmerkingen of tekenreeksen ongedaan. De opmerking/tekenreeksspecificatie waarvan het begin
volgorde is str1 is verwijderd. Dit is handig om het ingebouwde commentaar te wijzigen
specificaties van een standaardmodus -- bv, de cpp-compatibiliteitsmodus.

+s str1 str2 c
Geef tekenreeksen op. Elke niet-geciteerde gebeurtenis van str1 zal worden geïnterpreteerd als de
begin van een string. Alle invoer tot de eerste volgende gebeurtenis van str2 wil
worden uitgevoerd zoals ze zijn, zonder enige evaluatie. De scheidingstekens zelf worden uitgevoerd. Als c
is niet leeg, het eerste teken wordt gebruikt als a tekenreeks-citaat karakter -- dat wil zeggen, een
karakter wiens aanwezigheid onmiddellijk vóór het optreden van str2 verhindert het
het beëindigen van de string. De optionele parameter kan worden opgegeven om de
gedrag van de snaar en, bv, verander het in een opmerking, schakel macro-evaluatie in
binnen de string, of zorg ervoor dat de stringspecificatie onder bepaalde wordt genegeerd
omstandigheden. Zie hieronder.

-s str1
Maak de specificatie van opmerkingen of tekenreeksen ongedaan. Identiek aan -c.

--erbij betrekken filet
Proces filet vaardigheden in bestand

--nostdinc
Zoek niet naar include-bestanden in de standaardmap /usr/include.

--nocurinc
Zoek niet naar include-bestanden in de huidige map.

--curdirinclast
Zoek naar include-bestanden in de huidige map na de mappen gespecificeerd door
-I in plaats van vóór hen.

--waarschuwingsniveau n
Stel waarschuwingsniveau in op n (0, 1 of 2). De standaardwaarde is 2 (meest uitgebreid).

--inclusief markering str
bijhouden #include richtlijnen door een markering in de uitvoerstroom in te voegen. De
formaat van de marker wordt bepaald door str, die drie exemplaren van moet bevatten
het personage % (of gelijkwaardig) ?). Het eerste exemplaar wordt vervangen door de regel
nummer, de tweede met de bestandsnaam en de derde met 1, 2 of blanco. Wanneer dit
optie is opgegeven in de standaard-, cpp- of Prolog-modus, doet GPP zijn best om ervoor te zorgen
dat de regelnummers in de uitvoer hetzelfde zijn als in de invoer door blanco in te voegen
lijnen op de plaats van definities of opmerkingen.

in bestand Geef een invoerbestand op waaruit GPP de invoer leest. Als er geen invoerbestand is
opgegeven, wordt de invoer gelezen van de standaardinvoer.

SYNTAXIS SPECIFICATIE

De syntaxis van een macro-aanroep is als volgt: deze moet beginnen met een reeks tekens
overeenkomen met de macro begin volgorde zoals gespecificeerd in de huidige modus, onmiddellijk gevolgd
op basis van de naam van de macro, die geldig moet zijn identificatie -- dat wil zeggen, een reeks letters,
cijfers of onderstrepingstekens ("_"). De macronaam moet worden gevolgd door a kort macro einde
volgorde als de macro geen argumenten heeft, of door een reeks argumenten geïnitieerd door een
argument begin volgorde. De verschillende argumenten worden vervolgens gescheiden door een argument
afscheider, en de macro eindigt met a lang macro einde volgorde.

In alle gevallen zijn de parameters van de huidige context -- dat wil zeggen, de argumenten doorgegeven aan de
lichaam dat wordt geëvalueerd - kan worden verwezen met behulp van een argument referentie volgorde
gevolgd door een cijfer tussen 1 en 9. Als alternatief kunnen macroparameters een naam krijgen (zie
onderstaand). Om bovendien interferentie tussen de GPP-syntaxis en de inhoud van het
invoerbestand, een citeren karakter is voorzien. Het aanhalingsteken kan worden gebruikt om te voorkomen dat de
interpretatie van een macro-aanroep, opmerking of tekenreeks als alles behalve platte tekst. De Quote
karakter "beschermt" het volgende karakter, en wordt altijd verwijderd tijdens evaluatie.
Twee opeenvolgende aanhalingstekens worden beschouwd als één enkel aanhalingsteken.

Ten slotte kunnen, om de juiste argumentafbakening te vergemakkelijken, bepaalde karakters worden "gestapeld"
wanneer ze voorkomen in een macro-argument, zodat het argumentscheidingsteken of de macro-reeks eindigt
worden niet geparseerd als de argumenttekst niet evenwichtig is. Dit maakt het nesten van macro-oproepen mogelijk
zonder aanhalingstekens te gebruiken. Als een onjuist uitgebalanceerd argument nodig is, citeer dan tekens
moet vóór enkele gestapelde tekens worden toegevoegd om het in evenwicht te brengen.

De hierboven beschreven macroconstructiesequenties kunnen verschillend zijn voor metamacro's en voor
gebruikersmacro's: dit is bijvoorbeeld het geval in de cpp-modus. Merk op dat, aangezien meta-macro's dat wel kunnen
slechts maximaal twee argumenten hebben, zijn de afbakeningsregels voor het tweede argument enigszins
slordiger en niet-geciteerde argumentscheidingsreeksen zijn toegestaan ​​in het tweede argument van
een meta-macro.

Tenzij een van de standaard bedieningsmodi is geselecteerd, kunnen de bovenstaande syntaxissequenties dat zijn
opgegeven op de opdrachtregel, met respectievelijk de opties -M en -U voor meta-
macro's en gebruikersmacro's, of in een invoerbestand via de #modus meta en #modus gebruiker meta-
macro-oproepen. In beide gevallen bestaat de modusbeschrijving uit negen parameters voor de gebruiker
macrospecificaties, namelijk de macrostartvolgorde, de korte macro-eindvolgorde, de
startreeks van het argument, het argumentscheidingsteken, de lange eindreeks van de macro, de tekenreeks
lijst met tekens die moeten worden gestapeld, de reeks met tekens die moeten worden ontstapeld, het argument
referentiereeks en ten slotte het aanhalingsteken. Zoals hieronder uitgelegd, deze reeksen
moet worden opgegeven met behulp van de syntaxis van C-strings; ze moeten beginnen met een niet-alfanumeriek getal
karakter, en in de eerste vijf strings kunnen speciale overeenkomende reeksen worden gebruikt (zie
onderstaand). Als het argument dat overeenkomt met het aanhalingsteken de lege tekenreeks is, dan is dat
De functionaliteit van het argument is uitgeschakeld. Voor meta-macrospecificaties zijn er slechts zeven
parameters, aangezien de argumentreferentiereeks en het aanhalingsteken worden gedeeld met de
syntaxis van gebruikersmacro's.

De structuur van een commentaar/tekenreeks is als volgt: het moet beginnen met een reeks van
tekens die overeenkomen met het gegeven commentaar/tekenreeks begin volgorde, en eindigt altijd bij de eerste
voorkomen van de commentaar/tekenreeks einde volgorde, tenzij het wordt voorafgegaan door een oneven aantal
voorvallen van de tekenreeks-citaat karakter (als een dergelijk teken is opgegeven). In
in bepaalde gevallen kunnen opmerkingen/tekenreeksen worden opgegeven om macro-evaluatie binnen het bestand mogelijk te maken
commentaar/tekenreeks; in dat geval kan dit het geval zijn als er een aanhalingsteken voor macro's is gedefinieerd
wordt ook gebruikt om te voorkomen dat de opmerking/tekenreeks eindigt, met het verschil dat de macro
het aanhalingsteken wordt altijd uit de uitvoer verwijderd, terwijl het tekenreeks-aanhalingsteken altijd wordt verwijderd
uitgang. Houd er ook rekening mee dat onder bepaalde omstandigheden een commentaar-/tekenreeksspecificatie kan bestaan
invalide, in welk geval de startreeks voor commentaar/tekenreeks eenvoudigweg wordt genegeerd. Eindelijk, het
is het mogelijk om een snaar waarschuwing karakter wiens aanwezigheid in een opmerking/tekenreeks
zal ervoor zorgen dat GPP een waarschuwing geeft (dit is handig om niet-afgesloten tekenreeksen in cpp te lokaliseren
modus). Houd er rekening mee dat invoerbestanden geen niet-afgesloten opmerkingen/tekenreeksen mogen bevatten.

Een commentaar-/tekenreeksspecificatie kan vanuit het invoerbestand worden gedeclareerd met behulp van de #modus
commentaar meta-macro-aanroep (of gelijkwaardig #modus snaar), in welk geval het aantal C
tekenreeksen die moeten worden opgegeven als argumenten om de opmerking/tekenreeks te beschrijven, kunnen daar ergens tussenin liggen
twee en vier: de eerste twee argumenten (verplicht) zijn de startreeks en het einde
reeks, en kan gebruik maken van de speciale bijpassende reeksen (zie hieronder). Misschien niet
beginnen met alfanumerieke tekens. Het eerste teken van het derde argument, als dat zo is
one, wordt gebruikt als tekenreeks-aanhalingstekens (gebruik een lege tekenreeks om de
functionaliteit) en wordt het eerste teken van het vierde argument, als dat er is, gebruikt
als tekenreekswaarschuwing. Er kan ook een specificatie worden opgegeven vanaf de opdrachtregel,
in dat geval moeten er twee argumenten zijn als je de +c optie gebruikt en drie als je de +s gebruikt
optie.

Het gedrag van een opmerking/tekenreeks wordt gespecificeerd door een modificatiereeks van drie tekens, die
kan als optioneel argument worden doorgegeven aan de +c/+s opdrachtregelopties of aan de
#modus commentaar/#modus snaar meta-macro's. Als er geen modificatietekenreeks is opgegeven, is dit de standaardwaarde
waarde is "ccc" voor commentaar en "sss" voor tekenreeksen. Het eerste teken komt overeen met de
gedrag binnen meta-macro-aanroepen (inclusief definities van gebruikersmacro's, aangezien deze binnenkomen
a #define meta-macro-aanroep), komt het tweede teken overeen met het gedrag binnen de gebruikersinterface
macroparameters, en het derde teken komt overeen met het gedrag buiten een macro
telefoongesprek. Elk van deze tekens kan de volgende waarden aannemen:

i schakel de commentaar-/tekenreeksspecificatie uit.

c commentaar (noch geëvalueerd, noch output).

s string (de string en zijn scheidingstekenreeksen worden uitgevoerd zoals ze zijn).

q tekenreeks tussen aanhalingstekens (de tekenreeks wordt uitgevoerd zoals hij is, zonder de scheidingstekenreeksen).

C geëvalueerd commentaar (macro's worden geëvalueerd, maar de uitvoer wordt genegeerd).

S geëvalueerde tekenreeks (macro's worden geëvalueerd, scheidingstekens worden uitgevoerd).

Q geëvalueerde tekenreeks tussen aanhalingstekens (macro's worden geëvalueerd, scheidingstekens worden niet uitgevoerd).

Belangrijke opmerking: elk voorkomen van een commentaar/tekenreeks startreeks binnen een andere
commentaar/tekenreeks wordt altijd genegeerd, zelfs als macro-evaluatie is ingeschakeld. Met andere woorden,
opmerkingen/tekenreeksen kunnen niet worden genest. In het bijzonder kan de `Q'-modifier een handige manier zijn
van het definiëren van een syntaxis voor het tijdelijk uitschakelen van alle commentaar- en tekenreeksspecificaties.

Tekenreeksen voor syntaxisspecificaties moeten altijd worden opgegeven als C-tekenreeksen, ongeacht of dit het geval is
gegeven als argumenten voor a #modus meta-macro-oproep of op de opdrachtregel van een Unix-shell. Als
opdrachtregelargumenten worden gegeven via een andere methode dan een standaard Unix-shell, dan de
shell-gedrag moet worden nagebootst -- dat wil zeggen, de omringende "" aanhalingstekens moeten allemaal worden verwijderd
voorkomens van `\\' moeten worden vervangen door een enkele backslash, en op dezelfde manier zou `\"' moeten worden vervangen
vervangen door `"'. Reeksen zoals `\n' worden herkend door GPP en moeten zo blijven.

Er kunnen speciale reeksen worden gebruikt die overeenkomen met bepaalde subsets van de tekenset. Ze zijn van
de vorm `\x', waar x is een van:

b komt overeen met elke reeks van een of meer spaties of tabtekens (`\b' is identiek aan
` ').

w komt overeen met elke reeks van nul of meer spaties of tabtekens.

B komt overeen met elke reeks van een of meer spaties, tabs of nieuweregeltekens.

W komt overeen met elke reeks van nul of meer spaties, tabs of nieuweregeltekens.

a een alfabetisch teken (`a' tot `z' en `A' tot `Z').

A een alfabetisch teken, of een spatie, tab of nieuwe regel.

# een cijfer (`0' tot `9').

i een identificatieteken. De set overeenkomende karakters kan worden aangepast met behulp van de
#modus karakterset id commando. De standaardinstelling komt overeen met alfanumerieke tekens en
onderstrepingstekens (`a' tot `z', `A' tot `Z', `0' tot `9' en `_').

t een tabteken.

n een newline-teken.

o een operatorkarakter. De set overeenkomende karakters kan worden aangepast met behulp van de
#modus karakterset op commando. De standaardinstelling komt overeen met alle tekens in
"+-*/\^<>=`~:.?@#&!%|", behalve in Prolog-modus waar `!', `%' en `|' zijn niet
op elkaar afgestemd.

O een operatorteken of een haakjeteken. De set van extra afgestemd
tekens in vergelijking met `\o' kunnen worden aangepast met behulp van de #modus karakterset Weergave
commando. De standaardinstelling is dat de tekens tussen "()[]{}" tussen haakjes staan.

Bovendien kunnen al deze overeenkomende subsets behalve `\w' en `\W' worden ontkend door a in te voegen
`!' -- dat wil zeggen, door `\!x' in plaats van `\x'.

Let op een belangrijk onderscheidend kenmerk van begin sequenties: wanneer het eerste teken van a
macro of commentaar/tekenreeks startreeks is ' ' of een van de bovenstaande speciale reeksen
wordt niet beschouwd als onderdeel van de reeks zelf, maar wordt in plaats daarvan gebruikt als contextcontrole: for
een startreeks die begint met '\n' komt bijvoorbeeld alleen overeen met het begin van een regel, maar
het overeenkomende nieuweregelteken wordt niet als onderdeel van de reeks beschouwd. Zo ook een begin
reeks die begint met ' ' komt alleen overeen als er enige witruimte aanwezig is, maar de matching
witruimte wordt niet beschouwd als onderdeel van de startreeks en wordt daarom verzonden naar
uitgang. Als een contextcontrole helemaal aan het begin van een bestand wordt uitgevoerd (of algemener
van elk lichaam dat moet worden geëvalueerd), is het resultaat hetzelfde als het matchen met een newline-teken
(dit maakt het mogelijk dat een cpp-modusbestand begint met een meta-macro-aanroep).

In versie 2.1 zijn twee speciale syntaxisregels toegevoegd. Eerst argumentreferenties (#n) zijn geen
langer geëvalueerd wanneer ze buiten de macro-aanroepen en -definities vallen. Maar dat zijn ze wel
mag niet langer verschijnen (tenzij beschermd door aanhalingstekens) in een aanroep naar a
gedefinieerde gebruikersmacro; het huidige gedrag (achterwaarts compatibel) is om ze stil te verwijderen
van de invoer als dat gebeurt.

Ten tweede, als de eindreeks (voor macro's of commentaar) uit één enkele nieuwe regel bestaat
karakter, en of afbakeningsregels leiden tot evaluatie in een context waar de finale
het newline-teken ontbreekt, negeert GPP stilletjes de ontbrekende newline in plaats van te produceren
een fout. Het belangrijkste gevolg is dat meta-macro-aanroepen nu op een eenvoudige manier kunnen worden genest
in standaard-, cpp- en Prolog-modi.

EVALUATIE REGLEMENT

De invoer wordt sequentieel gelezen en geïnterpreteerd volgens de regels van de huidige modus. Alle
invoertekst wordt eerst vergeleken met de opgegeven startreeksen voor commentaar/tekenreeksen van de
huidige modus (behalve degene die zijn uitgeschakeld door de 'i'-modifier), tenzij het lichaam is
geëvalueerd is de inhoud van een opmerking/tekenreeks waarvan de modifier macro-evaluatie mogelijk maakt.
De meest recent gedefinieerde commentaar-/tekenreeksspecificaties worden eerst gecontroleerd. Belangrijk
Let op: het is mogelijk dat er geen commentaar verschijnt tussen de naam van een macro en zijn argumenten (als u dit doet
resulteert in ongedefinieerd gedrag).

Alles dat geen commentaar/tekenreeks is, wordt vervolgens vergeleken met een mogelijke meta-macro-aanroep,
en als dat ook niet lukt, tegen een mogelijke gebruikersmacro-oproep. Alle resterende tekst ondergaat
vervanging van argumentreferentiereeksen door de relevante argumenttekst (leeg tenzij
het lichaam dat wordt geëvalueerd is de definitie van een gebruikersmacro) en het verwijderen van het citaat
karakter als die er is.

Houd er rekening mee dat meta-macro-argumenten vóór elke evaluatie aan de meta-macro worden doorgegeven
(hoewel de meta-macro ervoor kan kiezen om ze te evalueren, zie de meta-macro-beschrijvingen hieronder).
Bij de #modus meta-macro voegt GPP tijdelijk een commentaar-/tekenreeksspecificatie toe
om herkenning van C-strings ("...") mogelijk te maken en elke evaluatie daarin te voorkomen, dus nee
interferentie van de karakters die in de C-stringargumenten worden geplaatst #modus met de
de huidige syntaxis is te vrezen.

Aan de andere kant worden de argumenten voor een gebruikersmacro systematisch geëvalueerd, en vervolgens
doorgegeven als contextparameters aan de hoofdtekst van de macrodefinitie, die daarmee wordt geëvalueerd
omgeving. De enige uitzondering is wanneer de macrodefinitie leeg is, in welk geval dit het geval is
argumenten worden niet beoordeeld. Merk op dat GPP tijdelijk terugschakelt naar de modus waarin
de macro is gedefinieerd om deze te evalueren, dus het is volkomen veilig om de
bedrijfsmodus tussen het tijdstip waarop een macro wordt gedefinieerd en het tijdstip waarop deze wordt opgeroepen.
Omgekeerd, als een gebruikersmacro met de huidige modus wil werken in plaats van met die
werd gebruikt om het te definiëren, het moet beginnen met a #modus herstellen bellen en eindigen met een #modus
besparen noemen.

Een gebruikersmacro kan worden gedefinieerd met benoemde argumenten (zie #define beschrijving hieronder). In dat
Wanneer de macrodefinitie wordt geëvalueerd, veroorzaakt elke benoemde parameter een
tijdelijke virtuele gebruikersmacrodefinitie die moet worden gemaakt; zo'n macro mag alleen worden aangeroepen
zonder argumenten en retourneert eenvoudigweg de tekst van het overeenkomstige argument.

Houd er rekening mee dat macro's worden geëvalueerd wanneer ze worden aangeroepen en niet wanneer ze worden aangeroepen
gedefinieerd, veroorzaakt elke poging om een ​​recursieve macro aan te roepen ongedefinieerd gedrag, behalve in de
heel specifiek geval wanneer de macro gebruikt #undef om zichzelf te wissen na een eindig aantal lussen
iteraties.

Ten slotte doet zich een speciaal geval voor wanneer een gebruikersmacro waarvan de definitie geen enkele omvat
argumenten (noch benoemde argumenten, noch de argumentreferentiereeks) worden aangeroepen in a
modus waarin de korte eindreeks van de gebruikersmacro leeg is (bv, cpp of TeX-modus). In dat
geval wordt aangenomen dat het een alias macro: de argumenten worden eerst geëvalueerd in de huidige
modus zoals gewoonlijk, maar in plaats van als parameters aan de macrodefinitie te worden doorgegeven (welke
waardoor ze worden weggegooid) worden ze feitelijk toegevoegd aan de macrodefinitie,
met behulp van de syntaxisregels van de modus waarin de macro is gedefinieerd, en de resulterende tekst
wordt opnieuw geëvalueerd. Het is daarom belangrijk op te merken dat, in het geval van een macroalias,
de argumenten worden feitelijk twee keer geëvalueerd in twee potentieel verschillende modi.

META-MACROS

Deze macro's zijn altijd vooraf gedefinieerd. Hun daadwerkelijke oproepvolgorde is afhankelijk van de stroom
modus; hier gebruiken we cpp-achtige notatie.

#define x y
Dit definieert de gebruikersmacro x as y. y kan elke geldige GPP-invoer zijn, en kan voor
voorbeeld verwijzen naar andere macro's. x moet een identificatie zijn (dat wil zeggen, een reeks van
alfanumerieke tekens en '_'), tenzij benoemde argumenten zijn opgegeven. Als x is
al gedefinieerd, wordt de vorige definitie overschreven. Als er geen tweede argument is
gegeven, x wordt gedefinieerd als een macro die niets uitvoert. Geen van beide x noch y zijn
geëvalueerd; de macrodefinitie wordt alleen geëvalueerd wanneer deze wordt aangeroepen, niet wanneer deze wordt aangeroepen
verklaard.

Het is ook mogelijk om de argumenten in een macrodefinitie een naam te geven: in dat geval is de
argument x moet een gebruikersmacro-aanroep zijn waarvan de argumenten allemaal identificatiegegevens zijn. Deze
ID's worden beschikbaar als gebruikersmacro's binnen de macrodefinitie; deze
virtuele macro's moeten zonder argumenten worden aangeroepen en naar de overeenkomstige worden geëvalueerd
macroparameter.

#defeval x y
Dit werkt op een vergelijkbare manier als #define, maar het tweede argument y wordt geëvalueerd
onmiddellijk. Omdat gebruikersmacrodefinities telkens ook worden geëvalueerd
genoemd, betekent dit dat de macro y zal ondergaan twee opeenvolgende evaluaties. De
nut van #defeval is aanzienlijk omdat het de enige manier is om iets te beoordelen
meer dan eens, wat nodig kan zijn om de evaluatie van de argumenten van een meta-
macro die normaal gesproken geen evaluatie uitvoert. Maar aangezien alle argument
referenties die op het moment van definiëren worden geëvalueerd, worden opgevat als de argumenten van het lichaam in
waarin de macro wordt gedefinieerd en niet als de argumenten van de macro zelf,
meestal moet men het aanhalingsteken gebruiken om onmiddellijke evaluatie van te voorkomen
argumentverwijzingen.

#undef x
Hiermee wordt elke bestaande definitie van de gebruikersmacro verwijderd x.

#ifdef x
Hiermee begint een voorwaardelijk blok. Alles wat volgt wordt alleen geëvalueerd als de
identificatie x is gedefinieerd, en totdat a #anders nodig heeft of #stop als verklaring is bereikt.
Houd er echter rekening mee dat de becommentarieerde tekst nog steeds grondig wordt gescand, dus ook de syntaxis ervan
Moet geldig zijn. Het is met name legaal om de #anders or #stop als verklaring
Het beëindigen van het voorwaardelijke blok verschijnt alleen als resultaat van een uitbreiding van een gebruikersmacro
en niet expliciet in de invoer.

#ifndef x
Hiermee begint een voorwaardelijk blok. Alles wat volgt wordt alleen geëvalueerd als de
identificatie x is niet gedefinieerd.

#ifeq x y
Hiermee begint een voorwaardelijk blok. Alles wat volgt wordt alleen geëvalueerd als de
resultaten van de evaluaties van x en y zijn identiek als tekenreeksen. Elk
voorloop- of volgspatie wordt bij de vergelijking genegeerd. Merk op dat in de cpp-modus
elk niet-geciteerd witruimteteken wordt opgevat als het einde van het eerste argument,
het is dus noodzakelijk om voorzichtig te zijn.

#ifneq x y
Hiermee begint een voorwaardelijk blok. Alles wat volgt wordt alleen geëvalueerd als de
resultaten van de evaluaties van x en y zijn niet identiek (zelfs niet als leidend of
achterliggende witruimte).

#anders Hierdoor wordt de logische waarde van het huidige voorwaardelijke blok omgeschakeld. Wat volgt is
geëvalueerd als en slechts als de voorgaande invoer is becommentarieerd.

#stop als Hiermee wordt een voorwaardelijk blok beëindigd dat is gestart door a #als... meta-macro.

#include filet
Dit zorgt ervoor dat GPP het opgegeven bestand opent en de inhoud ervan evalueert, door de
resulterende tekst in de huidige uitvoer. Alle gedefinieerde gebruikersmacro's zijn nog steeds beschikbaar
in het opgenomen bestand, en omgekeerd zullen alle macro's die in het opgenomen bestand zijn gedefinieerd dat ook doen
beschikbaar zijn in alles wat volgt. Het include-bestand wordt eerst gezocht in
de huidige map en vervolgens, als deze niet wordt gevonden, in een van de opgegeven mappen
Door de -I opdrachtregeloptie (of / Usr / include als er geen map is opgegeven).
Merk op dat het om compatibiliteitsredenen mogelijk is om de bestandsnaam tussen
"" of <>.

De volgorde waarin de verschillende mappen worden doorzocht, inclusief bestanden, is
beïnvloed door de -nostdinc, -nocurinc en - curdirinclast opdrachtregelopties.

Na het toevoegen van een bestand slaat GPP onmiddellijk een kopie op van de huidige bedrijfsmodus
op de modusstapel en herstelt de bedrijfsmodus aan het einde van de meegeleverde versie
bestand. Het opgenomen bestand kan dit gedrag overschrijven door te beginnen met a #modus herstellen
bellen en eindigen met een #modus duwen telefoongesprek. Bovendien, wanneer de -m opdrachtregel
optie is opgegeven, schakelt GPP automatisch over naar de cpp-compatibiliteitsmodus
bij het opnemen van een bestand waarvan de naam eindigt op '.c' of '.h'.

#exec commando
Dit zorgt ervoor dat GPP de opgegeven opdrachtregel uitvoert en de standaard ervan toevoegt
uitgang in de huidige uitgang. Merk op dat deze meta-macro om veiligheidsredenen dat wel is
uitgeschakeld, tenzij de -x opdrachtregelvlag is opgegeven. Indien gebruik van #exec is niet
toegestaan, wordt er een waarschuwingsbericht afgedrukt en blijft de uitvoer leeg. Merk op dat de
De opgegeven opdrachtregel wordt geëvalueerd voordat deze wordt uitgevoerd, waardoor het gebruik van
macro's op de opdrachtregel. De uitvoer van de opdracht is echter woordelijk opgenomen
en niet geëvalueerd. Als u wilt dat de uitvoer wordt geëvalueerd, moet u gebruiken #defeval
(zie hierboven) om een ​​dubbele evaluatie te veroorzaken.

#eval uitdrukken
De #eval meta-macro probeert te evalueren uitdrukken eerst door macro's uit te breiden (normaal
GPP-evaluatie) en vervolgens door een rekenkundige evaluatie en/of wildcard uit te voeren
bij elkaar passen. De syntaxis en operatorprioriteit voor rekenkundige expressies zijn de
hetzelfde als in C; de enige ontbrekende operatoren zijn <<, >>, ?:, en de toewijzing
exploitanten.

Matching met jokertekens in POSIX-stijl ('globbing') is alleen beschikbaar op POSIX
implementaties en kan worden aangeroepen met de operator =~. Kortom, een '?' wedstrijden
elk enkel teken, een '*' komt overeen met elke tekenreeks (inclusief de lege tekenreeks), en
'[...]' komt overeen met een van de tekens tussen haakjes. Een '[...]'-klasse is
aangevuld als het eerste teken tussen haakjes '!' is. De karakters in een
De klasse '[...]' kan ook worden opgegeven als een bereik met behulp van het teken '-' -- bv,
'[FN]' is gelijk aan '[FGHIJKLMN]'.

Als er geen numerieke waarde aan het resultaat kan worden toegewezen, is de geretourneerde tekst eenvoudigweg
het resultaat van macro-uitbreiding zonder enige rekenkundige evaluatie. De enige
uitzonderingen op deze regel zijn de vergelijkingsoperatoren ==, !=, <, >, <= en >=
die, als een van de zijden niet resulteert in een getal, een stringvergelijking uitvoert
in plaats daarvan (waarbij de volg- en voorloopspaties worden genegeerd). Bovendien is de lengte(...)
de rekenkundige operator retourneert de lengte in tekens van het geëvalueerde argument.

Binnen rekenkundige uitdrukkingen wordt de bepaald(...) speciale gebruikersmacro is ook
beschikbaar: er is slechts één argument nodig, dat niet wordt geëvalueerd, en retourneert 1 als dit het geval is
is de naam van een gebruikersmacro en anders 0.

#als uitdrukken
Deze meta-macro roept de rekenkundige/globberende evaluator op dezelfde manier aan als
#eval en vergelijkt het resultaat van de evaluatie met de string "0" om a te beginnen
voorwaardelijk blok. Merk in het bijzonder op dat de logische waarde van uitdrukken is altijd waar
wanneer het niet kan worden geëvalueerd tot een getal.

#elif uitdrukken
Deze meta-macro kan worden gebruikt om genest te voorkomen #als voorwaarden. #als ... #elif ...
#stop als is gelijk aan #als ... #anders #als ... #stop als #stop als.

#modus trefwoord ...
Deze meta-macro bepaalt de werkingsmodus van GPP. Zie hieronder voor een lijst met #modus
commando's.

#lijn Deze meta-macro evalueert het regelnummer van het huidige invoerbestand.

#bestand Deze meta-macro evalueert de bestandsnaam van het huidige invoerbestand zoals deze verschijnt
op de opdrachtregel of in het argument to #include. Als GPP zijn invoer leest
van stdin dan #bestand evalueert naar `stdin'.

#datum fmt
Deze meta-macro evalueert naar de huidige datum en tijd zoals geformatteerd door de
gespecificeerde formaatreeks fmt. Zie de sectie DATUM EN TIJD CONVERSIE SPECIFICATIES
hieronder.

#fout msg
Deze meta-macro veroorzaakt een foutmelding met de huidige bestandsnaam en regelnummer,
en met de tekst msg, om af te drukken naar het standaardfoutapparaat. Volgend
De verwerking wordt vervolgens afgebroken.

#waarschuwing msg
Deze meta-macro veroorzaakt een waarschuwingsbericht met de huidige bestandsnaam en regelnummer,
en met de tekst msg, om af te drukken naar het standaardfoutapparaat. Volgend
De verwerking wordt vervolgens hervat.

De sleutel tot de flexibiliteit van GPP is de #modus meta-macro. Het eerste argument is er altijd één van
een lijst met beschikbare trefwoorden (zie hieronder); het tweede argument is altijd een reeks van
woorden gescheiden door witruimte. Afgezien van mogelijk de eerste, elk van deze woorden
is altijd een scheidingsteken of syntaxisspecificatie en moet worden opgegeven als een door C-tekenreeks gescheiden tekenreeks
door dubbele aanhalingstekens (" "). De verschillende speciale bijpassende reeksen die worden vermeld in de sectie over
syntaxisspecificatie zijn beschikbaar. Elk #modus opdracht wordt geparseerd in een modus waarin "..." is
het wordt beschouwd als een string in C-stijl, dus het is veilig om hier een teken in te plaatsen
snaren. Merk ook op dat het eerste argument van #modus (het trefwoord) wordt nooit geëvalueerd,
terwijl het tweede argument wordt geëvalueerd (behalve natuurlijk voor de inhoud van C-strings),
zodat de syntaxisspecificatie kan worden verkregen als resultaat van een macro-evaluatie.

De beschikbare #modus commando's zijn:

#modus besparen / #modus duwen
Duw de huidige modusspecificatie naar de modusstapel.

#modus herstellen / #modus knal
Specificatie van de popmodus van de modusstapel.

#modus standaard naam
Selecteer een van de standaardmodi. Het enige argument moet een van de volgende zijn: standaard
(standaard modus); cpp, C (cpp-modus); tex, TeX (tex-modus); html, HTML (html-modus);
xhtml, XHTML (xhtml-modus); prolog, Prolog (prolog-modus). De modusnaam moet zijn
direct gegeven, niet als een C-snaar.

#modus gebruiker "S1" ... "S9"
Geef de syntaxis van de gebruikersmacro op. De 9 argumenten, allemaal C-strings, vormen de modus
specificatie voor gebruikersmacro's (zie de opdrachtregeloptie -U en de sectie over
syntaxisspecificatie). De meta-macrospecificatie wordt niet beïnvloed.

#modus meta {gebruiker | "S1" ... "s7"}
Geef de syntaxis van de meta-macro op. Ofwel is het enige argument gebruiker (niet als string), en
de specificaties van de gebruikersmacromodus worden gekopieerd naar de meta-macromodus
specificaties, of er moeten zeven stringargumenten zijn, waarvan de betekenis de
hetzelfde als voor de opdrachtregeloptie -M (zie sectie over syntaxisspecificatie).

#modus citeren ["C"]
Zonder argument of "" als argument verwijdert u de specificatie van het aanhalingsteken en
schakelt de citaatfunctionaliteit uit. Met één stringargument, het eerste teken
van de string wordt beschouwd als het nieuwe aanhalingsteken. Het aanhalingsteken kan zijn
noch alfanumeriek noch '_', noch kan het een van de speciale overeenkomende reeksen zijn.

#modus commentaar [Xxx] "begin" "einde" ["C" ["C"]]
Voeg een commentaarspecificatie toe. Optioneel een eerste argument bestaande uit drie
tekens die niet tussen " " staan, kunnen worden gebruikt om een ​​commentaar-/tekenreeksmodifier op te geven
(zie de sectie over syntaxisspecificatie). De standaardmodificator is ccc. De eerste
twee stringargumenten worden respectievelijk gebruikt als start- en eindreeksen voor commentaar. De
het derde stringargument is optioneel en kan worden gebruikt om een ​​string-quote op te geven
karakter. (Als het "" is, is de functionaliteit uitgeschakeld.) De vierde tekenreeks
argument is optioneel en kan worden gebruikt om een ​​tekenreeksafbakeningswaarschuwing op te geven
karakter. (Als het "" is, is de functionaliteit uitgeschakeld.)

#modus snaar [Xxx] "begin" "einde" ["C" ["C"]]
Voeg een tekenreeksspecificatie toe. Identiek aan #modus commentaar behalve dat dit de standaard is
modificator is sss.

#modus geen commentaar / #modus nietszeggend ["begin"]
Verwijder zonder argument alle commentaar-/tekenreeksspecificaties. Met één touwtje
argument verwijdert u de opmerking/tekenreeksspecificatie waarvan de startvolgorde de
argument.

#modus behouden { on | korting | 1 | 0 }
gelijk aan de -n opdrachtregelschakelaar. Als de argumentatie dat is on or 1, elke nieuwe regel
of een witruimteteken dat een macro-oproep beëindigt, of er wordt een opmerking/tekenreeks achtergelaten in de
invoerstroom voor verdere verwerking. Als de argumentatie dat is korting or 0 deze functie is
uitgeschakeld.

#modus karakterset { id | op | Weergave } "draad"
Geef de tekensets op die moeten worden gebruikt voor het matchen van de \o, \O en \i special
opeenvolgingen. Het eerste argument moet een van zijn id (de set die overeenkomt met \i), op (De
ingesteld overeenkomend met \o) of Weergave (de set die overeenkomt met \O naast de set die overeenkomt met
\O). "draad" is een C-reeks die alle tekens bevat die in de set moeten worden geplaatst. Het kan
bevatten alleen de speciale overeenkomende reeksen \a, \A, \b, \B en \# (de andere
reeksen en de ontkende reeksen zijn niet toegestaan). Wanneer een '-' wordt gevonden
tussen twee niet-speciale tekens, dit voegt alle tekens ertussen toe (bijv. "AZ"
komt overeen met uitsluitend hoofdletters). Om ook '-' in de overeenkomende set te hebben
plaats het op de eerste of laatste positie of plaats het naast een \x-reeks.

DATUM EN TIJD CONVERSIE SPECIFICATIES

Gewone tekens die in de formatstring zijn geplaatst, worden zonder conversie gekopieerd.
Conversiespecificaties worden geïntroduceerd door een `%'-teken en worden als volgt vervangen:

%a De afgekorte naam van de weekdag volgens de huidige locale.

%A De volledige naam van de weekdag volgens de huidige locale.

%b De afgekorte naam van de maand volgens de huidige locale.

%B De volledige naam van de maand volgens de huidige locale.

%c De voorkeursweergave voor datum en tijd voor de huidige locale.

%d De dag van de maand als een decimaal getal (bereik 01 tot 31).

%F Gelijk aan %Y-%m-%d (de ISO 8601-datumnotatie).

%H Het uur als een decimaal getal met een 24-uurs klok (bereik 00 tot 23).

%I Het uur als een decimaal getal met een 12-uurs klok (bereik 01 tot 12).

%j De dag van het jaar als een decimaal getal (bereik 001 tot 366).

%m De maand als een decimaal getal (bereik 01 tot 12).

%M De minuut als een decimaal getal (bereik 00 tot 59).

%p Ofwel 'AM' of 'PM' volgens de gegeven tijdswaarde, of het overeenkomstige
tekenreeksen voor de huidige landinstelling. Middag wordt behandeld als 'pm' en middernacht als 'am'.

%R De tijd in 24-uursnotatie (%H:%M).

%S De tweede als een decimaal getal (bereik 00 tot 61).

%U Het weeknummer van het huidige jaar als decimaal getal, bereik 00 tot 53,
te beginnen met de eerste zondag als de eerste dag van week 01.

%w De dag van de week als decimaal getal, van 0 tot 6, waarbij zondag 0 is.

%W Het weeknummer van het huidige jaar als decimaal getal, bereik 00 tot 53,
te beginnen met de eerste maandag als de eerste dag van week 01.

%x De voorkeursdatumweergave voor de huidige landinstelling zonder de tijd.

%X De geprefereerde tijdweergave voor de huidige locale zonder de datum.

%y Het jaar als decimaal getal zonder eeuw (bereik 00 tot 99).

%Y Het jaar als een decimaal getal inclusief de eeuw.

%Z De tijdzone of naam of afkorting.

%% Een letterlijk `%'-teken.

Afhankelijk van de C-compiler en bibliotheek die worden gebruikt om GPP te compileren, kan er meer conversie plaatsvinden
specificaties beschikbaar. Raadpleeg de documentatie van uw compiler voor de strftime () functie.
Houd er echter rekening mee dat eventuele conversiespecificaties die hierboven niet worden vermeld, mogelijk niet overdraagbaar zijn
installaties van GPP.

Voorbeelden

Hier is een eenvoudig, voor zichzelf sprekend voorbeeld in de standaard- of cpp-modus:

#define FOO Dit is
#define BAR een bericht.
#define concat #1 #2
concat(FOO,BAR)
#ifeq (concat(foo,bar)) (foobar)
Dit is uitvoer.
#anders
Dit is geen uitvoer.
#stop als

Met behulp van argumentnaamgeving kan de concat macro kan ook worden gedefinieerd als

#define concat(x,y) xy

In de TeX-modus en bij gebruik van argumentnaamgeving wordt hetzelfde voorbeeld:

\define{FOO}{Dit is}
\define{BAR}{een bericht.}
\definieer{\concat{x}{y}}{\x \y}
\concat{\FOO}{\BAR}
\ifeq{\concat{foo}{bar}}{foobar}
Dit is uitvoer.
\anders
Dit is geen uitvoer.
\stop als

In de HTML-modus en zonder argumentnaamgeving krijgt men op dezelfde manier:

<#define FOO|Dit is>
<#define BAR|een bericht.>
<#define concat|#1 #2>
<#concat <#FOO>|<#BAR>>
<#ifeq <#concat foo|bar>|foo bar>
Dit is uitvoer.
<#else>
Dit is geen uitvoer.
<#endif>

Het volgende voorbeeld (in de standaardmodus) illustreert het gebruik van het aanhalingsteken:

#define FOO Dit is \
een meerlijnige definitie.
#define BLAH(x) Mijn argument is x
BLAH(urf)
\BLAH(urf)

Merk op dat de multiline-definitie ook geldig is in de cpp- en Prolog-modi, ondanks de
afwezigheid van aanhalingstekens, omdat '\' gevolgd door een nieuwe regel dan wordt geïnterpreteerd als a
commentaar en weggegooid.

In de cpp-modus worden C-tekenreeksen en opmerkingen als zodanig opgevat, zoals geïllustreerd door de
volgend voorbeeld:

#define BLAH foo
BLAH "BLAH" /* BLAH */
'Het is een /*string*/ !'

Het belangrijkste verschil tussen de Prolog-modus en de cpp-modus is de omgang met strings en
opmerkingen: in Prolog begint een '...'-reeks mogelijk niet onmiddellijk na een cijfer, en een /*...*/
commentaar begint mogelijk niet onmiddellijk na een operatorteken. Verder zijn er opmerkingen
worden niet uit de uitvoer verwijderd, tenzij ze voorkomen in een #commando.

De verschillen tussen de cpp-modus en de standaardmodus zijn dieper: in de standaardmodus #commands
mogen overal beginnen, terwijl ze in cpp-modus aan het begin van een regel moeten staan; de standaard
mode heeft geen kennis van commentaar en strings, maar heeft een aanhalingsteken ('\'), terwijl cpp
modus heeft uitgebreide commentaar-/tekenreeksspecificaties, maar geen aanhalingstekens. Bovendien is de
argumenten voor metamacro's moeten in de standaardmodus correct tussen haakjes worden geplaatst, terwijl dat niet het geval is
de controle wordt uitgevoerd in de cpp-modus.

Dit maakt het gemakkelijker om meta-macro-oproepen in de standaardmodus te nesten dan in de cpp-modus. Voor
Beschouw bijvoorbeeld de volgende invoer in de HTML-modus, die test op de beschikbaarheid van de
#exec opdracht:

<#ifeq <#exec echo blah>|blah
> #exec toegestaan ​​<#else> #exec niet toegestaan ​​<#endif>

Er is geen equivalent in de cpp-modus, terwijl het in de standaardmodus eenvoudig kan worden vertaald als

#ifeq (#exec echo bla
) (bla
)
\#exec toegestaan
#anders
\#exec niet toegestaan
#stop als

Om meta-macro-oproepen in de cpp-modus te nesten, is het noodzakelijk om de modus te wijzigen
beschrijving, hetzij door de syntaxis van de meta-macro-aanroep te wijzigen, hetzij eleganter door te definiëren
een stille string en gebruikmakend van het feit dat de context aan het begin van een geëvalueerd
string is een newline-teken:

#mode tekenreeks QQQ "$" "$"
#ifeq $#exec echo bla
$ $ bla
$
\#exec toegestaan
#anders
\#exec niet toegestaan
#stop als

Houd er echter rekening mee dat opmerkingen/tekenreeksen niet kunnen worden genest ("..." binnen $...$ zou gaan
onopgemerkt), dus je moet voorzichtig zijn met wat je in zo’n stilte moet opnemen
geëvalueerde tekenreeks. In dit voorbeeld is de losse meta-macro-nesting geïntroduceerd in versie 2.1
maakt het mogelijk om de volgende eenvoudigere versie te gebruiken:

#ifeq bla #exec echo -n bla
\#exec toegestaan
#anders
\#exec niet toegestaan
#stop als

Houd er rekening mee dat macro's zonder argumenten feitelijk als aliassen worden beschouwd, terwijl dat wel het geval is
aangeroepen met argumenten, zoals geïllustreerd door het volgende voorbeeld (standaard- of cpp-modus):

#define DUP(x) xx
#define FOO en ik zei: DUP
FOO(blah)

Het nut van de #defeval meta-macro wordt weergegeven in het volgende voorbeeld in HTML-modus:

<#define TOEPASSEN|<#defeval TEMP|<\##1 \#1>><#TEMP #2>>
<#define <#foo x>|<#x> en <#x>>
<#APPLY foo|BLAH>

De reden waarom #defeval Wat nodig is, is dat, aangezien alles in één keer wordt geëvalueerd,
de invoer die zal resulteren in de gewenste macro-oproep moet eerst worden gegenereerd
evaluatie van de argumenten die aan APPLY zijn doorgegeven voordat ze een tweede keer worden geëvalueerd.

Om dit voorbeeld in de standaardmodus te vertalen, moet je de volgorde tussen haakjes gebruiken
om de #defeval-aanroep binnen de definitie van APPLY te nesten, maar moet dit zonder doen
het uitvoeren van de haakjes. De eenvoudigste oplossing is

#define BALANS(x) x
#define APPLY(f,v) BALANS(#defeval TEMP f
TEMP (v))
#define foo(x) x en x
TOEPASSEN(\foo,BLAH)

Zoals hierboven uitgelegd, is de eenvoudigste versie in de cpp-modus afhankelijk van het definiëren van een stille evaluatie
string om de rol van de BALANCE-macro te spelen.

Het volgende voorbeeld (standaard- of cpp-modus) demonstreert de rekenkundige evaluatie:

#definieer x 4
Het antwoord is:
#eval x*x + 2*(16-x) + 1998%x

#indien gedefinieerd(x)&&!(3*x+5>17)
Dit zou output moeten zijn.
#stop als

Ter afsluiting volgen hier enkele voorbeelden van modusomschakeling. Het volgende voorbeeld is
spreekt voor zich (beginnend in de standaardmodus):

#mode-push
#define f(x) xx
#mode standaard tekst
\f{blah}
\mode{string}{"$" "$"}
\mode{commentaar}{"/*" "*/"}
$\f{urf}$ /* bla */
\define{FOO}{bar/* en nog wat */}
\mode{pop}
f($FOO$)

Een goed voorbeeld waarbij een door de gebruiker gedefinieerde modus nuttig kan zijn, is de GPP-bron van dit document
(beschikbaar bij de broncodedistributie van GPP).

Een andere interessante toepassing is het selectief afdwingen van de evaluatie van macro's in C-strings
in de cpp-modus. Neem bijvoorbeeld de volgende invoer:

#define blah(x) "en hij zei: x"
bla (foe)

Het is duidelijk dat je de parameter wilt hebben x uit te breiden binnen de string. Er zijn
verschillende manieren om dit probleem te omzeilen:

#mode-push
#mode nostring "\""
#define blah(x) "en hij zei: x"
#modepop

#mode citaat "`"
#define blah(x) `"en hij zei: x`"

#mode tekenreeks QQQ "$$" "$$"
#define blah(x) $$"en hij zei: x"$$

De eerste methode is heel natuurlijk, maar heeft het nadeel dat deze lang duurt
het neutraliseren van de tekenreekssemantiek, zodat er een niet-geëvalueerde instantie van 'x' in de
string, of het voorkomen van '/*', zou onmogelijk zijn zonder verder te gaan
verdraaiingen.

De tweede methode is iets efficiënter vanwege de lokale aanwezigheid van een quote
karakter maakt het gemakkelijker om te bepalen wat wordt geëvalueerd en wat niet, maar het heeft de
nadeel dat het soms onmogelijk is om zonder een redelijk citaatteken te vinden
het bronbestand aanzienlijk moeten wijzigen of insluiten in een #modus duwen/poppen
construeren. Elke keer dat '/*' in de tekenreeks voorkomt, moet bijvoorbeeld tussen aanhalingstekens worden geplaatst.

De laatste methode demonstreert de efficiëntie van geëvalueerde tekenreeksen in de context van
selectieve evaluatie: aangezien opmerkingen/tekenreeksen niet kunnen worden genest, wordt elke keer dat '"' of
'/*' binnen de '$$' krijgt uitvoer als platte tekst, zoals verwacht binnen een string, en alleen
macro-evaluatie is ingeschakeld. Merk ook op dat er veel meer vrijheid is in de keuze van een
tekenreeksscheidingsteken dan bij de keuze van een aanhalingsteken.

Vanaf versie 2.1 kunnen meta-macro-aanroepen efficiënter worden genest in de standaard cpp
en Prolog-modi. Dit maakt het gemakkelijk om een ​​gebruikersversie van een meta-macro te maken, of om
een teller verhogen:

#define myeval #eval #1

#definieer x 1
#defeval x #eval x+1

ADVANCED Voorbeelden

Hier zijn enkele voorbeelden van geavanceerde constructies waarbij gebruik wordt gemaakt van GPP. Ze zijn vaak nogal onhandig
en moet worden beschouwd als bewijs van de beperkingen van GPP.

Het eerste voorbeeld is een recursieve macro. Het voornaamste probleem is dat (aangezien GPP evalueert
alles) moet een recursieve macro heel voorzichtig zijn met de manier waarop recursie plaatsvindt
beëindigd om ongedefinieerd gedrag te voorkomen (meestal crasht GPP gewoon).
Met name een beroep op a #if/#else/#endif constructie om recursie te beëindigen is niet mogelijk
en resulteert in een oneindige lus, omdat GPP gebruikersmacro-oproepen zelfs in de
niet-geëvalueerde tak van het voorwaardelijke blok. Een veilige manier om verder te gaan is bijvoorbeeld als
volgt (we geven het voorbeeld in TeX-modus):

\definieer{aftellen}{
\als{#1}
#1...
\define{loop}{\countdown}
\anders
Gereed.
\definieer{loop}{}
\stop als
\loop{\eval{#1-1}}
}
\aftellen{10}

Nog een voorbeeld, in cpp-modus:

#mode tekenreeks QQQ "$" "$"
#definieer driehoek(x,y) y \
$#als lengte(y)
$#define iter$ $#endif
$ iter(x,*y)
driehoek(20)

Het volgende is een (helaas zeer zwakke) poging om functioneel te implementeren
abstractie in GPP (in standaardmodus). Dit voorbeeld begrijpen en waarom het niet kan worden gemaakt
veel eenvoudiger is een oefening die aan de nieuwsgierige lezer wordt overgelaten.

#mode tekenreeks "`" "`" "\\"
#define ASIS(x) x
#define SILENT(x) ASIS()
#define EVAL(x,f,v) STIL(
#mode tekenreeks QQQ "`" "`" "\\"
#defeval TEMP0 x
#defeval TEMP1 (
\#define \TEMP2(TEMP0) f
)
TEMP1
)TEMP2(v)
#define LAMBDA(x,f,v) STIL(
#ifneq (v) ()
#define TEMP3(a,b,c) EVAL(a,b,c)
#anders
#define TEMP3(a,b,c) \LAMBDA(a,b)
#stop als
)TEMP3(x,f,v)
#define EVALAMBDA(x,y) STIL(
#defeval TEMP4 x
#defeval TEMP5 j
)
#define TOEPASSEN(f,v) STIL(
#defeval TEMP6 ASIS(\EVA)f
TEMP6
)EVAL(TEMP4,TEMP5,v)

Dit levert de volgende resultaten op:

LAMBDA(z,z+z)
=> LAMBDA(z,z+z)

LAMBDA(z,z+z,2)
=> 2+2

#define f LAMBDA(y,y*y)
f
=> LAMBDA(y,y*y)

TOEPASSEN(f, bla)
=> bla*bla

TOEPASSEN(LAMBDA(t,tt),(tt))
=> (tt) (tt)

LAMBDA(x,TOEPASSEN(f,(x+x)),urf)
=> (urf+urf)*(urf+urf)

TOEPASSEN(TOEPASSEN(LAMBDA(x,LAMBDA(y,x*y)),foo),bar)
=> foo*bar

#define test LAMBDA(y,`#ifeq y urf
y is urf#else
y is niet urf#endif
`)
TOEPASSEN(test,urf)
=> urf is urf

TOEPASSEN(test,foo)
=> foo is geen urf

Gebruik gpp online met behulp van onworks.net-services