Implementazione del supporto di array di lunghezza non fissa in un compilatore

Probabilmente lo renderà molto più facile su te stesso ed eviterai molti errori utente se permetti che la dichiarazione di array di lunghezza variabile sia ritardata fino a un punto in cui la dimensione è nota. Quindi non devi inventare una sintassi per assegnare la dimensione dell'array e non devi affrontare le differenze nell'ordine in cui gli array sono dichiarati e in cui ottengono le loro dimensioni.

Se il compilatore utilizza uno schema di allocazione basato su stack per le variabili locali (vengono assegnati indirizzi relativi allo stack-frame della loro funzione, come avviene per le piattaforme "grandi"), gli array a lunghezza variabile possono solo essere scolpito fuori dal telaio della pila, se necessario. Solo se ci sono più array di lunghezza variabile in una funzione hai bisogno di un puntatore aggiuntivo per indicare dove iniziano i dati di ciascuno.

Se il compilatore utilizza uno schema di allocazione fisso (tutte le variabili, inclusi i locali, ricevono un indirizzo fisso (assoluto) dal compilatore / linker), userei un 'array stack' per intagliare gli array a lunghezza variabile da. Come overhead, avresti bisogno di un puntatore globale per indicare dove inizia lo spazio libero correntemente, un puntatore per ogni array a lunghezza variabile per indicare dove si trovano i suoi dati e, in ogni funzione che utilizza array a lunghezza variabile, un modo per ripristinare il globale puntatore al valore che aveva quando si immette la funzione.
L'utente avrebbe anche bisogno di un modo per indicare al compilatore / linker quanta parte di un "array stack" che pensa sarà necessario. Un valore ragionevole potrebbe essere quello di utilizzare tutto ciò che è rimasto dopo aver assegnato tutte le variabili a dimensione fissa e l'overhead di array a lunghezza variabile.

Penso che questo schema usi il minor ammontare di spese generali, sia nello spazio che nel tempo. Lo schema che hai ideato è essenzialmente un'implementazione malloc .

Le matrici di lunghezza variabile in C99 sono ancora a dimensione fissa; semplicemente non conosci la dimensione fino al runtime. Non sono dinamici, quindi non puoi dichiarare int foo[] e iniziare ad accedere agli elementi. Non c'è modo di sapere quanto spazio dedicare ad esso e non c'è magia dietro le quinte che riorganizza tutto man mano che l'array cresce.

Nelle versioni precedenti di C, il compilatore eseguiva una singola mossa del puntatore dello stack all'inizio dello scope perché tutte le variabili erano dichiarate in primo piano:

{
  int foo;
  int bar;
  // Stack pointer gets nudged 2 * sizeof(int)
  ... Code ...
}

Ciò che rende possibile l'VLA era una modifica in C99 che consentiva la dichiarazione di variabili ovunque nel codice anziché solo nella parte superiore dello scope:

{
  int foo;  // Stack pointer gets nudged sizeof(int)
   ... Code ...
  int bar;  // Stack pointer gets nudged another sizeof(int)
}

Essere in grado di fare questo significa che per creare un VLA, tutto ciò che deve essere fatto è valutare l'espressione tra parentesi (che può usare variabili dichiarate in precedenza perché il compilatore sa dove trovarle), moltiplicare il risultato per la dimensione del tipo di array e spinge il puntatore dello stack di più di tanto:

{
  size_t size;  // Stack pointer gets nudged sizeof(size_t)
  size = get_number_of_ints_in_input();
   ... Code ...
  int data[size];  // Stack pointer gets nudged size * sizeof(int)
   ... Code ...
}

Se si tiene traccia di quanto è stato spostato il puntatore dello stack, è possibile tornare indietro dove dovrebbe essere ogni volta che si esce dal campo di applicazione.