Skip to topic | Skip to bottom
Home
Minfo03
Minfo03.PagePersoCyrilRodasr1.47 - 09 Jun 2004 - 16:13 - RodasCyriltopic end

Start of topic | Skip to actions
-- RodasCyril - 09 Jun 2004

J'ai mis un snapshot avec quelques changements au niveau de la doc et des demos...

  • Nouvelle section sur le mode light
  • Ajouté ce que JPR demandais
  • Decoupé le testfile en plusieurs fichiers, et remplacé les appels à vector-length et à modulo
  • Ajouté tri sur tableau
  • et diverses corrections sur la doc...

-- RodasCyril - 08 Jun 2004

Nouveau fichier "specialk-grammar.ss". J'ai du ajouté la possibilité d'ecrire la notation scientifique: [0-9]+[E+e][-]?[0-9]+

Nouvelle doc suite aux annotations de JPR.

-- RodasCyril - 07 Jun 2004

J'ai mis ma partie à ajouter sur le rapport final. Il y' a un nouvel analyseur qui s'appel "specialK-grammar.ss" suite à la localisation par Sylvain. J'ai egalement ajouté des commentaires pour la maintenance.

-- SylvainBeucler - 06 Jun 2004

  • DONE Correction du bug qui faisait planter l'opérateur ! dans arbre_un

J'ai aussi fait des remaniements dans la docs, à discuter (séparation des chapitres, utilisation de longtable - tableau sur plusieurs pages - pour la grammaire, ajout d'un paragraphe sur l'inclusion de code SpécialK dans Scheme)

-- RodasCyril - 04 Jun 2004

Le chapitre 3 (langage) de la doc est terminé. Reste à corriger les fautes.

Reste à faire:

  • Revoir le chapitre 2 (Prise en main) en particulier l'introduction.
  • Faire un chapitre "Outils de visualisation graphique des données".
  • Ajouter une doc de la librairie que Pierre à fait.
  • Eventuellement ce que JP à demandé.
  • Revoir la partie "Compatibilité avec MzScheme"
  • Et autre...

DONE Une correction a faire dans l'analyseur. Les opérateurs de comparaison sont associatifs à gauche alors qu'il ne devraient pas. Faudrait mettre nonassoc à la place de left.

-- RodasCyril - 03 Jun 2004

Nouvelle version de la doc, il me reste plus que la partie sur les tableaux.

Deuxieme version "finale" de l'analyseur et de la structure intermediaire. Changements:

  • Ajouté opérateur mod : a mod b renvoi le reste de la division euclidienne de a par b.
  • Ajouté opérateur div : a div b renvoi le quotient de la division euclidienne de a par b.
Ces opérateurs ont la même priorité que * et / et ne s'appliquent qu'a des operandes entiéres.

-- RodasCyril - 02 Jun 2004

Version final de l'analyseur et de la structure intermediaire disponible.

Il me reste encore plusieurs parties a écrire dans la doc. J'ai mis le .tex sur cette page. Je pense que j'aurai fini vendredi d'ecrire la doc, il y aura des parties a relire...

J'ai modifié quelques point dans l'analyseur et dans la structure intermediaire, les nouveaux fichiers sont disponibles:

  • DONE Autoriser l'usage des operateurs d'égalité et de différence avec les booléens.
  • DONE Revoir la priorité du - unaire.
  • DONE Vu que en SpécialK tout est vrai sauf faux, les opérateurs booléens devraient pouvoires s'appliquer à n'importe quel type d'objet.
  • DONE Localisation en debut de fichier des messages d'erreur, en vu de faciliter leur modification ou traduction.

-- JulienCharles - 01 Jun 2004

2 choses Cyril:
a. j'ai corrigé les bugs... et j'ai trouvé un bug dans pregexp.ss (!) - enfin c pas grave. ça doit marcher maintenant.
b. j'ai modifié les regexp des strings et des commentaires du lexer...

-- RodasCyril - 01 Jun 2004

J'ai commencé à rediger la doc, et j'ai finalizé le fichier de test. Le lien est à jour.

-- SylvainBeucler - 30 May 2004

Une petite modif dans le fichier d'exemples, où je remplace un length(L) > 1 -> fusion(L) par un fusion(c:d:L) (LENGTH IS BAD!). J'ai aussi rajouté l'exemple de la doc avec la recherche dans un arbre binaire.

-- RodasCyril - 29 May 2004

