Structures simples et tableaux Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure d’Informatique (ESI)

Structures simples et tableaux : Définitions Structure = Enregistrement Une structure simple est un ensemble d’éléments de types différents. Chaque type est simple (Entier, Booleen, Car, Chaine) Un tableau est un ensemble d’éléments de même type. Chaque élément peut être de type simple ou du type structure simple. Exemples Soit s1 une structure (entier, boolean, car); Soit s2 : (chaine, entier); Soit v1 un vecteur(5,6) de entiers; Soit v2 un vecteur de (chaine, booleen);

Structures simples et tableaux : Représentation d’un tableau en mémoire (à l’exécution) Zone de données Tableau Descriptif Dimension Bornes

Structures simples et tableaux Représentation d’une structure simple en mémoire (à l’exécution) Zone de données Les différents champsStructure( adresse vers les valeurs des champs)

Représentation d'un tableau en mémoire Déclaration : A(a 1 :b 1 ; a 2 :b 2 ;......a n :b n ) Ordre de rangement des sous tableaux A(i, *, *,..., *) : A(a 1, *, *,..., *), A(a 1 +1, *, *,..., *), A(a 1 +2, *, *,..., *), , A(b 1, *, *,..., *)

Représentation d'un tableau en mémoire A l'intérieur de chaque sous tableau A(i, *, *,...., *), l'ordre suivant des sous sous-tableaux est considéré : A(i, a 2, *, *,..., *), A(i, a 2 +1, *, *,..., *), A(i, a 2 +2, *, *,..., *),......, A(i, b 2, *, *,..., *) Et ainsi de suite...  Donc rangement de la matrice ligne par ligne. Ce sont les derniers indices qui varient le plus rapidement.

Représentation d'un tableau en mémoire Exemple pour un tableau A(3, 2, 3)

Représentation d'un tableau en mémoire Adresse d'un élément A(i 1, i 2.., i n ) ? Posons d i = b i - a i + 1 Adr de A(i 1, *, *,....) : AD 1 = Base + (i 1 -a 1 ) d 2 d 3...d n Adr de A(i 1, i 2, *,...., *) : AD 2 = AD 1 + (i 2 -a 2 )d 3 d 4...d n Adr de A(i 1, i 2,...i n ) : AD n = Base + (i 1 -a 1 )d 2 d 3..d n + (i 2 -a 2 )d 3 d 4...d n (i n-1 -a n-1 )d n + (i n -a n ) Partie constante : Base -(a 1  i=2,n d i + a 2  i=3,n d i +...+a n-1 d n + a n ) Partie variable : i 1  i=2,n d i + i 2  i=3,n d i i n-1 d n + i n

Représentation d'un tableau en mémoire Si a 1 = a 2 = = a n = 0, l‘adresse de A(i 1, i 2,...i n ) est i 1 d 2 d 3..d n + i 2 d 3 d 4...d n i n-1 d n + i n Ou bien :  j=1,n ( i j.  i=j+1,n d i ) d i d i+1...d n : facteur multiplicatif

Structure de TABOB (Statut, Type, Nombre, Adresse) avec Statut qui peut être : 'L' : Variables locales 'X' : Variable auxiliaire de valeur créée par le compilateur 'Y' : Variable auxiliaire d'adresse créée par le compilateur 'C' : Constante entière, logique, pointeur, chaîne de caractères Type : Indice vers la tables des types.( 'W' pour NIL ) TABTYP : chaîne de caractères contenant tous les types Nombre : Longueur du type (nombre de caractères formant le type) Adresse : Adresse relative de l'objet dans la zone de données si le statut est 'L', 'X' ou 'Y' Rang dans la liste des constantes si le statut est 'C'

Sémantique des structures simples : Quadruplés Au niveau des déclarations (Voir grammaire) A : pointeur TABOB vers l’objet composé B, et C non utilisés Pour un objet composé, Statut=‘L’, Type= indice dans la table des types (TABTYP), Nombre=nombre de caractères formant le type, Adresse=adresse relative de l’objet dans la zone de données (‘Ds’, A, B, C )

Sémantique des structures simples : Quadruplés Manipulation:STRUCT(S,Rang),AFF_STRUCT(S,Rang,Exp),INIT_STRU CT(S,[Exp1, Exp2, …]) A : pointeur dans TABOB vers l’objet composé B : numéro du champ C : pointeur dans TABOB vers le résultat de Struct B : numéro du champ C : pointeur dans TABOB vers la valeur à affecter A : pointeur dans TABOB vers l’objet composé B : pointeur dans TABCOMP vers la liste des expressions scalaires C : nombre d’expressions (‘Struct’, A, B, C ) (‘Aff_struct’, A, B, C ) (‘Init_struct’, A, B, C )

Sémantique des tableaux : Quadruplés Au niveau des déclarations (Voir grammaire) A : pointeur dans TABOB vers l’identificateur de tableau B : indice dans TABCOMP vers la liste des bornes D : dimension Pour un objet tableau, Statut=‘L’, Type= indice dans la table des types ( TABTYP ), Nombre=nombre de caractères formant le type, Adresse=adresse relative de l’objet dans la zone de données (‘Dt’, A, B, C )

Sémantique des tableaux : Quadruplés Au niveau des instructions : ELEMENT(T[Exp1,Exp2,..]), AFF_ELEMENT(T[Exp1,Exp2,..], Exp), INIT_TABLEAU(T, [[Exp1,Exp2,..]) A : pointeur TABOB vers l’identificateur de tableau B : pointeur dans TABCOMP vers la liste des expressions C : pointeur dans TABOB vers le résultat de Element A : pointeur TABOB vers l’identificateur de tableau B : pointeur dans TABCOMP vers la liste des expressions D : pointeur dans TABOB vers la valeur à affecter A : pointeur TABOB vers l’identificateur de tableau B : pointeur dans TABCOMP vers la listes des expressions C : non utilisé (‘Element’, A, B, C ) (‘Init_vect’, A, B, C ) (Aff_Element’, A, B, C )

Structures simples et tableaux : Déclarations Types dans {Entier, Booleen, Car, Chaine} Sep dans { :, Un, Une, Des} Cste désigne une constante numérique entière Chaîne : chaîne de caractères Idf désigne un identificateur Opr dans {, >=, =, <> } Opa dans { +, -, Ou } Opm dans { *, /, Et } Sign dans {+, -} Tableau est synonyme de Vecteur Init_tableau est synonyme de Init_vecteur

Structures simples et tableaux : Déclarations  [ ~Soit|Soient~ ] Debut Fin [;]  ;{ [~Soit|Soient~] ;}*  [Sep ]  Idf {, Idf}*

Structures simples et tableaux : Déclarations  Types | Tableau ( ) [De~ | Types~ ] | |  [Structure ](Types {, Types }*)  Cste {, Cste}*

Structures simples et tableaux : Instructions  { ; }*  Idf := | Lire ( Idf {, Idf }* ) | Ecrire ( {, }* ) | Tantque [ : ] Fintantque | Si [:] [Sinon ] Fsi | Pour Idf:=, [, ][:] Finpour

Structures simples et tableaux : Instructions  Aff_element ( [[ {, }* ]], ) | Aff_struct(Idf, Cste, ) ~ Init_vecteur | Init_struct ~ ( Idf, [[ ~ |[[ {, }*]] ~ {, ~ |[[ {, }*]]~}* ]] ) |

Structures simples et tableaux : Expressions  [ Opr ]  [Sign] { Opa }*  {Opm }*  Idf | Cste | ( ) | Non | Vrai | Faux | Chaine  Struct ( Idf, Cste) Element ( [[ {, }* ]] ) | |

Sémantique d’une déclaration de structure: Fonctions sémantiques  [Structure ] (Types {, Types }*) F1F2 Faire Type=‘(‘+Types F1 Faire Type= Type + Types F2 F3 Faire Type= Type + ‘)’ F3

Sémantique d’une déclaration de tableau: Fonctions sémantiques  Tableau ( ) [De~ | Types~ ] F1  Cste {, Cste }* Faire Type=‘V‘; Type_element=‘E’ (par défaut’) F1 Faire Type= Type +Cste; Ranger Cste dans TABCOMP(soit PtComp l’emplacement); Compte:=1 F2 Faire Type= Type + ‘,’+Cste; Ranger Cste dans TABCOMP; Compte= Compte +1; F3 F2F3 F4 Soit T est le type produit par ou Types. Type_element = T; Faire Type= Type + Type_element F4

Sémantique d’une déclaration : Fonctions sémantiques  [ Sep ] F1 Soit L la liste produite par et soit Type le type produit par. Ranger Type dans TABTYP si Type n’existe pas. Soit I son indice dans cette table.Pour chaque Idf dans L :-- Le mettre dans la table des symboles; -- Lui attribuer une adresse relative A et le mettre dans la table des objets (soit Pt son emplacement). L’objet créé aura comme Statut=‘L’;Type=I; Nombre=Longueur(Type) et Adresse=A; Si type simple :Générer le quadruplé (‘D’+types, Pt,, ) Si structure simple : Générer le quadruplé (‘DS’, Pt,, ) Si tableau : Générer le quadruplé (‘DT’, Pt, Ptcomp, Compte, ) F1 Déjà traité en CS7. C’est plus général

Sémantique de Aff_struct : Fonctions sémantiques Aff_struct (Idf, Cste, ) F1 Vérifier que idf est déclarée comme une structure (S). Sinon Erreur.Soit Pt son emplacement dans TABOB F1 F2F3 Récupérer le nombre (N)de champ de S. Si cste N :Erreur. Récupérer le type (T) du champ de S de rang cste. F2 Soit Temp le résultat de. Vérifier si le type de Temp est égal à T. Si non égal : erreur. Générer le quadruplet ( ‘Aff_struct’, Pt, cste, Temp) F3

Sémantique de Aff_element : Fonctions sémantiques Aff_element ( [[ {, }* ]], ) F1 Soit Temp1 (emplacement dans TABOB)le résultat de et soit Type son type. Si Type n’est pas un tableau : Erreur. Récupérer dans Typtab son type et dans Dim sa dimension F1 F2F3 Soit Temp le résultat de. Si son type n’est pas un entier: Erreur. Intialiser Compte à 0.Mettre Temp dans la table Tabcomp.Soit Ptabcomp son emplacement. F2 Soit Temp le résultat de. Si son type n’est pas un entier: Erreur. Incrémenter Compte d’une unité.Mettre Temp dans la table Tabcomp. F3 F4

Sémantique de Aff_element : Fonctions sémantiques Aff_element ( [[ {, }* ]], ) F1 Soit Temp2 (emplacement dans TABOB)le résultat de et soit Type2 son type. Si Type2 # Typtab : Erreur. Si Compte # Dim : Erreur Générer le quadruplé (‘Aff_element’, Temp1,Ptabcomp, Temp2) F4 F2F3 F4

Sémantique de Struct : Fonctions sémantiques Struct (, Cste ) F1 Soit Temp1 (emplacement dans TABOB)le résultat de et soit Type2 son type. Si Type2 n’est pas une structure : Erreur. Récupérer le nombre de champ de la structure dans N et le type du champ n° cste (Typechamp) F1 F2 Vérifier que Cste est entière et comprise entre 1 et N. Sinon Erreur. Générer un temporaire d’adresse avec le ‘Satut=‘Y’et avec Type= Typechamp. Soit Temp2 son emplacement dans TABOB). Générer le quadruplé (‘Struct’, Temp1,Cste, Temp2) F2

