<!doctype linuxdoc system>

<article>

<title>Bash Prompt HOWTO
<author> Giles Orr, 
<htmlurl url="mailto:giles@interlog.com" name="giles@interlog.com">
<date>v0.60, 07 gennaio 1999

<!-- NOTE DEL TRADUTTORE

Tradotto nel giugno 1999 da Daniel Dui <ddui@iee.org>

-->

<!-- CHANGELOG:

$Log: bashprompt.sgml,v $
Revision 0.60  1999/01/07 02:10:28  giles
Very minor cosmetic changes.
Forced revision 0.60.

Revision 0.57  1999/01/07 01:37:35  giles
Changed to code environment where appropriate.
Minor cosmetic changes.

Revision 0.56  1999/01/07 01:05:50  giles
Added "Copyright and Disclaimer," added Johan's note.
Some other minor changes.

-> RCS is unhappy with me because I moved the HOWTO between the laptop
   and the desktop: slight shift in the numbering scheme.
	
Revision 0.58  1998/12/25 04:35:31  giles
Corrected minor readability issues.
Look out for tabs in pasted scripts: this continues to be a problem.

Revision 0.57  1998/12/25 04:13:57  giles
Replaced esc0, esc1, esc2, and esc3 with one escgen script.
Added colour echoing script.

Revision 0.56  1998/12/23 05:25:13  giles
Added some minor revisions.
Added Torben's "jobcount" in the prompt suggestion.
Added section on ANSI cursor movement.

Revision 0.55  1998/12/01 12:22:48  giles
Clean-up in preparation for public release.

-->

<abstract>
Viene discusso come creare e controllare il prompt del terminale e
di xterm, compresa l'uso delle sequenze di escape standard per
ottenere il nome utente, la directory di lavoro corrente, l'ora,
ecc. Vengono esposti ulteriori suggerimenti su come modificare le
barre di titolo di xterm, usare funzioni esterne per fornire
informazioni sul prompt e su come usare i colori ANSI.
</abstract>

<toc>

<sect>Introduzione

<sect1>Prerequisiti

<p>
Avrete bisogno di Bash.  La versione fornita con quasi tutte le
distribuzioni Linux &egrave; la 1.14.7 (al momento della stesura di
questo documento, Novembre 98), che &egrave; una shell ben conosciuta e
affidabile.  Bash &egrave; ora disponibile nella versione 2.0+: oramai
ho utilizzato Bash 2.0 per qualche tempo, ma quasi tutto il codice
qui presentato dovrebbe funzionare con la 1.14.7. Se dovessi
essere a conoscenza di un problema, ne far&ograve; menzione. Potete
controllare la vostra versione di Bash digitando <TT>echo
$BASH_VERSION</TT> al prompt. Sulla mia macchina, risponde con
<TT>2.02.1(1)-release</TT>.

<p>
Sarebbe utile, ma non essenziale, esperienza nella programmazione
shell: pi&ugrave; ne sapete, pi&ugrave; sarete in grado di creare prompt
complessi. In questo tutorial presuppongo una conoscenza di base della
programmazione shell e delle utility Unix. Comunque, le mie stesse
capacit&agrave; nella programmazione shell sono limitate, cos&igrave;
fornisco molti esempi e spiegazioni che possono apparire superflue ad
un esperto programmatore shell.


<sect1>Come Usare Questo Documento

<p>
Includo molti esempi e spiegazioni. Parti diverse saranno utili in
varia misura a persone diverse. Questo documento &egrave; diventato
abbastanza lungo e leggerlo tutto in una volta sarebbe difficile -
leggete solamente le sezioni che vi servono, tornate indietro quando
necessario.

<sect1>Traduzioni

<p>
Al momento in cui scrivo (6 gennaio 99), sono in lavorazione
traduzioni in giapponese (Akira Endo, <htmlurl
url="mailto:akendo@t3.rim.or.jp" name="akendo@t3.rim.or.jp">) e
tedesco (Thomas Keil, <htmlurl url="mailto:thomas@h-preissler.de"
name="thomas@h-preissler.de">). Molte grazie ad entrambi!  Gli URL
verranno inclusi quando le traduzioni saranno disponibili.

<sect1>Problemi

<p>
Questa &egrave; una lista di problemi che ho notato nel programmare i
prompt. Non iniziate a leggere qui, e non lasciate che
questa lista vi scoraggi - questi sono principalmente dettagli
minori. Controllate qui se vi scontrate con qualche cosa di
strano.

