Cyclone (programmeringsspråk)

Cyklon
Designad av AT&T Labs
Utvecklare Cornell University
Dök först upp 2002 ; 21 år sedan ( 2002 )
Stabil frisättning
1.0 / 8 maj 2006 ; för 16 år sedan ( 2006-05-08 )
Hemsida cyklon .thelanguage .org
Influerad av
C
Influenced
Rust , Project Verona

Programmeringsspråket Cyclone är tänkt att vara en säker dialekt av C - språket . Cyclone är utformad för att undvika buffertspill och andra sårbarheter som är möjliga i C-program, utan att förlora kraften och bekvämligheten med C som verktyg för systemprogrammering .

Cyklonutveckling startades som ett gemensamt projekt av AT&T Labs Research och Greg Morrisetts grupp på Cornell 2001. Version 1.0 släpptes den 8 maj 2006.

Språkfunktioner

Cyclone försöker undvika några av de vanliga fallgroparna med C , samtidigt som den behåller sitt utseende och prestanda. För detta ändamål sätter Cyclone följande begränsningar för program:

För att behålla verktygsuppsättningen som C-programmerare är vana vid, tillhandahåller Cyclone följande tillägg:

  • Never- NULL- pekare kräver inte NULL- kontroller
  • "Feta" pekare stödjer pekararitmetik med kontroll av körtidsgränser
  • Odlingsbara regioner stöder en form av säker manuell minneshantering
  • Sophämtning för högallokerade värden
  • Taggade fackföreningar stödjer typvarierande argument
  • Injektioner hjälper till att automatisera användningen av taggade fackföreningar för programmerare
  • Polymorfism ersätter vissa användningar av void *
  • varargs implementeras som fettpekare
  • Undantag ersätter vissa användningar av setjmp och longjmp

För en bättre introduktion på hög nivå till Cyclone, resonemanget bakom Cyclone och källan till dessa listor, se denna artikel .

Cyclone ser i allmänhet ungefär ut som C , men det bör ses som ett C-liknande språk.

Pekartyper

Cyclone implementerar tre typer av pekare :

Syftet med att introducera dessa nya pekartyper är att undvika vanliga problem vid användning av pekare. Ta till exempel en funktion, kallad foo som tar en pekare till en int: 

    int  foo  (  int  *  );

Även om personen som skrev funktionen foo kunde ha satt in NULL- kontroller, låt oss anta att de inte gjorde det av prestationsskäl. Anropar foo(NULL); kommer att resultera i odefinierat beteende (vanligtvis, men inte nödvändigtvis, skickas en SIGSEGV- signal till applikationen). För att undvika sådana problem introducerar Cyclone @ -pekartypen, som aldrig kan vara NULL . Således skulle den "säkra" versionen av foo vara: 

    int  foo  (  int  @  );

Detta talar om för Cyclone-kompilatorn att argumentet till foo aldrig bör vara NULL , vilket undviker det ovannämnda odefinierade beteendet. Den enkla ändringen av * till @ sparar programmeraren från att behöva skriva NULL- kontroller och operativsystemet från att behöva fånga NULL -pekarereferenser. Denna extra gräns kan dock vara en ganska stor stötesten för de flesta C-programmerare, som är vana vid att kunna manipulera sina pekare direkt med aritmetik. Även om detta är önskvärt, kan det leda till buffertspill och andra "off-by-one"-liknande misstag. För att undvika detta måste ? pekartyp avgränsas av en känd gräns, storleken på arrayen. Även om detta lägger till extra kostnader på grund av den extra information som lagras om pekaren, förbättrar det säkerheten och säkerheten. Ta till exempel en enkel (och naiv) strlen- funktion, skriven i C: 

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

Denna funktion förutsätter att strängen som skickas in avslutas med NULL ( '\0' ) . Men vad skulle hända om char buf [ 6 ] = { 'h' , 'e' , 'l' , 'l' , 'o' , '!' }; skickades till denna sträng? Detta är helt lagligt i C, men skulle få strlen att iterera genom minnet som inte nödvändigtvis är associerat med strängen s . Det finns funktioner som strnlen som kan användas för att undvika sådana problem, men dessa funktioner är inte standard med varje implementering av ANSI C . Cyclone-versionen av strlen är inte så olik C-versionen: 

     
 
        
       
        0
       0      
          
           
    
     
  int  strlen  (  const  char  ?  s  )  {  int  iter  ,  n  =  s  .  storlek  ;  if  (  s  ==  NULL  )  returnera  ;  för  (  iter  =  ;  iter  <  n  ;  iter  ++  ,  s  ++  )  {  if  (  *  s  ==  '\0'  )  returnera  iter  ;  }  returnera  n  ;  }

Här begränsar strlen sig till längden på den matris som skickas till den, och går alltså inte över den faktiska längden. Var och en av typerna av pekare kan säkert castas till var och en av de andra, och arrayer och strängar castas automatiskt till ? av kompilatorn. (Att kasta från ? till * anropar en gränskontroll , och casting från ? till @ anropar både en NULL- kontroll och en gränskontroll. Kasta från * till ? resulterar i inga som helst kontroller; den resulterande ? -pekaren har storleken 1.)

Dingelpekare och regionanalys

Tänk på följande kod, i C:

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

Funktion itoa allokerar en array av tecken buf på stacken och returnerar en pekare till början av buf . Men minnet som används på stacken för buf avallokeras när funktionen återvänder, så det returnerade värdet kan inte användas säkert utanför funktionen. Medan gcc och andra kompilatorer varnar för sådan kod, kommer följande vanligtvis att kompilera utan varningar: 

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

gcc kan producera varningar för sådan kod som en bieffekt av alternativ -O2 eller -O3 , men det finns inga garantier för att alla sådana fel kommer att upptäckas. Cyclone gör regional analys av varje kodsegment och förhindrar hängande pekare, som den som returnerades från den här versionen av itoa . Alla lokala variabler i en given omfattning anses vara en del av samma region, separat från högen eller någon annan lokal region. Sålunda, när man analyserar itoa , skulle Cyclone-kompilatorn se att z är en pekare till den lokala stacken, och skulle rapportera ett fel.

Se även

externa länkar

Presentationer:

Hämtad från " https://en.wikipedia.org/w/index.php?title=Cyclone_(programming_language)&oldid=1141800143 "