Il semblerait que la la derniere version de la structure intermediaire et de l'analyseur n'ait pas été integré.

Nouveaux bugs:

  • DONE Le top-level ne marche plus.
  • DONE Le matching entre les parenthese et guillemets ouvrantes et fermante ne marche plus.
  • DONE Il serait bien que l'on puisse avoir une couleur particuliére pour nil.

-- RodasCyril - 27 May 2004

Nouvelle version de la structure intermediaire et de l'analyseur:

  • Corrections des bugs.
  • Desormais on ne peut utiliser que les operateurs d'égalité et de différence sur les tableaux et les listes. Les autres n'ont pas des sens pour ces types.

Deuxieme rapport de bug:
Les 2 points qui suivent sont à tester:

  • DONE Comparaison sur des listes litterales a un comportement bien étrange.
  • DONE Comparaison sur des tableaux et listes ne marche pas (Operateurs d'égalité et de difference).
  • DONE Swap multiple et affectations multiples ne fonctionne pas trés bien. Par exemple, essayer: T[0 <-> 1][1 <-> 2], T[0 <-> 1][1] <- x.
  • DONE Affectation et swap sur des tableau litterraux ne fonctionne pas. Par exemple : {1,2,3}[0 <-> 1], {1,2,3}[1] <- x.
  • DONE Comparaison de 2 tableaux impossible (à cause de l'analyse).

-- RodasCyril - 26 May 2004

Debut de la phase de test.

Il y' a en attachement un fichier testfile.spk dans lequel je vais mettre un ensemble d'algos a Kounalis, ce qui me permet egalement de tester le produit. Je mettrai donc ici regulierement la liste des bugs rencontré.

Dans l'ensemble ca marche plutot bien, et c'est même presque agréable à utiliser...

Voici le premier rapport de bug:

  • DONE Erreur avec les operateurs unaire (!, -) : surement du a l'erreur que j'avait fait dans la grammaire et que julien avait "mal" corrigée. Le fichier attaché est corrigé.
  • DONE (mais à tester encore) Lorsque l'on definie une fonction en special-k qui a le meme nom qu'une primitive scheme, celle ci n'est pas écrasée par la nouvelle fonction.
  • DONE Message d'erreur de syntaxe n'affiche pas le contenu du token (ca c'est a moi de le corriger).
  • DONE true et false affiche true ou false et renvoient la liste vide!
  • DONE L'affectation au top-level provoque une erreur.

Petits probleme:

  • L'operateur | dans la syntaxe de scheme est comme une parenthese : il attend un | fermant. Peut etre devrions changer le symbole.
  • l'utilisation de - dans lees identifiant fait que si oon ecrit par exemple n-1 ,ceci est pris comme un identifiant. On obligé de mettre des espaces. Est-il possible de remplacer les - par _ de sorte que l'appel à fonc_f appel fonc-f et supprimer ainsi le - des identifiants?

-- RodasCyril - 24 May 2004

Comme demandé la nouvelle version de du parser lance une exn:read en cas d'erreur semantique. J'ai aussi renommé les fonctions principales. Que ce soit une erreur lexical, syntaxique ou semantique, c'est une exn:read qui lancée. Cependant, attention dans le cas d'une erreur de syntaxe, il se peut qu'apres avoir appelé la continuation une autre exception soit lancée par le parser (Il n'y a pas de moyens de lui dire de ne pas l'envoyer).

  • Chaine de caractere ajoutée, nouveau type.

  • Position dans les clauses et expressions top ajoutées.
  • Renommage de certaines fonctions (k-real? ...)

Reste a faire(mais peu utile, il est rare que l'utilisateur tape 1+3): evaluation des expressions quand c'est possible.

-- RodasCyril - 18 May 2004

Nouvel analyseur et nouvelle structure intermediaire, il faut telecharger la derniere version pour les 2 sinon ca ne marche pas. La premiere phase de l'analyse semantique est terminée (Voir partie Analyse Semantique ci-dessous).

-- RodasCyril - 17 May 2004

Nouvelle grammaire, nouvelle structure intermediaire, nouvel analyseur. L'analyseur fonctionne, et génére correctement la structure intermediaire. Pour le moment la sémantique ne verifie que la concordance des types dans les expressions.

-- RodasCyril - 12 May 2004

J'ai mis les fichiers attachés à jour. La grammaire va encore changer parce que j'ai pas mal de conflits.

-- RodasCyril - 11 May 2004

Nouvelle version de la grammaire format papier disponible. Mise a jour de la partie sur les tableaux, suite à notre discussion. Finalement, je pense qu'il y'a besoin de la virgule...

-- RodasCyril - 10 May 2004

J'ai mis une nouvelle version de la structure intermediaire. On a desormais des predicats sur les differents elements de la structure: fonctions clauses et arbres.

J'ai egalement reflechis a l'implementation des tableaux, voir partie grammaire.

-- RodasCyril - 07 May 2004

La structure intermediaire(en particulier les arbres) est susceptible de changement, mais si vous n'utilisez que les accesseurs les changements ne devraient poser aucun problemes.


Analyse

Le code de l'analyseur est accessible en bas.

Operateurs

Voici la liste des operateurs tel qu'il a apparaitrerons dans la structure intermediaire:

  • Operateur arithmetique: + - * /
  • Operateurs de comparaisons: < > ...
  • Operateur de liste: :
  • Operateur booleen: | &
  • Operateur appel de procedure: call
  • Operateur sur les tableaux: [] <-> {}
  • Operateur d'affectation: <-

Pour tous les opérateurs binaires e1 op e2 on construit l'arbre dont op est la racine, e1 est le fils gauche e2 est le fils droite: (op, e1, =e2). Pour les operateurs unaires ! e et - e on produit un arbre unaire: (!, e), (-, e). Pour les appels de procedures f(args) on produit l'arbre binaire (call, f, args), args etant une liste.

Tableaux

Le probleme des tableaux est que l'on doit pouvoir, avec une seule expression, modifier plusieurs cases du tableau. On doit aussi pouvoir avoir des tableaux contenant des tableaux et acceder directement à une case du sous tableau. Voici donc ce que nous avons decidé.

Creation de tableaux

  • {a, b, c, 4:5:nil}
  • {{a,b,c}, {1,2,3,4,5}, {d,f,g}}

On produit est arbre unaire: ({}, list_expr), list_expr étant la liste des elements du tableaux(arbres).

Principe

L'operateur [] est associatif à gauche. On a donc des expressions de la forme: expr1[expr2]. expr1 est évaluée en premier, puis on lui applique l'operateur []. On dispose egalement de l'ecriture suivante pour acceder a des cases de sous-tableaux(indispensable pour faciliter le swapping dans des tableau a plusieurs dimensions): expr1[expr2,...]. Exemples:
  • T[i] renvoi la valeur à la position i.
  • T[i][j] renvoi la valeur à la position j du sous tableau à la position i.
  • T[i,j] idem.
Il n'y a pas vraiment de tableau à plusieurs dimension mais plutôt des tableaux de tableaux.

Pour modifier les valeurs d'un tableau on utilise l'operateur <-: expr1[expr2] <- expr3. Exemples:

  • T[i] <- a renvoi un tableau dont la ieme case vaut a .
  • (T[i] <- a)[j] <- b renvoi un tableau dont la case i, vaut a et j vaut b.
  • T[i][j] <- a renvoi le sous tableau de T à la position i dont la case j vaut a.
  • T[i,j] <- a attention, c'est different: renvoie le tableau T dont la case i,j vaut a.

On peut egalement echanger(swapper) des valeurs de cases du tableau de la manière suivante: expr1[expr2 <-> expr3]

  • T[i <-> j] renvoi un tableau dont les cases i et j sont swappées.
  • T[i <-> j][j <-> k] swapping successif des cases i, j puis j, k.
  • T[i,j <-> k,l] swapping sur des cases de sous-tableaux.

D'autres exemples:

  • f(x)[i] On suppose que f renvoi un tableau.
  • T[i<->j][k] <- x Swapping puis affectation.
  • (T[k] <- x)[i<->j] Affectation puis swapping.

Sémantique

Il y a donc 3 opérations possibles:
  • L'accés à une valeur.
  • Le swapping.
  • L'affectation.

La premiére est binaire et renvoi une valeur alors que les 2 autres sont ternaires et renvoient un tableau. On va donc produire les arbres suivants:

  • expr1[expr2] produit l'arbre binaire suivant: ('[] expr1 expr2)
  • expr1[expr2] <- expr2] produit l'arbre ternaire: ('<- expr1 expr2 expr3)
  • expr1[expr2 <-> expr3] produit l'arbre ternaire: ('<-> expr1 expr2 expr3)

