ter logo - rapportleclere/enseignements/ter/2007/rapport/18.pdf- mozilla public license 1.1 - new...

65
TER Logo M1 Informatique Université Montpellier II ALLIER Simon – GROLLEMUND Naïtan – LALLUQUE Renaud - DELFOUR Kevin 2006 - 2007

Upload: others

Post on 15-Sep-2020

2 views

Category:

Documents


0 download

TRANSCRIPT

Page 1: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Logo M1 Informatique Université Montpellier II ALLIER Simon – GROLLEMUND Naïtan – LALLUQUE Renaud - DELFOUR Kevin 2006 - 2007

Page 2: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion
Page 3: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

Ministère de l' Éducation Nationale

Université Montpellier II

Rapport de TER

Juin 2007

TER LOGO M1 Informatique

Encadré par Monsieur Michel Meynard

ALLIER Simon

GROLLEMUND Naïtan

LALLUQUE Renaud

DELFOUR Kevin

Page 4: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

REMERCIEMENTS

Ce rapport présente notre logiciel d’Interpréteur Logo. Nous tenons à remercier notre responsable

de projet Monsieur Michel Meynard pour son aide, ses directives ainsi que ses cours d’analyse syntaxique.

Merci aussi aux autres professeurs qui nous ont permis grâce à leurs cours de réaliser ce TER, à Mme

Mountaz pour l’interface homme machine et Mr Ducournau pour les cours d’évaluation de code.

Enfin nous remercions l'Université Montpellier 2 de nous proposer de présenter un projet de TER, ce

qui nous permet de nous spécialiser dans un domaine et de l'explorer en détail.

Page 5: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

SOMMAIRE

1. Etude préliminaire.............................................................................................................................................. 7

1.1 Logo en bref … ............................................................................................................................................ 7

2. Description du sujet ........................................................................................................................................... 8

2.1 Sujet : Interprète Logo ................................................................................................................................ 8

2.2 Description .................................................................................................................................................... 8

3. Organisation ....................................................................................................................................................... 9

3.1 Répartition des tâches ............................................................................................................................... 9

3.2 Calendrier prévisionnel............................................................................................................................. 10

4. Support logistiques et web............................................................................................................................. 11

4.1 Services web............................................................................................................................................... 11

4.2 IDE de developpement............................................................................................................................ 12

4.3 Logiciel de partage .................................................................................................................................. 13

5. Etude détaillée................................................................................................................................................. 14

5.1 Structure du projet..................................................................................................................................... 14

5.1.1 Le parseur ........................................................................................................................................... 14

5.1.2 Evaluation ............................................................................................................................................ 17

5.1.3 L’Interface ........................................................................................................................................... 18

5.1.4 Les bibliothèques................................................................................................................................ 29

5 .2 Diagrammes de classes .......................................................................................................................... 34

6. Guide d’utilisation............................................................................................................................................ 35

6.1 Edition du code ......................................................................................................................................... 36

6.2 Interprétation du code............................................................................................................................. 40

7. La programmation en LOGO....................................................................................................................... 45

7.1 Manipulation de la tortue........................................................................................................................ 45

7.2 Procédures et fonctions .......................................................................................................................... 48

7.3 Itération ....................................................................................................................................................... 48

7.4 Conditions ................................................................................................................................................... 49

Page 6: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

7.5 Calculs ......................................................................................................................................................... 50

7.6 Variables...................................................................................................................................................... 52

7.7 Liste............................................................................................................................................................... 53

7.8 Les tests........................................................................................................................................................ 54

7.9 Fonctions diverses...................................................................................................................................... 55

8. Contrôle de l’application............................................................................................................................... 56

8.1 Les contrôles graphiques ......................................................................................................................... 56

8.2 Les procédures........................................................................................................................................... 56

8.3 Les prédicats............................................................................................................................................... 56

8.4 Les variables ............................................................................................................................................... 57

8.5 Les fonctions controles ............................................................................................................................. 57

8.6 L’arithmétique ............................................................................................................................................ 57

8.7 Les listes........................................................................................................................................................ 58

8.8 Les raccourcis............................................................................................................................................. 58

9. Jeux de tests et resultats................................................................................................................................. 59

Conclusion et perspectives................................................................................................................................ 64

References ............................................................................................................................................................ 65

Page 7: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

7

1. ETUDE PRELIMINAIRE

1.1 LOGO EN BREF …

1.1.1 QU’EST CE QUE LE LOGO ?

Fondamentalement le Logo est un langage de programmation. Plus important, le

Logo est un langage conçu pour favoriser l'apprentissage, selon les idées

développées par le psychologue suisse Piaget Jean, en particulier comment une

personne construit sa connaissance au fil d'interactions continuelles avec les objets et

phénomènes environnants.

Contrairement à une idée reçue, le Logo est un langage de programmation complet;

il a pour vocation principale l'enseignement. Il est utilisé dans l'enseignement primaire,

secondaire et supérieur, un peu partout dans le monde.

Le nom Logo vient du mot grec Logos qui veut dire mot. Ce nom a été choisi parce

que, lors de sa conception, un des objectifs était de pouvoir manipuler les mots et les

phrases d'une langue.

1.1.2 LE LOGO FAVORISE L'APPRENTISSAGE

Depuis sa naissance fin des années soixante, le Logo a évolué pour tirer profit de

l'évolution du matériel, en particulier celle de l'ordinateur personnel. Cependant la

philosophie Logo et les bases du langage restent les mêmes; le Logo n'est pas lié à

une mode ou à une tendance momentanée. La valeur intemporelle du Logo réside

dans le fait qu'il favorise le développement de la réflexion formelle et la résolution de

problèmes, qu'il encourage les étudiants à explorer, à apprendre et à réfléchir.

La pratique du Logo constitue une sensibilisation générique aux différents concepts

informatiques qui permettra aux enfants d'être des utilisateurs éveillés des outils

informatiques d'aujourd'hui et de demain.

1.1.3 COMPARAISON AVEC D’AUTRES LANGAGES

Le Logo est un dialecte du Lisp, à l'origine un langage dédié à la recherche. Comme

ses grands frères du monde professionnel (Common Lisp et Scheme), c'est un

langage dont le pouvoir d'expression est élevé, bien plus que d'autres mieux connus,

comme le C, le Pascal et le Java. Cela veut dire que, en règle générale, il est plus

facile et plus rapide de traduire ses idées en Logo que dans un langage comme le C.

Pour ces mêmes raisons et d'autres, le Lisp et le Scheme constituent deux des rares

bonnes alternatives au Logo, du moins dans l'enseignement secondaire.

La syntaxe du Logo, c'est-à-dire les règles à appliquer pour écrire des instructions

valides, est simple et uniforme. De fait en Logo, il n'y a qu'une seule règle syntaxique

(en termes techniques : la règle de l'application d'une procédure).

Le Logo est un langage interactif : l'utilisateur dispose d'un feed-back immédiat, s'il le

souhaite.

Page 8: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

8

2. DESCRIPTION DU SUJET

2.1 SUJET : INTERPRETE LOGO

- Encadrant : Meynard Michel

- Résumé : Programmer un interprète LOGO

- Parcours concernés : TOIL, IDI, CODA

- Remarques (UE conseillées, langage…) : Analyse syntaxique (UMIN123),

Génération de code (UMIN122)

2.2 DESCRIPTION

L'objet de notre TER est de créer un interpréteur LOGO, c'est à dire que notre

application doit être capable d'analyser du code LOGO, dire si ce code contient des

erreurs et où, puis ensuite l'interpréter et afficher le résultat.

Pour la réalisation de ce projet, nous avons décidé d'utiliser le langage de

programmation Java. L'interface sera, tout d'abord, sous forme d'applet Java afin de

pouvoir ensuite l'implémenter sur une page Web.

Par la suite nous implémenterons notre projet sous forme d'application JAVA, ce qui

permettra de pouvoir la télécharger, et de pouvoir la lancer sans aucune connexion

internet (en local).

Etant donné que LOGO est un langage de programmation destiné à l'apprentissage

et à l’enseignement, nous allons simplifier l'interface graphique pour les plus jeunes et

permettre au plus expérimentés de pouvoir rajouter certaines options dans l'affichage

