3.4.10 Scripting language

Lo scripting language è il linguaggio di programmazione interpretato dalla shell. Esso si compone di comandi interni (built-in), propri di Bash, file eseguibili ed operatori aritmetico-logici.

È possibile pertanto realizzare degli script, ovvero files di testo che contengono istruzioni comprensibili dalla shell e da questa interpretate ed eseguite. Tali istruzioni possono essere composte dai comandi interni della shell e dai comandi del sistema (nomi di file eseguibili) con la sintassi accettata dalla riga di comando. Scrivere uno script di shell è come scrivere una sequenza di comandi da poter far eseguire in blocco alla shell indicando semplicemente il nome del file che li contiene (lo script)¹².

Ad esempio, se si vuol fare eseguire in sequenza i comandi

 
$ echo Sto creando il file 'pippo'
$ ls > pippo  
si può creare un file prova (ad esempio con il comando vi prova) ed inserire al suo interno le righe seguenti

 
echo Sto creando il file 'pippo'
ls > pippo  
poi fare in modo che tale file sia eseguibile, con il comando

 
$ chmod u+x prova
 
A questo punto sarà sufficiente digitare il comando

 
$ ./prova  
per far eseguire i comandi in esso contenuti.

In realtà Bash mette a disposizione un potente scripting language, con la valutazione di espressioni condizionali, cicli, inclusioni di file, che permette di automatizzare in maniera piuttosto semplice qualunque operazione di sistema.

Il lancio in esecuzione di un comando può richiedere degli argomenti sulla riga di comando. Questi vengono passati come parametri al processo che viene posto in esecuzione dalla shell che si preoccupa di “tokenizzarli” (separarli l’uno dall’altro, riconoscendo come simbolo separatore il carattere spazio ‘ ’).

Allo stesso modo, anche gli script Bash possono ricevere degli argomenti dalla riga di comando. Gli argomenti passati agli script sono memorizzati nei parametri $0, $1, $2, ... dello script stesso.

Come trattato nel cap. 7, quando un processo termina, esso ritorna un valore di uscita, detto exit status, cioè un valore numerico di un byte. L’exit status dell’ultimo processo eseguito viene memorizzato nel parametro $?.

Quando viene impartito un comando, rappresentato da un file eseguibile, la shell crea un nuovo processo per la sua esecuzione secondo quanto di seguito riportato:

• • Se si tratta di un file eseguibile in formato binario (ELF) la shell crea un processo figlio che esegue i comandi contenuti nel file (che è comprensibile dalla CPU);
• • Se si tratta di un file non binario, la shell lo considera uno script, ovvero un file contenente una sequenza di comandi che un interprete può eseguire. Quindi analizza i primi caratteri del file e se li trova uguali a “#!” legge i caratteri successivi fino al primo carattere di fine riga (LF) ed interpreta tale stringa come il file eseguibile in formato binario da lanciare per interpretare i comandi contenuti nello script. Quindi crea un processo figlio che esegue l’interprete indicato, al quale passa in input il file specificato dall’utente (lo script). Infatti, generalmente la prima riga di uno script Bash è la seguente:

   
  #!/bin/bash  
  in modo tale che, se tale file viene specificato come comando (ed il file ha il permesso di esecuzione per l’utente considerato), la shell lanci in esecuzione il file /bin/bash, ovvero l’interprete Bash, al quale fare interpretare il file stesso.

  Si supponga infatti di avere il file di testo ~/pippo con il seguente contenuto:

   
  #!/bin/bash
  echo Ciao a tutti !  
  e di avere almeno i diritti di lettura e di esecuzione su quel file. Lanciando il comando

   
  $ ~/pippo  
  la shell si accorge che il file pippo presente nella home directory dell’utente corrente ‘~’ è non è un file binario, quindi lo tratterà come se fosse uno script, estraendo dalla prima riga il nome dell’interprete da lanciare per eseguire tale script, ovvero /bin/bash, che provvederà a lanciare in esecuzione come processo figlio, passandogli come input lo script.

  Va notato il fatto che le linee che iniziano con il carattere ‘#’ sono considerate dei commenti dallo scripting language di Bash, pertanto tale riga viene ignorata dall’interprete stesso quando esegue il file (in genere la maggior parte degli interpreti utilizza il carattere ‘#’ come inizio di una riga di commento).

  Se il file ~/pippo avesse contenuto le istruzioni seguenti

                                                                          
                                                                          
    #!/usr/bin/perl
    print "Ciao a tutti !"
    

  la shell avrebbe lanciato in esecuzione il file /usr/bin/perl, ovvero l’interprete Perl, passandogli come input lo script (in questo caso si tratta di uno script Perl).
