Lisez-moi S.V.P. 

B La grammaire de validation du balisage de contenu

Table des matières : Le langage de balisage mathématique (MathML) version 2.0
Chapitre précédent : A L'interprétation MathML
Chapitre suivant : C Les définitions des éléments de contenu

Grammaire EBNF informelle pour la validation de la structure du balisage de contenu
===================================================================================
// Remarques
//
// Cette grammaire définit les arbres d'expression valides dans le balisage de contenu
//
// ** elle ne définit pas la validation des attributs
// ** qui doit avoir lieu en préalable.
//
// Presentation_tags est un paramètre fictif pour la balise ouvrante
// ou la balise fermante d'un élément de présentation valide
//
// #PCDATA représente les données textuelles analysables XML
//
// les symboles commençant par '_', par exemple _mmlarg, sont des symboles internes
// (une grammaire récursive habituellement requise pour reconnaissance)
//
// les symboles tout en minuscules, par exemple 'ci', sont des symboles terminaux
// représentant des éléments de contenu MathML
//
// les symboles commençant par une majuscule sont des terminaux
// représentant d'autres atomes
//
// révisé sb 3-11-97, 16-11-97 et 22-12-1997
// révisé sb 6-01-98, 6-02-98 et 4-04-1998
// révisé sb 27-11-2000 pour MathML2.0
//
// définitions des caractères blancs incluant Presentation_tags
Presentation_tags ::= "presentation"        //paramètre fictif
Space    ::= #x09 | #xoA | #xoD | #x20      //caractères tab, lf, cr, espace
S        ::= (Space | Presentation_tags)*   //traite présentation comme un espace
// seulement pour validation du contenu
// caractères
Char     ::= Space | [#x21 - #xFFFD] 
             | [#x00010000 - #x7FFFFFFFF]   //caractères XML valides
// fonctions pour les balises ouvrantes et fermantes
// start(\%x) renvoie la balise ouvrante valide de l'élément \%x
// end(\%x) renvoie la balise fermante valide de l'élément \%x
// empty(\%x) renvoie la balise vide valide de l'élément \%x
//
// start(ci)    ::= "<ci>"
// end(cn)      ::= "</cn>"
// empty(plus)  ::= "<plus/>"
//
// La justification de cela est d'éviter d'avoir à écrire
// une grammaire pour tous les attributs. Le modèle suivant
// n'est pas complet pour toutes les valeurs d'attributs possibles.

_start(\%x)   ::= "<\%x" (Char - '>')* ">"    // renvoie la balise ouvrante valide de l'élément \%x
_end(\%x)     ::= "<\%x" Space* ">"           // renvoie la balise fermante valide de l'élément \%x
_empty(\%x)   ::= "<\%x" (Char - '>')* "/>"   // renvoie la balise vide valide de l'élément \%x
_sg(\%x)      ::= S _start(\%x)               // balise ouvrante précédée par un caractère blanc optionnel
_eg(\%x)      ::= _end(\%x) S                 // balise fermante suivie par un caractère blanc optionnel
_ey(\%x)      ::= S _empty(\%x) S      // balise vide précédée et suivie par un caractère blanc optionnel

// structures de contenu mathml
_mmlall         ::= _container | _relation | _operator | _qualifier | _other
_mmlarg         ::= _container 
_container      ::= _token | _special | _constructor
_token          ::= ci | cn | csymbol | _constantsym
_special        ::= apply | lambda | reln | fn
_constructor    ::= interval | list | matrix | matrixrow | set | vector	| piecewise
                     | piece | otherwise
_other          ::= condition |  declare | sep
_qualifier      ::= lowlimit | uplimit | bvar | degree | logbase | domainofapplication
                     | momentabout
_constantsym    ::= integers | rationals | reals | naturalnumbers | complexes | primes 
                     | exponentiale | imaginaryi | notanumber | true | false | pi
                     | eulergamma | infinity

// relations
_relation       ::= _genrel | _setrel | _seqrel2ary
_genrel         ::= _genrel2ary | _genrelnary
_genrel2ary     ::= ne
_genrelnary     ::= eq | leq | lt | geq | gt
_setrel         ::=  _seqrel2ary | _setrelnary
_setrel2ary     ::=  in | notin | notsubset | notprsubset
_setrelnary     ::= subset | prsubset
_seqrel2ary     ::= tendsto

// opérateurs
_operator       ::= _funcop | _sepop | _arithop | _calcop | _vcalcop
                | _seqop | _trigop | _classop | _statop | _lalgop
                | _logicop | _setop

// opérateurs fonctionnels
_funcop         ::= _funcop1ary | _funcopnary
_funcop1ary     ::= inverse     | ident | domain | codomain | image
_funcopnary     ::= fn| compose   // general user-defined function is n-ary

// opérateurs arithmétiques
// (remarque : minus est unaire et binaire)
_arithop        ::= _arithop1ary | _arithop2ary | _arithopnary  | root
_arithop1ary    ::= abs | conjugate | factorial | minus | arg | real | imaginary
                     | floor | ceiling
_arithop2ary    ::= quotient | divide | minus | power | rem
_arithopnary    ::= plus | times | max | min | gcd | lcm

// calcul et calcul vectoriel
_calcop         ::= int | diff | partialdiff
_vcalcop        ::= divergence | grad | curl | laplacian

// suites et séries
_seqop          ::= sum | product | limit

// fonctions et trigonométrie classiques élémentaires

_classop        ::= exp | ln | log

_trigop         ::= sin | cos | tan | sec | csc | cot | sinh 
                    | cosh | tanh | sech | csch | coth 
                    | arcsin | arccos | arctan

// opérateurs statistiques
_statop         ::= _statopnary | moment
_statopnary     ::= mean | sdev | variance | median | mode

// opérateurs d'algèbre linéaire
_lalgop         ::= _lalgop1ary |_lalgop2ary | _lalgopnary
_lalgop1ary     ::= determinant | transpose
_lalgop2ary     ::= vectorproduct | scalarproduct | outerproduct
_lalgopnary     ::= selector

// opérateurs logiques
_logicop        ::= _logicop1ary | _logicopnary | _logicop2ary | _logicopquant
_logicop1ary    ::= not
_logicop2ary    ::= implies	| equivalent | approx | factorof
_logicopnary    ::= and | or | xor
_logicopquant   ::= forall | exists

// opérateurs d'ensembles
_setop          ::= _setop1ary |_setop2ary | _setopnary
_setop1ary      ::= card
_setop2ary      ::= setdiff
_setopnary      ::= union | intersect | cartesianproduct

// groupes d'opérateurs
_unaryop        ::=  _func1ary | _arithop1ary | _trigop | _classop  
                     | _calcop | vcalcop | _logicop1ary	| _lalgop1ary | setop1ary
_binaryop       ::=  _arithop2ary | _setop2ary | _logicop2ary | _lalgop2ary
_naryop         ::=  _arithopnary | _statopnary  | _logicopnary 
                     | _lalgopnary | _setopnary | _funcopnary
_ispop          ::= int | sum | product
_diffop         ::= diff | partialdiff
_binaryrel      ::= _genrel2ary | _setrel2ary |  _seqrel2ary
_naryrel        ::= _genrelnary | _setrelnary

// séparateur
sep             ::=  _ey(sep)

// atomes terminaux et contenu de données des éléments terminaux
// remarquez que _mdata inclut ici les structures de présentation.
_mdatai         ::= (#PCDATA | Presentation_tags)*
_mdatan         ::= (#PCDATA | sep | Presentation_tags)*
ci              ::=  _sg(ci) _mdatai _eg(ci)
cn              ::=  _sg(cn) _mdatan _eg(cn)
csymbol         ::=  _sg(csymbol) _mdatai _eg(csymbol)

// condition -  contraintes contraintes. Contient soit
// un seul reln (relation), soit un apply contenant
// une combinaison logique de relations ou un ensemble
// (sur lequel l'opérateur devrait s'appliquer)
condition       ::= _sg(condition)  reln | apply | set  _eg(condition)

// domaines des intégrales, sommes, produits
_ispdomain      ::= (lowlimit  uplimit?)
                | uplimit
                | interval
                | condition

// structure apply
// Remarquez qu'on utilise apply à la place de reln,
// déconseillé dans MathML2.0, pour les opérateurs de
// relation comme pour ceux arithmétiques, algébriques, etc.
apply           ::= _sg(apply) _applybody | _relnbody _eg(apply)
_applybody      ::= 
      ( _unaryop _mmlarg  )                   //opérateurs unaires
    | (_binaryop _mmlarg _mmlarg)             //opérateurs binaires
    | (_naryop _mmlarg*)                      //opérateurs n-aires, arguments énumérés
    | (_naryop bvar* condition _mmlarg)       //opérateurs n-aires, condition définit la liste des arguments
    | (_ispop  bvar? _ispdomain? _mmlarg)     //intégrale, somme, produit
    | (_ispop  domainofapplication? _mmlarg)  //intégrale, somme, produit
    | (_diffop bvar* _mmlarg)                 //opérateurs différentiels
    | (log logbase? _mmlarg)                  //logarithmes
    | (moment degree? momentabout? _mmlarg*)           //moment statistique
    | (root degree? _mmlarg)                           //radicaux - racine carrée par défaut
    | (limit bvar* lowlimit? condition? _mmlarg)       //limites
    | (_logicopquant bvar+ condition? (reln | apply))  //quantificateurs avec variables liées explicites



// équations et relations - reln utilise une syntaxe semblable à lisp (comme apply)
// bvar et condition servent à construire une contrainte "tel que"
// ou "dans lequel" sur la relation. 
// Remarquez que reln est déconseillé mais toujours valide dans MathML2.0
reln            ::= _sg(reln) _relnbody _eg(reln)
_relnbody       ::= ( _binaryrel bvar* condition? _mmlarg _mmlarg )
                    | ( _naryrel bvar* condition? _mmlarg*  )

// structure fn
// Remarquez que fn est déconseillé mais toujours valide dans MathML2.0
fn                      ::= _sg(fn) _fnbody _eg(fn)
_fnbody         ::=  Presentation_tags | container 

// structure lambda    - remarquez que doit être présent au moins un bvar
lambda          ::=  _sg(lambda) _lambdabody _eg(lambda)
_lambdabody     ::=  bvar+ _container  //multivariate lambda calculus

// structure declare
declare         ::= _sg(declare) _declarebody _eg(declare)
_declarebody    ::= ci (fn | constructor)?

// constructeurs
interval    ::=  _sg(interval) _mmlarg _mmlarg _eg(interval)    //début et fin d'un intervalle défini
set         ::=  _sg(set) _lsbody _eg(set)
list        ::=  _sg(list) _lsbody _eg(list)
_lsbody     ::=  _mmlarg*                  //arguments énumérés
             | (bvar* condition _mmlarg)   //arguments des structures condition

matrix        ::= _sg(matrix) matrixrow* _eg(matrix)
matrixrow     ::= _sg(matrixrow) _mmlall* _eg(matrixrow)         //admet une matrice d'opérateurs

vector        ::= _sg(vector) _mmlarg* _eg(vector)

piecewise     ::= _sg(piecewise) piece* otherwise? _eg(piecewise)
piece         ::= _sg(piece) _mmlall _eg(piece)          //admet une structure en bloc des opérateurs
otherwise     ::= _sg(otherwise) _mmlall _eg(otherwise)  //admet une structure en bloc des opérateurs

// qualificatifs - remarquez que le _mmlarg contenu pourrait être un reln
lowlimit            ::= _sg(lowlimit) _mmlarg  _eg(lowlimit)
uplimit             ::= _sg(uplimit) _mmlarg _eg(uplimit)
bvar                ::= _sg(bvar) ci degree? _eg(bvar)
degree              ::= _sg(degree) _mmlarg _eg(degree)
logbase             ::= _sg(logbase) _mmlarg _eg(logbase)
domainofapplication ::= _sg(domainofapplication) _mmlarg _eg(domainofapplication)
momentabout         ::= _sg(momentabout) _mmlarg _eg(momentabout)

//relations, opérateurs et symboles des constantes
// (une déclaration pour chaque élément opérateur et relation)
_relation       ::= _ey(\%relation)         //par exemple, <eq/>  <lt/>
_operator       ::= _ey(\%operator)         //par exemple, <exp/> <times/>
_const-symbol   ::= _ey(\%const-symbol)     //fpar exemple, <integers/> <false/>

//l'élément de premier niveau math
//admet un declare seulement en tête de l'élément math.
math            ::= _sg(math) declare* mmlall* _eg(math)

Table des matières : Le langage de balisage mathématique (MathML) version 2.0
Chapitre précédent : A L'interprétation MathML
Chapitre suivant : C Les définitions des éléments de contenu