(par exemple, l'affichage d'un bash pour visualiser les traitements effectués par

l'interprète LOGO).

Page 9: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

9

3. ORGANISATION

3.1 REPARTITION DES TACHES

Description des différentes tâches :

- Recherche : Consiste en une recherche approfondie sur le langage LOGO.

Quelle est sa grammaire ? Quels sont ses points forts et ses points faibles ?

- Analyse : Analyse et mise au point du découpage du projet en plusieurs parties.

- Conception du parseur /évaluateur : Conception de la classe java qui permettra

de parseur le fichier logo et dire si des erreurs sont présentes ou pas.

- Conception de l’affichage : Conception de l’affichage du résultat du fichier

parsé et évalué.

- Conception de l’éditeur : Conception d’un éditeur de texte permettant d’écrire

le programme en logo.

- Réalisation de l’applet : Réalisation de l’applet global.

- Ecriture des bibliothèques : Traduction des fonctions Logo en Java.

- Rapport : Ecriture du rapport du TER

- Publication Web : Publication sur le WEB de l’applet LOGO, ainsi que du rapport.

- Gestion Svn : Gestion de l’espace de partage des sources du TER

Naitan Renaud Simon Kevin

Recherche

Analyse

Conception

+ Parseur

+ Evaluateur

+ Affichage

+ Editeur

+ Réalisation Applet

+ Bibliothèques

Rapport

Publication Web

Gestion Svn

Page 10: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

10

3.2 CALENDRIER PREVISIONNEL

15/01- 30/01

01/02-15/02

16/02-28/02

01/03-15/03

16/03- 30/03

01/04- 15/04

16/04- 30/04

01/05- 8/05

Recherche

Analyse

Conception

+ Parseur

+ Evaluateur

+ Affichage

+ Editeur

+ Réalisation Applet

+ Bibliothèques

Rapport

Publication Web

Gestion Svn

Tests

Page 11: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

11

4. SUPPORT LOGISTIQUES ET WEB

4.1 SERVICES WEB

Dans le cadre du développement d’une application par plusieurs personnes, il est

souvent nécessaire de se maintenir à jour sur les dernières modifications apportées à

l’application et mettre à jour les différentes parties de celle-ci. Pour résoudre ce

problème de communication et de partage de code source, nous avons utilisé deux

services web disponibles gratuitement : Google Code Hosting et Google Groupe de

Discussion.

4.1.1 GOOGLE CODE HOSTING

Google Code est un site internet destiné aux développeurs intéressés par le

développement relatif à Google. L'entreprise y diffuse des codes sous licence libre

ainsi que la liste des API utilisables.

Project Hosting est un projet qui vise à apporter des services gratuits aux développeurs

open-source de la même façon que le fait déjà Source Forge. Il est intégré au site

Google Code.

Les projets qui peuvent y être soumis doivent être sous l'une de ses licences open-

source:

- Apache License 2.0

- Artistic License

- GNU General Public License 2.0

- GNU Lesser Public License

- MIT License

- Mozilla Public License 1.1

- New BSD License

4.1.2 GOOGLE GROUPE DE DISCUSSION

L'objectif de notre groupe de discussion Google Groupes est d’aider à garder le

contact avec les autres développeurs, à accéder aux informations concernant

des modifications et à communiquer efficacement par e-mail et via le Web.

Page 12: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

12

Les différentes fonctionnalités sont :

- Création de pages : créez des pages Web partagées en collaboration avec

d'autres utilisateurs. Ces pages sont hébergées au sein même du groupe.

- Personnalisation : sélectionnez des images, des couleurs et des styles pour

donner une touche personnelle à votre groupe.

- Partage de fichiers : transférez votre travail pour le partager avec d'autres

membres de votre groupe.

- Profils des membres : apprenez à connaître les autres membres de votre

groupe.

4.2 IDE DE DEVELOPPEMENT

Pour le choix de l’IDE de développement, étant donné que notre application est écris

en JAVA, nous avons donc choisis le logiciel Eclipse.

Eclipse IDE est un environnement de développement intégré (le terme Eclipse

désigne également le projet correspondant, lancé par IBM) extensible, universel et

polyvalent, permettant potentiellement de créer des projets de développement

mettant en œuvre n'importe quel langage de programmation. Eclipse IDE est écrit en

Java (à l'aide de la bibliothèque graphique SWT, d'IBM), et ce langage, grâce à des

bibliothèques spécifiques, est également utilisé pour écrire des extensions.

La spécificité d'Eclipse IDE vient du fait de son architecture totalement développée

autour de la notion de plug-in (en conformité avec la norme OGSi) : toutes les

fonctionnalités de cet atelier logiciel sont développées en tant que plug-in.

De plus, afin de pouvoir lire du code Logo et l’interpréter en code java, nous avons

ajouté à notre IDE Eclipse le plugin Javacc.

Java Compiler Compiler (JavaCC) est le plus utilisé des générateurs de parseur pour

Java. Un générateur de parseur est un outil qui lit les spécifications d’une grammaire

Page 13: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

13

et qui la convertit en programme Java. En plus d’être un générateur de parseur,

JavaCC fournit d’autres possibilités relatives à la génération de parseur comme la

construction d’arbre, le débogage, etc...

JavaCC prend comme entrée un fichier MaGrammaire.jj qui contient entre autre les

descriptions des règles de la grammaire et produit un parseur descendant (dans le

fichier MaGrammaire.java). Une classe MaGrammaire est définie dans le fichier java.

Elle implémente l’interface MaGrammaireConstants, définie dans

MaGrammaireConstants.java et qui contient les définitions des mots clés de la

grammaire.

4.3 LOGICIEL DE PARTAGE

Afin de maintenir à jour chacune de nos versions, nous avons utilisés un logiciel client

SVN, TortoiseSVN.

TortoiseSVN offre une interface graphique permettant de réaliser la plupart des

tâches qu'offre SVN en ligne de commande.

L'explorateur de Windows s'enrichit des fonctionnalités suivantes:

- Superposition d'icônes aux répertoires et fichiers permettant de visualiser

instantanément l'état (à jour, modifié, en conflit...)

- Menu contextuel permettant de committer ou d'updater, à l'échelle d'un fichier,

d'une sélection de fichiers ou encore d'un répertoire

- Possibilité d'ajouter en mode détails de l'explorateur des colonnes de type

numéro de révision, état.

Page 14: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

14

5. ETUDE DETAILLEE

5.1 STRUCTURE DU PROJET

La structure du projet est composée de trois grandes parties :

- Le parseur Logo : cette partie permet de lire du code Logo, de l’interpréter selon

la grammaire de Logo, et de lancer les traitements java adéquats.

- L’interface : permet l’interaction entre l’utilisateur et le programme.

- Les bibliothèques : contient toutes les fonctions Logo reconnus par notre parseur

et les traitements à effectuer.

5.1.1 LE PARSEUR

Afin de concevoir un parseur Logo à partir de JavaCC, il est nécessaire de connaître

d’extraire une grammaire et une liste de token.

A. LES TOKENS POUR : "pour" DEUX_POINTS : ":" EGALE : "=" INEGALE : "!=" PLUSPETIT : "<" PLUSGRAND : ">" PARA_O : "(" PARA_F : ")" CROCH_O : "[" CROCH_F : "]" PLUS : "+" MOINS : "-" MULTIPLIER : "*" DIVISER : "/" TRUE : "\"vrai" | "\"true" FALSE : "\"faux" | "\"false" ID : ["a"-"z"]+ ( ["a"-"z"] | ["0"-"9"] | "_" | "?" | "!" )* MOT : "\"" ["\n", "\r", " ", "[", "]"]* INT : ["0"-"9"]+ ["0"-"9"]* FLOAT : ( ["0"-"9"]+ "." ["0"-"9"]* | ["0"-"9"]* "." ["0"-"9"]+ ) ( "e" ["-","+"]? ["0"-"9"]+ )? ELEM_LIST : ["\n", "\r", "\t", " ", "[", "]"]+ De plus, on notera que les tokens sont insensibles à la case.

Page 15: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

15

B. LA GRAMMAIRE

Run -> ( Fct | Pour )* Pour -> <POUR> <ID> <CROCH_O> List <CROCH_F> <CROCH_O> List <CROCH_F> Fct -> ( <ID> ( Fct )+ ) | Test Test -> Add Rtest Rtest -> <EGALE> Fct | <INEGALE> Fct | <PLUSPETIT> Fct | <PLUSGRAND> Fct | | έ Add -> Mult Radd Radd -> <PLUS> Fct | <MOINS> Fct | | έ Mult -> Primary Rmult Rmult -> <MULTIPLIER> Fct | <DIVISER> Fct | | έ Primary -> <ID> | <PARA_O> Fct <PARA_F> | <CROCH_O> List <CROCH_F> | <DEUX_POINT> <ID> | <MOT> | <INT> | <MOINS> <INT> | <FLOAT> | <MOINS> <FLOAT> | <TRUE> | <FALSE> List -> <CROCH_O> list <CROCH_F> | <ELEM_LIST>

C. LA STRUCTURE DU PARSEUR

Le parseur est divisé en 2 parties distinctes :

• la première, transforme le code logo reçu à partir de la grammaire et des

tokens : effectué par la classe Trans.

• la seconde évalue le code transformé : effectué par la classe Evaluation.

Page 16: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

16

La division du parseur en 2 parties a pour but d’accélérer l’évaluation du code logo.

En effet, Trans vérifie que la grammaire est respectée et type certaines parties du

code transformé pour accélérer leur évaluation par Evaluation.

TRANS

Trans est généré par javacc à partir du fichier Trans.jj. Ce dernier contient les tokens,

la grammaire ainsi que les actions associées aux règles de la grammaire.

Trans parse les tokens INT ,FLOAT, en int et double, MOT en string et enfin TRUE et

FALSE en boolean.

La règle de grammaire List renvoie une liste (liste composée de int, double, string ou

boolean).

De plus, Trans remplace les fonctions logo primitives par leur équivalence java.

CODE RENVOYE PAR TRANS

Trans renvois une liste d’instruction (la liste peut être vide si le code logo est vide).

Les instructions sont de 4 types :

• Constante : une liste commençant par un 0 suivi d’une constante (int, float,

string, boolean ou list).

Exemple : [0 , 45] // 45

• fonction primitive : une liste commençant par un 2 suivi de la méthode java à

invoquer, puis des arguments de la fonction (des instructions).

Exemple : [2, public static java.lang.Object

EntreeSortie.ecris(java.util.ArrayList,java.util.HashMap), [0, 45]] // ecris 45

• fonction définie avec « pour » : une liste commençant par un 3 suivi du nom

de la fonction (un string), puis des arguments de la fonction (des instructions).

Exemple : [3, foo, [0, 45]] // foo 45

• « pour » (définition de fonction) : une liste commençant par un 4 suivi du nom

de la fonction (un string), ensuite viennent la liste des arguments, la liste des

arguments optionnels et le corps de la fonction (une liste d’instruction).

Exemple : [[4, foo, [x], [y, 1], [[2, public static java.lang.Object

GestionEnv.chose(java.util.ArrayList,java.util.HashMap), [0, x]]], foo [x [y 1 ]] [:x

]]] // pour foo [x [y 1]] [:x]

Page 17: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

17

5.1.2 EVALUATION

Une fois le code logo transformé par Trans, il est envoyé à Evaluation qui l’interprète

de façon récursive.

Evaluation reçoit une liste d’instruction et les évalue une après l’autre dans

l’environnement lexical courant.

Les instructions étant de 4 types, l’évaluation des instructions se fait selon 4 cas :

• Les constantes (cas 0) : Evaluation renvoie la constante.

• Les fonctions primitives (cas 2) : Evaluation évalue les arguments reçus puis

invoque la fonction avec les arguments.

• Les fonctions définies avec « pour » (cas 3) : Evaluation évalue les arguments

reçus, crée un nouvel environnement lexical et enfin crée une nouvelle

instance de Evaluation avec l’environnement créé ainsi que la liste

d’instructions correspondent à la fonction.

• Définition de fonction avec « pour » (cas 4) : on stocke la liste des arguments,

la liste des arguments optionnelles et la liste des instructions.

LA GESTION DES ERREURS

Etant donne que le code logo a évalué peut contenir des erreurs, le couple Trans

Evaluation peut les détecter et les signaler avant d’arrêter l’évaluation du code.

Erreurs détectées pendant la transformation du code :

• token inconnu : un token inconnu se trouve dans le code.

Exemple : |||||||||||| ce token n’existe pas il déclenche donc une

erreur.

• Erreur de grammaire : une erreur dans la grammaire du code qui est du à une

suite incompatible de token.

Exemple : [1 [1 2] "az // une liste non fermé

Erreur générée : erreur de grammaire à la ligne 1 après le token : "az

• Fonction inconnue : une fonction inconnue se trouve dans le code

Exemple : foo 4 5 // la fonction foo est inconnue du parser

Erreur générée : erreur à la ligne 1 : la fonction foo est inconnue

Erreur détectée pendant l’évaluation du code transformé :

• type incorrect : une fonction primitive a reçu un argument de type incorrect

Exemple : somme 1 "az // la fonction somme avec les arguments (1, "az )

Erreur génère : erreur dans la fonction somme

Type incorrect

Attendus : (nombre)*

Reçus : entier mot

Page 18: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

18

• nombre d’arguments incorrects : une fonction a reçu trop ou pas assez

arguments Exemple : (item [4 5] 8 7) // la fonction item prend de argument, ici

elle en a 3.

Erreur générée : erreur dans la fonction item nombre d'arguments incorrects

Attendus : 2

Reçus : 3

• variable inconnue : on fait appelle à une variable qui ne se trouve ni dans

l’environnement local ni dans l’environnent global

Exemple : ecris :x // la variable x est inconnue

Erreur générée : la variable x n’est pas dans l’environnement

Toute les erreurs qui peuvent se produire et qui ne sont pas répertoriées sont signalées

par le message : erreur dans la fonction <non de la fonction>

Par exemple l’instruction item [] 4 causera l’erreur : « erreur dans la fonction item »

5.1.3 L’INTERFACE

L’interface est toute la partie visuelle du programme, elle est donc très importante.

Elle va faire le lien entre le code, son évaluation, et l’affichage du résultat.

A. SPECIFICATIONS

Il nous a été demandé, afin d’en facilité l’accès, que notre logiciel soit accessible

directement sur Internet, nous avons donc décidé de le créer sous forme d’applet

Java et donc accessible grâce à n’importe quel navigateur web.

De plus comme le Logo est un langage simple il faut une interface claire et intuitive

pour rendre le logiciel accessible à tout le monde.

B. STRUCTURE

Notre interface va séparer le logiciel en deux grandes parties et ainsi faire la liaison

entre le code et son résultat.

D’un coté on aura l’éditeur, qui fonctionnera comme un simple éditeur de texte, il

aura quelques particularités tout de même comme la gestion de plusieurs textes en

même temps grâce à l’utilisation d’onglets et des boutons de contrôles : Démarrer qui

lancera l’exécution du code, Arrêter qui le stoppera, et Effacer pour vider le contenu

de l’éditeur courant.

Et de l’autre la fenêtre d’exécution qui fera afficher le résultat graphiquement,

comprenant la tortue et ses déplacements.

Une troisième fenêtre fera la coordination du logiciel : la console. Elle contiendra les

résultats textuels, les erreurs rencontrées et les messages systèmes. Cette console aura

Page 19: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

19

aussi un champ permettant l’exécution de commande simple, pratique pour faire des

tests sur certaine fonction ou simplement de programmer pas à pas.

Tout l’intérêt de notre interface est dans ces trois fenêtres, grâce au composant

JDesktopPane, elles sont toutes visibles en même temps, resizable, ou minimisable.

L’utilisateur a donc un contrôle complet sur son interface et peut la remanier comme

il le souhaite.

Pour faciliter le fonctionnement du logiciel une barre d’outils ainsi qu’une barre de

menu donnent accès aux fonctions systèmes et à certaines fonctions du Logo

fréquemment utilisé.

C. L’EDITEUR

Dans la JInternalFrame de l’éditeur on va ajouter un objet de la classe Editeur, on va

ainsi créer le panneau qui contiendra le texte et les boutons.

Cette classe est dans deux parties, le ou les textes et les boutons :

- Dans un souci d’efficacité, on a décidé que l’on pourrait avoir plusieurs

champs de texte en même temps, pour cela on va utiliser un système d’onglets

formables, ainsi lorsqu’on ouvrira un fichier ou ajoutera un éditeur vierge il se crée

dans un nouvel onglet.

Les onglets fermables se font grâce a la classe ClosableTabbedPane qui va modifier

les onglets en ajoutant un MouseListener et en modifiant l’affichage de l’onglet (la

croix). Ensuite on créer un simple JTabbedPane auquel on modifiera l’UI en la

remplaçant par ClosableTabbedPane.

La difficulté de l’ajout des onglets a surtout été notre volonté de faire disparaître les

onglets lorsqu’il n’y avait plus qu’un seul éditeur d’ouvert. Il a fallu prendre en

compte a chaque fois le cas ou il n’y avait qu’un seul éditeur d’ouvert et celui ou il y

en avait plusieurs et donc afficher les onglets.

Ensuite dans chaque onglet on ajoute un panneau de la classe JTexteLogo qui

contiendra le JScrollpane et le JTextArea. On a créer cette classe pour que chaque

onglet possède un nouvel objet et faciliter l’accès au texte grâce à de simple

accesseurs.

Lorsqu’un éditeur est modifié, son titre aussi le caractère « * » est concaténé a la fin

du nom du fichier.

On ajoute au JTexteLogo un JPopupMenu sur le JTextArea qui

Page 20: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

20

va permettre les action classiques sur un éditeur : le copy/paste et la recherche.

- On crée ensuite une Box qui contiendra tous les boutons (Démarrer, Annuler,

Effacer). On ajoute à chaque bouton un ActionListener et l’action correspondante.

Démarrer : on récupère le texte du JTexteLogo et on l’envoie a l’évaluation, le

JTexteLogo devient inéditable afin d’éviter la modification du code pendant son

exécution.

Annuler : il va stopper l’exécution du code et repermettre l’édition du code.

Effacer : il va supprimer le contenu de l’éditeur courant après un message de

confirmation.

D. LA CONSOLE

La console va permettre d’afficher les résultats textuels, les messages systèmes et les

erreurs.

Les trois fonctions principales sont out() qui va afficher les résultats en vert, sys() qui va

afficher les messages systèmes en bleu et err() pour les messages d’erreur en rouge.

La gestion des couleurs se fait grâce a des balises HTML, pour écrire en vert on

insérera la balise <span style=color:#00FF00;>texte</span><br> dans le JEditorPane

qui évaluera le code HTML et affichera le résultat voulu.

On peut aussi grâce à un champ texte et un bouton exécuté du code à partir de la

console. Ce code sera envoyer dans l’évaluateur de la même manière que pour

l’éditeur.

E. L’EXECUTION

La fenêtre d'exécution permet d'afficher les résultats visuels. La classe Execution est un

composant JPanel (panneau)qui contient un composant JScrollPane (scrolling).

Afin de rendre ce panneau visuellement « scrollable » nous avons dû reféfinir la

méthode getPreferredSize() en attribuant au panneau une taille fixe.

Le panneau d'exécution contient au départ deux éléments graphique, à savoir la

tortue et le quadrillage.

Page 21: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

21

Le quadrillage est dessiné grâce à la fonction graphique drawLine(int px,int py,int

p2x,int p2y) qui permet de tracer des lignes en fonction de la position de deux

points, une ligne joint les deux points. L'implémentation et l'affichage de ce dernier

se situe dans la méthode paintComponent().

F. LE MENU

Notre logiciel est un applet donc accessible à partir d’un navigateur Web, le

navigateur possède déjà un menu et une barre d’outils néanmoins nous avons voulu

que notre logiciel ait sa propre interface avec sa barre de menu et sa barre d’outils.

Le menu va implémenter les actions telles que l’ouverture d’un fichier,

l’enregistrement d’un éditeur ou l’impression. Les fonctions d’éditions, undo/redo, le

copier coller et la recherche comme vu précédemment. Enfin on aura des menus

pour l’affichage et l’aide.

MENU FICHIER

Le menu Nouveau va créer un nouvel éditeur dans un nouvel onglet. On utilise la

fonction nouveau() de la classe Editeur qui aussi utilisé lors de la création de la

fenêtre.

Les menus « Ouvrir », « Enregistrer » et « Enregistrer sous » vont faire appel au

composant JFileChooser, une fenêtre qui permet de parcourir les fichiers du disque

dur. Associé à la classe FiltreFichier, il suffit sélectionner le type de fichier voulu pour

filtrer l’affichage.

On notera que pour l’enregistrement d’un fichier normalement le composant

JFileChooser concatène automatiquement le type du fichier, malheureusement cela

ne fonctionne pas il s’agit d’un bug connu de Java Sun et il faut donc utiliser une

autre méthode : manipuler les chaînes de caractères du fichier et de la description,

les découper et si le type n’a pas déjà été ajouté, les concaténer.

L’ouverture d’un nouveau fichier se fait grâce à la fonction lecture() de l’éditeur qui

va changer le fichier dans un buffer et l’insérer dans le JTextArea de l’éditeur.

De même l’enregistrement va appeler la fonction ecrire() et écrire le code de

l’éditeur dans un buffer et l’insérer dans le fichier.

Page 22: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

22

Les fichiers seront de type « *.logo », il s’agit d’une extension de fichier créée pour le

logiciel mais les fichiers ne sont en réalité que de simple fichier texte. Les fichiers .logo

peuvent être ouverts grâce à n’importe quel éditeur de texte.

Le menu fichier dispose d'une fonctionnalité intéressante qui est l'impression.

Pour entamer une procédure d'impression, il suffit de cliquer sur l'imprimante.

Une fois ce clic effectué, une fenêtre apparaît demandant à l'utilisateur ce qu'il désire

imprimer (choix multiple).

Après avoir choisi les ce que l'on souhaite imprimer, il faut cliquer sur le bouton

imprimer afin de connecter l'application avec l'imprimante. La fenêtre ci-dessous

nous demande combien de page nous souhaitons imprimer, avec encore diverses

options d'impression.

La fenêtre de choix d'impression est un composant JDialog qui a la particularité de

disposer d'une unique croix de fermeture. Deux boutons radio sont implémentés dans

cette fenêtre et chacun d'eux appel la procédure impression de la classe Logo. Cette

procédure contient un élément essentiel PrinterJob qui va appeler la fonction print()

de Java. Cette dernière va faire appel au composant que l'on souhaite imprimer :

notre JTextArea qui figure dans l'éditeur ou alors Jpanel de l'exécution.

Page 23: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

23

MENU EDITION

Le undo/redo est essentiel lors de la saisie du code dans l'éditeur. Suite à une

mauvaise manipulation ou réflexion, l'utilisateur peut être amené à effacer le

contenu de l'éditeur ou bien à modifier son contenu. Grâce au bouton « Annuler »

(undo) nous pouvons revenir en arrière pour retrouver notre code avec son aspect

précédent. Il est aussi possible revenir sur notre décision donc de rétablir les

modifications en activant le bouton « Refaire » (redo).

Ces deux boutons font appel à la commande Java nommée « undoManager » et à

la procédure updateButtons(). La commande « undoManager » appelle les

méthodes undo() ou redo() de Java et la procédure updateButtons()permet

d'activer les fonctionnalités undo ou redo grâce aux méthodes canUndo() et

canRedo() de Java.

Le copier/couper/coller est très utile pour n'importe quel éditeur de texte. Il suffit de

sélectionner les parties du texte que l'on souhaite copier et de les coller ou l'on veut. Il

est aussi possible de supprimer une partie du texte en utilisant l'option « couper » et de

pouvoir le coller à l'endroit souhaité.

Afin de copier ou couper une partie du texte souhaité nous avons utilisé la méthode

getSelectedText() de la classe JtextArea qui permet de placer dans un String la zone

du texte sélectionné. Après avoir stocké la sélection, le texte sélectionné sera

remplacé par un String null pour l'option couper et demeurera inchangé pour

l'option copier. Le bouton coller va appelé la méthode insert(String texte, int position)

qui va placer le texte sélectionné précédemment à l'emplacement du pointeur. La

position du pointeur est définie par la méthode getCaretPosition() de la classe

JtextArea.

Notre éditeur dispose d'un outil de recherche performant qui permet de rechercher

dans notre éditeur n'importe quelle chaîne de caractères.

Lorsque l'utilisateur choisit l'option de recherche, une fenêtre demande une saisie de

la chaîne de caractère à rechercher.

Page 24: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

24

La méthode rechercherMot à été implementée dans la classe Editeur. Cette

méthode prend en paramètre chaîne de caractères que l'on souhaite rechercher. Un

algorithme de recherche consiste à regarder si le premier caractère du mot à

recherché est égal au premier caractère de chaque mot de l'éditeur. Si c'est le cas,

on va continuer en regardant le second caractère (si il y en a un))et ainsi de suite

