Guida al Setup dell'Ambiente

Per iniziare a scrivere, compilare e debbuggare programmi in C, sono necessari tre componenti fondamentali:

1. Un compilatore: traduce il codice sorgente C in linguaggio macchina eseguibile (gcc o alternativamente clang).
2. Un debugger: consente di analizzare l’esecuzione del programma passo-passo ed ispezionare la memoria RAM. Utilizzeremo lldb, lo standard moderno universale e pienamente supportato anche su architetture Apple Silicon.
3. Un editor di codice: per scrivere ed organizzare i sorgenti. Utilizzeremo lo stesso ambiente su tutte le piattaforme: Visual Studio Code (VS Code) con un profilo pre-configurato.

Su tutte le piattaforme utilizzeremo ambienti e toolchain equivalenti:

• Su Windows: useremo gcc / clang ed lldb all’interno del sottosistema Linux WSL (Windows Subsystem for Linux).
• Su macOS: useremo clang ed lldb, inclusi nei Command Line Tools di Apple (pienamente compatibili con la sintassi gcc).
• Su Linux: useremo gcc / clang ed lldb, gli strumenti nativi della distribuzione.

---

1. Installazione della Toolchain (Compilatore e Debugger)

L’installazione varia in base al sistema operativo. Segui la sezione specifica per il tuo computer.

💻 Piattaforma Windows (via WSL)

Per avere un ambiente di sviluppo POSIX/Linux allineato ai laboratori didattici, su Windows utilizzeremo WSL (Windows Subsystem for Linux) con distribuzione Ubuntu.

Passo 1: Installare WSL

1. Cerca PowerShell o Prompt dei comandi nel menu Start di Windows, fai click destro e seleziona Esegui come amministratore.
2. Digita il seguente comando e premi Invio:

   wsl --install -d Ubuntu

3. Al termine dell’installazione, riavvia il computer.
4. Dopo il riavvio, si aprirà automaticamente la finestra di terminale Ubuntu. Attendi l’inizializzazione e crea il tuo username e password per il sistema Linux.

Passo 2: Installare Compilatori e Debugger in WSL

Nel terminale di Ubuntu, esegui il seguente comando per aggiornare il gestore dei pacchetti ed installare gcc, clang ed lldb:

sudo apt update
sudo apt install build-essential clang lldb -y

Passo 3: Verificare l’installazione

Verifica la presenza degli strumenti digitando:

gcc --version
clang --version
lldb --version

---

🍎 Piattaforma macOS

Su macOS utilizzeremo i compilatori e debugger nativi Apple Clang ed LLDB forniti tramite i Command Line Tools.

Passo 1: Avviare l’installazione dei Command Line Tools

Apri il Terminale (cercandolo tramite Spotlight con Cmd + Spazio) e digita:

xcode-select --install

Clicca su Installa nella finestra che appare ed accetta i termini di licenza.

Passo 2: Verificare l’installazione

Attendi il completamento del download. Al termine, verifica la versione installata digitando nel Terminale:

clang --version
lldb --version

Nota su Apple Silicon (M1/M2/M3/M4)

Su Mac con processori Apple Silicon, il classico debugger gdb non è più supportato ed instabile. Utilizzeremo esclusivamente lldb, che offre prestazioni native straordinarie ed un’integrazione perfetta con VS Code.

---

🐧 Piattaforma Linux (Ubuntu/Debian)

La maggior parte delle distribuzioni Linux consente l’installazione rapida della toolchain completa tramite il gestore di pacchetti.

Passo 1: Installare i pacchetti

Apri il terminale e digita:

sudo apt update
sudo apt install build-essential clang lldb -y

Passo 2: Verificare l’installazione

Verifica la versione dei tools con:

clang --version
lldb --version

---

2. Installazione e Configurazione di Visual Studio Code

Passo 1: Download di VS Code

Scarica ed installa l’editor dal sito ufficiale: code.visualstudio.com.

Passo 2: Importazione del Profilo del Corso (Prog1-OZ)

Profilo Obbligatorio per Esercitazioni ed Esami

Abbiamo preparato un profilo pre-configurato pronto per essere importato. Questo profilo isola l’ambiente del corso, disabilita l’autocompletamento invasivo (per abituarti a scrivere la sintassi) e installa automaticamente l’estensione per il debugger (CodeLLDB).

1. Scarica il file del profilo da questo link: Prog1-OZ.code-profile.
2. Apri VS Code.
3. Fai clic sull’icona dell’ingranaggio in basso a sinistra (Impostazioni) e seleziona Profiles -> Import Profile….
4. Seleziona il file Prog1-OZ.code-profile appena scaricato e clicca su Create Profile.
5. Riconoscerai il profilo attivo dall’icona del libro (Book) in basso a sinistra.

Integrazione WSL su Windows

Una volta importato il profilo su Windows, apri le estensioni (Ctrl+Shift+X), cerca ed installa l’estensione WSL (by Microsoft). Clicca sul pulsante verde in basso a sinistra e seleziona Connect to WSL per collegare VS Code al compilatore Linux.

3. Test di Compilazione ed Esecuzione da Terminale

Per comprendere il funzionamento reale dei compilatori, non utilizzeremo pulsanti magici o estensioni automatiche. Compileremo direttamente dal terminale integrato.

Passo 1: Scrivere il codice sorgente

Crea un file chiamato hello.c ed inserisci il seguente codice:

#include <stdio.h>

int main(void) {
    printf("Benvenuti a Programmazione 1!\n");
    return 0;
}

Passo 2: Compilare con GCC o Clang

Prendere buone abitudini: Il flag -Wall

