gpp - Online en la nube

PROGRAMA:

NOMBRE

GPP - Preprocesador genérico

SINOPSIS

gpp [- {o | O} archivar] [-YO/ incluir / ruta] [-Dnombre = 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] [--nivel de advertencia n]
[--incluye marcador str] [--incluir presentar]
[en archivo]

gpp --ayuda

gpp --versión

DESCRIPCIÓN

GPP es un preprocesador de uso general con sintaxis personalizable, adecuado para una amplia gama
de tareas de preprocesamiento. Su independencia de cualquier lenguaje de programación lo hace mucho más
versátil que cpp, mientras que su sintaxis es más ligera y flexible que la de m4.

GPP está dirigido a todas las tareas comunes de preprocesamiento donde cpp no ​​es adecuado y donde no
se necesitan características muy sofisticadas. Para poder procesar con la misma eficiencia
archivos de texto o código fuente en una variedad de idiomas, la sintaxis utilizada por GPP es completamente
personalizable. El manejo de comentarios y cadenas es especialmente avanzado.

Inicialmente, GPP solo comprende un conjunto mínimo de macros integradas, llamado meta-macros.
Estas meta-macros permiten la definición de usuario macros así como algunas operaciones básicas
formando el núcleo del sistema de preprocesamiento, incluidas las pruebas condicionales, aritmética
evaluación, coincidencia de comodines (globbing) y especificación de sintaxis. Todas las macros de usuario
las definiciones son globales - es decir,, siguen siendo válidos hasta que se eliminen explícitamente; meta-macros
no se puede redefinir. Con cada definición de macro de usuario, GPP realiza un seguimiento de la
especificación de sintaxis para que una macro pueda invocarse de forma segura independientemente de cualquier
cambio de modo de funcionamiento.

Además de las macros, GPP comprende los comentarios y las cadenas, cuya sintaxis y comportamiento pueden
ser ampliamente personalizado para adaptarse a cualquier propósito en particular. Internamente, los comentarios y las cadenas son
la misma construcción, por lo que todo lo que se aplica a los comentarios también se aplica a las cadenas.

CAMPUS

GPP reconoce los siguientes conmutadores y opciones de la línea de comandos. Tenga en cuenta que el -nostdinc,
-nocurinc, -curdirinclast, -warninglevel y -includemarker opciones de la versión 2.1 y
anteriores están en desuso y no deben utilizarse. Utilice las variantes de "opción larga" en su lugar
(--nostdinc, etc.).

-h --ayuda
Imprima un breve mensaje de ayuda.

--versión
Imprime la información de la versión.

-o archivar
Especifique un archivo al que se deben enviar todos los resultados (de forma predeterminada, se envía todo
a salida estándar).

-O archivar
Especifique un archivo al que se deben enviar todos los resultados; la salida se envía simultáneamente a
salida estándar.

-I/ incluir / ruta
Especifique una ruta donde el #incluir la meta-macro buscará archivos de inclusión si
no están presentes en el directorio actual. El valor predeterminado es / usr / include si no-yo
se especifica la opción. Se pueden especificar varias opciones -I para buscar en varios
directorios.

-Dnombre = val
Definir la macro de usuario nombre como igual a val. Esto es estrictamente equivalente a usar
las #definir meta-macro, pero permite definir macros desde el comando-
línea. Si val hace referencias a argumentos u otras macros, debe ajustarse a
la sintaxis del modo especificado en la línea de comandos. A partir de la versión 2.1,
Se permite la denominación de argumentos macro en la línea de comandos. La sintaxis es la siguiente:
-Dmacro(arg1, ...) =definición. Los argumentos se especifican en sintaxis de estilo C,
sin ningún espacio en blanco, pero la definición debe seguir la sintaxis de
el modo especificado en la línea de comandos.

+z Establezca el modo de texto en modo Unix (terminador LF). Cualquier carácter CR en la entrada es
descartado sistemáticamente. Este es el valor predeterminado en los sistemas Unix.

-z Establezca el modo de texto en modo DOS (terminador CR-LF). En este modo, todos los caracteres CR son
eliminado de la entrada, y todos los caracteres LF de salida se convierten a CR-LF. Esta
es el valor predeterminado si GPP se compila con la opción WIN_NT.

-x Habilite el uso del #ejecutivo meta-macro. Ya que #ejecutivo incluye la salida de un
línea de comandos de shell arbitraria, puede causar una amenaza potencial a la seguridad y, por lo tanto, es
deshabilitado a menos que se especifique esta opción.

-m Habilite el cambio de modo automático al modo de compatibilidad cpp si el nombre de un
El archivo incluido termina en `.h 'o` .c'. Esto hace posible incluir un encabezado C
archivos con solo modificaciones menores.

-n Evite que los caracteres de nueva línea o espacios en blanco se eliminen de la entrada cuando
ocurren como el final de una llamada de macro o de un comentario. De forma predeterminada, cuando una nueva línea
o el carácter de espacio en blanco forma el final de una macro o un comentario que se analiza como parte
de la llamada o comentario macro y, por lo tanto, eliminado de la salida. Usa la opción -n
para mantener el último carácter en el flujo de entrada si era un espacio en blanco o una nueva línea.
Esto se activa en los modos cpp y Prolog.

+n Lo contrario de -n. Este es el valor predeterminado en todos los modos excepto cpp y Prolog. Nota
que + n se debe colocar después de -C o -P para tener algún efecto.

-U arg1 ... arg9
Modo definido por el usuario. Los nueve siguientes argumentos de la línea de comandos se consideran
respectivamente, la secuencia de inicio de macro, la secuencia de finalización de macro para una llamada sin
argumentos, la secuencia de inicio del argumento, el separador de argumento, el final del argumento
secuencia, la lista de caracteres para apilar para el equilibrio de argumentos, la lista de
caracteres para desapilar, la cadena que se utilizará para hacer referencia a un argumento por
número, y finalmente el carácter de comillas (si no hay ninguno, una cadena vacía debe ser
previsto). Esta configuración se aplica tanto a las macros de usuario como a las meta-macros, a menos que
La opción -M se usa para definir otras configuraciones para meta-macros. Ver la sección sobre
especificación de sintaxis para más detalles.

-M arg1 ... arg7
Especificaciones de modo definido por el usuario para meta-macros. Esta opción solo se puede utilizar
junto con -M. Los siete siguientes argumentos de la línea de comandos se consideran
respectivamente, la secuencia de inicio de macro, la secuencia de finalización de macro para una llamada sin
argumentos, la secuencia de inicio del argumento, el separador de argumento, el final del argumento
secuencia, la lista de caracteres para apilar para el equilibrio de argumentos, y la lista de
caracteres para desapilar. Consulte a continuación para obtener más detalles.