jusqu'à trouver ou pas la chaîne complète. Nous allons stocker la position de chaque

occurrence dans un vector<Integer> afin de procéder à la selection de ces derniers

grâce à la méthode select(int position début mot, int position fin mot). La première

occurrence trouvée sera sélectionnée automatiquement. Pour savoit si d'autre

occurrence sont visibles dans l'éditeur, une pression sur la touche F1 parcourt toutes

les autres occurrences trouvées.

MENU AFFICHAGE

En cochant ou décochant les options du menu on va permettre de cacher ou

montrer les fenêtres sur le JDesktopPane.

L’affichage de la télécommande va se faire dans une fenêtre hors de l’applet qui

permettra d’écrire dans l’éditeur comme on le verra plus bas.

La sélection du thème va changer le look&feel de l’application. Nous avons utilisé le

look&feel Nimrod.

Le projet Nimrod est un logiciel Open Source de création de Look&Feel créer par Nilo

J. Gonzàlez distribué sur son site : http://personales.ya.com/nimrod/index-

en.html. Nimrod permet de créer ses propres look&feel et les enregistrer dans un

fichier theme pour les charger ensuite dans notre logiciel.

Page 25: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

25

Les fichiers .theme sont dans le répertoire « theme ». Pour utiliser un thème en tant que

