re2c - Online en la nube

PROGRAMA:

NOMBRE

re2c - convierte expresiones regulares a código C / C ++

SINOPSIS

re2c [OPCIONES] ARCHIVO

DESCRIPCIÓN

re2c es un generador de lexer para C / C ++. Encuentra especificaciones de expresiones regulares dentro de
C / C ++ comenta y los reemplaza con un DFA codificado. El usuario debe proporcionar algunos
código de interfaz para controlar y personalizar el DFA generado.

OPCIONES

-? -h --ayuda
Invoca una pequeña ayuda.

-b --bit-vectores
Implica -s. Utilice también vectores de bits en el intento de extraer un mejor código del
compilador. Más útil para especificaciones con más de unas pocas palabras clave (por ejemplo, para
la mayoría de los lenguajes de programación).

-c --condiciones
Se utiliza para admitir (f) compatibilidad con condiciones similares a lex.

-d --salida de depuración
Crea un analizador que vuelca información sobre la posición actual y en la que
indica el analizador mientras analiza la entrada. Esto es útil para depurar problemas del analizador.
y estados. Si usa este interruptor, necesita definir una macro YYDEBUG que sea
llamado como una función con dos parámetros: vacío YYDEBUG (En t estado, tanque Actual).
El primer parámetro recibe el estado o -1 y el segundo parámetro recibe el
entrada en el cursor actual.

-D --emit-punto
Emite datos de puntos de Graphviz. Luego se puede procesar con, por ejemplo, punto -Tpng entrada.punto >
salida.png. Tenga en cuenta que los escáneres con muchos estados pueden fallar.

-e --bce
Genere un analizador que admita EBCDIC. El código generado puede tratar con cualquier
carácter hasta 0xFF. En este modo re2c asume que el tamaño del carácter de entrada es 1
byte. Este interruptor es incompatible con -w, -x, -u y -8.

-f --estado-almacenable
Genere un escáner con soporte para estado almacenable.

-F --sintaxis-flexible
Soporte parcial para sintaxis flexible. Cuando esta bandera está activa, entonces se nombran definiciones
debe estar rodeado por llaves y puede definirse sin un signo igual y el
terminando el punto y coma. En cambio, los nombres se tratan como cadenas directas entre comillas dobles.

-g --computado-gotos
Genere un escáner que utilice la función goto calculada de GCC. Es decir re2c
genera tablas de salto siempre que una decisión es de cierta complejidad (por ejemplo, una gran cantidad de
si las condiciones son necesarias de otro modo). Esto solo se puede utilizar con GCC y produce
salida que no se puede compilar con ningún otro compilador. Tenga en cuenta que esto implica -b
y que el umbral de complejidad se puede configurar utilizando la configuración in situ
cgoto: umbral.

-i --sin-depuración-info
No salida #línea información. Esto es útil cuando desea utilizar una herramienta CMS con
los re2c salida que puede desear si no requiere que sus usuarios tengan re2c
ellos mismos al construir a partir de su fuente.

-o SALIDA --salida = SALIDA
Especifica el SALIDA archivo.

-r --reutilizable
Permite la reutilización de definiciones de escáner con / *! use: re2c */ después de / *! reglas: re2c */. En
este modo no / *! re2c */ bloque y exactamente uno / *! reglas: re2c */ debe estar presente.
Las reglas están siendo guardadas y utilizadas por todos / *! use: re2c */ bloque que sigue.
Estos bloques pueden contener configuraciones in situ, especialmente re2c: banderas: e,
re2c: banderas: w, re2c: banderas: x, re2c: banderas: u y re2c: banderas: 8. De esa manera es posible
para crear el mismo escáner varias veces para diferentes tipos de caracteres, diferentes
mecanismos de entrada o diferentes mecanismos de salida. los / *! use: re2c */ los bloques pueden
también contienen reglas adicionales que se agregarán al conjunto de reglas en
/ *! reglas: re2c */.

-s - anidado-ifs
Genere ifs anidados para algunos conmutadores. Muchos compiladores necesitan esta ayuda para generar
mejor código.

-t CABECERA --type-header = ENCABEZADO
Créar un CABECERA archivo que contiene tipos para el soporte de condición de tipo lex (f).
Esto solo se puede activar cuando -c Está en uso.

-u --unicode
Genere un analizador que admita UTF-32. El código generado puede tratar con cualquier
Carácter Unicode hasta 0x10FFFF. En este modo re2c asume ese carácter de entrada
el tamaño es de 4 bytes. Este interruptor es incompatible con -e, -w, -x y -8. Esto implica
-s.

-v --versión
Muestra información de la versión.

-V --verno
Muestre la versión como un número XXYYZZ.

-w - caracteres anchos
Genere un analizador que admita UCS-2. El código generado puede tratar con cualquier
Carácter Unicode hasta 0xFFFF. En este modo re2c asume ese carácter de entrada
el tamaño es de 2 bytes. Este interruptor es incompatible con -e, -x, -u y -8. Esto implica
-s.

-x --utf-16
Genere un analizador que admita UTF-16. El código generado puede tratar con cualquier
Carácter Unicode hasta 0x10FFFF. En este modo re2c asume ese carácter de entrada
el tamaño es de 2 bytes. Este interruptor es incompatible con -e, -w, -u y -8. Esto implica
-s.

