Cours gratuits » Cours informatique » Cours programmation » Cours langage D » Cours initiation language D en PDF

Cours initiation language D en PDF

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Cours initiation language D méthodes et explications [Eng]

...

1.1 Motivation

Le succès des langages de programmation modernes est influencé non seulement par les caractéristiques de la langue, mais aussi par la disponibilité et la qualité de l'ensemble des outils linguistiques: compilateurs, outils de construction, débogueurs, environnement de développement intégré (IDE), profileurs, etc. De tous ces outils, l'IDE est le plus crucial: non seulement il est responsable de l'intégration avec les autres outils de développement, mais il fournit également un environnement d'édition où un projet logiciel et ses fichiers source sont manipulés.

ify;">En effet, l'IDE est le lieu où le flux de travail d'un développeur est centré, et où il passe la majorité de son temps [1], illustrant son importance. Les IDE ont vu une grande quantité de développement depuis leur aube, ayant beaucoup augmenté en puissance. À titre d'exemple, considérons les IDE modernes tels que Eclipse1, Microsoft Visual Studio2 ou IntelliJ IDEA3. Pour les langages Java et C #, ces environnements de développement intègrent un riche ensemble de fonctionnalités, notamment la navigation sémantique par code (aller à la déclaration, code, etc.), l'intégration complète d'outils (compilateur, générateur, débogueur) plus récemment, divers refactorings automatisés.

Ce niveau de fonctionnalité IDE améliore considérablement la productivité des développeurs [2], et pour cette raison, les nouveaux langages avec des IDE n'ayant guère plus que des fonctions basiques d'édition de texte peuvent rapidement se trouver désavantagés par rapport aux IDE disponibles pour ces autres langages. En effet, l'existence d'IDE de haute qualité pour une langue donnée peut jouer un rôle aussi important que la qualité du langage lui-même. Mais même si cela peut être important, la mise en œuvre d'un IDE à partir de zéro est également une tâche complexe et laborieuse. Pour cette raison, Eclipse présente une option très intéressante: la plateforme Eclipse.

La plate-forme Eclipse est une plate-forme de développement d'EDI extensible qui offre [3]:

 € ¢ Un cadre complet pour le développement d'IDE personnalisés, fournissant un support pour les fonctionnalités IDE génériques.

 € ¢ Intégration avec des outils de développement complémentaires, tels que l'outil de construction Apache Ant, les systèmes de contrôle de source tels que CVS ou Subversion, ou tout autre outil disponible en tant qu'extensions.

 € ¢ Un environnement d'interface utilisateur commun et le comportement à travers différents langages et outils.

  • Plus récemment, la possibilité d'intégration inter-langues.

La plate-forme Eclipse héberge deux IDE faisant officiellement partie d'Eclipse: JDT4 et CDT5. Les deux sont devenus très populaires, en particulier JDT, qui est reconnu comme l'un des IDE les plus puissants et riches en fonctionnalités [4], rivalisé seulement par IntelliJ IDEA (un IDE Java commercial), et, dans une moindre mesure, NetBeans . Le succès et la croissance continue de JDT et de CDT, ainsi que de la plate-forme Eclipse sous-jacente, sont notoires et ont attiré de nombreuses personnes vers le développement d'applications basées sur Eclipse. D'autres projets ont démarré dans le but de créer des IDE Eclipse pour des langages plus récents, tels que PHP, AspectJ, Ruby, C #, et bien d'autres. Un tel langage nouveau et prometteur est le langage de programmation D, et c'est avec cette motivation que ce projet de thèse consistera en la création d'un IDE basé sur Eclipse pour le langage de programmation D, tout en examinant l'état de la art dans la création d'IDE avec de riches fonctionnalités de manipulation de code, d'une manière agnostique langage.

1.2 Le langage de programmation D