look&feel, il a fallu modifier le code source du logiciel Nimrod en permettant

l’ouverture de plusieurs fichiers thème. Ensuite on définit l’objet créer comme

look&feel de l’application grâce a la fonction Java UIManager.setLookAndFeel().

MENU AIDE

L’option « Qu’est que le Logo » va ouvrir dans un nouveau navigateur un document

PDF d’aide et d’information sur le Logo.

L’option Version va ouvrir une fenêtre popup présentant les membres du projet et la

version du logiciel.

G. LA BARRE D’OUTILS

On va ajouter une barre d’outils de la classe ToolBarLogo héritant de JToolBar. Elle

sera divisée en deux parties, une barre d’outils pour l’éditeur et une pour la fenetre

d’execution.

Page 26: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

26

BARRE D’OUTILS DE L’EDITEUR

On va reprendre ici les fonction des la barre de menu (undo/redo, impression,

affichage de la télécommande) fréquemment utilisées pour qu’elles soient

rapidement accessibles.

BARRE D’OUTILS D’EXECUTION

- ENREGISTRER LE RESULTAT

Le premier bouton représenté par la disquette permet d'enregistrer le résultat obtenu

sous forme d'une image au format PNG. Lorsque l'on presse ce bouton, la fenêtre ci-

dessous apparaît permettant à l'utilisateur de sauvegarder cette image en choisissant

son nom ainsi que son emplacement de sauvegarde. Cette dernière sera aura une

définition égale à la dimension actuelle du panneau de la fenêtre d'exécution.

Il suffit de capturer le « graphic » du panneau et de l’enregistrer dans un buffer

d’image.

Page 27: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

27

- CACHER/AFFICHER LA TORTUE

Le bouton représenté par une tortue sur la boîte à outil permet d'afficher ou pas

l'animal au cours de son déplacement. L'animal peut être affiché ou masqué à tout

moment grâce a un simple booléen passé à true ou false.

- CACHER/AFFICHER LE QUADRILLAGE

Le bouton représenté par un quadrillage permet de masquer ou d'afficher le

quadrillage. Le quadrillage est en fait une aide pour l'utilisateur. Il peut regarder si le

déplacement effectué est correct sachant qu'un carreau fait 10x10 pixels.

Lorsqu’on repeint le panneau on regarde si le quadrillage doit être afficher ou pas

(utilisation d’un booléen) et on change l’affichage en conséquence.

- ZOOMER

Les deux boutons -/+ qui permettent de grossir ou de rétrécir le résultat qui figure dans

la fenêtre d'exécution. Le zoom permet de visualiser des détails précis et peut s'utiliser

à tout moment même lorsque la tortue est en mouvement.

On utilise pour cela la fonction scale() de Graphics2d accompagné de translate().

- MODIFIER LE FOND

La couleur de fond de la fenetre d'exécution n'est pas unique. En effet, l'utilisateur

peut choisir la couleur de fond qui lui plaît. Il est conseillé d'appliquer un fond blanc si

le résultat à imprimer a une grande définition afin de limiter la consommation d'encre.

Cette fonction est implémenté grâce a la fonction changefond() qui change

l’attribut « backgroundcolor » du panneau.

- MODIFIER LA VITESSE

L'utilisateur peut, lors d'un déplacement de l'animal, modifier la vitesse de

déplacement de ce dernier. La vitesse est variable, il suffit de placer le curseur sur la

vitesse souhaitée. La vitesse augmente lorsque le curseur se déplace vers la droite et

diminue lorsque le curseur est déplacé vers la gauche.

- EFFACER LE PANNEAU

Après que l'animal est effectué un déplacement, il trace derrière lui son chemin. Si

l'utilisateur souhaite effacer ce chemin afin d'en créer un autre, il peut l'effacer pour

rendre le fond vierge. Cela permet d'organiser au mieux son panneau.

On utilise pour cela la fonction Clearscreen() de la classe Execution qui réinitialise

toutes les variables et repeint le panneau.

Page 28: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

28

H. LA TELECOMMANDE

La télécommande est un outil très utile et original qui permet de faire bouger l'animal

en toute simplicité. En effet, il suffit d'appuyer sur une direction (flèches) puis de rentrer

la distance souhaitée (avancer, reculer) ou l'angle voulu (gauche, droite). La saisie

d'un bouton de la télécommande va entrer le code Logo correspondant dans

l'éditeur directement. En cas d'erreur de saisie, cette dernière est équipée d'un

bouton de correction « C » et d'un bouton qui permet d'effacer l'éditeur en entier

« E ». Après avoir entré le code voulu, une pression sur le bouton « Démarrer » va

activer les mouvements de l'animal. Ne pas oublier d'appuyer sur le bouton

« Arrêter » afin de réaliser une nouvelle saisie.

I. LA LIASON ENTRE LE CODE ET LE RESULTAT

Lorsque l’on clic sur le bouton démarrer de l’éditeur on va créer un nouveau objet de

la classe Parseur en lui passant en paramètre le code écrit. Le parseur va analyser le

code à la recherche d’erreur syntaxique, l’évaluer et exécuter les fonctions de la

bibliothèque. Ces fonctions vont traiter les information puis manipuler les fenêtres