-8 --utf-8
Genere un analizador que admita UTF-8. El código generado puede tratar con cualquier
Carácter Unicode hasta 0x10FFFF. En este modo re2c asume ese carácter de entrada
el tamaño es de 1 byte. Este interruptor es incompatible con -e, -w, -x y -u.

no distingue entre mayúsculas y minúsculas
Todas las cadenas no distinguen entre mayúsculas y minúsculas, por lo que todas las "-expresiones se tratan de la misma manera
'-expresiones son.

- caso invertido
Invierte el significado de cadenas entre comillas simples y dobles. Con este single switch
las comillas distinguen entre mayúsculas y minúsculas y las comillas dobles distinguen entre mayúsculas y minúsculas.

--no-generación-fecha
Suprime la salida de fecha en el archivo generado.

--no-generación-fecha
Suprime la salida de la versión en el archivo generado.

--política-de-codificación POLÍTICA
Especifique cómo re2c debe tratar a los sustitutos Unicode. POLÍTICA puede ser uno de los siguientes:
fallar (abortar con error cuando se encuentra un sustituto), sustitutas (sustituye silenciosamente
sustituto con punto de código de error 0xFFFD), pasar por alto (tratar a los sustitutos como código normal
puntos). Por defecto re2c ignora los sustitutos (para compatibilidad con versiones anteriores). Unicode
estándar dice que los sustitutos independientes son puntos de código inválidos, pero diferentes
las bibliotecas y los programas los tratan de manera diferente.

--aporte ENTRADA
Especifique la API de entrada re2c. ENTRADA puede ser uno de los siguientes: tu préstamo estudiantil, personalizado.

-S --esqueleto
En lugar de incrustar código generado por re2c en la fuente C / C ++, genere un
programa autónomo para el mismo DFA. Más útil para la corrección y
pruebas de rendimiento.

--clase vacía POLÍTICA
Qué hacer si el usuario ingresa una clase de carácter vacía. POLÍTICA puede ser uno de los
siguientes: partido-vacío (coincide con la entrada vacía: bastante ilógico, pero este es el
predeterminado por motivos de compatibilidad con versiones anteriores), ninguno coincidente (no coincide en ningún
aporte), error (error de compilación). Tenga en cuenta que hay varias formas de construir
clase vacía, por ejemplo: [], [^ \ x00- \ xFF], [\ x00- \ xFF] [\ x00- \ xFF].

--dfa-minimización <tabla | moore>
Algoritmo interno utilizado por re2c para minimizar DFA (el valor predeterminado es Moore). Ambos mesa
llenado y los algoritmos de Moore deben producir DFA idéntico (hasta estados
reetiquetado). El algoritmo de llenado de tablas es mucho más simple y lento; sirve como un
Implementación de referencia.

-1 - pase único
En desuso y no hace nada (ahora el pase único es predeterminado).

-W Active todas las advertencias.

-Error
Convierta las advertencias en errores. Tenga en cuenta que esta opción no activa ninguna
advertencias, solo afecta a aquellas advertencias que se han activado hasta ahora o que serán
encendido más tarde.

-W
Activar individual advertencia.

-Wno-
Apagar individual advertencia.

-Werror-
Activar individual advertencia y tratarlo como un error (esto implica -W).

-Wno-error-
No trates esto en particular advertencia como error. Esto no apaga la advertencia
misma.

-Condición-orden
Advierte si el programa generado hace suposiciones implícitas sobre la numeración de condiciones.
Uno debería usar -t, --tipo-encabezado Opción o / *! tipos: re2c * / directiva a
generar mapeo de nombres de condiciones a números y usar condiciones autogeneradas
Nombres

-Clase-personaje-Wempty
Advertir si la expresión regular contiene una clase de carácter vacía. Desde el punto racional
de vista tratando de hacer coincidir la clase de caracteres vacía no tiene sentido: siempre debe
fallar. Sin embargo, por razones de compatibilidad con versiones anteriores re2c permite carácter vacío
class y lo trata como una cadena vacía. Usar --clase vacía opción para cambiar por defecto
comportamiento.

-Wmatch-cadena-vacía
Advierte si la expresión regular en una regla es anulable (coincide con una cadena vacía). Si DFA
se ejecuta en un bucle y la coincidencia vacía no es intencional (la posición de entrada no está avanzada
manualmente), lexer puede quedarse atascado en un ciclo eterno.

-Wswapped-rango
Advertir si el límite inferior del rango es mayor que el límite superior. Defecto re2c el comportamiento es
intercambiar silenciosamente los límites del rango.

-Flujo-de-control-definido-wun
Advertir si algunas cadenas de entrada causan un flujo de control indefinido en lexer (el error
se informan patrones). Este es el error más peligroso y común. Puede ser
se arregla fácilmente agregando una regla predeterminada * (esta regla tiene la prioridad más baja, coincide
cualquier unidad de código y consume exactamente una unidad de código).

-Escape inútil
Advierte si un símbolo se escapa cuando no debería ser. Por defecto, re2c ignora silenciosamente
escape, pero esto también puede indicar un error tipográfico o un error en la secuencia de escape.

INTERFAZ CÓDIGO

El usuario debe proporcionar el código de interfaz en forma de código C / C ++ (macros, funciones,
variables, etc.) o en forma de EN SU LUGAR Configuraciones. Qué símbolos deben definirse
y cuáles son opcionales depende de un caso de uso particular.

TIPOYCOND
In -c modo que puedes usar -t para generar un archivo que contenga la enumeración utilizada como
condiciones. Cada uno de los valores se refiere a una condición de un conjunto de reglas.