<itemize>
<item>Molte funzionalit&agrave; di Bash (come i calcoli matematici
all'interno di $(()) fra gli altri) sono opzioni definite in fase di
compilazione. Se state usando una distribuzione binaria come quelle
fornite con una distribuzione standard di Linux, tutte queste
funzionalit&agrave; dovrebbero essere gi&agrave; definite in fase di
compilazione. Ma se state lavorando sul sistema altrui, vale la pena
ricordarsene se qualcosa non funziona come vi aspettate. Vi sono
alcune note su questo in <em>Learning the Bash Shell</em>, p.260-262.
<item>Lo screen manager "screen" non funziona sempre bene con i colori
ANSI. Sfortunatamente non sono un esperto di screen. La mia attuale
versione di screen (una molto recente) sembra funzionare bene in tutti
i casi, ma ho visto occasioni in cui screen ha ridotto tutti i colori
del prompt al colore di primo piano standard negli X terminal. Questo
non sembra essere un problema nella consolle.  <item>I file Xdefault
possono reimpostare i colori. Cercate in &tilde;/.Xdefaults linee che fanno
riferimento a XTerm*background e XTerm*foreground (o forse
XTerm*Background e XTerm*Foreground).  <item>Uno dei prompt menzionati
in questo documento usa l'output di "jobs" - come già discusso,
l'output di "jobs" verso un pipe non funziona in Bash 2.02.  <item>Le
sequenze di escape ANSI per il movimento del cursore non sono tutte
implementate in tutti gli X terminal. Questo &egrave; discusso in una
sezione a parte.  <item>Alcune pseudo-immagini carine possono essere
create usando i font VGA piuttosto che i font standard di
Linux. Sfortunatamente, questi effetti sono pessimi se non usate font
VGA, e non c'&egrave; modo di scoprire all'interno di un
terminale quali font sta usando.  <item>Bash 2.0+ &egrave; disponibile
e include alcune nuove funzionalit&agrave; e cambia un po' il
comportamento. Cose che funzionano sulla 1.14.7 non funzionano
necessariamente sulla 2.0+, o vice versa.
</itemize>

<sect1>Inviatemi Commenti e Suggerimenti

<p>
Questa &egrave; anche per me una "esperienza didattica". Sono arrivato
a saperne un bel po' su cosa pu&ograve; essere fatto per creare prompt
Bash interessanti e utili, ma ho bisogno dei vostri suggerimenti per
correggere e migliorare questo documento. Ho provato a controllare i
miei suggerimenti con versioni differenti di Bash (principalmente
2.02, che uso, e 1.14.7, che &egrave; molto usata), ma fatemi sapere
se trovate delle incompatibilit&agrave;.

<p>
L'ultima versione di questo documento dovrebbe essere sempre
disponibile su <htmlurl
url="http://www.interlog.com/~giles/bashprompt.html"
name="http://www.interlog.com/~giles/bashprompt.html">.  Per favore
dategli un'occhiata e lasciate pure un e-mail a
<htmlurl url="mailto:giles@interlog.com" name="giles@interlog.com">
con suggerimenti.

<p>
Uso gli HOWTO del Linux Documentation Project quasi esclusivamente in
formato HTML, cos&igrave; quando converto questo documento da SGML,
HTML &egrave; l'unico formato che controllo interamente. Se ci sono problemi
con altri formati, potrei non saperlo e gradirei una nota a riguardo.

<sect1>Crediti

<p>
Nel produrre questo documento, ho preso in prestito molto dal lavoro
del progetto Bashprompt su <htmlurl url="http://bash.current.nu/"
name="http://bash.current.nu/">.  Altre fonti usate includono
l'<em>xterm Title mini-HOWTO</em> di Ric Lister, reperibile su
<htmlurl url="http://sunsite.unc.edu/LDP/HOWTO/mini/Xterm-Title.html"
name="http://sunsite.unc.edu/LDP/HOWTO/mini/Xterm-Title.html">,
<em>Ansi Prompts</em> di Keebler, reperibile su <htmlurl
url="http://www.ncal.verio.com/~keebler/ansi.html"
name="http://www.ncal.verio.com/~keebler/ansi.html">, <em>How to make
a Bash Prompt Theme</em> di Stephen Webb, reperibile su <htmlurl
url="http://bash.current.nu/bash/HOWTO.html"
name="http://bash.current.nu/bash/HOWTO.html"> e <em>X ANSI Fonts</em>
di Stumpy, reperibile su <htmlurl
url="http://home.earthlink.net/~us5zahns/enl/ansifont.html"
name="http://home.earthlink.net/~us5zahns/enl/ansifont.html">.

<p>
Sono state anche di immenso aiuto diverse conversazioni e e-mail di
Dan, un collega del Georgia College & State University, le cui
conoscenze di UNIX superano di molto le mie. Egli mi ha dato numerosi
ed eccellenti suggerimenti, le sue idee hanno portato ad alcuni prompt
interessanti.


<p>
Tre libri che sono stati utili nel prorammare i prompt sono <em>Linux
in a Nutshell</em> di Jessica Heckman Perry (O'Reilly, 1997),
<em>Learning the Bash Shell</em> di Cameron Newham e Bill Rosenblatt
(O'Reilly, 2nd. ed., 1998) e <em>Unix Shell Programming</em> di Lowell
Jay Arthur (Wiley, 1986.  Questa &egrave; la prima edizione, la quarta
&egrave; uscita nel 1997).

<sect1>Copyright e Liberatoria
<p>
This document is copyright 1998-1999 by Giles Orr. You are encouraged
to redistribute it. You may not modify this document (see the section
on contacting me: I have so far been incorporating all changes
recommended by readers). Please contact me if you're interested in
doing a translation: that's one modification I can live with.  

This document is available for free, and, while I have done the best I
can to make it accurate and up to date, I take no responsibility for
any problems you may encounter resulting from the use of this
document.  

Ovvero:

Questo documento &egrave; sotto il copyright di 1998-1999 by Giles
Orr. Siete incoraggiati a ridistribuirlo. Non potete modificare questo
documento (vedete la sezione su come contattarmi: fino ad ora ho
incluso tutti cambiamenti raccomandati dai lettori). Per piacere
contattatemi se siete interessati a fare una traduzione: &egrave; una
modifica che posso tollerare.

<p>
Questo documento &egrave; disponibile gratuitamente e, mentre ho fatto
il mio meglio per renderlo accurato e aggiornato, non mi assumo
nessuna responsabilit&agrave; per alcun problema in cui vi possiate
imbattere come risultato dell'uso di questo documento.

<sect>Bash e i Prompt Bash 

<sect1>Cosa &egrave; Bash

<p>
Discendente dalla Bourne Shell, Bash &egrave; un progetto GNU, la
"<bf>B</bf>ourne <bf>A</bf>gain <bf>SH</bf>ell". &Egrave;
l'interfaccia a linea di comando standard su molte macchine
Linux. Eccelle in interattivit&agrave;, nel supportare modifica,
completamento e richiamo della linea di comando. Supporta anche prompt
configurabili - molti lo sanno, ma non sanno quanto si pu&ograve;
fare.

<sect1>Quali sono i vantaggi di modificare il prompt?

<p>
La maggior parte dei sistemi Linux hanno un prompt predefinito in un
colore (di solito grigio) che dice il vostro nome utente, il nome della
macchina su cui lavorate e qualche indicazione sulla directory di
lavoro corrente. Queste sono tutte informazioni utili, ma si
pu&ograve; fare molto di pi&ugrave; con il prompt: ogni genere di
informazione pu&ograve; essere visualizzata (numero di tty, ora, data,
carico della macchina, numero di utenti, uptime ...) e il prompt
pu&ograve; utilizzare colori ANSI, per farlo apparire interessante, o
per fare s&igrave; che certe informazioni siano evidenti. &Egrave;
anche possibile manipolare la barra del titolo di un Xterm per
visualizzare alcune di queste informazioni.


<sect1>Perch&eacute; darsi tante noie?

<p>
Oltre che essere bello, &egrave; spesso utile tenere traccia delle
informazioni di sistema. Una idea che so piace a molti &egrave; la
possibilit&agrave; di mettere su macchine differenti prompt con colori
differenti. Se avete diversi Xterm aperti su macchine differenti, o se
tendete a dimenticare su quale macchina state lavorando e a cancellare
file sbagliati, troverete questa un ottima maniera per ricordare su
che macchina vi trovate.

<sect1>Il Primo Passo

<p>
L'aspetto del prompt viene controllato dalla variabile della shell
PS1. Le continuazioni di un comando sono indicate dalla stringa PS2,
che pu&ograve; essere modificata con esattamente gli stessi metodi
qui discussi - poich&eacute; controllarla &egrave; esattamente
uguale e non &egrave; altrettanto "interessante", modificher&ograve;
primcipalmente la stringa PS1. (Ci sono anche le stringhe PS3 e
PS4. Queste non vengono mai viste dall'utente medio - si veda la
pagina di manuale di Bash se si &egrave; interessati al loro
scopo). Per modificare l'aspetto del prompt, dovete cambiare la
variabile PS1. Per fare esperimenti, potete cambiare la stringa PS1
direttamente al prompt e vedere immediatamente i risultati (questo
influenza solo la sessione corrente e i cambiamenti spariscono quando
fate log-out). Se volete rendere permanente un cambiamento del prompt,
modificate il file &tilde;/.bashrc e aggiungete l&igrave; la nuova
definizione di PS1. Se avete permessi di root, potete guardare in
/etc/profile e modificare la linea "<bf>PS1=</bf>". Sappiate che in
alcune distribuzioni (almeno la Redhat 5.1) /etc/bashrc resetta le
stringhe PS1 e PS2.

<p>
Prima di cominciare, &egrave; importante ricordare che la stringa PS1
viene salvata nell'ambiente. Se la modificate alla linea di comando,
il prompt cambier&agrave; di conseguenza. Prima di fare dei
cambiamenti, potete salvare il prompt corrente in un'altra variabile
d'ambiente:

<tscreen><verb>
[giles@nikola giles]$ SAVE=$PS1
[giles@nikola giles]$
</verb></tscreen>

<p>
Il prompt pi&ugrave; semplice sarebbe un singolo carattere, come:

<tscreen><verb>
[giles@nikola giles]$ PS1=$
$ls
bin   mail
$
</verb></tscreen>

<p>
Questo dimostra il modo migliore per fare esperimenti con semplici
prompt, digitarli alla linea di comando. Si noti che il testo digitato
dall'utente appare immediatamente dopo il prompt: io preferisco usare

<tscreen><verb>
$PS1="$ "
$ ls
bin   mail
$ 
</verb></tscreen>

<p>
che inserisce uno spazio dopo il prompt, rendendolo pi&ugrave;
leggibile. Per ripristinare il prompt originale, semplicemente
richiamate la variabile che avete salvato:

<tscreen><verb>
$ PS1=$SAVE
[giles@nikola giles]$
</verb></tscreen>

<sect1>Sequenza di Escape dei Prompt Bash 

<p>
Vi sono molte sequenze di escape offerte dalla shell Bash da inserire
nel prompt. Dalla pagina di manuale di Bash 2.02:

<tscreen><verb>
Quando eseguita in modalit&agrave; interattiva, bash mostra il prompt
primario quando &egrave; pronta per leggere un comando e il prompt
secondario PS2 quando &egrave; necessario ulteriore input per
completare il comando. Bash permette di personalizzare queste stringhe
di prompt inserendo vari caratteri di escape speciali che vengono
interpretati come segue:
       \a     il carattere ASCII beep (07)
       \d     la data nel formato "Giorno-della-settimana Mese Data"
              (e.g., "Tue May 26")
       \e     un carattere di escape ASCII (033)
       \h     l'hostname fino al primo `.'
       \H     l'hostname
       \n     il carattere "newline"
       \r     il carattere "carriage return"
       \s     il nome della shell, il nome base di $0
              (la parte che segue lo slash finale)
       \t     l'ora corrente nel formato 24-ore HH:MM:SS
       \T     l'ora corrente nel formato 12-ore HH:MM:SS
       \@     l'ora corrente nel formato 12-ore am/pm
       \u     lo username dell'utente corrente
       \v     la versione di bash (e.g., 2.00)
       \V     la release di bash, versione + patchlevel
              (e.g., 2.00.0)
       \w     la directory di lavoro corrente
       \W     il nome di base della directory di lavoro corrente
       \!     il numero cronologico (history number) di questo comando
       \#     il numero di questo comando
       \$     se l'UID effettivo &egrave; 0, un #, altrimenti un $
       \nnn   il carattere corrispondente al numero ottale nnn
       \\     un backslash
       \[     comuncia una sequenza di caratteri non stampabili, che
              potrebbero essere usati per inserire una sequenza di
              controllo del terminale nel prompt
       \]     termina la sequenza di caratteri non stampabili
</verb></tscreen>

<p>
Continuando da dove avevamo interrotto:

<tscreen><verb>
[giles@nikola giles]$ PS1="\u@\h \W&gt; "
giles@nikola giles&gt; ls
bin   mail
giles@nikola giles&gt;
</verb></tscreen>

<p>
Questo &egrave; simile al prompt predefinito su molte distribuzioni
Linux. Volevo un apparenza leggermente differente, cos&igrave; l'ho
cambiato a:

<tscreen><verb>
giles@nikola giles&gt; PS1="[\t][\u@\h:\w]\$ "
[21:52:01][giles@nikola:~]$ ls
bin   mail
[21:52:15][giles@nikola:~]$ 
</verb></tscreen>

<sect1>Impostare Permanentemente le Stringhe PS? <label id="setps">

<p>
Varie persone e distribuzioni impostano le loro stringhe PS? in posti
diversi. I posti pi&ugrave; comuni sono /etc/profile, /etc/bashrc,
&tilde;/.bash_profile e &tilde;/.bashrc. Johan Kullstam (<htmlurl
url="mailto:johan19@idt.net" name="johan19@idt.net">) scrive:

<tscreen><verb>
La stringa PS1 dovrebbe essere impostata in
.bashrc. questo perch&egrave; le shell bash non interattive resettano
PS1. La pagina di manuale di bash dice come la presenza o l'assenza di
PS1 &egrave; un buon modo di sapere se ci si trova in una sessione
bash interattiva oppure non-interattiva (e.g. uno script).

Il modo in cui mi sono accorto di questo &egrave; che startx &egrave;
uno script bash. Questo significa che startx annuller&agrave; il
vostro prompt. Quando impostate PS1 in .profile (o .bash_profile),
fate login alla consolle, fate partire X con startx, il vostro PS1
viene annullato nel processo lasciandovi con il prompt predefinito.

Una soluzione &egrave; di lanciare xterm e rxvt con l'opzione -ls per
forzarli a leggere .profile. Ma ogni volta che viene invoca una shell 
mediante uno shell-script non interativo PS1 viene perduto. system(3)
usa sh -c che se sh &egrave bash distrugger&agrave; 
PS1. Un modo migliore &egrave; mettere la definizione di PS1 in 
.bashrc . questo viene letto ogni volta bash parte ed &egrave; dove le
cose interattive - come PS1 - dovrebbero restare.

Quindi dovrebbe essere sottolineato che PS1=..blabla.. dovrebbe stare
in .bashrc e non in .profile.
</verb></tscreen>

<p>
Ho provato a duplicare il problema che spiega, e ne ho incontrato
uno diverso: la mia variabile PROMPT_COMMAND (che verr&agrave;
introdotta pi&ugrave; tardi) &egrave; stata distrutta. Le mie
conoscenze in quest'area sono un po' vaghe, cos&igrave; mi associo a
quanto dice Johan.

<sect>Comandi Esterni

<sect1>PROMPT_COMMAND

<p>
Bash fornisce un'altra variabile d'ambiente chiamata
<bf>PROMPT_COMMAND</bf>. Il contenuto di questa variabile viene
eseguito come un normale comando Bash appena prima che Bash visualizzi
il prompt.

<tscreen><verb>
[21:55:01][giles@nikola:~] PS1="[\u@\h:\w]\$ "
[giles@nikola:~] PROMPT_COMMAND="date +%H%M"
2155
[giles@nikola:~] d
bin   mail
2156
[giles@nikola:~] 
</verb></tscreen>

<p>
Ci&ograve che &egrave; accaduto sopra &egrave; che ho cambiato PS1 in
modo da non includere pi&ugrave; la sequenza di escape <TT>\t</TT>,
cos&igrave; da visualizzare l'ora in un formato che mi piace di
pi&ugrave;. Ma l'ora compare in una linea diversa dal
prompt. Aggiustando questo con <TT>echo -n ...</TT> (come mostrato
sotto) funziona con Bash 2.0+, ma sembra non funzonare con Bash
1.14.7: apparentemente il prompt viene ottenuto in maniera differente
e il metodo seguente causa una sovrapposizione del testo.

<tscreen><verb>
2156
[giles@nikola:~] PROMPT_COMMAND="echo -n [$(date +%H%M)]"
[2156][giles@nikola:~]$
[2156][giles@nikola:~]$ d
bin   mail
[2157][giles@nikola:~]$ unset PROMPT_COMMAND
[giles@nikola:~]
</verb></tscreen>

<p>
<TT>echo -n ...</TT> controlla l'output del comando <tt>date</tt> e sopprime il
carattere newline finale, permettendo al prompt di apparire tutto su
una riga. Alla fine ho usato il comando <TT>unset</TT> per rimuovere
la variabile d'ambiente PROMPT_COMMAND.

<p>
Si noti che uso la convenzione $(&lt;comando&gt;) per la sostituzione
dei comandi: ovvero:

<tscreen><verb>
$(date +%H%M)
</verb></tscreen>

<p>
significa "sostituisci qui l'output del comando <bf>date
+%H%M</bf>". Questo funziona in Bash 2.0+. In qualche versione
pi&ugrave; vecchia di Bash, precedente alla 1.14.7, potreste dovere
usare i backquote (<TT>`date +%H%M`</TT>). I backquote possono essere
usati in Bash 2.0+, ma stanno venendo via via rimpiazzati in favore di
$(), che si annida meglio. Continuer&ograve; ad utilizzare questa
convenzione in questo documento. Se state usando una versione
precedente di Bash, potete di solito sostituite dei backquote dove
vedete $(). Se la sostituzione di comandi &egrave; preceduta da "\"
(cio&egrave; \$(comando) ), usate dei backslash davanti ad
entrambi i backquote (cio&egrave; \'comando\' ).

<sect1>Comandi Esterni nel Prompt

<p>
Potete anche usare l'output di normali comandi Linux direttamente nel
prompt.  Ovviamente, non dovrete inserire molto materiale altrimenti
creer&agrave; un prompt molto grande. Dovrete anche inserire un
comando <bf>veloce</bf>, perch&eacute; verr&agrave; eseguito ogni
volta che il prompt appare sullo schemo e ritardi nell'apparire del
prompt mentre state lavorando possono essere molto
fastidiosi. (Differentemente dall'esempio precedente, a cui assomiglia
molto, questo funziona anche con Bash 1.14.7). 

<tscreen><verb>
[21:58:33][giles@nikola:~]$ PS1="[\$(date +%H%M)][\u@\h:\w]\$ "
[2159][giles@nikola:~]$ ls
bin   mail
[2200][giles@nikola:~]$
</verb></tscreen>

<p>
&Egrave; importante notare il backslash prima del segno dollaro della
sostituzione di comando. Senza di esso, il comando esterno viene
eseguito esattamente una volta: quando la stringa PS1 viene letta
nell'ambiente. Per questo prompt, ci&ograve; significherebbe mostrare
lo stesso orario indipendentemente da quanto il prompt viene
utilizzato.  Il backslash protegge il contenuto di $()
dall'interpretazione immediata della shell, cos&igrave; "date" viene
chiamato ogni volta che il prompt viene generato.

<p>
Linux viene fornito con molti piccoli programmi di utilit&agrave; come
<bf>date</bf>, <bf>grep</bf>, o <bf>wc</bf> che consentono di
manipolare informazioni. Se vi trovate a creare complesse combinazioni
di questi programmi all'interno di un prompt, potrebbe essere
pi&ugrave; semplice fare voi stessi uno shell script e chiamarlo dal
prompt. Per assicurare che le variabili della shell siano espanse al
momento giusto negli shell script bash sono spesso necessarie delle
sequenze di escape (come visto sopra con il comando <tt>date</tt>):
questo viene elevato ad un altro livello all'interno della linea del 
prompt PS1 ed evitare ci&ograve; creando degli shell script &egrave;
una buona idea. 

<p>
Un esempio di un piccolo shell script usato all'interno di un prompt
viene dato a seguire:

<tscreen><verb>
#!/bin/bash
#     lsbytesum - somma il numero di byte in un elenco di directory
TotalBytes=0
for Bytes in $(ls -l | grep "^-" | cut -c30-41)
do
    let TotalBytes=$TotalBytes+$Bytes
done
TotalMeg=$(echo -e "scale=3 \n$TotalBytes/1048576 \nquit" | bc)
echo -n "$TotalMeg"
</verb></tscreen>

<!-- Combo Verified! 8 Oct 98 -->

<p>
A volte l'ho usato come una funzione (molto pi&ugrave; efficiente -
sfortunatamente, spiegare in dettaglio le funzioni va oltre lo scopo
di questo documento), altre come uno shell script nella mia 
directory &tilde;/bin, che &egrave; nel mio path. Usata in un prompt:

<tscreen><verb>
[2158][giles@nikola:~]$ PS1="[\u@\h:\w (\$(lsbytesum) Mb)]\$ "
[giles@nikola:~ (0 Mb)]$ cd /bin
[giles@nikola:/bin (4.498 Mb)]$
</verb></tscreen>

<sect1>Cosa Mettere nel Prompt

<p>
Avrete notato che io metto il nome della macchina, l'ora e la
directory corrente nella maggioranza dei miei prompt. Ad eccezione
dell'ora queste sono cose molto standard da mettere nel prompt, l'ora
&egrave; l'aggiunta pi&ugrave; comune dopo queste. Ma cosa includere nel
prompt &egrave interamente una questione di gusto personale. Questi
sono esempi da persone che conosco per aiutare a darvi delle idee.

<p>
Il prompt di Dan &egrave; minimale ma efficace, particolarmente per
via del modo in cui funziona.

<tscreen><verb>
[giles@nikola:~]$ cur_tty=$(tty | sed -e "s/.*tty\(.*\)/\1/")
[giles@nikola:~]$ echo $cur_tty
p4
[giles@nikola:~]$ PS1="\!,$cur_tty,\$?\$ "
1095,p4,0$ 
</verb></tscreen>

<p>
A Dan non piace avere la directory corrente che pu&ograve;
ridimensionare drasticamente il prompt come ci si muove nell'albero
delle directory, cos&igrave; ne tiene traccia a mente (o digita
"pwd"). Lui ha imparato Unix con csh e tcsh, cos&igrave; usa molto la
command history (qualcosa che molti di noi, viziati da bash, non
facciamo), cos&igrave; la prima cosa nel prompt &egrave; l'history
number. La seconda cosa sono i caratteri significativi del tty
(l'output di "tty" viene tagliato con sed), una cosa che pu&ograve;
essere utile per gli utilizzatori di "screen". La terza cosa &egrave; il
valore di uscita dell'ultimo comando/pipeline (si noti che questo
viene reso inutile da ogni comando eseguito all'interno del prompt -
potreste per&ograve; ottenerlo salvando il valore in una variabile e
rimettendolo poi a posto). In fine, lo "\$" &egrave; un carattere dollaro
per un normale utente e cambia in un cancelletto ("#") se l'utente
&egrave; root.

<p>Torben Fjerdingstad ha scritto per dirmi che spesso sospende dei
job e poi se ne dimentica, cos&igrave; usa il prompt per ricordarsi
dei job sospesi:

<tscreen><verb>
[giles@nikola:~]$ function jobcount {
&gt; jobs|wc -l| awk '{print $1}'
&gt; }
[giles@nikola:~]$ export PS1='\W[`jobcount`]# '
giles[0]# man ls &
[1] 4150

[1]+  Stopped (tty output)    man ls
giles[1]#
</verb></tscreen>

<p>
Torben usa <bf>awk</bf> per togliere gli spazi vuoti dall'output di wc,
mentre io avrei usato sed oppure tr - non perch&eacute; siano meglio, ma
perch&eacute; mi sono pi&ugrave; familiari. Vi sono probabilmente
anche altri modi. Torben delimita la stringa PS1 con apostrofi (single 
quote), questo evita che Bash interpreti immediatamente i backquote,
cos&igrave; lui non deve farli precedere da "\" come ho menzionato.

<p>
<bf>NOTA:</bf> C'&egrave; un noto bug in Bash 2.02 che fa s&igrave; che il 
comando <bf>jobs</bf> (integrato nella  shell) non restituisca nulla ad un 
pipe. Se provate quanto sopra con Bash 2.02, otterrete sempre "0"
indipendentemente da quanti job avete sospesi. Chet Ramey, uno dei
manutentori di Bash, mi dice che questo sar&agrave; corretto in v2.03.

<sect1>Ambiente e Funzioni Bash

<p>
Come menzionato prima, PS1, PS2, PS3, PS4 e PROMPT_COMMAND sono tutti
salvati nell'ambiente Bash. Per quelli di noi che hanno precedente
esperienza con DOS, l'idea di maneggiare grosse porzioni di codice
nell'ambiente &egrave; terrificante, perch&egrave l'ambiente DOS era
piccolo e proprio non cresceva bene. Vi sono probabilmente limiti
pratici su cosa pu&ograve; e cosa dovrebbe essere messo nell'ambiente,
ma non so quali siano; stiamo probabilmente parlando di un paio di
ordini di grandezza in pi&ugrave; di quanto gli utenti DOS siano
abituati. Come dice Dan:

<p>
"Nella mia shell interattiva ho 62 alias e 25 funzioni. La mia regola
generale &egrave; che se ho bisogno di qualcosa solamente per uso
interattivo e pu&ograve; essere scritta in bash ne faccio una funzione
(presumendo che non possa essere espressa facilmente con un alias). Se
queste persone hanno problemi di memoria non dovrebbero usare
bash. Bash &egrave; uno dei programmi pi&ugrave; grossi che faccio
girare nella mia Linux box (a parte Oracle). Lancia top qualche volta
e premi 'M' per ordinare per memoria occupata - vedrai quanto bash
&egrave; vicino alla cima della lista. Caspita, &egrave; pi&ugrave;
grosso di sendmail! D&igrave; loro di prendere qualcosa come ash".

<p>
Credo che quel giorno stesse usando solo la consolle: girando X e le
applicazioni X, ho molte cose pi&ugrave; grosse di Bash. Ma l'idea
&egrave; la stessa: l'ambiente &egrave; qualcosa da utilizzare senza
preoccuparsi di riempirlo troppo.


<p>
Rischio la censura da parte dei guru di Unix quando dico questo (per
crimine di ipersemplificazione): le funzioni sono in pratica piccoli
shell script che vengono caricati nell'ambiente per motivi di
efficienza. Citando ancora Dan: "Le funzioni shell sono efficienti
quanto pi&ugrave; possibile. Approssimativamente &egrave;
l'equivalente di eseguire uno shell script bash/bourne eccetto che
nessun I/O di file &egrave; necessario perch&eacute; la funzione
&egrave; gi&agrave; in memoria. Le funzioni shell sono tipicamente
caricate da .bashrc o .bash_profile a seconda che le si voglia solo
nella shell iniziale o anche nelle sottoshell. Se confronti questo con
l'esecuzione di uno shell script: la shell fa un fork, il processo figlio
apre il file e fa un exec, potenzialmente il path viene esaminato, il
kernel apre il file e esamina sufficienti byte da determinare come
eseguire il file, nel caso di uno shell script una shell deve essere
avviata con il nome dello script come argomento, la shell allora apre
il file, legge e esegue i comandi. Diversamente, con una funzione shell,
tutto fuorch&eacute; l'esecuzione dei comandi pu&ograve; essere
considerato overhead non necessario".

<sect>Manipolazioni della Barra del Titolo di Xterm

<p>
Posso essere usate dele sequenze di escape non stampabili per produrre
effetti interessanti nei prompt. Per usare queste sequenze di escape,
dovete includerle fra <bf>\[</bf> e <bf>\]</bf>, dicendo a Bash di
ignorare questo materiale nel calcolare la dimensione del prompt. Se
non si includono questi delimitatori si fa in modo che il cursore appaia
nel posto sbagliato perch&eacute; la sua effettiva dimensione &egrave;
sconosciuta. Le sequenze di escape devono anche essere precedute da
<bf>\033[</bf> prima della versione 2 di Bash oppure da <bf>\033[</bf> o
<bf>\e[</bf> in versioni successive.

<p>
Se cercate di cambiare la barra del titolo dell'Xterm con il prompt
quando siete alla consolle, produrrete spazzatura. Per evitare questo,
testate la variabile d'ambiente XTERM per sapere se il prompt si
trover&agrave; in un Xterm.

<tscreen><verb>
function proml
{
case $TERM in
    xterm*)
        local TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        local TITLEBAR=''
        ;;
esac

PS1="${TITLEBAR}\
[\$(date +%H%M)]\
[\u@\h:\w]\
\$ "
PS2='&gt; '
PS4='+ '
}
</verb></tscreen>

<p>
Questa &egrave; una funzione che pu&ograve; essere incorporata in
&tilde;/.bashrc. Il nome della funzione potrebbe quindi essere chiamato per
eseguire la funzione. La funzione, come la stringa PS1, viene salvata
nell'ambiente. Una volta che la stringa PS1 viene impostata dalla
funzione, potete rimuovere la funzione dall'ambiente con <TT>unset
proml</TT>. Dal momento che il prompt non pu&ograve; cambiare da
quando sta in un Xterm a quando sta alla consolle, la variabile TERM
non viene testata ogni volta che il prompt viene generato. Ho usato i
marcatori di continuazione (i backslash) nella definizione del prompt,
per consentire di scriverlo su pi&ugrave; righe. Questo migliora la
leggibilit&agrave; rendendo pi&ugrave; facile modificarlo e fare un
debug.

<p>
Lo definisco come una funzione perch&eacute; cos&igrave; &egrave;
come il pacchetto Bashprompt (discusso pi&ugrave; avanti in questo
documento) tratta i prompt: non &egrave; la sola maniera di farlo, ma
funziona bene. Via via che i prompt che utilizzate diventano
pi&ugrave; complessi, diventa sempre pi&ugrave; sconveniente digitarli
al prompt e pi&ugrave; pratico metterli in qualche sorta di file di
testo. In questo caso, per testare questo prompt, salvate quendo sopra
come un file di testo chiamato "proml". potete lavorare come segue:

<tscreen><verb>
[giles@nikola:/bin (4.498 Mb)]$ cd     -> Andate dove volete salvare il prompt
[giles@nikola:~ (0 Mb)]$ vi proml      -> Modificate il file del prompt 
...                                    -> Inserite il testo dato sopra
[giles@nikola:~ (0 Mb)]$ source proml  -> Leggete la funzione del prompt
[giles@nikola:~ (0 Mb)]$ proml         -> Eseguite la funzione del prompt
</verb></tscreen>

<p>
Il primo passo nel creare questo prompt &egrave; di controllare se la
shell che stiamo facendo partire &egrave; in un xterm o no: se lo
&egrave;, la variabile della shell (${TITLEBAR}) viene definita. Essa
consiste delle sequenze di escape appropriate e <bf>\u@\h:\w</bf>,
che mettono &lt;utente&gt;@&lt;macchina&gt;:&lt;directory di lavoro&gt;
nella barra del titolo di Xterm. Questo &egrave; particolarmente utile
con Xterm minimizzati, rendendoli identificabili pi&ugrave;
rapidamente. Il resto del materiale in questo prompt dovrebbe essere
gi&agrave; noto dai precedenti prompt che abbiamo creato.

<p>
Il solo inconveniente di manipolare la barra dell'Xterm in questo modo
avviene quando vi loggate in un sistema su cui non avete predisposto
il trucchetto della barra del titolo: l'Xterm continuer&agrave; a
mostrare l'informazione del precedente sistema su cui c'era il
trucco.

<sect>Sequenze di escape ANSI: Colori e Movimenti del Cursore

<sect1>Colori

<p>
Come menzionato prima, i caratteri di escape non stampabili devono
essere racchiusi da <bf>\[\033[</bf> e <bf>\]</bf>. Per le sequenze di
escape, devono anche essere seguiti da <bf>m</bf> minuscola.

<p>
Se provate i prompt seguenti in un xterm e trovate che non vedete i
colori menzionati, controllate nel file &tilde;/.Xdefaults (e possibilmente
gli altri con simile funzione) le linee come "XTerm*Foreground:
BlanchedAlmond". Questo pu&ograve; essere commentato mettendo un punto
esclamativo ("!") davanti.  Ovviamente questo dipender&agrave; anche
da che emulatore di terminale state usando. Questo &egrave; il posto
pi&ugrave; probabile in cui i colori del vostro terminale possono
essere reimpostati.

<p>
Per includere del testo blu nel prompt:

<tscreen><verb>
PS1="\[\033[34m\][\$(date +%H%M)][\u@\h:\w]$ "
</verb></tscreen>

Il problema con questo prompt &egrave; che il colore blu che inizia
con il codice-colore 34 non viene mai cambiato nuovamente al normale
colore, cos&igrave; il testo digitato dopo il prompt &egrave; ancora
nel colore del promot. Questa &egrave; una tonalit&agrave; di
blu scura, unendola con il codice <bf>bold</bf>
(grassetto) potrebbe aiutare:

<tscreen><verb>
PS1="\[\033[1;34m\][\$(date +%H%M)][\u@\h:\w]$\[\033[0m\] "
</verb></tscreen>

<p>
Il prompt &egrave; ora blu chiaro e termina cambiando il colore
nuovamente a nulla (quale che fosse il colore di primo piano che
avevate prima)

<p>
Questo sono i restanti valori dei colori:

<tscreen><verb>
Nero           0;30     Grigio Scuro  1;30
Blu            0;34     Blu Chiaro    1;34
Verde          0;32     Verde Chiaro  1;32
Ciano          0;36     Ciano Chiaro  1;36
Rosso          0;31     Rosso Chiaro  1;31
Viola          0;35     Viola Chiaro  1;35
Marrone        0;33     Giallo        1;33
Grigio Chiaro  0;37     Bianco        1;37
</verb></tscreen>

<p>
Potete anche impostare i colori dello sfondo usando 44 per uno sfondo
blu, 41 per uno sfondo rosso, ecc. Non ci sono colori dello sfondo in
grassetto (bold). Possono essere usate delle combinazioni, come testo
Rosso Chiaro su uno sfondo Blu: <bf>\[\033[44;1;31m\]</bf>, sebbene
impostare i colori separatamente sembra funzionare meglio
(cio&egrave; <bf>\[\033[44m\]\[\033[1;31m\]</bf>). Gli altri codici
disponibili includono 4: Sottolineatura, 5: Lmpeggiante, 7: Negativo,
e 8: Nascosto.

<p>
<bf>In oltre:</bf> Molti (incluso me stesso) si oppongono fermamente
all'attributo "blink". Fortunatamente, non funziona in ogni emulatore
di terminale che conosco - ma funziona alla consolle. E, se vi state
chiedento (come ho fatto io) "A cosa serve un attributo 'Nascosto'?!" - 
l'ho visto usato in un esempio di uno shell script (non un prompt) per 
permettere di digitare una password senza visualizzarla sullo schermo.

<p>
Basato su un prompt chiamato "elite2" nel pacchetto Bashprompt (che ho
modificato per funzionare meglio su una consolle standard, piuttosto
che con i font speciali di xterm richiesti per vedere bene
l'originale), questo &egrave; un prompt che ho usato molto:

<tscreen><verb> 
function elite
{

local GRAY="\[\033[1;30m\]"
local LIGHT_GRAY="\[\033[0;37m\]"
local CYAN="\[\033[0;36m\]"
local LIGHT_CYAN="\[\033[1;36m\]"

case $TERM in
    xterm*)
        local TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        local TITLEBAR=""
        ;;
esac

local GRAD1=$(tty|cut -d/ -f3)
PS1="$TITLEBAR\
$GRAY-$CYAN-$LIGHT_CYAN(\
$CYAN\u$GRAY@$CYAN\h\
$LIGHT_CYAN)$CYAN-$LIGHT_CYAN(\
$CYAN\#$GRAY/$CYAN$GRAD1\
$LIGHT_CYAN)$CYAN-$LIGHT_CYAN(\
$CYAN\$(date +%H%M)$GRAY/$CYAN\$(date +%d-%b-%y)\
$LIGHT_CYAN)$CYAN-$GRAY-\
$LIGHT_GRAY\n\
$GRAY-$CYAN-$LIGHT_CYAN(\
$CYAN\$$GRAY:$CYAN\w\
$LIGHT_CYAN)$CYAN-$GRAY-$LIGHT_GRAY " 
PS2="$LIGHT_CYAN-$CYAN-$GRAY-$LIGHT_GRAY "
}
</verb></tscreen>

<p>
Io definisco i colori come variabili temporanee della shell per
leggibilit&agrave;. &Egrave; pi&ugrave; facile lavorarci. La variablie 
"GRAD1" &egrave; un controllo per determinare in che terminale ci si
trova, come il controllo per determinare se ci si trova su un Xterm,
&egrave; sufficiente farlo una sola volta. Il prompt che vedrete ha
questo aspetto, ma a colori:

<tscreen><verb>
--(giles@nikola)-(75/ttyp7)-(1908/12-Oct-98)--
--($:~/tmp)--
</verb></tscreen>

<p>
Per aiutarmi a ricordare quali colori sono disponibili, ho scritto lo
script seguente che visualizza tutti i colori sullo schermo:

<code>
#!/bin/bash
#
#   Questo file stampa molti codici-colore sul terminale per
#   mostrare quali sono disponibili. Ogni linea e` un colore su sfondo
#   nero o grigio, con il colore nel mezzo. E` verificato che funziona con 
#   sfondo bianco, nero e verde (2 dic 98).
#
echo "  On Light Gray:        On Black:"
echo -e "\033[47m\033[1;37m  White        \033[0m\
 1;37m \
\033[40m\033[1;37m  White        \033[0m"
echo -e "\033[47m\033[37m  Light Gray   \033[0m\
   37m \
\033[40m\033[37m  Light Gray   \033[0m"
echo -e "\033[47m\033[1;30m  Gray         \033[0m\
 1;30m \
\033[40m\033[1;30m  Gray         \033[0m"
echo -e "\033[47m\033[30m  Black        \033[0m\
   30m \
\033[40m\033[30m  Black        \033[0m"
echo -e "\033[47m\033[31m  Red          \033[0m\
   31m \
\033[40m\033[31m  Red          \033[0m"
echo -e "\033[47m\033[1;31m  Light Red    \033[0m\
 1;31m \
\033[40m\033[1;31m  Light Red    \033[0m"
echo -e "\033[47m\033[32m  Green        \033[0m\
   32m \
\033[40m\033[32m  Green        \033[0m"
echo -e "\033[47m\033[1;32m  Light Green  \033[0m\
 1;32m \
\033[40m\033[1;32m  Light Green  \033[0m"
echo -e "\033[47m\033[33m  Brown        \033[0m\
   33m \
\033[40m\033[33m  Brown        \033[0m"
echo -e "\033[47m\033[1;33m  Yellow       \033[0m\
 1;33m \
\033[40m\033[1;33m  Yellow       \033[0m"
echo -e "\033[47m\033[34m  Blue         \033[0m\
   34m \
\033[40m\033[34m  Blue         \033[0m"
echo -e "\033[47m\033[1;34m  Light Blue   \033[0m\
 1;34m \
\033[40m\033[1;34m  Light Blue   \033[0m"
echo -e "\033[47m\033[35m  Purple       \033[0m\
   35m \
\033[40m\033[35m  Purple       \033[0m"
echo -e "\033[47m\033[1;35m  Pink         \033[0m\
 1;35m \
\033[40m\033[1;35m  Pink         \033[0m"
echo -e "\033[47m\033[36m  Cyan         \033[0m\
   36m \
\033[40m\033[36m  Cyan         \033[0m"
echo -e "\033[47m\033[1;36m  Light Cyan   \033[0m\
 1;36m \
\033[40m\033[1;36m  Light Cyan   \033[0m"

</code>

<sect1>Movimenti del Cursore

<p>
Le sequenze di escape ANSI permettono di muovere il cursore a piacere
sullo schermo. Questo &egrave; pi&ugrave; utile per interfacce utente
a tutto schermo generate da shell script, ma possono essere usate
anche nei prompt. Le sequenze di escape di movimento sono le seguenti:

<tscreen><verb>
- Posizione del cursore:
  \033[&lt;L&gt;;&lt;C&gt;H
  mette il cursore alla linea L e colonna C.
- Muove il cursore su N linee:
  \033[&lt;N&gt;A
- Muove il cursore gi&ugrave; N linee:
  \033[&lt;N&gt;B
- Muove il cursore avanti N colonne:
  \033[&lt;N&gt;C
- Muove il cursore indietro N colonne:
  \033[&lt;N&gt;D

- Salva la posizione del cursore:
  \033[s
- Ripristina la posizione del cursore:
  \033[u
</verb></tscreen>

<p>
Gli ultimi due codici NON SONO supportati da molti emulatori di
terminale. Gli unici che so che lo fanno sono xterm e nxterm - anche
se la maggior parte degli emulatori di terminale sono basati sul
codice di xterm. Da quanto ho potuto vedere rxvt, kvt, xiterm, e Eterm
non li supportano. Sono supportati alla consolle.

<p>
Provate a digitare le seguenti linee di codice al prompt (cosa fa
&egrave; un po' pi&ugrave; chiaro se il prompt &egrave; alcune linee
gi&ugrave; nel terminale quando lo digitate): <tt>echo -en
"\033[7A\033[1;35m BASH \033[7B\033[6D"</tt>. Questo dovrebbe muovere
il cursore sette linee su per lo schermo, stampare la parola " BASH ",
e poi tornare dov'era per produrre un normale prompt. Questo non
&egrave; un prompt: &egrave; solo una dimostrazione di come muovere il
cursore sullo schermo, usando il colore per evidenziare quanto viene
fatto.

<p>
Salvate questo in un file chiamato "clock":

<code>
#!/bin/bash

function prompt_command {
let prompt_x=$COLUMNS-5
}

PROMPT_COMMAND=prompt_command

function clock {
local       BLUE="\[\033[0;34m\]"
local        RED="\[\033[0;31m\]"
local  LIGHT_RED="\[\033[1;31m\]"
local      WHITE="\[\033[1;37m\]"
local  NO_COLOUR="\[\033[0m\]"
case $TERM in
    xterm*)
        TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        TITLEBAR=""
        ;;
esac

PS1="${TITLEBAR}\
\[\033[s\033[1;\$(echo -n \${prompt_x})H\]\
$BLUE[$LIGHT_RED\$(date +%H%M)$BLUE]\[\033[u\033[1A\]
$BLUE[$LIGHT_RED\u@\h:\w$BLUE]\
$WHITE\$$NO_COLOUR "
PS2='> '
PS4='+ '
}
</code>


<p>
Questo prompt &egrave; piuttosto semplice, ma tiene un
orologio nell'angolo in alto a destra del terminale (anche se il
terminale viene ridimensionato). Questo NON funzioner&agrave; negli
emulatori di terminale che, come ho menzionato, non accettano i codici 
per salvare e ripristiare la posizione del cursore. Se provate ad
usare questo prompt in uno di quegli emulatori di terminale,
l'orologio apparir&agrave; correttamente, ma il prompt verr&agrave;
intrappolato nella seconda linea del terminale.


<p>Vedi anche 
<ref id="clock3" name="Il Prompt Orologio Inutile ed Elegante"> 
per un uso pi&ugrave; esteso di questi codici.

<sect1>Muovere il Cursore Con tput

<p>
Come molte cose in Unix, c'&egrave; pi&ugrave; di un modo per
raggiungere gli stessi fini. Una utility chiamata "tput" pu&ograve;
essere usata anche per spostare il cursore sullo schermo, o per
ottenere informazioni sullo stato di un terminale. "tput", per
posizionare il cursore, &egrave meno flessibile delle sequenze di
escape ANSI: si pu&ograve; muovere il cursore solo ad una posizione
assoluta, non si pu&ograve; relativamente alla sua posizione
corrente. Non uso "tput", quindi non intendo spiegarlo in
dettaglio. Digitate "man tput" e ne saprete quanto me.

<sect>Caratteri Speciali: Sequenze di Escape Ottali

<p>
Oltre i caratteri che si digitano sulla tastiera, ci sono molti altri
caratteri che possono essere stampati sullo schermo. Ho creato uno
script per permettervi di controllare cosa mette a disposizione il
font che state usando. Il comando principale che avrete bisogno di
usare &egrave; per utilizzare questi caratteri &egrave; "echo
-e". L'opzione "-e" dice ad echo di abilitare l'interpretazione dei
caratteri protetti con backslash. Cosa si vede quando guardate 200-400
ottale &egrave; molto diverso con un font VGA da quello che si vede
con un font Linux standard. Siate avvisati che queste sequenze di
escape hanno effetti strani sul terminale, e non ho tentato di
prevenire che facciano quello che fanno. I caratteri linedraw e block
(ai quali molti di noi sono diventati familiari con Word Perfect) e
che sono usati molto dal progetto Bashprompt, sono fra 260 e 337 ottale.

<code>
#!/bin/bash

#   Script: escgen

function usage {
   echo -e "\033[1;34mescgen\033[0m &lt;lower_octal_value&gt; [&lt;higher_octal_value&gt;]"
   echo "   Octal escape sequence generator: print all octal escape sequences"
   echo "   between the lower value and the upper value.  If a second value"
   echo "   isn't supplied, print eight characters."
   echo "   1998 - Giles Orr, no warranty."
   exit 1
}

if [ "$#" -eq "0" ]
then
   echo -e "\033[1;31mPlease supply one or two values.\033[0m"
   usage
fi
let lower_val=${1}
if [ "$#" -eq "1" ]
then
   #   If they don't supply a closing value, give them eight characters.
   upper_val=$(echo -e "obase=8 \n ibase=8 \n $lower_val+10 \n quit" | bc)
else
   let upper_val=${2}
fi
if [ "$#" -gt "2" ]
then 
   echo -e "\033[1;31mPlease supply two values.\033[0m"
   echo
   usage
fi
if [ "${lower_val}" -gt "${upper_val}" ]
then
   echo -e "\033[1;31m${lower_val} is larger than ${upper_val}."
   echo
   usage
fi
if [ "${upper_val}" -gt "777" ]
   then
   echo -e "\033[1;31mValues cannot exceed 777.\033[0m"
   echo
   usage
fi

let i=$lower_val
let line_count=1
let limit=$upper_val
while [ "$i" -lt "$limit" ]
do
   octal_escape="\\$i"
   echo -en "$i:'$octal_escape' "
   if [ "$line_count" -gt "7" ]
   then 
      echo
      #   Put a hard return in.
      let line_count=0
   fi
   let i=$(echo -e "obase=8 \n ibase=8 \n $i+1 \n quit" | bc)
   let line_count=$line_count+1
done
echo

</code>

<p>
Potete anche usare <bf>xfd</bf> per mostrare tutti i caratteri un un
font X, con il comando "xfd -fn &lt;fontname&gt;". Facendo clic su un
carattere vengono date molte informazioni circa quel catattere,
incluso il suo valore ottale. Lo script dato sopra sar&agrave; utile
alla consolle e se non siete sicuri del nome del font corrente.

<sect>Il Pacchetto Bash Prompt 

<sect1>Disponibilit&agrave; 

<p>
Il pacchetto Bash Prompt &egrave; disponibile qui <htmlurl
url="http://bash.current.nu"name="http://bash.current.nu">, ed
&egrave; il lavoro di molte persone, coordinate da Rob Current (aka
BadLandZ). Il pacchetto &egrave; in versione beta, ma offre una
maniera semplice di usare prompt multipli (o temi), permette di
impostare il prompt per shell di login e per sottoshell (cio&egrave;
mettere stringhe PS1 in (&tilde;/.bash_profile e &tilde;/.bashrc). La maggior
parte dei temi usano i set di caratteri estesi VGA, quindi hanno un
brutto aspetto a meno che siano usati con font VGA (che non sono
presenti su molti sistemi).

<sect1>Cambiare il Font di Xterm

<p>
Per usare alcuni dei prompt pi&ugrave; attraenti nel
pacchetto Bash Prompt, dovete prendere e installare installare i font
che supportano il set di caratteri richiesto dai prompt. Ci si
riferise ad essi come "Font VGA", ma non mi &egrave; chiara la
distinzione fra essi e i font gi&agrave; distribuiti presenti con Linux -
sebbene chiaramente supportano set di caratteri differenti. I font per 
Xterm standard supportano un alfabeto esteso, inclusi molti caratteri
accentati. Nei font VGA, questo materiale viene rimpiazzato da
caratteri grafici - blocchi, punti, linee. Se qualcuno pu&ograve;
spiegare questo pi&ugrave; in dettaglio mi mandi un e-mail e
includer&ograve; qui una spiegazione.

<p>
Ottenere e installare questi font &egrave; un processo un po' contorto.
Prima, recuperate i/il font. Poi, assicuratevi che siano file .pcf o
.pcf.gz. Se sono file .bdf, informatevi sul comando "bdftopcf"
(cio&egrave; leggete la man page). Mettete i file .pcf o .pcf.gz nella 
directory  /usr/X11R6/lib/X11/fonts/misc (questa &egrave; la directory 
corretta per RedHat 5.1 e Slackware 3.4, potrebbe essere differente su 
altre distribuzioni). Fate "cd" su quella directory ed eseguite il
comando "mkfontdir". Quindi eseguite "xset fp rehash". A volte
&egrave; una buona idea andare nel file fonts.alias nella stessa
directory e creare dei nomi alternativi pi&ugrave; corti per i font.

<p>
Per usare i nuovi font, lanciate l'Xterm che pi&ugrave; vi piace
con l'opzione appropriata, che pu&ograve; essere trovata nella man
page o usando il parametro "--help" alla linea di comando. Alcuni
Xterm comuni dovrebbero essere usati come segue: 

<tscreen><verb>
xterm -font &lt;fontname&gt;
</verb>
<bf>OPPURE</bf>   
<verb>
xterm -fn &lt;fontname&gt; -fb &lt;fontname-bold&gt;
Eterm -f &lt;fontname&gt;
rxvt -fn &lt;fontname&gt;
</verb></tscreen>

<p>
I font VGA sono disponibili alla <em>Stumpy's ANSI Fonts</em> su
<htmlurl url="http://home.earthlink.net/~us5zahns/enl/ansifont.html"
	    name="http://home.earthlink.net/~us5zahns/enl/ansifont.html"> 
(da cui ho preso in prestito molto nello scrivere questo documento).



<sect>Caricare un Prompt Differente

<sect1>Caricare un Prompt Differente, Pi&ugrave; Tardi
<p>
Le spiegazione in questo HOWTO hanno mostrato come creare variabili di 
ambiente PS1, oppure come incorporare quelle stringhe PS1 e PS2 in
funzioni che potrebbero essere create da &tilde;/.bashrc o come un tema dal
pacchetto bashprompt.


Usando il pachetto bashprompt, si deve digitare <TT>bashprompt -i</TT>
per vedere una lista dei prompt disponibili. Per impostare il prompt
in shell di login future (principalmente la consolle, ma anche telnet
e Xterm, dipende da come sono configurati i vostri Xterm), si deve
digitare <TT>bashprompt -l nometema</TT>. bashprompt quindi modifica
il vostro &tilde;/.bash_profile per chiamare il tema richiesto alla partenza.
Per impostare il prompt in future sottoshell (solitamente Xterm, rxvt, 
ecc.), si deve digitare <TT>bashprompt -s nometema</TT>, e bashprompt
modifica il vostro file &tilde;/.bashrc per chiamare il tema richiesto alla
partenza. 

<sect1>Caricare un Prompt Differente, Immediatamente

<p>
Potete cambiare il prompt nel terminale corrente (usando la funzione
esempio "elite" di cui sopra) digitando <TT>source elite</TT> seguito
da <TT>elite</TT> (assumendo che il file funzione elite sia nella
directory corrente). Questo &egrave; un po' poco pratico e vi lascia
con un'altra funzione (elite) nel vostro spazio ambiente - se volete
ripulire l'ambiente, dovreste digitare anche <TT>unset
elite</TT>. Questo sembrerebbe un candidato ideale per un piccolo
shell script, ma uno script in questo caso non funziona perch&eacute;
lo script non pu&ograve; modificare l'ambiente della shell corrente:
pu&ograve; solo cambiare l'abiente della sottoshell in cui gira. Come
lo script termina, la sottoshell sparisce e cos&igrave; i cambiamente
fatti all'ambiente. Cosa <bf>pu&ograve;</bf> cambiare le variabili
d'ambiente della shell corrente sono le funzioni d'ambiente.
Il pacchetto bashprompt mette una funzione chiamato "callbashprompt"
nell'ambiente e, sebbene non sia documentata, pu&ograve; essere
chiamata per caricare al volo qualsiasi tema bashprompt. Guarda nella
directory dei temi che ha installato (il tema che chiamate deve essere 
l&igrave;), interpreta la funzione richiesta, carica la funzione e poi 
elimina la funzione, mantenendo wuindi l'ambiente in
ordine. "callbashprompt" non &egrave; pensata per essere usata
cos&igrave; e non controlla eventuali errori, ma tenendo questo a
mente, funziona piuttosto bene.

<sect>Caricare il Colori del Prompt Dinamicamente

<sect1>Un esempio che dimostra il concetto

<p>
Questa &egrave; una dimostrazione del concetto piuttosto che un prompt
attraente: cambiare i colori all'interno di un prompt
dinamicamente. In questo esempio, il colore dell'hostname cambia in
funzione del carico (come un avvertimento).

<tscreen><verb>
#!/bin/bash
#   "hostloadcolour" - 17 ottobre 98, Giles
#
#   Qui l'idea e` di cambiare il colore dell'hostname nel prompt, a
#   seconda del valore del carico.

# THRESHOLD_LOAD e` il valore del carico per un minuto (moltiplicato
# per cento) al quale volete che il prompt cambi da COLOUR_LOW a
# COLOUR_HIGH

THRESHOLD_LOAD=200
COLOUR_LOW='1;34'
          # blu chiaro
COLOUR_HIGH='1;31'
          # rosso chiaro

function prompt_command {
ONE=$(uptime | sed -e "s/.*load average: \(.*\...\), \(.*\...\), \(.*\...\)/\1/" -e "s/ //g")
#   A quanto pare, "scale" in bc non funziona con la moltiplicazione,
#   ma funziona con la divisionone.
ONEHUNDRED=$(echo -e "scale=0 \n $ONE/0.01 \nquit \n" | bc)
if [ $ONEHUNDRED -gt $THRESHOLD_LOAD ] 
then 
    HOST_COLOUR=$COLOUR_HIGH
	# rosso chiaro
else
    HOST_COLOUR=$COLOUR_LOW
	# blu chiaro
fi
}

function hostloadcolour {

PROMPT_COMMAND=prompt_command
PS1="[$(date +%H%M)][\u@\[\033[\$(echo -n \$HOST_COLOUR)m\]\h\[\033[0;37m\]:\w]$ "
}
</verb></tscreen>

<p>
Usando il vostro editor preferito, salvate queso in un file chiamato
"hostloadcolour". Se avete il pacchetto Bashprompt installato, Questo
funzioner&agrave; come un tema. Se no, digitate <TT>source
hostloadcolour</TT> e poi <TT>hostloadcolour</TT>. In entrambi i
modi, "prompt_command" diventa una funzione nel vostro ambiente. Se
esaminate il codice, noterete che i colori ($COLOUR_HIGH e
$COLOUR_LOW) sono impostati usanto solo un codice del colore parziale, 
cio&egrave; "1;34" invece di "\[\033[1;34m\]", che avrei
preferito. Non sono stato in grado di farlo funzionare con il codice
completo. Siete pregati di farmi sapere se doveste riuscirvi.

<!-- 
     **********************************
     *                                *
	  *      Examples Start Here       *
	  *                                *
	  **********************************
-->

<sect>Prompt di Esempio

<sect1>Un Prompt "Leggero" 

<p>
<tscreen><verb>

function proml {
local BLUE="\[\033[0;34m\]"
local RED="\[\033[0;31m\]"
local LIGHT_RED="\[\033[1;31m\]"
local WHITE="\[\033[1;37m\]"
local LIGHT_GRAY="\[\033[0;37m\]"
case $TERM in
    xterm*)
        TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        TITLEBAR=""
        ;;
esac

PS1="${TITLEBAR}\
$BLUE[$RED\$(date +%H%M)$BLUE]\
$BLUE[$LIGHT_RED\u@\h:\w$BLUE]\
$WHITE\$$LIGHT_GRAY "
PS2='> '
PS4='+ '
}

</verb></tscreen>

<sect1>Elite dai Temi Bashprompt

<p>
Si noti che questo necessita di un font VGA.

<tscreen><verb>

# Creato da KrON da windowmaker su IRC
# Cambiato da Spidey 08/06
function elite {
PS1="\[\033[31m\]\332\304\[\033[34m\](\[\033[31m\]\u\[\033[34m\]@\[\033[31m\]\h\
\[\033[34m\])\[\033[31m\]-\[\033[34m\](\[\033[31m\]\$(date +%I:%M%P)\
\[\033[34m\]-:-\[\033[31m\]\$(date +%m)\[\033[34m\033[31m\]/\$(date +%d)\
\[\033[34m\])\[\033[31m\]\304-\[\033[34m]\\371\[\033[31m\]-\371\371\
\[\033[34m\]\372\n\[\033[31m\]\300\304\[\033[34m\](\[\033[31m\]\W\[\033[34m\])\
\[\033[31m\]\304\371\[\033[34m\]\372\[\033[00m\]"
PS2="> "
}

</verb></tscreen>

<sect1>Un Prompt per il "Power User"

<p>
Io in realt&agrave; uso questo prompt, ma si ottengono notevoli
ritardi quando il prompt appare su una macchina monoutente PII-400,
quindi non raccomando di usarlo su un P-100 multiutente o
altro... Guardatelo per cercare idee, piuttosto che per usarlo in pratica.

<p>

<code>

#!/bin/bash
#----------------------------------------------------------------------
#       POWER USER PROMPT "pprom2"
#----------------------------------------------------------------------
#
#   Creato nell'agosto 98, Ultima Modifica 9 novembre 98 da Giles
#
#   Problema: quando load va giu', dice "1.35down-.08", eliminare il
#   segno negativo


function prompt_command
{
#   Crea la variabile TotalMeg: somma delle dimensioni dei file
#   visibile nella directory corrente
local TotalBytes=0
for Bytes in $(ls -l | grep "^-" | cut -c30-41)
do
    let TotalBytes=$TotalBytes+$Bytes
done
TotalMeg=$(echo -e "scale=3 \nx=$TotalBytes/1048576\n if (x&lt;1) {print \"0\"} \n print x \nquit" | bc)

#      Questo viene usato per calcolare il differenziale del valore
#      del carico fornito dal comando "uptime". "uptime" fornisce medie di
#      carico per 1, 5 r 15 minuti.
#
local one=$(uptime | sed -e "s/.*load average: \(.*\...\), \(.*\...\), \(.*\...\)/\1/" -e "s/ //g")
local five=$(uptime | sed -e "s/.*load average: \(.*\...\), \(.*\...\), \(.*\...\).*/\2/" -e "s/ //g")
local diff1_5=$(echo -e "scale = scale ($one) \nx=$one - $five\n if (x>0) {print \"up\"} else {print \"down\"}\n print x \nquit \n" | bc)
loaddiff="$(echo -n "${one}${diff1_5}")"

#   Conta file visibili:
let files=$(ls -l | grep "^-" | wc -l | tr -d " ")
let hiddenfiles=$(ls -l -d .* | grep "^-" | wc -l | tr -d " ")
let executables=$(ls -l | grep ^-..x | wc -l | tr -d " ")
let directories=$(ls -l | grep "^d" | wc -l | tr -d " ")
let hiddendirectories=$(ls -l -d .* | grep "^d" | wc -l | tr -d " ")-2
let linktemp=$(ls -l | grep "^l" | wc -l | tr -d " ")
if [ "$linktemp" -eq "0" ]
then
    links=""
else
    links=" ${linktemp}l"
fi
unset linktemp
let devicetemp=$(ls -l | grep "^[bc]" | wc -l | tr -d " ")
if [ "$devicetemp" -eq "0" ]
then
    devices=""
else
    devices=" ${devicetemp}bc"
fi
unset devicetemp

}

PROMPT_COMMAND=prompt_command

function pprom2 {

local        BLUE="\[\033[0;34m\]"
local  LIGHT_GRAY="\[\033[0;37m\]"
local LIGHT_GREEN="\[\033[1;32m\]"
local  LIGHT_BLUE="\[\033[1;34m\]"
local  LIGHT_CYAN="\[\033[1;36m\]"
local      YELLOW="\[\033[1;33m\]"
local       WHITE="\[\033[1;37m\]"
local         RED="\[\033[0;31m\]"
local   NO_COLOUR="\[\033[0m\]"

case $TERM in
    xterm*)
        TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        TITLEBAR=""
        ;;
esac

PS1="$TITLEBAR\
$BLUE[$RED\$(date +%H%M)$BLUE]\
$BLUE[$RED\u@\h$BLUE]\
$BLUE[\
$LIGHT_GRAY\${files}.\${hiddenfiles}-\
$LIGHT_GREEN\${executables}x \
$LIGHT_GRAY(\${TotalMeg}Mb) \
$LIGHT_BLUE\${directories}.\
\${hiddendirectories}d\
$LIGHT_CYAN\${links}\
$YELLOW\${devices}\
$BLUE]\
$BLUE[${WHITE}\${loaddiff}$BLUE]\
$BLUE[\
$WHITE\$(ps ax | wc -l | sed -e \"s: ::g\")proc\
$BLUE]\
\n\
$BLUE[$RED\$PWD$BLUE]\
$WHITE\$\
\
$NO_COLOUR "
PS2='> '
PS4='+ '
}

</code>

<sect1>Un Prompt Largo Quanto il Terminale

<p>
Un amico si &egrave; lamentato perch&eacute; non gli piaceva che il
prompt cambiasse continuamente di dimensione perch&eacute; c'era $PWD
all'interno, cos&igrave; ho scritto questo prompt che adatta la sua
dimensione all'esatta larghezza dal terminale.

<code>

#!/bin/bash

#   termwide prompt
#      Giles - creato il 2 novembre 98
#
#   Qui l'idea e` di avere la linea superiore di questo prompt di due 
#   linee sempre della larghezza del terminale. Questo viene fatto
#   calcolando la larghezza degli elementi di testo e riempendo come
#   appropriato o troncando a destra $PWD.
#

function prompt_command {

TERMWIDTH=${COLUMNS}

#   Calcola la larghezza del prompt:

hostnam=$(echo -n $HOSTNAME | sed -e "s/[\.].*//")
#   "whoami" e "pwd" includono un carattere "carriage return" finale
usernam=$(whoami)
let usersize=$(echo -n $usernam | wc -c | tr -d " ")
newPWD="${PWD}"
let pwdsize=$(echo -n ${newPWD} | wc -c | tr -d " ")
#   Aggiunge tutti gli accessori sotto ...
let promptsize=$(echo -n "--(${usernam}@${hostnam})---(${PWD})--" \
                 | wc -c | tr -d " ")
let fillsize=${TERMWIDTH}-${promptsize}
fill=""
while [ "$fillsize" -gt "0" ] 
do 
   fill="${fill}-"
   let fillsize=${fillsize}-1
done

if [ "$fillsize" -lt "0" ]
then
   let cut=3-${fillsize}
   sedvar=""
   while [ "$cut" -gt "0" ]
   do
      sedvar="${sedvar}."
      let cut=${cut}-1
   done
   newPWD="...$(echo -n $PWD | sed -e "s/\(^${sedvar}\)\(.*\)/\2/")"
fi
}

PROMPT_COMMAND=prompt_command

function termwide {

local GRAY="\[\033[1;30m\]"
local LIGHT_GRAY="\[\033[0;37m\]"
local WHITE="\[\033[1;37m\]"
local NO_COLOUR="\[\033[0m\]"

local LIGHT_BLUE="\[\033[1;34m\]"
local YELLOW="\[\033[1;33m\]"

case $TERM in
    xterm*)
        TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        TITLEBAR=""
        ;;
esac

PS1="$TITLEBAR\
$YELLOW-$LIGHT_BLUE-(\
$YELLOW\${usernam}$LIGHT_BLUE@$YELLOW\${hostnam}\
${LIGHT_BLUE})-${YELLOW}-\${fill}${LIGHT_BLUE}-(\
$YELLOW\${newPWD}\
$LIGHT_BLUE)-$YELLOW-\
\n\
$YELLOW-$LIGHT_BLUE-(\
$YELLOW\$(date +%H%M)$LIGHT_BLUE:$YELLOW\$(date \"+%a,%d %b %y\")\
$LIGHT_BLUE:$WHITE\$$LIGHT_BLUE)-\
$YELLOW-\
$NO_COLOUR " 

PS2="$LIGHT_BLUE-$YELLOW-$YELLOW-$NO_COLOUR "

}

</code>

<sect1>Il Prompt Orologio Inutile ed Elegante<label id="clock3">
<!-- Don't change this section title without changing the name= tag that
refers to it.  The pointer is in the section on cursor movement. -->

<p>
Questo &egrave; probabilmente il pi&ugrave; attraente (e inutile)
prompt che abbia mai creato. Poich&eacute; gli emulatori di terminale
non implementano il salvataggio e ripristino della posizione del
cursore, l'alternativa per mettere un orologio nell'angolo in alto a
destra e di ancorare il prompt nella parte inferiore del
terminale. Questo deriva dall'idea del prompt ampio quanto il
terminale di cui sopra, disegnando una linea nella parte destra dello
schermo dal prompt all'orologio. &Egrave; richiesto un font VGA.

<p>Nota: qui c'&egrave; una sostituzione strana, che potrebbe non
venir stampata correttamente quando viene convertita da SGML ad altri
formati: ho dovuto sostituire il carattere screen con \304 -
normalmente avrei introdotto solo la sequenza "\304", ma in questo
caso era necessario per fare questa sostituzione.

<code>

#!/bin/bash

#   Questo prompt richiede i font VGA. Il prompt e` ancorato in basso
#   al terminale, riempie la larghezza del terminale e disegna una linea
#   sul lato destro del terminale per collegarsi all'orologio
#   nell'angolo in alto a destra del terminale.

function prompt_command {
#   Calcola la larghezza del prompt:
hostnam=$(echo -n $HOSTNAME | sed -e "s/[\.].*//")
#   "whoami" e "pwd" includono il carattere "carriage return" finale
usernam=$(whoami)
newPWD="${PWD}"
#   Aggiunge tutti gli accessori sotto ...
let promptsize=$(echo -n "--(${usernam}@${hostnam})---(${PWD})-----" \
                 | wc -c | tr -d " ")
#   Trova quanto aggiungere fra user@host e PWD (o quanto rimuovere
#   da PWD)
let fillsize=${COLUMNS}-${promptsize}
fill=""
#   Riempie la linea se il prompt non e` largo quanto il terminale:
while [ "$fillsize" -gt "0" ] 
do 
   fill="${fill}Ä"
   # La A con la dieresi (apparira` come una lunga linea se state
   # usando un font VGA) e` \304, ma l'ho "tagliata" e poi "incollata"
   # perche' Bash farebbe solo una sostituzione - che in questo caso e`
   # mettere $fill nel prompt.
   let fillsize=${fillsize}-1
done
#   Tronca a destra PWD se il prompt e` piu` largo del terminale:
if [ "$fillsize" -lt "0" ]
then
   let cutt=3-${fillsize}
   sedvar=""
   while [ "$cutt" -gt "0" ]
   do
      sedvar="${sedvar}."
      let cutt=${cutt}-1
   done
   newPWD="...$(echo -n $PWD | sed -e "s/\(^${sedvar}\)\(.*\)/\2/")"
fi
#
#   Crea l'orologio e la barra lungo il lato destro del terminale
#
local LIGHT_BLUE="\033[1;34m"
local     YELLOW="\033[1;33m"
#   Posiziona il cursore per stampare l'orologio:
echo -en "\033[2;$((${COLUMNS}-9))H"
echo -en "$LIGHT_BLUE($YELLOW$(date +%H%M)$LIGHT_BLUE)\304$YELLOW\304\304\277"
local i=${LINES}
echo -en "\033[2;${COLUMNS}H"
#   Stampa linee verticali lungo il lato del terminale:
while [ $i -ge 4 ]
do
   echo -en "\033[$(($i-1));${COLUMNS}H\263"
   let i=$i-1
done

let prompt_line=${LINES}-1
#   Questo e` necessario perche' facendo \${LINES} all'interno di una
#   espressione matematica Bash (come $(())) sembra non funzionare.
}

PROMPT_COMMAND=prompt_command

function clock3 {
local LIGHT_BLUE="\[\033[1;34m\]"
local     YELLOW="\[\033[1;33m\]"
local      WHITE="\[\033[1;37m\]"
local LIGHT_GRAY="\[\033[0;37m\]"
local  NO_COLOUR="\[\033[0m\]"

case $TERM in
    xterm*)
        TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        TITLEBAR=""
        ;;
esac

PS1="$TITLEBAR\
\[\033[\${prompt_line};0H\]
$YELLOW\332$LIGHT_BLUE\304(\
$YELLOW\${usernam}$LIGHT_BLUE@$YELLOW\${hostnam}\
${LIGHT_BLUE})\304${YELLOW}\304\${fill}${LIGHT_BLUE}\304(\
$YELLOW\${newPWD}\
$LIGHT_BLUE)\304$YELLOW\304\304\304\331\
\n\
$YELLOW\300$LIGHT_BLUE\304(\
$YELLOW\$(date \"+%a,%d %b %y\")\
$LIGHT_BLUE:$WHITE\$$LIGHT_BLUE)\304\
$YELLOW\304\
$LIGHT_GRAY " 

PS2="$LIGHT_BLUE\304$YELLOW\304$YELLOW\304$NO_COLOUR "

}

</code>

</article>
