Le langage CoddyRun

La référence complète du pseudo-code : chaque mot-clé, chaque structure et chaque fonction intégrée, avec des exemples prêts à copier dans l'éditeur.

Chapitres

FR · EN

Syntaxe native

Prérequis

Langage :

Mots-clés

Tous les mots réservés du langage CoddyRun

Les mots-clés sont les mots réservés du langage — on ne peut pas les utiliser comme noms de variables. Ils forment la grammaire CoddyRun et couvrent tout ce dont on a besoin pour écrire des programmes complets : déclarer et modifier des variables, interagir avec l'utilisateur, prendre des décisions, répéter des actions, et organiser son code en sous-programmes.

Déclaration & affectation

estununevautconstante

Ces mots servent à créer des variables et leur assigner des valeurs. x est un nombre déclare la variable, x vaut 42 l'affecte. Les deux peuvent être écrits séparément ou ensemble.

Types

nombretextebooléentableauenregistrementdateheuretoile

CoddyRun dispose de 8 types fondamentaux. Le type détermine la valeur par défaut et les opérations disponibles : on peut additionner des nombres, concaténer des textes, tester des booléens, et parcourir des tableaux.

Entrée / Sortie

affichedemandechoisirappuyerdansdéboguer

Conditions

sialorssinonfin siselonfin selon

Boucles

tant quefin tant querépètefoisfin répètepourde àpasfin pourcontinuearrete

CoddyRun propose trois structures de répétition pour couvrir tous les cas : pour quand on connaît le nombre d'itérations, tant que quand on répète sous condition, et répète … fois pour les répétitions simples à nombre fixe.

Fonctions & procédures

fonctionretournefin fonctionprocédureappellefin procédure

Tableaux

ajoutesupprimevide

Opérateurs logiques & Booléens

etounonvraifaux

Gestion des exceptions

essayerattraperfin essayer

Variables

Déclarer, affecter et manipuler les 4 types du langage

Qu'est-ce qu'une variable ?

Une variable est une boîte nommée qui stocke une valeur en mémoire. On lui donne un nom, un type, et une valeur initiale. Plus tard dans le programme, on peut lire sa valeur, la modifier, ou l'utiliser dans des calculs. En CoddyRun, on déclare une variable avec la syntaxe x est un type, et on lui assigne une valeur avec x vaut valeur.

