1 / 69

R éé criture pour la programmation et la preuve

R éé criture pour la programmation et la preuve. Claude Kirchner Pierre-Etienne Moreau. Application à XML. Document XML. XML permet de d é crire des documents structur é s <?xml version="1.0" encoding="UTF-8"?> <Persons> <Person Age="30"> <FirstName> Paul </FirstName> </Person>

len
Download Presentation

R éé criture pour la programmation et la preuve

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Réécriture pour la programmation et la preuve Claude Kirchner Pierre-Etienne Moreau

  2. Application à XML

  3. Document XML • XML permet de décrire des documents structurés <?xml version="1.0" encoding="UTF-8"?> <Persons> <Person Age="30"> <FirstName> Paul </FirstName> </Person> <Person Age="42"> <FirstName> Mark </FirstName> </Person> <Person Age="21"> <FirstName> Jurgen </FirstName> </Person> <Person Age="21"> <FirstName> Julien </FirstName> </Person> <Person Age="24"> <FirstName> Pierre </FirstName> </Person> </Persons> • On peut voir un document XML comme un arbre

  4. Transformation de documents XML • On a envie de pouvoir manipuler ces données • pour y rechercher de l’information • pour générer de nouveaux documents (HTML, LaTeX, PDF, XML, etc.) • Quels sont les outils permettant de le faire • XSLT / XPath • Xquery • Xduce / Cduce • DOM • … • Peu permettent de manipuler un document XML en Java • Les manipulations se font souvent en utilisant DOM directement

  5. Exemple • On veut savoir s’il existe un noeud de la forme <Person><FirstName> Julien </FirstName></Person> <?xml version="1.0" encoding="UTF-8"?> <Persons> <Person Age="30"> <FirstName> Paul </FirstName> </Person> <Person Age="42"> <FirstName> Mark </FirstName> </Person> <Person Age="21"> <FirstName> Jurgen </FirstName> </Person> <Person Age="21"> <FirstName> Julien </FirstName> </Person> <Person Age="24"> <FirstName> Pierre </FirstName> </Person> </Persons>

  6. Filtrage • Il faut savoir si un pattern XML filtre vers un noeud de document XML • On aimerait pouvoir écrire %match(t) { <Person><FirstName> Julien </FirstName></Person> -> { // Noeud trouvé } } • Ou plus généralement : <Person><FirstName> X </FirstName></Person> -> { … }

  7. Modèle de donnée (simplifié) ElementNode(name:str, attrList:TNodeList, childList:TNodeList) -> TNode AttributeNode(name:str, value:str) -> TNode TextNode(data:str) -> TNode conc(TNode*) -> TNodeList

  8. XML vs. Term • Un document XML peut se voir comme un arbre <A a="at1"><B/></A> est représenté par : ElementNode("A", conc(AttributeNode("a", "at1")), conc(ElementNode("B",conc(),conc())) )

  9. Pattern XML • On veut pouvoir écrire un pattern de la forme <A a="at1">X</A> qui sera encodé par : ElementNode("A", conc(AttributeNode("a", "at1")), conc(X) )

  10. Questions • A-t-on : • <A a="at1">X</A> << <A a="at1"><B/></A> ? • <A a="at1">X</A> << <A a="at1"><B/><C/></A> ? • Quel est le type de X ? • TNode ? • TNodeList ? • On voudrait pouvoir écrire • <A a="at1">X*</A> << <A a="at1"><B/><C/></A> • Quelles sont les solutions ?

  11. Questions • En fonction du parseur, <A a="at1"><B/></A> peut être reconnu comme <A a="at1"><B/></A> • A-t-on : • <A a="at1">X</A> << <A a="at1"><B/></A> ? • <A a="at1">X*</A> << <A a="at1"><B/></A> ? • Comment est encodé<A a="at1"><B/></A> ? ElementNode("A", conc(AttributeNode("a", "at1")), conc( TextNode(""), ElementNode("B",conc(),conc()), TextNode("")) ) • Est-ce que cela filtre ?

  12. Notation explicite <A a="at1">(_*,X,_*)</A> qui correspond à : <A a="at1">conc(_*,X,_*)</A> A-t-on <A a="at1">(_*,X,_*)</A> << <A a="at1"><B/></A> ? Oui, il y a 3 solutions

  13. Notation implicite <A a="at1">(_*,X,_*)</A> qui correspond à : <A a="at1">[X]</A> qui correspond également à <A a="at1">X</A> A-t-on <A a="at1">X</A> << <A a="at1"><B/></A> ? Oui, il y a 3 solutions

  14. Attributs • Les attributs sont représentés par une liste de couples (nom,valeur) • Il existe également des notations implicites et explicites • Ainsi : • <A a="at1"> correspond à<A [a="at1"]> • qui correspond à<A (_*,a="at1",_*)>

  15. Questions • A-t-on : • <A a="at1"></A> << <A a="at1"></A> ? • <A a="at1"></A> << <A a="at1" b="at2"></A> ? • Pourquoi ? • car <A (_*,a="at1",_*)></A> << <A (a="at1" b="at2 »)></A> ? • A-t-on : • <A a="at1" b="at2"></A> << <A a="at1" b="at2"></A> ? • <A a="at1" b="at2"></A> << <A b="at2" a="at1"></A> ? • Non, car : • (_*, a="at1", _*, b="at2", _*) !<< (b="at2", a="at1") • Il faudrait du filtrage AC avec élément neutre!

  16. Attributs dans Tom • On considère un ordre sur les noms d’attributs • et les formes canoniques où les attributs sont triés • Ainsi, <A b="at2" a="at1"></A> est représenté par ElementNode("A", conc( AttributeNode("a", "at1"), AttributeNode("b", "at2")), conc()) • De même, pour les motifs

  17. Utilisation dans Tom Node sort(Node subject) { %match(subject) { <Persons>(X1*,p1,X2*,p2,X3*)</Persons> -> { if(`compare(p1,p2) > 0) { return sort(`xml(<Persons> X1* p2 X2* p1 X3* </Persons>)); } } } return subject; }

  18. Comparaison d’attributs int compare(Node t1, Node t2) { %match(t1, t2) { <Person Age=a1><FirstName> n1 </FirstName></Person>, <Person Age=a2><FirstName> n2 </FirstName></Person> -> { return `a1.compareTo(`a2); } } return 0; }

  19. Ancrage formel Mapping

  20. Problématique • Comment faciliter l’utilisation du filtrage dans les programmes existants ? • en permettant un mélange des syntaxes • en permettant de filtrer vers des structures du langage hôte • Nous avons donc besoin de filtrer « modulo des vues »

  21. Solution adoptée • Tom permet de « voir » les objets en mémoire comme des termes algébrique • Il faut pour cela définir un «ancrage formel»permettant • de savoir si un terme commence par un symbole donné • d’accéder à un sous terme donné

  22. Plus formellement • On considère les ensembles : • [N], la représentation des entiers naturels • [B], la représentation des booléens • [F], la représentation des symboles • [T(F)], la représentation des termes clos • [X], la représentation des variables

  23. Contraintes à respecter • t1,t2T(F), eq([t1],[t2]) = [t1=t2] • fF, tT(F), is_fsym(t,f) = [Symb(t)=f] • fF, i[1..ar(f)], tT(F) subtermf(t,i) = [t|i]

  24. Structure de données struct term { int symb; struct term **subterm; } On représente les symboles par des entiers (zero,3), (suc,5), (plus,7), …

  25. Mapping de Nat vers une structureC %typeterm Nat { implement equals(t1,t2) } %op Nat zero { is_fsym(t) } %op Nat suc(p:Nat) { is_fsym(t) get_slot(p,t) } { struct term* } { term_equals(t1,t2) } { t!=null && t->symb==3 } { t!=null && t->symb==5 } { t->subterm[0] }

  26. Mapping • Permet de voir une structure arborescente comme un terme • Plus généralement, permet de voir n’importe quelle structure de donnée comme un terme • Permet de filtrer vers des objets en mémoire

  27. Exercice • Peut-on voir les entiers machine comme des entiers de Peano ? %typeterm Nat { implement { int } } %op Nat zero { is_fsym(t) { t==0 } } %op Nat suc(p:Nat) { is_fsym(t) { t>0 } get_slot(p,t) { t-1 } }

  28. Peut-on filtrer vers des objets ? class A { int a; } class B extends A { int b; } %typeterm A { implement { A } equals(t1,t2) {t1.equals(t2)} } %typeterm B { implement { B } equals(t1,t2) {t1.equals(t2)} }

  29. Mapping objet %op A A(a:int) { is_fsym(t) { t instanceof A } get_slot(a,t) { t.a } } %op A B(a:int,b:int) { is_fsym(t) { t instanceof B } get_slot(a,t) { t.a } get_slot(b,t) { t.b } } • A[a=x] << new A(3) • B[b=x] << new B(2,3) • A[a=x] << new B(2,3)

  30. Demo

  31. Questions • Doit-on écrire des mappings ? • Que fait %vas au juste ?

  32. Outils autour de Tom Aterm, SDF, ApiGen, Vas

  33. Bibliothèque ATerm • Aterm • AFun • ATermAppl • ATermList • ATermInt • ATermReal • ATermPlaceholder • ATermBlob • ATermFactory

  34. ATerms

  35. Bibliothèque ATerm • Aterm • AFun • ATermAppl • ATermList • ATermInt • ATermReal • ATermPlaceholder • ATermBlob • ATermFactory • getAnnotation • setAnnotation • toString • etc.

  36. Bibliothèque ATerm • Aterm • AFun • ATermAppl • ATermList • ATermInt • ATermReal • ATermPlaceholder • ATermBlob • ATermFactory • getName • getArity

  37. Bibliothèque ATerm • Aterm • AFun • ATermAppl • ATermList • ATermInt • ATermReal • ATermPlaceholder • ATermBlob • ATermFactory • getAFun • getArgument • setArgument • etc.

  38. Bibliothèque ATerm • Aterm • AFun • ATermAppl • ATermList • ATermInt • ATermReal • ATermPlaceholder • ATermBlob • ATermFactory • getFirst • getNext • elementAt • insert • append • concat • etc.

  39. Bibliothèque ATerm • Aterm • AFun • ATermAppl • ATermList • ATermInt • ATermReal • ATermPlaceholder • ATermBlob • ATermFactory • makeAFun • makeAppl • … • parse • readFromFile • etc.

  40. Utilisation des ATerms Aterm t1 = factory.parse("a") Aterm t2 = factory.parse("f(a,b)") t2.getArgument(1) == t1 ? > true Aterm t3 = t2.setArgument(t1,2) > t3 = f(a,a) Aterm t4 = factory.parse("f(a,f(b))") > ‘f’ n’a pas de signature particulière Les Aterms permettent de construire des termes, mais il n’y a pas de sécurité (signature, types)

  41. ApiGen / Vas • A partir d’une signature multi-sortée • Génère des classes, reposant sur les Aterms, permettant de représenter les termes • partage maximal • typage fort des termes • tout terme typé est un ATerm

  42. Exemple Module Expressions true -> Bool false -> Bool eq(lhs:Expr, rhs:Expr) -> Bool id(value:str) -> Expr nat(value:int) -> Expr add(lhs:Expr, rhs:Expr) -> Expr mul(lhs:Expr, rhs:Expr) -> Expr

  43. Classes générées

  44. Classes générées

  45. Stratégies

  46. Programmation par réécriture • Avantages • le filtrage est un mécanisme expressif • les règles expriment des transformations élémentaires • Limitations • les systèmes de règles sont souvent non-terminant et/ou non confluent • en général, on ne veut pas appliquer toutes les règles en même temps

  47. Exemple de système non terminant And(Or(x,y),z)  Or(And(x,z),And(y,z)) And(z,Or(x,y))  Or(And(z,x),And(z,y)) Or(And(x,y),z)  And(Or(x,z),Or(y,z)) Or(z,And(x,y))  And(Or(z,x),Or(z,y)) Not(Not(x))  x Not(And(x,y))  Or(Not(x),Not(y)) Not(Or(x,y))  And(Not(x),Not(y))

  48. Codage du contrôle dans les règles • Solution classique • introduire un nouvel opérateur f pour restreindre l’ensemble de règles permettant de normaliser • l  r devient f(l)  r’ • on normalise un terme f(t) • l’opérateur f permet de contrôler les règles à appliquer

  49. Encodage du contrôle f(And(x,y))  and(x,y) f(Not(x))  not(x) f(Or(x,y))  Or(f(x),f(y)) and(Or(x,y),z)  Or(and(x,z),and(y,z)) and(z,Or(x,y))  Or(and(z,x),and(z,y)) and(x,y)  And(x,y) not(Not(x))  x not(And(x,y))  Or(not(x),not(y)) not(Or(x,y))  and(not(x),not(y)) not(x)  Not(x)

  50. Conséquences • Il faut définir la congruence explicitement, pour chaque règle et chaque constructeur • Il n’y a plus de séparation entre transformation et contrôle • cela rend la compréhension plus difficile • les règles sont moins réutilisables

More Related