(defecto modo)
El modo predeterminado es un modo vagamente parecido a cpp, pero no maneja comentarios, y
presenta varias incompatibilidades con cpp. Meta-macros y macros de usuario típicas
se parece a esto:

#define xy
macro (arg, ...)

Este modo es equivalente a

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

-C modo de compatibilidad cpp. Este es el modo en el que el comportamiento de GPP se acerca más a
el de cpp. A diferencia del modo predeterminado, la expansión de meta-macro ocurre solo en el
se entienden el comienzo de las líneas y los comentarios y cadenas de C. Este modo es
equivalente a

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

-T Modo similar a TeX. En este modo, las típicas meta-macros y macros de usuario se ven así:

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

No se entienden comentarios. Este modo es equivalente a

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

-H Modo similar a HTML. En este modo, las típicas meta-macros y macros de usuario se ven así:

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

No se entienden comentarios. Este modo es equivalente a

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

-X Modo similar a XHTML. En este modo, las típicas meta-macros y macros de usuario se ven así:

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

No se entienden comentarios. Este modo es equivalente a

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

-P Modo similar a cpp compatible con Prolog. Este modo difiere del modo de compatibilidad cpp
por su manejo de comentarios, y es equivalente a

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

+c str1 str2
Especifique comentarios. Cualquier ocurrencia no citada de str1 será interpretado como el
comienzo de un comentario. Todas las entradas hasta la primera aparición siguiente de str2 seguirá
ser descartado. Esta opción se puede utilizar varias veces para especificar diferentes tipos de
delimitadores de comentarios. El parámetro opcional se puede especificar para alterar el
comportamiento del comentario y, p.ej, conviértalo en una cadena o hágalo ignorar en
determinadas circunstancias, consulte a continuación.

-c str1
Anule la especificación de comentarios o cadenas. La especificación de comentario / cadena cuyo inicio
la secuencia es str1 es removido. Esto es útil para modificar el comentario incorporado.
especificaciones de un modo estándar - p.ej, el modo de compatibilidad cpp.

+s str1 str2 c
Especifique cadenas. Cualquier ocurrencia no citada de str1 será interpretado como el
comienzo de una cadena. Todas las entradas hasta la primera aparición siguiente de str2 seguirá
ser salida como está sin ninguna evaluación. Se generan los delimitadores en sí mismos. Si c
no está vacío, su primer carácter se utiliza como cita-cadena personaje -- es decir,,
personaje cuya presencia inmediatamente antes de una ocurrencia de str2 lo previene de
terminando la cadena. El parámetro opcional se puede especificar para alterar el
comportamiento de la cuerda y, p.ej, conviértalo en un comentario, habilite la evaluación macro
dentro de la cadena, o hacer que la especificación de la cadena se ignore bajo ciertas
circunstancias. Vea abajo.

-s str1
Anule la especificación de comentarios o cadenas. Idéntico a -c.

--incluir presentar
Proceso presentar antes en archivo

--nostdinc
No busque archivos de inclusión en el directorio estándar / usr / include.

--nocurina
No busque archivos de inclusión en el directorio actual.

--curdirinclasto
Busque incluir archivos en el directorio actual después de los directorios especificados por
-I en lugar de antes de ellos.

--nivel de advertencia n
Establecer el nivel de advertencia en n (0, 1 o 2). El valor predeterminado es 2 (más detallado).

--incluye marcador str
seguir #incluir directivas insertando un marcador en el flujo de salida. El
El formato del marcador está determinado por str, que debe contener tres apariciones de
el personaje % (o equivalente ?). La primera aparición se reemplaza con la línea
número, el segundo con el nombre del archivo y el tercero con 1, 2 o en blanco. Cuando esto
La opción se especifica en modo predeterminado, cpp o Prolog, GPP hace todo lo posible para garantizar
que los números de línea son los mismos en la salida que en la entrada insertando un espacio en blanco
líneas en lugar de definiciones o comentarios.

en archivo Especifique un archivo de entrada desde el cual GPP lee su entrada. Si no hay ningún archivo de entrada
especificado, la entrada se lee desde la entrada estándar.

SINTAXIS Características

La sintaxis de una llamada a macro es la siguiente: debe comenzar con una secuencia de caracteres
coincidiendo con el macro comienzo secuencia como se especifica en el modo actual, seguido inmediatamente
por el nombre de la macro, que debe ser una identificador -- es decir,, una secuencia de letras,
dígitos o guiones bajos ("_"). El nombre de la macro debe ir seguido de un Corto macro final
secuencia si la macro no tiene argumentos, o por una secuencia de argumentos iniciada por un
argumento comienzo secuencia. Los diversos argumentos se separan luego por un argumento
separadory la macro termina con un Corto macro final secuencia.

En todos los casos, los parámetros del contexto actual - es decir,, los argumentos pasados ​​al
cuerpo que se está evaluando - se puede hacer referencia a él mediante el uso de un argumento referencia secuencia
seguido de un dígito entre 1 y 9. Alternativamente, se pueden nombrar parámetros macro (ver
debajo). Además, para evitar interferencias entre la sintaxis GPP y el contenido de la
archivo de entrada, un cotización inicial personaje está provisto. El carácter de cita se puede utilizar para evitar
interpretación de una macro llamada, comentario o cadena como cualquier cosa menos texto sin formato. La frase
El carácter "protege" al siguiente carácter y siempre se elimina durante la evaluación.
Dos caracteres de comillas consecutivos se evalúan como un carácter de comillas simples.

Por último, para facilitar la delimitación adecuada de los argumentos, se pueden "apilar" ciertos caracteres
cuando ocurren en un argumento macro, de modo que el separador de argumento o la secuencia final de macro
no se analizan si el cuerpo del argumento no está equilibrado. Esto permite anidar llamadas de macro.
sin usar comillas. Si se necesita un argumento incorrectamente equilibrado, cite caracteres
debe agregarse delante de algunos caracteres apilados para equilibrarlo.

Las secuencias de construcción de macros descritas anteriormente pueden ser diferentes para meta-macros y para
macros de usuario: este es el caso en el modo cpp, por ejemplo. Tenga en cuenta que, dado que las meta-macros pueden
sólo tienen hasta dos argumentos, las reglas de delimitación para el segundo argumento son algo
Se permiten secuencias de separadores de argumentos más descuidados y sin comillas en el segundo argumento de
una meta-macro.

