Langage

Langage

Le langage est indépendant des cibles. JavaScript, Python et C expérimental sont les backends actifs ; C++ et Java sont visibles mais indisponibles.

Types

Type	Détail
short int, short uint	entiers 16 bits signés / non signés
int, uint	entiers 32 bits signés / non signés
float, double	IEEE 754 32 / 64 bits
string	texte Unicode
char	scalaire Unicode unique
boolean	vrai / faux
void	retour de fonction ou de lambda uniquement
T[]	tableau d’un type
T*	pointeur vers un primitif non void
(T, …) → R	signature de fonction

Aucune conversion implicite, aucune promotion, aucun type de secours. Les littéraux et déclarations sont explicitement typés.

Constructions

Construction	Rôle
VariableDeclaration	variable typée, initialiseur optionnel
ConstantDeclaration	constante typée, initialiseur requis
FunctionDeclaration	fonction typée, paramètres, corps, point d’entrée optionnel
Parameter	paramètre typé
TypeDeclaration	alias transparent d’un primitif
Block	liste d’instructions
ReturnStatement	retour, avec ou sans valeur
IfStatement	test booléen, branche, alternative optionnelle
WhileStatement	boucle avec test
ForStatement	initialiseur, test, mise à jour, corps
BreakStatement, ContinueStatement	contrôle de boucle
ExpressionStatement	expression utilisée comme instruction
AssignmentStatement	affectation d’une variable, d’un paramètre, d’une case ou d’un *p
BinaryExpression, UnaryExpression	opérations typées
Literal	valeur explicitement typée
Reference	référence vers une déclaration
CallExpression	appel direct ou via une valeur de type fonction
CastExpression	conversion numérique explicite
ArrayLiteral, ArrayCreation, ArrayAccess	tableaux
LambdaExpression	fonction anonyme, corps expression
ForEachStatement	parcours avec rappel
NewExpression	instanciation d’une classe
MemberExpression	lecture ou appel d’un membre
ThisExpression	instance courante dans une méthode
MathCall	opération native SP3
PrintStatement	sortie de simulation

Règles d’expression

• Les opérateurs exigent des types compatibles ; + n’additionne pas un int et un double.
• and, or, not sont booléens.
• Une comparaison produit un boolean.
• Les appels vérifient arité, types et signature.
• Une fonction non void doit retourner sur tous les chemins prouvés.
• Un tableau ne peut pas être retourné par une fonction, sauf élément générique.
• Un void ne peut pas être une valeur.

Modules

• Exports de fonctions de premier niveau.
• Imports avec nom local.
• Une référence intermodule passe par un import explicite.
• Les flèches de dépendance n’apparaissent que pour un export réellement utilisé.

Classes

Une carte Class crée un module source kind: 'class' avec deux scopes : public et private. Chaque membre — attribut, constante, méthode, constructeur compris — porte sa visibilité. Une classe s’instancie avec new, son type {kind:'class', classId} est annotable sur les variables, constantes, paramètres et retours, et this désigne l’instance courante dans les méthodes et le constructeur.

• Constructeur nommé constructor, retour void, visibilité public ou private.
• Accès privés et constructeurs privés contrôlés.
• Aucun héritage ni polymorphisme.
• La simulation crée l’instance, initialise les attributs et lie this.
• Les classes sont transpilées en JavaScript/Python ; le C expérimental les refuse (TRANSPILE_C_UNSUPPORTED).

Génériques

Une fonction peut déclarer jusqu’à huit paramètres de type (T, U…) avec une contrainte exacte optionnelle. L’inférence se fait sur un appel direct ; tous les paramètres doivent être inférés avec des types identiques. Les tableaux génériques (T[]) sont acceptés. T*, T[][] et les génériques imbriqués sont refusés.

Lambdas et fermetures

Une LambdaExpression a des paramètres typés et un corps expression unique. Elle capture lexicalement les variables visibles, par référence. Elle peut être stockée, passée en callback, appelée immédiatement ou retournée par une fonction. Pas d’affectation ni de boucle dans son corps ; pas d’adresse sur ses paramètres ; pas de générique.

Pointeurs

• &x prend l’adresse d’une variable, constante, paramètre ou case de tableau.
• *p relit la valeur pointée.
• *p = v écrit réellement à travers le pointeur.
• Une constante reste protégée, même via un pointeur recopié.

Contrats

Sur une variable, constante ou paramètre, le panneau de propriétés permet d’attacher des contraintes :

• nombres : positif, non négatif, non nul, pair, impair, supérieur/inférieur, entre deux bornes ;
• chaînes : non vide, non blanc, une ligne, commence/finit par, contient, longueur min/max ;
• tableaux : non vide, éléments uniques, tri croissant ;
• booléens : vrai/faux.

Pendant Run, une violation est signalée avec le nom, la règle, le pas et la valeur, sans interrompre le programme.

Opérations natives

• Maths : abs, min, max, pow, trigonométrie, arrondis, logarithme, etc.
• Texte : longueur, caractère, portion, recherche.
• Tableaux : longueur, remplissage, tranche, concaténation, recherche, index, inversion.
• Aléatoire : réel dans [0,1), entier dans une plage.
• Grille/écran : remplissage, convolution, table de transition, blit, présentation.

Toutes sont locales, sans effet natif ni réseau.

Limites

• Classes sans héritage ni polymorphisme ; transpilées en JavaScript/Python, refusées par le C expérimental.
• Pas de structures ni de sous-modules.
• TypeDeclaration reste un alias.
• Pas d’interfaces ni d’héritage.
• Pas de saisie interactive, de fichier ou de réseau dans le programme simulé, hors boutons d’entrée déclarés par le projet.