Débuter avec le langage D

I-D-1-a. Les types simples▲

I-D-1-b. Les autres types▲

Cette section expose quelques éléments de la structure du langage. L'objectif n'est pas de décrire toutes les particularités du langage, car ce n'est pas le but de ce document.
Nous allons donc voir :

• Le point d'entrée d'un programme
• La classe
• Les modules
• Les tableaux
• Les boucles
• Structure du if
• Structure du switch
• Les exceptions
• Les templates
• Insertion de code assembleur
• Appel de fonctions C

I-D-2-a. Point d'entrée▲

void main() {
  // le code ce trouve ici
}

int main(char[][] args) {
  // le code ce trouve ici
  return 0;
}

I-D-2-b. Déclaration d'une classe▲

class MaClasse {
  int unInt() { return 3; }
}

I-D-2-c. La notion de module▲

module MonModule;

module MonPackage.MonModule;

module ModAinclure;
void methodeInc() {
  // Mon code
}

module ModQuiContient;
import ModAinclure;

void test() {
  methodeInc(); // appel de la méthode du module ModAinclure
}

I-D-2-d. Les tableaux▲

// Déclaration dynamique de tableau
int[] tab1;
int tab1[];

// Déclaration static de tableaux
int[4][3] tab2;
int[4] tab2[3];
int tab2[3][4];

int* pointer; // déclaration d'un pointer
int[5] tab2;
int[] tab3

// Pointer pointe vers le premier élément de tab2
pointer = tab2;
// tab3 est initialisé pour pointer vers tab2
tab3 = tab2

int[10] tab1;
int[] tab2;

// tab2 va pointer vers les trois éléments tab1[1],tab1[2] et tab1[3]
tab2 = tab1[1..4];

int val;
tab1[3] = 5;
val = tab2[2] // val contient la valeur 5

char[6] str = "coucou";
char[6] cop;

// Copie tous les caractères (6) de str dans cop
cop[] = str;
cop[] = str[];

// Copie l'élément 0 ("c") du tableau str vers l'élément 1 du tableau cop. 
cop[1..2] = str[0..1]; // équivalant à la ligne suivante :
cop[1] = str[0];
// Copie les éléments 2 et 3 ("uc") du tableau str vers les éléments 0 et 1 du tableau cop.
cop[0..2] = str[2..4];    // équivalent aux deux lignes suivantes :
cop[0] = str[1];
cop[1] = str[2];

char[3] tab1;
char[6] tab2;

// Affectation de la valeur "a" dans tout le tableau tab1
tab1[] = 'a';
// ou 
tab1[0] = 'a';
tab1[1] = 'a';
tab1[2] = 'a';

//Affectation d'une partie du tableau
tab2[2..4] = 3; // en utilisant le slice 
// ou 
tab2[2] = 'a';
tab2[3] = 'a';

char[] tab1 = "hello";
char[] tab2 = " world";
char[] conca;

conca = tab1 ~ tab2;

I-D-2-e. Les boucles▲

for (int i = 0; i < 5; i++) {
  // mon traitement
}

int i = 0;
while (i < 5) {
  // mon traitement
  i++;
}

int i = 0;
do {
  // mon traitement
} while (++i < 5);

char[] a;

foreach (int i, char c; a) {
  // mon traitement
}

I-D-2-f. Structure du if▲

int val = 0;
...

if (val > 0) {
  // mon traitement si vrai
} else {
  // mon traitement si faux
}

I-D-2-g. Structure du switch▲

char[] nom;
...
switch (nom) {
 case "seb":
   // traitement
   break;
 case "laurence":
   // traitement
   break;
 ...
 default :
   // traitement
}

I-D-2-h. Les exceptions▲

try {
  // Traitement susceptible de lancer une exception;
} catch(Exception e) {
  // Traitement de l'erreur
}

throw new Exception("Problème de traitement");

I-D-2-i. Les templates▲

template TCopy(T)
{
    void copy(out T to, T from)
    {
      to = from;
    }
}

int i;
TCopy!(int).copy(i, 3); // Notre type générique sera donc un int

I-D-2-j. Insertion de code assembleur▲

int foo(int x) {
  asm {
    mov EAX,x;
  }
}

I-D-2-k. Appel de fonctions C▲

extern (C) int strcmp (char * str1, char * str2 );

import std.string;

int comparer(char[] maChaine) {
  return strcmp(std.string.toStringz(maChaine), "Une chaîne");
}

La version stable actuelle du compilateur est la 1.x, et c'est cette version qui sera installée dans ce tutoriel.
Dans l'environnement cible, nous allons utiliser la bibliothèque Tango (cette bibliothèque est très utilisée dans les différents projets), même s'il en existe une autre qui est Phobos (livrée directement avec le compilateur dmd).
Tango est livrée avec le compilateur dmd et le linker, dans notre cas, les versions sont 0.99.7 pour Tango et 1.033 pour dmd. C'est cette version qui sera utilisée afin de garantir la compatibilité entre les différentes bibliothèques.

Il faut donc :

• récupérer le zip de Tango ;
• décompresser le contenu dans un répertoire (par exemple : D:/compile) ;
• pour plus de simplicité, renommer le répertoire tango-0.99.7-bin-win32-dmd.1.033 en « dmdt » ;
• mettre le répertoire bin dans la variable d'environnement « path ».

Comme je l'ai précisé plus haut, le compilateur est livré dans l'archive de Tango. Par conséquent, le fichier de configuration du compilateur (« répertoire d'installation »/bin/sc.ini) est préconfiguré pour fonctionner avec la bibliothèque Tango.
Ce fichier de configuration contient :

• LIB : la référence au répertoire contenant les bibliothèques qui seront recherchées par le linker ;
• DFLAGS : les arguments qui seront envoyés au compilateur (dmd.exe) ;
• LINKCMD : le linker utilisé par le compilateur.

Le %@P% que l'on peut voir dans les chemins sera remplacé par le compilateur avec le chemin du sc.ini. Si vous n'avez rien changé, ce chemin est : « répertoire d'installation »/bin.

Concernant le répertoire d'installation, il est conseillé d'avoir un chemin sans espace. Cependant, il semblerait que cela fonctionne si l'on utilise le nom DOS sur 8 caractères.
Notre fichier sc.ini pourrait s'écrire de la façon suivante (dans le cas d'une installation dans c:\program files\dmdt\) :

[Version] 
version=7.51 Build 020

[Environment] 
LIB="c:\progra~1\dmdt\lib" 
DFLAGS="-Ic:\progra~1\dmdt\import" -version=Tango -defaultlib=tango-base-dmd.lib -debuglib=tango-base-dmd.lib -L+tango-user-dmd.lib 
LINKCMD=c:\progra~1\dmdt\link.exe

Une petite précision est toutefois nécessaire sur l'installation du compilateur. D'après le site de digitalmars :

• l'utilisation de la commande unzip de Cygwin peut être la cause de problèmes étranges ;
• le lancement du compilateur en ligne de commande dans le shell Cygwin peut être la cause de problèmes ;
• l'installation de dmd et dmc dans des répertoires contenant des espaces peut être la cause de problèmes.

Pour ceux que cela intéresse, le compilateur et le linker se trouvent sur le site de Digital Mars. Attention : la version doit être compatible avec le reste de l'installation.

L'éditeur, qui sera installé dans ce document, peut fonctionner avec deux débogueurs DDBG et GDB , il est possible que d'autres fonctionnent aussi, mais l'auteur (de Descent) n'a testé que ces deux-là.
Dans le cadre de ce tutoriel, c'est DDBG qui a été retenu. L'installation de celui-ci se fait de la façon suivante :

• récupérer les binaires sur le site du projet DDBG ;
• décompresser le contenu ;
• Copier le fichier ddbg.exe dans le répertoire dmdt/bin/.

DSSS est un outil qui est destiné à créer un système normalisé pour la compilation, l'installation, la configuration, l'acquisition et l'utilisation de logiciels D.
Dans le cadre de ce document, il sera utilisé pour la compilation et pour l'installation de bibliothèques.

L'installation de cet outil se fait de la façon suivante :

• récupérer les binaires sur le site du projet DSSS ;
• décompresser le contenu ;
• ouvrir le fichier dsss/etc/rebuild/default et remplacer dmd-win par dmd-win-tango ;
• ouvrir le fichier dsss/etc/rebuild/dmd-win-tango, rechercher « oneatatime » et remplacer sa valeur par « no ». Attention, il y en a deux à changer ;
• placer le répertoire bin dans la variable d'environnement « path ».

DWT est en fait un portage en D de la boite à outils SWT bien connue dans le monde Java.

La première étape est l'installation des bibliothèques additionnelles :

• récupérer le zip importlibs ;
• décompresser le contenu dans le répertoire dmdt/lib créé lors de l'installation du compilateur.

OPTLINK (R) for Win32  Release 8.00.1
Copyright (C) Digital Mars 1989-2004  All rights reserved.
dsss_objs\D\dwt-widgets-Display.obj(dwt-widgets-Display)
 Error 42: Symbol Undefined _IsHungAppWindow@4
dsss_objs\D\dwt-internal-win32-OS.obj(dwt-internal-win32-OS)
 Error 42: Symbol Undefined _GetSystemDefaultUILanguage@0

La deuxième étape est la compilation et l'installation de DWT :

• récupérer la dernière version de DWT ;
• décompresser le contenu ;
• lancer une console DOS ;
• se positionner dans le répertoire dwt-win ;
• lancer la commande « dsss build » (pas d'inquiétude, c'est très long) ;
• lancer la commande « dsss install ».

DDBI est une bibliothèque qui permet d'effectuer des accès à quelques bases de données et aussi d'utiliser ODBC.
Pour le moment, elle permet l'accès aux bases suivantes :

• MS SQL Server et Sybase ;
• MySQL ;
• PostgreSQL ;
• SQLite 3.

Pour notre installation, nous utiliserons sqlite 3 comme base de données.

Les préparatifs pour sqlite 3 :

• récupérer la bibliothèque (sqlitedll-x.zip) SQLite 3 ;
• décompresser le contenu ;
• récupérer le Basic Utilities ;
• décompresser le contenu ;
• transformer la dll sqlite 3 avec implib.exe : « implib /s sqlite.lib sqlite3.dll » ;
• copier la dll obtenue dans le répertoire dmdt/lib créé lors de l'installation du compilateur.

Il ne reste plus qu'à compiler et installer DDBI :

• récupérer les sources de DDBI ;
• décompresser le contenu ;
• lancer une console DOS ;
• se positionner dans le répertoire 0.2.9 ;
• lancer la commande « dsss build -version=dbi_sqlite » ;
• lancer la commande « dsss install ».

Je ne vais pas m'attarder sur l'installation d'Eclipse, car il existe des tutoriels sur le forum qui vous expliqueront bien mieux que moi comment le faire.
Vous devez donc installer, si vous souhaitez faire du Java et du D, le JDK (Java Development Kit) sinon le JRE (Java Runtime Environment) et un environnement Eclipse.

Le JRE est peut-être déjà installé sur votre environnement. Pour le vérifier, il suffit d'exécuter la commande DOS suivante : « java -version ».
L'installation est automatique, il suffit de suivre les instructions de l'installeur.
Pour Eclipse, pas la peine de prendre une distribution super complète, les suivantes suffiront amplement :

• Eclipse IDE for Java Developers ;
• Eclipse for PHP Developers ;
• Eclipse IDE for C/C++ Developers.

Pour son installation, il suffit de décompresser le fichier téléchargé.
Pour le démarrer, il suffit de lancer eclipse.exe.

Il faut commencer par lancer Eclipse. Lancer l'installation d'un nouveau plugin via le menu « Help / Install new software… »

Cliquez ensuite sur le bouton « Add… » pour ajouter le site de Descent

Donnez un nom, celui-ci vous permettra de retrouver facilement le site en cas de besoin. Saisissez l'URL (http://downloads.dsource.org/projects/descent/update-site) du site et terminez par un clic sur le bouton « OK »

Maintenant que le site est saisi, sélectionnez la version de Descent à installer et validez en cliquant sur « Next ».

L'installeur recherche alors les dépendances nécessaires (cela peut prendre quelques minutes). Ensuite un récapitulatif apparait, validez en cliquant sur « Next ».

Un récapitulatif des plugins nécessitant une licence d'utilisation apparait, vous devez accepter la licence afin de pouvoir continuer. Validez ensuite en cliquant sur « Finish ».

L'installeur va ensuite télécharger tous les paquets et les installer. Cette action peut être très longue.

L'installation est enfin terminée. L'installeur vous demande si vous souhaitez redémarrer Eclipse afin de prendre en compte les modifications apportées. Validez en cliquant sur « yes ».

Avant d'aller plus loin, quelques explications sur la structure de l'interface d'Eclipse sont nécessaires.

1. Permet de changer de perspective. La perspective regroupe un ensemble d'éléments visuels (par exemple les différentes vues) ou non (exemple : le compilateur de la perspective java).
   Le bouton ouvre un menu donnant accès à toutes les perspectives.
