introduction language D en PDF


Télécharger introduction language D en PDF

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

Télécharger aussi :


Support de Cours language D en PDF

...

Organisation

  • Un front-end pour les gouverner tous

- et dans le D les lier

- écrit en D

  • Trois arrières

- Mars numérique (dmd)

- Collection de compilateurs Gnu (gdc)

- LLVM (ldc)

Changements majeurs dans la dernière année

  • Converti le frontal de C ++ en D
  • Passer à la gestion des exceptions naines

- ouvre une interface C ++ plus complète

...

Répertoires

  • code source src / front end
  • code générique src / tk pour back-end
  • code générique src / root pour le frontal
  • optimiseur src / backend et générateur de code
  • src / vcbuild pour construire un compilateur avec VS

Types de compilations

  • diagnostiquer les erreurs dans le code source
  • générer une construction de débogage
  • générer une version release

Allocation de mémoire

  • root / rmem.d
  • Allouer, mais jamais gratuit
  • très rapide
  • Pas besoin de suivi de propriété
  • Limite la taille de la compilation

Les cordes

  • root / stringtable.d
  • const (caractère) *
  • les chaînes d'identifiant stockées dans une seule table de hachage
  • l'adresse de la chaîne devient son hash

- Identifier.idPool ()

  • très rapide

Tableau (T)

  • root / array.d
  • un tableau de travail à la dynamique D tableaux
  • accessible à partir de code C ++
  • très utilisé

alias Strings = Array! (const (car) *);

alias Statements = Array! Statement;

alias Identifiers = Array! Identifier;

… etc.

RootObject

  • root / object.d
  • hiérarchie unique enracinée

- un peu comme D's Object, mais avant cela

- une classe C ++, donc accessible depuis la couche de colle

- Déclarations, déclarations, expressions

- utilisation intensive de la programmation orientée objet plus visiteur

Passes

  • lire des fichiers
  • lex
  • analyser
  • créer une table de symboles
  • sémantique 1
  • sémantique 2
  • sémantique 3
  • en ligne
  • colle
  • optimiser
  • générer du code
  • écrire dans un fichier objet

Lexing

  • lexer.d
  • assez simple
  • change rarement
  • principalement préoccupé par la vitesse

L'analyse

  • parse.d
  • aussi simple et change rarement
  • le lookahead est fait en formant une pile de jetons
  • le code ressemble beaucoup à la grammaire…

cas TOKwhile:

{

 nextToken ();

chèque (TOKlparen);

 Condition d'expression = parseExpression ();

 chèque (TOKrparen);

 Loc endloc;

 Statement _body =

 parseStatement (PSscope, null, & endloc);

 s = nouveau

 WhileStatement (loc, condition, _body, endloc);

 Pause;

}

Créer une table de symboles

  • importAll ()
  • établit une portée pour chaque symbole

Portée

  • dscope.d
  • lien vers la portée incluse
  • champs

- module

- une fonction

- classe de stockage en vigueur

- ...

Sémantique

int a;

int b = 3;

int foo () {



 retourne 6;

}

Abaissement

  • réécrire les AST dans des formes canoniques plus simples
  • réduit le nombre de cas devant être traités ultérieurement
  • réduit la complexité et les bugs
  • facilite même la documentation

Boucles

while (cond) {body}

pour (; cond;) {body}

foreach (i; n .. m) {corps}

pour (auto i = n; i <m; ++ i) {corps}

foreach (e; aggr) {corps}

pour (auto r = aggr [];! r.empty; r.popFront ())

{

 auto e = r.front;

 corps;

}

Exceptions

  • réécrit pour être enfin essayer
  • portée
  • synchronisé
  • RAII

Modèles de récupération d'erreur

  • quitter à la première erreur
  • deviner à l'intention de l'utilisateur, puis réparer
  • empoisonnement

Empoisonnement

  • avoir un noeud AST 'erreur' spécial
  • remplacer le noeud AST erroné par le noeud 'error'
  • remplacer tout nœud ayant un enfant 'erreur' par un nœud 'erreur'
  • élimine pratiquement les erreurs en cascade

- les erreurs affichées sont de vraies erreurs

Vérification orthographique

  • root / speller.d
  • pour les identifiants non définis

Pliage constant

  • constfold.d

UnionExp Bool (Type, Expression e1) {

 UnionExp ue;

 Loc loc = e1.loc;

 emplaceExp! (IntegerExp) (& ue, loc, e1.isBool (true)? 1: 0, type);

 retourne toi;

}

Exécution de la fonction de compilation

(CTFE)

  • juste un dossier constant glorifié
  • alloue de la mémoire pour évaluer une expression
  • donc il manque de mémoire
  • et est lent

Modèles

  • Stocké sous forme d'AST tel que produit par l'analyseur
  • Instancier:

