ragel - En ligne dans le Cloud

PROGRAMME:

Nom

ragel - compiler des langages réguliers dans des machines à états exécutables

SYNOPSIS

ragel [Options] filet

DESCRIPTION

Ragel compile des machines à états finis exécutables à partir de langages réguliers. Ragel peut
générer du code C, C++, Objective-C, D, Go ou Java. Les machines d'état de Ragel peuvent non seulement
reconnaissent les séquences d'octets comme le font les machines d'expressions régulières, mais peuvent également exécuter du code à
points arbitraires dans la reconnaissance d'un langage régulier. Le code utilisateur est intégré à l'aide
des opérateurs en ligne qui ne perturbent pas la syntaxe du langage normal.

Le langage de base se compose d'opérateurs d'expressions régulières standard, tels que union,
concaténation et étoile kleene, accompagnées d'opérateurs d'intégration d'action. Ragel aussi
fournit des opérateurs qui vous permettent de contrôler tout non-déterminisme que vous créez, construisez
scanners utilisant le paradigme de correspondance le plus long et construire des machines d'état à l'aide du diagramme d'états
maquette. Il est également possible d'influencer l'exécution d'une machine d'état depuis l'intérieur d'un
action intégrée en sautant ou en appelant à d'autres parties de la machine et en retraitement
contribution.

Ragel fournit une interface très flexible au langage hôte qui tente de placer
restrictions minimales sur la façon dont le code généré est utilisé et intégré dans le
application. Le code généré n'a pas de dépendances.

OPTIONS

-h, -H, -?, --Aidez-moi
Affichez l'aide et quittez.

-v Imprimer les informations sur la version et quitter.

-o filet
Écrire la sortie dans un fichier. Si -o n'est pas donné, un nom de fichier par défaut est choisi par
remplaçant l'extension de fichier du fichier d'entrée. Pour les fichiers source se terminant par .rh, le
le suffixe .h est utilisé. Pour tous les autres fichiers source, un suffixe basé sur la langue de sortie
est utilisé (.c, .cpp, .m, etc.). Si -o n'est pas donné pour Graphviz, la sortie générée
dot est écrit sur la sortie standard.

-s Imprimez des statistiques sur l'erreur standard.

--error-format=gnou
Imprimer les messages d'erreur en utilisant le format "file:line:column:" (par défaut)

--error-format=msvc
Imprimez les messages d'erreur au format "fichier(ligne,colonne):"

-d Ne supprimez pas les actions en double des listes d'actions.

-I dir
Ajouter dir à la liste des répertoires pour rechercher les fichiers inclus et importés

-n N'effectuez pas de minimisation d'état.

-m Effectuez la minimisation une fois, à la fin de la compilation de la machine d'état.

-l Minimiser après presque chaque opération. Les listes d'opérations similaires telles que les unions sont
minimisé une fois à la fin. Il s'agit de l'option de minimisation par défaut.

-e Minimiser après chaque opération.

-x Compilez les machines d'état et émettez une représentation XML des données de l'hôte et du
les machines.

-V Générez un fichier de points pour Graphviz.

-p Affichez des caractères imprimables sur les étiquettes.

-S
Spécification FSM à sortir.

-M
Définition/instanciation de la machine à la sortie.

-C Le langage hôte est C, C++, Obj-C ou Obj-C++. Il s'agit de la langue hôte par défaut
option.

-D La langue d'accueil est le D.

-J Le langage hôte est Java.

-Z La langue d'accueil est Go.

-R La langue de l'hôte est Ruby.

-L Empêcher l'écriture des directives #line.