Le D Programming Language6 est un langage de programmation système, créé par Walter Bright en 2001 et en cours de développement depuis. D a été créé avec l'intention d'être un successeur de C ++ et vise à relier les capacités des systèmes de programmation de bas niveau (tels que la génération de code natif, l'accès et la manipulation matérielle, et la génération de code efficace) (comme le garbage collection, la programmation de contrat, ou les constructions fonctionnelles pour appeler uns), tout en maintenant en même temps un design simple et propre (quelque chose considéré assez manquant en C ++).

D est un langage de famille C, nativement compilé. Ce n'est pas un sur-ensemble de C ++ ou de C, et en tant que tel, il n'est pas compatible avec eux (comme de nombreux aspects de la syntaxe C ++ étaient censés être repensés), mais il a une compatibilité binaire avec C. pas de fichiers d'en-tête), ne nécessite pas de préprocesseur, ne nécessite pas de déclarations anticipées, a des types primitifs bien définis, prend en charge les structures, unions et énumérations, prend en charge Unicode dans les types de données de langage et dans le code source soutien. D est un langage orienté objet, avec un héritage unique et un modèle d'objet à interfaces multiples. D prend en charge les classes anonymes, les pointeurs de fonction et les délégués, les littéraux de fonction (connus sous le nom d'expressions lambda dans les langages fonctionnels) et possède des capacités de méta-programmation très étendues7.

Le principal compilateur D est DMD - Digital Mars D8, développé uniquement par Walter Bright, et le front-end de DMD est publié sous une licence open-source (GPL), tandis que le back-end est propriétaire. DMD est suivi de près par son frère GDC - Gnu D Compiler9, qui est un port de l'interface DMD vers le back-end GNU Compiler Collection (GCC).

Le langage D, bien que continuellement développé, possède déjà un ensemble très puissant de fonctionnalités de base, et est déjà une alternative attrayante au C ++, mais seulement en termes de qualités de langage: la chaîne d'outils globale du langage D est pauvre comparée au C ++. autres langues. D a de bons outils de compilation et de compilation disponibles, mais manque de support en termes d'outils IDE et de débogage. Actuellement, les IDEs10 existants vont à peine (voire pas du tout) au-delà des fonctionnalités de coloration syntaxique et de construction de projet, et il n'existe pas de débogueurs spécialisés entièrement fonctionnels pour les débogueurs D (C), mais sans connaissance de Dâ € ™. intern s les fichiers internes de l'objet).

1.3 Objectifs du projet

Le but de ce projet de thèse est de développer un IDE riche en fonctionnalités pour le langage D, basé sur la plateforme Eclipse.

Autant que possible, il visera l'ensemble des fonctionnalités utilisateur suivantes:

Gestion de projet - Fonctionnalité de gestion des paramètres d'un projet et de ses ressources membres et fichiers source.

D Editor - Un éditeur de code source pour D, avec diverses fonctionnalités d'éditeur telles que la coloration syntaxique, le pliage de code, etc.

Rapport d'erreurs de syntaxe - La capacité de signaler les erreurs de syntaxe.

Vue en plan - Vue en plan montrant les éléments structurels de niveau supérieur d'un fichier source en D.

Project Builder - Un générateur capable de gérer, construire et lancer un projet D.

Navigator View - Vue du navigateur Eclipse personnalisée pour les projets en langage D.

Assistance à la navigation par code:

Aller à la définition - Une opération qui trouve et ouvre la définition d'un élément de langue sélectionné, éventuellement dans un autre fichier.

Rechercher des références - Une opération qui trouve toutes les références à l'élément sélectionné.

Aller à Super classe / méthode - Une opération qui trouve et ouvre la définition du parent de l'élément de langue sélectionné.

Outline Pop-up - Une fenêtre contextuelle d'éditeur contenant une vue générale avec une requête textuelle simple pour filtrer les noms (également appelée Quick Outline).

Fenêtre contextuelle Type de hiérarchie - Une fenêtre contextuelle d'éditeur contenant une vue hiérarchique de type (également appelée type rapide)

Hiérarchie).

Édition de code

Code Completion - Une opération qui propose des complétions pour les éléments en cours de saisie.

