Normalement, un programme AlgoTouch est construit automatiquement suite aux manipulations de l’utilisateur. Cependant, l’utilisateur peut être amené à effectuer des modifications au programme sans avoir à refaire les manipulations. AlgoTouch permet déjà d’effectuer certaines modifications. En effet, on peut renommer variables, constantes, tableaux, index et macros. On peut aussi en redéfinir le rôle. Cependant, actuellement a modification du code d’un bloc (Do, From, Until, Loop, Terminate) est limitée soit à l’effacement total, soit à l’ajout de nouvelles instructions en fin de bloc.
Il est parfois frustrant pour un programmeur expérimenté de ne pas pouvoir intervenir directement pour éditer le code, notamment lorsque la modification est mineure. Par exemple, on peut souhaiter changer le message d’une opération de saisie ou d’une opération d’affichage, modifier la condition d’un test (== par <=).
Dans cette page, nous décrirons la structure json des éléments d’un programme AlgoTouch.
Table des matières
[ "var", 242, 143, "s", "somme", "int", 55 ]
[ "const", 159, 217, "10", "", "int", 10 ]
Les variables et constantes ont une structure similaire. C’est un “tableau” de 7 valeurs. La première valeur est une chaîne indiquant le type d’élément: “var” ou “const”. Les deux valeurs suivantes indiquent les coordonnées dans la fenêtre (le point 0,0 est en haut à gauche). Les quatrième et cinquième valeurs sont respectivement le nom et le rôle de l’élément. La sixième valeur est le type de la variable ou constante (var ou char) et la septième est la valeur qui lui est affectée.
[ "array", 314, 45, "a", "", "int", [1,11,17,60,65,66,96,80,64,18,12] ]
[ "index", 314, 195, "i", "", "int", 0, "a" ]
De façon similaire aux variables et constantes, les 6 premiers paramètres représentent le type de l’élément, suivi de ses coordonnées, son nom, son rôle et le type de donnée (int ou char). Dans le cas, d’un tableau, le septième paramètres décrit le contenu du tableau entre crochets. Dans le cas d’un index, le septième paramètre contient la valeur de l’index et le huitième, le nom du tableau qu’il référence.
[ "i = 0 ;", "j = a.length ;", "j = j - 1 ;", "k = 0 ;" ]
Un bloc d’instruction est une suite de lignes séparées par des virgules et encadrée par des crochets. Les instructions sont encadrées par des guillemets.
Les instructions d’entrées/sorties ont une structure similaire: le type d’instruction (Write ou Read), suivi du message à afficher, suivi de la variable concernée (à afficher ou à saisir). Comme les autres instructions, elles sont encadrées par des guillemets.
{ "if": "a[i] < a[j]", "then": [ "b[k] = a[i] ;", "i = i + 1 ;" ], "else": [ "b[k] = a[j] ;", "j = j - 1 ;" ] }
Une condition est encadrée par les accolades. Elle comprend 3 parties étiquetées respectivement par “if”, “then” et “else”. La partie “if” est suivie par la condition entre guillemets. Les parties “then” et “else” sont suivies d’un bloc d’instructions.
[ "macroDo", 0, 0, "MacroDo", "Macro simple", { "do": [ ... à compléter ] } ]
[ "macroLoop", 120, 0, "MacroB", "Macro boucle", { "from": [ ... à compléter ], "until": [ ... à compléter ], "loop": [ ... à compléter ], "terminate": [ ... à compléter ] } ]
Les macros simple et boucle ont la même structure de base que les autres éléments (variables, constantes, etc.). Les 5 premiers composants sont: le type de l’élément (macroDo ou macroLoop), ses coordonnées, son nom et son rôle. Le sixième composant est encadré par des accolades. Dans le cas d’une macro simple, il s’agit d’un bloc d’instruction précédé de “do”. Dans le cas d’une macro boucle, les 4 blocs de la boucle sont définis, précédés par les mots clés “from”, “until”, “loop” et “terminate”.
Un programme AlgoTouch contient les définitions des données et des macros, encadrées par des crochets. Chaque élément possède la structure décrite précédemment.
[ [ "var", ... ], [ "const", ... ], [ "array", ... ], [ "index", ... ], [ "macroLoop", ... ], [ "macroDo", ... ] ]
[ "macroLoop", 120, 0, "Merge", "Fusion", { "from": [ "i = 0 ;", "j = a.length ;", "j = j - 1 ;", "k = 0 ;" ], "until": [ "k >= b.length" ], "loop": [ { "if": "a[i] < a[j]", "then": [ "b[k] = a[i] ;", "i = i + 1 ;" ], "else": [ "b[k] = a[j] ;", "j = j - 1 ;" ] }, "k = k + 1 ;" ] } ]
{ "if": "x <= 0", "then": [ "x = x + 1 ;" ], "else": [ "x = x - 1 ;" ] }
Les clauses “then” et “else” contiennent des instructions.
{ "if": "x <= 0", "then": [ "x = x + 1 ;" ] }
Dans ce cas, il n’y a pas de clause “else”.
{ "if": "x <= 0", "then": [ "x = x + 1 ;" ], "else": [] }
Dans ce cas, la clause “else” doit contenir seulement des crochets [].
{ "do": [ "Read \" Note : \" x ;", { "if": "x >= 0", "then": [ { "if": "x <= 20", "then": [ "Write \"Note ok : \" x ;" ], "else": [ "Write \"Note trop grande : \" x ;" ] } ], "else": [ "Write \"Note négative : \" x ;" ] } ] }
Dans cet exemple, une macro do vérifie si une note saisie x est comprise entre 0 et 20. Si la valeur est supérieure ou égale à 0, il faut alors tester si la valeur est inférieure ou égale à 20. On doit donc ajouter une condition dans la clause “then” du test “x >= 0”. On insère donc un bloc “if” complet entre parenthèses {} dans le bloc “then” encadré par des crochets [].