A menos que se seleccione uno de los modos de funcionamiento estándar, las secuencias de sintaxis anteriores se pueden
especificado en la línea de comandos, usando las opciones -M y -U respectivamente para meta-
macros y macros de usuario, o dentro de un archivo de entrada a través de la #modo meta y #modo usuario meta-
llamadas macro. En ambos casos, la descripción del modo consta de nueve parámetros para el usuario.
especificaciones macro, a saber, la secuencia de inicio de macro, la secuencia de fin de macro corta, la
secuencia de inicio de argumento, el separador de argumento, la secuencia de fin de macro larga, la cadena
enumerar los caracteres para apilar, la cadena enumerar los caracteres para desapilar, el argumento
secuencia de referencia, y finalmente el carácter de cita. Como se explica a continuación, estas secuencias
debe proporcionarse utilizando la sintaxis de cadenas C; deben comenzar con un no alfanumérico
carácter, y en las primeras cinco cadenas se pueden utilizar secuencias especiales de coincidencia (ver
debajo). Si el argumento correspondiente al carácter de comillas es la cadena vacía, eso
la funcionalidad del argumento está deshabilitada. Para especificaciones de meta-macro, solo hay siete
parámetros, ya que la secuencia de referencia del argumento y el carácter de cita se comparten con el
sintaxis de macros de usuario.

La estructura de un comentario / cadena es la siguiente: debe comenzar con una secuencia de
caracteres que coinciden con el dado comentario / cadena comienzo secuencia, y siempre termina en el primero
ocurrencia de la comentario / cadena final secuencia, a menos que esté precedido por un número impar de
ocurrencias de la cita-cadena personaje (si se ha especificado tal carácter). En
En ciertos casos, se pueden especificar comentarios / cadenas para permitir la evaluación de macros dentro del
comentario / cadena; en ese caso, si se ha definido un carácter de comillas para macros, se puede
se usa también para evitar que el comentario / cadena termine, con la diferencia de que la macro
El carácter de cita siempre se elimina de la salida, mientras que el carácter de comilla de cadena siempre se
producción. También tenga en cuenta que, en determinadas circunstancias, se puede realizar una especificación de comentario / cadena.
discapacitados, en cuyo caso la secuencia de inicio de comentario / cadena simplemente se ignora. Finalmente, es
es posible especificar un cadena advertencia personaje cuya presencia dentro de un comentario / cadena
hará que GPP genere una advertencia (esto es útil para ubicar cadenas no terminadas en cpp
modo). Tenga en cuenta que los archivos de entrada no pueden contener comentarios / cadenas sin terminar.