• • Se il file non contiene nessuna intestazione particolare, Bash tenta di eseguirlo interpretando le istruzioni in esso contenute (come se fosse uno script Bash).

La sintassi del linguaggio di scripting di Bash è piuttosto articolata, e di seguito saranno riportate alcune caratteristiche essenziali per la comprensione e realizzazione di semplici script. Per una descrizione più dettagliata della programmazione con Bash v.  [0].

I comandi vengono scritti in sequenza su righe diverse. Alcuni caratteri assumono un significato particolare, di seguito illustrato:

• # commento. Tutto il contenuto della riga che segue questo carattere è ignorato. Ad esempio considerando la riga

   
  echo salve # mondo  
  # mondo è considerato un commento;

• ; separatore di comandi. In questo modo possono essere espressi più comandi sulla stessa riga. Ad esempio la riga

   
  echo salve; echo mondo  
  viene considerata come

   
  echo salve
  echo mondo  
  

• ;; terminatore di rami case. Ogni ramo relativo ad un costrutto case deve essere terminato con questa sequenza di caratteri. Esempio

   
  case "$variable" in
  abc) echo "$variable = abc" ;;
  xyz) echo "$variable = xyz" ;;
  esac
   
  

• . Assume vari significati:
  • • v. il comando interno source;
  • • l’occorrenza di un singolo carattere (v. espressioni regolari);
  • • parte del nome di un file o di un path;
• " partial quoting - il testo contenuto tra ‘"’ viene considerato così com’è (a parte qualche carattere particolare che viene comunque interpretato);
• ' full quoting - il testo contenuto tra ‘"’ viene considerato così com’è.
• , separatore di espressioni aritmetiche. più espressioni possono essere specificate sulla stessa riga ed il valore di ritorno è quello dell’ultima espressione. Ad esempio

   
  let "b = ((a = 1, 21 / 7))"  
  imposta a col valore 1 e b col valore 3 (= 21/7);

• \ carattere di escape. Questo carattere viene utilizzato per indicare all’interprete di considerare il carattere che segue così com’è, senza considerare il particolare significato ad esso attribuito. Ad esempio

   
  echo salve \# mondo  
  in questo caso il carattere # viene considerato come tale, non assume il significato di inizio di un commento.

• / assume vari significati:
  • • operazione di divisione;
  • • parte del nome di un path;
• ` command substitution - il testo contenuto tra ‘`’ (backtick) viene eseguito come un comando ed il risultato è reso disponibile per poterlo assegnare ad una variabile;
• : null command - è l’equivalente dell’operazione assembly NOP (no operation), ovvero un’istruzione che non fa niente ed il suo valore di ritorno è true (0);
• ! assume vari significati:
  • • fornisce il complementare booleano del valore di ritorno o di una condizione;
  • • fa riferimento indiretto alle variabili;
• * assume vari significati:
  • • moltiplicazione aritmetica;
  • • wildcard nei nomi di file (v. anche le espressioni regolari);
• ** elevamento a potenza;
• ? assume vari significati:
  • • analogo all’operatore ternario del linguaggio C (?:);
  • • esegue un test sull’impostazione di una variabile;
  • • wildcard nei nomi di file (v. anche le espressioni regolari);
• $ assume vari significati:
  • $var variable substitution - indica il valore contenuto nella variabile var;
  • $ end-of-line - nelle espressioni regolari indica la fine di una riga;
  • ${} parameter substitution;
  • $num, $@ positional parameters - parametri di ingresso, specificati sulla riga di comando: $1 è il primo parametro, $2 è il secondo, ... e $@ è l’elenco di tutti i parametri passati allo script sulla riga di comando;
  • $? exit status - valore di ritorno dell’ultimo comando eseguito;
  • $$ PID del processo che esegue le istruzioni contenute nello script;