Code Modèles - Une opération qui propose des modèles de code (dans le même pop-up que l'achèvement du code), chaque fois qu'une certaine clé de texte prédéfinie est entrée.

Corrections rapides - Opération qui propose des modifications (correctifs) pour les erreurs dans le code source.

Formatage de code - Fonctionnalité pour ajuster l'indentation et l'espacement selon la structure du document.

Refactoring:

Refactor-Rename - Une opération qui change le nom d'un élément donné, mettant à jour toutes les références à cet élément.

L'intégration du débogueur n'est pas une fonctionnalité de projet planifiée.

Étant donné qu'il s'agit d'un projet concret et concret, il est prévu de le publier en tant que projet open-source

D communauté de développeurs dès qu'il devient utilisable. Cela permettra au projet d'avoir une base d'utilisateurs, permettant une rétroaction et aussi un certain degré de test. De plus, dans la mesure où cela en vaut la peine, le code produit doit être bien structuré et documenté, afin que le travail effectué ici puisse potentiellement être étendu ou réutilisé par d'autres.

Ce document est structuré en deux parties principales: La première partie (chapitres 2 et 3) explore les différentes questions entourant la mise en œuvre d'EDI avec de riches caractéristiques sémantiques, de manière agnostique. Deux termes particuliers sont utilisés ici:

Langue cible - La langue pour laquelle l'IDE personnalisé est développé, à savoir D.

Hôte - Langue dans laquelle l'IDE personnalisé est développé. Dans le cas d'Eclipse, c'est Java.

La deuxième partie de ce document (chapitre 4) détaille l'effort de développement pour produire l'implémentation IDE basée sur Eclipse pour le langage D.

 2 Intégration Eclipse

2.1 Plate-forme Eclipse

La plate-forme Eclipse est un framework Open Source complet pour le développement d'IDE. Il offre une base solide de blocs de construction où les IDE personnalisés (ainsi que d'autres types d'applications) peuvent être construits et intégrés ensemble [3].

2.1.1 Architecture d'Eclipse

Eclipse est conçu et construit à l'aide d'une architecture de plug-in. Un projet développé pour la plate-forme Eclipse consiste en un ensemble d'un ou de plusieurs plug-ins, où chaque plug-in représente un module logique de ce projet, qui peut à son tour dépendre d'autres plug-ins. Chaque plug-in contribue à Eclipse en fournissant des implémentations (appelées extensions) de points d'extension bien définis, et de nombreux composants d'Eclipse sont des plug-ins eux-mêmes (ceci est représenté sur la figure 2.1). Un groupe de plug-ins interdépendants peut être regroupé dans ce qu'on appelle une fonctionnalité, ce qui leur permet d'être installés et mis à jour ensemble.

2.1.2 Architecture IDE

La plupart des EDI Eclipse, quelle que soit la langue cible, suivent une architecture générale similaire. Ils sont divisés en composants majeurs séparés où chaque composant est empaqueté dans un plug-in qui lui est propre, avec une API d'interaction bien définie. Il y a généralement au moins deux composants principaux: le noyau et l'interface utilisateur (UI). En outre, il peut y avoir des composants pour le débogage, le système de construction ou la documentation, si leur taille mérite un plug-in distinct. La Fig. 2.2 montre une telle architecture IDE de base, avec trois composants principaux.

2.1.2.1 Le noyau:

Le noyau est le cerveau de l'EDI et il est responsable de la gestion de la logique de domaine des projets de la langue cible. La logique de domaine, qui dans son ensemble peut être appelée le modèle de langage, est composée principalement de deux parties: le modèle de projet, qui spécifie quels sont les fichiers du projet, les options de configuration, etc. modèle source, une représentation sémantique structurée du code source des fichiers du projet. Cette structure est généralement un arbre de syntaxe abstraite (AST), ou un dérivé de celui-ci. Il est généré par un analyseur de langage (voir 2.2.1) et constitue une structure de données très importante, largement utilisée dans l'EDI. Le noyau est également responsable de la construction et du lancement du projet, qui consiste généralement à appeler un compilateur externe avec les différentes options de configuration du projet. Le système de compilation peut également collecter des messages du compilateur à partir de ce processus (en particulier si le compilateur est externe) et les rapporter à l'utilisateur. Si ce système est assez complexe, il peut parfois être placé dans son propre plug-in.

2.1.2.2 UI:

L'interface utilisateur est responsable de l'interaction de l'utilisateur et du contrôle des opérations sur les données de domaine, telles que le code source, les ressources du système de fichiers ou d'autres éléments de langage. L'interface utilisateur comprend plusieurs composants tels que l'éditeur, les vues, les actions, les assistants, les pages de préférences, etc. Il est responsable de ces composants, ainsi que des interactions entre eux et le plan de travail Eclipse.

à ¢ â,¬Â

2.1.2.3 Déboguer:

Le composant de débogage est responsable du lancement et de l'exécution des programmes du langage cible dans un environnement de débogage et fournit les fonctionnalités requises pour le débogage interactif. Le débogage peut implémenter un débogueur propre, ou il peut s'interfacer avec un one1 externe. Le composant Débogage peut posséder son propre composant d'interface utilisateur pour héberger des fonctionnalités d'interface utilisateur spécifiques au débogage. Le sujet de l'implémentation du composant Déboguer n'est pas examiné dans ce document.

2.2 Composante de base

Le noyau est, comme son nom l'indique, le centre de l'IDE. Dans cette section, les sous-composants de base d'un cœur IDE sont examinés. Au chapitre 3, les fonctionnalités les plus avancées d'un IDE sont analysées.

2.2.1 Analyseur

L'un des principaux sous-composants du noyau est l'analyseur de langage. Le travail du parserâ est de reconnaître la langue d'un fichier source, tout en créant une représentation structurée en mémoire du code source. Aho, Sethi et Ullman [5, 15] distinguent deux types de représentations: un arbre de syntaxe abstraite (AST) et un arbre d'analyse2. L'AST diffère de l'arbre d'analyse en ce que les nœuds redondants ou non pertinents à la structure sémantique du programme sont supprimés ou simplifiés, alors que l'arbre d'analyse est une structure directement ou très étroitement liée à la grammaire du parserâ € ™ s. productions.

La création d'un analyseur est une tâche qui sort du cadre de la plate-forme Eclipse et, par conséquent, Eclipse n'offre pas de prise en charge directe. Un analyseur est codé indépendamment d'Eclipse, soit en tant qu'application externe, soit en tant que code Java utilisé directement par l'IDE Eclipse. Il existe plusieurs options pour créer l'analyseur: l'analyseur peut être développé à partir de rien; des outils de compilateur externes préexistants peuvent être utilisés pour analyser un AST (si de tels outils existent pour la langue cible); ou l'analyseur peut être créé en utilisant un générateur d'analyseur. Voici une liste (nullement exhaustive) de certains générateurs d'analyseurs syntaxiques qui génèrent du code en langage Java:

 € ¢ ANTLR3 - Générateur d'analyseur développé par Terrence Parr avec plus de 15 ans de développement. Très bien soutenu et documenté. Génère des analyseurs LL (*) à partir de la version 3.

 € ¢ JikesPG4 - Générateur d'analyseur qui fait partie du compilateur Jikes. Rapide mais pas bien documenté et n'est plus développé activement. Pourtant, c'est celui utilisé par JDT.

 € ¢ JavaCC5 - analyseur LL (1) basé sur Java.

 € ¢ SableCC6 - Générateur d'analyseur LALR (1) basé sur Java.

2.2.2 AST

L'une des structures de données centrales que le noyau doit gérer est l'AST. L'AST, comme mentionné précédemment, est créé par l'analyseur à partir d'un fichier source, et est une représentation sémantique structurée du code source, sous forme arborescente. La fonctionnalité sémantique d'un IDE est directement ou indirectement déterminée par l'AST.

À tout le moins, les nœuds d'AST contiennent des informations telles que le type de nœud, les nœuds enfants et la position dans le code source d'où provient le nœud. Mais la plupart des fonctionnalités avancées d'un IDE (comme la définition ouverte, l'achèvement de code, le refactoring de code, etc.) nécessitent progressivement une structure AST plus complexe et plus détaillée. Dans la section 3, les problèmes de conception et les exigences fonctionnelles requises pour de telles fonctions avancées sont examinés plus en détail.