YYCTXMARKER
valor l de tipo TIPO YYC *. El código generado guarda el retroceso del contexto final
información en YYCTXMARKER. El usuario solo necesita definir esta macro si un escáner
La especificación utiliza el contexto final en una o más de sus expresiones regulares.

TIPO YYC
Tipo utilizado para contener un símbolo de entrada (unidad de código). Generalmente tanque or no firmado tanque for
ASCII, EBCDIC y UTF-8, no firmado short para UTF-16 o UCS-2 y no firmado int for
UTF-32.

YCURSOR
valor l de tipo TIPO YYC * que apunta al símbolo de entrada actual. El generado
avances en el código YCURSOR como los símbolos coinciden. Al entrar, YCURSOR se supone que
apunte al primer carácter del token actual. Al salir, YCURSOR apuntará a
el primer carácter del siguiente token.

YYDEBUG (estado, Actual)
Esto solo es necesario si el -d se especificó la bandera. Permite depurar fácilmente el
analizador generado llamando a una función definida por el usuario para cada estado. La función
debe tener la siguiente firma: vacío YYDEBUG (En t estado, tanque Actual).
El primer parámetro recibe el estado o -1 y el segundo parámetro recibe el
entrada en el cursor actual.

LLENAR (norte)
El código generado "llama" " LLENAR (norte) cuando el búfer necesita (re) llenado: al menos
n deben proporcionarse caracteres adicionales. LLENAR (norte) debería ajustar YCURSOR,
YYLIMITE, MARCADOR YY y YYCTXMARKER según sea necesario. Tenga en cuenta que para la programación típica
idiomas n será la longitud de la palabra clave más larga más una. El usuario puede colocar
un comentario del formulario / *! max: re2c * / para insertar YYMAXFILL definición que se establece en
el valor máximo de longitud.

YYGETCONDICIÓN ()
Esta definición se usa para obtener la condición antes de ingresar el código del escáner cuando
usando -c cambiar. El valor debe inicializarse con un valor de la enumeración.
TIPOYCOND tipo.

ESTADOYYGET ()
El usuario solo necesita definir esta macro si el -f se especificó la bandera. En eso
caso, el código generado "llama" ESTADOYYGET () al comienzo del escáner
para obtener el estado guardado. ESTADOYYGET () debe devolver un entero con signo. los
El valor debe ser -1, lo que indica que el escáner se ingresa por primera vez,
o un valor previamente guardado por ESTADOYYSET (S). En el segundo caso, el escáner
reanudar las operaciones justo después de donde el último LLENAR (norte) fue llamado.

YYLIMITE
Expresión de tipo TIPO YYC * que marca el final del búfer YYLIMIT [-1] son los
último carácter del búfer). El código generado se compara repetidamente YCURSOR a
YYLIMITE para determinar cuándo el búfer necesita (re) llenarse.

MARCADOR YY
valor l de tipo TIPO YYC *. El código generado guarda la información de retroceso en
MARCADOR YY. Es posible que algunos escáneres sencillos no utilicen esto.

YYMAXFILL
Esto será definido automáticamente por / *! max: re2c * / bloques como se explicó anteriormente.

YYSETCONDICIÓN (C)
Esta definición se utiliza para establecer la condición en las reglas de transición. Esto es solo ser
usado cuando -c está activo y se están utilizando reglas de transición.

ESTADOYYSET (S)
El usuario solo necesita definir esta macro si el -f se especificó la bandera. En eso
caso, el código generado "llama" ESTADOYYSET justo antes de llamar LLENAR (norte).
parámetro para ESTADOYYSET es un entero con signo que identifica de forma exclusiva el
en vez de LLENAR (norte) que está a punto de ser llamado. Si el usuario desea guardar el
estado del escáner y tener LLENAR (norte) volver a la persona que llama, todo lo que tiene que hacer es
almacenar ese identificador único en una variable. Más tarde, cuando se llama al escaneado
de nuevo, llamará ESTADOYYGET () y reanudar la ejecución justo donde la dejó. los
el código generado contendrá tanto ESTADOYYSET (S) y ESTADOYYGET aunque LLENAR (norte)
está siendo deshabilitado.

SINTAXIS

Código para re2c consta de un conjunto de REGLAS, LLAMADO DEFINICIONES y EN SU LUGAR Configuraciones.

REGLAS
Las reglas consisten en una expresión regular (ver REGULAR EXPRESIONES) junto con un bloque de
Código C / C ++ que se ejecutará cuando se haga coincidir la expresión regular asociada. usted
puede iniciar el código con una llave de apertura o la secuencia :=. Cuando el codigo
con una llave rizada entonces re2c cuenta la profundidad de la riostra y deja de buscar código
automáticamente. De lo contrario, no se permiten llaves y re2c deja de buscar código en
la primera línea que no comienza con espacios en blanco. Si dos o más reglas se superponen, el
se prefiere la primera regla.
expresión regular { C / C ++ código }

expresión regular := C / C ++ código

Hay una regla especial: regla predeterminada *
* { C / C ++ código }

* := C / C ++ código

Tenga en cuenta que la regla predeterminada * difiere de [^]: la regla predeterminada tiene la prioridad más baja, coincide
cualquier unidad de código (válida o no válida) y siempre consume un carácter; tiempo [^]
coincide con cualquier punto de código válido (no unidad de código) y puede consumir varias unidades de código. De hecho,
cuando se utiliza codificación de longitud variable, * es la única forma posible de hacer coincidir una entrada no válida
personaje (ver CODIFICACIONES para más detalles).