-T0 (C/D/Java/Ruby/C#/Go) Générez un FSM basé sur une table. Il s'agit du style de code par défaut.
Le FSM piloté par table représente la machine d'état sous forme de données statiques. il y a des tableaux
d'états, de transitions, d'indices et d'actions. L'état actuel est stocké dans un
variable. L'exécution est une boucle qui regarde cela étant donné l'état actuel et
le caractère courant à traiter recherche la transition à effectuer à l'aide d'une recherche binaire,
exécute toutes les actions et passe à l'état cible. En général, la table entraînée
FSM produit un binaire plus petit et nécessite une compilation en langage hôte moins coûteuse
mais entraîne un code d'exécution plus lent. Le FSM entraîné par table convient à tout FSM.

-T1 (C/D/Ruby/C#/Go) Générez un FSM plus rapide piloté par table en développant les listes d'actions dans
l'action exécuter le code.

-F0 (C/D/Ruby/C#/Go) Générez un FSM piloté par une table plate. Les transitions sont représentées comme
un tableau indexé par le caractère alphabétique courant. Cela élimine le besoin d'un
recherche binaire pour localiser les transitions et produit un code plus rapide, mais ce n'est que
adapté aux petits alphabets.

-F1 (C/D/Ruby/C#/Go) Générez un FSM plus rapide piloté par une table plate en élargissant les listes d'actions
dans l'action exécuter le code.

-G0 (C/D/C#/Go) Générez un FSM dirigé par goto. Le FSM dirigé par goto représente l'état
machine comme une série d'instructions goto. Dans la machine, l'état actuel est
stocké par le pointeur d'instruction du processeur. L'exécution est une fonction plate
où le contrôle est passé d'un état à l'autre à l'aide de gotos. En général, le goto FSM
produit un code plus rapide mais donne un binaire plus gros et un hôte plus cher
langage de compilation.

-G1 (C/D/C#/Go) Générez un FSM plus rapide piloté par goto en élargissant les listes d'actions dans le
action exécuter le code.

-G2 (C/D/Go) Générez un FSM très rapide piloté par goto en incorporant des listes d'actions dans le
code de contrôle de la machine d'état.

-P (C/D) N-Way Split FSM très rapide piloté par goto.

RAGEL CONTRIBUTION

REMARQUE : Il s'agit d'une très brève description de l'entrée Ragel. Ragel est décrit plus en détail
dans le guide d'utilisation disponible depuis la page d'accueil (voir ci-dessous).

Ragel transmet normalement les fichiers d'entrée directement à la sortie. Quand il voit un FSM
spécification qui contient des instanciations de machine, il s'arrête pour générer la machine d'état.
S'il y a des instructions d'écriture (telles que "write exec"), alors ragel émet le message correspondant
code. Il peut y avoir n'importe quel nombre de spécifications FSM dans un fichier d'entrée. Un FSM multiligne
la spécification commence par '%%{' et se termine par '}%%'. Une spécification FSM à une seule ligne
commence par %% et se termine à la première nouvelle ligne.

FSM ÉTATS

Machine Nom :
Définissez le nom de la machine. S'il est donné, il doit s'agir de la première déclaration.

Alphabet Type :
Définissez le type de données de l'alphabet.

Obtenir la clé:
Spécifiez comment récupérer le caractère alphabétique du type d'élément.

Comprendre:
Incluez une machine du même nom que la machine actuelle ou d'un nom différent dans
fichier actuel ou un autre fichier.

Action Définition:
Définissez une action qui peut être invoquée par le FSM.

FSM Définition, Instanciation et les La plus longue Match Instanciation :
Utilisé pour construire des FSM. Description de la syntaxe dans les prochaines sections.

Accès:
Spécifiez comment accéder aux variables de la machine d'état persistante.

Écrire: Écrivez un composant de la machine.

Variable:
Remplacez les noms de variables par défaut (p, pe, cs, act, etc.).

BASIQUE MACHINES

Les machines de base sont les opérandes de base des expressions en langage régulier.

'Bonjour'
Concat littéral. Produit une concaténation des caractères de la chaîne. Les soutiens
séquences d'échappement avec '\'. Le résultat aura un état de départ et une transition vers
un nouvel état pour chaque caractère de la chaîne. Le dernier état de la séquence sera
être rendu définitif. Pour rendre la chaîne insensible à la casse, ajoutez un "i" à la chaîne, comme
dans 'cmd'i.

"Bonjour"
Identique à la version à guillemet simple.

[Bonjour]
Ou littéral. Produit une union de caractères. Prend en charge les plages de caractères avec '-',
nier le sens de l'union avec un '^' initial et les séquences d'échappement avec '\'.
Le résultat aura deux états avec une transition entre eux pour chaque caractère
ou gamme.

REMARQUE : '', "" et [] produisent des FSM nuls. Les machines nulles ont un état qui est à la fois un début
state et un état final et correspondent à la chaîne de longueur zéro. Une machine nulle peut être créée
avec la machine intégrée null.

entier
Crée une machine à deux états avec une transition sur le nombre entier donné.

hex Crée une machine à deux états avec une transition sur le nombre hexadécimal donné.

/simple_regex/
Une expression régulière simple. Prend en charge la notation '.', '*' et '[]', caractère
s'étend avec '-', annulant le sens d'une expression OU avec et initial '^' et
séquences d'échappement avec '\'. Prend également en charge un indicateur de fin : i. Utilisez-le pour produire un
expression régulière insensible à la casse, comme dans /GET/i.

Allumé .. Allumé
Spécifie une plage. Les limites supérieures et inférieures autorisées sont des littéraux concat de
longueur un et nombre de machines. Par exemple, 0x10..0x20, 0..63 et 'a'..'z' sont
plages valides.

variable_name
Fait référence à la définition de machine affectée au nom de variable donné.

machine_intégrée
Plusieurs machines intégrées sont disponibles. Ce sont tous deux des machines à états pour
le but de faire correspondre des classes communes de caractères. Elles sont:

tous N'importe quel caractère de l'alphabet.

ascii Caractères Ascii 0..127.

étendre Caractères étendus Ascii. Il s'agit de la plage -128..127 pour les alphabets signés
et la plage 0..255 pour les alphabets non signés.

Alpha Caractères alphabétiques /[A-Za-z]/.

chiffre Chiffres /[0-9]/.

numéro d'album Alphanumériques /[0-9A-Za-z]/.

baisser Caractères minuscules /[az]/.

supérieur Caractères majuscules /[AZ]/.

xchiffre Chiffres hexadécimaux /[0-9A-Fa-f]/.

ctrl Caractères de contrôle 0..31.

graphique Caractères graphiques /[!-~]/.

impression Caractères imprimables /[ -~]/.

point Ponctuation. Caractères graphiques qui ne sont pas alphanumériques
/[!-/:-@\[-`{-~]/.

espace Espace blanc /[\t\v\f\n\r ]/.

nul Chaîne de longueur nulle. Équivalent à '', "" et [].

vide Ensemble vide. Ne correspond à rien.

LE PROJET OPÉRATEUR RÉFÉRENCE

Les opérateurs sont regroupés par priorité, le groupe 1 étant le plus bas et le groupe 6 le plus élevé.

GROUPE 1:

expr , expr
Joindre des machines ensemble sans tracer de transitions, configurer un état de départ ou
tous les états finaux. L'état de démarrage doit être explicitement spécifié avec l'étiquette "start".
Les états finaux peuvent être spécifiés avec les transitions an epsilon vers le
créé l'état "final".

GROUPE 2:

expr | expr
Produit une machine qui correspond à n'importe quelle chaîne de la machine une ou de la machine deux.

expr & expr
Produit une machine qui correspond à n'importe quelle chaîne qui se trouve à la fois dans la machine XNUMX et dans la machine
deux.

expr - expr
Produit une machine qui correspond à n'importe quelle chaîne qui est dans la machine un mais pas dans
machine deux.

expr -- expr
Soustraction forte. Correspond à n'importe quelle chaîne de la machine XNUMX qui n'a pas de chaîne
dans la machine deux en tant que sous-chaîne.

GROUPE 3:

expr . expr
Produit une machine qui correspond à toutes les chaînes de la machine une suivie de toutes les
cordes dans la machine deux.

expr :> expr
Concaténation protégée par entrée : termine la machine un lors de l'entrée dans la machine deux.

expr :>> expr
Finish-Guarded Concaténation : termine la machine un lorsque la machine deux se termine.

expr <: expr
Concaténation à gauche : donne une priorité plus élevée à la première machine.

REMARQUE : La concaténation est l'opérateur par défaut. Deux machines côte à côte sans
entre eux entraîne l'opération de concaténation.

GROUPE 4:

étiquette: expr
Attache une étiquette à une expression. Les étiquettes peuvent être utilisées par les transitions epsilon et
les instructions fgoto et fcall dans les actions. A noter également que le référencement d'une machine
La définition provoque la création implicite d'une étiquette du même nom.

GROUPE 5:

expr -> étiquette
Dessine une transition epsilon vers l'état défini par l'étiquette. L'étiquette doit être un nom dans
la portée actuelle. Les transitions Epsilon sont résolues lorsque les opérateurs virgules sont
évalué et à la racine de l'arbre d'expression de la machine
affectation/instanciation.

GROUPE 6: Actions

Une action peut être un nom prédéfini avec une instruction d'action ou peut être spécifié directement
avec '{' et '}' dans l'expression.

expr > action
Intègre l'action dans les transitions de démarrage.

expr @ action
Incorpore l'action dans les transitions qui entrent dans un état final.

expr $ action
Intègre l'action dans toutes les transitions. N'inclut pas les transitions en attente.

expr % action
Intègre l'action dans les transitions en attente à partir des états finaux.

GROUPE 6: EOF Actions

Lorsque la routine de finition d'une machine est appelée, les actions EOF de l'état actuel sont exécutées.

expr >/ action
Intégrez une action EOF dans l'état de démarrage.

expr </ action
Intégrez une action EOF dans tous les états à l'exception de l'état de démarrage.

expr $/ action
Intégrez une action EOF dans tous les états.

expr %/ action
Intégrez une action EOF dans les états finaux.

expr @/ action
Intégrez une action EOF dans tous les états qui ne sont pas définitifs.

expr <>/ action
Intégrez une action EOF dans tous les états qui ne sont pas l'état de départ et qui ne sont pas
finale (états intermédiaires).

GROUPE 6: Global Erreur Actions

Les actions d'erreur globales sont stockées dans des états jusqu'à ce que la machine d'état finale ait été entièrement
construit. Ils sont ensuite transférés vers des transitions d'erreur, donnant l'effet d'un
action par défaut.

expr >! action
Intégrez une action d'erreur globale dans l'état de démarrage.

expr <! action
Intégrez une action d'erreur globale dans tous les états, à l'exception de l'état de démarrage.

expr $! action
Intégrez une action d'erreur globale dans tous les états.

expr %! action
Intégrez une action d'erreur globale dans les états finaux.

expr @! action
Intégrez une action d'erreur globale dans tous les états qui ne sont pas définitifs.

expr <>! action
Intégrez une action d'erreur globale dans tous les états qui ne sont pas l'état de départ et sont
non définitif (états intermédiaires).

GROUPE 6: Lieu Erreur Actions

Les actions d'erreur locales sont stockées dans des états jusqu'à ce que la machine nommée soit entièrement construite.
Ils sont ensuite transférés vers les transitions d'erreur, donnant l'effet d'une action par défaut pour
une partie de la machine totale. Notez que le nom peut être omis, auquel cas le
l'action sera transférée aux actions d'erreur lors de la construction de la machine actuelle.

expr >^ action
Intégrez une action d'erreur locale dans l'état de démarrage.

expr <^ action
Intégrez une action d'erreur locale dans tous les états, à l'exception de l'état de démarrage.

expr $^ action
Intégrez une action d'erreur locale dans tous les états.

expr %^ action
Intégrez une action d'erreur locale dans les états finaux.

expr @^ action
Intégrez une action d'erreur locale dans tous les états qui ne sont pas définitifs.

expr <>^ action
Intégrez une action d'erreur locale dans tous les états qui ne sont pas l'état de départ et sont
non définitif (états intermédiaires).

GROUPE 6: Établir Actions

Les actions d'état sont stockées dans des états et exécutées à chaque fois que la machine entre dans un
Etat. Cela inclut les transitions régulières et les transferts de contrôle tels que fgoto. Noter
ce réglage de l'état courant depuis l'extérieur de la machine (par exemple pendant
initialisation) ne compte pas comme une transition vers un état.

expr >~ action
Intégrez une action d'action vers l'état dans l'état de démarrage.

expr <~ action
Intégrez une action d'état dans tous les états à l'exception de l'état de départ.

expr $~ action
Intégrez une action d'état dans tous les états.

expr %~ action
Intégrez une action d'état dans les états finaux.

expr @~ action
Intégrez une action vers un état dans tous les états qui ne sont pas définitifs.

expr <>~ action
Intégrez une action d'état dans tous les états qui ne sont pas l'état de départ et ne sont pas
finale (états intermédiaires).

GROUPE 6: De-État Actions

Depuis l'état, les actions sont exécutées chaque fois qu'un état effectue une transition sur un caractère. Cette
comprend la transition d'erreur et une transition vers soi.

expr >* action
Intégrez une action de l'état dans l'état de départ.

expr <* action
Intégrez une action à partir de l'état dans chaque état, à l'exception de l'état de démarrage.

expr $* action
Intégrez une action de l'état dans tous les états.

expr %* action
Intégrez une action de l'état dans les états finaux.

expr @* action
Intégrez une action de l'état dans tous les états qui ne sont pas définitifs.

expr <>* action
Intégrez une action de l'état dans tous les états qui ne sont pas l'état de départ et ne sont pas
finale (états intermédiaires).

GROUPE 6: Priorité Affectation

Des priorités sont attribuées aux noms dans les transitions. Seules les priorités portant le même nom sont
autorisé à interagir. Dans la première forme de priorités, le nom par défaut est le nom du
définition de la machine dans laquelle la priorité est attribuée. Les transitions n'ont pas de valeur par défaut
priorités.

expr > int
Attribue la priorité int dans toutes les transitions quittant l'état de départ.

expr @ int
Attribue la priorité int dans toutes les transitions qui entrent dans un état final.

expr $ int
Attribue la priorité int dans toutes les transitions existantes.

expr % int
Attribue la priorité int dans toutes les transitions de sortie en attente.

Une deuxième forme d'attribution de priorité permet au programmeur de spécifier le nom auquel
la priorité est attribuée, permettant aux interactions de franchir les limites de la définition de la machine.

expr > (nom,int)
Attribue la priorité int à name dans toutes les transitions quittant l'état de départ.

expr @ (Nom, entier)
Attribue la priorité int à name dans toutes les transitions qui entrent dans un état final.

expr $ (Nom, entier)
Attribue la priorité int à name dans toutes les transitions existantes.

expr % (Nom, entier)
Attribue la priorité int au nom dans toutes les transitions de sortie en attente.

GROUPE 7:

expr * Produit l'étoile kleene d'une machine. Correspond à zéro ou plusieurs répétitions du
machine.

expr **
Kleene Star du match le plus long. Cette version de kleene star accorde une plus grande priorité à
rester dans la machine pour l'enrouler et recommencer. Cet opérateur est
équivalent à ( ( expr ) $0 %1 )*.

expr ? Produit une machine qui accepte la machine donnée ou la chaîne nulle. Cet opérateur
est équivalent à ( expr | '' ).

expr + Produit la machine concaténée avec l'étoile kleen d'elle-même. Correspond à un ou
plus de répétitions de la machine. Cet opérateur est équivalent à ( expr . expr* ).

expr {n}
Produit une machine qui correspond exactement à n répétitions de expr.

expr {,n}
Produit une machine qui correspond n'importe où de zéro à n répétitions d'expr.

expr {n,}
Produit une machine qui correspond à n répétitions ou plus de expr.

expr {n,m}
Produit une machine qui correspond à n à m répétitions d'expr.

GROUPE 8:

! expr Produit une machine qui correspond à toute chaîne qui ne correspond pas à la machine donnée. Cette
L'opérateur est équivalent à ( *extend - expr ).

^ expr Négation au niveau des caractères. Correspond à tout caractère unique qui ne correspond pas au seul
machine à caractères expr.

GROUPE 9:

( expr )
Force la priorité sur les opérateurs.

VALEURS DISPONIBLE IN CODE BLOCS

fc Le personnage actuel. Équivalent à *p.

fpc Un pointeur vers le caractère actuel. Équivalent à p.

fcurs Une valeur entière représentant l'état actuel.

fargs Une valeur entière représentant l'état cible.

garde-corps ( )
Une valeur entière représentant le point d'entrée .

ÉTATS DISPONIBLE IN CODE BLOCS

retiens ; N'avance pas sur le caractère actuel. Équivalent à --p;.

fexec ;
Définit le caractère actuel à autre chose. Équivalent à p = ( )-1;

fgoto ;
Aller à la machine définie par .

fgoto * ;
Aller au point d'entrée donné par . L'expression doit être évaluée à un entier
valeur représentant un état.

suivant ;
Définissez l'état suivant comme point d'entrée défini par . La prochaine déclaration
ne saute pas immédiatement à l'état spécifié. Tout code d'action suivant le
est exécutée.

suivant * ;
Définir l'état suivant comme point d'entrée donné par . L'expression doit
évaluer à une valeur entière représentant un état.

appeler ;
Appelez la machine définie par . La frette suivante sautera à la cible du
transition sur laquelle l'action est invoquée.

appeler * ;
Appelez le point d'entrée indiqué par . La frette suivante sautera à la cible du
transition sur laquelle l'action est invoquée.

frette; Retour à l'état cible de la transition sur laquelle le dernier fcall a été effectué.

fbreak ;
Enregistrez l'état actuel et sortez immédiatement de la machine.

CRÉDITS

Ragel a été écrit par Adrian Thurston[email protected]>. Sortie Objective-C
contribué par Erich Ocean. D sortie contribué par Alan West. Sortie Ruby contribué par
Victor Hugo Borja. C Génération de code Sharp contribué par Daniel Tang. Contributions à
Génération de code Java par Colin Fleming. Go génération de code contribué par Justine Tunney.

Utilisez ragel en ligne en utilisant les services onworks.net