Pourquoi déclarer le type ? Déclarer explicitement le type (nombre, texte, booléen, tableau) a deux avantages pédagogiques : cela force l'apprenant à réfléchir à la nature de sa donnée, et cela permet à l'interpréteur de faire des conversions automatiques cohérentes (par exemple lors d'une saisie utilisateur).

Déclaration

x est un nombre0 par défaut

x est un texte'' par défaut

x est un booléenfaux par défaut

x est un tableau[] par défaut

x est un enregistrementVariable regrouper

x est une datejj/mm/aaaa

x est une heurehh:mm:ss

x, y est un nombreDéclarer plusieurs variables

x est un nombre vaut 1.5Déclaration et initialisation en une seule ligne

Quand plusieurs variables ont le même type, il est plus simple et plus lisible de les déclarer sur une seule ligne.

Affectation

x vaut 42Nombre entier

x vaut 3.14Nombre décimal (le point comme séparateur)

x vaut $FFNombre hexadécimal ($)

x vaut 'Bonjour' / "Bonjour"Texte entre '...' - "..."

x vaut vraiBooléen positif

x vaut fauxBooléen négatif

x vaut y + 1Résultat d'une expression

Raccourcis numériques

Ces raccourcis permettent de modifier une variable numérique sans réécrire son nom des deux côtés.

x ajoute 10x = x + 10

x soustrait 5x = x − 5

Exemple Tableau

                                t est un tableau
                                t[1] vaut 10
                                t[1] soustrait 1 // 9
                                affiche t[1]
                                t[1] ajoute 1
                                affiche t[1] // 10
                            

Qu'est-ce qu'un enregistrement ?

Un enregistrement est une variable qui peut regrouper plusieurs informations différentes sous un même nom.

Contrairement : à un nombre (une seule valeur), à un texte (une seule chaîne), à un tableau (plusieurs valeurs du même type),

un enregistrement permet de stocker plusieurs champs, chacun pouvant représenter une information différente.

On utilise un enregistrement pour représenter un objet du monde réel : un élève (nom, note, âge…), un point (x, y), un produit (prix, quantité, nom)

Exemple

élève est un enregistrement
élève.nom vaut 'Alice'
élève.note vaut 15
affiche élève.nom
affiche élève.note

Utilisation dans les calculs et conditions

si élève.note >= 10 alors
affiche 'Admis'
sinon
affiche 'Refusé'
fin si

Classes

Définir un modèle nommé regroupant plusieurs champs typés

Qu'est-ce qu'une classe ?

Une classe est un modèle qui regroupe sous un même nom plusieurs informations différentes, appelées champs. Chaque champ possède son propre type (nombre, texte, booléen…). Une fois la classe définie, on accède à ses champs directement par leur nom, avec la notation nom_de_classe.champ.

La classe est proche de l'enregistrement : elle sert à représenter un objet du monde réel (un joueur, un produit, un point…) en réunissant toutes ses caractéristiques au même endroit. La différence est que les champs sont déclarés à l'avance, avec leur type, dans le bloc classe … fin classe. Cela rend la structure de l'objet claire et lisible dès le début du programme.

Définir une classe

Une classe commence par classe suivi de son nom et de deux-points, puis liste ses champs (un par ligne), et se termine par fin classe.

classe joueur:
nom est un texte
score est un nombre
vie est un nombre
fin classe

Accéder aux champs

Après la définition, chaque champ s'utilise comme une variable, en le préfixant du nom de la classe et d'un point. On peut lui affecter une valeur, la lire, ou la modifier avec les raccourcis numériques (ajoute, soustrait…).

joueur.nom vaut 'Alice'
joueur.score vaut 100
joueur.score ajoute 50
affiche joueur.nom + ' : ' + joueur.score  // Alice : 150

Classe ou enregistrement ?

Les deux regroupent plusieurs informations sous un même nom. La différence est surtout pédagogique : avec l'enregistrement, les champs apparaissent au fur et à mesure des affectations ; avec la classe, on décrit d'abord le modèle complet (tous les champs et leurs types), puis on le remplit. La classe est donc utile pour poser clairement la structure d'un objet avant de l'utiliser.

Constante

Déclarer, affecter et manipuler les constantes

Qu'est-ce qu'une constante ?

Une constante est un nom associé à une valeur qui ne peut jamais changer.

Contrairement à une variable, une constante est immuable : sa valeur est fixée une fois pour toutes, toute tentative de modification provoque une erreur.

Les constantes servent à représenter : des valeurs fixes (ex : π, une limite, un message), des paramètres importants du programme, des données que l'on ne veut pas modifier par erreur.

Déclarer une constante

nom est une constante vaut <expression>

constante nom vaut <expression>

Exemples

min est une constante vaut 3.14

max est une constante vaut 100

message est une constante vaut 'Bonjour'

Utiliser une constante

affiche min

affiche max

affiche message

Date & Heure

Déclaration, affectation et affichage

Formats de référence

CoddyRun utilise des formats standards pour les dates et les heures :

jj/mm/aaaaFormat date : 25/12/2024

hh:mm:ssFormat heure : 14:30:00

Le format jj/mm/aaaa est le format européen (jour/mois/année), cohérent avec l'usage scolaire français.

Exemple de base

d est une date
h est une heure
d vaut aujourd_hui()
h vaut maintenant()
affiche 'Nous sommes le : ' + convertir_date(d)
affiche 'Il est : ' + convertir_heure(h)

Formater une date

d est une date
d vaut aujourd_hui()
affiche format_date(d, 'jj/mm/aaaa') // 31/05/2026
affiche format_date(d, 'jjjj j mmmm aaaa') // dimanche 31 mai 2026
affiche format_date(d, 'jjj jj mmm') // dim. 31 mai
affiche format_date(d, 'aa') // 26
affiche format_date('31/05/2026', 'aaaa-mm-jj') // 2026-05-31
// j : jour du mois (sans zéro)
// jj : jour du mois sur 2 chiffres
// jjj : jour de la semaine abrégé
// jjjj : jour de la semaine en entier
// mm : mois sur 2 chiffres
// mmm : mois abrégé
// mmmm : mois en entier
// aa : année sur 2 chiffres
// aaaa : année sur 4 chiffres

Entrée / Sortie

Afficher des résultats et lire des données saisies par l'utilisateur

L'interaction avec l'utilisateur est au cœur de tout programme interactif. affiche envoie une valeur vers la console, demande attend une saisie clavier, et choisir propose des options à sélectionner d'un simple clic. Ces instructions permettent de créer des programmes qui posent des questions, calculent, et répondent — le cycle fondamental de tout logiciel interactif.

affiche — écrire dans la console

Affiche peut prendre n'importe quelle valeur ou expression. Texte, nombre, variable, calcul — tout est accepté. Pour afficher plusieurs éléments sur une ligne, on les concatène avec +.

affiche 'Bonjour monde'Texte littéral

affiche xValeur d'une variable

affiche 2 + 2Expression calculée → 4

affiche 'x = ' + xConcaténation texte + variable

affiche t[0]Premier élément d'un tableau

demande — lire une saisie utilisateur

La variable doit être déclarée avant demande. Son type détermine la conversion automatique de la saisie : si c'est un nombre, la chaîne tapée est convertie en nombre; si c'est un texte, elle reste telle quelle.

x est un nombre

demande xAttend un nombre (sans message)

demande 'Entrez un nombre' dans xAvec message d'invite

n est un texte

demande 'Votre prénom ?' dans nSaisie de texte

Exemple d'utilisation de l'instruction demander

choisir — proposer des options cliquables

Contrairement à demande, l'utilisateur sélectionne d'un simple clic. Les options s'affichent comme des liens cliquables dans la console, et le numéro de l'option choisie (1 pour la première, 2 pour la deuxième…) est stocké dans la variable. La variable doit être déclarée comme un nombre.

                            x est un nombre
                            choisir ['Option 1', 'Option 2', 'Option 3'] dans x
                            selon x
                            cas 1 :
                            affiche 'Option 1'
                            cas 2 :
                            affiche 'Option 2'
                            cas 3 :
                            affiche 'Option 3'
                            fin selon
                            

                            menu est un tableau
                            choix est un nombre
                            menu ajoute 'Option 1'
                            menu ajoute 'Option 2'
                            menu ajoute 'Option 3'
                            choisir menu dans choix
                            

Boîte de dialogue de l'instruction choisir

appuyer — attend que l'utilisateur appuie sur une touche

                            action est un nombre
                            appuyer ['z', 's', 'd', 'q'] dans action
                            si action = 1 alors
                            affiche 'Avancer'
                            sinon si action = 2 alors
                            affiche 'Reculer'
                            sinon si action = 3 alors
                            affiche 'Droite'
                            sinon si action = 4 alors
                            affiche 'Gauche'
                            fin si
                            

Exemple d'utilisation de l'instruction appuyer

cliquer — attendre un clic sur la toile

La toile doit avoir été affichée avec affiche avant l'appel. Le programme se met alors en pause jusqu'au clic, puis range les coordonnées du point cliqué dans deux variables de type nombre : l'abscisse x, puis l'ordonnée y. L'origine (0, 0) est le coin haut-gauche de la toile.

maToile est une toile

x, y est un nombre

cliquer maToile dans x, yAttend un clic et récupère sa position

Combiné à la fonction clique, qui teste si un point tombe dans une zone, cliquer permet de fabriquer de véritables boutons : il suffit d'utiliser les mêmes valeurs pour dessiner la forme et pour tester la zone.

                            maToile est une toile
                            x, y est un nombre
                            dimension(maToile, 300, 200)
                            remplir(maToile, #0D1117)
                            // mêmes valeurs pour le dessin et pour le test
                            rectangle(maToile, 40, 80, 100, 45, #1976D2)
                            label(maToile, 60, 108, 'Jouer', #FFFFFF, 16)
                            affiche maToile

                            cliquer maToile dans x, y

                            si clique(x, y, 40, 80, 100, 45) alors
                            affiche 'Tu as cliqué sur le bouton !'
                            sinon
                            affiche 'Raté, à côté du bouton.'
                            fin si
                            

Exemple d'utilisation de l'instruction cliquer

interagir — attendre un clic ou une touche

interagir réunit cliquer et appuyer en une seule instruction : le premier événement qui arrive — un clic sur la toile ou une touche de la liste — débloque le programme. C'est l'instruction de base pour écrire un jeu qui se pilote à la souris comme au clavier.

Les trois variables doivent être des nombres.
• Clic sur la toile : action vaut 0, et x, y reçoivent les coordonnées du clic.
• Touche pressée : action vaut le numéro de la touche (1 pour la première de la liste, 2 pour la deuxième…), et x, y valent -1.

interagir maToile, ['z', 's', 'd', 'q'] dans action, x, yClic ou touche

                            maToile est une toile
                            action, x, y est un nombre
                            dimension(maToile, 300, 200)
                            remplir(maToile, #1E2430)
                            affiche maToile

                            interagir maToile, ['z', 's', 'd', 'q'] dans action, x, y

                            si action = 0 alors
                            affiche 'Clic en ' + x + ' ; ' + y
                            sinon
                            affiche 'Touche numéro ' + action
                            fin si
                            

Placée dans une boucle, cette instruction forme la boucle de jeu : on redessine la toile, on l'affiche, on attend l'action du joueur, puis on recommence.

                            maToile est une toile
                            action, x, y est un nombre
                            posX, posY est un nombre
                            posX vaut 150
                            posY vaut 100
                            dimension(maToile, 300, 200)

                            répète 20 fois
                            effacer(maToile)
                            cercle(maToile, posX, posY, 10, #FFD60A)
                            remplir(maToile, #1E2430)
                            affiche maToile
                            interagir maToile, ['z', 's', 'd', 'q'] dans action, x, y
                            selon action
                            cas 0 : // clic : on téléporte le cercle
                            posX vaut x
                            posY vaut y
                            cas 1 : posY vaut posY - 10
                            cas 2 : posY vaut posY + 10
                            cas 3 : posX vaut posX + 10
                            cas 4 : posX vaut posX - 10
                            fin selon
                            fin répète
                            

Exemple d'utilisation de l'instruction interagir

Souris et clavier sans attendre — jeux en temps réel

cliquer, appuyer et interagir bloquent le programme jusqu'à l'action du joueur. Les six fonctions ci-dessous, au contraire, lisent le dernier état connu de la souris ou du clavier et rendent la main tout de suite : le programme continue de tourner, ce qui permet d'écrire des jeux où la scène bouge pendant que le joueur agit.

souris_x(maToile)Position horizontale de la souris sur la toile, -1 hors de la toile

souris_y(maToile)Position verticale, -1 hors de la toile

souris_appuyée(maToile)Vrai tant que le bouton gauche est enfoncé sur la toile

souris_clic(maToile)Vrai une seule fois après un clic sur la toile, puis faux

touche_enfoncée('gauche')Vrai tant que la touche est maintenue

touche_pressée('espace')Vrai une seule fois par appui

Noms de touches (entre guillemets, en majuscules ou en minuscules) : une lettre ou un chiffre ('z', '5'…), les flèches 'haut', 'bas', 'gauche', 'droite', puis 'espace', 'entrée', 'échap'. Les noms anglais sont acceptés aussi : 'up', 'down', 'left', 'right', 'space', 'enter', 'escape'. Tout autre nom provoque une erreur.
Variantes sans accent : souris_appuyee, touche_enfoncee, touche_pressee.

Les règles à connaître :

La toile doit être affichée avec affiche pour que la souris soit suivie ; un clic en dehors de la toile ne compte pas.
Mets une pause de 30 à 60 ms dans la boucle : à chaque tour, la toile se rafraîchit et l'état de la souris et du clavier est mis à jour.
souris_clic et touche_pressée « consomment » l'événement : appelle-les une seule fois par tour, et range le résultat dans une variable booléenne si tu en as besoin à plusieurs endroits.
Les clics et appuis faits pendant un cliquer, appuyer, interagir ou demande ne sont pas comptés.
touche_enfoncée('gauche') est la flèche gauche du clavier, pas le bouton gauche de la souris : pour la souris, utilise souris_appuyée ou souris_clic.
Ces six fonctions sont autorisées dans un processus, puisqu'elles n'attendent pas.

Exemple : un carré piloté aux flèches, un viseur qui suit la souris, Échap pour quitter.

                            t est une toile
                            dimension(t, 300, 200)
                            x est un nombre
                            x vaut 140
                            tant que non touche_pressée('échap')
                            si touche_enfoncée('gauche') alors
                            x soustrait 6
                            fin si
                            si touche_enfoncée('droite') alors
                            x ajoute 6
                            fin si
                            effacer(t)
                            remplir(t, #0d1117)
                            rectangle(t, x, 90, 20, 20, #4dabf7)
                            si souris_x(t) >= 0 alors
                            cercle(t, souris_x(t), souris_y(t), 6, #ffd43b)
                            fin si
                            affiche t
                            pause 30
                            fin tant que
                            

Dans une boucle de jeu en temps réel, n'utilise pas cliquer, appuyer ou interagir : ils bloqueraient le jeu à chaque tour. Garde-les pour les menus, les quiz et les jeux au tour par tour.

saisie — une zone de texte dans la toile

saisie dessine une vraie zone de texte sur la toile, reliée à une variable de type texte ou nombre déjà déclarée. On construit ainsi de petits formulaires : un prénom, un âge, un bouton Valider.

saisie(maToile, prenom, 20, 42, 280, 32, 'Ex : Ada')toile, variable, x, y, largeur, hauteur [, indication]

1. On dessine les zones et un bouton (rectangle + label), puis affiche maToile.
2. L'utilisateur tape dans les zones ; la touche Entrée passe à la zone suivante.
3. Quand cliquer (ou interagir) se débloque sur cette toile, chaque variable reçoit le texte tapé dans sa zone. On teste ensuite le bouton avec clique.
Il n'existe aucune fonction pour lire la zone : on lit directement la variable. Un clic ou une touche tapés dans une zone ne débloquent pas l'attente.

                            maToile est une toile
                            dimension(maToile, 320, 200)
                            remplir(maToile, #FFFFFF)
                            prenom est un texte
                            x, y est un nombre
                            saisie(maToile, prenom, 20, 42, 280, 32, 'Ex : Ada')
                            rectangle_arrondi(maToile, 200, 140, 100, 36, 8, #1D9BF0)
                            label(maToile, 222, 164, 'Valider', #FFFFFF)
                            affiche maToile
                            valide est un booléen
                            tant que non valide
                            cliquer maToile dans x, y
                            valide vaut clique(x, y, 200, 140, 100, 36)
                            fin tant que
                            affiche 'Bonjour ' + prenom
                            

Variable nombre : une zone vide donne 0 ; un texte qui n'est pas un nombre déclenche une erreur au moment du cliquer (« Saisie invalide pour… »), et la zone se borde de rouge pendant la frappe. Entoure l'attente de essayer / attraper, ou déclare la variable comme texte et vérifie-la avec est_nombre.
Pré-remplir ou vider : la zone montre la valeur de sa variable quand la toile est affichée. Change la variable (prenom vaut '') puis refais affiche maToile. Le texte tapé est conservé quand la toile est redessinée.
Le 2^e argument est le nom d'une variable simple : pas une valeur entre guillemets, ni une constante, ni un champ (a.b), ni une case de tableau (t[0]). Largeur et hauteur valent au moins 10.

Commentaires — documenter son code

Un commentaire commence par // et s'étend jusqu'à la fin de la ligne.

Pour les commentaires sur plusieurs lignes, on utilise les accolades { } : tout ce qui se trouve entre elles est ignoré lors de l'exécution.

Les commentaires servent à expliquer le code — aux autres, mais surtout à soi-même quand on relit un programme plus tard. C'est une bonne habitude à prendre dès le début.

// Ceci est un commentaire — ignoré à l'exécution

affiche x // peut aussi suivre une instruction

{

                                Ceci est un commentaire 

                                sur plusieurs lignes

                                }

Sections — se repérer dans un long programme

Une ligne qui commence par @ suivi d'un titre marque une section du code. Elle ne change rien à l'exécution, mais aide à s'y retrouver quand le programme s'allonge.

@ Déclaration des variablesTitre de section

Instruction terminer

terminer permet d'arrêter immédiatement le programme.

Quand l'instruction terminer est exécutée : le programme s'arrête, aucune autre instruction n'est exécutée, on sort définitivement du programme.

pour i de 1 a 10
si i = 5 alors
terminer
fin si
affiche i
fin pour
affiche 'Ce message ne sera jamais affiché'

Gestion des erreurs

Anticiper et intercepter les erreurs d'exécution sans interrompre le programme

Dans un programme, certaines instructions peuvent provoquer des erreurs : division par zéro, variable inconnue, accès hors limites dans un tableau. Par défaut, une erreur arrête le programme immédiatement. La structure essayer / attraper permet de prévoir ces situations et de réagir proprement, sans faire planter tout le programme.

Structure de base

Le bloc essayer contient le code à risque. Si une erreur survient, l'exécution saute immédiatement dans le bloc attraper — les instructions suivantes du bloc essayer sont ignorées. Après le bloc attraper, le programme reprend normalement.

essayer
affiche 10 / 0
affiche 'ce texte ne sera jamais affiché'
attraper
affiche 'Une erreur est survenue'
fin essayer
affiche 'Le programme continue'

Le programme ne plante pas : après le bloc attraper, l'exécution reprend à la ligne suivant fin essayer.

Récupérer le message d'erreur

En nommant une variable après attraper, on peut lire le message d'erreur exact et l'afficher ou le traiter dans le programme.

essayer
affiche x
attraper erreur
affiche 'Erreur détectée : ' + erreur
fin essayer

Essayer imbriqué

Les blocs essayer peuvent être imbriqués. Chaque niveau gère ses propres erreurs indépendamment — une erreur dans le bloc interne ne remonte pas au bloc externe si elle est attrapée.

essayer
essayer
affiche 10 / 0
attraper e1
affiche 'Erreur interne : ' + e1
fin essayer
attraper e2
affiche 'Erreur externe : ' + e2
fin essayer

Si l'erreur interne est attrapée par le premier attraper, le bloc attraper externe ne s'exécute pas.

Cas d'usage typiques

Division par zéro

Protéger un calcul dont le diviseur vient d'une saisie utilisateur et pourrait valoir 0.

Accès à une variable inconnue

Tenter d'accéder à une variable qui n'a pas encore été déclarée ou initialisée.

Index hors limites

Accéder à un index de tableau qui n'existe pas (ex : t[10] sur un tableau de 3 éléments).

Conversion impossible

Appeler convertir_nombre('abc') sur un texte qui ne peut pas être converti en nombre.

essayer / attraper ne doit pas servir à masquer des erreurs de logique. Si une erreur survient souvent au même endroit, mieux vaut corriger la cause avec une condition (si) plutôt que de simplement l'ignorer avec attraper.

Opérateurs

Arithmétiques, comparaisons, logiques et priorités

Les opérateurs permettent de calculer (arithmétiques), comparer (relationnels) et combiner des conditions (logiques). Il est important de comprendre leur priorité : certains opérateurs s'évaluent avant d'autres, tout comme en mathématiques (la multiplication avant l'addition). En cas de doute, on peut toujours utiliser des parenthèses pour forcer l'ordre d'évaluation.

Addition / ConcaténationPour les nombres : 3 + 4 = 7. Pour les textes : 'Bon' + 'jour' = 'Bonjour'

SoustractionUniquement entre nombres. Erreur si appliqué à des textes.

MultiplicationNombre × Nombre uniquement

DivisionRésultat décimal. Provoque une erreur si le diviseur est 0.

mod

Modulo (reste de division)8 mod 3 = 2. Aussi écrit %. Très utile pour tester la parité (n mod 2 = 0) ou créer des cycles.

Égalité (comparaison)Retourne vrai ou faux. En CoddyRun, = compare — pour affecter, on utilise le mot-clé vaut.

Différent deVrai si les deux valeurs sont différentes

< >

Inférieur / Supérieur strictComparaison stricte : 5 < 5 est faux, 4 < 5 est vrai

<= >=

Inférieur ou égal / Supérieur ou égalComparaison inclusive : 5 <= 5 est vrai

ET logiqueVrai uniquement si les deux conditions sont vraies simultanément

OU logiqueVrai si au moins l'une des conditions est vraie

non

Négation logiqueInverse un booléen : non vrai = faux, non (x > 5) = (x <= 5)

Priorité des opérateurs (du plus fort au plus faible)

Quand une expression contient plusieurs opérateurs, ils ne sont pas évalués de gauche à droite : certains ont une priorité plus élevée. Voici l'ordre, du plus prioritaire au moins prioritaire :

1. nonNégation unaire — évalué en premier

2. * / modMultiplication, division, modulo

3. + -Addition, soustraction (et concaténation de textes)

4. = <> < > <= >=Comparaisons

5. etET logique

6. ouOU logique — le moins prioritaire

// En cas de doute, utilisez des parenthèses : (a + b) * c

Conditions

Prendre des décisions avec si / sinon / fin si

Une structure conditionnelle permet au programme de prendre des décisions en fonction d'une condition. Si la condition est vraie, on exécute un bloc d'instructions ; sinon, on en exécute éventuellement un autre. C'est le mécanisme fondamental qui donne au programme un comportement différent selon les données.

si … alors … fin si — la forme simple

Exécute le bloc seulement si la condition est vraie. Si elle est fausse, rien ne se passe et l'exécution continue après fin si.

si age >= 18 alors
affiche 'Vous êtes majeur.'
fin si

si … sinon … fin si — deux branches

L'une des deux branches est toujours exécutée. Si la condition est vraie → bloc alors ; sinon → bloc sinon. Les deux branches s'excluent mutuellement.

si x mod 2 = 0 alors
affiche 'pair'
sinon
affiche 'impair'
fin si

si imbriqués — plusieurs cas

On peut imbriquer des structures si pour traiter plus de deux cas. Chaque si doit avoir son propre fin si. L'indentation aide à visualiser quelle fin si ferme quel si.

si note >= 16 alors
affiche 'Très bien'
sinon
si note >= 12 alors
affiche 'Bien'
sinon
affiche 'À améliorer'
fin si
fin si

si age < 12 alors
afficher('Tu es un enfant')
sinon si age < 18 alors
afficher('Tu es un adolescent')
sinon
afficher('Tu es un adulte')
fin si

Conditions composées avec et / ou / non

On peut combiner plusieurs conditions dans un même si avec et (les deux doivent être vraies), ou (au moins l'une doit être vraie), et non (inverse la condition). Les parenthèses aident à lever toute ambiguïté.

si x > 0 et x < 10 alors
affiche 'entre 0 et 10 (exclus)'
fin si
si non (age >= 18) alors
affiche 'mineur'
fin si

Structure SELON / CAS

La structure selon permet de choisir une action parmi plusieurs possibilités, en fonction de la valeur d'une variable ou d'une expression.

note est un nombre
note vaut 18
// je regarde la valeur
selon note
cas 18, 19, 20 :
affiche 'Parfait'
// je compare avec une valeur précise
cas 10 :
affiche 'Moyen'
// aucun cas ne correspond
sinon selon :
affiche 'À améliorer'
// la structure est terminée
fin selon

Boucles

Répéter des instructions avec pour, tant que et répète

Une boucle permet d'exécuter plusieurs fois le même bloc d'instructions sans le réécrire. C'est l'un des concepts les plus puissants de la programmation : grâce aux boucles, un programme de 10 lignes peut effectuer des millions d'opérations. CoddyRun propose trois structures adaptées à différents contextes.

pour … de … à … fin pour — nombre d'itérations connu

Utilisez pour quand vous savez à l'avance combien de fois la boucle doit s'exécuter. La variable de contrôle (i) prend automatiquement les valeurs de départ à fin, de 1 en 1 par défaut. Le mot-clé pas permet de changer l'incrément — y compris en négatif pour parcourir à rebours.

// Affiche 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
pour i de 1 à 10
affiche i
fin pour
// Pas personnalisé : affiche 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20
pour i de 0 à 20 pas 2
affiche i
fin pour
// Boucle décroissante
pour i de 5 à 1 pas -1
affiche i
fin pour

Le pas ne peut pas être 0 — cela provoquerait une boucle infinie. Pour parcourir à rebours, utilisez un pas négatif : pas -1.

tant que … fin tant que — condition de continuation

Utilisez tant que quand le nombre d'itérations n'est pas connu à l'avance — par exemple, répéter jusqu'à ce que l'utilisateur saisisse une valeur correcte, ou jusqu'à ce qu'un compteur atteigne un certain seuil.

x est un nombre
x vaut 1
tant que x <= 100
affiche x
x ajoute 1
fin tant que

Assurez-vous que la condition finit par devenir fausse ! Oublier de modifier la variable de condition à l'intérieur de la boucle provoque une boucle infinie qui bloque le programme.

répète … fois … fin répète — nombre fixe, sans variable

La forme la plus simple : répéter exactement N fois, sans avoir besoin d'une variable de contrôle. Idéale pour les actions répétitives simples (afficher un message N fois, dessiner une figure, etc.).

répète 5 fois
affiche 'tic'
fin répète

Boucles imbriquées

On peut placer une boucle à l'intérieur d'une autre. Pour chaque itération de la boucle extérieure, la boucle intérieure s'exécute entièrement. C'est la base des algorithmes sur des structures à deux dimensions (tableaux 2D, tables de multiplication, matrices).

// Table de multiplication complète
pour i de 1 à 5
pour j de 1 à 5
affiche i + ' × ' + j + ' = ' + (i * j)
fin pour
fin pour

continue — passer à l'itération suivante

continue sert à ignorer le reste de la boucle pour l'itération en cours et à passer directement à l'itération suivante.

// Explication :
// quand i = 3, le programme rencontre continue
// il saute l'affichage
// il passe directement à i = 4
pour i de 1 a 5
si i = 3 alors
continue
fin si
affiche i
fin pour

La boucle ne s'arrête pas, elle continue, mais sans exécuter les lignes suivantes.

À retenir pour continue : continue ne sort pas de la boucle il saute seulement le reste de l'itération actuelle, il est utile pour ignorer certains cas.

arrête — sortir de la boucle

arrête sert à arrêter complètement la boucle en cours.

// Explication :
// quand i = 4, la condition est vraie
// arrête met fin à la boucle
// les valeurs 5 à 10 ne sont jamais exécutées
pour i de 1 a 10
affiche i
si i = 4 alors
arrête
fin si
fin pour

Une fois arrête exécuté : la boucle se termine immédiatement, le programme continue après la boucle

À retenir pour arrête : arrête sort définitivement de la boucle, les instructions suivantes dans la boucle ne sont plus exécutées, il sert à mettre fin à une répétition quand une condition est remplie.

Tableaux

Listes dynamiques à index numérique (l'index commence à 0)

Un tableau est une variable qui contient plusieurs valeurs, accessibles par leur position (index). En CoddyRun, les tableaux sont dynamiques : on peut y ajouter ou supprimer des éléments à tout moment. L'index commence à 0 (le premier élément est t[0], le deuxième t[1], etc.) — une convention universelle dans la quasi-totalité des langages de programmation.

Opérations de base

t est un tableauCréer un tableau vide []

t ajoute 42Ajouter 42 en fin de tableau

t[0] vaut 99Modifier l'élément à l'index 0

affiche t[0]Lire la valeur à l'index 0

t supprime 2Supprimer l'élément à l'index 2

vide tVider entièrement le tableau

Parcourir un tableau avec une boucle

Le pattern classique pour accéder à chaque élément d'un tableau : une boucle pour allant de 0 à longueur(t) - 1. La fonction longueur retourne le nombre d'éléments, donc le dernier index valide est toujours longueur - 1.

t est un tableau
t ajoute 10
t ajoute 20
t ajoute 30
pour i de 0 à longueur(t) - 1
affiche 't[' + i + '] = ' + t[i]
fin pour

Extension automatique par affectation directe

Affecter directement une valeur à un index inexistant étend automatiquement le tableau. Les éléments intermédiaires sont initialisés à une chaîne vide. Cela peut être pratique, mais peut aussi provoquer des surprises si on n'y prend pas garde.

t est un tableau
t[5] vaut 'saut'
affiche longueur(t) // → 6
// t[0] à t[4] contiennent '' (texte vide)

Tableau à 2 dimensions

Un tableau à 2 dimensions (souvent appelé "grille" ou "matrice") est un tableau qui contient d’autres tableaux.

- Chaque élément du tableau principal représente une ligne

- Chaque ligne est un tableau qui contient plusieurs cases (colonnes)

Important :

- L’index commence à 0 (premier élément = t[0]).

- Pour parcourir un tableau, on utilise souvent une boucle de 0 à longueur(t) - 1.

Pour une grille 2D, on utilise généralement deux boucles imbriquées (lignes puis colonnes).

// Création d’un tableau (matrice)
t est un tableau
// Dimensions
lignes vaut 3
colonnes vaut 4
// Remplissage de la matrice avec deux boucles imbriquées
pour i de 0 à lignes - 1
pour j de 0 à colonnes - 1
t[i][j] vaut i * 10 + j
fin pour
fin pour
// Affichage de la matrice
affiche 'Contenu de la matrice :'
pour i de 0 à lignes - 1
pour j de 0 à colonnes - 1
affiche 't[' + i + '][' + j + '] = ' + t[i][j]
fin pour
fin pour

Définir dynamiquement la taille d’un tableau

La fonction taille permet de définir ou modifier dynamiquement la taille d’un tableau.

t est un tableau
taille(t, 5)
t[0] vaut 10
t[4] vaut 99
affiche 'Taille de t = ' + longueur(t)
affiche 't[4] = ' + t[4]
taille(t, 2)
affiche 'Taille de t = ' + longueur(t)
affiche 't[0] = ' + t[0]

si n est supérieur à la taille actuelle :

- le tableau est agrandi

- les nouvelles cases reçoivent une valeur par défaut

si n est inférieur :

- les éléments excédentaires en fin de tableau sont supprimés

- si le tableau est vide, il est automatiquement initialisé

Dictionnaire

Collection de valeurs accessibles par clé (paires clé → valeur)

Un dictionnaire est une variable qui associe des clés à des valeurs. Contrairement au tableau, où l'on accède aux éléments par un index numérique, ici chaque valeur est retrouvée grâce à sa clé (par exemple un texte comme 'nom'). Les dictionnaires sont dynamiques : on peut ajouter, modifier ou supprimer des clés à tout moment.

Opérations de base

Dico est un dictionnaireCréer un dictionnaire vide

Dico vaut ['nom': 'Jean', 'age': 25]Initialiser avec des paires clé → valeur

affiche Dico['nom']Lire une valeur par sa clé

Dico['ville'] ajoute 'Paris'Ajouter une nouvelle clé

Dico['age'] vaut 26Modifier la valeur d'une clé existante

Dico supprime 'nom'Supprimer une clé

affiche longueur(Dico)Nombre de clés du dictionnaire

affiche contient(Dico, 'ville')Tester l'existence d'une clé (vrai / faux)

clés(Dico)Récupérer la liste des clés

Créer et lire un dictionnaire

On déclare un dictionnaire, puis on l'initialise avec des paires 'clé' : valeur. Chaque valeur se lit ensuite grâce à sa clé, placée entre crochets.

Dico est un dictionnaire
Dico vaut ['nom': 'Jean', 'age': 25]
// Lire une valeur par clé
affiche Dico['nom'] // Jean
affiche Dico['age'] // 25

Ajouter, modifier et supprimer une clé

On peut faire évoluer le dictionnaire à tout moment : ajouter une nouvelle clé avec ajoute, changer une valeur avec vaut, ou retirer une clé avec supprime.

// Ajouter / modifier une clé
Dico['ville'] ajoute 'Paris'
Dico['age'] vaut 26
// Supprimer une clé
Dico supprime 'nom'
// Nombre de clés
affiche longueur(Dico) // 2
// Tester l'existence d'une clé
affiche contient(Dico, 'ville') // vrai

Parcourir les clés d'un dictionnaire

La fonction cles retourne un tableau contenant toutes les clés du dictionnaire. On peut alors le parcourir avec une boucle pour pour accéder à chaque paire clé → valeur.

Liste est un tableau
Liste vaut clés(Dico)
pour i de 0 à longueur(Liste) - 1
affiche Liste[i] + ' = ' + Dico[Liste[i]]
fin pour

Fonctions

Sous-programmes qui calculent et retournent une valeur

Une fonction est un bloc de code nommé qui prend des paramètres en entrée, effectue un traitement, et retourne une valeur. Les fonctions permettent de découper un programme en sous-problèmes, de réutiliser du code sans le réécrire, et de rendre les programmes plus lisibles et plus faciles à déboguer. En CoddyRun, les fonctions peuvent être définies n'importe où — le moteur les pré-scanne toutes avant de commencer l'exécution.

Définition & appel

fonction addition(xa, xb)
retourne xa + xb
fin fonction
// Appel : le résultat est stocké dans r
r est un nombre
r vaut addition(3, 7)
affiche r // → 10
// On peut aussi appeler directement dans affiche
affiche addition(100, 200) // → 300

Fonctions avec conditions

Une fonction peut contenir n'importe quelle structure du langage. Ici, deux branches de retour : l'une si a > b, l'autre sinon. La première instruction retourne rencontrée arrête l'exécution de la fonction.

fonction maximum(xa, xb)
si xa > xb alors
retourne xa
sinon
retourne xb
fin si
fin fonction
affiche maximum(8, 13) // → 13

Fonctions récursives

Une fonction peut s'appeler elle-même — c'est la récursivité. C'est un concept avancé mais très élégant pour certains problèmes. La clé est toujours le cas de base : une condition qui arrête la récursion (ici n <= 1), sans laquelle la fonction s'appellerait infiniment.

fonction factorielle(n)
si n <= 1 alors
retourne 1 // cas de base
fin si
retourne n *  factorielle(n - 1) // appel récursif
fin fonction
affiche factorielle(5) // → 120 (5×4×3×2×1)

Les fonctions peuvent être définies n'importe où dans le fichier (avant ou après leur premier appel). Le pré-scan de l'interpréteur les enregistre toutes avant de commencer l'exécution — cette souplesse évite d'avoir à s'interroger sur l'ordre de déclaration.

Procédures

Sous-programmes qui effectuent des actions sans retourner de valeur

Une procédure ressemble à une fonction, mais elle n'a pas de valeur de retour. Elle effectue des actions (afficher, modifier un tableau, interagir avec l'utilisateur) sans produire de résultat qu'on peut utiliser dans une expression. En CoddyRun, les procédures se définissent avec procédure et s'appellent avec appelle.

Définition & appel

procédure saluer(prénom)
affiche 'Bonjour ' + prénom + ' !'
fin procédure
appelle saluer('Alice') // → Bonjour Alice !
appelle saluer('Bob') // → Bonjour Bob !

Différences fonction / procédure

Le choix entre fonction et procédure dépend du besoin : si on veut un résultat réutilisable (dans un calcul, une condition, un affichage), on utilise une fonction. Si on veut effectuer une action sans s'attendre à un résultat (afficher, remplir un tableau, etc.), on utilise une procédure.

Critère	Fonction	Procédure
Mot-clé début	`fonction`	`procédure`
Mot-clé fin	`fin fonction`	`fin procédure`
Retourne une valeur	Oui (`retourne`)	Non
Utilisable dans expression	Oui : `x vaut f(3)`	Non
Mode d'appel	Direct ou avec `appelle`	Obligatoirement avec `appelle`

Processus

Une tâche de fond qui s'exécute en parallèle du programme principal

Un processus est un bloc de code qui tourne en parallèle du programme principal, comme une tâche de fond. On le démarre par un simple appel — MonProcessus() — qui rend la main immédiatement : le programme continue son chemin pendant que le processus travaille. C'est l'outil idéal pour animer une toile toute seule, faire avancer une horloge ou mettre à jour des variables en arrière-plan, sans bloquer le dialogue avec l'utilisateur.

Définition & démarrage

La définition ressemble à celle d'une procédure : processus suivi d'un nom, puis fin processus. Le processus partage les variables du programme, il peut donc lire et modifier ce qui a été déclaré avant lui.

processus Compteur()
n est un nombre
n vaut 0
tant que vrai
n ajoute 1
affiche n
pause 500
fin tant que
fin processus

Compteur()

Le rythme : pause

Dans la boucle d'un processus, pause donne son rythme à l'animation et rend la main au programme principal. Une pause 100 correspond à dix images par seconde. La durée est exprimée en millisecondes (1000 = une seconde) et ramenée entre 30 et 3000 ms.

pause 30Le plus rapide autorisé

pause 100Dix images par seconde, fluide pour une animation

pause 500Deux fois par seconde

pause 1000Une fois par seconde, rythme d'une horloge

Dans le programme principal, pause attend en laissant vivre le processus et active l'affichage progressif : ce qui a été affiché avant la pause apparaît tout de suite.

Animer une toile pendant que le programme écoute le clavier

C'est l'usage le plus courant : le processus redessine la toile en boucle, pendant que le programme principal attend une touche. Quand le processus redessine avec affiche, l'image est remplacée en place, donc cliquer et interagir restent actifs dans le programme principal.

t est une toile
dimension(t, 300, 200)
x est un nombre
x vaut 0

processus Balle()
tant que vrai
x ajoute 5
si x > 300 alors
x vaut 0
fin si
effacer(t)
cercle(t, x, 100, 10, #ffd43b)
affiche t
pause 100
fin tant que
fin processus

Balle()
action est un nombre
tant que vrai
appuyer ['e'] dans action
terminer
fin tant que

Suspendre & reprendre

suspendre met le processus en pause : il ne s'exécute plus mais garde sa position et ses variables. reprendre le relance exactement là où il s'était arrêté. Le nom entre les parenthèses est facultatif, puisqu'il n'y a qu'un processus par programme.

processus Horloge()
tant que vrai
affiche maintenant()
pause 1000
fin tant que
fin processus

Horloge()
nom est un texte
suspendre Horloge()
demande 'Ton prénom ?' dans nom
reprendre Horloge()
affiche 'Bonjour ' + nom

suspendre et reprendre restent sans effet si aucun processus n'est en cours ou s'il n'est pas suspendu. Pour redémarrer un processus terminé, il suffit de l'appeler à nouveau.

Les règles à connaître

Un seul processus par programme

Un appel lancé pendant qu'il tourne déjà est simplement ignoré : le processus ne démarre jamais deux fois.

Aucun dialogue avec l'utilisateur

demande, choisir, appuyer, cliquer et interagir y sont interdits : seul le programme principal parle à l'utilisateur.

Toujours une pause dans la boucle

Sans pause, le processus monopolise le programme. C'est elle qui lui donne son rythme et laisse le programme principal travailler.

Fin du programme

Le programme attend la fin du processus avant de se terminer. terminer ou le bouton Stop coupent tout immédiatement.

Récapitulatif des mots-clés

processus Nom()Ouvre la définition du processus

fin processusFerme la définition

Nom()Démarre le processus et rend la main aussitôt

pause 100Donne son rythme à la boucle (30 à 3000 ms)

suspendre Nom()Met le processus en pause sans perdre son état

reprendre Nom()Le relance là où il s'était arrêté

terminerArrête le programme et le processus

processusfin processuspausesuspendrereprendre

Fonctions intégrées

Disponibles sans déclaration, directement dans vos expressions

CoddyRun fournit une bibliothèque de fonctions prêtes à l'emploi couvrant les opérations mathématiques courantes, la manipulation de texte, les opérations sur les tableaux, la date/heure et quelques utilitaires de conversion. Toutes ces fonctions s'utilisent comme n'importe quelle autre : racine(9) retourne 3, longueur('bonjour') retourne 7, etc.

Mathématiques

racine(x) math

Racine carrée de x. Retourne un nombre décimal si x n'est pas un carré parfait. racine(9) → 3, racine(2) → 1.414…

absolue(x) math

Valeur absolue : supprime le signe négatif. absolue(-5) → 5, absolue(3) → 3. Utile pour calculer des distances.

arrondi(x) math

Arrondi à l'entier le plus proche (règle standard : .5 arrondit vers le haut). arrondi(3.7) → 4, arrondi(3.2) → 3

hasard(n) math

Entier aléatoire entre 0 et n inclus. Chaque appel peut donner un résultat différent — utile pour les jeux et simulations.

hasard(min, max) math

Entier aléatoire entre min et max inclus. hasard(1, 6) simule un lancer de dé à 6 faces.

minimum(a, b) math

Retourne le plus petit des deux arguments. Équivalent à écrire un si a < b alors retourne a sinon retourne b.

maximum(a, b) math

Retourne le plus grand des deux arguments.

puissance(a, b) math

Calcule a à la puissance b (aᵇ).

décimal(x, n) math

Arrondir un nombre à n décimales. décimal(3.14159265358979, 2) → 3.14

sinus(x) math

Retourne le sinus de x (en radians). sinus(3.14159)

cosinus(x) math

Retourne le cosinus de x (en radians). cosinus(3.14159)

tangente(x) math

Retourne la tangente de x (en radians), erreur si cosinus(x) = 0 tangente(45 * pi / 180)

logarithme(x) math

Retourne le logarithme naturel (base e) de x, x doit être > 0 logarithme(2.71828) → ≈ 1

pi() math

Retourne la valeur de π (3.14159265358979). pi() → 3.14159265358979

pair(n) math

Retourne vrai si le nombre est pair. pair(7) → faux

impair(n) math

Retourne vrai si le nombre est impair. impair(3) → vrai

pourcentage(n1, n2) math

Retourne le % que représente valeur sur total.

arrondi_supérieur(n) math

Retourne le plus petit entier supérieur ou égal à x (plafond).

arrondi_inférieur(n) math

Retourne le plus grand entier inférieur ou égal à x (plancher).

signe(n) math

Retourne 1 si le nombre est positif, -1 s'il est négatif, 0 s'il est nul.

factorielle(n) math

Retourne la factorielle d'un entier positif (n! = 1 × 2 × … × n).

pgcd(n1, n2) math

Retourne le plus grand commun diviseur (PGCD) de deux entiers.

évaluer(expression) math

Évaluer une expression mathématique donnée sous forme de texte et retourne le résultat numérique.

arcsinus(radians) math

Retourne l'arc sinus de x : l'angle (en radians) dont le sinus vaut x.

arccosinus(radians) math

Retourne l'arc cosinus de x : l'angle (en radians) dont le cosinus vaut x.

arctangente(x) math

Retourne l'arc tangente de x, en radians.

radians(angle) math

Convertit un angle exprimé en degrés en radians.

hypoténuse(a, b) math

Retourne la longueur de l'hypoténuse d'un triangle rectangle de côtés a et b.

Texte

longueur(texte) texte

Nombre de caractères dans le texte. Les espaces et la ponctuation comptent. longueur('abc') → 3, longueur('bonjour monde') → 13

majuscule_initiale(texte) texte

Met la première lettre en majuscule. majuscule_initiale('bonjour') → 'Bonjour'. de la casse.

majuscules(texte) texte

Convertit tous les caractères en majuscules. majuscules('bonjour') → 'BONJOUR'. Utile pour comparer des chaînes sans tenir compte de la casse.

minuscules(texte) texte

Convertit tous les caractères en minuscules. minuscules('BONJOUR') → 'bonjour'.

inverser(texte) texte

Inverse l'ordre des caractères. inverser('abc') → 'cba'. Utile pour détecter les palindromes.

contient(texte, mot) texte

Cherche si mot apparaît dans texte, sans tenir compte de la casse. Retourne vrai ou faux.

remplacer(texte, ancien, nouveau) texte

Remplace toutes les occurrences de ancien par nouveau dans le texte. Retourne le texte modifié (n'altère pas l'original).

supprime_espace(texte) texte

Supprime les espaces en début et en fin de texte (trim). Indispensable pour nettoyer les saisies utilisateur avant de les comparer.

repeter_texte(texte, n) texte

Répète le texte n fois (maximum 10 000). repeter_texte('*', 5) → '*****'. Idéal pour dessiner des formes dans la console.

hasardtexte(v1, v2, …) texte

Retourne aléatoirement l'un des arguments fournis. hasardtexte('Pierre', 'Feuille', 'Ciseaux') simule un choix aléatoire.

commence_par(texte, prefixe) texte

Vérifie si un texte commence par un certain mot ou groupe de caractères. commence_par('Bonjour', 'Bon') // vrai

termine_par(texte, suffixe) texte

Vérifie si un texte se termine par un certain mot ou groupe de caractères. termine_par('Bonjour', 'Bon') // faux

compter(texte, motif) texte

Compte combien de fois un motif apparaît dans un texte. compter('banana', 'a') // 3

copier(texte, debut, longueur) texte

Copier extrait une partie d'un texte. copier('bonjour', 4, 4) // 'jour'

caractère(65) texte

Convertit un code ASCII en caractère. caractère(65) // A

code('A') texte

Convertit un code ASCII en caractère. code('A') // 65

position(motif, texte) texte

Position sert à chercher un motif (un mot, une lettre, un morceau de texte) à l’intérieur d’une chaîne, et à renvoyer l’endroit (la position) où ce motif commence. position('jour', texte) // texte = bonjour → 4

insertion(texte, position, morceau) texte

Ajoute un texte à l’intérieur d’une chaîne, à une position donnée. insertion('jour', 1, Bon) // Bonjour

chiffres(texte) texte

Récupére uniquement les caractères numériques présents dans un texte. chiffres('23ABC10') // 2310

lettres(texte) texte

Récupérer uniquement les caractères alphabétiques présents dans un texte. lettres('23ABC10') // ABC

normaliser(texte) texte

Supprime les accents et caractères spéciaux d'un texte en les remplaçant par leur équivalent ASCII. affiche normaliser('éàü') // eau

expression(motif, texte) texte

Recherche un motif (expression régulière) dans un texte. expression('\w+@\w+\.\w+', texte)

retirer(texte, motif) texte

Supprime toutes les occurrences d'un motif.

supprimer(position, texte) texte

Supprime le caractère situé à une position donnée dans un texte.

uid() texte

Génère un identifiant unique aléatoire.

compter_mots(texte) texte

Retourne le nombre de mots d'un texte.

similaire(t1, t2, seuil) texte

Compare deux textes et retourne vrai s'ils se ressemblent suffisamment.

Tableaux

longueur(tableau) tableau

Retourne le nombre d'éléments dans le tableau.

taille(tableau, n) tableau

Permet de définir ou modifier dynamiquement la taille d’un tableau. taille(t, 2)

premier(tableau) tableau

Retourne le premier élément (index 0). Équivalent à t[0] mais plus lisible. Provoque une erreur si le tableau est vide — vérifiez avec longueur(t) > 0 avant.

dernier(tableau) tableau

Retourne le dernier élément. Équivalent à t[longueur(t) - 1] mais plus concis. Provoque une erreur si le tableau est vide.

mélanger(tableau) tableau

Mélange les éléments en place de façon aléatoire (algorithme Fisher-Yates). Le tableau original est modifié. Utile pour les jeux de cartes, les quizz à ordre aléatoire, etc.

contient(tableau, valeur) tableau

Vérifie si la valeur est présente dans le tableau. Retourne vrai ou faux. Plus simple qu'une boucle de recherche manuelle.

liste_tableau(tableau) tableau

Affiche chaque élément sous la forme [0] = val. Très pratique pour déboguer l'état d'un tableau sans écrire une boucle d'affichage.

découper(texte, séparateur) tableau

Permet de couper un texte en plusieurs morceaux à chaque fois qu'on rencontre un séparateur. mots vaut découper('pomme,poire,banane', ',')

joindre(tableau, séparateur) tableau

Assemble les éléments d'un tableau en un texte. affiche joindre(t, ', ')

trier(tableau) tableau

Trie les éléments d'un tableau par ordre croissant (par défaut). trier(t) // Ordre décroissant : trier(t, 'desc')

unique(tableau) tableau

Retourne un nouveau tableau sans doublons. unique(t)

somme(tableau) tableau

Retourne la somme de tous les éléments d'un tableau de nombres.

moyenne(tableau) tableau

Retourne la moyenne de tous les éléments d'un tableau de nombres.

fusionner(t1, t2) tableau

Retourne un nouveau tableau contenant tous les éléments de deux tableaux mis bout à bout.

médiane(tableau) tableau

Retourne la médiane d'un tableau de nombres (valeur centrale).

index_de(tableau) tableau

Cherche une valeur dans un tableau et retourne sa position (0 si absente).

intervalle(n1, n2) tableau

Génère un tableau d'entiers consécutifs du début à fin inclus.

assembler(t1, t2) tableau

Regroupe plusieurs tableaux élément par élément.

Dictionnaire

clés(dictionnaire) Dictionnaire

Retourne un tableau contenant toutes les clés du dictionnaire.

longueur(dictionnaire) Dictionnaire

Retourne le nombre de clés que contient le dictionnaire.

contient(clé) Dictionnaire

Vérifie si une clé existe dans le dictionnaire.

fusionner(dict1, dict2) Dictionnaire

Fusionne deux dictionnaires en un nouveau.

Enregistrement

existe(enregistrement, champ) Enregistrement

Vérifier si un champ existe dans un enregistrement.

champs(enregistrement) Enregistrement

Affiche la liste des champs contenus dans un enregistrement.

supprime_champ(enregistrement, champ) Enregistrement

Supprimer un champ précis d’un enregistrement.

Date & Heure

aujourd_hui() Heure

Date actuelle au format jj/mm/aaaa. Retourne une date

hier() Date

Renvoie la date d’hier, c’est-à-dire la veille de la date d’aujourd’hui.

demain() Date

Renvoie la date de demain, c’est-à-dire le lendemain de la date d’aujourd’hui.

maintenant() Heure

Heure actuelle au format hh:mm:ss. Retourne une heure

jours_entre(date1, date2) Date

Renvoie le nombre de jours entre deux dates.

jour_semaine(date) Date

Retourne le numéro du jour dans la semaine (norme ISO).

année_de(date) Date

Retourne l'année d'une date sous forme de nombre.

mois_de(date) Date

Retourne le numéro du mois d'une date (1 à 12).

jour_de(date) Date

Retourne le numéro du jour dans le mois d'une date (1 à 31).

heure_de(heure) Heure

Retourne la partie heures d'une variable heure (0 à 23).

minute_de(heure) Heure

Retourne la partie minutes d'une variable heure (0 à 59).

seconde_de(heure) Heure

Retourne la partie secondes d'une variable heure (0 à 59).

ajouter_heures(heure, n) Heure

Ajoute (ou soustrait si négatif) un nombre d'heures à une heure.

ajouter_minutes(heure, n) Heure

Ajoute (ou soustrait si négatif) un nombre de minutes à une heure.

ajouter_jours(date, n) Date

Retourne la partie minutes d'une variable heure (0 à 59).

format_date(date, motif) Date

Affiche une date selon un motif personnalisé (jj, mm, aaaa, hh, nn, ss).

semaine_de(date) Date

Retourne le numéro de la semaine dans l'année (norme ISO 8601).

est_bissextile(date) Date

Retourne vrai si l'année est bissextile.

ajouter_mois(date, n) Date

Ajoute (ou soustrait si négatif) un nombre de mois à une date.

ajouter_annees(date, n) Date

Ajoute (ou soustrait si négatif) un nombre d'années à une date.

Fichier

importer(fichier/url) Fichier

Lecture du contenu d'un fichier .txt, .csv, .svg ou d'une page web. importer('C:\monfichier.csv') / importer('https://coddyrun.fr/')

sauvegarder(fichier, texte) Fichier

Écrit un texte dans un fichier .txt ou .csv sur le disque. sauvegarder('C:\monfichier.txt', 'Bonjour monde !')

fichier_existe(fichier) Fichier

Vérifie si un fichier .txt ou .csv existe sur le disque. fichier_existe('C:\monfichier.txt')

ajouter_ligne(fichier, texte) Fichier

Ajoute une ligne à la fin d'un fichier .txt ou .csv sans effacer son contenu. ajouter_ligne('C:\log.txt', 'Démarrage du programme')

télécharger(url, répertoire) Fichier

Télécharge un fichier depuis une URL https:// et le sauvegarde dans un dossier local. télécharger('https://exemple.fr/img1.png', 'C:\Images')

ouvrir(fichier) Fichier

ouvrir : Ouvre un fichier, un dossier ou une URL avec l'application par défaut du système.

liste_fichiers(dossier, extention, tableau) Fichier

Liste les fichiers d'un dossier et remplit un tableau avec leurs chemins complets.

paramètre(section, clé, valeur) / paramètre(section, clé)Fichier

Enregistre et relit des paramètres conservés d'une exécution.

Dessins

dimension(toile, largeur, hauteur) Dessin

Définit la largeur et la hauteur d'une toile.

remplir(toile, couleur) Dessin

Remplit toute la toile avec une couleur.

contour(toile, couleur, épaisseur) Dessin

Active un contour (une bordure) appliqué à toutes les formes pleines dessinées ensuite sur la toile.

dégradé(toile, [Couleur, Couleur, p3, ...] / tableau) Dessin

Remplit toute la toile avec un dégradé horizontal (de gauche à droite) entre plusieurs couleurs.

rectangle(toile, x1, y1, x2, y2, couleur) Dessin

Dessine un rectangle plein sur la toile.

rectangle arrondi(toile, x1, y1, x2, y2, rayon, couleur) Dessin

Dessine un rectangle aux coins arrondis sur la toile.

cercle(toile, cx, cy, rayon, couleur) Dessin

Dessine un cercle plein sur la toile.

ligne(toile, x1, y1, x2, y2, couleur, épaisseur) Dessin

Trace une ligne entre deux points sur la toile.

pixel(toile, x, y, couleur) Dessin

Colore un seul pixel de la toile.

label(toile, x, y, texte, couleur, taille , angle) Dessin

Écrit un texte sur la toile.

polygone(toile, [p1, p2, p3, ...] / tableau, couleur) Dessin

Dessine un polygone plein en reliant une suite de points.

arc(toile, cx1, cy1, cx2, cy2, angle, couleur) Dessin

Dessine un secteur de disque (une part de camembert).

grille(toile, pas, couleur) Dessin

Trace un quadrillage sur toute la toile.

ellipse(toile, cx, cy, rx, ry, couleur) Dessin

Dessine une ellipse pleine sur la toile.

courbe(toile, [p1, p2, p3, ...] / tableau, couleur) Dessin

Trace une courbe en reliant une suite de points par des segments.

histogramme(toile, [n1, n2, n3, ...] / tableau, couleur) Dessin

Dessine un histogramme (diagramme en barres) sur la toile.

label_largeur(texte, taille) Dessin

Renvoie la largeur estimée en pixels d'un texte affiché avec label.

label_hauteur(taille) Dessin

Renvoie la hauteur estimée en pixels d'une ligne de texte affichée avec label.

effacer(toile) Dessin

Efface tout le contenu dessiné sur un toile.

icône(toile, x, y, icône, couleur, taille) Dessin

Dessine une icône (glyph) sur une toile à partir d'un code hexadécimal Unicode.

svg(toile, x, y, source 'c:\img.svg' / variable image, largeur, hauteur) Dessin

Dessine une image vectorielle sur une toile.

animation(tableau, millisecondes, répétition) Dessin

Anime une suite d'images de toile stockées dans un tableau.

enregistrer(fichier) Dessin

Enregistre une toile dans un fichier .svg sur le disque.

clique(x, y, x_coin, y_coin, largeur, hauteur) Dessin

Vérifie si un point (x, y), obtenu après un clic (cliquer), se situe dans une zone de la toile.

flèche(toile, tableau, couleur, epaisseur, pointe) Dessin

Dessine une flèche, une ligne terminée par une pointe au dernier point.

triangle(toile, x1, y1, x2, y2, x3, y3, couleur) Dessin

Dessine un triangle plein à partir de ses 3 sommets.

rectangle_arrondi(toile, x, y, largeur, hauteur, rayon, couleur) Dessin

Dessine un rectangle aux coins arrondis ; rayon = arrondi des coins, couleur facultative.

saisie(toile, variable, x, y, largeur, hauteur, indication) Dessin

Dessine une zone de texte reliée à une variable texte ou nombre, remplie au déblocage de cliquer. Voir Entrées / sorties.

souris_x(toile) Souris

Position horizontale de la souris sur la toile, sans attendre ; -1 hors de la toile.

souris_y(toile) Souris

Position verticale de la souris sur la toile, sans attendre ; -1 hors de la toile.

souris_appuyée(toile) Souris

Vrai tant que le bouton gauche de la souris est enfoncé sur la toile.

souris_clic(toile) Souris

Vrai une seule fois après un ou plusieurs clics sur la toile, puis faux jusqu'au clic suivant.

touche_enfoncée(touche) Clavier

Vrai tant que la touche du clavier est maintenue : touche_enfoncée('gauche').

touche_pressée(touche) Clavier

Vrai une seule fois par appui sur la touche : touche_pressée('espace').

Utilitaires

est_nombre(x) util

Vrai si x est de type nombre, ou si c'est une chaîne de texte qui peut être convertie en nombre (ex : '42'). Utile pour valider les saisies utilisateur avant de faire des calculs.

est_texte(x) util

Vrai si x est de type texte. Permet de vérifier le type d'une valeur avant de lui appliquer des opérations spécifiques.

est_booleen(x) util

Vrai si x contient une valeur booléenne (vrai ou faux), Faux dans tous les autres cas (nombre, texte, tableau…)

convertir_texte(x) util

Convertit n'importe quelle valeur en texte. convertir_texte(42) → '42'. Nécessaire pour concaténer un nombre avec du texte dans certains contextes.

convertir_nombre(x) util

Convertit une valeur texte en nombre. convertir_nombre('3.14') → 3.14. Provoque une erreur si la conversion est impossible.

convertir_date(x) util

Convertit une valeur date en texte. convertir_date(x)

convertir_heure(x) util

Convertit une valeur heure en texte. convertir_heure(x)

type_de(x) util

Indique le type d'une valeur. Valeur retournée : nombre, texte, booléen, tableau, enregistrement, date, heure

limiter(s, min, max) util

Force une valeur à rester dans un intervalle. score vaut 120 → score vaut limiter(score, 0, 100)

sialors(condition, 'a', 'b') util

Renvoie a si condition est vraie, sinon b. sialors(vrai, 'oui', 'non')

incrément(x, n) util

Renvoie une nouvelle valeur correspondant à : (x + n) Elle permet donc d’augmenter une valeur numérique. x vaut incrément(x, 1)

décrément(x, n) util

Renvoie une nouvelle valeur correspondant à : (x - n) Elle permet donc de diminuer une valeur numérique. x vaut décrément(x, 1)

est_vide(x) util

Retourne vrai si le texte, le tableau ou l'enregistrement est vide.

défaut(x) util

Retourne la valeur par défaut correspondant au type de la variable.

vers_date(texte) util

Convertit un texte au format jj/mm/aaaa en une valeur de type date.

vers_heure(texte) util

Convertit un texte au format hh:mm:ss en une valeur de type heure.

vers_type(type, texte) util

Convertit une valeur vers le type demandé.

vers_hexadécimal(valeur, préfixe) util

Convertit un nombre entier en sa représentation hexadécimale (base 16).

vers_décimal(valeur, base) util

Convertit un texte écrit en binaire (base 2), octal (base 8) ou hexadécimal (base 16) en sa valeur décimale.

rgb(rouge, vert, bleu) util

Construit une couleur hexadécimale #RRGGBB à partir de trois composantes numériques : rouge, vert et bleu.

chrono() util

Retourne le temps courant en millisecondes (haute résolution).

tls(teinte, luminosité, saturation) util

Construit une couleur hexadécimale #RRGGBB à partir de la teinte, de la saturation et de la luminosité.

rgba(rouge, vert, bleu, alpha) util

Construit une couleur hexadécimale #RRGGBBAA à partir de trois composantes de couleur (rouge, vert, bleu, chacune entre 0 et 255) et d'un canal alpha de transparence.

centimètre(cm) util

Convertit une longueur en centimètres en pixels.

millimètre(mm) util

Convertit une longueur en millimètres en pixels.

son(chemin, en_boucle) util

Joue un fichier .wav en arrière-plan ; en_boucle (facultatif) = vrai pour le répéter. son('') arrête le son.

Erreurs courantes

Comprendre les messages d'erreur et comment les corriger

Les erreurs font partie intégrante de l'apprentissage de la programmation. CoddyRun fournit des messages d'erreur en français, aussi clairs que possible (et, avec la syntaxe anglaise, avec les mots du code en anglais), pour aider à identifier rapidement ce qui ne va pas. Le tableau ci-dessous recense les erreurs les plus fréquentes, leur cause et la correction à apporter.

Message d'erreur	Cause probable	Solution
`Variable inconnue : « x » : elle ne reçoit de valeur nulle part dans le programme. Déclarez-la d'abord, ex : x est un nombre`	Variable utilisée avant d'être déclarée	Ajouter `x est un nombre` (ou texte, booléen, tableau) avant la première utilisation
`Pour donner une valeur, écrivez « x vaut ... » (le signe = sert à comparer, ex : si x = 3 alors)`	Affectation écrite avec `=`, comme dans d'autres langages (`x = 3`)	Écrire `x vaut 3`. Le signe `=` sert uniquement à comparer
`Division par zéro`	`a / 0` ou `a mod 0` — le diviseur vaut 0	Vérifier le diviseur avec un `si` avant de diviser : `si b <> 0 alors …`
`Index hors limites : t[5] ; le tableau contient 5 élément(s), indices valides : 0 à 4`	Accès à un index qui n'existe pas dans le tableau	Vérifier avec `longueur(t)` que l'index est valide avant d'y accéder
`"x" n'est pas un tableau`	Utilisation de la notation `t[i]` sur une variable qui n'est pas un tableau	Déclarer la variable avec `x est un tableau`
`Le bloc « si » commencé sur cette ligne n'est jamais fermé : il manque « fin si »`	Un `si` n'a pas de `fin si` correspondant	Vérifier que chaque `si` imbriqué est bien fermé par son propre `fin si`
`pas ne peut pas être 0`	Boucle `pour` avec un incrément (`pas`) égal à 0	Utiliser un pas non nul — positif pour aller en avant, négatif pour aller en arrière
`« f » attend 2 paramètre(s) (a, b), mais 1 valeur(s) ont été données`	Nombre d'arguments incorrect lors de l'appel d'une fonction	Vérifier la signature de la fonction et passer le bon nombre d'arguments
`Soustraction de textes impossible`	`'a' - 'b'` n'est pas supporté	Seul l'opérateur `+` est valable pour les textes (concaténation)
`premier: tableau vide`	Appel de `premier()` ou `dernier()` sur un tableau sans éléments	Vérifier `longueur(t) > 0` avant d'appeler ces fonctions
`La boucle « tant que » dépasse … tours : probable boucle infinie`	Boucle infinie détectée	Vérifier que la condition évolue à chaque itération
`Champ inconnu : « x.nom » (champs existants : prenom, age)`	Le champ demandé n’existe pas dans l’enregistrement	Créer le champ avant de le lire : `x.nom vaut …`
`« x » est un nombre, pas un enregistrement : la notation « x.nom » est impossible`	Accès à un champ (`x.nom`) sur une variable non enregistrement	Déclarer la variable comme enregistrement : `x est un enregistrement`
`« x » est une constante : sa valeur ne peut pas être modifiée`	Tentative de modification d’une constante	Supprimer l’affectation ou utiliser une variable à la place

Quand vous obtenez une erreur, lisez-la attentivement avant de modifier le code. Le message indique la ligne concernée — commencez par regarder cette ligne et ses lignes voisines. 90% des erreurs se résolvent en lisant le message correctement.

Toutes les erreurs

Référence exhaustive des messages de l'interpréteur, classés par thème

Le chapitre précédent présente les erreurs les plus fréquentes. Celui-ci recense l'ensemble des messages que CoddyRun peut afficher, regroupés par thème. Les parties variables d'un message (nom de variable, nom de fonction, valeur, numéro de ligne) sont notées … : seul le texte fixe permet de retrouver l'erreur dans ce tableau. Chaque message indique toujours la ligne concernée — c'est par elle qu'il faut commencer.

Lire un message d'erreur

Un message complet se lit en trois parties : le numéro de ligne, le message (souvent suivi d'un exemple ou d'une astuce), puis, si l'erreur s'est produite dans une fonction, le contexte d'appel entre crochets.

Ligne 4: Index hors limites : t[3] ; le tableau contient 3 élément(s), indices valides : 0 à 2 [dans la fonction « dernier_score », appelée ligne 9]

Ici, l'erreur est à la ligne 4, dans la fonction dernier_score, elle-même appelée à la ligne 9. Le contexte peut aussi être [dans la procédure « … », appelée ligne …] ou [dans le processus « … »]. Quand une suggestion est possible, le message propose le nom le plus proche : Vouliez-vous dire « total » ?

Les familles d'erreurs

Les erreurs de CoddyRun se répartissent en 17 familles. Les premières sont détectées à la lecture du programme, les suivantes pendant son exécution. Le bouton Analyser la syntaxe a ses propres messages (erreurs, avertissements et conseils), regroupés plus bas.

Syntaxe & structure du programme

Ces erreurs sont levées par l'analyseur avant même l'exécution : une ligne est mal formée, un mot-clé manque ou un délimiteur n'est pas fermé.

Message d'erreur	Cause probable	Solution
`Instruction inattendue : "…"`	La ligne commence par un jeton qui n'est pas une instruction valide.	Vérifier l'orthographe du mot-clé (`affiche`, `si`, `pour`…) et les accents.
`Instruction inconnue après "x"`	Après un nom de variable, CoddyRun attend `est`, `vaut`, `ajoute`, `soustrait` ou `supprime`.	Compléter l'instruction, par exemple `x vaut 10`.
`Expression attendue, obtenu : "…"`	Un opérande manque : opérateur en fin de ligne, virgule en trop, parenthèse ouverte suivie de rien.	Compléter l'expression ou supprimer l'opérateur orphelin.
`Élément attendu : …, mais trouvé : …`	L'analyseur attendait un jeton précis (mot-clé, virgule, parenthèse) et en a trouvé un autre.	Comparer la ligne avec la syntaxe de référence du chapitre concerné.
`")" attendu`	Une parenthèse ouvrante n'a jamais été refermée.	Compter les parenthèses ; chaque `(` a besoin de son `)`.
`Crochet fermant "]" attendu dans le tableau`	Un littéral tableau `[1, 2, 3]` n'est pas refermé.	Ajouter le `]` manquant et vérifier les virgules entre les éléments.
`Crochet fermant "]" attendu dans le dictionnaire`	Un littéral dictionnaire `['clé': valeur]` n'est pas refermé.	Ajouter le `]` final.
`Crochet fermant "]" attendu après ":" (dictionnaire vide)`	Le dictionnaire vide s'écrit exactement `[:]`.	Écrire `d vaut [:]` sans rien entre `:` et `]`.
`Identifiant attendu après ","`	Dans une déclaration multiple `x, y, z est un nombre`, une virgule n'est pas suivie d'un nom.	Supprimer la virgule en trop ou ajouter le nom manquant.
`Après "x, y", seule la forme "x, y est ..." est supportée`	Une liste de variables séparées par des virgules ne peut servir qu'à une déclaration.	Affecter chaque variable sur sa propre ligne.
`Nom attendu après "…"`	Un mot-clé de définition (fonction, procédure, processus, classe) n'est pas suivi d'un nom.	Donner un nom valide, commençant par une lettre.
`Nom de champ attendu après "."`	Le point d'accès à un champ n'est suivi d'aucun identifiant.	Écrire `personne.nom`, jamais `personne.` seul.
`Définition "…" sans fin correspondante`	Une fonction, procédure ou un processus n'a pas son mot-clé de fermeture.	Ajouter `fin fonction`, `fin procédure` ou `fin processus`.
`Ligne %d: instruction invalide sur champ "x.y"`	Après `x.champ`, seuls `vaut`, `ajoute` et `soustrait` sont acceptés.	Utiliser une de ces trois formes.
`Nombre attendu après "#"`	Un littéral caractère `#65` ou `#$41` est incomplet.	Faire suivre le `#` d'un code décimal ou hexadécimal.
`Erreur interne: pop global interdit`	Anomalie de l'interpréteur : une portée globale a tenté d'être libérée.	Ce cas ne doit pas se produire ; signaler le programme qui le déclenche.
`Texte non fermé : il manque l'apostrophe ' qui termine le texte commencé sur cette ligne. Astuce : pour écrire une apostrophe dans un texte entre ' ', doublez-la ('l''arbre') ou utilisez des guillemets doubles ("l'arbre")`	Un texte ouvert par `'` n'est pas refermé sur la même ligne, souvent à cause d'une apostrophe dans le texte (`'l'arbre'`).	Doubler l'apostrophe intérieure : `affiche 'l''arbre'`, ou entourer le texte de guillemets : `affiche "l'arbre"`.
`Texte non fermé : il manque le guillemet " qui termine le texte commencé sur cette ligne`	Un texte ouvert par `"` n'a pas de guillemet fermant sur la même ligne.	Ajouter le guillemet manquant en fin de texte. Un texte ne peut pas s'étendre sur plusieurs lignes.
`Commentaire non fermé : l'accolade « { » ouverte sur cette ligne n'a pas d'accolade « } » correspondante (tout le reste du programme serait ignoré)`	Un commentaire multiligne `{ …` n'est jamais refermé.	Ajouter `}` à la fin du commentaire, ou utiliser `//` pour un commentaire d'une seule ligne.
`Parenthèse non fermée : il manque « ) » avant la fin de la ligne`	Il y a plus de `(` que de `)` sur la ligne.	Compter les parenthèses : chaque `(` doit avoir sa `)`, par exemple `affiche longueur(t)`.
`Crochet non fermé : il manque « ] » avant la fin de la ligne`	Un tableau, un index ou une clé ouvert par `[` n'est pas refermé.	Ajouter le `]` manquant : `t vaut [1, 2, 3]`, `affiche t[0]`.
`Le bloc « si » commencé sur cette ligne n'est jamais fermé : il manque « fin si »`	Un bloc (`si`, `pour`, `tant que`, `répète`, `selon`, `essayer`…) arrive à la fin du programme sans sa ligne de fermeture. Le message donne la ligne d'ouverture.	Ajouter la fermeture indiquée (`fin si`, `fin pour`, `fin tant que`…) à l'endroit où le bloc doit s'arrêter.
`Fin du programme inattendue : un bloc n'est pas fermé`	Le programme se termine alors qu'une structure est encore ouverte.	Vérifier que chaque bloc ouvert a sa ligne `fin …`. L'indentation aide à repérer celui qui manque.
`« sinon » mal placé : dans le « si » de la ligne …, « sinon » doit être le dernier cas (les « sinon si » se placent avant)`	Un `sinon si` (ou un second `sinon`) apparaît après le `sinon` final.	Remettre les cas dans l'ordre : `si … alors`, puis les `sinon si … alors`, et `sinon` en dernier.
`« sinon selon » en double dans le « selon » de la ligne …`	Un `selon` contient deux cas par défaut.	Garder un seul `sinon selon :`, placé après tous les `cas`.
`« fin pour » inattendu : le bloc « si » ouvert ligne … n'est pas encore fermé (il manque « fin si » avant)`	Les blocs se chevauchent : on ferme un bloc extérieur alors qu'un bloc intérieur est encore ouvert.	Fermer d'abord le bloc le plus intérieur : `fin si` avant `fin pour`.
`« fin si » sans « si » correspondant : aucun bloc « si » n'est ouvert ici`	Une ligne de fermeture (ou un `sinon`, `attraper`…) n'a pas de bloc ouvert à refermer.	Supprimer la fermeture en trop, ou ajouter la ligne d'ouverture manquante.
`Instruction inattendue : … ne peut pas commencer une ligne`	La ligne commence par un mot ou un symbole qui ne peut pas débuter une instruction (par exemple `et`, `vaut`, `)`).	Commencer la ligne par une instruction : une variable, `affiche`, `si`, `pour`, un appel de procédure…
`Une ligne ne peut pas commencer par 42 : pour afficher une valeur, écrivez « affiche ... »`	La ligne commence par une valeur (nombre, texte, parenthèse, crochet ou signe moins) au lieu d'une instruction.	Écrire `affiche 42` ou affecter la valeur à une variable : `x vaut 42`.
`« alors » doit suivre la condition d'un « si » ou d'un « sinon si »`	Le mot `alors` se trouve seul ou au début d'une ligne.	Placer `alors` en fin de condition, sur la même ligne : `si x > 3 alors`.
`« fois » doit suivre le nombre de tours de « répète », ex : répète 3 fois`	Le mot `fois` apparaît en dehors d'un `répète`.	Écrire la boucle complète : `répète 3 fois`.
`Élément en trop : … après la fin de l'instruction. Écrivez une seule instruction par ligne (vérifiez aussi un opérateur oublié, comme + ou *)`	L'instruction est complète mais la ligne continue : deux instructions sur une ligne, ou un opérateur oublié (`affiche a b`).	Passer à la ligne entre deux instructions, ou ajouter l'opérateur manquant : `affiche a + b`.
`« affiche » n'accepte qu'une valeur : pour en afficher plusieurs, assemblez-les avec +, ex : affiche a + ' ' + b`	Plusieurs valeurs séparées par des virgules après `affiche`.	Concaténer les valeurs : `affiche nom + ' a ' + age + ' ans'`.
`« vaut » inattendu après « affiche » : écrivez la modification et l'affichage sur deux lignes`	Une affectation est écrite dans un `affiche` (`affiche x vaut 3`).	Séparer : `x vaut 3` puis, ligne suivante, `affiche x`.
`« selon » n'est pas une instruction connue. Vouliez-vous dire « … » ?`	Le mot en début de ligne ressemble à un mot-clé ou à une procédure, mais il est mal orthographié.	Reprendre l'orthographe proposée par le message (accents compris).
`« x » seul ne fait rien : écrivez par exemple « affiche x », « x vaut ... » ou « x est un nombre »`	Une ligne ne contient qu'un nom de variable.	Compléter l'instruction : affichage, affectation ou déclaration.
`Instruction inconnue : « x » doit être suivi de « vaut », « est », « ajoute », « soustrait », « supprime » ou de parenthèses pour un appel (trouvé : …)`	Après un nom en début de ligne, CoddyRun ne reconnaît pas la suite.	Écrire par exemple `x vaut 10`, `x ajoute 1`, ou `dessiner()` pour appeler une procédure.
`Valeur attendue, mais trouvé …`	Une expression est attendue (après un opérateur, une virgule, une parenthèse…), mais le jeton trouvé n'est pas une valeur. Un conseil peut suivre si un caractère inconnu est en cause.	Vérifier ce qui suit l'opérateur : `x vaut a + 1` et non `x vaut a +`.
`Valeur manquante : une valeur ou une expression est attendue ici`	Une instruction attend une valeur qui n'a pas été écrite.	Compléter avec une valeur, une variable ou un calcul.
`Valeur manquante après + : la ligne se termine trop tôt`	La ligne s'arrête juste après un opérateur.	Ajouter l'opérande manquant ou retirer l'opérateur en trop.
`Valeur manquante avant « = »`	Une comparaison ou un opérateur n'a pas de valeur à sa gauche.	Écrire la valeur à comparer avant l'opérateur : `si x = 3 alors`.
`Valeur manquante avant « = » : la condition commence par une valeur, ex : si x = 3 alors`	La condition d'un `si` commence directement par `=`.	Ajouter la variable testée devant le `=`.
`Valeur ou expression attendue, mais trouvé …`	Un mot-clé ou un symbole est placé là où une valeur est attendue.	Remplacer par une valeur, ou vérifier qu'un mot-clé n'est pas utilisé comme nom.
`« == » n'existe pas : pour comparer, écrivez un seul « = » (ex : si x = 3 alors)`	Habitude d'autres langages : en CoddyRun, l'égalité s'écrit avec un seul signe.	Remplacer `==` par `=` : `si x = 3 alors`.
`« # » doit être suivi d'un code de caractère (ex : #65 pour A) ou d'une couleur à 6 ou 8 chiffres (ex : #FF8800)`	Un `#` isolé ou suivi d'une valeur incomplète.	Écrire un code de caractère (`#65`) ou une couleur complète (`#FF8800`).
`Code de caractère invalide : #300 (de #0 à #255 ; au-delà, utilisez caractère(n) ou U+XXXX)`	Le code après `#` dépasse 255.	Utiliser `caractère(300)` ou la notation `U+012C`.
`Opérateur inconnu`	Combinaison de symboles qui ne correspond à aucun opérateur.	Utiliser les opérateurs du chapitre Opérateurs : `+ - * / mod = <> < > <= >=`.
`Pour donner une valeur, écrivez « x vaut ... » (le signe = sert à comparer, ex : si x = 3 alors)`	Une affectation écrite avec `=` (`x = 3`), comme dans d'autres langages.	Écrire `x vaut 3`. Le signe `=` est réservé aux conditions.
`… : le point-virgule n'est pas utilisé, écrivez une instruction par ligne`	Un « ; » termine une instruction, comme dans d'autres langages.	Supprimer le point-virgule et passer à la ligne.
`… : pour « non », écrivez non ; pour « différent de », écrivez <>`	Le « ! » d'autres langages n'existe pas en CoddyRun.	Écrire `non` ou `<>`.
`… : pour « et logique », écrivez et`	« && » ou « & » n'existe pas.	Écrire `et`.
`… : pour « ou logique », écrivez ou`	« \|\| » ou « \| » n'existe pas.	Écrire `ou`.
`… : accolade fermante sans « { » (les accolades servent aux commentaires)`	Une « } » ferme un commentaire qui n'a pas été ouvert.	Supprimer l'accolade, ou ouvrir le commentaire avec « { ».
`… : « fin » doit être suivi du bloc à fermer (fin si, fin pour, fin tant que, fin répète, fin selon, fin essayer, fin fonction...)`	Le mot « fin » est seul sur la ligne.	Écrire la fin complète du bloc : `fin si`, `fin pour`…
`… : un nombre hexadécimal s'écrit $FF`	Un « $ » isolé ou mal placé.	Coller les chiffres au dollar : `$FF`.
`… : # doit être suivi d'un code (#65) ou d'une couleur (#RRGGBB)`	Un « # » isolé.	Écrire un code de caractère (`#65`) ou une couleur (`#FF0000`).
`… : guillemet isolé`	Un guillemet ouvre un texte qui n'est jamais fermé.	Fermer le texte avec le même guillemet.
`… : caractère non reconnu par CoddyRun`	Un symbole que le langage n'utilise pas (€, §, @ au milieu d'une ligne…).	Le retirer, ou le mettre entre guillemets s'il fait partie d'un texte.

Variables, types et constantes

CoddyRun est typé : une variable garde le type reçu à la déclaration. La plupart des erreurs ci-dessous viennent d'une affectation qui change ce type.

Message d'erreur	Cause probable	Solution
`Variable inconnue : "x"`	La variable est lue avant d'avoir été déclarée, ou son nom est mal orthographié.	Déclarer la variable avant usage : `x est un nombre`.
`"x" existe déjà comme variable`	Le nom est déjà pris par une variable ou une constante de la même portée.	Choisir un autre nom, ou supprimer la seconde déclaration.
`Type inconnu : "…"`	Le mot placé après `est un / est une` n'est pas un type reconnu.	Utiliser nombre, texte, booléen, tableau, dictionnaire, enregistrement, date, heure ou toile.
`Déclaration de type …, impossible d'affecter un …`	La déclaration et la valeur initiale ne sont pas du même type.	Aligner le type déclaré sur la valeur, ou convertir la valeur.
`"x" est déclaré de type …, impossible d'affecter un …`	Affectation d'une valeur d'un autre type que celui déclaré.	Convertir avec `convertir_nombre()`, `convertir_texte()` ou `vers_type()`.
`"x" est de type …, impossible d'affecter un …`	Même situation, détectée au moment de l'exécution.	Vérifier le type renvoyé par l'expression de droite avec `type_de()`.
`"x" est de type nombre, impossible d'ajouter un …`	`ajoute` sur un nombre exige une valeur numérique.	Convertir la valeur avant : `x ajoute convertir_nombre(v)`.
`"x" est de type …, "soustrait" réservé aux nombres`	`soustrait` n'existe que pour les nombres.	Pour un texte, utiliser `retirer()` ; pour un tableau, `supprime`.
`Impossible de soustraire un … à un nombre`	La valeur soustraite n'est pas un nombre.	Convertir la valeur, ou corriger l'expression.
`"ajoute" non supporté sur le type …`	`ajoute` ne fonctionne que sur nombre, texte et tableau.	Utiliser `vaut` pour les autres types.
`"x" est une constante : modification interdite`	Une constante ne peut être affectée qu'une fois, à sa définition.	Transformer en variable, ou supprimer la réaffectation.
`Constante attend un identifiant`	`constante` n'est pas suivi d'un nom valide.	Écrire `constante TVA vaut 20`.
`Constante déjà définie : "…"`	Deux constantes portent le même nom.	Renommer l'une des deux.
`Nom de variable interdit : "…" est un mot réservé`	Le nom choisi est un mot-clé du langage.	Choisir un autre nom (par exemple `pour_total` au lieu de `pour`).
`Nom de variable interdit : "…" est un nom de type`	Le nom choisi est un nom de type (nombre, texte, tableau…).	Choisir un nom différent du type.
`Nom de variable interdit : "…" est une fonction native`	Le nom entre en collision avec une fonction intégrée.	Renommer la variable ; la liste complète est au chapitre Fonctions intégrées.
`Nom de variable interdit : "…" est déjà une fonction ou une procédure`	Une fonction ou procédure du programme porte déjà ce nom.	Renommer la variable ou le sous-programme.
`défaut : type non pris en charge`	`défaut()` ne connaît pas de valeur par défaut pour ce type.	L'appeler sur un nombre, un texte, un booléen, un tableau ou un dictionnaire.
`Variable inconnue : « totl ». Vouliez-vous dire « total » ?`	Le nom ne correspond à aucune variable, mais un nom proche existe : faute de frappe probable.	Corriger le nom avec la suggestion du message.
`Variable inconnue : « x » : elle ne reçoit de valeur nulle part dans le programme. Déclarez-la d'abord, ex : x est un nombre`	La variable n'est jamais déclarée ni affectée dans tout le programme.	Déclarer la variable avant de l'utiliser : `x est un nombre`.
`La variable « x » est utilisée avant d'avoir reçu une valeur : déclarez-la ou affectez-la plus haut (ex : x est un nombre), ou vérifiez que le bloc qui lui donne sa valeur a bien été exécuté.`	La variable existe ailleurs dans le programme, mais la ligne qui lui donne une valeur n'a pas encore été exécutée (elle est plus bas, ou dans un `si` non exécuté).	Déclarer la variable en haut du programme, ou lui donner une valeur par défaut avant le bloc conditionnel.
`La variable « x » n'a pas de valeur ici : dans une fonction, on ne voit que ses paramètres, ses propres variables (déjà affectées) et les variables du programme principal. Passez-la en paramètre ou affectez-la avant de la lire.`	Une fonction lit une variable locale d'une autre fonction, ou une variable locale pas encore affectée.	Passer la valeur en paramètre : `fonction double(x)` puis `double(n)`.
`« f » est une fonction : ajoutez des parenthèses pour l'appeler, ex : f()`	Le nom d'une fonction est utilisé comme une variable.	Ajouter les parenthèses (et les arguments) : `affiche maintenant()`.
`« x » est une constante : sa valeur ne peut pas être modifiée`	Une constante reçoit une nouvelle valeur (`vaut`, `ajoute`, `soustrait`…).	Utiliser une variable si la valeur doit changer.
`Type inconnu : « nombr ». Vouliez-vous dire « nombre » ?`	Le type après `est un` est mal orthographié.	Reprendre le type proposé.
`Type inconnu : « … ». Types possibles : nombre, texte, booléen, tableau, enregistrement, dictionnaire, date, heure, toile, image`	Le type n'existe pas et ne ressemble à aucun type connu.	Choisir l'un des types listés : `x est un dictionnaire`.
`« x » est de type nombre : impossible de lui affecter un texte (astuce : convertir_nombre(...) transforme un texte en nombre)`	Une variable déclarée d'un type reçoit une valeur d'un autre type. Le message ajoute une astuce de conversion quand elle existe.	Convertir la valeur (`x vaut convertir_nombre(saisie)`) ou changer le type déclaré.
`« x » est un nombre : impossible d'y ajouter un texte (astuce : convertir_nombre(...) transforme un texte en nombre)`	`ajoute` sur un nombre avec une valeur qui n'est pas un nombre.	Convertir la valeur ajoutée : `x ajoute convertir_nombre(t)`.
`« x » est un texte : « soustrait » ne s'utilise qu'avec un nombre`	`soustrait` appliqué à une variable qui n'est pas un nombre.	Utiliser `soustrait` uniquement sur des nombres ; pour un texte, voir `remplacer` ou `supprimer`.
`Impossible de soustraire un texte à un nombre (astuce : convertir_nombre(...) transforme un texte en nombre)`	La valeur retirée avec `soustrait` n'est pas un nombre.	Convertir la valeur : `x soustrait convertir_nombre(t)`.
`« ajoute » ne fonctionne pas sur « x », qui est un booléen : il s'utilise avec un nombre, un texte ou un tableau`	`ajoute` sur un booléen, une date, un enregistrement…	Réserver `ajoute` aux nombres (addition), textes (concaténation) et tableaux (nouvel élément).
`Pour donner une valeur, écrivez « x vaut ... » (le signe = sert à comparer, ex : si x = 3 alors)`	Affectation écrite avec `=`.	Écrire `x vaut 3`.
`« est » sert à déclarer un type (ex : x est un nombre). Pour donner une valeur, écrivez « x vaut ... »`	Confusion entre déclaration et affectation : `x est 5`.	Déclarer (`x est un nombre`) puis affecter (`x vaut 5`).
`Type manquant après « est », ex : x est un nombre`	La déclaration s'arrête après `est un`.	Ajouter le type : `x est un texte`.
`Type attendu après « est » (nombre, texte, booléen, tableau...), mais trouvé …`	Le mot après `est un` n'est pas un type.	Remplacer par un type valide.
`Nom de variable attendu après la virgule (trouvé : …)`	Dans une déclaration multiple, la virgule n'est pas suivie d'un nom.	Écrire `x, y est un nombre`.
`Une liste de variables « x, ... » ne peut être suivie que de « est », ex : x, y est un nombre. Pour donner une valeur, écrivez une affectation par ligne (trouvé : …)`	Tentative d'affecter plusieurs variables d'un coup (`x, y vaut 0`).	Une affectation par ligne : `x vaut 0` puis `y vaut 0`.
`Une constante reçoit sa valeur avec « vaut », ex : constante TVA vaut 20 (trouvé : …)`	La constante est déclarée sans valeur, ou avec `=`.	Écrire `constante TVA vaut 20`.
`« constante » attend un nom, ex : constante TVA vaut 20 (trouvé : …)`	Le mot `constante` n'est pas suivi d'un nom valide.	Donner un nom qui n'est pas un mot réservé.
`Une constante reçoit sa valeur avec « vaut », ex : TVA est constante vaut 20`	La constante est déclarée sans valeur, ou avec un autre mot que `vaut`.	Écrire `TVA est une constante vaut 20`.

Nombres et calculs

Les nombres CoddyRun sont des flottants double précision : ils restent exacts jusqu'à 2⁵³. Au-delà, ou en cas d'opération impossible, l'exécution s'arrête plutôt que de produire un résultat faux.

Message d'erreur	Cause probable	Solution
`Division par zéro`	Le diviseur d'une division vaut 0.	Tester avant : `si b <> 0 alors …`.
`Modulo par zéro`	`a mod 0` n'a pas de sens.	Vérifier que le second opérande n'est pas nul.
`Dépassement numérique : la valeur dépasse le maximum représentable`	Le résultat sort des bornes des nombres flottants.	Réduire l'ordre de grandeur du calcul (éviter les puissances et factorielles trop grandes).
`Résultat numérique indéfini (NaN)`	Opération mathématiquement indéfinie (0/0, ∞−∞…).	Contrôler les valeurs d'entrée avant le calcul.
`Nombre invalide ou hors limites : "…"`	Un littéral numérique est mal écrit ou trop grand.	Corriger l'écriture du nombre (pas d'espace, point décimal).
`Nombre trop grand : "…"`	Le littéral dépasse ce que le langage peut stocker.	Utiliser une valeur plus petite, ou un texte si le nombre sert d'identifiant.
`Nombre trop grand : "…" dépasse 2^53`	Au-delà de 9 007 199 254 740 992, les entiers ne sont plus exacts.	Rester sous cette limite, ou manipuler la valeur sous forme de texte.
`Nombre trop grand : au-delà de 9 007 199 254 740 992 (2^53), les nombres ne sont plus exacts`	Résultat de calcul dépassant la précision entière garantie.	Revoir l'algorithme pour limiter la croissance des valeurs.
`Nombre hexadécimal invalide : …`	Un littéral `$…` contient un caractère hors de 0-9 A-F.	N'utiliser que des chiffres hexadécimaux valides.
`Conversion en nombre impossible`	La valeur fournie ne représente pas un nombre.	Vérifier le texte source, ou tester avec `est_nombre()`.
`arcsinus(x) : x doit être compris entre -1 et 1`	L'arc sinus n'est défini que sur [-1 ; 1].	Borner la valeur avec `limiter(x, -1, 1)`.
`arccosinus(x) : x doit être compris entre -1 et 1`	L'arc cosinus n'est défini que sur [-1 ; 1].	Borner la valeur avant l'appel.
`tangente(x) : valeur indéfinie (cos = 0)`	La tangente diverge quand le cosinus s'annule (90°, 270°…).	Éviter ces angles ou tester le cosinus avant.
`logarithme(x) : x doit être strictement positif`	Le logarithme de 0 ou d'un nombre négatif n'existe pas.	Tester `x > 0` avant l'appel.
`factorielle : n doit être >= 0`	La factorielle n'est pas définie pour un nombre négatif.	Passer un entier positif ou nul.
`factorielle : n doit être un entier`	Un nombre à virgule a été fourni.	Arrondir d'abord avec `arrondi()`.
`factorielle : n trop grand (max 170)`	Au-delà de 170!, le résultat dépasse les limites numériques.	Rester sous 170.
`pgcd : les deux arguments doivent être des entiers`	Le PGCD ne s'applique qu'à des entiers.	Arrondir les deux valeurs avant l'appel.
`decimal(x, n) : n doit être >= 0`	Le nombre de décimales demandé est négatif.	Passer 0 ou plus.
`decimal(x, n) : n trop grand (max 15)`	Au-delà de 15 décimales, l'affichage n'a plus de sens.	Réduire `n`.
`pourcentage : le total ne peut pas être zéro`	Le calcul d'un pourcentage divise par le total.	Vérifier que le total est non nul avant l'appel.
`hasard(n) ou hasard(min,max)`	Le nombre d'arguments fourni à `hasard()` n'est ni 1 ni 2.	Utiliser une des deux formes documentées.
`intervalle : plage trop grande (maximum 1 000 000 éléments)`	L'intervalle demandé générerait un tableau démesuré.	Réduire l'écart entre début et fin.
`Le texte '12a' n'est pas un nombre : impossible de calculer avec. Pour une saisie, vérifiez-la avec est_nombre(...) puis convertissez-la avec convertir_nombre(...)`	Un texte qui ne représente pas un nombre est utilisé dans un calcul.	Tester avant de calculer : `si est_nombre(saisie) alors` puis `n vaut convertir_nombre(saisie)`.
`Conversion en nombre impossible : un tableau n'est pas un nombre`	Une valeur d'un autre type (tableau, booléen, enregistrement…) est utilisée dans un calcul.	Vérifier le type avec `type_de(x)` et utiliser la bonne valeur.

Textes, couleurs et expressions

Les textes se concatènent avec + ; toute autre opération arithmétique est refusée. Les fonctions de recherche et de mise en forme valident en plus leurs bornes.

Message d'erreur	Cause probable	Solution
`Soustraction de textes impossible`	`'a' - 'b'` n'existe pas.	Pour enlever un fragment, utiliser `retirer(texte, motif)`.
`code: texte vide`	`code()` a reçu une chaîne vide.	Vérifier que le texte contient au moins un caractère.
`Code ASCII invalide`	Le code fourni ne correspond à aucun caractère.	Rester dans l'intervalle autorisé.
`caractère: code hors limites (…). Intervalle autorisé: 0..65535`	`caractère()` n'accepte qu'un code sur 16 bits.	Borner la valeur entre 0 et 65535.
`U+… : code Unicode hors limites (max U+10FFFF)`	Le point de code dépasse le maximum Unicode.	Utiliser un point de code valide.
`repeter_texte: n trop grand (max 10000)`	Répétition démesurée, protection contre la saturation mémoire.	Réduire le nombre de répétitions.
`supprimer: position hors limites (…). Intervalle autorisé: 1..…`	La position demandée n'existe pas dans le texte.	Contrôler avec `longueur(texte)`. Les positions commencent à 1.
`position(motif, chaine) ou position(motif, chaine, depart)`	Nombre d'arguments incorrect.	Utiliser la forme à 2 ou à 3 arguments.
`expression : le motif ne peut pas être vide`	L'expression régulière fournie est une chaîne vide.	Fournir un motif non vide.
`expression : motif invalide "…" (…)`	L'expression régulière est mal formée.	Vérifier les parenthèses, crochets et échappements du motif.
`expression : trop de correspondances (motif trop général ?)`	Le motif capture un nombre excessif de résultats.	Rendre le motif plus précis.
`similaire : le seuil doit être compris entre 0 et 1`	Le seuil de similarité est une proportion.	Passer une valeur entre 0 et 1 (par exemple 0.8).
`hasardtexte attend au moins un argument`	Aucune source de caractères n'a été fournie.	Passer au moins une longueur ou un jeu de caractères.
`html : balise <…> non autorisée. Balises permises : h1 à h6, a, img, ul, ol, li, strong, em.`	`html()` n'accepte qu'une liste blanche de balises.	Remplacer la balise par une balise autorisée.
`couleur : valeur invalide "…". Utilisez #RRGGBB, #RRGGBBAA (avec transparence) ou #0 pour reset.`	Le code couleur n'est pas un hexadécimal reconnu.	Écrire la couleur au format `#RRGGBB`, ou passer par `rgb()`.
`Couleur invalide : "…". Utilisez un code hexadécimal #RRGGBB, #RRGGBBAA (avec transparence), #RGB ou #RGBA.`	Même cause, lors d'un dessin sur toile.	Corriger le code couleur ou utiliser `rgba()` / `tls()`.
`couleur ne peut pas être appliquée à du html(). Utilisez html() pour la mise en forme, ou couleur() sur du texte simple.`	Les deux fonctions de mise en forme sont exclusives.	Choisir l'une ou l'autre pour un même affichage.
`rgb : chaque composante doit être comprise entre 0 et 255`	Une composante rouge, verte ou bleue sort des bornes.	Borner avec `limiter(v, 0, 255)`.
`rgba : R, V, B doivent être compris entre 0 et 255`	Même cause pour la variante avec transparence.	Corriger les trois composantes.
`rgba : l'alpha doit être compris entre 0 (transparent) et 1 (opaque)`	Le canal alpha est une proportion, pas un nombre sur 255.	Passer une valeur entre 0 et 1.
`tls : la teinte doit être comprise entre 0 et 360`	La teinte est un angle en degrés.	Ramener la valeur dans [0 ; 360].
`tls : la saturation doit être comprise entre 0 et 100`	Saturation exprimée en pourcentage.	Passer une valeur entre 0 et 100.
`tls : la luminosité doit être comprise entre 0 et 100`	Luminosité exprimée en pourcentage.	Passer une valeur entre 0 et 100.
`« t » est un texte : on ne peut pas modifier un caractère avec t[...] vaut ... ; utilisez remplacer(...), insertion(...) ou supprimer(...)`	Un texte se lit caractère par caractère avec `t[i]`, mais ne se modifie pas ainsi.	Reconstruire le texte : `t vaut remplacer(t, 'a', 'b')`.
`Position hors limites : t[0] ; le texte contient 5 caractère(s), positions valides : 1 à 5 (dans un texte, la première position est 1)`	La position lue dans un texte n'existe pas. Dans un texte, les positions commencent à 1.	Utiliser une position entre 1 et `longueur(t)`.
`Position hors limites : t[1] ; le texte est vide`	Lecture d'un caractère dans un texte vide.	Vérifier `longueur(t) > 0` avant de lire.
`« x » est un nombre : les crochets [ ] ne s'utilisent qu'avec un tableau, un texte ou un dictionnaire`	Notation `x[i]` sur une variable qui n'est ni un tableau, ni un texte, ni un dictionnaire.	Déclarer la variable avec le bon type, ou retirer les crochets.

Tableaux

Les index commencent à 0 et doivent toujours exister avant d'être lus. Beaucoup de fonctions intégrées exigent explicitement un tableau en premier argument.

Message d'erreur	Cause probable	Solution
`"x" n'est pas un tableau`	Notation `x[i]`, `ajoute` ou fonction de tableau utilisée sur une autre variable.	Déclarer `x est un tableau`.
`"x" n'est pas un tableau ni un texte`	L'indexation `x[i]` ne s'applique qu'aux tableaux et aux textes.	Vérifier le type avec `type_de(x)`.
`Index hors limites : x[5]`	L'index demandé dépasse la taille du tableau.	Contrôler `longueur(x)` ; le dernier index vaut `longueur(x) - 1`.
`Index négatif interdit`	Un index calculé est devenu négatif.	Tester l'index avant l'accès, ou utiliser `limiter()`.
`Tableau vide`	Suppression ou lecture dans un tableau sans élément.	Vérifier `longueur(t) > 0`.
`Tableau vide : "x"`	Même cause, avec le nom de la variable concernée.	Remplir le tableau avant de le parcourir.
`premier: tableau vide`	`premier()` sur un tableau sans élément.	Tester la longueur avant l'appel.
`dernier: tableau vide`	`dernier()` sur un tableau sans élément.	Tester la longueur avant l'appel.
`premier attend un tableau`	L'argument n'est pas un tableau.	Passer une variable déclarée comme tableau.
`dernier attend un tableau`	L'argument n'est pas un tableau.	Passer une variable déclarée comme tableau.
`melanger attend un tableau`	`melanger()` ne s'applique qu'aux tableaux.	Convertir ou corriger l'argument.
`liste_tableau attend un tableau`	L'argument fourni n'est pas un tableau.	Passer un tableau initialisé.
`supprime attend un nom de tableau`	`supprime` doit porter sur une variable tableau ou dictionnaire.	Écrire `t supprime 2`.
`vide attend un nom de tableau`	`vide` doit porter sur un nom de tableau.	Écrire `vide t`.
`taille(tableau, n) : le premier argument doit être un tableau`	Argument de mauvais type.	Passer un tableau en premier.
`taille(tableau, n) : n doit être >= 0`	Taille cible négative.	Passer 0 ou plus.
`trier : le premier argument doit être un tableau`	Tri demandé sur autre chose qu'un tableau.	Corriger l'argument.
`index_de : le premier argument doit être un tableau`	Recherche d'index sur un type non indexable.	Pour un texte, utiliser `position()`.
`joindre : le premier argument doit être un tableau`	`joindre()` assemble les éléments d'un tableau.	Passer un tableau et un séparateur texte.
`somme : l'argument doit être un tableau`	Argument de mauvais type.	Passer un tableau de nombres.
`moyenne : l'argument doit être un tableau`	Argument de mauvais type.	Passer un tableau de nombres.
`moyenne : le tableau est vide`	La moyenne d'un ensemble vide n'existe pas.	Tester la longueur avant l'appel.
`médiane : l'argument doit être un tableau`	Argument de mauvais type.	Passer un tableau de nombres.
`médiane : le tableau ne doit pas être vide`	Pas de valeur centrale dans un tableau vide.	Tester la longueur avant l'appel.
`unique : l'argument doit être un tableau`	Argument de mauvais type.	Passer un tableau.
`assembler : tous les arguments doivent être des tableaux`	Un des arguments n'est pas un tableau.	Vérifier chaque argument avec `type_de()`.
`fusionner : le premier argument doit être un tableau`	Fusion de tableaux avec un premier argument d'un autre type.	Passer deux tableaux, ou deux dictionnaires.
`fusionner : le second argument doit être un tableau`	Le premier argument est un tableau, pas le second.	Les deux arguments doivent être du même genre.
`longueur attend un texte, un tableau ou un dictionnaire`	`longueur()` ne s'applique qu'à ces trois types.	Corriger l'argument.
`contient attend un texte, un tableau ou un dictionnaire en premier argument`	Recherche d'appartenance sur un type non supporté.	Corriger le premier argument.
`est_vide : attend un texte, un tableau, un enregistrement ou un dictionnaire`	`est_vide()` n'a pas de sens sur un nombre ou un booléen.	Comparer directement à 0 ou à faux dans ce cas.
`Index hors limites : t[5] ; le tableau contient 5 élément(s), indices valides : 0 à 4 (les indices commencent à 0 : le dernier élément est t[4])`	L'indice dépasse la taille du tableau. Le message rappelle les indices valides.	Les indices vont de 0 à `longueur(t) - 1`.
`Index hors limites : t[0] ; le tableau est vide`	Lecture d'un élément dans un tableau sans élément.	Remplir le tableau (`t ajoute 5`) ou tester `longueur(t) > 0`.
`Index négatif interdit : t[-1] (les indices commencent à 0)`	Indice négatif dans une affectation `t[i] vaut …`.	Utiliser un indice entre 0 et `longueur(t) - 1`.
`Index trop grand : t[10] (… au maximum)`	L'indice d'affectation est si grand que le tableau devrait grandir jusqu'à saturer la mémoire (la limite est celle des itérations de boucle).	Ajouter les éléments un par un avec `ajoute`, ou utiliser un indice raisonnable.
`« x » est un nombre, pas un tableau : x[...] vaut ... est impossible`	Affectation d'un élément sur une variable qui n'est pas un tableau.	Déclarer `x est un tableau`.
`Pour modifier un élément, écrivez « t[...] vaut ... » (le signe = sert à comparer)`	Modification d'un élément écrite avec `=`.	Écrire `t[0] vaut 5`.
`Après t[...] on attend « vaut », « ajoute » ou « soustrait » (trouvé : …). Pour afficher l'élément, écrivez « affiche t[...] »`	Une ligne commence par `t[i]` sans instruction derrière.	Compléter (`t[0] vaut 5`) ou afficher (`affiche t[0]`).
`« x » est un nombre : « vide » s'utilise uniquement avec un tableau`	`vide` appliqué à une variable qui n'est pas un tableau.	Pour remettre un nombre à zéro : `x vaut 0`.
`« vide » attend le nom d'un tableau, ex : vide mesNotes (trouvé : …)`	`vide` n'est pas suivi d'un nom de variable.	Écrire `vide mesNotes`.
`« t » est un texte : « supprime » s'utilise avec un tableau. Pour retirer un caractère, utilisez supprimer(position, texte)`	`supprime` sur un texte.	Utiliser la fonction : `t vaut supprimer(1, t)`.
`« x » est un nombre : « supprime » s'utilise avec un tableau ou un dictionnaire`	`supprime` sur une variable qui n'est ni un tableau ni un dictionnaire.	Vérifier le type de la variable.
`« supprime » attend le nom d'un tableau puis un indice, ex : supprime mesNotes 0 (trouvé : …)`	Syntaxe incomplète de `supprime`.	Écrire `supprime mesNotes 0`.
`Index … hors limites pour "…"`	La case demandée n'existe pas : les indices vont de 0 à longueur − 1.	Vérifier l'indice, ou agrandir le tableau avec `ajoute` ou `taille`.
`Après …[...] on attend "vaut", "ajoute" ou "soustrait"`	Une case de tableau est écrite seule sur la ligne.	Compléter : `t[0] vaut 5`.

Dictionnaires

Un dictionnaire associe une clé texte à une valeur. La clé doit exister avant toute lecture.

Message d'erreur	Cause probable	Solution
`Clé de dictionnaire invalide : la clé doit être un texte`	Une clé numérique ou booléenne a été utilisée.	Convertir la clé : `d[convertir_texte(i)]`.
`Clé inconnue : "…"`	Lecture d'une clé absente du dictionnaire.	Tester avec `contient(d, 'clé')` avant de lire.
`Clé inconnue : d['ville']`	Suppression ou lecture d'une clé qui n'existe pas.	Vérifier les clés disponibles avec `cles(d)`.
`Dictionnaire vide : "d"`	Opération nécessitant au moins une entrée.	Ajouter des entrées avant : `d['clé'] vaut …`.
`Après d[...] on attend "vaut" ou "ajouter"`	Après un accès indexé sur dictionnaire, seuls ces deux mots-clés sont acceptés.	Écrire `d['clé'] vaut valeur`.
`cles : l'argument doit être un dictionnaire`	`cles()` appelée sur autre chose.	Passer un dictionnaire.
`fusionner : le premier argument doit être un dictionnaire`	Mélange de types dans une fusion.	Fusionner deux dictionnaires entre eux.
`fusionner : le second argument doit être un dictionnaire`	Le premier argument est un dictionnaire, pas le second.	Aligner les deux types.
`Clé inconnue : d['vile']. Vouliez-vous dire 'ville' ?`	La clé lue n'existe pas, mais une clé proche existe.	Corriger la clé avec la suggestion.
`Clé inconnue : d['ville'] (le dictionnaire est vide)`	Lecture d'une clé dans un dictionnaire encore vide.	Ajouter la clé avant de la lire : `d['ville'] vaut 'Lyon'`.
`Clé inconnue : d['ville'] (vérifiez avec contient(dictionnaire, clé) avant de lire une clé)`	La clé n'existe pas et ne ressemble à aucune clé existante.	Tester d'abord : `si contient(d, 'ville') alors`.
`« soustrait » ne s'applique pas à une clé de dictionnaire (« d ») : écrivez d[clé] vaut d[clé] - valeur`	`d['n'] soustrait 1` n'est pas pris en charge.	Écrire l'opération complète : `d['n'] vaut d['n'] - 1`.
`« d » est un dictionnaire : une seule clé entre crochets, ex : d['nom'] vaut ...`	Plusieurs clés ou index entre crochets (`d['a', 'b']`).	Une seule clé par accès.

Enregistrements, classes et champs

Un champ doit être créé par une affectation avant d'être lu. Les types de champ sont figés une fois le champ créé.

Message d'erreur	Cause probable	Solution
`"x" n'est pas un enregistrement`	Accès `x.champ` sur une variable d'un autre type.	Déclarer `x est un enregistrement`.
`"x" n'est pas un objet ni un enregistrement`	Accès par point sur une valeur qui n'est ni une instance de classe ni un enregistrement.	Vérifier le type avec `type_de(x)`.
`Champ inconnu : "nom"`	Le champ n'a jamais été créé.	Créer le champ d'abord : `x.nom vaut 'Alice'`, ou tester avec `existe()`.
`Enregistrement vide : "x"`	Opération demandée sur un enregistrement sans aucun champ.	Ajouter au moins un champ.
`"x.champ" est de type …, impossible d'affecter un …`	Le champ change de type entre deux affectations.	Conserver le type initial, ou convertir la valeur.
`"x.champ" est de type nombre, impossible d'ajouter un …`	`ajoute` sur un champ numérique avec une valeur non numérique.	Convertir avant d'ajouter.
`"x.champ" est de type …, "soustrait" réservé aux nombres`	`soustrait` sur un champ non numérique.	N'utiliser `soustrait` que sur des champs nombre.
`champs: argument doit être un enregistrement`	`champs()` liste les champs d'un enregistrement.	Passer un enregistrement.
`existe: premier argument doit être un enregistrement`	Test d'existence de champ sur un autre type.	Pour un dictionnaire, utiliser `contient()`.
`supprime_champ: premier argument doit être un enregistrement`	Suppression de champ sur un autre type.	Passer un enregistrement.
`Champ inconnu : « x.nom » (champs existants : prenom, age)`	Le champ lu n'existe pas. Le message liste les champs disponibles, ou propose un nom proche (« Vouliez-vous dire … ? »).	Corriger le nom, ou créer le champ avant de le lire : `x.nom vaut 'Alice'`.
`Champ inconnu : « x.nom » (cet enregistrement n'a encore aucun champ)`	Lecture d'un champ dans un enregistrement vide.	Affecter le champ avant de le lire.
`« x » est un nombre, pas un enregistrement : la notation « x.nom » est impossible`	Notation pointée sur une variable qui n'est pas un enregistrement.	Déclarer `x est un enregistrement`.
`Pour donner une valeur au champ, écrivez « x.nom vaut ... » (le signe = sert à comparer)`	Affectation d'un champ avec `=`.	Écrire `x.nom vaut 'Alice'`.
`Instruction incomplète sur le champ « x.nom » : on attend « vaut », « ajoute » ou « soustrait » (trouvé : …)`	Une ligne commence par `x.nom` sans instruction derrière.	Compléter l'instruction ou utiliser `affiche x.nom`.
`Nom de champ attendu après « x. » (trouvé : …)`	Le point n'est pas suivi d'un nom de champ.	Écrire le nom du champ juste après le point, sans espace.
`classe attend un nom`	`classe` n'est pas suivi d'un nom.	Écrire `classe Eleve` puis ses champs.
`Nom de champ attendu dans la classe "Eleve"`	Une ligne de la classe ne commence pas par un nom de champ.	Chaque ligne déclare un champ : `nom est un texte`.
`Nom de champ attendu après "," dans la classe "Eleve"`	Une virgule n'est pas suivie d'un nom de champ.	Écrire `nom, prenom est un texte`.
`Type de champ inconnu dans la classe : "…"`	Le type d'un champ n'existe pas.	Utiliser un type valide (nombre, texte, booléen, tableau, date…).

Conditions, boucles et contrôle de flux

Les boucles sont protégées par une limite d'itérations : au-delà, CoddyRun considère qu'il s'agit d'une boucle infinie et interrompt le programme.

Message d'erreur	Cause probable	Solution
`"pas" ne peut pas être 0`	Une boucle `pour` avec un pas nul ne progresse jamais.	Utiliser un pas non nul : positif pour monter, négatif pour descendre.
`"pour" attend un identifiant`	Le mot-clé `pour` n'est pas suivi d'un nom de variable.	Écrire `pour i de 1 à 10`.
`La boucle "…" dépasse … itérations (probable boucle infinie).`	La condition de sortie n'est jamais satisfaite.	Vérifier que la variable testée est bien modifiée dans le corps de la boucle.
`"répète … fois" dépasse la limite de … itérations.`	Le nombre de répétitions demandé est trop grand.	Réduire le nombre, ou restructurer l'algorithme.
`"arrete" ne peut être utilisé qu'à l'intérieur d'une boucle`	`arrete` placé hors d'une boucle.	Le déplacer dans un `pour`, `tant que` ou `répète`.
`"continue" ne peut être utilisé qu'à l'intérieur d'une boucle`	`continue` placé hors d'une boucle.	Même correction.
`Il manque « alors » après la condition du « si » (trouvé : …)`	La condition n'est pas suivie de `alors`. Un conseil est ajouté si un `==` ou un opérateur manquant est repéré.	Terminer la ligne par `alors` : `si x > 3 alors`.
`« sinon » ne prend pas de condition : pour un autre cas, écrivez « sinon si condition alors »`	Une condition est écrite après `sinon`.	Écrire `sinon si x > 3 alors`.
`Dans un « selon », chaque cas commence par « cas », ex : cas 1 : (trouvé : …)`	Une ligne du `selon` ne commence ni par `cas` ni par `sinon selon`.	Commencer chaque cas par `cas valeur :`.
`Il manque « : » après la valeur du « cas », ex : cas 1 : (trouvé : …)`	Les deux-points sont oubliés après la valeur.	Écrire `cas 1 :`.
`Il manque « : » après « sinon selon » (trouvé : …)`	Les deux-points sont oubliés après le cas par défaut.	Écrire `sinon selon :`.
`« tant que » ne prend pas « alors » : écrivez simplement « tant que condition » puis le corps de la boucle`	Confusion avec la syntaxe du `si`.	Retirer `alors` : `tant que x < 10`.
`Pour comparer dans la condition, utilisez « = », ex : tant que x = 3`	Une condition de boucle contient `vaut` ou `==`.	Comparer avec un seul `=`.
`« pour » attend le nom de la variable de boucle, ex : pour i de 1 à 10 (trouvé : …)`	Le `pour` n'est pas suivi d'un nom de variable.	Écrire `pour i de 1 à 10`.
`Forme attendue : pour i de 1 à 10 (il manque « de ») (trouvé : …)`	Le mot `de` manque après la variable de boucle.	Écrire `pour i de 1 à 10`.
`Forme attendue : pour i de 1 à 10 (il manque « à ») (trouvé : …)`	Le mot `à` manque entre les deux bornes.	Écrire `pour i de 1 à 10` (le `à` peut s'écrire sans accent).
`« répète » attend un nombre de tours suivi de « fois », ex : répète 3 fois (trouvé : …)`	Le mot `fois` manque après le nombre de tours.	Écrire `répète 3 fois`.
`La boucle « tant que » dépasse … tours : probable boucle infinie. Vérifiez que la condition finit par devenir fausse (la variable testée change-t-elle dans la boucle ?)`	La condition reste vraie indéfiniment : la variable testée n'est jamais modifiée dans la boucle.	Modifier la variable dans le corps de la boucle : `i ajoute 1`.
`La boucle « pour » dépasse … tours : intervalle trop grand ou pas trop petit`	Les bornes sont très éloignées ou le `pas` est minuscule.	Réduire l'intervalle ou augmenter le pas.
`« arrête » ne s'utilise qu'à l'intérieur d'une boucle (pour, tant que, répète). Pour arrêter le programme, utilisez « terminer ».`	`arrête` en dehors de toute boucle.	Pour quitter le programme : `terminer`.
`« continue » ne s'utilise qu'à l'intérieur d'une boucle (pour, tant que, répète)`	`continue` en dehors de toute boucle.	Placer `continue` dans une boucle, ou le retirer.
`pause attend une durée en millisecondes (30 à 3000), ex : pause 500`	La durée de `pause` manque ou sort de l'intervalle autorisé.	Écrire une durée entre 30 et 3000 : `pause 500`.

Fonctions, procédures et processus

Les sous-programmes vérifient leur nom, le nombre de paramètres et l'unicité des noms au moment de l'appel.

Message d'erreur	Cause probable	Solution
`Fonction/procédure inconnue : "f"`	Le nom appelé n'existe ni dans le programme, ni parmi les fonctions intégrées.	Vérifier l'orthographe, et que la définition précède l'appel.
`"f" : 2 paramètre(s) attendu(s), 1 fourni(s)`	Le nombre d'arguments ne correspond pas à la signature.	Comparer l'appel à la ligne `fonction f(...)`.
`Paramètre en double : "x"`	Deux paramètres portent le même nom dans une définition.	Renommer l'un des deux.
`Nom de paramètre interdit : "…" est un mot réservé`	Un paramètre porte le nom d'un mot-clé.	Choisir un autre nom.
`Nom de paramètre interdit : "…" est un nom de type`	Un paramètre porte un nom de type.	Choisir un autre nom.
`Nom de paramètre interdit : "…" est une fonction native`	Collision avec une fonction intégrée.	Renommer le paramètre.
`Nom de paramètre interdit : "…" est déjà une fonction ou une procédure`	Collision avec un sous-programme du fichier.	Renommer le paramètre.
`retourne attend une expression`	`retourne` est seul sur sa ligne.	Indiquer la valeur renvoyée : `retourne total`.
`appelle attend un nom de procédure`	`appelle` n'est pas suivi d'un nom valide.	Écrire `appelle maProcedure(…)`.
`Un seul processus est autorisé par programme : « … » est déjà défini, « … » ne peut pas être ajouté.`	Deux blocs `processus` dans le même fichier.	Fusionner les deux en un seul processus.
`Fonction inconnue : « longeur ». Vouliez-vous dire « longueur » ?`	Le nom appelé ressemble à une fonction native ou à une fonction du programme.	Corriger le nom avec la suggestion.
`Fonction inconnue : « … » : ce n'est ni une fonction native, ni une fonction, procédure ou processus défini dans le programme`	Le nom appelé n'existe nulle part.	Définir la fonction (`fonction calcul(x)` … `fin fonction`) ou vérifier son nom.
`« t » est une variable, pas une fonction : pour lire un élément de tableau, utilisez des crochets, ex : t[0]`	Des parenthèses sont utilisées après un nom de variable (`t(0)`).	Utiliser les crochets : `t[0]`.
`« f » attend 2 paramètre(s) (a, b), mais 1 valeur(s) ont été données`	Le nombre d'arguments de l'appel ne correspond pas à la définition. Le message rappelle les paramètres.	Passer une valeur par paramètre : `f(3, 4)`.
`« f » n'attend aucun paramètre, mais 2 valeur(s) ont été données`	Appel avec des arguments d'une fonction définie sans paramètre.	Appeler `f()` sans argument, ou ajouter les paramètres à la définition.
`« moyenne » est déjà une fonction native de CoddyRun : votre fonction ne serait jamais appelée. Choisissez un autre nom (ex : mon_moyenne).`	Une fonction, procédure ou processus du programme porte le nom d'une fonction intégrée.	Renommer : `fonction ma_moyenne(t)`.
`« calcul » est déjà définie ligne … : deux fonctions, procédures ou processus ne peuvent pas porter le même nom.`	Deux définitions portent le même nom.	Renommer l'une des deux, ou supprimer le doublon.
`« fonction » doit être suivi d'un nom, ex : fonction calcul(x)`	`fonction`, `procédure` ou `processus` sans nom.	Écrire `fonction calcul(x)`.
`Nom interdit après « fonction » : « si » est un mot réservé du langage`	Le nom choisi est un mot-clé.	Choisir un autre nom (voir le chapitre Mots-clés).
`Paramètres de « calcul » incomplets : il manque « ) »`	La liste des paramètres n'est pas refermée.	Fermer la parenthèse : `fonction calcul(a, b)`.
`Nom de paramètre attendu dans « calcul(...) », mais trouvé « … »`	Un élément de la liste des paramètres n'est pas un nom (valeur, symbole…).	Les paramètres sont des noms séparés par des virgules.
`Il manque « ) » pour fermer les paramètres de « calcul » (les paramètres sont séparés par des virgules : calcul(a, b))`	Paramètres séparés par des espaces, ou parenthèse oubliée.	Écrire `fonction calcul(a, b)`.
`La fonction « calcul » n'est jamais fermée : il manque « fin fonction »`	Une fonction n'a pas de ligne de fermeture.	Ajouter `fin fonction` à la fin du corps.
`La procédure « dessiner » n'est jamais fermée : il manque « fin procédure »`	Une procédure n'a pas de ligne de fermeture.	Ajouter `fin procédure`.
`Le processus « horloge » n'est jamais fermé : il manque « fin processus »`	Un processus n'a pas de ligne de fermeture.	Ajouter `fin processus`.
`La fonction « calcul » s'est terminée sans exécuter « retourne » : elle n'a aucune valeur à renvoyer ici. Vérifiez que chaque cas (si / sinon...) se termine par « retourne ... ».`	La fonction contient un `retourne`, mais le chemin suivi n'en a exécuté aucun (cas non prévu d'un `si`).	Ajouter un `retourne` dans chaque branche, ou un `retourne` final par défaut.
`La fonction « calcul » ne contient aucun « retourne » : elle ne produit pas de valeur et ne peut pas être utilisée dans un calcul ou un affichage. Ajoutez « retourne ... » dans la fonction, ou faites-en une procédure appelée seule sur sa ligne.`	Une fonction sans `retourne` est utilisée comme une valeur.	Ajouter `retourne résultat`, ou transformer la fonction en procédure.
`« dessiner » est une procédure : elle ne renvoie pas de valeur et ne peut pas être utilisée dans un calcul, une condition ou un affichage. Appelez-la seule sur sa ligne (dessiner(...)), ou faites-en une fonction avec « retourne ».`	Une procédure est utilisée dans une expression (`affiche dessiner()`).	Appeler la procédure seule sur sa ligne : `dessiner()`.
`« horloge » est un processus : il ne renvoie pas de valeur. Démarrez-le seul sur sa ligne, ex : horloge()`	Un processus est utilisé dans une expression.	Démarrer le processus seul sur sa ligne.
`« horloge » n'est pas un processus`	`suspendre` ou `reprendre` vise un nom qui n'est pas un processus.	Indiquer le nom d'un processus défini dans le programme.
`« demande » n'est pas autorisé dans un processus : seul le programme principal peut demander une saisie à l'utilisateur.`	Un processus utilise `demande`, `choisir`, `appuyer`, `cliquer` ou `interagir`.	Faire la saisie dans le programme principal et partager la valeur par une variable.
`« appelle » attend le nom d'une procédure, ex : appelle dessiner(3) (trouvé : …)`	`appelle` n'est pas suivi d'un nom.	Écrire `appelle dessiner(3)`, ou simplement `dessiner(3)`.
`« retourne » ne s'utilise que dans une fonction ou une procédure. Pour arrêter le programme, utilisez « terminer ».`	`retourne` dans le programme principal.	Utiliser `terminer` pour arrêter le programme.
`« retourne » attend la valeur à renvoyer, ex : retourne x * 2`	`retourne` seul dans une fonction.	Indiquer la valeur : `retourne x * 2`.
`Récursion trop profonde (… appels imbriqués) : « f » s'appelle peut-être elle-même sans condition d'arrêt (vérifiez le cas de base : un « si » qui retourne sans rappeler « f »).`	Une fonction récursive ne s'arrête jamais : son cas de base manque ou n'est jamais atteint.	Ajouter un cas de base : `si n <= 1 alors` / `retourne 1` avant l'appel récursif.
`« … » attend … paramètre(s), mais … valeur(s) ont été données`	L'appel ne donne pas autant de valeurs que la définition a de paramètres.	Ajouter ou retirer des valeurs dans l'appel, ou modifier la définition.

Entrées utilisateur : demande, choisir, appuyer, cliquer, interagir

Ces instructions stockent leur résultat dans une variable existante, dont le type doit correspondre à ce qui est reçu.

Message d'erreur	Cause probable	Solution
`demande "texte" attend le mot-clé "dans"`	La destination du résultat n'est pas indiquée.	Écrire `demande 'Ton nom ?' dans nom`.
`demande sur tableau non supporté : "t"`	Une saisie ne peut pas remplir directement un tableau.	Lire dans une variable simple, puis `t ajoute valeur`.
`demande sur enregistrement non supporté : "x"`	Une saisie ne peut pas remplir directement un enregistrement.	Lire champ par champ.
`choisir attend une liste entre crochets, ex : choisir ['A', 'B'] dans x, ou un tableau, ex : choisir mesOptions dans x`	Les options ne sont ni un littéral entre crochets ni un tableau.	Fournir une des deux formes.
`choisir attend au moins une option`	La liste d'options est absente.	Proposer au moins un choix.
`choisir : le tableau d'options est vide`	Le tableau passé ne contient aucun élément.	Le remplir avant l'appel.
`choisir : crochet fermant "]" attendu`	La liste d'options n'est pas refermée.	Ajouter le `]`.
`choisir attend le mot-clé "dans"`	La variable de destination n'est pas indiquée.	Écrire `choisir [...] dans x`.
`choisir ... dans attend un nom de variable`	Après `dans`, il faut un identifiant.	Indiquer une variable déjà déclarée.
`choisir : la variable "x" doit être de type nombre`	`choisir` renvoie l'indice de l'option retenue.	Déclarer `x est un nombre`.
`choisir : la variable "x" doit être déclarée comme un nombre (ex : x est un nombre)`	La variable de destination n'est pas déclarée.	La déclarer avant l'instruction.
`appuyer attend une liste de touches entre crochets, ex : appuyer ['z', 's', 'd', 'q'] dans action`	La liste de touches est mal formée.	Utiliser la forme documentée.
`appuyer attend au moins une touche`	Aucune touche n'est surveillée.	Indiquer au moins une touche.
`appuyer : crochet fermant "]" attendu`	La liste de touches n'est pas refermée.	Ajouter le `]`.
`appuyer attend le mot-clé "dans"`	La variable de destination manque.	Écrire `appuyer [...] dans action`.
`appuyer ... dans attend un nom de variable`	Après `dans`, il faut un identifiant.	Indiquer une variable déclarée.
`appuyer : la variable "x" doit être de type nombre`	L'indice de la touche pressée est un nombre.	Déclarer la variable comme nombre.
`appuyer : la variable "x" doit être déclarée comme un nombre (ex : x est un nombre)`	Variable de destination non déclarée.	La déclarer avant.
`cliquer attend le mot-clé "dans", ex : cliquer maToile dans x, y`	La syntaxe attendue n'est pas respectée.	Suivre l'exemple donné dans le message.
`cliquer ... dans attend des noms de variables, ex : cliquer maToile dans x, y`	Il faut deux variables : abscisse et ordonnée.	Déclarer `x` et `y` comme nombres.
`cliquer : virgule attendue entre les variables (x, y)`	La virgule séparant les deux variables manque.	Écrire `… dans x, y`.
`cliquer : la variable "x" doit être de type nombre`	Les coordonnées sont des nombres.	Déclarer les deux variables comme nombres.
`cliquer : la variable "x" doit être déclarée comme un nombre (ex : x est un nombre)`	Variable non déclarée.	La déclarer avant l'instruction.
`cliquer n'accepte pas de délai, ex : cliquer maToile dans x, y`	Un argument supplémentaire a été ajouté.	Supprimer le délai.
`interagir attend une virgule puis une liste de touches, ex : interagir maToile, ['z', 's'] dans action, x, y`	La toile et la liste de touches doivent être séparées par une virgule.	Suivre l'exemple du message.
`interagir attend une liste de touches entre crochets, ex : interagir maToile, ['z', 's', 'd', 'q'] dans action, x, y`	Liste de touches mal formée.	Encadrer les touches par des crochets.
`interagir attend au moins une touche`	Aucune touche surveillée.	Indiquer au moins une touche.
`interagir : crochet fermant "]" attendu`	Liste non refermée.	Ajouter le `]`.
`interagir attend le mot-clé "dans", ex : ... dans action, x, y`	Les variables de destination manquent.	Ajouter `dans action, x, y`.
`interagir ... dans attend des noms de variables`	Trois variables sont attendues après `dans`.	Déclarer `action`, `x` et `y`.
`interagir : virgule attendue entre les variables (action, x, y)`	Une virgule manque entre les destinations.	Séparer les trois variables par des virgules.
`interagir : la variable "x" doit être de type nombre`	Les trois destinations sont numériques.	Déclarer chacune comme nombre.
`interagir : la variable "x" doit être déclarée comme un nombre (ex : x est un nombre)`	Variable non déclarée.	La déclarer avant.
`Saisie invalide pour « age » : 'abc' n'est pas un nombre. Astuce : entourez la demande d'un bloc essayer / attraper pour redemander, ou déclarez « age » comme texte puis vérifiez-le avec est_nombre(...)`	L'utilisateur a saisi un texte dans une variable déclarée nombre.	Entourer la saisie d'un `essayer` … `attraper` … `fin essayer`, ou lire un texte puis le tester avec `est_nombre(...)`.
`Il manque « dans » : écrivez demande 'Votre nom ?' dans nom (trouvé : …)`	Le mot `dans` manque après la question.	Écrire `demande 'Votre nom ?' dans nom`.
`« demande » attend un nom de variable, ex : demande 'Votre âge ?' dans age (trouvé : …)`	Aucune variable de destination n'est indiquée.	Ajouter `dans` suivi d'un nom de variable.
`« demande ... dans » attend un nom de variable (trouvé : …)`	Après `dans`, un nom de variable est attendu.	Écrire un nom de variable (ou un champ : `eleve.nom`).
`demande ne peut pas remplir le tableau « notes » directement : demandez dans une variable texte, puis ajoutez-la (notes ajoute reponse)`	La destination de `demande` est un tableau entier.	Demander dans une variable, puis `notes ajoute reponse`.
`demande ne peut pas remplir l'enregistrement « eleve » en entier : demandez chaque champ, ex : demande dans eleve.nom`	La destination de `demande` est un enregistrement entier.	Demander champ par champ : `demande 'Nom ?' dans eleve.nom`.
`« x » est un nombre, pas un enregistrement : « demande dans x.nom » est impossible`	La destination est un champ d'une variable qui n'est pas un enregistrement.	Déclarer `x est un enregistrement`.
`interagir ... dans attend des noms de variables, ex : interagir maToile, ['z'] dans action, x, y`	Après `dans`, les trois variables de destination manquent.	Indiquer trois variables : action, x et y.
`Saisie invalide pour « … » : '…' n'est pas un nombre. Astuce : déclare « … » comme texte, puis vérifie-la avec est_nombre(...)`	Une zone `saisie` reliée à une variable nombre contient autre chose qu'un nombre au moment du `cliquer`.	Entourer l'attente de `essayer` / `attraper`, ou déclarer la variable comme texte et la tester avec `est_nombre`.
`saisie attend une variable en 2e argument, ex : prenom est un texte, puis saisie(maToile, prenom, 20, 40, 200, 30)`	Le 2^e argument est une valeur (texte entre guillemets, nombre, case de tableau, champ) au lieu d'un nom de variable.	Déclarer une variable puis donner son nom.
`saisie : « … » doit être un texte ou un nombre (ex : … est un texte)`	La variable est d'un autre type (booléen, tableau…).	Déclarer la variable comme `texte` ou `nombre`.
`saisie : « … » est une constante, elle ne peut pas recevoir de texte tapé`	Une constante ne peut pas changer de valeur.	Utiliser une variable ordinaire.
`saisie : la largeur et la hauteur doivent valoir au moins 10`	La zone serait trop petite pour être utilisable.	Donner au moins 10 pixels de largeur et de hauteur.
`… : touche inconnue « … ». Indique une lettre ou un chiffre (ex : …('z')), ou haut, bas, gauche, droite, espace, entrée, échap`	Le nom de touche donné à `touche_enfoncée` ou `touche_pressée` n'existe pas.	Utiliser une lettre, un chiffre ou un nom reconnu (les noms anglais up, down, left, right, space, enter, escape sont acceptés).
`demande "texte" dans attend un nom de variable`	Après `dans`, il manque la variable qui reçoit la réponse.	Écrire `demande 'Ton nom ?' dans nom`.
`demande <var> dans attend un nom de variable`	La question vient d'une variable, mais la variable de réponse manque après `dans`.	Compléter : `demande question dans reponse`.
`demande attend un nom de variable`	`demande` est seul sur la ligne.	Donner la variable : `demande age`.

Dates et heures

Les fonctions de date acceptent une valeur date ou un texte au format reconnu ; celles d'heure une valeur heure ou un texte. Les messages ci-dessous se déclinent pour chaque fonction concernée.

Message d'erreur	Cause probable	Solution
`… : date invalide`	Le texte fourni ne correspond à aucune date lisible. Concerne `année_de`, `mois_de`, `jour_de`, `jour_semaine`, `semaine_de`, `ajouter_jours`, `ajouter_mois`, `ajouter_années`, `format_date`, `vers_date`.	Utiliser le format documenté au chapitre Date & Heure, ou `convertir_date()`.
`… : attend une date ou un texte`	L'argument est d'un type incompatible (nombre, booléen, tableau…).	Passer une variable `date` ou un texte.
`… : le premier argument doit être une date ou un texte`	Même cause pour les fonctions à plusieurs arguments.	Corriger le premier argument.
`… : heure invalide`	Texte d'heure non reconnu. Concerne `heure_de`, `minute_de`, `seconde_de`, `ajouter_heures`, `ajouter_minutes`, `vers_heure`.	Respecter le format `hh:mm:ss`.
`… : attend une heure ou un texte`	Argument d'un type incompatible.	Passer une variable `heure` ou un texte.
`… : le premier argument doit être une heure ou un texte`	Même cause pour les fonctions à plusieurs arguments.	Corriger le premier argument.
`jours_entre: date invalide (argument 1)`	La première date n'est pas lisible.	Corriger ou convertir cette date.
`jours_entre: date invalide (argument 2)`	La seconde date n'est pas lisible.	Corriger ou convertir cette date.
`jours_entre: le premier argument doit être une date ou un texte`	Type incompatible en première position.	Passer une date ou un texte.
`jours_entre: le second argument doit être une date ou un texte`	Type incompatible en seconde position.	Passer une date ou un texte.
`est_bissextile : attend une année ou une date`	L'argument n'est ni un nombre d'année ni une date.	Passer `2026` ou une variable date.
`est_bissextile : année hors limites (1 à 9999)`	L'année demandée sort du calendrier supporté.	Rester entre 1 et 9999.
`format_date : le motif ne doit pas être vide`	Aucun motif de formatage fourni.	Passer un motif, par exemple `'jj/mm/aaaa'`.
`format_date : motif invalide "…"`	Le motif contient des symboles non reconnus.	Se référer au tableau des motifs du chapitre Date & Heure.

Toile, dessin et animation

Toutes les fonctions de dessin attendent une toile en premier argument et vérifient leurs bornes (tailles, angles, nombre de points).

Message d'erreur	Cause probable	Solution
`toile : dimensions invalides (1 a 1000)`	La toile créée est trop petite ou trop grande.	Choisir une largeur et une hauteur entre 1 et 1000.
`dimension : taille 1 a 1000`	Redimensionnement hors bornes.	Rester dans l'intervalle autorisé.
`… : le 1er argument doit etre une toile`	Une fonction de dessin a reçu autre chose qu'une toile.	Créer la toile avec `t est une toile` et la passer en premier.
`… : toile introuvable`	La toile référencée n'existe plus (variable écrasée ou hors portée).	Conserver la toile dans une variable accessible.
`contour : l'épaisseur doit être comprise entre 1 et 100`	Épaisseur de trait hors bornes.	Passer une valeur entre 1 et 100.
`grille : le pas doit être >= 1`	Un pas nul ou négatif produirait une infinité de lignes.	Passer un pas d'au moins 1.
`grille : pas trop petit (trop de lignes)`	Le pas génère plus de lignes que la toile ne peut en contenir.	Augmenter le pas.
`pixel : trop d'elements sur la toile (max 1 000 000)`	Limite de complexité du dessin atteinte.	Dessiner des formes plutôt que des pixels un à un, ou effacer la toile.
`courbe : le tableau doit contenir au moins 2 points (paires x,y)`	Une courbe a besoin de deux points minimum.	Fournir au moins quatre valeurs (x1, y1, x2, y2).
`courbe(toile, x1, y1, x2, y2, ... [, couleur]) : au moins 2 points (paires x,y)`	Coordonnées incomplètes en appel direct.	Compléter les paires de coordonnées.
`polygone(toile, x1, y1, ... [, couleur]) : au moins 3 points (paires x,y)`	Un polygone exige trois sommets.	Ajouter les points manquants.
`fleche(toile, x1, y1, x2, y2, ... [, couleur [, epaisseur [, pointe]]]) : au moins 2 points (paires x,y)`	Une flèche relie au moins deux points.	Compléter les coordonnées.
`histogramme : le tableau est vide`	Aucune valeur à représenter.	Remplir le tableau avant l'appel.
`degrade : il faut au moins 2 couleurs`	Un dégradé a besoin d'une couleur de départ et d'arrivée.	Fournir au moins deux couleurs.
`degrade : le 2e argument doit etre un tableau de couleurs, ex : degrade(toile, [#3f87a6, #ebf8e1, #f69d3c])`	Le second argument n'est pas un tableau.	Écrire par exemple `degrade(toile, ['#3f87a6', '#f69d3c'])`.
`label : la taille doit être comprise entre 1 et 100`	Taille de texte hors bornes.	Passer une valeur entre 1 et 100.
`label : l'angle doit être compris entre -180 et 180`	Rotation du texte hors bornes.	Ramener l'angle dans cet intervalle.
`label_hauteur : la taille doit être comprise entre 1 et 100`	Taille hors bornes.	Corriger la taille.
`label_largeur : la taille doit être comprise entre 1 et 100`	Taille hors bornes.	Corriger la taille.
`icone : la taille doit être comprise entre 1 et 400`	Taille d'icône hors bornes.	Passer une valeur entre 1 et 400.
`icone : point de code Unicode invalide "…" (ex. $E735)`	Le code d'icône n'est pas au format attendu.	Utiliser la notation hexadécimale `$E735`.
`icone : point de code Unicode hors limites`	Le point de code dépasse le maximum Unicode.	Choisir un code valide.
`clique(x, y, x_coin, y_coin, largeur, hauteur) pour une zone rectangulaire, ou clique(x, y, cx, cy, rayon) pour une zone circulaire`	Le nombre d'arguments ne correspond à aucune des deux formes.	Choisir la forme rectangulaire (6 arguments) ou circulaire (5 arguments).
`animation : le 1er argument doit être un tableau de toiles`	L'animation s'alimente d'un tableau d'images.	Construire un tableau et y ajouter les toiles une à une.
`animation : le tableau ne contient aucune image`	Le tableau d'images est vide.	Ajouter au moins une toile avant de lancer l'animation.
`animation : l'élément … n'est pas une toile`	Un élément du tableau n'est pas une image.	Vérifier ce que contient le tableau.
`svg : le fichier doit être un ".svg" (reçu "…")`	Extension de fichier non autorisée.	Fournir un fichier `.svg`.
`svg : fichier introuvable "…"`	Le chemin ne pointe vers aucun fichier.	Vérifier le chemin, absolu ou relatif au programme.
`svg : impossible de lire "…" (…)`	Le fichier existe mais n'est pas lisible.	Vérifier les droits d'accès.
`svg : "…" ne contient pas de balise <svg>`	Le contenu n'est pas un SVG valide.	Ouvrir le fichier pour vérifier son contenu.
`svg : image vide`	La source ne contient aucun élément dessinable.	Utiliser une image non vide.
`svg : la largeur et la hauteur doivent être supérieures à 0`	Dimensions d'incrustation nulles ou négatives.	Passer des dimensions positives.
`svg : le 4e argument doit être une toile, une image ou un chemin de fichier`	Source d'incrustation d'un type non supporté.	Passer une toile, une image importée ou un chemin.
`svg : une toile ne peut pas s'incruster elle-même`	Incrustation récursive détectée.	Utiliser une seconde toile comme source.
`enregistrer : le chemin est vide`	Aucun chemin de sortie fourni.	Indiquer un chemin de fichier.
`enregistrer : seuls les fichiers .svg sont autorisés (obtenu : "…")`	Une toile ne s'enregistre qu'au format SVG.	Terminer le chemin par `.svg`.
`enregistrer : le dossier destination n'existe pas : "…"`	Le dossier de sortie est introuvable.	Créer le dossier, ou corriger le chemin.
`enregistrer : impossible d'écrire dans "…" : …`	Écriture refusée par le système.	Vérifier les droits d'écriture et que le fichier n'est pas ouvert ailleurs.
`fonction indisponible pendant la lecture d'un dessin`	Pendant la lecture d'un dessin, le programme s'exécute en mode protégé : les fonctions de fichier, de réseau, de son et d'écriture de paramètres sont bloquées.	Retirer ces appels du programme de dessin, ou les exécuter en dehors de la lecture.
`processus indisponible pendant la lecture d'un dessin`	Un processus est démarré pendant la lecture (exécution protégée) d'un dessin.	Démarrer le processus en dehors de la lecture.
`son : le 2e argument doit être un booléen (vrai ou faux)`	Le second argument de `son` (lecture en boucle) n'est pas un booléen.	Écrire `son('musique.wav', vrai)`.
`son : seuls les fichiers .wav sont pris en charge : "…"`	Le fichier son n'est pas au format WAV.	Convertir le fichier en .wav.
`histogramme(toile, valeurs... [, couleur]) : au moins une valeur`	Aucune valeur n'est passée après la toile.	Passer un tableau ou au moins une valeur.

Fichiers, paramètres et réseau

Pour des raisons de sécurité, la lecture et l'écriture sont limitées à quelques extensions, les dossiers doivent exister, et seules les URL https:// sont acceptées.

Message d'erreur	Cause probable	Solution
`importer : seuls les fichiers .txt et .csv sont autorisés (obtenu : "…")`	Extension non autorisée en lecture.	Convertir le fichier en `.txt` ou `.csv`.
`importer : fichier introuvable : "…"`	Le chemin ne correspond à aucun fichier.	Vérifier le chemin et le nom exact, accents compris.
`importer : fichier trop volumineux (… octets, maximum 1 Mo)`	La taille dépasse la limite de sécurité.	Découper le fichier ou n'en lire qu'une partie.
`importer : contenu URL trop volumineux (… octets, maximum 1 Mo)`	Même limite appliquée au contenu distant.	Utiliser une ressource plus légère.
`importer : les URLs non sécurisées (http://) ne sont pas autorisées. Utilisez https:// à la place.`	Seul HTTPS est accepté.	Remplacer `http://` par `https://`.
`importer : impossible de récupérer l'URL "…" : …`	Échec réseau (hors ligne, domaine injoignable, certificat).	Vérifier la connexion et l'adresse.
`importer : l'URL "…" a retourné le code HTTP …`	Le serveur a répondu par une erreur (404, 403, 500…).	Vérifier que l'adresse est publique et valide.
`importer : "…" ne contient pas de balise <svg>`	Le contenu importé n'est pas un SVG.	Vérifier la ressource visée.
`sauvegarder : seuls les fichiers .txt et .csv sont autorisés (obtenu : "…")`	Extension non autorisée en écriture.	Choisir `.txt` ou `.csv`.
`sauvegarder : le dossier destination n'existe pas : "…"`	Le dossier de sortie est introuvable.	Créer le dossier au préalable.
`sauvegarder : impossible d'écrire dans "…" : …`	Écriture refusée (droits, fichier verrouillé).	Vérifier les permissions.
`ajouter_ligne : seuls les fichiers .txt et .csv sont autorisés (obtenu : "…")`	Extension non autorisée.	Choisir `.txt` ou `.csv`.
`ajouter_ligne : le dossier destination n'existe pas : "…"`	Dossier introuvable.	Corriger le chemin.
`ajouter_ligne : impossible d'écrire dans "…" : …`	Écriture refusée.	Vérifier les droits et la disponibilité du fichier.
`fichier_existe : seuls les fichiers .txt et .csv sont autorisés (obtenu : "…")`	Le test d'existence est limité à ces extensions.	Tester un fichier `.txt` ou `.csv`.
`liste_fichiers : le dossier "…" n'existe pas`	Le dossier à lister est introuvable.	Vérifier le chemin.
`liste_fichiers : lecture de "…" impossible : …`	Le dossier existe mais n'est pas lisible.	Vérifier les droits d'accès.
`liste_fichiers : le 3e argument doit être un tableau`	Le résultat doit être stocké dans un tableau.	Déclarer `t est un tableau` et le passer en 3e position.
`liste_fichiers : le tableau n'est pas initialisé`	Le tableau de destination n'a jamais été créé.	Le déclarer avant l'appel.
`télécharger : URL invalide "…"`	L'adresse n'est pas une URL exploitable.	Fournir une adresse complète commençant par `https://`.
`télécharger : les URLs non sécurisées (http://) ne sont pas autorisées. Utilisez https:// à la place.`	Seul HTTPS est accepté.	Remplacer le protocole.
`télécharger : l'URL "…" a retourné le code HTTP …`	Réponse d'erreur du serveur.	Vérifier que la ressource est accessible publiquement.
`télécharger : impossible de récupérer "…" : …`	Échec réseau.	Vérifier la connexion.
`télécharger : impossible de déterminer le nom du fichier depuis "…"`	L'URL ne se termine pas par un nom de fichier.	Utiliser une URL pointant directement le fichier.
`télécharger : type de fichier non autorisé "…". Extensions acceptées : jpg, jpeg, png, gif, svg, webp, bmp, ico, txt, csv, html`	Extension hors de la liste blanche.	Télécharger un format autorisé.
`télécharger : fichier trop volumineux (… octets, maximum 1 Mo)`	Taille au-delà de la limite.	Choisir une ressource plus petite.
`télécharger : le dossier destination n'existe pas : "…"`	Dossier de réception introuvable.	Créer le dossier avant.
`télécharger : impossible d'écrire "…" : …`	Écriture refusée sur le disque.	Vérifier les droits du dossier.
`ouvrir : le chemin est vide`	Aucune cible fournie.	Indiquer un fichier, un dossier ou une URL.
`ouvrir : fichier ou dossier introuvable : "…"`	La cible n'existe pas.	Vérifier le chemin.
`ouvrir : les URLs non sécurisées (http://) ne sont pas autorisées. Utilisez https:// à la place.`	Seul HTTPS est accepté.	Remplacer le protocole.
`ouvrir : impossible d'ouvrir "…" (code …)`	Le système a refusé l'ouverture.	Vérifier qu'une application est associée à ce type de fichier.
`paramètre(section, clé) pour lire une valeur, paramètre(section, clé, valeur) pour l'enregistrer`	Nombre d'arguments incorrect.	Utiliser la forme à 2 arguments pour lire, à 3 pour écrire.
`paramètre : la section "…" n'existe pas dans …`	Lecture d'une section absente du fichier de paramètres.	L'écrire d'abord, ou vérifier son orthographe.
`paramètre : la clé "…" n'existe pas dans la section "…"`	Lecture d'une clé absente.	L'enregistrer avant de la lire.
`paramètre : le nom de … ne peut pas être vide`	Nom de section ou de clé vide.	Fournir un nom non vide.
`paramètre : le nom de … est trop long (… caractères, max …)`	Nom au-delà de la longueur autorisée.	Raccourcir le nom.
`paramètre : le nom de … ne peut pas contenir "[", "]", "=" ni de retour à la ligne`	Ces caractères sont réservés au format du fichier.	Les retirer du nom.
`paramètre : le texte est trop long (… caractères, max …)`	Valeur au-delà de la longueur autorisée.	Stocker la donnée dans un fichier à part.
`paramètre : le texte ne peut pas contenir de retour à la ligne`	Une valeur doit tenir sur une seule ligne.	Remplacer les sauts de ligne par un séparateur.
`paramètre : seuls un nombre, un texte ou un booléen peuvent être enregistrés`	Type non sérialisable (tableau, enregistrement, toile…).	Convertir en texte avant d'enregistrer.
`paramètre : impossible d'ouvrir "…" : …`	Fichier de paramètres illisible.	Vérifier les droits d'accès.
`paramètre : impossible d'écrire dans "…" : …`	Fichier de paramètres non modifiable.	Vérifier les droits d'écriture.

Conversions et évaluation d'expressions

Les conversions explicites échouent proprement plutôt que de renvoyer une valeur approximative.

Message d'erreur	Cause probable	Solution
`convertir_nombre: texte non convertible en nombre`	Le texte contient des caractères non numériques.	Nettoyer le texte, ou tester avec `est_nombre()`.
`convertir_nombre: type non convertible`	Le type source n'a pas d'équivalent numérique.	Convertir d'abord en texte.
`vers_type : type cible inconnu "…" (attendu : nombre, texte, date ou heure)`	Le type demandé n'est pas supporté par cette fonction.	Utiliser un des quatre types listés.
`vers_type : "…" n'est pas convertible en nombre`	La valeur source n'a pas de lecture numérique.	Vérifier la valeur d'origine.
`vers_type : "…" n'est pas une date valide`	Texte non reconnu comme date.	Respecter le format documenté.
`vers_type : "…" n'est pas une heure valide`	Texte non reconnu comme heure.	Respecter le format `hh:mm:ss`.
`vers_type : conversion vers nombre impossible pour ce type`	Le type source ne peut pas devenir un nombre.	Passer par un texte intermédiaire.
`vers_type : conversion vers date impossible pour ce type`	Le type source ne peut pas devenir une date.	Passer par un texte au bon format.
`vers_type : conversion vers heure impossible pour ce type`	Le type source ne peut pas devenir une heure.	Passer par un texte au bon format.
`vers_decimal : base invalide (2, 8 ou 16 seulement)`	Seules ces trois bases sont gérées.	Passer 2, 8 ou 16.
`vers_decimal : texte vide`	Aucun chiffre à convertir.	Fournir un texte non vide.
`vers_decimal : caractere invalide "…"`	Un caractère n'appartient pas à la base indiquée.	Nettoyer le texte source.
`vers_decimal : chiffre "…" invalide en base …`	Le chiffre dépasse la base (par exemple 9 en base 8).	Corriger la valeur ou la base.
`vers_hexadecimal : largeur trop grande (max 16)`	Le remplissage demandé dépasse la limite.	Passer une largeur inférieure ou égale à 16.
`évaluer : caractère non autorisé "…" (seuls ( ) + - * / , et 0..9 sont permis)`	`évaluer()` n'évalue que de l'arithmétique simple.	Retirer les lettres et symboles non autorisés.
`évaluer : caractère inattendu "…"`	Symbole mal placé dans l'expression.	Vérifier l'écriture de l'expression.
`évaluer : nombre invalide "…"`	Un nombre est mal formé (deux points décimaux, par exemple).	Corriger le nombre.
`évaluer : expression incomplète`	L'expression se termine sur un opérateur.	Compléter l'expression.
`évaluer : parenthèse fermante manquante`	Parenthèses déséquilibrées.	Ajouter la parenthèse manquante.
`évaluer : division par zéro`	L'expression évaluée divise par zéro.	Corriger l'expression.

Erreurs système et limites de l'interpréteur

Quand le processeur ou le système refuse une opération, CoddyRun traduit l'erreur technique en français et y ajoute la ligne fautive. Ces messages sont rares et peuvent aussi être rattrapés par essayer … attraper.

Message d'erreur	Cause probable	Solution
`Division par zéro`	Une division ou un `mod` par 0 détecté par le processeur.	Tester le diviseur avant le calcul.
`Opération numérique invalide : le résultat est indéfini (par exemple la racine d'un nombre négatif)`	Calcul sans résultat réel : racine d'un nombre négatif, 0 / 0…	Vérifier les valeurs avant le calcul : `si x >= 0 alors`.
`Dépassement numérique : le résultat est trop grand`	Le résultat dépasse la plus grande valeur représentable.	Réduire les valeurs ou l'exposant.
`Résultat numérique trop proche de zéro`	Le résultat est trop petit pour être représenté.	Arrondir les valeurs intermédiaires.
`Dépassement de capacité : nombre entier trop grand`	Un calcul entier dépasse la capacité.	Travailler avec des valeurs plus petites.
`Valeur en dehors des limites autorisées`	Une valeur passée à une fonction sort de l'intervalle prévu.	Vérifier les arguments (taille, indice, code…).
`Conversion impossible : la valeur n'a pas le bon format`	Une conversion interne échoue (texte mal formé).	Vérifier le format avec `est_nombre(...)` avant de convertir.
`Index ou position en dehors des limites`	Accès interne à une position inexistante.	Vérifier les indices et positions.
`Index en dehors des limites de la liste`	Accès interne à un élément de liste inexistant.	Vérifier `longueur(...)` avant l'accès.
`Mémoire insuffisante : le programme manipule trop de données`	Tableaux ou textes gigantesques.	Réduire la quantité de données, vider les tableaux inutiles avec `vide`.
`Pile d'appels saturée : trop d'appels imbriqués (une fonction s'appelle-t-elle elle-même sans fin ?)`	Récursion infinie non détectée plus tôt.	Ajouter un cas de base à la fonction récursive.
`Erreur de fichier : …`	Lecture ou écriture de fichier refusée par le système.	Vérifier le chemin, les droits et que le fichier n'est pas ouvert ailleurs.
`Erreur interne de l'interpréteur (accès mémoire invalide). Merci de signaler ce programme.`	Défaut de CoddyRun lui-même, pas de votre programme.	Signaler le programme sur le support.
`Erreur inattendue (…) : …`	Erreur système non répertoriée.	Noter le message complet et le signaler.

Analyser la syntaxe : erreurs, avertissements et conseils

Le bouton Analyser la syntaxe de l'éditeur vérifie le programme sans l'exécuter. Il donne trois niveaux de messages :

Erreur : le programme ne démarrera pas, ou échouera à coup sûr à cet endroit.
Avertissement : le programme démarre, mais il y a probablement une faute (boucle sans fin, code jamais exécuté, fonction sans retourne…).
Conseil : une bonne pratique (variable jamais utilisée, jamais remplie, non déclarée…).

Les trois tableaux ci-dessous listent ces messages. Quand l'analyse ne trouve aucune erreur, le programme est garanti de démarrer.

Analyse : erreurs

Le programme ne démarrera pas tant que ces erreurs ne sont pas corrigées.

Message	Que faire
`"…" attendu, obtenu …`	Ajouter l'élément attendu à l'endroit indiqué.
`Expression manquante après "…"`	Compléter le calcul ou la valeur après le mot ou l'opérateur cité.
`Expression vide après "…"`	Donner une valeur ou un calcul.
`Division par zéro`	Le diviseur écrit dans le code vaut 0 : le corriger, ou tester la valeur avant de diviser.
`Modulo par zéro`	`x mod 0` n'a pas de sens : changer le diviseur.
`Parenthèse(s) non fermée(s) dans l'expression après "…"`	Compter les parenthèses ouvrantes et fermantes.
`Crochet(s) non fermé(s) dans l'expression après "…"`	Fermer le crochet du tableau ou de l'indice.
`Fin de ligne attendue, obtenu …`	Une seule instruction par ligne : passer à la ligne avant la suite.
`Instruction inattendue : "…"`	Vérifier l'orthographe du mot-clé et les accents.
`Instruction inattendue : … — pour l'afficher, écris : affiche …`	Une valeur est seule sur la ligne : la précéder de `affiche`.
`Instruction inconnue après "…" : on attend « vaut », « est », « ajoute », « soustrait » ou des parenthèses pour un appel`	Compléter l'instruction : `x vaut 10`, `x est un nombre`, `maFonction()`…
`"dans" ne peut pas commencer une instruction, ex : demande 'Ton nom ?' dans nom`	Remettre `dans` sur la même ligne que `demande`, `choisir`…
`« fin » doit être suivi du bloc à fermer : fin si, fin pour, fin tant que, fin répète, fin selon, fin fonction, fin procédure…`	Écrire la fin complète du bloc.
`"fin si" sans "si" correspondant`	Supprimer cette ligne, ou ajouter le `si … alors` qui manque. Les mêmes messages existent pour `fin tant que`, `fin répète`, `fin pour`, `fin fonction`, `fin procédure`, `fin processus`, `fin selon`, `fin essayer` et `fin classe`.
`"sinon" sans "si" correspondant`	Placer `sinon` à l'intérieur d'un bloc `si`.
`"attraper" sans "essayer" correspondant`	Placer `attraper` à l'intérieur d'un bloc `essayer`.
`"fin si" manquant`	Fermer le bloc. Mêmes messages pour `fin tant que`, `fin répète`, `fin pour`, `fin selon`, `fin essayer` et `fin classe`.
`"alors" attendu après la condition du "si"`	Terminer la ligne par `alors` (même message pour `sinon si`).
`Nom de champ attendu après "."`	Écrire le nom du champ : `personne.nom`.
`Après "….champ" on attend "vaut", "ajoute" ou "soustrait"`	Compléter : `personne.age vaut 30`.
`Après "…[...]" on attend "vaut", "ajoute" ou "soustrait"`	Compléter : `t[0] vaut 5`.
`")" manquant dans l'appel de "…"`	Fermer la parenthèse de l'appel.
`"… ... dans" attend un nom de variable`	Donner la variable qui reçoit le résultat après `dans`.
`"vaut" attendu après "constante" pour "…"`	Écrire `NOM est une constante vaut valeur`.
`"constante" attend un identifiant`	Donner un nom à la constante.
`"vaut" attendu après le nom de la constante "…"`	Ajouter `vaut` et la valeur.
`Type inconnu "…" pour "…" — voulais-tu dire "…" ?`	Corriger le type comme proposé.
`Type inconnu "…" pour "…". Types valides : …`	Choisir un type de la liste : nombre, texte, booléen, tableau, enregistrement, dictionnaire, date, heure, toile, image.
`Type attendu pour la déclaration de "…" (…)`	Compléter : `x est un nombre`.
`"…" est déclaré de type … : impossible de lui donner une valeur de type …`	Changer la valeur, ou le type de la déclaration.
`"…" est de type … : impossible de lui affecter un …`	La valeur n'a pas le bon type : la convertir (`convertir_nombre`, `convertir_texte`…) ou changer la déclaration.
`Identifiant attendu après ","`	Une virgule en trop dans une liste de noms.
`Déclaration multiple : "est" attendu après la liste de noms, ex : x, y est un nombre`	Ajouter `est un …` après les noms.
`"dans" attendu après la question`	Écrire `demande 'Question ?' dans variable`.
`Nom de variable attendu après "dans"`	Donner la variable qui reçoit la réponse.
`"demande" attend une question ou un nom de variable, ex : demande 'Ton nom ?' dans nom`	Compléter l'instruction.
`"…" n'est pas autorisé dans un processus : seul le programme principal peut demander une saisie à l'utilisateur.`	Déplacer `demande`, `choisir`, `appuyer`, `cliquer` ou `interagir` dans le programme principal. Dans un processus, utiliser plutôt `touche_pressée` ou `souris_clic`.
`"choisir" attend au moins une option`	Donner une liste d'options : `choisir ['Oui', 'Non'] dans choix`.
`"]" manquant dans la liste d'options de "choisir"`	Fermer le crochet.
`"dans" attendu après les options de "choisir"`	Ajouter `dans` et la variable nombre.
`"appuyer" attend une liste de touches entre crochets, ex : appuyer ['z', 's', 'd', 'q'] dans action`	Mettre les touches entre crochets.
`"appuyer" attend au moins une touche`	Donner au moins une touche.
`"]" manquant dans la liste de touches de "appuyer"`	Fermer le crochet (même message pour `interagir`).
`"dans" attendu après la liste de touches de "appuyer"`	Ajouter `dans` et la variable nombre.
`"cliquer" attend une toile, ex : cliquer maToile dans x, y`	Donner le nom de la toile.
`"cliquer" n'accepte pas de délai, ex : cliquer maToile dans x, y`	La forme avec délai n'existe pas : pour un jeu qui continue sans attendre, utiliser `souris_clic`.
`"dans" attendu après la toile de "cliquer", ex : cliquer maToile dans x, y`	Ajouter `dans x, y`.
`"," attendue entre les variables de "cliquer" (x, y)`	Séparer x et y par une virgule (même message pour `interagir`).
`"interagir" attend une toile, ex : interagir maToile, ['z', 's'] dans action, x, y`	Donner le nom de la toile.
`"interagir" attend une virgule puis une liste de touches, ex : interagir maToile, ['z', 's'] dans action, x, y`	Ajouter la virgule après la toile, puis la liste de touches.
`"interagir" attend une liste de touches entre crochets, ex : interagir maToile, ['z', 's', 'd', 'q'] dans action, x, y`	Mettre les touches entre crochets.
`"interagir" attend au moins une touche`	Donner au moins une touche.
`"dans" attendu après la liste de touches de "interagir", ex : ... dans action, x, y`	Ajouter `dans action, x, y`.
`"couleur" attend une parenthèse ouvrante "("`	Écrire `couleur(#FF0000, 'texte')` (même message pour `html`).
`")" manquant dans "couleur(...)"`	Fermer la parenthèse (même message pour `html(...)`).
`« répète … fois » dépasse la limite de … tours`	Réduire le nombre de tours (1 000 000 au maximum).
`"fois" attendu après l'expression dans "répète"`	Écrire `répète 5 fois`.
`"pour" attend un nom de variable, ex : pour i de 1 à 10`	Donner le compteur de la boucle.
`"de" attendu après la variable de boucle`	Écrire `pour i de 1 à 10`.
`"à" attendu après la valeur de départ`	Écrire `pour i de 1 à 10`.
`"pas" ne peut pas valoir 0`	Un pas nul ferait tourner la boucle sans fin : utiliser 1, -1, 2…
`La boucle « pour » ferait … tours : la limite est de …`	Réduire l'intervalle (1 000 000 de tours au maximum).
`":" attendu après la valeur du cas`	Écrire `cas 1 :`.
`":" attendu après "sinon selon"`	Écrire `sinon selon :`.
`"cas" après "sinon selon" : « sinon selon » doit être la dernière branche`	Déplacer `sinon selon` à la fin du bloc.
`"classe" attend un nom`	Écrire `classe Personne :`.
`":" attendu après "classe …"`	Ajouter les deux-points après le nom de la classe.
`Nom de champ attendu dans la classe "…"`	Déclarer les champs : `nom est un texte`.
`Nom de champ attendu après "," dans la classe "…"`	Une virgule en trop dans la liste des champs.
`"est" attendu après le nom du champ`	Écrire `age est un nombre`.
`Type de champ inconnu "…" dans la classe "…". Types valides : …`	Choisir un type de la liste.
`Type attendu pour le champ de la classe "…"`	Compléter : `age est un nombre`.
`"fin classe" manquant pour la classe "…" avant le début d'une nouvelle classe`	Fermer la première classe avant d'en commencer une autre.
`Nom attendu après "…"`	Donner un nom à la fonction, la procédure ou le processus.
`Nom de paramètre attendu dans "…"`	Une virgule en trop, ou un paramètre qui n'est pas un nom.
`")" manquant dans la définition de "…"`	Fermer la parenthèse des paramètres.
`"…" manquant pour "…"`	Fermer la définition : `fin fonction`, `fin procédure` ou `fin processus`.
`Une fonction, une procédure ou un processus doit être défini au niveau principal du programme, pas à l'intérieur d'une autre définition`	Sortir la définition de la fonction ou du bloc qui la contient.
`Un seul processus est autorisé par programme (« … » est déjà défini ligne …) : « … » ne peut pas être ajouté.`	Regrouper le travail de fond dans un seul processus.
`"…" n'est pas un processus (le processus du programme est "…")`	Donner le nom du processus à `suspendre` ou `reprendre`, ou ne rien donner.
`"…" : ")" attendu`	Fermer la parenthèse après le nom du processus.
`"…" attend au plus le nom du processus, ex : … MonProcessus()`	Retirer ce qui suit le nom du processus.
`pause attend une durée en millisecondes (30 à 3000), ex : pause 500`	Donner une durée en millisecondes.
`"appelle" attend un nom de procédure`	Écrire `appelle saluer()`.
`"retourne" utilisé en dehors d'une fonction`	`retourne` n'a de sens que dans une fonction.
`"retourne" attend une expression`	Indiquer la valeur à renvoyer : `retourne x * 2`.
`"arrête" utilisé en dehors d'une boucle`	Placer `arrête` dans une boucle, ou utiliser `terminer` pour arrêter le programme.
`"continue" utilisé en dehors d'une boucle`	Placer `continue` dans une boucle.
`"vide" attend un nom de tableau`	Écrire `vide scores`.
`"supprime" attend un nom de tableau`	Écrire `scores supprime 0`.
`"…" est déjà une fonction native : ta définition ne serait jamais appelée. Choisis un autre nom.`	Renommer la fonction ou la procédure.
`"…" est déjà défini ligne …`	Deux définitions portent le même nom : en renommer une.
`Fonction ou procédure inconnue : "…" — voulais-tu dire "…" ?`	Corriger le nom comme proposé.
`Fonction ou procédure inconnue : "…"`	Vérifier l'orthographe, ou définir la fonction.
`"…" attend … paramètre(s), … fourni(s)`	Donner autant de valeurs que de paramètres.
`"…" est une fonction : ajoute des parenthèses, ex : …()`	Appeler la fonction avec ses parenthèses.
`Variable inconnue : "…" — elle n'est créée que dans "…", où elle reste locale. Crée-la d'abord dans le programme principal.`	Déclarer la variable dans le programme principal, ou la passer en paramètre.
`Variable inconnue : "…" — voulais-tu dire "…" ?`	Corriger le nom comme proposé.
`Variable inconnue : "…" — crée-la avant de l'utiliser, ex : … est un nombre`	Déclarer la variable avant sa première utilisation.
`"…" est utilisée avant d'être créée (ligne …)`	Déplacer la déclaration avant la première utilisation.
`"…" est une constante : on ne peut pas la modifier`	Utiliser une variable si la valeur doit changer.
`La constante "…" est déjà définie ligne …`	Renommer l'une des deux constantes.
`"…" est à la fois une constante et une variable : choisis un autre nom`	Renommer la constante ou la variable.
`"…" doit d'abord être déclarée comme un nombre (ex : … est un nombre)`	`ajoute` et `soustrait` sur un nombre demandent une variable déclarée.
`"…" doit être de type nombre (elle est déclarée … ligne …)`	`soustrait` ne fonctionne que sur les nombres.
`Erreur interne de l'analyseur : …`	Une erreur de CoddyRun lui-même : signale-la sur le support avec ton programme.

Analyse : avertissements

Le programme peut démarrer, mais le résultat ne sera probablement pas celui attendu.

Message	Que faire
`Code inaccessible : les instructions placées après « … » ne seront jamais exécutées`	Supprimer ces lignes, ou les placer avant `retourne`, `arrête` ou `terminer`.
`« tant que vrai » sans « arrête », « retourne » ni « terminer » : la boucle ne s'arrêtera jamais (le programme s'interrompra après 1 000 000 tours)`	Prévoir une sortie, par exemple `si touche_pressée('échap') alors` … `arrête`.
`Aucune variable de la condition (…) n'est modifiée dans la boucle : elle risque de ne jamais s'arrêter`	Modifier dans la boucle une variable de la condition.
`« répète … fois » : la boucle ne s'exécutera jamais`	Le nombre de tours vaut 0 ou moins.
`La boucle « pour » ne s'exécutera jamais : … est plus grand que …. Pour compter à rebours, ajoute « pas -1 »`	Inverser les bornes, ou ajouter `pas -1`.
`La boucle « pour » ne s'exécutera jamais : avec un pas négatif, … devrait être plus grand que …`	Inverser les bornes.
`"selon" sans aucune branche "cas" — bloc probablement vide`	Ajouter des branches `cas`.
`"essayer" sans "attraper" : une erreur ne sera pas interceptée`	Ajouter un bloc `attraper`.
`La fonction "…" ne contient aucun « retourne » : elle renverra toujours 0. Ajoute « retourne valeur », ou fais-en une procédure.`	Ajouter `retourne`, ou transformer la fonction en procédure.
`Le processus "…" boucle sans "pause" : il rendra la main au programme principal toutes les 40 ms. Ajoute par exemple "pause 100" dans sa boucle.`	Ajouter une `pause` dans la boucle du processus.
`"…" : aucun processus n'est défini dans ce programme (l'instruction sera ignorée)`	Retirer `suspendre` ou `reprendre`, ou définir un processus.
`pause … : la durée sera ramenée entre … et … ms`	Donner une durée entre 30 et 3000 ms.
`Dans une procédure, la valeur de « retourne » est ignorée : utilise une fonction pour renvoyer un résultat.`	Transformer la procédure en fonction.
`"…" est une procédure : elle ne renvoie pas de valeur (le résultat vaudra 0). Utilise une fonction avec « retourne ».`	Appeler la procédure avec `appelle`, ou en faire une fonction.
`Un processus se démarre seul sur sa ligne : …()`	Écrire `MonProcessus()` seul sur sa ligne, sans `appelle` ni `vaut`.
`"…" est utilisée avant d'être créée (ligne …) : vérifie que ce passage ne s'exécute pas avant`	Dans une boucle ou une condition : s'assurer que la variable est créée avant ce passage.
`"…" est redéclarée avec un autre type (déjà déclarée ligne …)`	Utiliser un autre nom pour la nouvelle variable.

Analyse : conseils

Ces remarques n'empêchent rien : elles aident à garder un programme clair.

Message	Que faire
`Le bloc « si » est vide`	Ajouter des instructions, ou supprimer le bloc (même conseil pour `sinon si`).
`« sinon » vide : tu peux le supprimer`	Supprimer le `sinon` inutile.
`La boucle « tant que » est vide`	Ajouter des instructions, ou supprimer la boucle (même conseil pour `répète` et `pour`).
`« tant que vrai » sans « arrête » ni « terminer » : le programme ne s'arrêtera qu'avec le bouton Arrêter`	Normal pour une boucle de jeu ; sinon, prévoir une sortie.
`La fonction "…" est vide`	Écrire le corps de la fonction (même conseil pour une procédure ou un processus).
`Dans un processus, « retourne » arrête le processus ; la valeur est ignorée.`	Écrire `retourne` seul, ou sortir de la boucle.
`La valeur renvoyée par la fonction "…" est ignorée : range-la dans une variable (x vaut …(…)) ou fais-en une procédure`	Utiliser le résultat, ou transformer la fonction en procédure.
`"…" lit la souris ou le clavier sans attendre : ajoute une « pause » dans ta boucle (ex : pause 60) pour que la toile se rafraîchisse à chaque tour`	Ajouter `pause 30` à `pause 60` dans la boucle.
`Le processus "…" n'est jamais démarré : écris …() dans le programme principal`	Démarrer le processus par son nom suivi de parenthèses.
`La fonction "…" n'est jamais appelée`	L'appeler, ou la supprimer (même conseil pour une procédure).
`La variable locale "…" porte le nom d'une variable du programme principal : dans "…", elle la masque`	Renommer la variable locale pour éviter la confusion.
`La classe "…" n'est jamais utilisée`	L'utiliser ou la supprimer.
`La constante "…" n'est jamais utilisée`	L'utiliser ou la supprimer.
`Le paramètre "…" de "…" n'est jamais utilisé`	L'utiliser dans la fonction, ou le retirer.
`La variable de boucle "…" n'est pas utilisée : « répète N fois » suffirait`	Remplacer la boucle `pour` par `répète N fois`.
`« attraper … » : le message d'erreur n'est pas utilisé, « attraper » seul suffit`	Écrire `attraper` seul, ou afficher le message.
`"…" reçoit une valeur mais n'est jamais utilisée`	Utiliser la variable, ou supprimer les lignes qui la remplissent.
`"…" est déclarée mais n'est jamais utilisée`	Supprimer la déclaration inutile.
`"…" est utilisée mais ne reçoit jamais de valeur : elle vaudra toujours …. Donne-lui une valeur (… vaut …), ou utilise une constante.`	Donner une valeur à la variable, ou en faire une constante.
`"…" n'est pas déclarée : la réponse sera un texte. Pour obtenir un nombre, déclare-la avant (… est un nombre).`	Déclarer la variable de `demande` comme nombre pour calculer avec la réponse.
`"…" est créée sans déclaration : déclare-la (ex : … est un nombre) pour fixer son type`	Ajouter une déclaration avec un type.
`"…" est déjà déclarée ligne … : cette nouvelle déclaration la remet à sa valeur par défaut`	Supprimer la seconde déclaration, ou changer le nom.

Nombre d'arguments des fonctions intégrées

Chaque fonction intégrée contrôle le nombre d'arguments reçus et affiche sa propre signature quand le compte n'y est pas. Ces messages suivent toujours l'une des quatre formes ci-dessous : le texte entre parenthèses est la syntaxe correcte à recopier.

Forme du message	Signification	Solution
`longueur(x) attend 1 argument`	La fonction exige exactement ce nombre d'arguments.	Recopier la signature affichée entre parenthèses.
`décrément(x[, n]) attend 1 ou 2 arguments`	Les crochets signalent un argument facultatif.	Fournir le minimum, et l'option seulement si nécessaire.
`assembler(tableau1, tableau2, ...) attend au moins 2 tableaux`	La fonction accepte un nombre variable d'arguments, avec un minimum.	Ajouter les arguments manquants.
`rectangle(toile, x, y, largeur, hauteur [, couleur]) : 5 ou 6 arguments`	Forme employée par les fonctions de dessin : signature complète puis nombres admis.	Compter les arguments par rapport à la signature affichée.
`maintenant() ne prend aucun argument`	La fonction s'appelle sans rien entre les parenthèses.	Écrire `maintenant()` sans argument.

Les 161 signatures contrôlées

Voici le message exact affiché par chaque fonction intégrée quand le nombre d'arguments ne correspond pas. La partie entre parenthèses est la signature à recopier ; les crochets [ ] marquent les arguments facultatifs.

absolue(x) attend 1 argument
ajouter_années(date, n) attend 2 arguments
ajouter_heures(heure, n) attend 2 arguments
ajouter_jours(date, n) attend 2 arguments
ajouter_ligne(chemin, texte) attend 2 arguments
ajouter_minutes(heure, n) attend 2 arguments
ajouter_mois(date, n) attend 2 arguments
animation(tableau, ms [, repetitions]) attend 2 ou 3 arguments
année_de(date) attend 1 argument
arc(toile, cx, cy, rayon, angle_debut, angle_fin [, couleur]) : 6 ou 7 arguments
arccosinus(x) attend 1 argument
arcsinus(x) attend 1 argument
arctangente(x) attend 1 argument
arrondi(x) attend 1 argument
arrondi_inférieur(x) attend 1 argument
arrondi_supérieur(x) attend 1 argument
assembler(tableau1, tableau2, ...) attend au moins 2 tableaux
aujourd_hui() ne prend aucun argument
caractère(n) attend 1 argument
centimètre(cm) attend 1 argument
cercle(toile, cx, cy, rayon [, couleur]) : 4 ou 5 arguments
champs(enregistrement) attend 1 argument
chiffres(texte) attend 1 argument
chrono() n'attend aucun argument
cles(dictionnaire) attend 1 argument
code(x) attend 1 argument
commence_par(texte, prefixe) attend 2 arguments
compter(texte, motif) attend 2 arguments
compter_mots(texte) attend 1 argument
contient(x, y) attend 2 arguments
contour(toile, couleur, epaisseur) : 2 ou 3 arguments
convertir_date(x) attend 1 argument
convertir_heure(x) attend 1 argument
convertir_nombre(x) attend 1 argument
convertir_texte(x) attend 1 argument
copier(texte, debut, longueur) attend 3 arguments
cosinus(x) attend 1 argument
courbe(toile, tableau [, couleur]) : 2 ou 3 arguments
courbe(toile, x1, y1, x2, y2, ... [, couleur]) : au moins 2 points (paires x,y)
decimal(x, n) attend 2 arguments
découper(texte, séparateur) attend 2 arguments
décrément(x[, n]) attend 1 ou 2 arguments
défaut(valeur) attend 1 argument
degrade(toile, [couleur1, couleur2, ...]) attend 2 arguments
demain() ne prend aucun argument
dernier(tableau) attend 1 argument
dimension(toile, largeur, hauteur) attend 3 arguments
effacer(toile) attend 1 argument
ellipse(toile, cx, cy, rx, ry [, couleur]) : 5 ou 6 arguments
enregistrer(toile, chemin) attend 2 arguments
est_bissextile(annee) attend 1 argument
est_booleen(x) attend 1 argument
est_nombre(x) attend 1 argument
est_texte(x) attend 1 argument
est_vide(x) attend 1 argument
évaluer(expression) attend 1 argument
existe(enregistrement, champ) attend 2 arguments
expression(motif, texte [, toutes]) attend 2 ou 3 arguments
factorielle(n) attend 1 argument
fichier_existe(chemin) attend 1 argument
fleche(toile, tableau [, couleur [, epaisseur [, pointe]]]) : avec un tableau, 2 a 5 arguments
fleche(toile, x1, y1, x2, y2, ... [, couleur [, epaisseur [, pointe]]]) : au moins 2 points (paires x,y)
format_date(date, motif) attend 2 arguments
fusionner(tableau1, tableau2) attend 2 arguments
grille(toile, pas [, couleur]) : 2 ou 3 arguments
heure_de(h) attend 1 argument
hier() ne prend aucun argument
histogramme(toile, tableau [, couleur]) : 2 ou 3 arguments
histogramme(toile, tableau|valeurs... [, couleur]) : au moins 2 arguments
histogramme(toile, valeurs... [, couleur]) : au moins une valeur
hypotenuse(a, b) attend 2 arguments
icone(toile, x, y, code [, couleur [, taille]]) : 4 à 6 arguments
impair(n) attend 1 argument
importer(chemin) attend 1 argument
incrément(x[, n]) attend 1 ou 2 arguments
index_de(tableau, valeur) attend 2 arguments
insertion(texte, position, morceau) attend 3 arguments
intervalle(debut, fin) attend 2 arguments
inverser(texte) attend 1 argument
joindre(tableau, separateur) attend 2 arguments
jour_de(date) attend 1 argument
jour_semaine(date) attend 1 argument
jours_entre(date1, date2) attend 2 arguments
label(toile, x, y, texte [, couleur [, taille [, angle]]]) : 4 à 7 arguments
label_hauteur(taille) attend 1 argument
label_largeur(texte, taille) attend 2 arguments
lettres(texte) attend 1 argument
ligne(toile, x1, y1, x2, y2 [, couleur [, epaisseur]]) : 5 a 7 arguments
limiter(x, min, max) attend 3 arguments
liste_fichiers(chemin, extension, tableau) attend 3 arguments
liste_tableau(tableau) attend 1 argument
logarithme(x) attend 1 argument
longueur(x) attend 1 argument
maintenant() ne prend aucun argument
majuscule_initiale(texte) attend 1 argument
majuscules(texte) attend 1 argument
maximum(a,b) attend 2 arguments
médiane(tableau) attend 1 argument
melanger(tableau) attend 1 argument
millimètre(mm) attend 1 argument
minimum(a,b) attend 2 arguments
minuscules(texte) attend 1 argument
minute_de(h) attend 1 argument
mois_de(date) attend 1 argument
moyenne(tableau) attend 1 argument
normaliser(texte) attend 1 argument
ouvrir(fichier_ou_dossier_ou_url) attend 1 argument
pair(n) attend 1 argument
pgcd(a, b) attend 2 arguments
pi ne prend aucun argument
pixel(toile, x, y, couleur) attend 4 arguments
polygone(toile, tableau [, couleur]) : avec un tableau, 2 ou 3 arguments
polygone(toile, x1, y1, x2, y2, x3, y3, ... [, couleur]) : au moins 3 points (paires x,y)
pourcentage(valeur, total) attend 2 arguments
premier(tableau) attend 1 argument
puissance(a, b) attend 2 arguments
racine(x) attend 1 argument
radians(degres) attend 1 argument
rectangle(toile, x, y, largeur, hauteur [, couleur]) : 5 ou 6 arguments
rectangle_arrondi(toile, x, y, largeur, hauteur, rayon [, couleur]) : 6 ou 7 arguments
remplacer(texte, ancien, nouveau) attend 3 arguments
remplir(toile, couleur) attend 2 arguments
repeter_texte(texte, n) attend 2 arguments
retirer(texte, motif) attend 2 arguments
rgb(r, v, b) attend 3 arguments
rgba(r, v, b, a) attend 4 arguments
saisie(toile, variable, x, y, largeur, hauteur [, indication]) : 6 ou 7 arguments
sauvegarder(chemin, texte) attend 2 arguments
seconde_de(h) attend 1 argument
semaine_de(date) attend 1 argument
sialors(cond, a, b) attend 3 arguments
signe(x) attend 1 argument
similaire(texte1, texte2 [, seuil]) attend 2 ou 3 arguments
sinus(x) attend 1 argument
somme(tableau) attend 1 argument
son(chemin, en_boucle) attend 1 ou 2 arguments
souris_appuyée(toile) attend 1 argument, ex : souris_appuyée(maToile)
souris_clic(toile) attend 1 argument, ex : souris_clic(maToile)
souris_x(toile) attend 1 argument, ex : souris_x(maToile)
souris_y(toile) attend 1 argument, ex : souris_y(maToile)
supprime_champ(enregistrement, champ) attend 2 arguments
supprime_espace(texte) attend 1 argument
supprimer(position, texte) attend 2 arguments
svg(toile, x, y, source, largeur, hauteur) attend 6 arguments
taille(tableau, n) attend exactement 2 arguments
tangente(x) attend 1 argument
télécharger(url, dossier) attend 2 arguments
termine_par(texte, suffixe) attend 2 arguments
tls(teinte, saturation, luminosite) attend 3 arguments
touche_enfoncée(touche) attend 1 argument, ex : touche_enfoncée('z')
touche_pressée(touche) attend 1 argument, ex : touche_pressée('z')
triangle(toile, x1, y1, x2, y2, x3, y3 [, couleur]) : 7 ou 8 arguments
trier(tableau [, sens]) attend 1 ou 2 arguments
type_de(x) attend 1 argument
uid() ne prend aucun argument
unique(tableau) attend 1 argument
vers_date(texte) attend 1 argument
vers_decimal(texte, base) attend 2 arguments
vers_heure(texte) attend 1 argument
vers_hexadecimal(entier [, prefixe [, largeur]]) : 1 a 3 arguments
vers_type(type, valeur) attend 2 arguments

Toutes ces erreurs sont interceptables : entoure le code sensible d'un bloc essayer … attraper … fin essayer pour afficher un message adapté au lieu d'interrompre le programme. Voir le chapitre Gestion des erreurs.

Trois réflexes avant de modifier quoi que ce soit : lire le numéro de ligne, lire le type mentionné dans le message, puis vérifier la déclaration de la variable concernée. La plupart des erreurs se corrigent en une ligne.

Note de fin

CoddyRun est un outil d’apprentissage : avance par petites étapes, teste souvent, et privilégie toujours la compréhension à la vitesse. Si tu bloques, simplifie ton programme, puis recommence.

Bonne exploration — et surtout : amuse-toi à comprendre !

Comprendre d’abord. Coder ensuite. Progresser toujours.