If -c está activa, entonces cada expresión regular está precedida por una lista de comas separadas
nombres de condiciones. Además de las reglas de nomenclatura normales, hay dos casos especiales: <*> (tales reglas
se fusionan con todas las condiciones) y <> (tal la regla no puede tener un asociado regular
expresión, su código se fusiona con todas las acciones). Las reglas no vacías pueden especificar más
la nueva condición. En ese caso re2c generará el código necesario para cambiar el
condición automáticamente. Las reglas pueden usar : => como un atajo para generar código automáticamente
que no solo establece el nuevo estado de condición, sino que también continúa la ejecución con el nuevo
estado. No se debe utilizar una regla de acceso directo en un bucle donde hay un código entre el inicio
del bucle y el re2c bloquear a menos que re2c: cond: goto se cambia a continue. Si el código es
necesario antes de todas las reglas (aunque no simples saltos) puedes hacerlo usando
pseudo-reglas.
expresión regular { C / C ++ código }

expresión regular := C / C ++ código

* { C / C ++ código }

* := C / C ++ código

expresión regular => condición { C / C ++ código }

expresión regular => condición := C / C ++ código

* => condición { C / C ++ código }

* => condición := C / C ++ código

expresión regular : => condición

<*> expresión regular { C / C ++ código }

<*> expresión regular := C / C ++ código

<*> * { C / C ++ código }

<*> * := C / C ++ código

<*> expresión regular => condición { C / C ++ código }

<*> expresión regular => condición := C / C ++ código

<*> * => condición { C / C ++ código }

<*> * => condición := C / C ++ código

<*> expresión regular : => condición

<> { C / C ++ código }

<> := C / C ++ código

<> => condición { C / C ++ código }

<> => condición := C / C ++ código

<> : => condición

<> : => condición

<! lista de condiciones> { C / C ++ código }

<! lista de condiciones> := C / C ++ código

{ C / C ++ código }

:= C / C ++ código

LLAMADO DEFINICIONES
Las definiciones nombradas tienen la forma:
nombre = expresión regular;

If -F está activo, entonces las definiciones nombradas también tienen la forma:
nombre { expresión regular }

EN SU LUGAR Configuraciones
re2c: condprefix = yyc;
Permite especificar el prefijo utilizado para las etiquetas de condición. Ese es este texto
antepuesto a cualquier etiqueta de condición en el archivo de salida generado.

re2c: condenumprefix = yyc;
Permite especificar el prefijo utilizado para los valores de condición. Ese es este texto
antepuesto a cualquier valor de enumeración de condición en el archivo de salida generado.

re2c: cond: divisor = /* *********************************** */ ;
Permite personalizar el devider para bloques de condición. Puedes usar @@ para poner el
nombre de la condición o personalice el marcador de posición usando re2c: cond: divisor @ cond.

re2c: cond: divisor @ cond = @@;
Especifica el marcador de posición que se reemplazará con el nombre de la condición en
re2c: cond: divisor.

re2c: cond: goto = Goto @@; ;
Permite personalizar las sentencias de condición goto utilizadas con : => reglas de estilo.
Puedes usar @@ para poner el nombre de la condición o ustomizar el marcador de posición usando
re2c: cond: goto @ cond. También puede cambiar esto a continuar, que te permitiría
para continuar con el siguiente ciclo de bucle, incluido cualquier código entre el inicio del bucle y re2c
bloquear.

re2c: cond: goto @ cond = @@;
Especifica el marcador de posición que se reemplazará con la etiqueta de condición en
re2c: cond: goto.

re2c: sangría: arriba = 0;
Especifica el número mínimo de sangría que se utilizará. Requiere un valor numérico
mayor o igual a cero.

re2c: sangría: cadena = \t ;
Especifica la cadena que se utilizará para la sangría. Requiere una cadena que debe contener
solo espacios en blanco a menos que lo necesite para herramientas externas. La forma más sencilla de especificar
espacios es incluirlos entre comillas simples o dobles. Si no quieres ninguno
sangría en absoluto, simplemente puede establecer esto en "".

re2c: yych: conversión = 0;
Cuando este ajuste es distinto de cero, entonces re2c genera automáticamente el código de conversión
cada vez que se lee yych. En este caso, el tipo debe definirse utilizando
re2c: define: YYCTYPE.

re2c: yych: emitir = 1;
Generación de yych puede suprimirse estableciendo esto en 0.

re2c: yybm: hex = 0;
Si se establece en cero, se está utilizando una tabla decimal; de lo contrario, se utilizará una tabla hexadecimal.
generado.

re2c: yyfill: enable = 1;
Establezca esto en cero para suprimir la generación de LLENAR (norte). Al usar esto, asegúrese de
Verifique que el escáner generado no lea detrás de la entrada. Permitiendo esto
El comportamiento puede introducir graves problemas de seguridad en sus programas.

re2c: yyfill: check = 1;
Esto se puede establecer en 0 para suprimir la salida de la condición previa usando YCURSOR y
YYLIMITE que se vuelve útil cuando YYLIMITE + YYMAXFILL siempre es accesible.

