s
19 708 Pages

cyclone
auteur AT T Labs, Université Cornell
Date d'origine 2001
dernière version 1.0
utilisation Générique (rendement élevé)
paradigmes programmation procédurale, programmation structurée
dactylographie statique
influencé par C
Il a influencé rouille
Mise en oeuvre de référence
exécution GCC
le système d'exploitation Microsoft Windows
site Web

cyclone est un langage de programmation publié le 8 mai 2006 et destiné à devenir un dialecte sûr C. En fait, contrairement à ce dernier parvient à éviter la dépassements de tampon et d'autres vulnérabilité endémique du langage C, sans perdre la puissance et la commodité du programmation structurée.

Le développement du cyclone a commencé comme un projet commun entre le groupe AT T Labs et Greg Morrisett de Université Cornell, en 2001.

Caractéristiques linguistiques

Cyclone parvient à éviter certains des problèmes communs C, tout en conservant son aspect et de performance. A cet effet, le cyclone a les limites suivantes sur les programmes:

  • contrôles NULL pour éviter les erreurs de segmentation
  • Limiter l'utilisation de arithmétique de pointeur
  • Obligation de l'initialisation de la matrice avant l'utilisation
  • Analyse de la région pointeur ballants et l'utilisation de free () limité
  • Autorisé seulement la coulée et l'union « en toute sécurité »
  • goto désactivé dans certaines zones
  • Les étiquettes changent désactivé en cas de homonymie
  • Obligation de retourner des pointeurs avec retour
  • setjmp et longjmp non pris en charge

Afin de garder les ensembles d'outils qui sont utilisés par les programmeurs C, Cyclone fournit les extensions suivantes:

  • pointeurs ne ayant jamais fuméNULL ne nécessitent pas de contrôles NULL
  • Les pointeurs arithmétiques par des pointeurs "FAT" et les limites de contrôle sur Exécution
  • Gestion de la mémoire pris en charge par régions cultivables
  • Collecte des ordures ménagères pour l'attribution de valeurs tas
  • syndicats tag Il prend en charge différents types d'arguments
  • la injections contribuer à l'automatisation des délégués
  • fonctions void * remplacé par polymorphisme
  • varargs mis en œuvre
  • la la gestion des exceptions le remplacement des utilisations de setjmp et longjmp

Pointeurs / Types de référence

Cyclone met en œuvre trois types de références (suivant la terminologie C):

  • * (Pointeur partagé)
  • @ (Pointeur ne ayant jamais fuméNULL)
  • ? (Pointeur de support arithmétique de pointeur et pointeurs "Fat").

Ces nouveaux types de pointeurs ont été mis en place pour éviter des problèmes communs. Considérons la fonction foo, qui dirige le pointeur vers un entier:

int foo(int *);

Cet article suppose que le créateur de contrôle foo ne sont pas entrées par des contrôles NULL pour des raisons de performance, appelant en fait foo (NULL); le code entraînerait une le signal SIGSEGV. Pour éviter de tels problèmes, Cyclone introduit le type de pointeur Jamais-nul @. Par conséquent, la version « sécurité » de foo serait:

int foo(int @);

De cette façon, le compilateur comprend que foo il est ne ayant jamais fuméNULL, évitant le comportement non défini précité. L'échange simple * en @. Il permet au programmeur d'éviter les contrôles d'écriture NULL. Cette limite plus, cependant, peut être un gros obstacle pour la plupart des programmeurs C, habitués à manipuler des pointeurs directement avec l'arithmétique, mais conduirait à dépassements de tampon et d'autres erreurs similaires. Pour éviter cela, le pointeur ? Il est désigné pour cette fonction. Bien que cela ajouterait l'information supplémentaire améliore la sécurité. Prenons par exemple une fonction simple strlen, écrit en C:

int strlen(const carboniser *s)
{
int processus = 0;
si (s == NULL)
retour 0;
tandis que (s[processus] != '\ 0') {
processus++;
}
retour processus;
}

Cette fonction suppose que la chaîne est passée et complétée par le contrôle NULL ( '\ 0'). Cependant, nous risconteremmo erreurs dans passe un tableau. Bien que ne serait pas reconnu cette erreur C, aurait besoin d'utiliser strlen pour corriger la répartition de la mémoire de chaîne s, bien que ces fonctionnalités ne sont pas standard avec toutes les versions de la mise en œuvre ANSI C. Cyclone, en fait utilise strlen pas si différent de C:

int strlen(const carboniser ? s)
{
int processus, n = s.taille;
si (s == NULL)
retour 0;
pour (processus = 0; processus < n; processus++, s++) {
si (*s == '\ 0')
retour processus;
}
retour n;
}

On peut voir, dans l'exécution du code, les limites strlen dans le passage de la longueur de la matrice. la ? Il est utilisé comme un pointeur sur la table adressée par le compilateur, (la transition entre * à ? Il place un contrôle de gamme, en fait, si nous avions utilisé le pointeur @ au lieu de ? nous aurions dû utiliser les contrôles supplémentaires NULL et une pièce moulée par * à ? pour chaque commande NULL)

employés Pointeurs et analyse des régions

Considérez le code suivant, écrit en C:

carboniser *itoa(int la)
{
carboniser BUF[20];
sprintf(BUF,"% D",la);
retour BUF;
}

Le code renvoie la valeur d'un objet alloué sur la fonction de la pile itoa, qui ne sera plus disponible après l'exécution des instructions. tandis que GCC et d'autres compilateurs avertissent de ce code, les éléments suivants seront compilés sans problèmes:

carboniser *itoa(int la)
{
carboniser BUF[20] *z;
sprintf(BUF,"% D",la);
z = BUF;
retour z;
}

Cyclone, ce qui rend une analyse régionale, blocs pointeurs de la façon dont itoa, faire variables locales séparées par le groupe ou par toute autre région. De cette façon, l'initialisation itoa, le compilateur verrait que z les points à la pile locale, rencontrez des erreurs.

Gestion manuelle de la mémoire

Exemples

Le meilleur exemple de Cyclone est le programme de langue classique Bonjour tout le monde:

#include 
#include 
en utilisant noyau;
int principal(int argc, string_t ? args)
{
si (argc <= 1) {
printf(« Utilisation: bonjour-cyclone \ n");
retour 1;
}
printf(« Bonjour de Cyclone,% s\ n", args[1]);
retour 0;
}

Articles connexes

liens externes

documentation: