Cette série d’articles est en construction, tous les codes sources sont disponibles sur github
Le langage Basilic est un langage procédural visant à offrir une syntaxe simple analogue à celle du langage Basic, mais permettant d’exploiter toutes les ressources disponibles dans le langage Java. Basilic est implanté comme un langage de script. Un « compilateur » traduit le code basilic en code java.
Exemple:
helloworld.bcj
helloworld.java : code java produit par le « compilateur »
Basilic est un langage très fortement typé. Aucune conversion implicite n’est autorisée.
Basilic est modulaire. Une unité de compilation (fichier source) correspond à une classe Java. Il n’y a pas de type primitif tel que char, int ,…
Il suffit de définir pour chaque type primitif un module réalisant l’implémentation correspondante.
La version minimale de Basilic est fournie avec les modules (classes) suivants:
boolean, int, string, double, long, byte, system, console, stringvector, conversions, lexical, datetime, filedirectory, inifile, arraytools, stringhashmap, stringstack et zip
Ces modules permettent notamment de modifier et de recompiler le compilateur Basilic si l’on souhaite y apporter des modifications.
Pourquoi Basilic ?
Aucune raison logique !
Peut-être une référence à la chambre des secrets dans Harry Potter ?
et le langage Python ?
Définitions du langage Basilic
Notations syntaxiques
Les accolades { } permettent de spécifier des choix. Ceux-ci sont séparés par le symbole |
Les mots-clés du langage sont notés en gras
Si un bloc accolade contient « » cela signifie qu’il est facultatif
Module ( classe)
suite de { déclaration | instruction | code java | "" }
Un module peut donc être vide !
Déclaration
{ déclaration de variable | déclaration de procédure | déclaration de fonction | « » }
Déclaration de variable
déclareur identificateur suite de , identificateur
Exemples:
int i,n
string[] t1
string[][] t2,t3
Il est possible de définir des variables simples ou des tableaux à une ou deux dimensions. Pour pouvoir être utilisés les tableaux doivent être dimensionnés à l’aide de l’instruction dim
Exemple:
dim t1[50] n=10 dim t2[n*2][5]
- La fonction prédéfinie length retourne le nombre d’éléments pour un tableau à une dimension et le nombre de lignes pour un tableau à deux dimensions
- La fonction prédéfinie collength retourne le nombre de colonnes pour un tableau à deux dimensions
Déclareur
identificateur de type { [] | [][] | "" }
Déclaration de procédure
proc { static | public | "" } identificateur ( paramètres ) { exception | "" }
liste de déclarations de variable
liste d'instructions
end proc
Déclaration de fonction
func { static | public | "" } déclareur identificateur ( paramètres ) { exception | "" }
liste de déclarations de variable
liste d'instructions
end func
Paramètres
{ « » | déclareur identificateur { , déclareur identificateur | « » } }
Exemple:
int n , string k , string[] t
Code java
java
suite instructions et/ou de déclarations java
end java
Exemple:
Remarque: la valeur String java du paramètre d se note d.val (voir l’implantation de la classe string)
Instruction
{ « » | code java | inst. return | inst. affectation | inst.dim | inst appel procedure |
inst. if | inst while | inst. switch | inst. try | inst. for | inst. import | inst heritage interface }
Instruction return
Dans une procédure return
Dans une fonction return expression
Exemple:
Instruction import
Généralement définie au début d’un module, doit être conforme à la syntaxe java
import directive import ;
Exemple
Instruction héritage interface
Doit être écrite au début du module après les instructions import éventuelles
extends identificateur de classe
{ « » | implements identificateur d’interface suivi de { « » | , identificateur d’interface } }
Exemple:
Instruction for
for identificateur de type int while expression booléenne
Exemple
Cette instruction initialise i à 0, et tant que l’expression booléenne vaut vrai, exécute la ou les instructions comprises jusqu’au end for, ajoute 1 au compteur i et retourne évaluer la condition.
Instruction try
try suite d'instructions catch suite d'instructions end catch
Exemple
Instruction while
while expression booléenne
suite d’instructions
end while
Exemple
Remarque: la fonction itos permet de convertir un int en string. Cette fonction est disponible dans le package d’installation.
Instruction if
if expression booléenne
liste d'instructions
{ "" | else liste d'instructions }
end if
Exemple
Instruction switch
switch suite de case expression booléenne liste d'instructions default liste d'instructions end switch
Exemple
Remarque, cette instruction est très différente de celles de C et de Java.
Elle correspond à un suite de si sinon si….
Instruction appel de procédure
identificateur de procédure ( suite d’expression )
Le nombre d’expressions doit correspondre au nombre de paramètres. Le type de chaque expression doit être identique au type du paramètre en respectant l’ordre d’écriture.
Exemple
Instruction dim
Pour les tableaux à une dimension
dim identificateur de tableau [ expression1 ]
Pour les tableaux à 2 dimensions
dim identificateur de tableau [ expression1 ] [ expression2 ]
où expression1 et expression2 sont des expressions de type int
Instruction d’affectation
référence = expression
où référence et expression doivent être de même type
Référence
--> id1 -+-------------^--+---------------------------------^-->
+-> . --> id2 + +--> [ exp1 ]--+--------------^---+
+--> [ exp2 ] -+
où
- id1 et id2 sont des identificateurs de variables,
- exp1 et exp2 sont des expressions de type int
id2 est un attribut d’objet: variable définie dans le module objet (voir en exemple le fichier cbtextfile.bcj dans le chapitre suivant)
Expression
Syntaxe de style C, Java avec les priorités classiques. Voici par priorité décroissante. Sur une même ligne l’évaluation est faite de gauche à droite
or and < <= > >= == != + - * / % - unaire ( )