re2c: define: YYFILL = LLENAR ;
Sustitución de LLENAR. Tenga en cuenta que por defecto re2c genera argumento entre llaves y
punto y coma después LLENAR. Si necesitas hacer LLENAR una declaración arbitraria más bien
que una llamada re2c: define: YYFILL: desnudo a distinto de cero y usar
re2c: define: YYFILL @ len para denotar un parámetro formal dentro de LLENAR cuerpo.

re2c: define: YYFILL @ len = @@ ;
Cualquier aparición de este texto dentro de LLENAR será reemplazado por el actual
argumento.

re2c: yyfill: parámetro = 1;
Controla el argumento entre llaves después de LLENAR. Si es cero, se omite el análisis. Si
distinto de cero, el argumento se genera a menos que re2c: define: YYFILL: desnudo se establece en un valor distinto de cero.

re2c: define: YYFILL: desnudo = 0;
Controla el argumento entre llaves y punto y coma después LLENAR. Si es cero, tanto agrument como
se omite el punto y coma. Si no es cero, se genera un argumento a menos que
re2c: yyfill: parámetro se establece en cero y el punto y coma se genera incondicionalmente.

re2c: startlabel = 0;
Si se establece en un número entero distinto de cero, la etiqueta de inicio de los siguientes bloques de escáner
generarse incluso si no lo utiliza el propio escáner. De lo contrario, lo normal yy0 como uno
La etiqueta de inicio solo se genera si es necesario. Si se establece en un valor de texto, entonces una etiqueta
con ese texto se generará independientemente de si la etiqueta de inicio normal es
siendo utilizado o no. Este ajuste se restablece a 0 después de que se haya colocado una etiqueta de inicio.
generado.

re2c: labelprefix = yy ;
Permite cambiar el prefijo de las etiquetas numeradas. El valor predeterminado es yy y puede ser
establezca cualquier cadena que sea una etiqueta válida.

re2c: estado: abortar = 0;
Cuando no es cero y cambia -f está activo entonces el ESTADOYYGET bloque contendrá un
caso predeterminado que aborta y un caso -1 se utiliza para la inicialización.

re2c: estado: nextlabel = 0;
Usado cuando -f está activo para controlar si el ESTADOYYGET El bloque va seguido de un
yySiguiente: línea de etiqueta. En lugar de usar aaSiguiente normalmente también puedes usar la configuración
etiqueta de inicio para forzar una etiqueta de inicio específica o por defecto para yy0 como etiqueta de inicio.
En lugar de utilizar una etiqueta dedicada, a menudo es mejor separar las ESTADOYYGET
código del código del escáner real colocando un / *! getstate: re2c * / comentario.

re2c: cgoto: umbral = 9;
Cuándo -g está activo este valor especifica el umbral de complejidad que desencadena
generación de tablas de salto en lugar de utilizar if anidados y campos de bits de decisión. los
El umbral se compara con una estimación calculada de si es necesario donde cada
El mapa de bits usado divide el umbral por 2.

re2c: yych: conversión = 0;
Cuando la entrada usa caracteres firmados y -s or -b los interruptores están en efecto re2c
permite que uno se convierta automáticamente al tipo de carácter sin firmar que luego se
necesario para su carácter único interno. Cuando esta configuración es cero o un vacío
cadena la conversión está deshabilitada. Usando un número distinto de cero, se toma la conversión
desde TIPO YYC. Si eso viene dado por una configuración in situ, ese valor se está
usó. De lo contrario será (TIPO YCC) y los cambios a esa configuración no son
más tiempo posible. Cuando esta configuración es una cadena, se deben especificar las llaves. Ahora
asumiendo que su entrada es un tanque * búfer y está utilizando los interruptores mencionados anteriormente
puedes configurar TIPO YYC a no firmado tanque y este ajuste a 1 o (no firmado
carbonizarse).

re2c: define: YYCONDTYPE = TIPOYCOND ;
Enumeración utilizada para el apoyo de condiciones con -c modo.

re2c: definir: YYCTXMARKER = YYCTXMARKER ;
Permite a uno sobrescribir la definición YYCTXMARKER y así evitarlo estableciendo el
valor al código real necesario.

re2c: define: YYCTYPE = TIPO YYC ;
Permite a uno sobrescribir la definición TIPO YYC y así evitarlo estableciendo el
valor al código real necesario.

re2c: define: YYCURSOR = YCURSOR ;
Permite a uno sobrescribir la definición YCURSOR y así evitarlo estableciendo el
valor al código real necesario.

re2c: define: YYDEBUG = YYDEBUG ;
Permite a uno sobrescribir la definición YYDEBUG y así evitarlo estableciendo el
valor al código real necesario.

re2c: define: YYGETCONDITION = YYGETCONDICIÓN ;
Sustitución de YYGETCONDICIÓN. Tenga en cuenta que por defecto re2c genera llaves después
YYGETCONDICIÓN. Conjunto re2c: define: YYGETCONDITION: desnudo a distinto de cero para omitir las llaves.

re2c: define: YYGETCONDITION: desnudo = 0;
Controla los frenos después YYGETCONDICIÓN. Si es cero, se omiten las llaves. Si no es cero,
Se generan llaves.

re2c: define: YYSETCONDITION = YYSETCONDICIÓN ;
Sustitución de YYSETCONDICIÓN. Tenga en cuenta que por defecto re2c genera argumento en
llaves y punto y coma después YYSETCONDICIÓN. Si necesitas hacer YYSETCONDICIÓN an
declaración arbitraria en lugar de una llamada, establecer re2c: define: YYSETCONDITION: desnudo a
distinto de cero y uso re2c: define: YYSETCONDITION @ cond para denotar un parámetro formal dentro
of YYSETCONDICIÓN cuerpo.

