In quale lingua è scritto Swift?

Question

Bene, come dice il titolo, in che lingua è scritto Swift (Apple lingua, non l'altra cosa di Swift)? Più in particolare, in cosa consiste il compilatore scritto. È scritto in C (come ogni altra lingua) o in qualche altro magico, sconosciuto-til-ora Super Language? O è una strana versione ricorsiva, a baionetta, di Swift? Il web è stranamente silenzioso su questo tema.

Answer 1

Il codice sorgente ha just been made available on Github e sembra che Swift stesso sia scritto principalmente in C++ e la sua libreria standard sia scritta in Swift.

Per ulteriori informazioni, vedere this press release from Apple e il nuovo .

Answer 2

È costruito con il framework del compilatore LLVM incluso in Xcode 6 e utilizza il runtime Objective-C, consentendo l'esecuzione di codice C, Objective-C, C++ e Swift all'interno di un singolo programma.

da swift wikipedia

Answer 3

Swift è implementato in C. Si può vedere una panoramica delle analisi di una persona qui: https://github.com/rodionovd/SWRoute/wiki/Function-hooking-in-Swift

Con Swift andare open-source, immagino questa domanda sarà risposta in modo più completo in quel punto.

io includo una porzione al di sotto, ma assolutamente leggere l'intera analisi, se siete interessati:

func call_function(f :() -> Int) { 
    let b = f() 
} 

func someFunction() -> Int { 
    return 0 
} 

In Swift noi scrive appena CALL_FUNCTION (someFunction). Ma, invece di effettuare la chiamata come CALL_FUNCTION (& someFunction), compilatore Swift produce il codice:

struct swift_func_wrapper *wrapper = ... /* configure wrapper for someFunction() */ 
struct swift_func_type_metadata *type_metadata = ... /* information about function's arguments and return type */ 
call_function(wrapper->trampoline, type_metadata); 

Un involucro ha la seguente struttura:

struct swift_func_wrapper { 
    uint64_t **trampoline_ptr_ptr; // = &trampoline_ptr 
    uint64_t *trampoline_ptr; 
    struct swift_func_object *object; 
} 

E qual è il tipo swift_func_object? Per creare questo oggetto, runtime Swift utilizza un globale costante di nome metadati [N] (che è unico per ogni chiamata di funzione che toglie il func come argomento di un tipo generico, quindi per questo codice:

func callf(f:() ->()) { 
    f(); 
} 
callf(someFunction); 
callf(someFunction); 

due costanti verranno creati metadati e metadati2).

Un metadati struttura [N] s’è un pò questo:

struct metadata { 
    uint64_t *destructor_func; 
    uint64_t *unknown0; 
    const char type:1; // I'm not sure about this and padding, 
    char padding[7]; // maybe it's just a uint64_t too... 
    uint64_t *self; 
} 

Inizialmente metadataN ha solo due campi impostati: destructor_func e tipo. Il primo è un puntatore a una funzione che verrà utilizzata per deallocare tutta la memoria per un oggetto creato con swift_allocObject(). E il secondo è di tipo identificatore dell'oggetto (0x40 o '@' per funzioni/metodi), ed è (in qualche modo) utilizzato da swift_allocObject() per creare un oggetto giusto per il nostro func:

swift_allocObject(&metadata2->type, 0x20, 0x7); 

Una volta che l'oggetto func viene creato ha la seguente struttura:

struct swift_func_object { 
    uint64_t *original_type_ptr; 
    uint64_t *unknown0; 
    uint64_t function_address; 
    uint64_t *self; 
} 

il primo campo è un puntatore ad una corrispondente metadati [N] -> valore tipo, il secondo sembra essere 0x4 | 1 < 24 (0x100000004) e questo indica qualcosa forse (non so cosa). function_address è ciò che in realtà ci interessa per l'aggancio, e self è (improvvisamente) un puntatore al sé (se il nostro oggetto rappresenta una funzione semplice questo campo è NULL).

Answer 4

Swift è una lingua propria della mela. Sembra che sia implementato da c e C++ e possiede librerie swift