Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
TER Logo M1 Informatique Université Montpellier II ALLIER Simon – GROLLEMUND Naïtan – LALLUQUE Renaud - DELFOUR Kevin 2006 - 2007
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
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.
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
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
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.
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).
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
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
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.
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
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.
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.
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.
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]
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
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
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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()
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.
TER Interpréteur Logo
34
5 .2 DIAGRAMMES DE CLASSES
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.
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.
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.
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…
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.
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.
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.
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.
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 :
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
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
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
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
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.
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.
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
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
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.
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]]]
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
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
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.
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.
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.
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
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
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
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
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
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.
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.