Les expressions entre crochet peuvent contenir plusieurs indices séparés pas des virgules, on produira donc l'arbre unaire suivant: (', liste-des-indexes), chaque index etant une expression donc un arbre.

Analyse semantique

L'analyse semantique se fait en 2 passes.

Premiére Phase

Cette phase est effectué "en meme temps" que l'analyse syntaxique, c'est a dire que toutes cette partie est ecrite dans la grammaire du parser. On verifie ici des aspects qui auraient pu être verifiés dans la syntaxe mais qui finalement sont verifiés semantiquement pour simplifier la grammaire et permettre d'afficher des messages d'erreurs plus explicites. Voici dans le détails les verifications effectuées:

1. Consistances des operations

On verifie tant que possible que le type des operandes soit applicable à l'operateur. Par exemple: (a + b) & c n'est pas correcte car on sait que a + b est de type numerique et nous n'autorisons l'usage de l'operateur booleen & que sur le des operandes de type booleen ou variable. Autre exemple: (a + b)[i] n'est pas correcte puisque l'operateur [] ne s'applique qu'a une expression de type tableau ou variable.

Les types des expressions sont les suivant:

  • INT : entier, par exemple: 1, 1 + 2
  • REAL : réel, par exemple: 1.55, 1.55 + 2, 1.55 + a
  • NUMERIC : type numerique mais on ne sais pas si c'est entier ou réel, par exemple: a + 1
  • BOOL : booléen, par exemple: true, false, A & B
  • LISTE : liste, par exemple: nil, c:L
  • TAB: tableau, par exemple: {a,b,c,d}, T[i <-> j], T[i] <- a
  • VAR: variable, le joker(tout ce dont on ne peut pas connaitre le type): a, T[i], f(x)