Quando compilate, aggiungete sempre il flag -Wall (Warnings: All). Questo comanda a GCC/Clang di segnalare ogni potenziale anomalia o bug non bloccante presente nel vostro codice:

gcc -Wall hello.c -o hello

In alternativa, potete usare Clang:

clang -Wall hello.c -o hello

L’opzione -o hello indica al compilatore di generare un file eseguibile chiamato hello.

Passo 3: Eseguire il programma

Nel terminale, avvia il programma eseguibile digitando:

./hello

A schermo apparirà il messaggio di benvenuto corretto!

---

4. Primi Passi con il Debugger lldb

Quando il tuo programma presenta bachi o crash di memoria (come i famosi Segmentation Fault), il debugger lldb ti permette di fermare il tempo ed ispezionare le variabili.

Compilazione per il Debugging (Flag -g)

Per consentire a lldb di leggere i nomi delle variabili e le righe di codice, occorre compilare aggiungendo il flag -g (mantenendo sempre attivo anche -Wall):

clang -g -Wall hello.c -o hello

Comandi Fondamentali di lldb

Avvia il debugger passando l’eseguibile:

lldb ./hello

All’interno della shell di lldb (indicata dal prompt (lldb)), puoi usare i seguenti comandi essenziali:

Comando	Scorciatoia	Descrizione
breakpoint set --name main	b main	Imposta un punto di interruzione all’inizio della funzione main.
breakpoint set --line 6	b 6	Imposta un punto di interruzione alla riga 6 del sorgente.
run	r	Avvia l’esecuzione del programma fino al primo breakpoint.
next	n	Esegue la riga di codice corrente e passa alla successiva (step over).
step	s	Entra all’interno della funzione chiamata nella riga corrente (step in).
frame variable	v	Stampa il valore di tutte le variabili locali nella funzione corrente.
print mia_var	p mia_var	Stampa il valore specifico della variabile mia_var.
continue	c	Riprende l’esecuzione normale fino al prossimo breakpoint o alla fine.
quit	q	Esci dal debugger lldb.

---

5. Integrazione del Debugger in VS Code (Estensione CodeLLDB)

Sebbene sia possibile fare tutto da riga di comando (consigliato per capire i meccanismi), Visual Studio Code permette di utilizzare un’interfaccia grafica per il debug. Per farlo in modo affidabile (specialmente su macOS e WSL), utilizzeremo l’estensione CodeLLDB.

Passo 1: Verificare CodeLLDB in VS Code

Se hai importato il profilo Prog1-OZ, CodeLLDB è già installato. Per verificarlo, o per installarlo a mano:

1. Vai nella barra delle estensioni a sinistra (Ctrl+Shift+X o Cmd+Shift+X).
2. Cerca CodeLLDB (pubblicata da Vadim Chugunov) e, se non è già presente, clicca su Install.
3. Se sei su Windows all’interno di WSL, assicurati di installare l’estensione all’interno della sessione di WSL (dovrebbe comparire il pulsante Install in WSL).

Passo 2: Configurazione Progetto per Progetto

Il debug e la compilazione grafica in VS Code vanno configurati progetto per progetto (ossia per ciascuna cartella aperta). Questo è normale e necessario, poiché progetti diversi potrebbero richiedere comandi di compilazione o parametri di debugging specifici.

La configurazione consiste nel creare una cartella speciale chiamata .vscode all’interno della cartella del progetto corrente, contenente due file JSON:

1. tasks.json: definisce come compilare il programma prima di avviarlo.
2. launch.json: definisce come avviare il debugger collegandolo all’eseguibile compilato.

File .vscode/tasks.json

Crea questo file e incolla il seguente contenuto:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Prog1 O-Z Simple Build",
      "type": "shell",
      "command": "/usr/bin/clang",
      "args": [
        "-g",
        "${file}",
        "-o",
        "${fileDirname}/${fileBasenameNoExtension}"
      ],
      "group": "build",
      "problemMatcher": ["$gcc"]
    }
  ]
}

File .vscode/launch.json

Crea questo file e incolla il seguente contenuto:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Prog1 O-Z Debugging Profile",
      "type": "lldb",
      "request": "launch",
      "program": "${fileDirname}/${fileBasenameNoExtension}",
      "args": [],
      "cwd": "${fileDirname}",
      "preLaunchTask": "Prog1 O-Z Simple Build"
    }
  ]
}

Nota: Non è fondamentale studiare a memoria i parametri di questi file JSON; il loro scopo è semplicemente compilare il file C attualmente aperto (con l’opzione -g attiva) e avviare la sessione di debug grafico.

Pre-configurati nei Laboratori

Nelle attività pratiche e negli assignment scaricabili troverai già la cartella .vscode con questi file pre-configurati per facilitarti lo studio. L’uso del debug grafico tramite estensione non è obbligatorio: puoi sempre compilare ed eseguire il debug manuale da terminale con lldb come visto nella sezione precedente.

Passo 3: Come usare il Debug Grafico

1. Assicurati di aver aperto la cartella principale del progetto (es. lab1-demo) in VS Code.
2. Apri il file .c su cui stai lavorando (es. hello.c o orbite.c).
3. Posiziona il cursore a sinistra del numero di riga in cui vuoi interrompere l’esecuzione e fai clic per impostare un cerchio rosso (Breakpoint).
4. Premi F5 sulla tastiera o vai nel menu a sinistra (icona Run and Debug) e fai clic sul pulsante verde Play vicino a Prog1 O-Z Debugging Profile.
5. VS Code compilerà automaticamente il file C e aprirà una barra dei controlli in alto per permetterti di avanzare passo-passo (Step Over F10, Step In F11, Continue F5), mentre a sinistra potrai visualizzare il valore delle variabili locali in tempo reale.