Edition d’un fichier AlgoTouch au format json

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.

Les données

Variables, constantes

[
"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.

Tableaux et index

[
  "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.

Les macros et instructions

Les affectations

[
  "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 entrées/sorties

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.

“Write \”Résultat : \” s ;”,
“Read \”Combien : \” s ;”

Les conditions

{
  "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.

Les macros

[
  "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”.

Structure d’un fichier json Algotouch

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", ...
  ]
]

Exemple de macro boucle

[
  "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 ;"
    ]
  }
]

Cas des instructions conditionnelles

If avec then et else

{
  "if": "x <= 0",
  "then": [
    "x = x + 1 ;"
  ],
  "else": [
    "x = x - 1 ;"
  ]
}

Les clauses “then” et “else” contiennent des instructions.

If sans else

{
  "if": "x <= 0",
  "then": [
    "x = x + 1 ;"
  ]
}

Dans ce cas, il n’y a pas de clause “else”.

Else avec TODO

{
  "if": "x <= 0",
  "then": [
    "x = x + 1 ;"
  ],
  "else": []
}

Dans ce cas, la clause “else” doit contenir seulement des crochets [].

Conditions imbriquées

{
  "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 [].