2. Bouton permettant d'ouvrir d'autres vues (le 3,5 et 6 sont des vues).
3. La vue projet, qui permet de voir les fichiers des projets en cours.
4. L'éditeur de fichier, un onglet est ouvert pour chaque fichier en cours d'édition.
5. La vue outline, elle montre la structure du fichier en cours d'édition. Un clic sur un élément permet de se positionner sur cet élément dans l'éditeur.
6. La console de sortie, elle affiche les informations de compilation ou lors de l'exécution d'un programme (sortie standard et erreur).

Ce chapitre explique comment mettre en place la configuration générale de Descent qui sera donc identique pour tous les projets.
L'objectif n'est pas de vous expliquer toutes les options de paramétrage de Descent, mais de configurer ce qui est nécessaire au bon fonctionnement de celui-ci.

Il faut donc configurer :

• le chemin de compilation ;
• le débogueur.

II-C-3-a. Le chemin de compilation▲

Pour configurer le chemin de compilation, il faut ouvrir la fenêtre des préférences via le menu « Window / Preferences ».
Il faut ajouter les références de nos différentes bibliothèques et plus précisément le ou les répertoires où se trouvent les fichiers « .di ». Cela permettra à l'éditeur de faire des propositions pour la complétion.

Pour ajouter une bibliothèque, vous définissez le nœud racine (un nom quelconque, par exemple « standardLibs ») en cliquant sur « New… ». Ensuite vous ajoutez le répertoire en cliquant sur « Add Directory… ».
Finalement, vous devez obtenir le résultat ci-dessous :

II-C-3-b. Le débogueur▲

La configuration du débogueur est relativement simple puisqu'il suffit de donner le chemin vers l'exécutable dans la section « debug » des préférences pour le langage D.

Avant de créer votre module, vous pouvez créer un package qui va permettre de mieux organiser les sources. Un clic droit dans la vue « Project », puis sélectionnez dans le menu popup « New / Package ».

Vous pouvez alors saisir le nom ou la hiérarchie (cas avec un ou plusieurs sous-répertoires, exemple : « com.prog ») de votre package. Ensuite validez avec le bouton « Finish ».

Ajoutez un nouveau module via le menu popup « New / Module » en effectuant un clic droit dans la vue « Project ».

Donnez le nom de module et sélectionnez le package où doit être ajouté votre module. Ensuite validez avec le bouton « Finish ».

Votre module est maintenant créé, l'éditeur l'a ouvert dans un nouvel onglet. Ajoutez le code suivant au contenu déjà existant :

import tango.io.Stdout;

void main() {
    Stdout("Hello world !");
}

Bravo ! Vous avez écrit votre premier programme en D.

Vous avez écrit votre module, il faut maintenant le compiler. L'éditeur Descent ne contient pas un « builder » valide (il est en cours de développement), c'est pourquoi vous allez utiliser DSSS.
Vous devez créer un nouveau fichier (dans la vue projet, popup menu « New / File ») dans le répertoire source (src). Nommez le fichier dsss.conf puis validez en cliquant sur le bouton « Finish ».

L'éditeur ouvre alors le fichier dans un nouvel onglet. Il suffit d'y placer le texte suivant :

# Section de compilation
[com/prog/MonPremProg.d]
# nom du fichier exe cible
target=../bin/hello

Votre fichier de compilation est prêt. Pour pouvoir utiliser DSSS au sein d'Eclipse (ce qui est tout de même plus pratique que de lancer une console DOS), vous devez configurer un « external tools ». Exécutez la commande « external tools configuration » soit par la barre de boutons, soit par le menu « Run / External tools ».

Demandez la création d'une nouvelle configuration via un clic droit sur « Program » dans l'arbre à gauche puis sur « New ».

Vous devez donner un nom, l'exécutable à lancer (dans notre cas c'est DSSS), le répertoire d'exécution (le répertoire src du projet « ${project_loc}/src ») et les arguments « build --debug -g ».
Les arguments indiquent à DSSS qu'il faut lancer la compilation en mode debug. Si toutefois vous souhaitez compiler sans le mode debug, il vous suffira de créer une nouvelle configuration en remplaçant « build --debug -g » par « build ».

Afin que vous puissiez voir votre exécutable dans le dossier « bin », vous devez aller dans l'onglet « Refresh ». Il faut cocher la case « Refresh resources upon completion » puis sélectionner « The project containing the selected resource ». Vous pouvez alors tester la compilation en cliquant sur le bouton « Run ».

