V3.0: Un nouveau départ avec des nouveautés et fixs

Pourquoi

Le parser actuel manquait clairement de clarté et pouvait paraître illisible pour les curieux qui souhaitaient regarder le code source.
Par ailleurs beaucoup plus d'éléments seront présents de base comparé à la V2 qui ressemblait à une mini base sans vraiment beaucoup de contenu.

Contenu

Globalité

• Suppression des ; pour simplifier l'écriture et la compréhension du langage.
  Ainsi il est possible de faire par exemple, sans problème : variable entier a -> 5 envoyer "cc" ou variable entier a -> 5 envoyer a

envoyer

L'instruction envoyer a toujours la même syntaxe sauf lorsqu'on envoi plusieurs valeurs dans un seul et même "envoyer".
Suite à la suppression des ";" j'ai décidé de rajouter un truc à l'instruction envoyer:
envoyer [ valeur1 valeur2 valeur3 valeur4 ... ]
Exemple: envoyer [ "cc" "yo, " 10 ". I am " 10.5 " yo !" ]

https://program-4.gitbook.io/french-programming-language/instructions/le-print

saisir

Même principe qu'avant sauf que cette fois-ci, si le type précisé n'est pas équivalent à la réponse donné, la variable sera de type texte et aura la valeur vide
Exemple:

saisir texte a
envoyer ["Valeur recuperer: " a ]

saisir entier age -> "Age: "
envoyer ["Valeur recuperer (vide): " age ]

On aura:
c

Valeur recuperer: c
Age: a

Valeur recuperer (vide): vide

https://program-4.gitbook.io/french-programming-language/instructions/les-entrees-claviers

fichier

Nouvelle syntaxe, exemple:

fichier lire content "file_to.txt"
envoyer content

fichier ecrire "file_to.txt" -> "Salut la compagnie ! "
fichier lire c "file_to.txt"
envoyer c

https://program-4.gitbook.io/french-programming-language/instructions/les-fichiers

Variables constantes et globales

Deux instructions font leur apparition : constante et globale ces dernières peuvent être combiné pour qu'une variable soit constante et globale par exemple :

constante entier a -> 10
envoyer a
constante globale entier c -> 1
envoyer c

globale texte ms -> "Bienvenue !"
envoyer ms
globale constante texte msg -> "BEYE NOOB"
envoyer msg

10
1
Bienvenue !
BEYE NOOB

verifier

Pas spécialement une nouvelle syntaxe depuis la dernière mise à jour mais les bugs concernant les verifier dans des verifier est résolu (vous pouviez avoir des erreurs avec 'Inconnu' car il ne reconnaissait pas les différent blocs).

variable entier a -> 5

verifier a {
    cas 0:
        envoyer "Salut"
        ,
    cas 5:
        variable entier b -> 10

        verifier b {
            cas 10:
            envoyer "Bye"
            ,
            cas 25:
            envoyer "++"
            ,
        }
    ,
}

Bye

tant que -> tantque

Le nom de l'instruction est maintenant tout attaché au lieu de "tant que" on aura "tantque".
Pour les actions, c'est dès maintenant augmenter et diminuer !

variable entier i -> 2
variable entier a -> 10
variable entier z -> 3

tantque i > 0, diminuer 1 {
    tantque a >= 0, diminuer 5 {}
    tantque z >= 0, diminuer 1 {}
}

envoyer a
envoyer z

changer i -> 2
changer a -> 10
changer z -> 3

tantque i > 0, diminuer 1 {
    tantque a > 0, diminuer 5 {}
    tantque z > 0, diminuer 1 {}
}

envoyer a
envoyer z

0
0
5
1

math

Nouvelle syntaxe: math VAR_NAME [ CALCUL ]
Le type de base d'une variable déclaré avec math est toujours decimal

math a [ 10 + 5 - 2 ]
envoyer a

V2.3 : Correction Bugs + Boucle

Contenu

• Corrections des bugs présent + ajout de la boucle :
  • Pouvoir ajouter 0.5 à une variable de type decimal dans la boucle tant que sans devoir mettre le numéro vérifier en type decimal.
    Exemple avec fix:

variable decimal i -> 0.0;

tant que i < 2 incrementer 0.5 {
    envoyer "i (1) : " i;
}

envoyer "La valeur i vaut a la fin : " i;

Exemple sans fix:

variable decimal i -> 0.0;

tant que i < 2.0 incrementer 0.5 {
    envoyer "i (1) : " i;
}

envoyer "La valeur i vaut a la fin : " i;

Ajout de l'instruction verifier

Première instruction pour executer des conditions, tout les éléments jusqu'à la V2.3 seront remis directement dans le parser de la V3 et seront approfondi.

V2.15 : Première boucle

Contenu :

Création de types

• Ajout de la création de type, sous ce format :

• type nouveau TYPE -> "le_nouveau_ici";
• type supprimer "le_nouveau_ici";
  • Exemples :

type nouveau entier -> "int";
variable int a -> 5;
envoyer a;

paquet types {
    type nouveau entier -> "int";
}

variable types.int a -> 5;
envoyer a;    

Boucle tant que

• Ajout de la boucle tant que, format :

• tant que VARIABLE OPERATEUR VALEUR incrementer VALEUR { }
• tant que VARIABLE OPERATEUR VALEUR decrementer VALEUR { }
  • Exemples :

      variable entier i -> 0;
      
      tant que i < 10 incrementer 1 {
          envoyer "i (1) : " i;
      }
      
      tant que i > 5 incrementer 1 {
          envoyer "i (2) :" i;
      }
      
      envoyer "La valeur i vaut a la fin : " i;

• ATTENTION : les opérateurs =, >= et <= ne sont pas encore disponibles dans cette mise à jour !

Documentation

tant que : https://program-4.gitbook.io/french-programming-language/instructions/ajout-de-types
type : https://program-4.gitbook.io/french-programming-language/instructions/boule-tant-que

V2.0 : Un nouveau parser

Parser

Un nouveau parser est arrivé pour cette nouvelle version !

Rien de particulier modifié/ajouté au premier regard mais en backend beaucoup de chose ont changé : plus de séparation des fichiers, accès aux datas du code sans problème, etc.

La documentation a également été mis à jour ! Des changements risques d'arrivé à la fin de la pre-release.

Cependant, les instructions pour les boucles et conditions ont temporairement été enlevé, elle reviendront pendant la V2.

News

Le langage comporte une nouveauté : les paquets, ils permettent le regroupement des éléments telle que les fonctions ou autre, voir la doc.