Sémantique de Element : Fonctions sémantiques Element ( [[ {, }* ]] ) F1 Soit Temp1 (emplacement dans TABOB)le résultat de et soit Type2 son type. Si Type2 n’est pas une tableau : Erreur. Récupérer la dimension du tableau dans Dim et le type des éléments dans Typtab F1 F2 Soit Temp1 le résultat de. Vérifier que Temp est du type entier. Sinon Erreur. Intialiser Compte à 0.Mettre Temp1 dans la table Tabcomp.Soit Ptabcomp son emplacement F2 F3 Soit Temp le résultat de. Si son type n’est pas un entier: Erreur. Incrémenter Compte d’une unité.Mettre Temp dans la table Tabcomp. F3 F4

Sémantique de Element : Fonctions sémantiques Element ( [[ {, }* ]] ) F1F2 Si Dim # Compte : Erreur Générer un temporaire d’adresse avec le ‘Satut=‘Y’et avec Type= Typtab. Soit Temp2 son emplacement dans TABOB). Générer le quadruplé (‘Element’, Temp1, Ptabcomp, Temp2) F4 F3F4

Sémantique de Init_Struct et Init_vecteur : Fonctions sémantiques Retrouver la sémantique pour Init_struct et Init_vecteur

Sémantique des structures : Exemple soit s une structure(entier, chaine, booleen); debut aff_struct(s, 1, 5); aff_struct(s, 2, 'abc'); aff_struct(s, 3, Vrai); ecrire (Struct(s,2)); fin TABCONS En fin de compilation, programme source = table des quadruplés + TABOB + TABCONS + LONGZDD ‘L’150 ‘C’ ‘Y’ TABOB 2 LONGZDD 3 4 Quadruplés générés ‘Ds’1 ‘Aff_st’ ‘Struct’137 ‘Ecr’ TABCOMP 7 ‘1’, ‘5’,’2’,’abc’,’3’,’vrai’ TABTYP (ESB)