Dans votre console, vous pouvez constater que l'exécution s'est bien passée :



Pour faciliter la compilation, vous allez ajouter votre « external tool » en tant que « builder » de votre projet.
Pour cela, ouvrez les propriétés de votre projet en faisant un clic droit sur la racine du projet, puis cliquez sur « Properties ».

Dans la section « Builders » décochez « D Builder », ensuite cliquez sur le bouton « Import… », sélectionnez votre « External tool » et validez en cliquant sur « OK ». Pour finir, validez les propriétés en cliquant sur le bouton « OK ».

Votre programme est maintenant créé et compilé, vous voulez donc l'exécuter… mais où est donc l'exécutable ?
La vue projet ne permet pas de le voir. Le plus simple est d'aller dans la vue « Navigator » ou vous pourrez voir votre répertoire bin.

Sélectionnez votre fichier exe et lancez l'exécution via la barre de boutons à l'aide du menu « Run As / D Application ».

En regardant la console, vous pourrez constater l'exécution du programme.

Pour votre première application DWT, vous allez faire l'équivalent graphique de ce bon vieux « Hello World ».

Commencez par créer un nouveau module « HelloWin.d » dans le même package que « MonPremProg.d » et collez le code suivant :

module com.prog.HelloWin;

import dwt.DWT;
import dwt.widgets.Shell;
import dwt.widgets.Text;
import dwt.widgets.Display;

void main() {
    Display display = new Display ();
    Shell shell = new Shell(display);
    
    Text hellotxt = new Text(shell, DWT.NONE);
    hellotxt.setText("Hello World !");
    hellotxt.pack();
    
    shell.pack();
    shell.open ();
    while (!shell.isDisposed ()) {
        if (!display.readAndDispatch ()) display.sleep ();
    }
    display.dispose ();
}

Dans le répertoire des sources de dwt, copiez le fichier dwt.res et placez-le dans le répertoire src du projet (le répertoire de compilation).
Modifiez le fichier dsss.conf de la manière suivante :

# Section de compilation
[com/prog/MonPremProg.d]
# nom du fichier exe cible
target=../bin/hello

[com/prog/HelloWin.d]
target=../bin/helloWin
# permet de masquer la console DOS lors de l'exécution du programme compilé
buildflags += -L/SUBSYSTEM:windows:5
# Nécéssaire pour le thème windows (dwt.res)
buildflags += -L/rc:dwt;

Dans le cas où vous omettriez de rajouter les « buildFlags » vous seriez confronté à l'erreur suivante :

CreateActCtx failed, hence theme support will not be available
Please check for:
 - missing link option -L/su:windows:5 or -L/su:console:5
 - missing link option -L/rc:dwt
 - resource file 'dwt.res' was not accessible by linker
: Le fichier image spécifié ne contenait pas de section ressource.

Vous remarquerez que nous avons dans notre dsss.conf plusieurs sections, ce qui nous permettra d'avoir plusieurs exécutables. Si nous avions un module référençant plusieurs autres modules, il suffirait de mettre notre module racine pour que tous soient compilés.

Maintenant, lancez la compilation et l'exécution du programme, vous obtenez alors votre nouveau « Hello World »

Pour votre dernier test, vous allez créer un nouveau module « DbProg.d » et y coller le code suivant :

module com.prog.DbProg;

import tango.io.Stdout;
import dbi.Row;
import dbi.sqlite.SqliteDatabase;

void main() {
    SqliteDatabase db = new SqliteDatabase();
    db.connect("test.db");

    Row[] rows = db.queryFetchAll("SELECT * FROM sqlite_master");
    foreach (Row row; rows) {
        Stdout("name:")(row["name"]).newline();
    }

    db.close();
}

Complétez ensuite votre dsss.conf :

[com/prog/MonPremProg.d]
target=../bin/hello

[com/prog/HelloWin.d]
target=../bin/helloWin
buildflags += -L/SUBSYSTEM:windows:5
buildflags += -L/rc:dwt;

[com/prog/DbProg.d]
target=../bin/DbAcc
# Permet de compiler avec un accès pour sqlite
buildflags += -Lsqlite -version=dbi_sqlite

Compilez le nouveau module et exécutez-le. Vous n'obtenez rien dans la console ? C'est que le test a fonctionné.
Lors du test, la base « test.db » a été créée (à la racine du projet), mais comme elle ne contient aucune table, la table « sqlite_master » est vide.