Console (en affichant du texte) ou Exécution (en déplaçant la tortue ou modifiant

l’environnement graphique).

On garde néanmoins un contrôle sur ces actions, un bouton stop sur la barre d’outil

ou simplement le bouton Arrêter de l’éditeur permette d’arrêter l’évaluation du code,

ainsi si la tortue est en train de se déplacer elle s’arrêtera automatiquement.

Page 29: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

29

J. L’ANIMATION DE LA TORTUE

On va utiliser un objet Thread pour déplacer la tortue. Il s’agit de processus léger qui

va tourner en parallèle et s’occuper des mouvements.

Il faut qu’il n’y ait qu’un seul Thread qui tourne en même temps sinon plusieurs actions

vont se faire en même temps, on va donc gérer une liste d’instruction grâce à un

Vector. On enverra dans la liste un message comprenant un code de type String qui

indiquera le type de déplacement et un objet pour la valeur.

Lorsque l’on appellel la fonction Avance ou Recule on va lancer le Thread avec la

méthode start() s’il n’est pas déjà en train de tourner.

Le Thread va parcourir la liste et exécuter les instructions dans les messages. Il ne

s’arrêtera que lorsque la liste sera vide. Les fonctions de déplacement ajouteront un

message dans la liste lorsqu’elles seront appelées. Ainsi chaque instruction sera

exécutée à la suite sans se superposer,

On ajoute des fonctions stop(), pause() et finpause() avant de contrôler les

déplacements implémentant les fonction des Thread (stop(), wait(), notify()).

5.1.4 LES BIBLIOTHEQUES

Dans le cadre de notre projet, de nombreuses bibliothèques ont du être implémenté.

Les différentes bibliothèques implémentées sont les suivantes :

• Les fonctions mathématiques

• Les fonctions de contrôle

• Les fonctions de teste

• Les fonctions de gestion d’environnement

• Les fonctions portant sur les listes

• Les fonctions d’entrées sorties

• Les fonctions d’affichage graphique

• Les fonctions portant sur le temps

• Les fonctions portant sur le texte

• Les autres fonctions non classées se trouvent dans l’autre librairie

A. STRUCTURE

Chaque librairie est implémentée sous forme de HashMap, ceci afin de pouvoir

faciliter l’ajout de nouvelles fonctions.

Page 30: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

30

Exemple :

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.HashMap;

public class Texte {

public HashMap<String,Integer> argFctPredefinie = new

HashMap<String,Integer>();

public HashMap<String,Method> methodFctPredefinie = new

HashMap<String,Method>();

public Texte() {

//Dans cette partie il faut definir la syntaxe de la commande avec le

nombre d’argument

argFctPredefinie.put("majuscule", 1);

argFctPredefinie.put("minuscule", 1);

Class c = Texte.class;

Method[] tab = c.getMethods();

//Dans cette partie on definit la fonction a effecteur pour la syntaxe de

la commande

Method m;

for (int i=0;i<tab.length;i++) {

m = tab[i];

if(m.getName().equals("majuscule"))

methodFctPredefinie.put("majuscule", m);

if(m.getName().equals("minuscule"))

methodFctPredefinie.put("minuscule", m);

}

}

//Pour finir on écris le traitement pour chaque fonction implémenté

public static Object majuscule(ArrayList<Object> v, HashMap<String,

Object> penv) {

return ((String) v.get(0)).toUpperCase();

}

public static Object minuscule(ArrayList<Object> v, HashMap<String,

Object> penv) {

return ((String) v.get(0)).toLowerCase();

}

}

Chaque librairie suit ce schéma bien précis.

Page 31: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

31

B. AJOUTER UNE BIBLIOTHEQUE

Pour des mises à jour ultérieures, il est possible de rajouter de nouvelles bibliothèques

au projet Logo, pour cela il faut effectuer deux étapes :

• La première étape consiste à écrire la librairie

• La seconde étape consiste à l’ajouter à la liste des librairies existantes

Le schéma d’une bibliothèque est la suivante :

//1. Liste des imports nécessaires

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.HashMap;

//2. Le nom de la nouvelle librairie