- copier l'AST

- définit la portée sur laquelle se trouve la déclaration de modèle

dans la table des symboles

- créer des symboles à partir d'arguments de template

- exécuter des passes sémantiques ()

En ligne

  • inline.d
  • les fonctions pouvant être représentées comme un

l'expression peut être en ligne

int func (int x) {if (x == 8) renvoie 9; sinon, retourne 68; }

y = func (z) + 8;

y = ((int x = z), (x = 8? 9: 68)) + 8;

  • mais ça ne marche pas avec les boucles

Déclarations en ligne

x = 3;

func (x);

y = x + 3;

Défis

  • éliminer les variables globales

- tôt ou tard toujours causer des problèmes avec la logique récursive comme les tripes du compilateur

  • maîtriser la complexité

- réduire la complexité cyclomatique

- le code doit circuler plutôt que de sauter

- modifier les structures de données pour éliminer les cas spéciaux

  • réduire la consommation de mémoire

- localiser (encapsuler) la gestion de la mémoire

Plus de défis

  • améliorer l'encapsulation

- les détails de l'implémentation des conteneurs, comme une liste chaînée ou un tableau

- l'encapsulation signifie que les structures de données peuvent être changées

  • utilisez const / pure / nothrow / @safe
  • meilleure nourriture pour chiens

- trop de vestiges de l'ancienne implémentation de C ++ traînant

………

Propriétés

Chaque symbole, type et expression possède des propriétés pouvant être interrogées:

Exemples de propriété

Valeur d'expression

int.sizeof rendements 4



float.nan renvoie la valeur du point de virage nan (Not A Number)

(float) .nan donne la valeur nan

(3) .sizeof donne 4 (parce que 3 est un int)

int.init initialiseur par défaut pour ints

int.mangleof donne la chaîne "i"

int.stringof donne la chaîne "int"

(1 + 2) .stringof donne la chaîne "1 + 2"

Propriétés pour tous les types

Description de la propriété

initialiseur .init

Taille de la taille en octets

.alignof taille d'alignement

.mangleof chaîne représentant la représentation `mutilé 'du type

.stringof chaîne représentant la représentation source du type 135

Propriétés pour les types intégraux

Description de la propriété

initialiseur .init

Valeur maximale .max

valeur minimale .min

Propriétés des types à virgule flottante

Description de la propriété

Initialiseur .init (NaN)

.infinity in nity value

Valeur NaN .nan

Nombre de chiffres décimaux de précision .dig

.epsilon plus petit incrément à la valeur 1

.mant_dig nombre de bits dans la mantisse

.max_10_exp valeur int maximale telle que 10 <sup> max_10_exp </ sup> soit représentable

.max_exp valeur int maximale telle que 2 <sup> max_exp-1 </ sup> soit représentable

.min_10_exp valeur int minimale telle que 10 <sup> min_10_exp </ sup> soit représentable sous forme de valeur normalisée

.min_exp valeur int minimale telle que 2 <sup> min_exp-1 </ sup> puisse être représentée sous forme de valeur normalisée

.max plus grande valeur représentable qui n'est pas dans nity

.min_normal La plus petite valeur normalisée représentable qui n'est pas 0

.re partie réelle

.im partie imaginaire

Propriétés pour les types de classe

Description de la propriété

.classinfo Informations sur le type dynamique de la classe

7.1 Propriété .init

.init produit une expression constante qui est l'initialiseur par défaut. S'il est appliqué à un type, il s'agit de l'initialiseur par défaut pour ce type. S'il est appliqué à une variable ou à un champ, il s'agit de l'initialiseur par défaut pour cette variable ou ce type de champ.

int a;

int b = 1;

7.1. .INIT PROPRIÉTÉ 137

int.init // est 0

a.init // vaut 0

b.init // est 0

struct Foo

{

int a;

int b = 7;

}

Foo.init.a // vaut 0

Foo.init.b // vaut 7

Remarque: .init produit un objet initialisé par défaut, pas construit par défaut. S'il existe un constructeur par défaut pour un objet, il peut produire une valeur différente.

  1. Si T est une structure imbriquée, le pointeur de contexte dans T.init est null.

void main ()

{

int x;

struct S

{

void foo () {x = 1; } // accède à x dans la portée englobante via le pointeur de contexte

}

S s1; // D'ACCORD. S () initialise correctement son pointeur de contexte.

S s2 = S (); // D'ACCORD. identique à s1

S s3 = S.init; // Mal. le pointeur de contexte dans s3 est null

s3.foo (); // Violation d'accès

}

  1. Si T est une structure qui a désactivé this () ;, T.init peut renvoyer un objet logiquement incorrect.

struct S

{

int x;

@disable this ();

ceci (int n) {x = n; }

invariant {assert (x> 0); }

chèque sans provision () {}

}



148