gpp - Online nel cloud

PROGRAMMA:

NOME

GPP - Preprocessore generico

SINOSSI

gpp [-{o|O} file di uscita] [-IO/include/percorso] [-Dnome=valore ...]
[-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] [--warninglevel n]
[--includemarker str] [--includere filetto]
[infilare]

gpp --aiuto

gpp --versione

DESCRIZIONE

GPP è un preprocessore generico con sintassi personalizzabile, adatto a un'ampia gamma
dei compiti di pre-elaborazione. La sua indipendenza da qualsiasi linguaggio di programmazione lo rende molto di più
versatile di cpp, mentre la sua sintassi è più leggera e flessibile di quella di m4.

GPP è mirato a tutte le comuni attività di pre-elaborazione in cui cpp non è adatto e dove no
sono necessarie funzionalità molto sofisticate. Per poter elaborare in modo altrettanto efficiente
file di testo o codice sorgente in una varietà di lingue, la sintassi utilizzata da GPP è completamente
personalizzabile. La gestione dei commenti e delle stringhe è particolarmente avanzata.

Inizialmente, GPP comprende solo un insieme minimo di macro integrate, chiamate meta-macro.
Queste meta-macro consentono la definizione di Utente macro così come alcune operazioni di base
che costituiscono il nucleo del sistema di pre-elaborazione, compresi i test condizionali, l'aritmetica
valutazione, corrispondenza con caratteri jolly (globbing) e specifica della sintassi. Tutte le macro utente
le definizioni sono globali - vale a dire, restano validi fino a quando non vengono esplicitamente rimossi; meta-macro
non può essere ridefinito. Con ogni definizione di macro utente, GPP tiene traccia della corrispondente
specifica della sintassi in modo che una macro possa essere invocata in sicurezza indipendentemente da qualsiasi successiva
cambio di modalità di funzionamento.

Oltre alle macro, GPP comprende commenti e stringhe, la cui sintassi e comportamento possono
essere ampiamente personalizzato per adattarsi a qualsiasi scopo particolare. Internamente i commenti e le stringhe sono
la stessa costruzione, quindi tutto ciò che si applica ai commenti si applica anche alle stringhe.

VERSIONI

GPP riconosce le seguenti opzioni e opzioni della riga di comando. Nota che -nostdinc,
Opzioni -nocurinc, -curdirinclast, -warninglevel e -includemarker dalla versione 2.1 e
precedenti sono deprecati e non devono essere utilizzati. Usa invece le varianti "opzione lunga"
(--nostdin, ecc.).

-h --Aiuto
Stampa un breve messaggio di aiuto.

--versione
Stampa le informazioni sulla versione.

-o file di uscita
Specifica un file a cui inviare tutto l'output (per impostazione predefinita, viene inviato tutto
all'uscita standard).

-O file di uscita
Specificare un file a cui inviare tutto l'output; l'output viene inviato contemporaneamente a
normale.

-I/include/percorso
Specificare un percorso in cui il #includere meta-macro cercherà i file include se lo fanno
non sono presenti nella directory corrente. L'impostazione predefinita è / usr / include se no -io
l'opzione è specificata. È possibile specificare più opzioni -I per cercare in diverse
directory.

-Dnome=valore
Definire la macro utente Nome come uguale a val. Questo è strettamente equivalente a usare
, il #define meta-macro, ma permette di definire macro dal comando-
linea. Se val fa riferimento ad argomenti o altre macro, dovrebbe essere conforme a
la sintassi della modalità specificata nella riga di comando. A partire dalla versione 2.1,
la denominazione degli argomenti macro è consentita sulla riga di comando. La sintassi è la seguente:
-Dmacro(arg1,...)=definizione. Gli argomenti sono specificati nella sintassi in stile C,
senza spazi bianchi, ma la definizione dovrebbe comunque essere conforme alla sintassi di
la modalità specificata nella riga di comando.

+z Imposta la modalità testo sulla modalità Unix (terminatore LF). Qualsiasi carattere CR nell'input è
sistematicamente scartato. Questa è l'impostazione predefinita nei sistemi Unix.

-z Imposta la modalità testo sulla modalità DOS (terminatore CR-LF). In questa modalità tutti i caratteri CR sono
rimosso dall'input e tutti i caratteri LF di output vengono convertiti in CR-LF. Questo
è l'impostazione predefinita se GPP è compilato con l'opzione WIN_NT.

-x Abilita l'uso del #esecutivo meta-macro. Da quando #esecutivo include l'output di an
riga di comando della shell arbitraria, può causare una potenziale minaccia alla sicurezza ed è quindi
disabilitato a meno che questa opzione non sia specificata.

-m Abilita il passaggio dalla modalità automatica alla modalità di compatibilità cpp se il nome di an
il file incluso termina con ".h" o ".c". Ciò rende possibile includere l'intestazione C
file con solo piccole modifiche.

-n Impedisci la rimozione di caratteri di nuova riga o spazi bianchi dall'input quando
si verificano alla fine di una chiamata macro o di un commento. Per impostazione predefinita, quando una nuova riga
o il carattere di spazio bianco forma la fine di una macro o di un commento che viene analizzato come parte
della chiamata o del commento della macro e quindi rimosso dall'output. Usa l'opzione -n
per mantenere l'ultimo carattere nel flusso di input se era uno spazio bianco o una nuova riga.
Questo è attivato nelle modalità cpp e Prolog.

+n L'opposto di -n. Questa è l'impostazione predefinita in tutte le modalità eccetto cpp e Prolog. Nota
che +n deve essere posizionato dopo -C o -P per avere qualsiasi effetto.

-U arg1 ... arg9
Modalità definita dall'utente. I nove seguenti argomenti della riga di comando sono considerati
rispettivamente la sequenza di inizio macro, la sequenza di fine macro per una chiamata senza
argomenti, la sequenza di inizio dell'argomento, il separatore di argomenti, la fine dell'argomento
sequenza, l'elenco di caratteri da impilare per il bilanciamento degli argomenti, l'elenco di
caratteri da separare, la stringa da usare per fare riferimento a un argomento di
numero e infine il carattere di virgoletta (se non ce n'è uno dovrebbe essere una stringa vuota
fornito). Queste impostazioni si applicano sia alle macro utente che alle meta-macro, a meno che il
L'opzione -M viene utilizzata per definire altre impostazioni per le meta-macro. Vedi la sezione su
specifica della sintassi per maggiori dettagli.

-M arg1 ... arg7
Specifiche della modalità definita dall'utente per le meta-macro. Questa opzione può essere utilizzata solo
insieme a -M. I sette seguenti argomenti della riga di comando sono considerati
rispettivamente la sequenza di inizio macro, la sequenza di fine macro per una chiamata senza
argomenti, la sequenza di inizio dell'argomento, il separatore di argomenti, la fine dell'argomento
sequenza, l'elenco di caratteri da impilare per il bilanciamento degli argomenti e l'elenco di
caratteri da separare. Vedi sotto per ulteriori dettagli.

(predefinito modalità)
La modalità predefinita è vagamente simile a cpp, ma non gestisce i commenti e
presenta diverse incompatibilità con cpp. Tipiche meta-macro e macro utente
simile a questa:

#definire xy
macro(argomento,...)

Questa modalità è equivalente a

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

-C modalità di compatibilità cpp. Questa è la modalità in cui il comportamento di GPP è il più vicino a
quello di cpp. A differenza della modalità predefinita, l'espansione meta-macro avviene solo al
l'inizio delle righe e i commenti e le stringhe in C sono compresi. Questa modalità è
equivalente

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

-T Modalità simile a TeX. In questa modalità, le meta-macro tipiche e le macro utente hanno il seguente aspetto:

\definisci{x}{y}
\macro{argo}{...}

Nessun commento è compreso. Questa modalità è equivalente a

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

-H Modalità simile a HTML. In questa modalità, le meta-macro tipiche e le macro utente hanno il seguente aspetto:

<#definisci x|y>
<#macro argomento|...>

Nessun commento è compreso. Questa modalità è equivalente a

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

-X Modalità simile a XHTML. In questa modalità, le meta-macro tipiche e le macro utente hanno il seguente aspetto:

<#define x|y/>
<#macro argomento|.../>

Nessun commento è compreso. Questa modalità è equivalente a

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

-P Modalità simile a cpp compatibile con Prolog. Questa modalità è diversa dalla modalità di compatibilità cpp
dalla sua gestione dei commenti, ed è equivalente a

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

+c str1 str2
Specificare commenti. Qualsiasi occorrenza non quotata di str1 sarà interpretato come il
inizio di un commento. Tutti gli input fino alla prima occorrenza successiva di str2 volere
essere scartato. Questa opzione può essere utilizzata più volte per specificare diversi tipi di
delimitatori di commento. Il parametro opzionale può essere specificato per modificare il
comportamento del commento e, per esempio, trasformalo in una stringa o fallo ignorare sotto
determinate circostanze, vedi sotto.

-c str1
Deselezionare commenti o stringhe. La specifica del commento/stringa il cui inizio
la sequenza è str1 è rimosso. Questo è utile per modificare il commento integrato
specifiche di una modalità standard -- per esempio, la modalità di compatibilità cpp.

+s str1 str2 c
Specifica le stringhe. Qualsiasi occorrenza non quotata di str1 sarà interpretato come il
inizio di una stringa. Tutti gli input fino alla prima occorrenza successiva di str2 volere
essere emesso così com'è senza alcuna valutazione. Vengono emessi i delimitatori stessi. Se c
non è vuoto, il suo primo carattere è usato come a citazione di stringa carattere -- vale a dire, un
personaggio la cui presenza immediatamente prima del verificarsi di str2 glielo impedisce
terminare la stringa. Il parametro opzionale può essere specificato per modificare il
comportamento della stringa e, per esempio, trasformalo in un commento, abilita la valutazione macro
all'interno della stringa, o fare in modo che la specifica della stringa venga ignorata in determinate condizioni
circostanze. Vedi sotto.

-s str1
Deselezionare commenti o stringhe. Identico a -c.

--includere filetto
Processo filetto prima infilare

--nostdin
Non cercare i file include nella directory standard /usr/include.

--nocurinc
Non cercare file di inclusione nella directory corrente.

--curdirinclast
Cerca i file di inclusione nella directory corrente dopo le directory specificate da
-I piuttosto che prima di loro.

--livello di avviso n
Imposta il livello di avviso su n (0, 1 o 2). Il valore predefinito è 2 (il più dettagliato).

--includemarker str
tenere traccia di #includere direttive inserendo un marker nel flusso di output. Il
il formato del marker è determinato da str, che deve contenere tre occorrenze di
il personaggio % (o equivalentemente ?). La prima occorrenza viene sostituita con la linea
numero, il secondo con il nome del file e il terzo con 1, 2 o vuoto. Quando questo
l'opzione è specificata in modalità predefinita, cpp o Prolog, GPP fa del suo meglio per garantire
che i numeri di riga siano gli stessi nell'output come nell'input inserendo uno spazio vuoto
righe al posto di definizioni o commenti.

infilare Specificare un file di input da cui GPP legge il suo input. Se nessun file di input è
specificato, l'input viene letto dall'input standard.

SINTASSI SPECIFICHE

La sintassi di una chiamata di macro è la seguente: deve iniziare con una sequenza di caratteri
abbinando il macro inizia a sequenza come specificato nella modalità corrente, seguito immediatamente
dal nome della macro, che deve essere un valido identificatore -- vale a dire, una sequenza di lettere,
cifre o trattini bassi ("_"). Il nome della macro deve essere seguito da a corto macro fine
sequenza se la macro non ha argomenti, o da una sequenza di argomenti iniziata da an
argomento inizia a sequenza. I vari argomenti sono poi separati da an argomento
separatore, e la macro termina con a lungo macro fine sequenza.

In tutti i casi, i parametri del contesto attuale -- vale a dire, gli argomenti passati al
corpo in fase di valutazione - si può fare riferimento utilizzando an argomento riferimento sequenza
seguito da una cifra tra 1 e 9. In alternativa, i parametri macro possono essere nominati (vedi
sotto). Inoltre, per evitare interferenze tra la sintassi GPP e il contenuto del
file di input, a citare carattere è fornito. Il carattere di citazione può essere utilizzato per evitare che
interpretazione di una chiamata di macro, commento o stringa come tutto tranne che come testo normale. La citazione
carattere "protegge" il carattere successivo e viene sempre rimosso durante la valutazione.
Due virgolette consecutive vengono valutate come un singolo carattere di virgolette.

Infine, per facilitare una corretta delimitazione degli argomenti, alcuni caratteri possono essere "impilati"
quando si verificano in un argomento macro, in modo che il separatore di argomenti o la sequenza finale della macro
non vengono analizzati se il corpo dell'argomento non è bilanciato. Ciò consente di nidificare le chiamate di macro
senza usare le virgolette. Se è necessario un argomento bilanciato in modo improprio, virgolette caratteri
dovrebbe essere aggiunto davanti ad alcuni personaggi impilati per renderlo bilanciato.

Le sequenze di costruzione delle macro descritte sopra possono essere diverse per le meta-macro e per
macro utente: è il caso, ad esempio, della modalità cpp. Nota che, poiché le meta-macro possono
avere solo fino a due argomenti, le regole di delimitazione per il secondo argomento sono in qualche modo
sequenze di separatori di argomenti più sciatte e senza virgolette sono consentite nel secondo argomento di
una meta-macro.

A meno che non sia selezionata una delle modalità operative standard, le sequenze di sintassi di cui sopra possono essere
specificato sulla riga di comando, utilizzando rispettivamente le opzioni -M e -U per meta-
macro e macro utente, o all'interno di un file di input tramite il #modalità arrivo ed #modalità Utente meta-
chiamate macro. In entrambi i casi la descrizione della modalità è composta da nove parametri per l'utente
specifiche macro, ovvero la sequenza di inizio macro, la sequenza di fine macro breve, il
sequenza di inizio dell'argomento, il separatore di argomenti, la sequenza di fine della macro lunga, la stringa
elencare i caratteri da impilare, la stringa elencare i caratteri da smontare, l'argomento
sequenza di riferimento e infine il carattere di citazione. Come spiegato di seguito, queste sequenze
deve essere fornito utilizzando la sintassi delle stringhe C; devono iniziare con un carattere non alfanumerico
carattere, e nelle prime cinque stringhe possono essere usate sequenze di corrispondenza speciali (vedi
sotto). Se l'argomento corrispondente al carattere di virgoletta è la stringa vuota, questo
la funzionalità dell'argomento è disabilitata. Per le specifiche meta-macro ce ne sono solo sette
parametri, poiché la sequenza di riferimento dell'argomento e il carattere di citazione sono condivisi con
sintassi della macro utente.

La struttura di un commento/stringa è la seguente: deve iniziare con una sequenza di
caratteri corrispondenti al dato commento/stringa inizia a sequenza, e finisce sempre alla prima
occorrenza del commento/stringa fine sequenza, a meno che non sia preceduto da un numero dispari di
occorrenze del citazione di stringa carattere (se è stato specificato tale carattere). In
in alcuni casi è possibile specificare commenti/stringhe per abilitare la valutazione macro all'interno del
commento/stringa; in tal caso, se è stata definita una virgoletta per le macro, può essere
usato anche per evitare che il commento/stringa finisca, con la differenza che la macro
il carattere di citazione viene sempre rimosso dall'output mentre il carattere di virgolette è sempre
produzione. Si noti inoltre che in determinate circostanze una specifica di commento/stringa può essere
disabile, nel qual caso la sequenza di inizio di commento/stringa viene semplicemente ignorata. Infine, è
è possibile specificare a stringa identificazione dei warning carattere la cui presenza all'interno di un commento/stringa
farà in modo che GPP emetta un avviso (utile per individuare stringhe non terminate in cpp
modalità). Nota che i file di input non possono contenere commenti/stringhe non terminati.

Una specifica di commento/stringa può essere dichiarata dall'interno del file di input usando il #modalità
commento chiamata meta-macro (o equivalente #modalità stringa), nel qual caso il numero di C
le stringhe da fornire come argomenti per descrivere il commento/stringa possono essere ovunque tra
due e quattro: i primi due argomenti (obbligatori) sono la sequenza di inizio e la fine
sequenza e può fare uso delle sequenze di corrispondenza speciali (vedi sotto). potrebbero non
iniziare con caratteri alfanumerici. Il primo carattere del terzo argomento, se presente
uno, è usato come carattere di virgolette (usa una stringa vuota per disabilitare il
funzionalità) e viene utilizzato il primo carattere del quarto argomento, se presente
come carattere di avviso di stringa. Una specifica può anche essere fornita dalla riga di comando,
in tal caso devono esserci due argomenti se si usa l'opzione +c e tre se si usa +s
opzione.

Il comportamento di un commento/stringa è specificato da una stringa di modifica di tre caratteri, che
può essere passato come argomento opzionale alle opzioni della riga di comando +c/+s o al
#modalità commento/#modalità stringa meta-macro. Se non viene specificata alcuna stringa di modifica, il valore predefinito
il valore è "ccc" per i commenti e "sss" per le stringhe. Il primo carattere corrisponde al
comportamento all'interno delle chiamate meta-macro (incluse le definizioni utente-macro poiché queste vengono all'interno)
a #define meta-macro call), il secondo carattere corrisponde al comportamento all'interno dell'utente-
parametri macro, e il terzo carattere corrisponde al comportamento al di fuori di qualsiasi macro
chiamata. Ciascuno di questi caratteri può assumere i seguenti valori:

i disabilita la specifica di commento/stringa.

c commento (né valutato né prodotto).

s string (la stringa e le sue sequenze di delimitatori vengono emesse così come sono).