Se puede declarar una especificación de comentario / cadena desde dentro del archivo de entrada usando el #modo
comentario llamada meta-macro (o equivalentemente #modo cadena), en cuyo caso el número de C
Las cadenas que se darán como argumentos para describir el comentario / cadena pueden estar en cualquier lugar entre
dos y cuatro: los dos primeros argumentos (obligatorios) son la secuencia de inicio y el final
secuencia, y puede hacer uso de las secuencias de coincidencia especiales (ver más abajo). Pueden no
comience con caracteres alfanuméricos. El primer carácter del tercer argumento, si hay
uno, se usa como el carácter de comilla de cadena (use una cadena vacía para deshabilitar el
funcionalidad), y el primer carácter del cuarto argumento, si hay uno, se utiliza
como el carácter de advertencia de cadena. También se puede dar una especificación desde la línea de comandos,
en cuyo caso debe haber dos argumentos si se usa la opción + c y tres si se usa + s
.

El comportamiento de un comentario / cadena se especifica mediante una cadena modificadora de tres caracteres, que
se puede pasar como un argumento opcional a las opciones de la línea de comandos + c / + s o al
#modo comentario/#modo cadena meta-macros. Si no se especifica una cadena modificadora, el valor predeterminado
el valor es "ccc" para comentarios y "sss" para cadenas. El primer carácter corresponde al
comportamiento dentro de las llamadas de meta-macro (incluidas las definiciones de macro de usuario, ya que
a #definir llamada meta-macro), el segundo carácter corresponde al comportamiento dentro del usuario-
parámetros de macro, y el tercer carácter corresponde al comportamiento fuera de cualquier macro
llamar. Cada uno de estos caracteres puede tomar los siguientes valores:

i deshabilite la especificación de comentario / cadena.

c comentario (ni evaluado ni de salida).

s cadena (la cadena y sus secuencias delimitadores se generan tal cual).

q cadena entre comillas (la cadena se emite como está, sin las secuencias delimitadores).

C comentario evaluado (las macros se evalúan, pero la salida se descarta).

S cadena evaluada (se evalúan las macros, se emiten los delimitadores).

Q cadena entre comillas evaluada (las macros se evalúan, los delimitadores no se generan).

Nota importante: cualquier ocurrencia de una secuencia de inicio de comentario / cadena dentro de otra
el comentario / cadena siempre se ignora, incluso si la evaluación de macros está habilitada. En otras palabras,
los comentarios / cadenas no se pueden anidar. En particular, el modificador 'Q' puede ser una forma conveniente
de definir una sintaxis para deshabilitar temporalmente todos los comentarios y especificaciones de cadenas.

Las cadenas de especificación de sintaxis siempre deben proporcionarse como cadenas C, ya sean
dado como argumentos a un #modo llamada meta-macro o en la línea de comandos de un shell de Unix. Si
Los argumentos de la línea de comandos se dan a través de otro método que no sea un shell estándar de Unix, luego el
el comportamiento del shell debe ser emulado - es decir,, las comillas "" circundantes deben eliminarse, todas
las apariciones de `\\ 'deben ser reemplazadas por una sola barra invertida, y de manera similar,` \ "' debe ser
reemplazado por `" '. Secuencias como `\ n' son reconocidas por GPP y deben dejarse como están.

Se pueden utilizar secuencias especiales que coincidan con ciertos subconjuntos del juego de caracteres. Son de
la forma `\x', dónde x es uno de:

b coincide con cualquier secuencia de uno o más espacios o caracteres de tabulación (`\ b 'es idéntico a
'').

w coincide con cualquier secuencia de cero o más espacios o caracteres de tabulación.

B coincide con cualquier secuencia de uno o más espacios, tabulaciones o caracteres de nueva línea.

W coincide con cualquier secuencia de cero o más espacios, tabulaciones o caracteres de nueva línea.

a un carácter alfabético (de la 'a' a la 'z' y de la 'A' a la 'Z').

A un carácter alfabético, o un espacio, tabulación o nueva línea.

# un dígito ("0" a "9").

i un carácter identificador. El conjunto de caracteres coincidentes se puede personalizar mediante el
#modo charset id mando. La configuración predeterminada coincide con caracteres alfanuméricos y
guiones bajos ('a' a 'z', 'A' a 'Z', '0' a '9' y '_').

t un carácter de tabulación.

n un carácter de nueva línea.

o un personaje de operador. El conjunto de caracteres coincidentes se puede personalizar mediante el
#modo charset op mando. La configuración predeterminada coincide con todos los caracteres en
"+ - * / \ ^ <> =` ~:.? @ # &!% | ", excepto en el modo Prólogo donde`! ', `%' y` | ' no son
emparejado

O un carácter operador o un carácter entre paréntesis. El conjunto de emparejados adicionales
caracteres en comparación con '\ o' es personalizable usando el #modo charset por
mando. La configuración predeterminada es tener los caracteres entre "() [] {}" entre paréntesis.

Además, todos estos subconjuntos coincidentes excepto `\ w 'y` \ W' se pueden negar insertando un
'!' - es decir,, escribiendo `\!x'en lugar de' \x'.

Nótese una característica distintiva importante de comienzo secuencias: cuando el primer carácter de un
macro o secuencia de inicio de comentario / cadena es '' o una de las secuencias especiales anteriores, es
no se toma como parte de la secuencia en sí, sino que se usa como una verificación de contexto: para
ejemplo, una secuencia de inicio que comienza con '\ n' coincide solo con el comienzo de una línea, pero
el carácter de nueva línea coincidente no se considera parte de la secuencia. Similarmente un comienzo
secuencia que comienza con '' coincide solo si hay algún espacio en blanco presente, pero la
el espacio en blanco no se considera parte de la secuencia de inicio y, por lo tanto, se envía a
producción. Si se realiza una verificación de contexto al principio de un archivo (o de manera más general
de cualquier cuerpo que se va a evaluar), el resultado es el mismo que coincidir con un carácter de nueva línea
(esto hace posible que un archivo en modo cpp comience con una llamada de meta-macro).

Se agregaron dos reglas de sintaxis especiales en la versión 2.1. Primero, referencias de argumentos (#n) no son
ya se evalúan cuando están fuera de las llamadas y definiciones de macros. Sin embargo, son
ya no se permite aparecer (a menos que esté protegido por comillas) dentro de una llamada a un
macro de usuario definida; el comportamiento actual (compatible con versiones anteriores) es eliminarlos silenciosamente
de la entrada si eso sucede.

En segundo lugar, si la secuencia final (ya sea para macros o comentarios) consta de una única línea nueva
carácter, y si las reglas de delimitación conducen a una evaluación en un contexto donde la
El carácter de nueva línea está ausente, GPP ignora silenciosamente la nueva línea que falta en lugar de producir
un error. La principal consecuencia es que las llamadas a meta-macro ahora se pueden anidar de una manera sencilla
en los modos estándar, cpp y Prolog.

IMPACTO REGLAS

La entrada se lee secuencialmente y se interpreta de acuerdo con las reglas del modo actual. Todo
El texto de entrada se compara primero con las secuencias de inicio de cadena / comentario especificadas del
modo actual (excepto aquellos que están desactivados por el modificador 'i'), a menos que el cuerpo esté
evaluado es el contenido de un comentario / cadena cuyo modificador habilita la evaluación de macros.
Primero se comprueban las especificaciones de cadena / comentario definidas más recientemente. Importante
nota: los comentarios pueden no aparecer entre el nombre de una macro y sus argumentos (al hacerlo
da como resultado un comportamiento indefinido).

Todo lo que no sea un comentario / cadena se compara con una posible llamada de meta-macro,
y si eso también falla, contra una posible llamada de macro de usuario. Todo el texto restante se somete a
sustitución de secuencias de referencia de argumentos por el texto del argumento relevante (vacío a menos que
el cuerpo que se evalúa es la definición de una macro de usuario) y la eliminación de la cita
personaje si hay uno.

Tenga en cuenta que los argumentos de la meta-macro se pasan a la meta-macro antes de cualquier evaluación
(aunque la meta-macro puede optar por evaluarlos, consulte las descripciones de la meta-macro a continuación).
En el caso de la #modo meta-macro, GPP agrega temporalmente una especificación de comentario / cadena
para permitir el reconocimiento de cadenas C ("...") y evitar cualquier evaluación dentro de ellas, por lo que no
interferencia de los caracteres que se ponen en los argumentos de la cadena C para #modo con el
es de temer la sintaxis actual.

Por otro lado, los argumentos de una macro de usuario se evalúan sistemáticamente y luego
pasados ​​como parámetros de contexto al cuerpo de la definición de macro, que se evalúa con eso
ambiente. La única excepción es cuando la definición de macro está vacía, en cuyo caso su
los argumentos no se evalúan. Tenga en cuenta que GPP vuelve temporalmente al modo en el que
la macro se definió para evaluarla, por lo que es perfectamente seguro cambiar la
modo de funcionamiento entre el momento en que se define una macro y el momento en que se llama.
Por el contrario, si una macro de usuario desea trabajar con el modo actual en lugar del que
se usó para definirlo, debe comenzar con un #modo restaurar llamar y terminar con un #modo
ahorrar llamada.

Una macro de usuario puede definirse con argumentos con nombre (consulte #definir descripción a continuación). En eso
caso, cuando se evalúa la definición de la macro, cada parámetro nombrado causa una
se creará una definición temporal de macro de usuario virtual; tal macro se puede llamar solo
sin argumentos y simplemente devuelve el texto del argumento correspondiente.

Tenga en cuenta que, dado que las macros se evalúan cuando se llaman en lugar de cuando se
definido, cualquier intento de llamar a una macro recursiva provoca un comportamiento indefinido excepto en el
caso muy específico cuando la macro utiliza #undef borrarse a sí mismo después de un número finito de bucles
iteraciones.

Finalmente, ocurre un caso especial cuando una macro de usuario cuya definición no implica ninguna
argumentos (ni argumentos con nombre ni la secuencia de referencia de argumentos) se llama en un
modo en el que la secuencia corta de finalización de macro de usuario está vacía (p.ej, cpp o modo TeX). En eso
caso se asume que es un alias macro: sus argumentos se evalúan primero en el actual
modo como de costumbre, pero en lugar de pasar a la definición de macro como parámetros (que
haría que se descartaran) en realidad se añaden a la definición de macro,
utilizando las reglas de sintaxis del modo en el que se definió la macro, y el texto resultante
se evalúa de nuevo. Por tanto, es importante tener en cuenta que, en el caso de un alias de macro,
los argumentos en realidad se evalúan dos veces en dos modos potencialmente diferentes.

META-MACROS

Estas macros siempre están predefinidas. Su secuencia de llamada real depende de la corriente
modo; aquí usamos una notación similar a cpp.

#definir x y
Esto define la macro de usuario x as y. y puede ser cualquier entrada GPP válida, y puede
ejemplo se refiere a otras macros. x debe ser un identificador (es decir,, una secuencia de
caracteres alfanuméricos y '_'), a menos que se especifiquen argumentos con nombre. Si x is
ya definida, se sobrescribe la definición anterior. Si no hay un segundo argumento
dado, x se definirá como una macro que no genera nada. Ninguno de los dos x ni y en
evaluado; la definición de macro solo se evalúa cuando se llama, no cuando se
declarado.

También es posible nombrar los argumentos en una definición de macro: en ese caso, el
argumento x debe ser una llamada de macro de usuario cuyos argumentos sean todos identificadores. Estos
los identificadores están disponibles como macros de usuario dentro de la definición de macro; estos
Las macros virtuales deben llamarse sin argumentos y evaluarse al correspondiente
parámetro macro.

#defeval x y
Esto actúa de manera similar a #definir, pero el segundo argumento y es evaluado
inmediatamente. Dado que las definiciones de macros de usuario también se evalúan cada vez que se
llamado, esto significa que la macro y se va a someter dos evaluaciones sucesivas. El
utilidad de #defeval es considerable, ya que es la única forma de evaluar algo
más de una vez, lo que puede ser necesario para forzar la evaluación de los argumentos de una meta-
macro que normalmente no realiza ninguna evaluación. Sin embargo, dado que todo argumento
Las referencias evaluadas en el tiempo de definición se entienden como los argumentos del cuerpo en
que la macro se está definiendo y no como los argumentos de la macro en sí,
Por lo general, uno tiene que usar el carácter de cita para evitar una evaluación inmediata de
referencias de argumentos.

#undef x
Esto elimina cualquier definición existente de la macro de usuario. x.

#ifdef x
Esto comienza un bloque condicional. Todo lo que sigue se evalúa solo si el
identificador x está definido, y hasta que un #else o un #terminara si se alcanza la declaración.
Sin embargo, tenga en cuenta que el texto comentado todavía se escanea a fondo, por lo que su sintaxis
Debe ser válido. En particular, es legal tener la #else or #terminara si ambiental
finalizar el bloque condicional aparece solo como resultado de una expansión de macro de usuario
y no explícitamente en la entrada.

#siempre x
Esto comienza un bloque condicional. Todo lo que sigue se evalúa solo si el
identificador x no está definido.

#ifeq x y
Esto comienza un bloque condicional. Todo lo que sigue se evalúa solo si el
resultados de las evaluaciones de x y y son idénticas a las cadenas de caracteres. Ningún
Los espacios en blanco iniciales o finales se ignoran para la comparación. Tenga en cuenta que en modo cpp
cualquier carácter de espacio en blanco sin comillas se entiende como el final del primer argumento,
por eso es necesario tener cuidado.

#ifneq x y
Esto comienza un bloque condicional. Todo lo que sigue se evalúa solo si el
resultados de las evaluaciones de x y y no son idénticos (incluso hasta el inicio o
espacio en blanco final).

#else Esto alterna el valor lógico del bloque condicional actual. Lo que sigue es
evaluado si y solo si la entrada anterior fue comentada.

#terminara si Esto finaliza un bloque condicional iniciado por un #Si... meta-macro.

#incluir presentar
Esto hace que GPP abra el archivo especificado y evalúe su contenido, insertando el
texto resultante en la salida actual. Todas las macros de usuario definidas todavía están disponibles
en el archivo incluido, y recíprocamente todas las macros definidas en el archivo incluido
estar disponible en todo lo que sigue. El archivo de inclusión se busca primero en
el directorio actual, y luego, si no se encuentra, en uno de los directorios especificados
según el -I opción de línea de comandos (o / usr / include si no se especificó ningún directorio).
Tenga en cuenta que, por razones de compatibilidad, es posible poner el nombre del archivo entre
"" o <>.

El orden en el que se buscan los archivos de inclusión en los distintos directorios es
afectado por el -nostdinc, -nocurina y -curdirinclast opciones de la línea de comandos.

Al incluir un archivo, GPP guarda inmediatamente una copia del modo de funcionamiento actual
en la pila de modo, y restaura el modo de funcionamiento al final de la lista incluida.
Archivo. El archivo incluido puede anular este comportamiento comenzando con un #modo restaurar
llamar y terminar con un #modo empuje llamar. Además, cuando el -m de línea de comandos
se especifica la opción, GPP cambiará automáticamente al modo de compatibilidad cpp
al incluir un archivo cuyo nombre termine con '.c' o '.h'.

#ejecutivo comando
Esto hace que GPP ejecute la línea de comando especificada e incluya su estándar
salida en la salida actual. Tenga en cuenta que, por razones de seguridad, esta meta-macro es
discapacitado a menos que el -x Se especificó el indicador de línea de comando. Si el uso de #ejecutivo no es
permitido, se imprime un mensaje de advertencia y la salida se deja en blanco. Tenga en cuenta que el
La línea de comando especificada se evalúa antes de ejecutarse, lo que permite el uso de
macros en la línea de comandos. Sin embargo, el resultado del comando se incluye literalmente
y no evaluado. Si necesita que se evalúe la salida, debe usar #defeval
(ver arriba) para causar una doble evaluación.

#evaluar expr
El #evaluar meta-macro intenta evaluar expr primero expandiendo macros (normal
Evaluación de GPP) y luego realizando una evaluación aritmética y / o comodín
pareo. La sintaxis y la precedencia del operador para las expresiones aritméticas son las
igual que en C; los únicos operadores que faltan son <<, >>,?:, y la asignación
operadores.

La coincidencia de comodines de estilo POSIX ('globbing') está disponible solo en POSIX
implementaciones y se puede invocar con el operador = ~. En resumen, un '?' partidos
cualquier carácter, un '*' coincide con cualquier cadena (incluida la cadena vacía), y
'[...]' coincide con cualquiera de los caracteres entre corchetes. Una clase '[...]' es
complementado cuando el primer carácter entre paréntesis es '!'. Los personajes en un
La clase '[...]' también se puede especificar como un rango usando el carácter '-' - p.ej,
'[FN]' es equivalente a '[FGHIJKLMN]'.

Si no puede asignar un valor numérico al resultado, el texto devuelto es simplemente
el resultado de la expansión macro sin ninguna evaluación aritmética. Lo único
Las excepciones a esta regla son los operadores de comparación ==,! =, <,>, <= y> =
que, si uno de los lados no se evalúa como un número, realiza una comparación de cadenas
en su lugar (ignorando los espacios iniciales y finales). Además, el longitud(...)
El operador aritmético devuelve la longitud en caracteres de su argumento evaluado.

Dentro de las expresiones aritméticas, el definido (...) macro de usuario especial también es
disponible: toma solo un argumento, que no se evalúa, y devuelve 1 si
es el nombre de una macro de usuario y 0 en caso contrario.

#Si expr
Esta meta-macro invoca al evaluador aritmético / globbing de la misma manera que
#evaluar y compara el resultado de la evaluación con la cadena "0" para comenzar una
bloque condicional. En particular, tenga en cuenta que el valor lógico de expr siempre es verdad
cuando no se puede evaluar a un número.

#elif expr
Esta meta-macro se puede utilizar para evitar anidadas #Si . #Si ... #elif ...
#terminara si es equivalente a #Si ... #else #Si ... #terminara si #terminara si.

#modo keyword ...
Esta meta-macro controla el modo de funcionamiento de GPP. Consulte a continuación una lista de #modo
comandos.

#línea Esta meta-macro evalúa el número de línea del archivo de entrada actual.

#expediente Esta meta-macro evalúa el nombre de archivo del archivo de entrada actual tal como aparece
en la línea de comando o en el argumento para #incluir. Si GPP está leyendo su entrada
de stdin, entonces #expediente se evalúa como 'stdin'.

#fecha fmt
Esta meta-macro evalúa la fecha y hora actuales como formateada por el
cadena de formato especificado fmt. Ver la sección FECHA Y HORA CONVERSIÓN ESPECIFICADORES
abajo.

#error MSG
Esta meta-macro provoca un mensaje de error con el nombre de archivo actual y el número de línea,
y con el texto MSG, que se imprimirá en el dispositivo de error estándar. Subsecuente
entonces se interrumpe el procesamiento.

#advertencia MSG
Esta meta-macro genera un mensaje de advertencia con el nombre de archivo actual y el número de línea,
y con el texto MSG, que se imprimirá en el dispositivo de error estándar. Subsecuente
luego se reanuda el procesamiento.

La clave de la flexibilidad de GPP es la #modo meta-macro. Su primer argumento es siempre uno de
una lista de palabras clave disponibles (ver más abajo); su segundo argumento es siempre una secuencia de
palabras separadas por espacios en blanco. Aparte de posiblemente la primera de ellas, cada una de estas palabras
es siempre un delimitador o especificador de sintaxis, y debe proporcionarse como una cadena C delimitada
entre comillas dobles (""). Las diversas secuencias especiales de coincidencia enumeradas en la sección sobre
la especificación de sintaxis está disponible. Ningún #modo El comando se analiza en un modo donde "..." es
entendido como una cadena de estilo C, por lo que es seguro poner cualquier carácter dentro de estos
instrumentos de cuerda. También tenga en cuenta que el primer argumento de #modo (la palabra clave) nunca se evalúa,
mientras se evalúa el segundo argumento (excepto, por supuesto, para el contenido de las cadenas de C),
de modo que la especificación de sintaxis pueda obtenerse como resultado de una macroevaluación.

El disponible #modo los comandos son:

#modo ahorrar / #modo empuje
Empuje la especificación del modo actual en la pila de modos.

#modo restaurar / #modo Deliciosos
Especificación del modo emergente de la pila de modos.

#modo estándar nombre
Seleccione uno de los modos estándar. El único argumento debe ser uno de los siguientes: predeterminado
(modo por defecto); cpp, C (modo cpp); tex, TeX (modo tex); html, HTML (modo html);
xhtml, XHTML (modo xhtml); prolog, Prolog (modo de prólogo). El nombre del modo debe ser
dado directamente, no como una cadena de C.

#modo usuario "s1" ... "s9"
Especifique la sintaxis de la macro de usuario. Los 9 argumentos, todos ellos cadenas C, son el modo
especificación para macros de usuario (consulte la opción de línea de comandos -U y la sección sobre
especificación de sintaxis). La especificación de la meta-macro no se ve afectada.

#modo meta {usuario | "s1" ... "s7"}
Especifica la sintaxis de la meta-macro. O el único argumento es usuario (no como una cuerda), y
las especificaciones del modo macro de usuario se copian en el modo meta-macro
especificaciones, o debe haber siete argumentos de cadena, cuyo significado es el
lo mismo que para la opción de línea de comandos -M (consulte la sección sobre especificación de sintaxis).

#modo cotización inicial ["C"]
Sin argumento o "" como argumento, elimina la especificación del carácter de comillas y
desactiva la función de cotización. Con un argumento de cadena, el primer carácter
de la cadena se toma como el nuevo carácter de comillas. El carácter de cita puede ser
ni alfanumérico ni '_', ni puede ser una de las secuencias especiales de coincidencia.

#modo comentario [xxx] "comienzo" "fin" ["C" ["C"]]
Agregue una especificación de comentario. Opcionalmente, un primer argumento que consta de tres
los caracteres que no están entre "" se pueden utilizar para especificar un modificador de comentario / cadena
(consulte la sección sobre especificación de sintaxis). El modificador predeterminado es ccc. La primera
Se utilizan dos argumentos de cadena como secuencias de inicio y finalización de comentarios, respectivamente. El
El tercer argumento de cadena es opcional y se puede usar para especificar una cita de cadena.
personaje. (Si es "", la funcionalidad está deshabilitada). La cuarta cadena
El argumento es opcional y se puede utilizar para especificar una advertencia de delimitación de cadenas.
personaje. (Si es "", la funcionalidad está deshabilitada).

#modo cadena [xxx] "comienzo" "fin" ["C" ["C"]]
Agregue una especificación de cadena. Idéntico a #modo comentario excepto que el predeterminado
el modificador es sss.

#modo sin comentarios / #modo Sin ataduras ["comienzo"]
Sin argumento, elimine todas las especificaciones de comentarios / cadenas. Con una cuerda
argumento, elimine la especificación de comentario / cadena cuya secuencia de inicio es la
argumento.

#modo preservar { on | off | 1 | 0 }
Equivalente a la -n conmutador de línea de comandos. Si el argumento es on or 1, cualquier nueva línea
o un carácter de espacio en blanco que finaliza una llamada de macro o se deja un comentario / cadena en el
flujo de entrada para su posterior procesamiento. Si el argumento es off or 0 esta característica es
discapacitado.

#modo charset { id | op | por } "cuerda"
Especifique los juegos de caracteres que se utilizarán para hacer coincidir los valores especiales \ o, \ O y \ i
secuencias. El primer argumento debe ser uno de id (el conjunto emparejado por \ i), op (la
conjunto emparejado por \ o) o por (el conjunto emparejado por \ O además del emparejado por
\ o). "cuerda" es una cadena de C que enumera todos los caracteres para poner en el conjunto. Puede
contienen solo las secuencias coincidentes especiales \ a, \ A, \ b, \ B y \ # (el otro
secuencias y las secuencias negadas no están permitidas). Cuando se encuentra un '-'
entre dos caracteres no especiales, esto agrega todos los caracteres intermedios (por ejemplo, "AZ"
corresponde a todos los caracteres en mayúscula). Tener '-' en el conjunto combinado, ya sea
colóquelo en la primera o última posición o colóquelo junto a una secuencia \ x.

FECHA Y HORA CONVERSIÓN ESPECIFICADORES

Los caracteres ordinarios colocados en la cadena de formato se copian sin conversión.
Los especificadores de conversión se introducen con un carácter '%' y se reemplazan de la siguiente manera:

%a El nombre abreviado del día de la semana según la configuración regional actual.

%A El nombre completo del día de la semana según la configuración regional actual.

%b El nombre del mes abreviado según la configuración regional actual.

%B El nombre completo del mes según la configuración regional actual.

%c La representación de fecha y hora preferida para la configuración regional actual.

%d El día del mes como un número decimal (rango de 01 a 31).

%F Equivalente a% Y-% m-% d (el formato de fecha ISO 8601).

%H La hora como un número decimal usando un reloj de 24 horas (rango de 00 a 23).

%I La hora como un número decimal usando un reloj de 12 horas (rango de 01 a 12).

%j El día del año como número decimal (rango 001 a 366).

%m El mes como un número decimal (rango de 01 a 12).

%M El minuto como número decimal (rango de 00 a 59).

%p Ya sea 'AM' o 'PM' de acuerdo con el valor de tiempo dado, o el correspondiente
cadenas para la configuración regional actual. El mediodía se trata como "pm" y la medianoche como "am".

%R El tiempo en notación de 24 horas (% H:% M).

%S El segundo como un número decimal (rango de 00 a 61).

%U El número de semana del año actual como un número decimal, rango de 00 a 53,
comenzando con el primer domingo como el primer día de la semana 01.

%w El día de la semana como decimal, rango de 0 a 6, siendo el domingo 0.

%W El número de semana del año actual como un número decimal, rango de 00 a 53,
comenzando con el primer lunes como el primer día de la semana 01.

%x La representación de fecha preferida para la configuración regional actual sin la hora.

%X La representación de hora preferida para la configuración regional actual sin la fecha.

%y El año como un número decimal sin siglo (rango de 00 a 99).

%Y El año como número decimal incluido el siglo.

%Z La zona horaria, el nombre o la abreviatura.

%% Un carácter literal `% '.

Dependiendo del compilador de C y la biblioteca utilizados para compilar GPP, puede haber más conversión
especificadores disponibles. Consulte la documentación de su compilador para strftime () función.
Sin embargo, tenga en cuenta que es posible que los especificadores de conversión no enumerados anteriormente no sean portables a través de
instalaciones de GPP.

EJEMPLOS

Aquí hay un ejemplo básico que se explica por sí mismo en modo estándar o cpp:

#define FOO Esto es
#define BAR un mensaje.
#define concat # 1 # 2
concat (FOO, BAR)
#ifeq (concat (foo, bar)) (foo bar)
Esta es la salida.
#else
Esto no es una salida.
#terminara si

Usando nombres de argumentos, el concat macro podría definirse alternativamente como

#define concat (x, y) xy

En el modo TeX y usando el nombre de los argumentos, el mismo ejemplo se convierte en:

\ define {FOO} {Esto es}
\ define {BAR} {un mensaje.}
\ define {\ concat {x} {y}} {\ x \ y}
\ concat {\ FOO} {\ BAR}
\ ifeq {\ concat {foo} {bar}} {foo bar}
Esta es la salida.
\demás
Esto no es una salida.
\terminara si

En modo HTML y sin nombrar argumentos, se obtiene de manera similar:

<#define FOO | Esto es>
<#define BAR | un mensaje.>
<#define concat | # 1 # 2>
<#concat <#FOO> | <#BAR >>
<#ifeq <#concat foo | bar> | foo bar>
Esta es la salida.
<#else>
Esto no es una salida.
<#endif>

El siguiente ejemplo (en modo estándar) ilustra el uso del carácter de comillas:

#define FOO Esto es \
una definición multilínea.
#define BLAH (x) Mi argumento es x
BLAH (urf)
\ BLAH (urf)

Tenga en cuenta que la definición de varias líneas también es válida en los modos cpp y Prolog a pesar de la
ausencia del carácter de comillas, porque '\' seguido de una nueva línea se interpreta como un
comentar y descartar.

En el modo cpp, las cadenas C y los comentarios se entienden como tales, como lo ilustra el
siguiente ejemplo:

#definir BLAH foo
BLA, BLA, BLA */
'¡Es una / * cadena * /!'

La principal diferencia entre el modo Prolog y el modo cpp es el manejo de cadenas y
comentarios: en Prolog, una cadena '...' no puede comenzar inmediatamente después de un dígito, y un /*...*/
Es posible que el comentario no comience inmediatamente después de un carácter de operador. Además, los comentarios son
no se eliminan de la salida a menos que ocurran en un #comando.

Las diferencias entre el modo cpp y el modo predeterminado son más profundas: en el modo predeterminado #comandos
pueden comenzar en cualquier lugar, mientras que en el modo cpp deben estar al comienzo de una línea; el valor por defecto
mode no tiene conocimiento de comentarios y cadenas, pero tiene un carácter de comillas ('\'), mientras que cpp
El modo tiene especificaciones extensas de comentarios / cadenas, pero no incluye comillas. Además, el
Los argumentos de las meta-macros deben estar correctamente entre paréntesis en el modo predeterminado, mientras que no
la verificación se realiza en modo cpp.

Esto hace que sea más fácil anidar llamadas de meta-macro en el modo predeterminado que en el modo cpp. Para
Por ejemplo, considere la siguiente entrada en modo HTML, que prueba la disponibilidad del
#ejecutivo mando:

<#ifeq <#exec echo blah> | blah
> #exec permitido <#else> #exec no permitido <#endif>

No hay un modo cpp equivalente, mientras que en el modo predeterminado se puede traducir fácilmente como

#ifeq (#exec echo bla
) (bla
)
\ #exec permitido
#else
\ #exec no permitido
#terminara si

Para anidar llamadas de meta-macro en modo cpp es necesario modificar el modo
descripción, ya sea cambiando la sintaxis de la llamada meta-macro, o más elegantemente definiendo
una cadena silenciosa y utilizando el hecho de que el contexto al comienzo de una evaluación
cadena es un carácter de nueva línea:

#mode string QQQ "$" "$"
#ifeq $ # exec echo blah
$ $ bla
$
\ #exec permitido
#else
\ #exec no permitido
#terminara si

Sin embargo, tenga en cuenta que los comentarios / cadenas no se pueden anidar ("..." dentro de $ ... $ iría
sin ser detectado), por lo que hay que tener cuidado con lo que se debe incluir dentro de un
cadena evaluada. En este ejemplo, el anidamiento suelto de meta-macro introducido en la versión 2.1
permite utilizar la siguiente versión más sencilla:

#ifeq blah #ejec echo -n blah
\ #exec permitido
#else
\ #exec no permitido
#terminara si

Recuerde que las macros sin argumentos se entienden realmente como alias cuando se
llamado con argumentos, como se ilustra en el siguiente ejemplo (modo predeterminado o cpp):

#define DUP (x) xx
#define FOO y dije: DUP
FOO (bla)

La utilidad del #defeval La meta-macro se muestra en el siguiente ejemplo en modo HTML:

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

La razón por la cual #defeval Lo que se necesita es que, dado que todo se evalúa en una sola pasada,
la entrada que dará como resultado la llamada macro deseada debe ser generada por un primer
evaluación de los argumentos pasados ​​a APPLY antes de ser evaluados por segunda vez.

Para traducir este ejemplo en el modo predeterminado, es necesario recurrir a los paréntesis para
para anidar la llamada #defeval dentro de la definición de APPLY, pero necesita hacerlo sin
dando salida a los paréntesis. La solucion mas facil es

#define BALANCE (x) x
#define APPLY (f, v) BALANCE (#defeval TEMP f
TEMPERATURA (v))
#define foo (x) x y x
APLICAR (\ foo, BLAH)