re2c: define: YYSETCONDITION @ cond = @@ ;
Cualquier aparición de este texto dentro de YYSETCONDICIÓN será reemplazado con el
argumento real.

re2c: define: YYSETCONDITION: desnudo = 0;
Controla el argumento entre llaves y punto y coma después YYSETCONDICIÓN. Si es cero, ambos
se omiten el grupo y el punto y coma. Si es distinto de cero, tanto el argumento como el punto y coma son
generado.

re2c: define: YYGETSTATE = ESTADOYYGET ;
Sustitución de ESTADOYYGET. Tenga en cuenta que por defecto re2c genera llaves después
ESTADOYYGET. Conjunto re2c: define: YYGETSTATE: desnudo a distinto de cero para omitir las llaves.

re2c: define: YYGETSTATE: desnudo = 0;
Controla los frenos después ESTADOYYGET. Si es cero, se omiten las llaves. Si es distinto de cero, llaves
son generadas.

re2c: define: YYSETSTATE = ESTADOYYSET ;
Sustitución de ESTADOYYSET. Tenga en cuenta que por defecto re2c genera argumento entre llaves
y punto y coma después ESTADOYYSET. Si necesitas hacer ESTADOYYSET un arbitrario
declaración en lugar de una llamada, establezca re2c: define: YYSETSTATE: desnudo a distinto de cero y usar
re2c: define: YYSETSTATE @ cond para denotar un parámetro formal dentro de ESTADOYYSET cuerpo.

re2c: define: YYSETSTATE @ estado = @@ ;
Cualquier aparición de este texto dentro de ESTADOYYSET será reemplazado por el actual
argumento.

re2c: define: YYSETSTATE: desnudo = 0;
Controla el argumento entre llaves y punto y coma después ESTADOYYSET. Si es cero, ambos se agrupan
y el punto y coma se omiten. Si es distinto de cero, se generan tanto el argumento como el punto y coma.

re2c: define: YYLIMIT = YYLIMITE ;
Permite a uno sobrescribir la definición YYLIMITE y así evitarlo estableciendo el
valor al código real necesario.

re2c: define: YYMARKER = MARCADOR YY ;
Permite a uno sobrescribir la definición MARCADOR YY y así evitarlo estableciendo el
valor al código real necesario.

re2c: etiqueta: yyFillLabel = yyRellenarEtiqueta ;
Permite sobrescribir el nombre de la etiqueta. yyRellenarEtiqueta.

re2c: label: yyNext = aaSiguiente ;
Permite sobrescribir el nombre de la etiqueta. aaSiguiente.

re2c: variable: yyaccept = yyacepto;
Permite sobrescribir el nombre de la variable. yyaceptar.

re2c: variable: yybm = yybm ;
Permite sobrescribir el nombre de la variable. yybm.

re2c: variable: yych = yych ;
Permite sobrescribir el nombre de la variable. yych.

re2c: variable: yyctable = yytable ;
Cuando ambos -c y -g están activos entonces re2c utiliza esta variable para generar una estática
mesa de salto para YYGETCONDICIÓN.

re2c: variable: yystable = estable ;
Obsoleto.

re2c: variable: yytarget = yyobjetivo ;
Permite sobrescribir el nombre de la variable. yyobjetivo.

REGULAR EXPRESIONES
"foo" cadena literal "foo". Se pueden utilizar secuencias de escape ANSI-C.

'foo' cadena literal "foo" (los caracteres [a-zA-Z] no distinguen entre mayúsculas y minúsculas). Escape ANSI-C
Se pueden utilizar secuencias.

[xyz] clase de personaje; en este caso, la expresión regular coincide con x, yo z.

[abj-oZ]
clase de carácter con un rango en ella; partidos a, b, cualquier carta de j atravesar o or Z.

[^ clase]
clase de caracteres invertidos.

r \ s coincidir con cualquiera r que no es s. r y s deben ser expresiones regulares que pueden ser
expresado como clases de caracteres.

r* cero o más ocurrencias de r.

r+ una o más ocurrencias de r.

r? opcional r.

(R) r; los paréntesis se utilizan para anular la precedencia.

r s r seguido por s (concatenación).

r | s ya sea r or s (alternativa).

r / s r pero solo si va seguido de s. Tenga en cuenta que s no es parte del texto coincidente.
Este tipo de expresión regular se denomina "contexto final". El contexto final puede
ser solo el final de una regla y no parte de una definición con nombre.

r {n} cerillas r exactamente n veces.

r {n,} cerillas r al menos n veces.

r {n, m} cerillas r al menos n veces, pero no más de m veces.

. coincidir con cualquier carácter excepto nueva línea.

nombre coincide con la definición nombrada según lo especificado por nombre sólo si -F esta apagado. Si -F está activo
entonces esto se comporta como si estuviera entre comillas dobles y coincide con la cadena
"nombre".