public class NewBibliotheque {

//3. On déclare de HashMap, une pour les arguments, une autre pour les

fonctions

public HashMap<String,Integer> argFctPredefinie = new

HashMap<String,Integer>();

public HashMap<String,Method> methodFctPredefinie = new

HashMap<String,Method>();

public NewBibliotheque () {

//4. Pour chaque commande que l’on veut appeler par la suite dans logo

// il faut ajouter son nom et le nombre d’argument qu’elle prend à la liste des

// fonctions prédéfinies

argFctPredefinie.put("nom commande",nombre_argument) ;

argFctPredefinie.put("nom commande",nombre_argument) ;

……..

argFctPredefinie.put("nom commande",nombre_argument) ;

Class c = Texte.class;

Method[] tab = c.getMethods();

Method m;

//5. On déclare qu’elle fonction lancé pour chaque commande appelé

for (int i=0;i<tab.length;i++) {

m = tab[i];

if(m.getName().equals("nom_Commande")) {

methodFctPredefinie.put("abbreviation 1", m);

methodFctPredefinie.put("abbreviation 2", m);

}

//6. On écris le traitement a faire pour chaque commande

Page 32: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

32

public static Object nom_Commande (ArrayList<Object> v,

HashMap<String, Object> penv) {

TRAITEMENT

}

}

Une fois cette étape franchis, il faut ajouter notre bibliothèque à la liste des

bibliothèques existantes de la manière suivantes :

• Ouvrir le fichier Bibliotheque.java

• Ensuite ajouter les lignes suivantes (dans notre exemple en rouge)

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.HashMap;

public class Bibliotheque {

public static HashMap<String,Integer> argFctPredefinie = new

HashMap<String,Integer>();

public static HashMap<String,Method> methodFctPredefinie = new

HashMap<String,Method>();

public static HashMap<String, ArrayList> argFctDefinie = new HashMap<String,

ArrayList>();

public static HashMap<String, ArrayList> argOpFctDefinie = new

HashMap<String, ArrayList>();

public static HashMap<String, ArrayList> corpsFctDefinie = new

HashMap<String, ArrayList>();

public static HashMap<String, String> stringFctDefinie = new HashMap<String,

String>();

public Bibliotheque(Logo logo) {

Math m = new Math();

Controle c = new Controle();

Test t = new Test();

GestionEnv g = new GestionEnv(this);

Liste l = new Liste();

EntreeSortie es = new EntreeSortie(logo);

AffichageGraphique ag = new

AffichageGraphique(logo.getExec(),logo.getConsol());

Temps tps = new Temps();

Texte txt = new Texte();

FctDivers fd = new FctDivers();

NewBibliotheque nb = new NewBibliotheque()

Page 33: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

33

argFctPredefinie.putAll(m.argFctPredefinie);

argFctPredefinie.putAll(c.argFctPredefinie);

argFctPredefinie.putAll(t.argFctPredefinie);

argFctPredefinie.putAll(g.argFctPredefinie);

argFctPredefinie.putAll(l.argFctPredefinie);

argFctPredefinie.putAll(es.argFctPredefinie);

argFctPredefinie.putAll(ag.argFctPredefinie);

argFctPredefinie.putAll(tps.argFctPredefinie);

argFctPredefinie.putAll(txt.argFctPredefinie);

argFctPredefinie.putAll(fd.argFctPredefinie);

argFctPredefinie.putAll(ng.argFctPredefinie) ;

methodFctPredefinie.putAll(m.methodFctPredefinie);

methodFctPredefinie.putAll(c.methodFctPredefinie);

methodFctPredefinie.putAll(t.methodFctPredefinie);

methodFctPredefinie.putAll(g.methodFctPredefinie);

methodFctPredefinie.putAll(l.methodFctPredefinie);

methodFctPredefinie.putAll(es.methodFctPredefinie);

methodFctPredefinie.putAll(ag.methodFctPredefinie);

methodFctPredefinie.putAll(tps.methodFctPredefinie);

methodFctPredefinie.putAll(txt.methodFctPredefinie);

methodFctPredefinie.putAll(fd.methodFctPredefinie);

methodFctPredefinie.putAll(nb.methodFctPredefinie);

}

}

Pour terminer, il faut juste recompiler la nouvelle bibliothèque et bibliotheque.java pour

pouvoir utiliser l’applet Logo avec les nouvelles commandes.

Page 34: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

34

5 .2 DIAGRAMMES DE CLASSES

Page 35: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

35

6. GUIDE D’UTILISATION

Notre applet Logo est un logiciel en français.

L'interface est un programme écrit en Logo dont le rôle est de transmettre des

instructions données en français à l'interpréteur Logo et d'intercepter les messages

d'erreurs éventuelles.

Chaque ligne d'instructions, validée à l'aide du bouton Démarrer ou lue à partir de

l'éditeur, Logo est enregistrée dans un fichier d'échange. Ce fichier est aussitôt

analysé. Les commandes qu'il contient sont traduites par le parseur et exécutées. Les

éventuels messages d'erreur sont interceptés et affichés dans la console. Ils

contiennent les informations essentielles sur l'erreur.

Par rapport à la version originale de MSWLogo, le programme permet en plus

l'affichage d'une télécommande, facilitant l’utilisation par de jeunes enfants.

Page 36: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

36

6.1 EDITION DU CODE

Notre applet permet différentes manières pour exécuter du code Logo, l’utilisateur

peut saisir son code directement dans l’éditeur de texte ou dans la console, ou il peut

ouvrir un fichier existant dans l’éditeur de texte et le modifier à sa guise par la suite.

6.1.1 OUVRIR UN FICHIER

Pour ouvrir un fichier, il faut cliquer sur Fichier/Ouvrir.

Page 37: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

37

Une boite de dialogue apparaît, il suffit alors de choisir un fichier et ensuite de cliquer

sur Ouvrir.

Les fichiers dont l’extension est *.logo ou *.txt sont éditables.

6.1.2 ECRIRE AVEC L’EDITEUR

L’éditeur de texte est une fenêtre qui peut être minimisée ou maximisée. Lorsque la

fenêtre est minimisée, pour quel redevienne visible il faut cliquer sur Affichage/Editeur.

A partir de l’éditeur, on peut visualiser directement dans la barre de titre, le nom du

fichier en cours de modification. Pour lancer l’exécution, il faut cliquer sur Démarrer et

pour arrêter le traitement, un bouton Arrêter est disponible aussi.

Page 38: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

38

Si on veut effacer le contenu de la fenêtre de l’éditeur, il suffit de cliquer sur Effacer.

Le contenu de la fenêtre de l’éditeur peut être sauvegardé, pour cela il faut cliquer

sur Fichier/Enregistrer ou Fichier/Enregistrer sous…

Page 39: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

39

6.1.3 ECRIRE AVEC LA TELECOMMANDE

L’applet Logo dispose également d’une télécommande permettant de saisir des

instructions rudimentaires pour faire bouger la tortue et faire des dessins en toute

simplicité.

Pour programmer, il suffit juste de cliquer sur les boutons de la télécommande, les

instructions correspondantes sont alors écrites dans l’éditeur de texte.

6.1.4 ECRIRE EN LIGNE DE COMMANDE DIRECTEMENT

Il est aussi possible de saisir des instructions dans la console directement. On peut

seulement saisir une seule commande à la fois.

Apres avoir validé l’instruction que vous avez saisie, un appui sur la touche « Haut » du

pavé numérique permet de réafficher la dernière instruction saisie.

Page 40: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

40

6.2 INTERPRETATION DU CODE

Une fois que le code à été saisie, il est utile de le vérifier et d’afficher le résultat des

instructions saisies.

6.2.1 VERIFICATION DU CODE

Une fois que le code a été saisi dans l’éditeur, il suffit de cliquer sur Démarrer pour

lancer l’exécution de la tortue. S’il existe des erreurs dans le code écrit, l’application

envoie un message en rouge sur la console afin de signaler à l’utilisateur que son

code comporte des erreurs à un numéro de ligne donnée.

Une erreur faite dans la ligne de commande de la console entraîne aussi un message

d’erreur en rouge celle-ci.

Dans le cas où, l’utilisateur a demandé des informations sur l’épaisseur du trait, le type

de trait, ou d’autres informations avec les commandes « trait », « épais » , etc.…, ces

informations apparaissent en vert dans la console.

Page 41: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

41

Les informations relatives à l’application apparaissent en bleu dans la console.

6.2.2 AFFICHAGE DU RESULTAT

Le résultat d’une commande ou d’une suite d’instructions apparaît dans le panneau

« Exécutions », pour tous les évènements graphiques et dans la console pour toutes les

informations demandées par l’utilisateur.

Le panneau Exécution peut être maximisé afin de pouvoir profiter du résultat en plein

page. Des Scrollpane permettent de naviguer dans le panneau Exécution de

manière horizontale et verticale.

Page 42: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

42

6.2.3 ENREGISTRER LE RESULTAT

Une fois l’exécution terminée, il est possible d’enregistrer le résultat graphique d’un

code. Pour cela, il suffit de cliquer sur la disquette, dans le menu au dessus du

panneau Exécution.

Une fenêtre d’enregistrement apparaît et demande à l’utilisateur où il veut

sauvegarder l’image. L’image sera enregistrée au format PNG.

6.2.4 MODIFIER LE RESULTAT

Il est possible de modifier l’affichage du résultat avant ou après la sauvegarde. Des

outils dans le menu au dessus de la fenêtre Exécution sont disponibles.

De gauche à droite :

• La disquette : permet d’enregistrer le résultat

• La tortue : permet d’afficher ou de cacher la tortue

• Le quadrillage : permet d’afficher ou non un quadrillage en fond d’écran

• Le moins et le plus : permettent de dézoomer et de zoomer sur le résultat.

• La liste déroulante « Couleur fond » : permet de choisir une autre couleur de fond

que celle par défaut.

• Le curseur « vitesse » : permet d’augmenter ou de diminuer la vitesse de la tortue

pendant lors de ses déplacements.

• Le stop : arrête la tortue la ou elle se trouve.

• La gomme : permet d’effacer les dessins déjà dessinés.

Exemple de Zoom :

Avant le Zoom, la tortue a une taille normale.

Page 43: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

43

Apres le Zoom, la taille de la tortue a augmentée.

Il n’y a pas de limite pour zoomer sur une image, on peut zoomer autant de fois qu’on

le désire.

Exemple de changement de fond :

Page 44: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

44

Dans cette exemple, on a changé le fond en vert mais d’autres couleurs sont

disponibles comme :

• Blanc

• Bleu

• Jaune

• Noir

• Rouge

Page 45: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

45

7. LA PROGRAMMATION EN LOGO

Logo permet de faire des dessins en donnant des ordres à un instrument

appelé tortue, mais aussi de faire des calculs mathématiques. La

manipulation de la tortue peut être une suite d’instructions rudimentaires

ou des instructions récursives et itératives.

L’appelle d’une fonction (primitive ou pas) se fait de cette façon :

Non_de_la_fonction argt_1 … arg_n

Exemple : somme 1 45 ;calcule 1 + 45

L’appelle d’une fonction (primitive ou pas) avec ses arguments optionnelles

se fait de cette façon :

( Non_de_la_fonction arg_1 … arg_n arg_op_1 … arg_op_n)

Exemple : (somme 1 45 4 5 6) ;calcul 1 + 45 + 5 + 6

7.1 MANIPULATION DE LA TORTUE

Les principales instructions de la tortue sont :

- AVANCE

- DROITE

- GAUCHE

- RECULE

- FIXEPOS

- FIXECAP

- MONTRETORTUE

- CACHETORTUE

- LEVECRAYON

- BAISSECRAYON

- FCC

AVANCE OU AV

AVANCE n, avec n un entier, va faire avancer la tortue de n pas dans la direction

dans laquelle elle est dirigée.

Exemple :

AVANCE 10

AV 10

; Ces deux instructions sont identiques

Page 46: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

46

DROITE OU DR

DROITE n, avec n un entier, va modifier la direction de la tortue de n degrés vers la

droite (c'est à dire dans le sens horaire).

Exemple :

DROITE 10

DR 10

; Ces deux instructions sont identiques

GAUCHE OU GA

GAUCHE n, avec n un entier, va modifier la direction de la tortue de n degrés vers la

gauche (c'est à dire dans le sens trigonométrique).

Exemple :

GAUCHE 10

GA 10

; Ces deux instructions sont identiques

RECULE OU RE

RECULE n, avec n un entier, va faire reculer la tortue de n pas, c'est à dire la faire

avancer dans la direction formant un angle complémentaire avec la direction dans

laquelle elle est dirigée.

Exemple :

RECULE 10

RE 10

; Ces deux instructions sont identiques

FIXEPOS OU FPOS

FIXEPOS [x y], avec x et y des entiers, permet de fixer la position de la souris, x et y les

coordonnés de la nouvelle position.

Exemple :

FIXEPOS [100 10]

FPOS [100 10]

; Ces deux instructions sont identiques

FIXECAP OU FCAP

FIXECAP n, avec n un entier permet de fixer la direction dans laquelle la tortue doit

etre dirigée, n étant l'angle (l'angle 0 étant l'angle vertical montant).

Exemple :

FIXECAP 10

FCAP 10

; Ces deux instructions sont identiques

Page 47: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

47

MONTRETORTUE

MONTRETORTUE permet de visualiser la tortue.

CACHETORTUE

CACHETORTUE permet de dissimuler la tortue.

LEVECRAYON

LEVECRAYON permet de ne plus tracer de figure, ce qui veut dire les prochains

déplacements ne seront plus accompagné d'un tracé (mode par défaut).

Exemple :

AV 10

LEVECRAYON

AV 10

; La tortue trace un trait de 10px puis avance de 10px sans tracer de trait

BAISSECRAYON

BAISSECRAYON permet de recommencer le tracé, ce qui veut dire que les prochains

déplacements seront à nouveau accompagnés d'un tracé.

Exemple :

AV 10

LEVECRAYON

AV 10

BAISSECRAYON

AV 10

; La tortue trace un trait de 10px puis avance de 10px sans tracer de trait

; puis trace un trait de 10px

FCC

FCC n, avec n un nombre entier, permet de sélectionner la couleur des prochains

tracés :

• 0 : noir

• 1 : rouge

• 2 : vert

• 3 : jaune

• 4 : bleu

• 5 : violet

• 6 : bleu clair

• 7 : blanc

Page 48: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

48

Exemple:

AV 10

LEVECRAYON

AV 10

FCC 1

BAISSECRAYON

AV 10

; La tortue trace un trait de 10px noir puis avance de 10px sans tracer de trait

; puis trace un trait de 10px rouge

7.2 PROCEDURES ET FONCTIONS

En Logo, une procédure est un ensemble nommé d'instructions qui peut être appelé :

POUR nom

[var1 … varn [option1 val] ...]

[Instructions]

L'appel se fera simplement en invoquant le nom de la procédure.

PARAMETRES

Les paramètres var1 … varn sont autant de paramètres que l’on désire utiliser pour

nos fonctions tandis que [option1 val]… [Option n val] sont des paramètres optionnels

initialisés lors de la déclaration de la fonction.

Exemple :

POUR equi [longueur]

[ REPETE 3

[

AVANCE :longueur

DROITE 300

]

]

; Cet exemple trace un triangle équilatéral. La fonction renvoie le résultat de la dernière instruction effectué.

7.3 ITERATION

REPETE

Logo permet d'effectuer de manière simple des itérations, grâce à l'instruction

REPETE :

REPETE n [INSTRUCTIONS], avec n un nombre entier, va répéter n fois le bloc

d'instructions entre crochet.

Page 49: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

49

Exemple :

REPETE 4

[

AVANCE 50

DROITE 90

]

; va tracer un carré ayant 50 de coté.

Il est possible d'imbriquer des itérations.

REPETEPOUR

L'instruction REPETEPOUR permet de connaître, à l'intérieur d'une boucle, combien de

fois le contenu de la boucle a déjà été répété.

La syntaxe est la suivante : REPETEPOUR [‘’variable borneInf borneSup Step]

[INSTRUCTIONS]

Exemple :

REPETEPOUR [‘’Iterateur 1 4 1]

[

REPETE :Iterateur [AVANCE 50 GAUCHE 90]

]

; va tracer un carré ayant 50 de coté. ; Le premier argument est le nom de la variable

; Le second argument est la borne de départ ; Le troisième est la borne d’arrivée

; Le dernier est optionnel, le pas de l’indentation de l’iterateur

TANTQUE

L'instruction TANTQUE [EXPRESSION] [INSTRUCTIONS] permet de répéter le bloc

instructions tant que la condition contenue dans expression est vérifié.

EXEC

L'instruction EXEC [instructions] permet d'exécuter les instructions.

7.4 CONDITION

En Logo, une condition est testée avec l'instruction SI ou SINON

Avec l’instruction SI condition [instructions1], si la condition est remplie, le bloc

instructions1 est exécuté, sinon elle renvoie faux.

Page 50: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

50

Avec l’instruction SINON condition [instructions1] [instructions2], si la condition est

remplie, le bloc instructions1 est exécuté, sinon, c'est le bloc instructions2 qui l'est.

7.5 CALCULS

OPERATEURS

Opérateur Rôle

(, ) Parenthèses ouvrantes et fermantes

+, - Addition, soustraction

*, / Multiplication, division

<,>, = , != Comparaison

FONCTIONS MATHEMATIQUES

Fonction Rôle

SOMME Addition

PRODUIT Multiplication

DIVISION Division entière

MOINS Moins unaire

MODULO Reste de la division entière

RACINE Racine carré

ABS Valeur absolue

Page 51: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

51

PI Nombre Pi

PUISSANCE Puissance

SIN Sinus

COS Cosinus

TAN Tangente

ARCSIN Réciproque de sinus

ARCCOS Réciproque de cosinus

ARCTAN Réciproque de tangente

EXP Exponentielle

LOG10 Logarithme en base 10

LN Logarithme népérien

ARRONDIE Arrondir

SIGNE Renvoie le signe du nombre

HASARD Renvoie un nombre au hasard

Page 52: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

52

7.6 VARIABLES

Logo permet un mécanisme simple concernant les variables.

INSTRUCTION DONNE

L'instruction DONNE permet d'affecter une valeur à un nom d’une variable globale.

Exemple :

DONNE "nombre 36

ECRIS :nombre

;Ce programme affichera la valeur de la variable, soit 36.

Toutefois, il est possible d'affecter les valeurs en cascade.

Exemple :

DONNE "nombre1 36

DONNE "nombre2 :nombre1

ECRIS :nombre2

;Ce programme affichera également le nombre 36.

INSTRUCTION DONNELOCALE

L'instruction DONNELOCALE permet de créer une variable dont la portée se limite à la

procédure courante.

Exemple :

SI ‘’vrai [

DONNELOCALE "nombre 36

ECRIS : nombre ; Écris 36

]

ECRIS : nombre

; Écris rien, l'évaluateur ne connais pas la ; variable nombre

INSTRUCTION CHOSE?

L'instruction CHOSE ? renvoie vrai si c’est une variable.

INSTRUCTION NETTOIEGLOBAL

L’instruction nettoieglobal vide l'environnement global.

Page 53: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

53

7.7 LISTE

MOTS ET LISTE

LES MOTS

Un mot LOGO peut comporter zéro élément (c'est le mot vide : " ), ou un seul élément

(exemple : "a ), ou plusieurs éléments (exemple : "anticonstitutionnellement ). On

considère un mot de plusieurs éléments comme la concaténation de mots d'un

élément.

Fonctions portant sur les mots :

Code Renvoie Exemple de code Ce que ça

affiche

COMPTE :mot Le nombre d'éléments de :mot ECRIS COMPTE "abc 3

CONCAT :mot1 :mo

t2

Un mot qui est la concaténation

de :mot1 et :mot2 ECRIS CONCAT "Lo "go Logo

PREMIER :mot Le premier élément de :mot ECRIS PREMIER "abc a

DERNIER :mot Le dernier élément de :mot ECRIS DERNIER "abc c

SAUFPREMIER :mot :mot sans son premier élément ECRIS SAUFPREMIER

"abc bc

SAUFDERNIER :mot :mot sans son dernier élément ECRIS SAUFDERNIER

"abc Ab

LES LISTES

Une liste peut comporter zéro élément, ou un seul élément, ou plusieurs éléments. Un

élément d'une liste peut être un mot ou une liste.

Exemples de listes :

• à zéro élément (liste vide) : []

• à un élément : [abc]

[ [1 2 3] ]

[[Jean Dupont [place du marché] [46200

Souillac]]]

Page 54: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

54

• à plusieurs éléments : [x y z]

[Jean Dupont [place du marché] [46200

Souillac]]

FONCTIONS PORTANT SUR LES LISTES

Les fonctions COMPTE, PREMIER, DERNIER, SAUFPREMIER et SAUFDERNIER opèrent de la

même manière sur une liste que sur un mot.

Six autres fonctions opèrent seulement sur des listes :

LISTE :élément1 :élément2 ou (LISTE :élément1 … :élémentn) renvoie une liste

composée des DEUX éléments, :élément1 et :élément2

Exemple :

ECRIS LISTE "Logo [un langage ultra puissant]

; Le programme affichera Logo [un langage ultra puissant]

METSPREMIER :élément :liste renvoie la liste :liste augmentée de :élément en première

position2

METSDERNIER :élément :liste renvoie la liste :liste augmentée de :élément en derniére

position

INVERSE :élément inverse la liste :élément

COMPTE :liste renvoie le nombre d’élément d’une liste

VIDE? :liste renvoie si la liste :liste est vide ou non

PHRASE :liste1 :liste2 ou (PHRASE :liste1 :listen) renvoie la concaténation de liste1 et

liste2

Exemple :

ECRIS METSPREMIER [Le langage Logo] [va plus loin que les petits dessins]

; Le programme affichera [Le langage Logo] va plus loin que les petits dessins

ECRIS METSDERNIER 8 [1 1 2 3 5]

; Le programme affichera 1 1 2 3 5 8

7.8 LES TESTS

Différentes fonctions de testes sont disponible, elles renvoient vrai si la condition du

test est vérifiée sinon elle renvoie faux.

• egal? :élément1 : élément2 permet de tester l’égalité entre deux éléments

• inegal? :élément1 : élément2 permet de tester l’inégalité entre deux éléments

• pluspetit? :élément1 : élément2 permet de tester si :élément1 est plus petit

que :élément2

Page 55: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

55

• plusgrand? :élément1 : élément2 permet de tester si :élément1 est plus grand

que :élément2

• pluspetitou? :élément1 : élément2 permet de tester si :élément1 est plus petit

ou égal que :élément2

• plusgrandou? :élément1 : élément2 permet de tester si :élément1 est plus

grand ou égal que :élément2

• mot? :élément permet de vérifier si :élément est un mot

• nombre? :élément permet de vérifier si :élément est un nombre

• liste? :élément permet de vérifier si :élément est une liste

• vide? :élément permet de vérifier si :élément est vide

• fonction? :élément permet de vérifier si :élément est fonction existante

• pour? :element permet de vérifier si :élément est fonction définie avec "pour"

existante

• primitive? :element permet de vérifier si :élément est fonction primitive

existante

• precede? :élément1 :élément2 compare deux mot

• membre? :élément1 :élément2 test si :élément2 appartient à la liste :élément1

7.9 FONCTIONS DIVERSES

Invoque :fct :arg1 ou (invoque :fct :arg1 … argn) : invoque la fonction :fct avec les

arguments arg1 … argn

detaillefct :fct : si la :fct est une fonction définie avec « pour », rend un mot qui

contient la définition de :fct sinon rend faux

Page 56: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

56

8. CONTROLE DE L’APPLICATION

8.1 LES CONTROLES GRAPHIQUES

AVANCE ou AV n : Avance la tortue de n.

RECULE ou RE n : Recule la tortue de n.

TOURNEGAUCHE ou TG o : Tourne la tortue d’un angle o.

TOURNEDROITE ou TD o : Tourne la tortue d’un angle o.

LEVECRAYON ou LC : Lève le crayon de la tortue (arrête de tracer).

BAISSECRAYON ou BC : Baisse le crayon (trace).

FIXEPOS ou FPOS [m n] : Fixe la position de la tortue.

POSITION ou POS : Rend la position de la tortue.

FIXECAP ou FCAP o : Fixe la cap de la tortue.

CAP : Rend le cap de la tortue.

FIXEEPAIS ou FEPAIS m : Fixe l’épaisseur du trait (0-20)

EPAIS : Rend l’épaisseur du trait.

FIXETRAIT ou FTRAIT m : Fixe le type de trait (0-65535).

TRAIT : Rend le type de trait.

DISTANCE [m n] : Rend la distance séparant la tortue du point (m,n).

FCC n : Fixe la couleur du crayon avec la couleur n.

CC : Rend la couleur du crayon.

FCFG n : Fixe la couleur du fond graphique avec la couleur n.

CF : Rend la couleur du fond graphique.

NETTOIE : Nettoie l’écran.

ORIGINE : Place la tortue à l’origine.

POINT m n : Dessine un point défini dont la coordonnée est (m,n).

VITESSE n : Change la vitesse de déplacement de la tortue, n doit être compris entre 1

et 500

STOP : arrête le déplacement de la tortue.

PAUSE : met en pause la tortue.

FINPAUSE : relance la tortue.

8.2 LES PROCEDURES

POUR m [x1 xn] [instruction] : Déclarer une fonction

8.3 LES PREDICATS

PLP? ou PLUSPETIT? m n : Rend VRAI si m est plus petit que n.

PLG? ou PLUSGRAND? m n : Rend VRAI si m est plus grand que n.

Page 57: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

57

PLPO? ou PLUSPETITOU? m n : Rend VRAI si m est plus petit ou égal que n.

PLGO? ou PLUSGRANDOU? m n : Rend VRAI si m est plus grand ou égal que n.

EGAL? m n : Rend VRAI si m est égal à n.

INEGAL? m n : Rend VRAI si m est différent de n.

BC? : Rend VRAI si le crayon est baissé.

VIDE? m : Rend VRAI si m est vide.

NOMBRE? m : Rend VRAI si m est un nombre.

MOT? l : Rend VRAI si l est un mot.

PRIMITIVE? l : Rend VRAI si l est une primitive Logo.

POUR? l : Rend VRAI si l est une procédure utilisateur.

FONCTION? l : Rend VRAI si l est une procédure ou une primitive Logo.

PRECEDE? :élément1 :élément2 compare deux mot

MEMBRE? :élément1 :élément2 test si :élément2 appartient à la liste :élément1

ET p q ou (ET v1 … vn): Rend VRAI si les 2 prédicats p et q sont vrais.

OU ou (ET v1 … vn) p q : Rend VRAI si au moins un des 2 prédicats p ou q est vrai.

‘’VRAI : Valeur « vrai ».

‘’FAUX : Valeur « faux ».

8.4 LES VARIABLES

DONNE "i x : Assigne x à la variable i. (Création de la variable si elle n’existe pas)

DONNELOCALE "i x : Assigne x à la variable i locale. (Création de la variable si elle

n’existe pas)

CHOSE ‘’m : Renvoie la valeur de la variable m

NETTOIEGLOBAL : vide l’environnement global

8.5 LES FONCTIONS CONTROLES

REPETE m [l] : Répète m fois la liste d’instructions l.

REPETEPOUR [‘’i dep arr pas] [l] : Répète la liste d’instructions l de ‘’i allant de dep a

arr.

TANTQUE [condition] [l] : Répète la liste d’instructions l tant que condition est vrai

EXEC [l] : Exécute la liste d’instruction l.

SI m [l1] : Exécute la liste d’instruction l1 si le prédicat m est vrai.

SINON m [l1][l2] : Exécute la liste d’instruction l1 si le prédicat m est vrai sinon exécute

la liste d’instruction I2

8.6 L’ARITHMETIQUE

SOMME m n ou (SOMME v1 … vn): Rend la somme de m et n.

PRODUIT m n ou (PRODUIT v1 … vn): Rend le produit de m par n

DIVISION m n : Rend le résultat de la division de m par n.

MODULO : Rend le reste de la division entière de m par n.

COS o, SIN o, TAN o : Rend le cosinus, le sinus et la tangente de o.

Page 58: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

58

ARCCOS o, ARCSIN o, ARCTAN o : Rend le co-cosinus, le co-sinus et la co-tangente

de o.

RACINE m : Rend la racine carrée de m.

PUISSANCE m n : Rend m élevé à la puissance n.

EXP m : Rend l’exponentielle de m.

LOG10 m : Rend le logarithme en base 10 de m.

LN m : Rend le logarithme népérien de m.

HASARD m : Rend un nombre aléatoire compris entre 0 et m-1.

ABS m : Rend la valeur absolue de m.

ARRONDIE m : Rend l’arrondie le nombre m.

PI : Rend la valeur pi.

SIGNE m : Rend le signe de m.

8.7 LES LISTES

ITEM n l : Rend le n ème élément de la liste l.

COMPTE l : Rend le nombre d’élément de la liste l.

METSDERNIER ou MD m l : Rend une liste construite en ajoutant m à la fin de la liste l.

METSPREMIER MP m l : Rend une liste construite en ajoutant m en tête de la liste l.

SAUFDERNIER ou SD l : Rend la liste l sans son dernier élément.

SAUFPREMIER SP l : Rend la liste l sans son premier élément.

INVERSE m : Rend la liste l inversé.

ASCII l : Rend le code ascii du premier caractère de l.

CAR m : Rend le caractère de code ascii m.

8.8 LES RACCOURCIS

ECRIS m : Ecris m sur le canal (sortie) courant (Ex : ECRIS [Sauve la princesse])

VITESSE : Changer la vitesse de la tortue

PAUSE : Met en pause la tortue

FINPAUSE : Remet la tortue en marche.

Page 59: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

59

9. JEUX DE TESTS ET RESULTATS

Exemple N°1 :

; Ce code permet de dessiner des cercles décalés pour n_eck [ne sz] [ repete :ne [dr 360 / :ne av :sz] ] pour mn_eck [ne sz] [ repete :ne [dr 360 / :ne n_eck :ne :sz] ] ; dessine une première fois avec un trait plein en bleu mn_eck 36 20 ; change le style de trait en pointillés ftrait 3 ; change la couleur du trait en rouge fcc 4 ; redessine par dessus mn_eck 36 20

Page 60: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

60

Exemple N°2 :

; Déclaration de la fonction CCURVE pour CCURVE [LONG PROFONDEUR] [

sinon :PROFONDEUR < -1 [av arrondie :LONG] [ ga 45 CCURVE :LONG / 1.4142 :PROFONDEUR - 1 dr 90

CCURVE :LONG / 1.4142 :PROFONDEUR - 1 ga 45 ] ] pour ro [x] [ repete :x [CCURVE 100 8 dr 360 / :x] ] ; on nettoie tout nettoie ; on lance ro de 6 ro 6

Page 61: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

61

Exemple N°3 :

; Déclaration de la fonction spit pour spit [a co] [ sinon :a > 3000 [ ] [

fcc modulo :co 15 av 10 dr :a spit :a + 7 :co + 1

] ] ;On nettoie nettoie ;On lance plusieurs le même programme avec des paramètres différents spit 0 0 spit 45 270 spit 90 180 spit 135 90

Page 62: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

62

Exemple N°4 :

pour eth8 [] [ repete 8 [ av 170 dr 135 ] ] pour dav [x] [ repete 5 [ av :x dr 144 ] ] pour vad [x co] [ sinon :x < 0 [] [ fcc modulo :co 15 dav :x vad :x - 10 1 + :co ] ] nettoie vad 2000 0

Page 63: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

63

Exemple N°5:

; un exemple de fonction avec un argument optionnel

;declaration de la fonction rectangle

pour rectangle [x [y 50]] [

av :x dr 90

av :y dr 90

av :x dr 90

av :y dr 90

]

nettoie

;appelle de la fonction rectangle avec le

;nombre d'argument par défaut

;valeur des arguments (x=100, y=50)

rectangle 100 ;le rectangle bleu

fcc 10

;appelle de la fonction rectangle avec un

;argument optionnelle

;valeur des arguments (x=150, y=100)

(rectangle 150 100) ;le rectangle vert

Page 64: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

64

CONCLUSION ET PERSPECTIVES

Logo est un langage d'une remarquable simplicité, ce qui ne l'empêche pas toutefois

d'être puissant dans son domaine de prédilection, le graphisme. Toutes ces qualités

en font un langage idéal pour l'apprentissage de la programmation impérative,

notamment pour initier les enfants.

Notre objectif était de créer un interpréteur LOGO. En utilisant le langage de

programmation Java nous avons réussi a créer un logiciel accessible à tout le monde grâce

une interface simple et intuitive, de n’importe où grâce à la création d’un applet disponible

sur Internet, performant et évolutif grâce à sa structure tout en répondant au cahier des

charges.

Si notre logiciel n’est pas l’unique interpréteur Logo existant il peut se démarquer grâce ces

fonctionnalités tel que la télécommande qui permet de programmer grâce a de simples

clics, son interactivité et son langage en français (beaucoup de logiciels LOGO sont écrits en

anglais). Mais le programme n’est sûrement pas complet, en effet on pourra toujours

l’améliorer, ajouter de nouvelle fonctions LOGO, modifier l’interface (notamment

compléter la télécommande avec un plus grand panel de fonctions).

Ce projet nous a aussi obligé à développer une communication quasi permanente dans le

groupe, notamment grâce au protocole SVN qui nous a permis de travailler à distance sans

problème, et obtenir un travail clair et correctement organisé.

Grâce à ce TER, nous avons donc amélioré nos connaissances en Java, dans l’animation,

dans l’interface Homme machine, en évaluation de code, et en analyse syntaxique. Nous

avons du trouver une bonne organisation pour coordonner un groupe de quatre personne. Et

nous avons développé un projet de façon professionnelle avec un résultat fonctionnel et

performant.

Page 65: TER Logo - Rapportleclere/enseignements/TER/2007/Rapport/18.pdf- Mozilla Public License 1.1 - New BSD License 4.1.2 GOOGLE GROUPE DE DISCUSSION L'objectif de notre groupe de discussion

TER Interpréteur Logo

65

REFERENCES

- MSWLogo : http://www.algo.be/

Nous avons utilisé le logiciel MSWLogo et la documentation pour

comprendre le fonctionnement du langage.

- XLogo : http://xlogo.tuxfamily.org/

Un autre interpréteur Logo.

- MICROWORLDS : http://www.microworlds.com/

- LogoPLUS : http://perso.orange.fr/logoplus/

- Google Groupe : http://groups.google.com/group/dekka-studio?hl=fr

A permis de créer un groupe de discussion pour projet afin de partager

nos idées et de s’organiser.

- Google Code : http://code.google.com/p/ter-logo/

Serveur SVN pour le projet (mise a jour de version)

- Look&Feel Nimrod : http://personales.ya.com/nimrod/faq-en.html

Nous avons utilisé ce look&feel en open source pour le projet, très

pratique et facile à implémenté.

- IconArchive : http://www.iconarchive.com/

Propose des icônes en Open Source pour les logiciels.

- Developpez.com : http://java.developpez.com/

Site de programmation et de renseignement sur les techniques en java, il

dispose aussi d’un forum avec une grande communauté de

programmeur qui s’entraide.