Como se explicó anteriormente, la versión más simple en modo cpp se basa en definir una evaluación silenciosa
cadena para desempeñar el papel de la macro BALANCE.

El siguiente ejemplo (modo predeterminado o cpp) demuestra la evaluación aritmética:

#definir x 4
La respuesta es:
#eval x * x + 2 * (16-x) + 1998% x

# si está definido (x) &&! (3 * x + 5> 17)
Esto debería ser una salida.
#terminara si

Para terminar, aquí hay algunos ejemplos relacionados con el cambio de modo. El siguiente ejemplo es
autoexplicativo (a partir del modo predeterminado):

#empuje de modo
#define f (x) xx
#mode estándar tex
\ f {blah}
\ mode {string} {"$" "$"}
\ mode {comentario} {"/ *" "* /"}
$ \ f {urf} $ / * bla * /
\ define {FOO} {bar / * y algo más * /}
\ mode {pop}
f ($ FOO $)

Un buen ejemplo en el que un modo definido por el usuario se vuelve útil es la fuente GPP de este documento.
(disponible con la distribución del código fuente de GPP).

Otra aplicación interesante es forzar selectivamente la evaluación de macros en cadenas C
cuando está en modo cpp. Por ejemplo, considere la siguiente entrada:

#define blah (x) "y él dijo: x"
bla (foo)