Sémantique des vecteurs : Exemple soit T un vecteur(3) de entier; debut Aff_element(T[1], 13); Aff_element(T[2], 18); Aff_element(T[3], 35); ecrire( Element(T[2]) ); fin TABCONS En fin de compilation, programme source = table des quadruplés + TABOB + TABCONS + LONGZDD ‘C’110 ‘L’230 ‘C’ ‘Y’ TABOB 8 LONGZDD 3 4 Quadruplés générés ‘Dt’2 ‘Aff_el’ ‘Elem’247 ‘Ecr’ TABCOMP 7 ‘3’, ‘1’,’13’,’2’,’18’,’35’ TABTYP EV3E

Structures simples et tableaux : interprétation À la rencontre du quadruplé Pt : Pointeur dans TABOB vers l’objet tableau Liste : Pointeur dans TABCOMP vers la liste des bornes Dim : Dimension (nombre de bornes) Il y a : Allocation d’une zone pour le descriptif et son remplissage Allocation d’un espace pour le tableau et initialisation à Nil (‘Dt’, Pt, Liste, Dim )

Structures simples et tableaux : interprétation À la rencontre du quadruplé Pt : pointeur dans TABOB vers la structure Il y a Allocation d’un espace pour la structure dont la taille est égal au nombre de champ Allocation pour les différents champs en fonction des types (‘Ds’, Pt,, )

Structures simples et tableaux : interprétation À la rencontre du quadruplé Ptobj: pointeur dans TABOB vers le tableau Ptcom : pointeur dans TABCOMP Ptres : pointeur vers l’objet où sera rangé le résultat Les opérations suivantes sont entreprises : - Accès au descriptif via le champ adresse de Ptobj. On y trouvera l’adresse du premier élément du tableau. - Utiliser le module de calcul d’adresse pour calculer l’emplacement de l ’élément d’indice i1, i2, i3,.. - Vérifier que c’est dans l’intervalle. Sinon Erreur. (Ces indices sont récupérés via TABCOMP  TABOB  adresses) - Récupérer le résultat dans Ptres (‘Element’, Ptobj, Ptcomp, Ptres )

Structures simples et tableaux : interprétation Retrouver l’interprétation des quadruplés pour Struct, Aff_struct, Aff_element, Init_struct et Init_vecteur