2. Type de la garde

On verife que la garde soit de type booleen ou variable.

3. Operations en partie gauche.

Le seul operateurs autorisé en partie gauche est l'operateur :. On verifie donc qu'aucun autre operateur est utilisé.

Definition de la structure intermediaire

Après la phase d'analyse on obtient un dictionnaire.

  • Un dictionnaire est une liste de fonctions et d'expressions top level (arbre).

  • Une expression top-level est une liste de la forme: (start-pos end-pos expr)

  • Une fonction est une liste de la forme: (nom nb_args clauses)
    • accesseurs: get_nom get_nb_args get_clauses
    • predicat: fonction?

  • Une clause est une liste de la forme: (start-pos end-pos args garde partie_droite)
    • accesseurs: get_pos get_args get_garde get_partie_droite
    • predicat: clause?
    • pos: position de la clause dans le code source.
    • args: liste des arguments en partie droite (arbres)
    • garde: arbre
    • partie_droite: arbre

  • Un arbre est une liste de la forme: ((op type) fg [fd] [fdd])
    • fg et fd sont des arbres.
    • accesseurs: get_fg get_fd get_op
    • predicats: unaire? binaire? ternaire? feuille? arbre? int? k-real? numeric? bool? var? k-list? k-string?


to top

I Attachment sort Action Size Date Who Comment
grammaireK.ps manage 47.2 K 18 May 2004 - 14:42 RodasCyril Grammaire du langage format papier
grammaireK.tex manage 5.6 K 18 May 2004 - 14:43 RodasCyril Fichier source
special-k-structs.ss manage 14.6 K 07 Jun 2004 - 14:30 SylvainBeucler une version modulaire de la structure
testfile.spk manage 6.3 K 01 Jun 2004 - 00:36 RodasCyril Un fichier de test en special K
specialk-fr.tex manage 55.0 K 08 Jun 2004 - 14:53 RodasCyril La documentation (quelques remaniements)
rapport_analyse.sxw manage 11.5 K 07 Jun 2004 - 15:33 RodasCyril Partie a ajouter dans le rapport final
special-k-grammar.ss manage 16.7 K 08 Jun 2004 - 14:02 RodasCyril analyseur
plannig.sxw manage 8.0 K 08 Jun 2004 - 15:35 RodasCyril Mon planning détaillé
specialk.tar.gz manage 118.8 K 09 Jun 2004 - 16:11 RodasCyril Snapshot

You are here: Minfo03 > TerRo1 > PagePersoCyrilRodas

to top

Copyright © 1999-2019 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding WIKIDeptinfo? Send feedback