Las clases de caracteres y los literales de cadena pueden contener caracteres octales o hexadecimales.
definiciones y el siguiente conjunto de secuencias de escape: \a, \b, \f, \n, \r, \t, \v, \\. Un
El carácter octal se define mediante una barra invertida seguida de sus tres dígitos octales (p. ej. \ 377).
Los caracteres hexadecimales de 0 a 0xFF se definen mediante una barra invertida, una minúscula x y dos
dígitos hexadecimales (p. ej. \ x12). Los caracteres hexadecimales de 0x100 a 0xFFFF están definidos por
barra invertida, una minúscula \u o una caja superior \X y cuatro dígitos hexadecimales (p. ej.
\ u1234). Los caracteres hexadecimales de 0x10000 a 0xFFFFffff se definen mediante una barra invertida, una
caja superior \U y ocho dígitos hexadecimales (p. ej. \ U12345678).

La única regla portátil "cualquiera" es la regla predeterminada *.

ESCANEAR HE TRABAJADO ALMACENABLE ESTADOS

Cuando el -f se especifica la bandera, re2c genera un escáner que puede almacenar su estado actual,
volver a la persona que llama y luego reanudar las operaciones exactamente donde las dejó.

La operación predeterminada de re2c es un modelo de "extracción", en el que el escáner solicita información adicional
siempre que lo necesite. Sin embargo, este modo de funcionamiento asume que el escáner es el
"propietario" del ciclo de análisis, y eso no siempre es conveniente.

Normalmente, si hay un preprocesador delante del escáner en la secuencia, o para eso
importa cualquier otra fuente de datos de procedimiento, el escáner no puede "pedir" más datos a menos que
tanto el escáner como la fuente viven en hilos separados.

El -f flag es útil solo para esta situación: permite a los usuarios diseñar escáneres que funcionan en
un modelo "push", es decir, donde los datos se envían al escáner fragmento a fragmento. Cuando el escáner
se queda sin datos para consumir, simplemente almacena su estado y regresa a la persona que llama. Cuando mas
los datos de entrada se envían al escáner, que reanuda las operaciones exactamente donde las dejó.

Cambios necesarios en comparación con el modelo "pull":

· El usuario debe proporcionar macros ESTADOYYSET () y ESTADOYYGET (estado).

· Los -f opción inhibe la declaración de yych y yyaceptar. Entonces el usuario tiene que declarar
estas. Además, el usuario debe guardarlos y restaurarlos. En el ejemplo
ejemplos / push_model / push.re Estos se declaran como campos de la clase (C ++) de los cuales el
El escáner es un método, por lo que no es necesario guardarlos / restaurarlos explícitamente. Para C ellos
Por ejemplo, se podrían hacer macros que seleccionen campos de una estructura pasada como parámetro.
Alternativamente, podrían declararse como variables locales, guardadas con LLENAR (norte) cuando
decide regresar y se restablece en el ingreso a la función. Además, podría ser más
eficiente para salvar al estado de LLENAR (norte) because ESTADOYYSET (estado) se llama
incondicionalmente. LLENAR (norte) sin embargo no consigue estado como parámetro, por lo que tendríamos
para almacenar el estado en una variable local por ESTADOYYSET (estado).

· Modificar LLENAR (norte) para regresar (desde la función que lo llama) si se necesita más entrada.

· Modificar a la persona que llama para reconocer si se necesita más información y responder adecuadamente.

· El código generado contendrá un bloque de interruptores que se utiliza para restaurar el último estado
saltando detrás del corrspoding LLENAR (norte) llama. Este código se genera automáticamente
en el epílogo del primero / *! re2c */ cuadra. Es posible activar la generación del
ESTADOYYGET () bloquear antes colocando un / *! getstate: re2c * / comentario. Esto es especialmente
útil cuando el código del escáner debe estar envuelto dentro de un bucle.

Por favor mira ejemplos / push_model / push.re para modelo de escáner "push". El código generado puede ser
ajustado usando configuraciones in situ estado: abortar y estado: nextlabel.

ESCANEAR HE TRABAJADO CONDICIÓN SOPORTE

Puede ir precedido de expresiones regulares con una lista de nombres de condición cuando utilice el -c
cambiar. En este caso re2c genera bloques de escáner para cada condición. Donde cada uno de los
Los bloques generados tienen su propia condición previa. La condición previa viene dada por la interfaz
definir YYGETCONDITON () y debe ser de tipo TIPOYCOND.

Hay dos tipos de reglas especiales. Primero, las reglas de la condición. <*> se fusionan con todos
condiciones (tenga en cuenta que tienen menor prioridad que otras reglas de esa condición). Y
En segundo lugar, la lista de condiciones vacía le permite a uno proporcionar un bloque de código que no tiene un
parte del escáner. Lo que significa que no permite ninguna expresión regular. El valor de la condición
que se refiere a este bloque especial es siempre el que tiene el valor de enumeración 0. De esta manera
el código de esta regla especial se puede utilizar para inicializar un escáner. De ninguna manera
necesario tener estas reglas: pero a veces es útil tener un
estado de condición no inicializado.

Las reglas no vacías permiten especificar la nueva condición, lo que las convierte en reglas de transición.
Además de generar llamadas para definir YYSETCONDTICIÓN ningún otro código especial es
generado.

Hay otro tipo de reglas especiales que permiten anteponer código a cualquier bloque de código de
todas las reglas de un determinado conjunto de condiciones o para todos los bloques de código para todas las reglas. Esto puede ser
útil cuando alguna operación es común entre las reglas. Por ejemplo, esto se puede utilizar para almacenar
la longitud de la cadena escaneada. Estas reglas de configuración especiales comienzan con un signo de exclamación
seguido de una lista de condiciones <! condición, ... > o una estrella . Cuando el re2c
genera el código para una regla cuyo estado no tiene una regla de configuración y una configuración con estrella
está presente, ese código se utilizará como código de configuración.

