Siklon (programlama dili) - Cyclone (programming language)

Siklon
Tarafından tasarlanmıştır AT&T Labs
İlk ortaya çıktı 2002 ; 18 yıl önce ( 2002 )
Son sürüm
1.0 / 8 Mayıs 2006 ; 14 yıl önce ( 2006-05-08 )
İnternet sitesi siklon .thelanguage .org
Tarafından etkilenmiş
C
Etkilenen
Rust , Verona Projesi

Cyclone programlama dili güvenli bir lehçesi olması amaçlanmıştır C dilinde . Cyclone, sistem programlama için bir araç olarak C'nin gücünü ve rahatlığını kaybetmeden, C programlarında mümkün olan arabellek taşmalarını ve diğer güvenlik açıklarını önlemek için tasarlanmıştır .

Siklon geliştirme, AT&T Labs Research ve Greg Morrisett'in grubunun Cornell'deki ortak projesi olarak 2001'de başlatıldı. Versiyon 1.0, 8 Mayıs 2006'da yayınlandı.

Dil özellikleri

Cyclone , görünümünü ve performansını korurken, C'nin bazı yaygın tuzaklarından kaçınmaya çalışır . Bu amaçla Cyclone, programlara aşağıdaki sınırları koyar:

C programcılarının alışkın olduğu araç setini korumak için Cyclone aşağıdaki uzantıları sağlar:

  • Asla NULLişaretçiler NULLkontrol gerektirmez
  • "Fat" işaretçiler, çalışma zamanı sınırları denetlemesiyle işaretçi aritmetiğini destekler
  • Büyütülebilir bölgeler, bir tür güvenli manuel bellek yönetimini destekler
  • Yığın ayrılmış değerler için atık toplama
  • Etiketli sendikalar, türe göre değişen argümanları destekler
  • Enjeksiyonlar, programcılar için etiketli sendikaların kullanımını otomatikleştirmeye yardımcı olur
  • Çok biçimlilik, bazı kullanımların yerini alırvoid *
  • vararjlar şişman işaretçiler olarak uygulanır
  • İstisnalar bazı kullanımların yerini alır setjmpvelongjmp

Cyclone için daha iyi bir üst düzey giriş için Cyclone arkasındaki mantık ve bu listelerin kaynağı, bkz bu kağıdı .

Cyclone, genel olarak C'ye çok benzer , ancak C benzeri bir dil olarak görülmelidir.

İşaretçi türleri

Cyclone, üç tür işaretçi uygular :

Bu yeni işaretçi türlerini tanıtmanın amacı, işaretçileri kullanırken yaygın sorunlardan kaçınmaktır. Örneğin, fooint'e bir işaretçi götüren adı verilen bir işlevi ele alalım : 

 int foo(int *);

İşlevi yazan kişi çek eklemiş fooolabilirse de NULL, performans nedenlerinden ötürü çek eklemediklerini varsayalım. Arama foo(NULL);, tanımlanmamış davranışla sonuçlanacaktır (tipik olarak zorunlu olmamakla birlikte, uygulamaya bir SIGSEGV sinyali gönderilir). Bu tür sorunları önlemek için Cyclone @, asla olamayacak olan işaretçi tipini sunar NULL. Bu nedenle, "güvenli" sürümü fooşöyle olacaktır: 

 int foo(int @);

Bu, Cyclone derleyicisine , yukarıda belirtilen tanımlanmamış davranıştan kaçınarak argümanın fooasla olmaması gerektiğini söyler NULL. Basit bir değişiklik *için @yazmak zorunda programcı kaydeder NULLtuzak zorunda çek ve işletim sistemini NULLişaretçi dereferences. Bununla birlikte, bu ekstra sınır, işaretçilerini doğrudan aritmetik ile değiştirmeye alışkın olan çoğu C programcısı için oldukça büyük bir engel olabilir. Bu arzu edilen bir durum olsa da, arabellek taşmalarına ve diğer "tek tek" tarzı hatalara yol açabilir . Bunu önlemek için, ?işaretçi türü bilinen bir sınırla, dizinin boyutuyla sınırlandırılır. Bu, işaretçi hakkında depolanan ekstra bilgiler nedeniyle ek yük getirse de, güvenliği ve güvenliği artırır. Örneğin strlenC ile yazılmış basit (ve naif) bir işlevi ele alalım : 

 int strlen(const char *s)
 {
     int iter = 0;
     if (s == NULL)
        return 0;
     while (s[iter] != '\0') {
        iter++;
     }
     return iter;
 }

Bu işlev, iletilen dizgenin NULL ( '\0') tarafından sonlandırıldığını varsayar . Ancak, char buf[6] = {'h','e','l','l','o','!'};bu dizeye geçilseydi ne olur ? Bu, C'de tamamen yasaldır, ancak strlendizeyle ilişkilendirilmesi gerekmeyen bellek yoluyla yinelemeye neden olur s. Orada gibi işlevleri vardır strnlentür sorunları önlemek için kullanılabilecek, ancak bu işlevler her uygulamasıyla standart olmayan ANSI C . Cyclone sürümü strlenC sürümünden çok farklı değildir: 

 int strlen(const char ? s)
 {
    int iter, n = s.size;
    if (s == NULL)
       return 0;
    for (iter = 0; iter < n; iter++, s++) {
       if (*s == '\0')
          return iter;
    }
    return n;
 }

Burada, strlenkendisine aktarılan dizinin uzunluğu ile kendisini sınırlar, böylece gerçek uzunluğu aşmaz. İşaretçi türlerinin her biri, diğerlerinin her birine güvenli bir şekilde dönüştürülebilir ve diziler ve dizeler ?, derleyici tarafından otomatik olarak dönüştürülür . (Dökümler ?için *bir çağrıştırır sınır kontrol ve yayın yapmak ?için @çağırır hem NULLkontrol ve bir sınır kontrol dökümden. *İçin ?hiçbir kontroller ile sonuçlanır; elde edilen ?işaretçi 1 bir boyuta sahiptir)

Sarkan işaretçiler ve bölge analizi

Aşağıdaki kodu C olarak düşünün: 

 char *itoa(int i)
 {
    char buf[20];
    sprintf(buf,"%d",i);
    return buf;
 }

İşlev , yığın üzerinde itoabir karakter dizisi ayırır bufve başlangıcına bir işaretçi döndürür buf. Bununla birlikte, yığın üzerinde kullanılan bellek bufişlev geri döndüğünde serbest bırakılır, bu nedenle döndürülen değer işlevin dışında güvenli bir şekilde kullanılamaz. Gcc ve diğer derleyiciler bu tür bir kod hakkında uyarı verirken , aşağıdakiler genellikle uyarı olmadan derlenir: 

 char *itoa(int i)
 {
    char buf[20], *z;
    sprintf(buf,"%d",i);
    z = buf;
    return z;
 }

gcc , -O2 veya -O3 seçeneğinin yan etkisi olarak bu tür kodlar için uyarılar üretebilir, ancak bu tür hataların tümünün tespit edileceğine dair hiçbir garanti yoktur. Cyclone, kodun her segmentinin bölgesel analizini yaparak, bu sürümden döndürülen gibi işaretçilerin sarkmasını önler itoa. Belirli bir kapsamdaki tüm yerel değişkenler, aynı bölgenin parçası olarak, öbek veya diğer herhangi bir yerel bölgeden ayrı olarak kabul edilir. Böylece, analiz ederken itoa, Cyclone derleyicisi bunun zyerel yığına bir işaretçi olduğunu görür ve bir hata bildirir.

Ayrıca bakınız

Referanslar

Dış bağlantılar

Sunumlar: