liste associative à droite et stds

[essemme]

bonjour,

je vais vous parler de grammaire hors contexte, ou plus précisément de schéma de traduction dirigé par la syntaxe.
Ma question est comment sont organisés le attributs synthétisés et hérités dans une production associative à droite?

est-ce comme ceci:
A -> a { A.h = a.uniLex} A₁ { A.s = A.h || A₁.s }
A -> epsilone { A.s = chaine vide }

ou auterment?

quelqu'un a une idée?
-----

[essemme]

a-t-on le droit d'écrire ceci:
A -> a A₁ { A.s = a.uniLex || A₁.s }
A -> epsilone { A.s = chaine vide }

qu'en pensez-vous?

[essemme]

je pense qu'il faut faire ceci:
A -> a { A₁.h = a.uniLex } A₁ { A.s = A₁.h || A₁.s }
A -> epsilone { A.s = chaine vide }

[essemme]

dans les posts #1 et #3, le problème est que l’attribut synthétisé A.s se calcul toujours avec un attribut hérité A.h. Le problème est dans l'arbre syntaxique décoré, à la racine, on a pas d'attribut hérité (puisqu'on est à la racine). on ne peut donc pas calculer A.s de la racine.

[A voir en vidéo sur Futura]

[essemme]

je rappelle la grammaire hors contexte:

A -> a A
A -> epsilon

je propose comme stds:

A -> a { A1.h=a.valex } A1 {A.s=A.h||A1.s}
A -> epsilon {A.s=A.h}

[essemme]

pour le problème d'attribut hérités à l'axiome, on recrée l'axiome avec un autre non terminal:

P -> A       | P.s = A.s
             | A.h=vide
A -> a A1    | A1.h = a.unilex
             | A.s=A.h || A1.s
A -> epsilon | A.s=A.h

le schéma de traduction dirigé par la syntaxe:

P -> { A.h=vide } A { P.s = A.s}
A -> a { A1.h = a.unilex } A1 { A.s = A.h || A1.s }
A -> epsilon {A.s=A.h}

[essemme]

Le calcul f(A.h,a.vallex) doit se faire avant A1 :

A -> a { A1.h = f( A.h , a.vallex ) } A1 { A.s = A1.s }
A -> epsilon { A.s = A.h }

en ajoutant l'axiome P :

P -> { A.h = nil } A { P.s = A.s }
A -> a { A1.h = f( A.h , a.vallex ) } A1 { A.s = A1.s }
A -> epsilon { A.s = A.h }

[essemme]

voici la définition dirigée par la syntaxe:

P -> A       | P.s = A.s
             | A.h = nil
A -> a A1    | A1.h = f( A.h , a.unilex)
             | A.s = A1.s
A -> epsilon | A.s = A.h

[essemme]

par exemple, la liste d'affectations:
A=affectation
RA=reste affectation
VG: destination d'une affectation
VD source d'une affectation
la grammaire est:

A -> VG RA
RA -> egal VG RA
   -> VD

la stds est la suivante

A -> VG {liste RA.h=(VG.s)} RA {A.s = RA.s}
RA -> egal VG { liste RA1.h= (VG.s) + liste RA.h } RA1 {RA.s=RA1.s}
   -> VD { RA.s=affectation(RA.h,VD.s) }

[essemme]

non, je me suis gourré. la grammaire est:

A -> VG egal RA
RA -> VG egal RA
      -> VD

le stds (schéma de traduction dirigé par la syntaxe)

A -> VG { liste RA.h = (VG.s) } egal RA {A.s=RA.s}
RA -> VG { liste RA1.h = (VG.s) + liste RA.h } egal RA1 {RA.s=RA1.s}
   -> VD { RA.s = affectation(RA.h,VD.s}

[essemme]

si on utilise une grammaire LL, VG et VD sont factorisables à gauche par un identificateur.
j'utilise alors un mot-cle "valdroite" (vous n'êtes pas obligé si vous avez une meilleur solution):

A -> VG egal RA
RA -> VG egal RA
   -> valdroite VD

le stds est:

A -> VG {liste RA.h=(VG.s)} RA {A.s = RA.s}
RA -> egal VG { liste RA1.h= liste RA.h +  (VG.s) } RA1 {RA.s=RA1.s}
   -> valdroite VD { RA.s=affectation(RA.h,VD.s) }

[essemme]

désolé, je me suis trompé de post pour le stds.
valdroite est ici un terminal:

A -> VG { liste RA.h = (VG.s) } egal RA {A.s=RA.s}
RA -> VG { liste RA1.h = liste RA.h +  (VG.s)} egal RA1 {RA.s=RA1.s}
   -> valdroite VD { RA.s = affectation(RA.h,VD.s)}

[essemme]

finlement c'est le stds du post #9 qui est bon. un valdroite dans toutes les affectations, ça fait un peu lourd.

A -> VG { listeRA.h =VG.s } RA { A.s = RA.s}
RA -> deuxptsegal VG {listeRA1.h = VG.s + listeRA.h } RA1 { RA.s = RA1.s }
RA -> VD {RA.s = affectation(listeRA.h , VD.s ) }

[JPL]

Le forum n’est pas un blog. "Discussion" fermée.