CODIFICACIONES

re2c admite las siguientes codificaciones: ASCII (predeterminado), EBCDIC (-e), UCS-2 (-w), UTF-16
(-x), UTF-32 (-u) y UTF-8 (-8). Ver también configuración in situ re2c: banderas.

Los siguientes conceptos deben aclararse cuando se habla de codificación. El punto de código es un
número abstracto, que representa un símbolo de codificación único. La unidad de código es la unidad más pequeña
de memoria, que se utiliza en el texto codificado (corresponde a un carácter en la entrada
Arroyo). Se pueden necesitar una o más unidades de código para representar un solo punto de código, dependiendo
en la codificación. En la codificación de longitud fija, cada punto de código se representa con la misma
número de unidades de código. En la codificación de longitud variable, se pueden
representado con diferente número de unidades de código.

ASCII es una codificación de longitud fija. Su espacio de código incluye puntos de código 0x100, de 0 a
0xFF. Un punto de código se representa con exactamente una unidad de código de 1 byte, que tiene
el mismo valor que el punto de código. Tamaño de TIPO YYC debe ser de 1 byte.

EBCDIC es una codificación de longitud fija. Su espacio de código incluye puntos de código 0x100, de 0 a
0xFF. Un punto de código se representa con exactamente una unidad de código de 1 byte, que tiene
el mismo valor que el punto de código. Tamaño de TIPO YYC debe ser de 1 byte.

UCS-2 es una codificación de longitud fija. Su espacio de código incluye puntos de código 0x10000, de 0 a
0xFFFF. Un punto de código se representa con exactamente una unidad de código de 2 bytes, que tiene
el mismo valor que el punto de código. Tamaño de TIPO YYC debe ser de 2 bytes.

UTF-16 es una codificación de longitud variable. Su espacio de código incluye todos los puntos de código Unicode,
de 0 a 0xD7FF y de 0xE000 a 0x10FFFF. Un punto de código se representa con
una o dos unidades de código de 2 bytes. Tamaño de TIPO YYC debe ser de 2 bytes.

UTF-32 es una codificación de longitud fija. Su espacio de código incluye todos los puntos de código Unicode, desde 0
a 0xD7FF y de 0xE000 a 0x10FFFF. Un punto de código se representa con exactamente
una unidad de código de 4 bytes. Tamaño de TIPO YYC debe ser de 4 bytes.

UTF-8 es una codificación de longitud variable. Su espacio de código incluye todos los puntos de código Unicode,
de 0 a 0xD7FF y de 0xE000 a 0x10FFFF. Un punto de código se representa con
secuencia de una, dos, tres o cuatro unidades de código de 1 byte. Tamaño de TIPO YYC debe ser 1
byte.

En Unicode, los valores del rango 0xD800 a 0xDFFF (sustitutos) no son un código Unicode válido
puntos, cualquier secuencia codificada de unidades de código, que se correlacionaría con puntos de código Unicode en el
rango 0xD800-0xDFFF, está mal formado. El usuario puede controlar cómo re2c trata tan mal formado
secuencias con --política-de-codificación bandera (ver OPCIONES para una explicación completa).

Para algunas codificaciones, hay unidades de código que nunca ocurren en una secuencia codificada válida (por ejemplo,
0xFF byte en UTF-8). Si el escáner generado debe comprobar si hay una entrada no válida, el único
La forma de hacerlo es usar la regla predeterminada *. Tenga en cuenta que la regla de rango completo [^] no atrapará inválido
unidades de código cuando se utiliza codificación de longitud variable ([^] significa "todos los puntos de código válidos", mientras que
regla predeterminada * significa "todas las unidades de código posibles").

GENÉRICO ENTRADA API

re2c generalmente opera en la entrada usando primitivas tipo puntero YCURSOR, MARCADOR YY,
YYCTXMARKER y YYLIMITE.

API de entrada genérica (habilitada con --aporte personalizado interruptor) permite personalizar la entrada
operaciones. En este modo, re2c Expresará todas las operaciones sobre la entrada en términos de
siguientes primitivas:

┌───────────────┬───────────────────────────────── ──┐
│YPEEK () │ obtener el carácter de entrada actual │
├───────────────┼───────────────────────────────── ──┤
│YYSALTAR () │ avanzar al siguiente carácter │
├───────────────┼───────────────────────────────── ──┤
│YYBACKUP () │ posición de entrada de corriente de respaldo │
├───────────────┼───────────────────────────────── ──┤
│YYBACKUPPTX () │ posición de entrada de corriente de respaldo │
│ │ para el contexto final │
├───────────────┼───────────────────────────────── ──┤
│YRESTORE () │ restablecer la posición de entrada actual │
├───────────────┼───────────────────────────────── ──┤
│YYRESTORECTX () │ restablecer la posición de entrada actual │
│ │ para el contexto final │
├───────────────┼───────────────────────────────── ──┤
│YYLESSTHAN (norte) │ comprobar si menos de n entrada │
│ │ quedan caracteres │
└───────────────┴───────────────────────────────── ──┘

Un par de enlaces útiles que proporcionan algunos ejemplos:

1. http://skvadrik.github.io/aleph_null/posts/re2c/2015-01-13-input_model.html

2. http://skvadrik.github.io/aleph_null/posts/re2c/2015-01-15-input_model_custom.html

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