Obviamente, uno querría el parámetro x para expandirse dentro de la cuerda. Existen
varias formas de solucionar este problema:

#empuje de modo
#mode nostring "\" "
#define blah (x) "y él dijo: x"
#modo pop

#mode quote "` "
#define blah (x) `" y él dijo: x` "

#mode string QQQ "$$" "$$"
#define blah (x) $$ "y dijo: x" $$

El primer método es muy natural, pero tiene el inconveniente de ser largo y
neutralizar la semántica de cadenas, de modo que tener una instancia no evaluada de 'x' en el
cadena, o una aparición de '/ *', sería imposible sin recurrir a más
contorsiones.

El segundo método es un poco más eficiente porque la presencia local de una cotización
El carácter facilita el control de lo que se evalúa y lo que no, pero tiene la
inconveniente de que a veces es imposible encontrar un carácter de cita razonable sin
tener que alterar significativamente el archivo fuente o encerrarlo dentro de un #modo empujar / hacer estallar
construir. Por ejemplo, cualquier aparición de '/ *' en la cadena debería estar entre comillas.

El último método demuestra la eficiencia de las cadenas evaluadas en el contexto de
evaluación selectiva: dado que los comentarios / cadenas no se pueden anidar, cualquier aparición de '"' o
'/ *' dentro de '$$' obtiene la salida como texto sin formato, como se esperaba dentro de una cadena, y solo
La evaluación macro está habilitada. También tenga en cuenta que hay mucha más libertad en la elección de un
delimitador de cadena que en la elección de un carácter de comillas.