• (...) assume vari significati:
  • • command group - i comandi racchiusi tra parentesi vengono eseguiti in una subshell (un processo figlio), quindi le variabili utilizzate all’interno non saranno visibili dal resto dello script;
  • • array initialization - tra parentesi vengono specificati i valori da assegnare ai vari elementi del vettore. Ad esempio

     
    MyArray=(value1 value2 value3)  
    

• {...} assume vari significati:
  • • brace espansion - indica un insieme di valori specificato dall’elenco separato dal carattere ‘,’ contenuto tra parentesi graffe. Ad esempio

     
    grep Linux myfile*.{txt,htm*}  
    trova tutte le istanze della parola “Linux” nei file che iniziano per myfile ed hanno estensione txt o che inizia per htm;

  • • raggruppamento di un blocco di comandi. Più comandi possono essere raggruppati tra { e } per poter redirigere tutto il loro input/output da o verso un file (il blocco di comandi non viene eseguito in una subshell).
• [...] assume vari significati:
  • • elemento di un vettore. Ad esempio

     
    echo ${MyArray[1]};  
    visualizza il valore contento nel secondo elemento (1) del vettore MyArray;

  • • v. comando interno test (tra [ e ] viene specificata la condizione da testare). Ad esempio

     
    [ -n "$var" ]  
    ritorna vero (0) se la variabile var non è stata inizializzata;

  • • specifica un intervallo di valori (v. espressioni regolari);
• [[...]] esegue un test con una sintassi della condizione più simile a quella utilizzata dagli altri linguaggi di programmazione (possono essere utilizzati i simboli &&, ||, < e > che non possono essere utilizzati con [...]). Ad esempio

   
  [[$var1 > $var2 ]] 
  ritorna vero se il contenuto della variabile var1 è maggiore di quello della variabile var2.

• > assume vari significati:
  • • redirezione dell’output. Ad esempio

     
    echo "ciao" >~/myfile  
    redirige l’output del comando echo "ciao" nel file ~/myfile, sovrascrivendolo se il file esiste già. Il comando

     
    echo "ciao" >&2  
    redirige l’output del comando echo "ciao" nel file descriptor 2, ovvero l’error associato al processo.

  • • simbolo di confronto: maggiore;
• &> redirezione dell’output e dell’error. Ad esempio

   
  echo "ciao" &>~/myfile  
  redirige l’output e l’error del comando echo "ciao" nel file ~/myfile, sovrascrivendolo se il file esiste già.

• >> redirezione dell’output. Ad esempio

   
  echo "ciao" >>~/myfile  
  redirige l’output del comando echo "ciao" nel file ~/myfile, aggiungendolo a quanto già contenuto nel file. Se il file non esiste viene creato.

• < assume vari significati:
  • • redirezione dell’input. Ad esempio

     
    tail <~/myfile  
    redirige l’input del comando tail sul file ~/myfile. In questo modo tail gestisce il contenuto del file ~/myfile come se fosse digitato dalla tastiera (standard input);

  • • simbolo di confronto: minore;
• \< inizio di una parola (v. espressioni regolari);
• \> fine di una parola (v. espressioni regolari);
• | redirezione dell’output del comando che precede nell’input del comando che segue ???;
• >| forza la redirezione ???;
• || operazione di OR logico;
• & lancia un comando in background;
• && operazione di AND logico;
• - assume vari significati:
  • • redirezione dell’input (quando il comando si aspetta il nome di un file da cui prelevare i dati di ingresso) sullo standard input o dell’output (quando il comando si aspetta il nome di un file in cui scrivere i dati di uscita) sullo standard output. Ad esempio

     
    $ file
    Usage: file [-bciknvzL] [-f namefile] [-m magicfiles] file...  
    mentre

     
    $ file -
    abc
    standard input:             ASCII text  
    

  • • simbolo di sottrazione matematica;
  • • previous working directory;
• = operatore di assegnamento;
• + assume vari significati:
  • • operatore di addizione;
  • • v. espressioni regolari;
• % assume vari significati:
  • • operatore di modulo;
  • • operatore di confronto tra stringhe;
• ~ home directory;
• ~+ current working directory;
• ~- previous working directory;
• ^ beginning-of-line (v. espressioni regolari);