/*
*
*
~
~~
~
~ ~ Neuro-Translator
00
~~
°
)
~
~
~
\_|_/_/`-,
\_/ `-,
______________________________________________________________________.
XBNF_fr.html : documentation en Français
______________________________________________________________________.
___________________________________________________________________________.
Neurotranslator is an XBNF grammar parser to
translate several channels
Copyright (C) 2011 Matthieu DAMEROSE / damo@cpan.org
This program is free software: you can
redistribute it and/or modify
it under the terms of the GNU General Public
License as published by
the Free Software Foundation, either version 3
of the License, or
(at your option) any later version.
This program is distributed in the hope that it
will be useful,
but WITHOUT ANY WARRANTY; without even the
implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU
General Public License
along with Neurotranslator. If not, see
<http://www.gnu.org/licenses/>.
___________________________________________________________________________*/
|
NeuroTranslator est un compilateur de grammaires de traduction déterministes
et non déterministes permettant l'application de flux entrants et sortants
sur des canaux définies dans une grammaire XBNF (Xtended BNF).
Sommaire :
- Exemples XBNF
- Ligne de commande
- XBNF & NeuroTranslator
- Controller
- Fonctions
- options et
paramètres
****************************************************************************
1. Exemples basiques de grammaires
XBNF
****************************************************************************
|
| Exemple
sur quelques chiffres : |
Dans cet exemple,
le premier canal attend un chiffre et le second, une traduction
écrite en Anglais, Français ou Espagnol.
L'ordre des option d'appel est important car il détermine si
l'entrée ou la sortie porte sur le premier ou le second canal.
|
num.xbnf
:
axiome: nombre axiome | ()
nombre : num "/"
num : "1" # "one"|"un"|"unos"
num : "2" #
"two"|"deux"|"dos"
num : "3" #
"three"|"trois"|"très"
...
|
mail.txt
:
1322
|
#
xbnf -i mail.txt -o - num.xbnf
un/très/dos/two/
|
|
mail_text.txt
:
dos/three/un/one/ |
# xbnf -o -
-i mail_text.txt num.xbnf
2311
|
Traduction
d'une expression logique parenthésée passée par l'entrée
standard
en expression booléenne préfixée sur la sortie standards. |
logic.xbnf
:
axiome : ou (RC)
ou : et "+" ou
#
"(ou " <et>
(SP) <ou> (SP) ")"
ou : et
et : fact "." et
#
"(et " <fact> (SP) <et> (SP)
")"
et : fact
fact : (SP) boolean
fact : (SP) "(" ou (SP) ")" | ou # ou
boolean : "1" # "vrai"
boolean : "0" # "faux"
|
#
xbnf -i - -o - logic.xbnf
(0+1).1+(0.(1+1))+1.0
^D
(ou (et (ou faux
vrai) vrai) (ou (et faux (ou vrai vrai))
(et vrai faux))) |
#
xbnf -o - -i
- logic.xbnf
(ou (et (ou
faux vrai) vrai) (ou (et faux (ou
vrai vrai)) (et vrai faux)))
^D
(0+1).1+(0.(1+1))+1.0
|
axiome : a b | b # z
a : {| "a" "A"}
b : {| "b" "B"}
z : {| "z" "Z"} |
axiome : a b # z
axiome : b # z
a : "a" | "A"
b : "b" | "B"
z : "z" | "Z"
|
| Identification
des suites de chiffre pair ou impaire par
des P ou I. |
--- suite_chiffre.txt ---
680.12345.24680.13579.333444.
|
#
xbnf -i suite_chiffre.txt -o - parity.xbnf
pair.impair.pair.impair.pair.
|
--- parity.xbnf
---
<one-or-more>: nombre series
series : nombre series | ()
nombre: nb-pair "." # "pair."
nombre: nb-impair "." # "impair."
nb-pair: {| "0" "2" "4" "6" "8"} {! chiffre}
nb-pair: chiffre nb-pair
nb-impair: {| "1" "3" "5" "7" "9"} {! chiffre}
nb-impair: chiffre nb-impair
chiffre: {| "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"}
|
| Convertion
du résultat de find . en type abstrait de donnée
Perl |
axiome : listing
#
"
#
# Generated by
Neuro-Translator / find-to-perl.xbnf
#
use Data::Dumper;
my $find = {};
"
listing
listing : path (RC) listing
#
"$find->" path "={};\n" listing
listing : ()
#
"
print Dumper($find);
"
path : {| "./" "."}
path2 # "{'.'}" path2
path2 : filename "/" path2 #
"{'" filename "'}" path2
path2 :
filename
# "{'" filename "'}"
path2 : ()
filename: (STRING
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789"
"-_.~#") |
|
****************************************************************************
2. Options de ligne de commande
NeuroTranslator
****************************************************************************
|
> xbnf <options> [ <XBNF
files> ]
<XBNF files> : any XBNF file
<options> :
-a categorie :
grammar entry point
if
unspecified, first defined categorie
-0 : skip this
channel
-f : real-time
input/output (=>)
-i <flux>
: input flux to use
-is <flux> :
input flux using XBNF/SCOPE
-o <flux>
: output flux to use
-o+ <flux> :
output flux to append
-os <flux> :
output flux using XBNF/SCOPE
-i & -o flux
options are binded on chanels
with the order in declaration
-c <flux>
: controller directives
<flux> : file or stream to bind to the channel
'-'
stands for stdin as input (-i)
'-'
stands for stdout as output (-o)
Misc options :
-h : help
-l : print GNU
licence
-s : strict grammar
(generate errors and warning)
-d :
debugger
-di : internal
debugger
-mf : matrix
flux mode
-mr : matrix
rules mode
-ms
<step> : matrix steps
-nc : no color
to terminal
-v : verbose
mode
-t : auto-test
mode
--arg arg0,arg1, ... : provide running arguments
--stat : provide statistical
output
--progress : see flux progression bar
--version : gives running version
|
| Permet de lancer un fichier grammaire en remodelant les options |
Fichier grep.xbnf :
#!/usr/bin/xbnf sheebang $3 -i $2 -o - --arg $1 $0
// grep.xbnf <pattern> <file> [option facultative]
grep:
(PARAM* o_loop_detection 1)
search
search: line-ok search
search: line-ko search # search
search: ()
line-ok:
(SNAP {* {! "\n"} {! pattern} . *})
pattern
(STRING-TO "\n") "\n"
#
[0] "{" [1] "}" [2] "\n"
line-ko: {* {* {! "\n"} {! pattern} . *} "\n" *}
pattern: (ARG* 0)
|
bash# ./grep.xbnf "pattern" file
bash#
./grep.xbnf "pattern" file -v
|
- le mot clef "sheebang" suivit
des options permet de préciser à XBNF comment interpréter les options
- $0 correspond au fichier
grammaire, grep.xbnf dans l'exemple
- $1 dans l'exemple est le
pattern à rechercher
- $2 est le fichier à analyser
- $3 dans l'exemple ci-dessus $3
est facultatif, il sera ignoré s'il n'est pas précisé
Les options -mr (matrice des règles déployées) -mf -(matrice des
flux) permettent de visualiser les actions de neurotranslator.
L'option -ms <step> permet d'accélérer l'affichage selon les
besoins. |
# xbnf -mf -i samples/empty -o - samples/test.loop.xbnf
_ctrl : ..(INFLUX* "samples/empty" axiome )..#..(OUTFLUX* () axiome )..#..().axiome: <declare_first>.پ|>|
ctrl : ..(INFLUX* "samples/empty" axiome )..#..(OUTFLUX* () axiome )..#..().axiome: <declare_first>.پ|>|
trl : ..(INFLUX* "samples/empty" axiome )..#..(OUTFLUX* () axiome )..#..().axiome: <declare_first>.پ|>|
...
iome: <declare_first>.پ|>|
ome: <declare_first>.پ|>|
me: <declare_first>.پ|>|
...
|>|
پ|>|
پ|>|
پ<0 <1 <2 <3 <4 <1 <3> 1> 4> 3><1 <3 <4 <1> 4> 3> 1> 2> 1> 0><0 <1 <2 <3 <4 <1 <3> 1> 4> 3><1 <3 <4 <1> 4> 3> 1> 2> 1> 0
|
# xbnf -mf -ms 30 -i samples/empty -o - samples/test.loop.xbnf
|=|
_ctrl : ..(INFLUX* "samples/empty" axiome )..#..(OUTFLUX* () axiome )..#..().axiome: <declare_first>.پ!|=|
_ctrl : ..(INFLUX* "samples/empty" axiome )..#..(OUTFLUX* () axiome )..#..().axiome: <declare_first>.پ!|=|
_ctrl : ..(INFLUX* "samples/empty" axiome )..#..(OUTFLUX* () axiome )..#..().axiome: <declare_first>.پ!!!!!!!|>|
mpty" axiome )..#..(OUTFLUX* () axiome )..#..().axiome: <declare_first>.پ!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!|>|
) axiome )..#..().axiome: <declare_first>.پ!|>|
) axiome )..#..().axiome: <declare_first>.پ!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!|>|
lare_first>.پ!!!!!<0 <1 <2 <3 <4 <1 <3> 1> 4> 3><1 <3 <4 <1> 4> 3> 1> 2> 1> 0><0 <1 <2 <3 <4 <1 <3> 1> 4> 3><1 <3 <4 <1> 4> 3> 1> 2> 1> 0
|
# xbnf -mr -i samples/empty -o - samples/test.loop.xbnf
...
| <axiome> : # | <declare_first> : # | <looping1> : # | <loop0>
...
| <axiome> : # | <declare_first> : # | <looping2> : # | <loop0> :[0] #[1] | <loop1> :[0] #[1] ...
| <loop2> :[0] #[1] | <A> :[0] # | <loop1> :[1] #[1] | <loop3> :[0] #[1] | <loop4> :[0] #[1] ...
| <A> :[1] # | <loop1>
...
| <axiome> : # | <declare_first> : # | <looping2> : # | <loop0> :[0] #[1] |
<0 <1 <2 <3 <4 <1 <3> 1> 4> 3><1 <3 <4 <1> 4> 3> 1> 2> 1> 0><0 <1 <2 <3 <4 <1 <3> 1> 4> 3><1 <3 <4 <1> 4> 3> 1> 2> 1> 0>
|
| Les options -d grammaire utilisateur / -di pour suivre la
grammaire XBNF interne |
# xbnf -d -i samples/empty -o - samples/test.loop.xbnf
...
ENTER GRAMMAR <_ctrl>
0--|> n
Grammar<_ctrl>::proceed()
...
Rule::proceed()
INFLUX*::proceed() analysis...
| <-- ENTER
1--|> n
| <axiome> : # | <-- ENTER
...
4--|> n
| <axiome> : # | <declare_first> : # | <looping1> : # | <loop0> :[0] #[0] | <-- ENTER
5--|> h <= pour afficher l'aide
5--|> C <= pour configurer le mode débug
|
Le *** dans la grammaire permet de poser un point d'arrêt, exemple :
..
A: loop1
A: loop1 ***
# xbnf -v -i samples/empty -o - samples/test.loop.xbnf
...
(BREAK) | <axiome> : # | <declare_first> : # | <looping1> : # | <loop0> :[0] #[0] | <loop1> :[0] #[0] ...
| <loop2> :[0] #[0] | <A> :[0] # | <loop1> :[1] #[0] | <loop3> :[0] #[0] | <loop4> :[0] #[0] ...
| <A> :[1] # | (BREAK) | <-- ENTER
/!\ bug en cours cette grammaire
|
L'option -C (C majuscule) permet de générer un
fichier {grammaire}.cache.{canal} correspondante à la
grammaire parsée,
lors d'un second parsing avec la même grammaire, le parsing sera
grandement accéléré.
Il s'agit d'une alternative au controller avec l'option -c
(c minuscule) qui nécessite de paramétrer les commandes du
contrôlleur). |
# xbnf -C -i samples/empty -o - samples/test.loop.xbnf
...
|
# xbnf -C -i samples/empty -o - samples/test.loop.xbnf
...
|
****************************************************************************
3. Définitions des termes XBNF dans
NeuroTranslator
****************************************************************************
|
Une Grammaire XBNF est une extention de la grammaire
BNF.
Une grammaire XBNF est un ensemble de définition regroupant éventuellement
plusieurs des canaux.
L'application d'une grammaire sur un flux d'entré ou
de sortie est correcte si elle se concrétise
par la validation des flux d'entrés et par la capacité à générer un flux
cohérent en sortie.
Une grammaire est déterminée par une catégorie d'entrée dite axiome et
de l'ensemble des catégories qui la compose.
Une élément nommé pouvant être substitué logiquement à l'intérieur des
règles par son contenu.
En lecture, une categorie est valide lorsqu'une définition valide pour le
flux appliqué en entré.
Syntax :
nom ou "<" nom ">" (les chevrons permettant l'utilisation de
caractères non protégés)
- une
règle : est un enchaînement d'éléments applicables ou non sur
flux d'entrée ou en sortie (génération d'un flux)
- élément
: peut être une catégorie, un terminal (chaine, nombre, ...) ou
l'élément vide ()
- un
canal : séparés par un
'#' les
canaux analyse ou produisent des flux :
- d'entré : interprétation par le canal d'un fichier en entré
- de sortie : génération/production vers la sortie (fichier ou
sortie standard)
- mot-clefs :
- voir section "fonction & pragma"
Définie les règles possibles pour chaque canal.
La cohérence de la définition détermine les canaux et règles cohérents
entre eux,
Toute catégorie peut se voir enrichie d'une nouvelle définition avec
autant
de définitions que nécéssaires.
Syntax :
// Première définition
cat : /* 1er canal */ # /* 2nd canal
*/ # ...
// Seconde définition
cat : ... #
... # ...
Une définition directe permet de prioriser et générer le ou les flux de
sorties dès que le canal en lecture est valide
(une règle a été parsée/validée).
Les définitions directes sont un moyen d'optimiser l'occupation mémoire
pour des grammaires de type
recherche d'éléments, prompts, extraction de logs et plus généralement des
flux d'entrées/sorties volumineux.
Syntax :
axiome : {* cat *}
cat = /* 1er canal */ # /* 2nd canal
*/ # ...
Suite
de règles possibles utilisablent sur le flux courant.
Rien n'indique le sens du flux : interprétable (flux d'entrée) ou
productif (flux de sortie).
Est valide en entré le canal qui possède une règle valide pour ce flux
d'entré.
Est valide en sortie le canal possèdant une règle ayant été validé en
entré.
Si plusieurs règles peuvent valider un flux en entré, ou plusieurs règles
produirent
sur le flux de sortie, la grammaire sera non-déterministe et soumis à des
règles
de choix paramétrables ou aléatoire.
Syntax :
cat : /* règles du
canal 1 */ ... | /* règle suivante du canal 1 */
# /* second canal */ ...
# /* 3ieme canal */ ...
Les options { -i | -o | -0
} de la ligne de commandes doivent respecter
l'ordre des canaux :
- les options -0 et -0
permettent de d'ignorer le canal en fonction de sa position
dans la liste des options.
- la grammaire valide les canaux dans l'ordre cohérent d'application des
canaux sur les flux
EX:
shell# xbnf
-i fichier1.txt -i fichier2.txt -o sortie1.txt -o sortie2.txt
test_multi-flux.xbnf
----- contenu de test_multi-flux.xbnf ------
axiome : categorie // tous les flux
passent par catégorie
categorie :
idem // idem
idem :
input1_A
input1_B
// >> flux fichier1.txt
# input2_A input2_B
// >> flux fichier2.txt
# output1_A |
output1_or_B // << flux sortie1.txt
# output2_A output2_and_B // <<
flux sortie2.txt
- s'il n'existe qu'un seul canal pour plusieurs flux d'entré, alors le
même canal est utilisé pour tous les flux
l'ordre des elements est conservé
- si le nombre est inférieure la règle suivante est appliquée le canal
utilisé sera modulo
du nombre de canaux présent dans la définition
Les éléments constitutifs de la règle valident la règle en entrée en
validant chaqu'un d'eux.
Un éléments invalide invalide la règle entièrement.
La production d'un règle produit chaque éléments sequentiellement sur le
flux.
EX:
"chaine" (APPEL )
... "."
/!\ Les boucles :
Si le paramètre _o_loop_detection est vrai.
toute règle appelée sur le flux d'entrée se trouvant à la même position sur
cette même règle appelée récursivement
est un considérée comme une boucle
et ne produira rien mais restera valide.
L'element unitaire contenu dans une règle est
soit un catégorie,
soit un terminal, soit une probabilité
XBNF, soit un appel de fonction.
Terminal :
- une chaîne : (voir la
fonction STRING)
- toute chaine de caractères entre ""
avec caractères d'échappement :
\ suivit du caractère et \x suivit de la valeur hexadecimal de 0 à
FF),
EX: "Voici une
\"chaine\" de carat\xC3res\n"
- toute chaine de caractères entre {{{ et
}}} sans caractères d'échappement
EX: {{{ Voici une
"chaine" de caratères
suivit de EOF ^0}}}
- un nombre : suite
convertit en format binaire (voir fonction NOMBRE)
EX: 124, 0x23FEC,
043216, %110, 0
/!\
taille convertit minimal de 1 octet (F*)
- L'element vide () :
toujours valide il indique une règle vide
EX:
read_A : "a" read_A | ()
- L'élément . (point) :
lit un ou plusieurs octets d'un coups selon le nombre de points
échoue si la fin de fichier est atteinte
EX:
A : "|" ... # "voici les 3 caractères situés après |" ...
<<
produit la chaine complète de l'avancé du flux
Position
[<description du noeud>]:
- <<
[description] désigne
l'élement à traduire, permet de lever l'ambiguité lorsque plusieurs
éléments
du même type dans la règle analyer. Permet de récupérer un élément
analysé dans une règle parente.
- l'utilisation de la position (o)ptimise
la sélection de l'élément durant la production
EX:
Utilisation des positions [n]
|
A: B B B # [0] [1] [2]
B: elm0 elm1 elm2 # [2] [1] [0]
|
Une grammaire équivalente nécessite l'utilisation de catégories avec un nom
différent dans chaque règle.
Utilisation des positions [n]
|
A: B1 B2 B3
B1: B
B2:
B
B3: B
B: elm0 elm1 elm2 # elm2 elm1 elm0
|
EX2
:
Utilisation de noeud parent
|
A: id ...
B: A
C: A # [../../0] // récupère id analysé dans la categorie parente
|
- (INV
[a1] [a2] ...)
- retrouve
les positions injectives, (voir libraire lib/crypto)
EX:
- <> valide,
ne fait rien (equivalent à ()
****************************************************************************
4. Controlleur
****************************************************************************
|
Le controlleur a pour but premier de traiter plusieurs fichiers d'entré avec
la même grammaire et
ainsi éviter d'avoir à re-parser la grammaire à chaque fichier d'entré et de
sortie.
Le controlleur repose sur l'utilisation de fonctions particulières notée
{nom}* dont
le traitement est lié à l'intialisation avant parsing.
Le caractère %%% indique la fin des commandes de
paramétrage et déclenche la préparation et le parsing.
Une fois la traduction réalisée, le bloc suivant est traité.
Exemple :
xbnf -c
samples/test.controller.xbnf samples/exemple1.xbnf
|
//
samples/test.controller.xbnf
_ctrl :
(INFLUX* "samples/exemple1.txt" exemple)
#
(OUTFLUX* () exemple)
%%%
_ctrl :
(INFLUX* "samples/exemple2.txt" exemple)
#
(OUTFLUX* () exemple)
%%%
|
utilisation
avec l'option -c - (stdin)
|
L'exemple ci-dessous montre qu'il est possible de controller XBNF avec
des données passé sur l'entrée standard (stdin).
N'utilisation d'un pipe dans une application permet de controller les
plusieurs fichiers d'entré pour une même grammaire.
cat samples/test.controller.xbnf | xbnf
-c - samples/exemple1.xbnf
|
fonctions
d'initialisation du controleur
|
Les fonctions suivit d'une étoile permettent de controller XBNF à
l'initialisation d'une grammaire.
- (ARG*
{position de l'argument})
- permet de passer des arguments depuis l'appel de la commande xbnf
avec l'option --arg
"arg1,arg2,..."
- >>
appel considère l'argument comme une chaine de caractère
durant la lecture de la grammaire
- <<
l'argument produira la chaine de l'argument.
- (INFLUX*
"fichier d'entré" <categorie>)
- prépare le flux d'entré à l'initialisation avec le fichier de
donnée à parser en entré
- (INFLUX*
() <categorie>)
- prépare le flux d'entré à l'initialisation avec l'entrée standard
(stdin)
- (INFLUX*
"RT" "fichier d'entré" <categorie>)
(INFLUX*
"RT" () <categorie>)
- prépare le flux d'entré à l'initialisation avec un flux
temps-réel
fichier de donnée régulièrement mis à jours (log typiquement) ou
données en entré standard
- Le déclenchemet du parsing se fera à partir de la <catégorie>
- (OUTFLUX*
"fichier de sortie" <categorie>)
- prépare le flux d'entré à l'initialisation avec le fichier de donnée
à parser en entré
- le déclenchemet du parsing se fera à partir de la catégorie
- (OUTFLUX*
"A" "fichier de sortie" <categorie>)
- l'option "A" indique que le fichier sera ouvert en mode append cad
concaténation à la suite d'un fichier existant
****************************************************************************
5.Fonctions XBNF
****************************************************************************
|
Toute fonction est appelée "(" L'utilisation de cette fonction permet de
gagner efficacement du temps par rapport à")".
La vérification des arguments est effectué à l'initialisation de la
grammaire.
Notations :
>>
comportement avec un flux en entré durant la lecture
<<
comportement avec un flux de sortie durant la production
<> comportement
quelquesoit le sens du flux
{ ...
Sucres syntaxiques ...
|
- {!
<rule> }
- >>
négation de la règle / valide lorsque la règle ne peut
être satisfaite
échec, si la règle (suite d'éléments) est valide
- <<
ne produit rien (valide ou pas)
- {!}
- <> échoue
systématiquement
- {?
<rule>}
- >>
évalue la règle mais n'avance pas dans le flux, échoue si la
règle échoue
- <<
produit la règle validée
- {|
<element1> <element2>...}
- >>
valide si l'un des elements est valide (consommation de
l'élément valide)
- <<
produit l'element validé
- {|}
- <> valide,
ne fait rien (equivalent à ()
- {.
<rule>}
- >>
évalue la règle. toujours valide même si la règle échoue
- <<
produit la règle validée
- {
<min> <rule> <max> }
- >>
valide la règle au minimum une
fois, au maximum 2^32 fois.
- La valeur de <min> :
0 => validation optionel ( peut-être en echec)
1 => validation obligatoire ( doit être valide pour
valider)
=> executé au minimum <nombre> fois
- La valeur de :
0 => infini (maximum est indéterminée)
1 => une seule fois (unique)
=> ne valide (consomme) que le de
fois la règle
- <<
produit le nombre de fois que la règle a
été consommée
avec la traduction correspondant à chaque itération
(un arbre d'analyse pour chaque itération)
- L'utilisation de cette fonction permet de gagner efficacement du
temps par rapport à
une règle récursive, l'optimisation peut être encore poussé plus
encore avec l'utilisation du
couple (SNAP {* <rule> *})
Note: les formats de
et correspondent à la fonction (NUMBER).
- >>
valide la règle autant de fois que possible, ou vide
si aucune.
Il n'y a pas de limitation logique du nombre d'appel.
- <<
produit la chaine correspondant à l'exact flux qui
aura été lu.
- (o)ptimisation : le
bloc de lecture est traduit sans consommer de mémoire,
la chaine lu est prise telle quelle.
/!\
Expérimental
Une variable noté @identifiant, permet de stocker une donnée de type
terminal,
cad soit un numbre, soit une chaine de
caractère.
A: (LET @a 0) (LET @msg "Nombre
de points")
count
#
@msg ": " @a
count: "." (OP "++" @a)
|
- (SP)
- >>
valid zero ou plusieurs caractère espacement ou de
tabulation
et ignore les commentaires de type C++ (/* ... */ //)
(o)ptimisation par
rapport à une règles de type
:" "|
" " |
- <<
ré-écriture du nombre d'espaces lus
- (SP
<nb d'espaces>)
- >>
valid le nombres d'espaces ou tabulation attendus sinon
échec
- <<
écriture du nombre d'espaces précisés
- (RC)
- >>
valid zero ou plusieurs retours à la ligne (Dos/Unix)
et ignore les commentaires de type C++ (/* ... */ //)
(o)ptimisation par
rapport à une règles de type
:"\n"|"\n"|
- <<
ré-écriture du nombre d'espaces lus
- (RC
<nb de retour à la ligne>)
- >>
valid le nombres de retour à la ligne
- <<
écriture du nombre d'espaces précisés
- (NUMBER)
- >>
lecture d'un nombre au format ascii
- "%" <nombre binaire>
- "0" <nombre octal>
- <nombre décimal>
- "0x" <nombre hexadecimal>
- <<
production de bloc de 8bits convertit octet par octet
- (NUMBER
<base>)
- >>
lecture d'un nombre décrit dans la base 2/8/10/16 (sans
prefix "0" ou "0x" ou "%")
- (STRING
"caractères autorisés" "\n\t\x9E" "...")
- >>
lecture de tout caractère autorisé.
Sont autorisés tout caractèrs au format XBNF (voir STRING*)
présents en argument,
les caractères en échappement sont transcrit en leur valeur
trasncris.
(Exemple : "\x61" autorisera le charactère "a")
- <<
la chaine valide, c'est à dire la chaine contenant tous
les caractères autorisés.
- (STRING)
- >>
lecture de tout caractère sauf ".
- (CONV
"format" <rule>)
- >>
lecture classique du flux selon <rule>
- <<
conversion
du flux d'entré représentant un nombre selon le format
%d : conversion en décimal
%x : conversion en hexa-décimal
%o : conversion en octal
%b : conversion en binaire
%s : conversion en chaine de caractères
%l : conversion en chaine minuscule
%U : conversion de chaine majuscule
- (STRING-TO
<chaine>)
- >>
lecture de tout caractère jusqu'à la chaine indiquée
- <<
la chaine validée est celle précédent ( exclue)
- (IDENTIFIER)
- >>
lecture d'un identifiant
1er caractère parmis
{abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!}
caractères suivants parmis
{abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-!.*+=}
- <<
écriture de la chaine lu
- (RANGE
<first> <last>)
- >>
lecture d'un caractère compris entre <first> et
<last> (numbre ou caractère)
EX: (RANGE "a" "z") ou (RANGE 0x61 0x7a) ou (RANGE 97 122)
- <<
écriture du caractère valide
- (PROBA
<NUMBER>)
- >>
élement valide avec un probabilité du nombre indiqué par
rapport à 2³² => 4 294 967 296
par exemple le nombre 2147483648 donnera 50% de chance d'être
valide et 1 une chance sur 4 milliards
- <<
continue la règle si le tirage a été validé
- (SNAP
<rule>)
- >>
conserve la chaine analysée en entré si la règle
est valide.
- <<
produit la chaine analysée en entré correspondant à
l'exact avancée du flux.
- (o)ptimisation :
le bloc de lecture est traduit de tel quel de sorte que cela ne
consomme que la mémoire du flux lui-même.
(pas d'arbre d'analyse, seule la chaine lu)
- (STOP)
- permet de stopper l'analyse immédiatement
- >>
en lecture : arrêt de l'analyse du flux en entré, l'arbre
sera incomplet
- <<
en écriture : arrêt de la production du flux en sortie
- (VACUUM)
- >>
en lecture : purge du flux d'entré juqu'à la position
courante,
s'assurer que la règle ne sera pas invalidée, aucun
retour arrière n'est possible
- <<
valide, ne fait rien (equivalent à ()
- (o)ptimisation : la
mémoire occupée par le flux est libérée jusqu'au curseur en cours
- (INCLUDE
"filename")
- (INCLUDE
<rule>)
- >>
lecture d'une règle en tant que chemin d'un fichier
dont le chemin est relatif ou absolu
<<
inclusion du contenu du fichier dont le chemin a été
produit
- (XBNF*
... XBNF grammaire...)
- >>
lecture du flux "XBNF grammaire" qui doit être construite
avec des règles, chaines de caractères, ...
- <<
production de la grammaire XBNF, si valide chargement des éléments
dans la grammaire courante.
La grammaire courante sera enrichie des définitions ou fusionné
(si catégorie déja existante),
pour l'éxécuter il faudra appeler la catégorie après.
/!\ la grammaire ne
sera utilisable que si elle est construite avant utilisation
pour cela, elle doit être placée dans une définition directe
(<grm>= (XBNF* ...))
la catégorie de la grammaire produite n'existant pas avant d'être
construite, l'option strict oit être désactivée.
Voir le test <test.call_XBNF.xbnf> pour quelques exemples.
- (ARRANGEMENT
{nb de tirage} {element1} ... {elementN})
- >>
effectue un tirage de {nb} éléments au sort dans la liste des N
éléments sans remise.
(aucun élément ne pourra être tiré plus d'unevseule fois)
- <<
produit les éléments lu et validés dans l'ordre sans
remise des éléments lu en entré.
- (CHAOS
{element1} ... {elementN})
- >>
chaque élément doit être validé une fois mais pas nécéssairement
dans l'ordre défini,
chaque élément peut apparaitre dans un ordre différent, le curseur
avance si valide.
- <<
produit les éléments dans l'ordre de leur validation
lu en entrée.
| command grep avec la chaine a rechercher en argument |
--- samples/dump-number.txt
---
680.12345.24680.13579.333444.
|
--- samples/search.xbnf ---
axiome : number axiome | ()
number : (ARG 0) #
"!"
number : (ARG 1)
# "?"
number : .
|
# xbnf -i
samples/dump-number.txt -o - --arg
680,deux samples/search.xbnf
!.12345.24!.13579.333444. |
***
or (BREAK)
- >>
<<
déclenche le débugger la ou ce point d'arrêt est positionné
(CATCH)
- >>
<<
affiche l'exception provoquée durant le parsing/lecture
- (EOF*)
- >>
- détection
de la fin de fichier lorsq de l'analyse d'un fichier d'entrée
- n'est jamais valide si le flux est un flux temps-réel avec
l'option -f
- <<
transparent
- (PARAM*
parametre valeur)
- permet de valoriser le paramétrage pour toute grammaire utilisée
à l'initialisation,
voir chapitre 5.
- >>
appel transparent (aucune modification de l'arbre
des choix)
- <<
rien n'est produit sur le flux courant.
- (STRING*)
- >>
lecture d'une chaine de caractère de type XBNF jusqu'à la
double-quote (")
tout caractère peut être échappé : \", \n, \t, ...
ou si noté \xAB indique la valeur de la chaine
- <<
la chaine valide en mémoire en tant que chaine de
caractère à réutiliser avec
toute fonction prenant en arguement une ou plusieurs chaine
****************************************************************************
6. Options et paramètres.
****************************************************************************
|
Options accessibles par ligne de commande :
- o_verbose
(option -v)
- valeur
par default = false
- génère des informations utiles sur la sortie d'erreur (stderr)
- o_debug
(option -d ou -di)
- valeur
par default = false
- active le débugger sur la gramaire interne (option -di)
- active le debugger sur le flux entré et sorte (option -d)
- o_strict
(option -s)
- valeur
par default = false
- >>
- propose des vérifications plus stricts durant toutes les
étapes
- o_matrix_flux
(option -mf)
- valeur
par default = false
- >>
- affiche en temps-réel les portions du flux en cours d'analyse
- o_matrix_rule
(option -mr)
- valeur
par default = false
- >>
- affiche en temp-réel la pile d'éxecution des règles
- o_overwrite_file
(option -o+)
- valeur
par default = false
- <<
production à la fin du fichier de sortie / concaténation
sur les fichiers de sortie
-
o_progress
(option --progress)
- valeur
par default = false
- >>
- affiche une barre de progression des fichiers analysés en
entré
Paramètres accessibles via la fonction (PARAM*) :
- o_loop_detection
- valeur
par default = false
- >>
- échec si une
boucle infinie est détecté / si la même règle est déclenchée
avec la même position du curseur
- s'applique à une règle, un appel MOVE_WHILE {* <rule> *}
ou REPEAT {a <rule> b}
- o_rt_flush_stdin_character
- valeur
par default = \n
- >>
- purge
la lecture du flux d'entré lorsque le caractère est rencontré
- bloque en attente de nouvelles donnée sur le flux d'entré
- s'utilise conjointement avec l'option temps-réel -f
(aucune action sans la présence de cette option)
-
o_rt_flush_duration
- valeur
par default = 1000
/ en millisecondes
- >>
- temps
d'attente de nouvelles entrée sur le flux d'entré
- sort du cycle d'attente après le délai pour analyse du buffer
lu
(peut-être des données ou fin de fichier)
- s'utilise conjointement avec l'options temps-réel -f
(aucune action sans la présentce de cette option)
- o_MTU
- valeur
par default = 4096
/ en octets
- >>
- taille
maximale du buffer d'entré analysé
- sors de la boucle d'attente lorsque la taille est atteinte
- s'utilise conjointement avec l'option temps-réel -f
(aucune action sans la présence de cette option)
-
o_count_max_depth_analyze
- >>
- si
valorisée, limite le nombre d'appel à la même règle
- soit en levant une exeption
o_enable_stop_max_depth_analyze
est faux (par défaut)
- soit en validant la règle, l'analyse de la règle se termine
o_enable_stop_max_depth_analyze
est vrai
- cette limitation évite une erreur de segmentation mémoire
(limitation de la pile d'éxécution)
- o_enable_stop_max_depth_analyze
- valeur
par default = false
- >>
- par défault (faux), lève une exception lorsque la limitation
d'appel est atteinte
(o_count_max_depth_analyze
est valorisée)
- si valide, l'analyse de la règle s'arrête lorsque la
limitation o_count_max_depth_analyze
est atteinte
-
o_count_max_depth_produce
- <<
- si valorisée, limite le nombre d'appel à la même règle
- soit en levant une exeption
o_enable_stop_max_depth_analyze
est faux (par défaut)
- soit en validant la règle
o_enable_stop_max_depth_analyze
est vrai
- cette limitation évite une erreur de segmentation mémoire
(limitation de la pile d'éxécution)
- o_enable_stop_max_depth_produce
- valeur
par default = false
- <<
- par défault une exception est lévée lorsque la limitation
d'appel est atteinte
(o_count_max_depth_analyze)
- fait échouer la règle lorsque la limitation o_count_max_depth_analyze
est atteinte
- o_backtrace_three_point
- valeur
par default = true
- lors
de l'affichage de la pile d'execution, "..." signifie que la
courante règle est la même que précédement
Fin.