A partir de la versión 2.1, las llamadas a meta-macro se pueden anidar de manera más eficiente en forma predeterminada, cpp
y modos Prolog. Esto facilita la creación de una versión de usuario de una meta-macro, o
incrementar un contador:

#define myeval #eval # 1

#definir x 1
# defensa x #eval x + 1

ADVANCED EJEMPLOS

A continuación se muestran algunos ejemplos de construcciones avanzadas que utilizan GPP. Suelen ser bastante incómodos
y debe considerarse como evidencia de las limitaciones de GPP.

El primer ejemplo es una macro recursiva. El principal problema es que (dado que GPP evalúa
todo) una macro recursiva debe tener mucho cuidado con la forma en que la recursividad es
terminado para evitar un comportamiento indefinido (la mayoría de las veces, GPP simplemente fallará).
En particular, confiando en un # if / # else / # endif construir para terminar la recursividad no es posible
y da como resultado un bucle infinito, porque GPP escanea las llamadas de macro de usuario incluso en el
rama no evaluada del bloque condicional. Una forma segura de proceder es, por ejemplo,
sigue (damos el ejemplo en modo TeX):

\ define {cuenta atrás} {
\ if {# 1}
# 1 ...
\ define {loop} {\ countdown}
\demás
Hecho.
\ define {bucle} {}
\terminara si
\ loop {\ eval {# 1-1}}
}
\ countdown {10}

Otro ejemplo, en modo cpp:

#mode string QQQ "$" "$"
#define triángulo (x, y) y \
$ # if longitud (y)
$ # definir iter $ $ # endif
$ iter (x, * y)
triángulo(20)

El siguiente es un intento (desafortunadamente muy débil) de implementar funcional
abstracción en GPP (en modo estándar). Entender este ejemplo y por qué no se puede hacer
mucho más simple es un ejercicio que se deja al lector curioso.

#mode string "` "" `" "\\"
#define ASIS (x) x
#define SILENT (x) ASIS ()
#define EVAL (x, f, v) SILENT (
#mode string QQQ "` "" `" "\\"
#defeval TEMP0 x
#defeval TEMP1 (
\ #define \ TEMP2 (TEMP0) f
)
TEMP1
) TEMP2 (v)
#define LAMBDA (x, f, v) SILENT (
#ifneq (v) ()
#define TEMP3 (a, b, c) EVAL (a, b, c)
#else
#define TEMP3 (a, b, c) \ LAMBDA (a, b)
#terminara si
) TEMP3 (x, f, v)
#define EVALAMBDA (x, y) SILENT (
#defeval TEMP4 x
#defeval TEMP5 y
)
#define APLICAR (f, v) SILENCIOSO (
#defeval TEMP6 ASIS (\ EVA) f
TEMP6
) EVAL (TEMP4, TEMP5, v)

Esto produce los siguientes resultados:

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)

APLICAR (f, bla)
=> bla * bla

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

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

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

#define test LAMBDA (y, `# ifeq y urf
y es urf # else
y no es urf # endif
`)
APLICAR (prueba, urf)
=> urf es urf

APLICAR (prueba, foo)
=> foo no es urf

Use gpp en línea usando los servicios de onworks.net