2.2.3 Modèle de projet

Une autre structure de données importante que le noyau gère est le modèle de projet. Cette structure est constituée des informations nécessaires pour décrire un projet dans son ensemble, tels que les dossiers source du projet, les fichiers source et les bibliothèques requises (appelé génériquement le «chemin de compilation» 7 ), les options de compilateur et de compilation, les conditions et variables de compilation, etc. Cette information est utilisée non seulement pour construire un projet, mais aussi pour décrire la structure sémantique globale du projet. Dans les langages cibles avec des systèmes de modules structurés8, les informations de chemin de construction sont nécessaires pour avoir une idée complète des fichiers source et des entités et symboles de langage disponibles pour l'achèvement du code, la recherche sémantique, le refactoring, etc.

2.2.4 Project Builder

Un autre sous-composant principal est le constructeur de projet (ou simplement "constructeur") Bien que non strictement requis, ce composant est généralement présent dans la plupart des IDE avancés, car il offre une meilleure expérience utilisateur lorsque le constructeur est partiellement ou entièrement intégré à l'EDI, ne nécessitant pas d'action externe pour l'invoquer Le générateur est responsable de l'exécution de toutes les étapes nécessaires à la construction et à la compilation de l'artefact cible, tel qu'un exécutable ou une bibliothèque. sortie du processus de construction et signalez tous les messages ou événements importants à l'interface utilisateur, par exemple les erreurs de compilation et les avertissements, qui sont renvoyés au workbench Eclipse sous la forme de marqueurs de problème9. Un moteur d'analyse sémantique complet n'est pas disponible, et repose donc sur un constructeur ou un compilateur pour ces informations.Les constructeurs Eclipse peuvent fonctionner de deux façons: complète ou incrémentielle. Il construit une sortie à partir de zéro, à chaque invocation. Les générateurs incrémentiels sont des générateurs qui prennent en compte uniquement les ressources de système de fichiers ou les éléments de modèle qui ont été modifiés depuis la dernière génération et qui sont capables de produire la sortie de génération sans effectuer de génération complète. Cela est possible dans Eclipse grâce à un mécanisme qui suit et collecte les deltas de changement de ressource et les envoie au constructeur lorsque cela est demandé.