q stringa tra virgolette (la stringa viene emessa così com'è, senza le sequenze di delimitatori).

C commento valutato (le macro vengono valutate, ma l'output viene scartato).

S stringa valutata (le macro vengono valutate, i delimitatori vengono emessi).

Q stringa tra virgolette valutata (le macro vengono valutate, i delimitatori non vengono emessi).

Nota importante: qualsiasi occorrenza di una sequenza di inizio di un commento/stringa all'interno di un'altra
commento/stringa viene sempre ignorato, anche se è abilitata la valutazione macro. In altre parole,
commenti/stringhe non possono essere nidificati. In particolare, il modificatore `Q' può essere un modo conveniente
di definire una sintassi per disabilitare temporaneamente tutti i commenti e le specifiche di stringa.

Le stringhe di specifica della sintassi dovrebbero sempre essere fornite come stringhe C, indipendentemente dal fatto che lo siano
dati come argomenti ad a #modalità chiamata meta-macro o sulla riga di comando di una shell Unix. Se
gli argomenti della riga di comando vengono forniti tramite un metodo diverso da una shell Unix standard, quindi
il comportamento della shell deve essere emulato -- vale a dire, le virgolette "" circostanti dovrebbero essere rimosse, tutto
le occorrenze di `\\' dovrebbero essere sostituite da una singola barra rovesciata e, allo stesso modo, `\"' dovrebbe essere
sostituito da `"'. Sequenze come `\n' sono riconosciute da GPP e dovrebbero essere lasciate così come sono.

È possibile utilizzare sequenze speciali che corrispondono a determinati sottoinsiemi del set di caratteri. sono di
il modulo `\x', dove x è uno di:

b corrisponde a qualsiasi sequenza di uno o più spazi o caratteri di tabulazione (`\b'èidentico a
` ').

w corrisponde a qualsiasi sequenza di zero o più spazi o caratteri di tabulazione.

B corrisponde a qualsiasi sequenza di uno o più spazi, tabulazioni o caratteri di nuova riga.

W corrisponde a qualsiasi sequenza di zero o più spazi, tabulazioni o caratteri di nuova riga.

a un carattere alfabetico (da `a' a `z' e da `A' a `Z').

A un carattere alfabetico, uno spazio, un tab o una nuova riga.

# una cifra (da `0' a `9').

i un carattere identificativo. Il set di caratteri abbinati è personalizzabile utilizzando il
#modalità set di caratteri id comando. L'impostazione predefinita corrisponde a caratteri alfanumerici e
trattini bassi (da `a' a `z', da `A' a `Z', da `0' a `9' e `_').

t un carattere di tabulazione.

n un carattere di nuova riga.

o un carattere operatore. Il set di caratteri abbinati è personalizzabile utilizzando il
#modalità set di caratteri op comando. L'impostazione predefinita corrisponde a tutti i caratteri in
"+-*/\^<>=`~:.?@#&!%|", eccetto in modalità Prolog dove `!', `%' e `|' non sono
abbinato.

O un carattere operatore o un carattere parentesi. Il set di ulteriori abbinati
caratteri in confronto a `\o' è personalizzabile utilizzando il #modalità set di caratteri da
comando. L'impostazione predefinita prevede che i caratteri tra "()[]{}" siano tra parentesi.

Inoltre, tutti questi sottoinsiemi corrispondenti eccetto `\w' e `\W' possono essere negati inserendo a
`!' -- vale a dire, scrivendo `\!x' invece di `\x'.

Notare un'importante caratteristica distintiva di inizia a sequenze: quando il primo carattere di a
la sequenza di inizio della macro o del commento/stringa è ' ' o una delle sequenze speciali di cui sopra, è
non viene considerato parte della sequenza stessa ma viene invece utilizzato come controllo del contesto: for
esempio una sequenza di inizio che inizia con '\n' corrisponde solo all'inizio di una riga, ma
il carattere di nuova riga corrispondente non viene considerato parte della sequenza. Allo stesso modo un inizio
sequenza che inizia con ' ' corrisponde solo se è presente uno spazio bianco, ma la corrispondenza
lo spazio bianco non è considerato parte della sequenza di avvio e viene quindi inviato a
produzione. Se viene eseguito un controllo del contesto all'inizio di un file (o più in generale
di qualsiasi corpo da valutare), il risultato è lo stesso della corrispondenza con un carattere di nuova riga
(questo rende possibile l'avvio di un file in modalità cpp con una chiamata meta-macro).

Nella versione 2.1 sono state aggiunte due regole speciali di sintassi. Innanzitutto, i riferimenti agli argomenti (#n) non sono
più valutati quando sono al di fuori di chiamate e definizioni di macro. Tuttavia, sono
non è più consentito apparire (a meno che non sia protetto da virgolette) all'interno di una chiamata a a
macro utente definita; il comportamento attuale (compatibile con le versioni precedenti) è rimuoverli silenziosamente
dall'input se ciò accade.

In secondo luogo, se la sequenza finale (sia per le macro che per i commenti) consiste in una singola nuova riga
carattere, e se le regole di delimitazione portano alla valutazione in un contesto in cui il finale
il carattere newline è assente, GPP ignora silenziosamente il newline mancante invece di produrre
un errore. La conseguenza principale è che le chiamate meta-macro possono ora essere nidificate in modo semplice
nelle modalità standard, cpp e Prolog.

VALUTAZIONE REGOLE

L'input viene letto in sequenza e interpretato secondo le regole della modalità corrente. Tutto
il testo di input viene prima confrontato con le sequenze di inizio stringa/commento specificate del
modalità corrente (eccetto quelli che sono disabilitati dal modificatore 'i'), a meno che il corpo non sia
valutato è il contenuto di un commento/stringa il cui modificatore consente la valutazione della macro.
Vengono controllate per prime le specifiche di commento/stringa definite più di recente. Importante
nota: i commenti potrebbero non apparire tra il nome di una macro e i suoi argomenti (in questo modo
comporta un comportamento indefinito).

Tutto ciò che non è un commento/stringa viene quindi confrontato con una possibile chiamata meta-macro,
e se anche questo fallisce, contro una possibile chiamata macro utente. Tutto il testo rimanente subisce
sostituzione delle sequenze di riferimento dell'argomento con il testo dell'argomento pertinente (vuoto a meno che
il corpo che si sta valutando è la definizione di una macro utente) e la rimozione della citazione
carattere se ce n'è uno.

Nota che gli argomenti della meta-macro vengono passati alla meta-macro prima di qualsiasi valutazione
(sebbene la meta-macro possa scegliere di valutarli, vedere le descrizioni delle meta-macro sotto).
Nel caso della #modalità meta-macro, GPP aggiunge temporaneamente una specifica di commento/stringa
per consentire il riconoscimento delle stringhe C ("...") e impedire qualsiasi valutazione al loro interno, quindi no
interferenza dei caratteri inseriti negli argomenti della stringa C a #modalità con la
la sintassi attuale è da temere.

D'altra parte, gli argomenti di una macro utente vengono valutati sistematicamente e quindi
passati come parametri di contesto al corpo della definizione della macro, che viene valutato con quello
ambiente. L'unica eccezione è quando la definizione della macro è vuota, nel qual caso è
gli argomenti non vengono valutati. Nota che GPP torna temporaneamente alla modalità in cui
la macro è stata definita per valutarla, quindi è perfettamente sicuro cambiare il
modalità operativa tra il momento in cui viene definita una macro e il momento in cui viene chiamata.
Al contrario, se una macro utente desidera lavorare con la modalità corrente invece di quella che
è stato usato per definirlo deve iniziare con a #modalità ripristinare chiama e termina con a #modalità
salvare chiamata.

Una macro utente può essere definita con argomenti denominati (vedi #define descrizione sotto). In ciò
caso, quando viene valutata la definizione della macro, ogni parametro denominato provoca un
definizione temporanea della macro utente virtuale da creare; una tale macro può essere chiamata solo
senza argomenti e restituisce semplicemente il testo dell'argomento corrispondente.

Nota che, poiché le macro vengono valutate quando vengono chiamate piuttosto che quando lo sono
definito, qualsiasi tentativo di chiamare una macro ricorsiva causa un comportamento indefinito tranne che nel
caso molto specifico quando la macro usa #indif cancellarsi dopo un numero finito di loop
iterazioni.

Infine, un caso particolare si verifica quando una macro utente la cui definizione non comporta alcuna
argomenti (né gli argomenti denominati né la sequenza di riferimento degli argomenti) viene chiamato in a
modalità in cui la breve sequenza finale della macro utente è vuota (per esempio, cpp o modalità TeX). In ciò
caso si presume che sia an alias macro: i suoi argomenti vengono valutati prima nella corrente
mode come al solito, ma invece di essere passati alla definizione della macro come parametri (che
li farebbe scartare) sono effettivamente aggiunti alla definizione della macro,
utilizzando le regole di sintassi della modalità in cui è stata definita la macro e il testo risultante
viene nuovamente valutato. È quindi importante notare che, nel caso di un macro alias,
gli argomenti vengono effettivamente valutati due volte in due modalità potenzialmente diverse.

META-MACRO

Queste macro sono sempre predefinite. La loro effettiva sequenza di chiamate dipende dalla corrente
modalità; qui usiamo la notazione simile a cpp.

#define x y
Questo definisce la macro utente x as y. y può essere qualsiasi input GPP valido e può per
esempio fare riferimento ad altre macro. x deve essere un identificatore (vale a dire, una sequenza di
caratteri alfanumerici e '_'), a meno che non vengano specificati argomenti denominati. Se x is
già definita, la definizione precedente viene sovrascritta. Se nessun secondo argomento è
dato, x sarà definito come una macro che non restituisce nulla. Nessuno dei due x né y sono
valutato; la definizione della macro viene valutata solo quando viene chiamata, non quando lo è
dichiarato.

È anche possibile nominare gli argomenti in una definizione di macro: in tal caso, il
argomento x dovrebbe essere una macro chiamata utente i cui argomenti sono tutti identificatori. Queste
gli identificatori diventano disponibili come macro utente all'interno della definizione della macro; queste
le macro virtuali devono essere chiamate senza argomenti e valutate al corrispondente
parametro macro.

#defeval x y
Questo agisce in modo simile a #define, ma il secondo argomento y viene valutato
subito. Poiché anche le definizioni delle macro utente vengono valutate ogni volta che lo sono
chiamato, questo significa che la macro y subirà seconda valutazioni successive. Il
utilità di #defeval è considerevole in quanto è l'unico modo per valutare qualcosa
più di una volta, che può essere necessario per forzare la valutazione degli argomenti di un meta-
macro che normalmente non esegue alcuna valutazione. Tuttavia, poiché tutti gli argomenti
i riferimenti valutati al momento della definizione sono intesi come gli argomenti del corpo in
quale la macro viene definita e non come gli argomenti della macro stessa,
di solito si deve usare il carattere di citazione per evitare una valutazione immediata di
riferimenti argomentativi.

#indif x
Questo rimuove qualsiasi definizione esistente della macro utente x.

#ifdef x
Questo inizia un blocco condizionale. Tutto ciò che segue viene valutato solo se il
identificatore x è definito, e fino a quando a #else o #endif l'affermazione è raggiunta.
Nota, tuttavia, che il testo commentato viene ancora scansionato accuratamente, quindi la sua sintassi
Deve essere valido. In particolare è legale avere il #else or #endif dichiarazione
la fine del blocco condizionale appare solo come risultato di un'espansione della macro utente
e non esplicitamente nell'input.

#ifndef x
Questo inizia un blocco condizionale. Tutto ciò che segue viene valutato solo se il
identificatore x non è definito.

#ifeq x y
Questo inizia un blocco condizionale. Tutto ciò che segue viene valutato solo se il
risultati delle valutazioni di x ed y sono identici alle stringhe di caratteri. Qualunque
gli spazi iniziali o finali vengono ignorati per il confronto. Nota che in modalità cpp
qualsiasi carattere di spazio bianco senza virgolette è inteso come la fine del primo argomento,
quindi è necessario stare attenti.

#se neq x y
Questo inizia un blocco condizionale. Tutto ciò che segue viene valutato solo se il
risultati delle valutazioni di x ed y non sono identici (anche fino al primo o
spazi bianchi finali).

#else Questo alterna il valore logico del blocco condizionale corrente. Quello che segue è
valutato se e solo se l'input precedente è stato commentato.

#endif Questo termina un blocco condizionale iniziato da a #Se... meta-macro.

#includere filetto
Questo fa sì che GPP apra il file specificato e ne valuti il ​​contenuto, inserendo il
testo risultante nell'output corrente. Tutte le macro utente definite sono ancora disponibili
nel file incluso e reciprocamente tutte le macro definite nel file incluso lo faranno
essere disponibile in tutto ciò che segue. Il file di inclusione viene cercato per primo in
la directory corrente, e poi, se non trovata, in una delle directory specificate
dal -I opzione della riga di comando (o / usr / include se non è stata specificata alcuna directory).
Nota che, per motivi di compatibilità, è possibile inserire il nome del file tra
"" o <>.

L'ordine in cui vengono cercati i file include nelle varie directory è
influenzato dal -nostdin, -nocurinc ed -curdirinclasta opzioni della riga di comando.

Dopo aver incluso un file, GPP salva immediatamente una copia della modalità operativa corrente
nello stack delle modalità, e ripristina la modalità operativa alla fine dell'incluso
file. Il file incluso può sovrascrivere questo comportamento iniziando con a #modalità ripristinare
chiama e termina con a #modalità spingere chiamata. Inoltre, quando il -m riga di comando
specificata, GPP passerà automaticamente alla modalità di compatibilità cpp
includendo un file il cui nome termina con '.c' o '.h'.

#esecutivo command
Ciò fa sì che GPP esegua la riga di comando specificata e includa il suo standard
uscita nell'uscita corrente. Nota che, per motivi di sicurezza, questa meta-macro è
disabilitato a meno che non -x è stato specificato il flag della riga di comando. Se l'uso di #esecutivo non è
consentito, viene stampato un messaggio di avviso e l'output viene lasciato vuoto. Nota che il
la riga di comando specificata viene valutata prima di essere eseguita, consentendo così l'uso di
macro nella riga di comando. Tuttavia, l'output del comando è incluso letteralmente
e non valutato. Se è necessario che l'output venga valutato, è necessario utilizzare #defeval
(vedi sopra) per provocare una doppia valutazione.

#valutazione espr
I #valutazione meta-macro tenta di valutare espr prima espandendo le macro (normale
valutazione GPP) e quindi eseguendo la valutazione aritmetica e/o il carattere jolly
corrispondenza. La sintassi e la precedenza degli operatori per le espressioni aritmetiche sono i
come in C; gli unici operatori mancanti sono <<, >>, ?:, e l'assegnamento
gli operatori.

La corrispondenza con caratteri jolly in stile POSIX ("globbing") è disponibile solo su POSIX
implementazioni e può essere invocato con l'operatore =~. In breve, un '?' partite
qualsiasi singolo carattere, un '*' corrisponde a qualsiasi stringa (inclusa la stringa vuota), e
'[...]' corrisponde a uno qualsiasi dei caratteri racchiusi tra parentesi. Una classe '[...]' è
completato quando il primo carattere tra parentesi quadre è '!'. I personaggi in a
La classe '[...]' può anche essere specificata come un intervallo usando il carattere '-' -- per esempio,
'[FN]' è equivalente a '[FGHIJKLMN]'.

Se non è possibile assegnare un valore numerico al risultato, il testo restituito è semplicemente
il risultato di un'espansione macro senza alcuna valutazione aritmetica. Il solo
eccezioni a questa regola sono gli operatori di confronto ==, !=, <, >, <= e >=
che, se uno dei lati non restituisce un numero, esegue il confronto di stringhe
invece (ignorando gli spazi finali e iniziali). Inoltre, il lunghezza(...)
L'operatore aritmetico restituisce la lunghezza in caratteri del suo argomento valutato.

All'interno di espressioni aritmetiche, il definito(...) anche la macro utente speciale
disponibile: prende solo un argomento, che non viene valutato, e restituisce 1 se lo è
è il nome di una macro utente e 0 altrimenti.

#Se espr
Questa meta-macro richiama il valutatore aritmetico/globale nello stesso modo di
#valutazione e confronta il risultato della valutazione con la stringa "0" per iniziare a
blocco condizionale. In particolare si noti che il valore logico di espr è sempre vero
quando non può essere valutato come un numero.

#elif espr
Questa meta-macro può essere utilizzata per evitare l'annidamento #Se condizioni. #Se ... #elif ...
#endif è equivalente #Se ... #else #Se ... #endif #endif.

#modalità parola chiave ...
Questa meta-macro controlla la modalità operativa di GPP. Vedi sotto per un elenco di #modalità
comandi.

#linea Questa meta-macro valuta il numero di riga del file di input corrente.

#filetto Questa meta-macro valuta il nome del file di input corrente come appare
sulla riga di comando o nell'argomento to #includere. Se GPP sta leggendo il suo input
da stdin, quindi #filetto restituisce `stdin'.

#Data FMT
Questa meta-macro valuta la data e l'ora correnti come formattate dal
stringa di formato specificata FMT. Vedi la sezione DATA E ORARIO CONVERSIONE SPECIFICATORI
qua sotto.

#errore msg
Questa meta-macro causa un messaggio di errore con il nome del file corrente e il numero di riga,
e con il testo msg, da stampare sul dispositivo di errore standard. Successivo
l'elaborazione viene quindi interrotta.

#avvertimento msg
Questa meta-macro provoca un messaggio di avviso con il nome del file corrente e il numero di riga,
e con il testo msg, da stampare sul dispositivo di errore standard. Successivo
l'elaborazione viene quindi ripresa.

La chiave della flessibilità di GPP è il #modalità meta-macro. Il suo primo argomento è sempre uno dei
un elenco di parole chiave disponibili (vedi sotto); il suo secondo argomento è sempre una sequenza di
parole separate da spazi. A parte forse la prima di esse, ognuna di queste parole
è sempre un delimitatore o un identificatore di sintassi e dovrebbe essere fornito come una stringa C delimitata
tra virgolette (" "). Le varie sequenze di abbinamento speciali elencate nella sezione su
sono disponibili le specifiche della sintassi. Qualunque #modalità il comando viene analizzato in una modalità in cui "..." è
inteso come una stringa in stile C, quindi è sicuro inserire qualsiasi carattere all'interno di questi
stringhe. Si noti inoltre che il primo argomento di #modalità (la parola chiave) non viene mai valutata,
mentre viene valutato il secondo argomento (tranne ovviamente per il contenuto delle stringhe C),
in modo che la specificazione della sintassi possa essere ottenuta come risultato di una valutazione macro.

Il disponibile #modalità i comandi sono:

#modalità salvare / #modalità spingere
Spingi la specifica della modalità corrente nello stack delle modalità.

#modalità ripristinare / #modalità pop
Specifica della modalità pop dallo stack delle modalità.

#modalità Standard Nome
Seleziona una delle modalità standard. L'unico argomento deve essere uno tra: default
(modalità di default); cpp, C (modalità cpp); tex, TeX (modalità tex); html, HTML (modalità html);
xhtml, XHTML (modalità xhtml); prolog, Prolog (modalità prolog). Il nome della modalità deve essere
dato direttamente, non come una stringa C.

#modalità Utente "S1" ... "S9"
Specificare la sintassi della macro utente. I 9 argomenti, tutti stringhe C, sono la modalità
specifica per le macro utente (vedere l'opzione della riga di comando -U e la sezione su
sintassi specifica). La specifica della meta-macro non è interessata.

#modalità arrivo {utente | "S1" ... "s7"}
Specificare la sintassi della meta-macro. O l'unico argomento è Utente (non come una stringa), e
le specifiche della modalità macro utente vengono copiate nella modalità meta-macro
specifiche, oppure devono essere presenti sette argomenti stringa, il cui significato è il
come per l'opzione della riga di comando -M (vedere la sezione sulla specifica della sintassi).

#modalità citare ["C"]
Senza argomenti o "" come argomento, rimuove la specifica del carattere di citazione e
disabilita la funzionalità di quotazione. Con un argomento stringa, il primo carattere
della stringa è considerato il nuovo carattere apice. Il carattere di citazione può essere
né alfanumerico né '_', né può essere una delle sequenze di corrispondenza speciali.

#modalità commento [Xxx] "cominciare" "fine" ["C" ["C"]]
Aggiungi una specifica di commento. Facoltativamente un primo argomento composto da tre
i caratteri non racchiusi tra " " possono essere usati per specificare un commento/modificatore di stringa
(vedere la sezione sulla specifica della sintassi). Il modificatore predefinito è ccc. Il primo
due argomenti stringa vengono utilizzati rispettivamente come sequenze di inizio e fine dei commenti. Il
il terzo argomento stringa è facoltativo e può essere utilizzato per specificare una stringa-quote
carattere. (Se è "", la funzionalità è disabilitata.) La quarta stringa
l'argomento è facoltativo e può essere utilizzato per specificare un avviso di delimitazione della stringa
carattere. (Se è "", la funzionalità è disabilitata.)

#modalità stringa [Xxx] "cominciare" "fine" ["C" ["C"]]
Aggiungi una specifica di stringa. Uguale a #modalità commento tranne che l'impostazione predefinita
il modificatore è sss.

#modalità nessun commento / #modalità nessuna stringa ["cominciare"]
Senza argomenti, rimuove tutte le specifiche di commento/stringa. Con una corda
argomento, elimina la specifica di commento/stringa la cui sequenza di inizio è la
discussione.

#modalità preservare { on | MENO | 1 | 0 }
Equivalente a -n opzione della riga di comando. Se l'argomento è on or 1, qualsiasi nuova riga
o il carattere di spazio bianco che termina una chiamata di macro o un commento/stringa viene lasciato nel
flusso di input per ulteriori elaborazioni. Se l'argomento è MENO or 0 questa caratteristica è
Disabilitato.

#modalità set di caratteri { id | op | da } "corda"
Specificare i set di caratteri da utilizzare per la corrispondenza con \o, \O e \i speciale
sequenze. Il primo argomento deve essere uno di id (l'insieme abbinato a \i), op (la
set abbinato da \o) o da (l'insieme abbinato da \O oltre a quello abbinato da
\o). "corda" è una stringa C che elenca tutti i caratteri da inserire nel set. Esso può
contengono solo le sequenze di corrispondenza speciali \a, \A, \b, \B e \# (l'altra
sequenze e le sequenze negate non sono consentite). Quando viene trovato un '-'
tra due caratteri non speciali questo aggiunge tutti i caratteri in mezzo (es "AZ"
corrisponde a tutti i caratteri maiuscoli). Per avere '-' nel set abbinato, neanche
mettilo nella prima o nell'ultima posizione o posizionalo accanto a una sequenza \x.

DATA E ORARIO CONVERSIONE SPECIFICATORI

I caratteri ordinari inseriti nella stringa di formato vengono copiati senza conversione.
Gli identificatori di conversione sono introdotti da un carattere "%" e sono sostituiti come segue:

%a Il nome del giorno della settimana abbreviato in base alla locale corrente.

%A Il nome completo del giorno della settimana in base alla locale corrente.

%b Il nome del mese abbreviato in base alla locale corrente.

%B Il nome completo del mese in base alla locale corrente.

%c La rappresentazione di data e ora preferita per la locale corrente.

%d Il giorno del mese come numero decimale (intervallo da 01 a 31).

%F Equivalente a %Y-%m-%d (il formato della data ISO 8601).

%H L'ora come numero decimale utilizzando un orologio a 24 ore (intervallo da 00 a 23).

%I L'ora come numero decimale utilizzando un orologio a 12 ore (intervallo da 01 a 12).

%j Il giorno dell'anno come numero decimale (intervallo da 001 a 366).

%m Il mese come numero decimale (intervallo da 01 a 12).

%M Il minuto come numero decimale (intervallo da 00 a 59).

%p O "AM" o "PM" in base al valore dell'ora dato, o il corrispondente
stringhe per la locale corrente. Mezzogiorno viene trattato come "pomeriggio" e mezzanotte come "mattina".

%R L'ora nella notazione a 24 ore (%H:%M).

%S Il secondo come numero decimale (intervallo da 00 a 61).

%U Il numero della settimana dell'anno corrente come numero decimale, intervallo da 00 a 53,
a partire dalla prima domenica come primo giorno della settimana 01.

%w Il giorno della settimana come decimale, intervallo da 0 a 6, domenica essendo 0.

%W Il numero della settimana dell'anno corrente come numero decimale, intervallo da 00 a 53,
a partire dal primo lunedì come primo giorno della settimana 01.

%x La rappresentazione della data preferita per la locale corrente senza l'ora.

%X La rappresentazione dell'ora preferita per la locale corrente senza la data.

%y L'anno come numero decimale senza secolo (intervallo da 00 a 99).

%Y L'anno come numero decimale compreso il secolo.

%Z Il fuso orario o il nome o l'abbreviazione.

%% Un carattere "%" letterale.

A seconda del compilatore C e della libreria utilizzati per compilare GPP, potrebbero esserci più conversioni
specificatori disponibili. Consultare la documentazione del compilatore per il strftime() funzione.
Nota, tuttavia, che qualsiasi identificatore di conversione non elencato sopra potrebbe non essere trasferibile attraverso
impianti di GPP.

ESEMPI

Ecco un esempio di base autoesplicativo in modalità standard o cpp:

#define FOO Questo è
#define BAR un messaggio.
#definisci concat #1 #2
concat(FOO,BAR)
#ifeq (concat(foo,bar)) (foo bar)
Questo è l'output.
#else
Questo non è in uscita.
#endif

Usando la denominazione degli argomenti, il concat macro potrebbe in alternativa essere definita come

#define concat(x,y) xy

In modalità TeX e utilizzando la denominazione degli argomenti, lo stesso esempio diventa:

\define{FOO}{Questo è}
\define{BAR}{un messaggio.}
\define{\concat{x}{y}}{\x \y}
\concat{\FOO}{\BAR}
\ifeq{\concat{pippo}{bar}}{pippo bar}
Questo è l'output.
\altro
Questo non è in uscita.
\finisci se

In modalità HTML e senza denominazione degli argomenti, si ottiene in modo simile:

<#define FOO|Questo è>
<#define BAR|un messaggio.>
<#define concat|#1 #2>
<#concat <#FOO>|<#BAR>>
<#ifeq <#concat foo|bar>|foo bar>
Questo è l'output.
<#else>
Questo non è in uscita.
<#endif>

L'esempio seguente (in modalità standard) illustra l'uso del carattere di citazione:

#define FOO Questo è \
una definizione multilinea.
#define BLAH(x) Il mio argomento è x
BLAH (urf)
\BLAH(urf)

Nota che la definizione multilinea è valida anche nelle modalità cpp e Prolog nonostante il
assenza di virgolette, perché '\' seguito da una nuova riga viene quindi interpretato come a
commento e scarto.

In modalità cpp, le stringhe C e i commenti sono intesi come tali, come illustrato da
seguente esempio:

#definisci BLAH foo
BLAH "BLAH" /* BLAH */
'È una /*stringa*/ !'

La principale differenza tra la modalità Prolog e la modalità cpp è la gestione delle stringhe e
commenti: in Prolog, una stringa '...' potrebbe non iniziare immediatamente dopo una cifra e un /*...*/
il commento potrebbe non iniziare immediatamente dopo un carattere operatore. Inoltre, i commenti sono
non vengono rimossi dall'output a meno che non si verifichino in un #comando.

Le differenze tra la modalità cpp e la modalità predefinita sono più profonde: in modalità predefinita #comandi
possono iniziare ovunque, mentre in modalità cpp devono essere all'inizio di una riga; il predefinito
mode non conosce commenti e stringhe, ma ha un carattere di citazione ('\'), mentre cpp
mode ha ampie specifiche di commenti/stringhe ma nessun carattere di citazione. Inoltre, il
gli argomenti delle meta-macro devono essere correttamente tra parentesi in modalità predefinita, mentre non è così
il controllo viene eseguito in modalità cpp.

Ciò rende più facile nidificare le chiamate meta-macro in modalità predefinita rispetto alla modalità cpp. Per
esempio, si consideri il seguente input in modalità HTML, che verifica la disponibilità del
#esecutivo comando:

<#ifeq <#exec echo blah>|blah
> #exec consentito <#else> #exec non consentito <#endif>

Non esiste una modalità cpp equivalente, mentre in modalità predefinita può essere facilmente tradotta come

#ifeq (#exec echo bla
) (bla
)
\#exec consentito
#else
\#exec non consentito
#endif

Per nidificare le chiamate meta-macro in modalità cpp è necessario modificare la modalità
descrizione, modificando la sintassi della chiamata meta-macro o, più elegantemente, definendo
una stringa silenziosa e utilizzando il fatto che il contesto all'inizio di un valore
stringa è un carattere di nuova riga:

#mode stringa QQQ "$" "$"
#ifeq $#exec echo bla
$$blah
$
\#exec consentito
#else
\#exec non consentito
#endif

Nota, tuttavia, che i commenti/stringhe non possono essere nidificati ("..." all'interno di $...$ andrebbe
inosservato), quindi bisogna stare attenti a cosa includere all'interno di un tale silenzio
stringa valutata. In questo esempio, il nesting sciolto meta-macro introdotto nella versione 2.1
permette di utilizzare la seguente versione più semplice:

#ifeq bla #exec echo -n bla
\#exec consentito
#else
\#exec non consentito
#endif

Ricorda che le macro senza argomenti sono in realtà intese come alias quando lo sono
chiamato con argomenti, come illustrato dal seguente esempio (modalità predefinita o cpp):

#define DUP(x) xx
#define FOO e ho detto: DUP
FOO (bla)

L'utilità di #defeval la meta-macro è mostrata dal seguente esempio in modalità HTML:

<#define APPLICA|<#defeval TEMP|<\##1 \#1>><#TEMP #2>>
<#define <#foo x>|<#x> e <#x>>
<#APPLICA pippo|BLAH>

La ragione per cui #defeval è necessario che, poiché tutto viene valutato in un unico passaggio,
l'input che risulterà nella chiamata macro desiderata deve essere generato da un primo
valutazione degli argomenti passati ad APPLY prima di essere valutati una seconda volta.

Per tradurre questo esempio in modalità predefinita, è necessario ricorrere alla parentesi nell'ordine
per annidare la chiamata #defeval all'interno della definizione di APPLY, ma è necessario farlo senza
emettendo le parentesi. La soluzione più semplice è

#define SALDO(x) x
#define APPLICA(f,v) BILANCIO(#defeval TEMP f
TEMP(v))
#define foo(x) x e x
APPLICA (\pippo, BLAH)

Come spiegato sopra, la versione più semplice in modalità cpp si basa sulla definizione di un silent valutato
stringa per svolgere il ruolo della macro BALANCE.

L'esempio seguente (modalità predefinita o cpp) mostra la valutazione aritmetica:

#definire x 4
La risposta è:
#val x*x + 2*(16-x) + 1998%x

#se definito(x)&&!(3*x+5>17)
Questo dovrebbe essere prodotto.
#endif

Per finire, ecco alcuni esempi che riguardano il cambio di modalità. Il seguente esempio è
autoesplicativo (a partire dalla modalità predefinita):

#modalità push
#definisci f(x) xx
#modalità standard tex
\f{bla}
\mode{stringa}{"$" "$"}
\mode{commento}{"/*" "*/"}
$\f{urf}$ /* bla */
\define{FOO}{bar/* e altro ancora */}
\modalità{pop}
f($PIU'$)

Un buon esempio in cui una modalità definita dall'utente diventa utile è la fonte GPP di questo documento
(disponibile con la distribuzione del codice sorgente di GPP).

Un'altra applicazione interessante è forzare selettivamente la valutazione delle macro nelle stringhe C
quando in modalità cpp. Si consideri ad esempio il seguente input:

#define blah(x) "e ha detto: x"
bla (pippo)

Ovviamente uno vorrebbe il parametro x da espandere all'interno della stringa. Ci sono
diversi modi per aggirare questo problema:

#modalità push
#mode narice "\""
#define blah(x) "e ha detto: x"
#modalità pop

#mode citazione "`"
#define blah(x) `"e ha detto: x`"

#mode stringa QQQ "$$" "$$"
#define blah(x) $$"e ha detto: x"$$

Il primo metodo è molto naturale, ma ha l'inconveniente di essere lungo e
neutralizzando la semantica delle stringhe, in modo che avere un'istanza non valutata di 'x' nel
stringa, o un'occorrenza di '/*', sarebbe impossibile senza ricorrere a ulteriori
contorsioni.

Il secondo metodo è leggermente più efficiente perché la presenza locale di una citazione
carattere rende più facile controllare ciò che viene valutato e ciò che non lo è, ma ha il
svantaggio che a volte è impossibile trovare un carattere di citazione ragionevole senza
dover alterare in modo significativo il file sorgente o racchiuderlo all'interno di a #modalità premi/scarica
costruire. Ad esempio, qualsiasi occorrenza di '/*' nella stringa dovrebbe essere citata.

L'ultimo metodo dimostra l'efficienza delle stringhe valutate nel contesto di
valutazione selettiva: poiché i commenti/stringhe non possono essere nidificati, qualsiasi occorrenza di '"' o
'/*' all'interno di '$$' ottiene l'output come testo normale, come previsto all'interno di una stringa, e solo
la valutazione macro è abilitata. Si noti inoltre che c'è molta più libertà nella scelta di a
delimitatore di stringa rispetto alla scelta di un carattere apice.

A partire dalla versione 2.1, le chiamate meta-macro possono essere nidificate in modo più efficiente in modo predefinito, cpp
e modalità Prolog. In questo modo è facile creare una versione utente di una meta-macro o
incrementare un contatore:

#define myeval #eval #1

#definire x 1
#defeval x #eval x+1

AVANZATE ESEMPI

Ecco alcuni esempi di costruzioni avanzate che utilizzano GPP. Tendono ad essere piuttosto imbarazzanti
e dovrebbe essere considerata una prova dei limiti del GPP.

Il primo esempio è una macro ricorsiva. Il problema principale è che (dal momento che GPP valuta
tutto) una macro ricorsiva deve stare molto attenta al modo in cui è ricorsione
terminato per evitare comportamenti indefiniti (la maggior parte delle volte GPP andrà semplicemente in crash).
In particolare, basandosi su a #se/#altro/#endif costruire per terminare la ricorsione non è possibile
e si traduce in un ciclo infinito, perché GPP scansiona le chiamate macro dell'utente anche nel
ramo non valutato del blocco condizionale. Un modo sicuro per procedere è ad esempio come
segue (diamo l'esempio in modalità TeX):

\define{conto alla rovescia}{
\se{#1}
#1...
\define{ciclo}{\conto alla rovescia}
\altro
Donate.
\define{ciclo}{}
\finisci se
\loop{\eval{#1-1}}
}
\conto alla rovescia{10}

Un altro esempio, in modalità cpp:

#mode stringa QQQ "$" "$"
#define triangolo(x,y) y \
$#se lunghezza(y)
$#definisci iter$ $#endif
$ iter(x,*y)
triangolo(20)

Quello che segue è un tentativo (purtroppo molto debole) di implementare il funzionale
astrazione in GPP (in modalità standard). Comprendere questo esempio e perché non può essere realizzato
molto più semplice è un esercizio lasciato al lettore curioso.

#mode stringa "`" "`" "\\"
#define ASIS(x) x
#define SILENZIOSO(x) ASIS()
#define EVAL(x,f,v) SILENZIOSO(
#mode stringa QQQ "`" "`" "\\"
#defeval TEMP0 x
#defeval TEMP1 (
\#define \TEMP2(TEMP0) f
)
TEMP1
)TEMP2(v)
#define LAMBDA(x,f,v) SILENZIOSO(
#ifneq (v) ()
#define TEMP3(a,b,c) EVAL(a,b,c)
#else
#define TEMP3(a,b,c) \LAMBDA(a,b)
#endif
)TEMP3(x,f,v)
#define EVALAMBDA(x,y) SILENZIOSO(
#defeval TEMP4 x
#defeval TEMP5 a
)
#define APPLICA(f,v) SILENZIOSO(
#defeval TEMP6 ASIS(\EVA)f
TEMP6
)VAL(TEMP4,TEMP5,v)

Ciò produce i seguenti risultati:

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)

APPLICA (f, bla)
=> bla*bla

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

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

APPLICA(APPLICA(LAMBDA(x,LAMBDA(y,x*y)),pippo),bar)
=> pippo*bar

#define test LAMBDA(y,`#ifeq y urf
y è urf#altro
y non è urf#endif
`)
APPLICA(test,urf)
=> urf è urf

APPLICA (prova, pippo)
=> pippo non è urf

Usa gpp online usando i servizi onworks.net