2.2.5 Nature du projet

Une autre tâche du noyau IDE consiste à définir une nature de projet pour la langue cible. Une nature de projet Eclipse est un mécanisme qui identifie un projet de workbench avec une caractéristique particulière (telle que le langage du projet). Rappelons que la plate-forme Eclipse peut héberger plusieurs EDI, chacun étant responsable de son propre langage, et qu'un tel projet peut appartenir à n'importe laquelle de ces langues. Une nature de projet identifie la langue à laquelle le projet appartient réellement. Cela permet à Eclipse de savoir pour quels projets il doit activer un plug-in IDE particulier et ses fonctionnalités respectives (telles que les éléments d'interface utilisateur). En outre, un projet peut avoir plusieurs natures, comme c'est le cas, par exemple, d'un projet PDE10, qui a une nature PDE ainsi qu'une nature Java. Une nature de projet est également la manière standard d'attacher et de configurer (et de dé-configurer aussi) un générateur pour ce projet [6]. Quand une nature est ajoutée à un projet (ce qui arrive généralement lors de la création du projet), alors cette nature configure un générateur approprié pour le projet (et fait l'inverse dans le cas de la suppression de la nature).

2.3 Composante de l'interface utilisateur

Le prochain composant majeur de l'IDE est l'interface utilisateur. L'interface utilisateur comprend des éléments tels que des vues, des menus, des actions, des pages de préférences, des assistants et, bien sûr, l'éditeur lui-même. La figure 2.3 illustre les différents éléments de l'interface utilisateur de l'atelier Eclipse. La plupart de ces sous-composants d'interface utilisateur sont simples et faciles à implémenter, et l'on peut facilement apprendre à créer des extensions d'interface utilisateur en consultant des exemples d'implémentation ou dans la documentation correspondante. Cependant, certains de ces sous-composants sont un peu plus complexes, en particulier l'éditeur de code source et sa structure de texte sous-jacente. Une vue d'ensemble de ce framework et de son mécanisme de personnalisation est ensuite donnée.


126