Csh & TCsh

Le shell est un interpréteur de commande en ligne. Chaque entrée sur un terminal est analysée et décomposée en terme d'instructions à exécuter. Ces instructions peuvent impliquer des commandes internes que le shell connaît et est en mesure d'exécuter directement, ou bien d'autres commandes déclenchant des programmes que le shell va tenter de localiser et de lancer. Le shell dispose d'instructions (structures de contrôle, ...) et de variables qui le rende en partie comparable à un langage de programmation, de sorte que l'on peut écrire des shell scripts, littérallement de petits ou moyens programmes rédigé en shell.

Un interpréteur shell exécutent trois types de commandes :

Lors du login, csh exécute les instructions contenues dans le fichier /etc/csh.cshrc puis celles du fichier /etc/csh.login puis celles de ~/.cshrc (tcsh lit le script ~/.tcshrc, s'il existe et sinon ~/.cshrc) et enfin celles de ~/.login. La signification du caractère ~ est donnée en Section 1.5, « Métacaractères et autres caractères spéciaux du shell ». Lors de la fin de session (logout) csh ou tcsh exécutent les commandes des fichiers /etc/csh.logout et ~/.logout, dans cet ordre.

Un sous-shell, ne lit pas les fichiers suffixés en .login à son démarrage ni les fichiers suffixés en .logout à sa terminaison.

De ce qui précède, on déduit que les commandes à exécuter une seule fois pendant une session sont à placer dans les fichiers suffixés en .login (typiquement les variables d'environnement), tandis que les autres sont à placer dans les fichiers suffixés en .cshrc.

Le fichier ~/.cshrc contient typiquement :

# ~/.cshrc
#
# $FreeBSD: src/share/skel/dot.cshrc,v 1.10.2.3 2001/08/01 17:15:46 obrien Exp $#
# .cshrc - csh resource script, read at beginning of execution by each shell
# see also csh(1), environ(7).
#

# Les alias
# -------------------------
alias j         jobs -l
alias la        /bin/ls -aoBG
alias lf        /bin/ls -FABG
alias ll        /bin/ls -loABG
alias gv        /usr/X11R6/bin/gv -color -safer -quiet \ 
-media a4 -portrait
alias rm        /bin/rm -i
alias wget      `which wget` -N -c -S
alias emacs     `which emacs` -q
alias gnuplot   `which gnuplot` -background ivory
alias xdvi      `which xdvi` -fg DarkSlateGray  -paper a4 
alias xfig      `which xfig` -center -centim -pap a4 -po
alias dvips     `which dvips` -t a4 -o out.ps
alias h         'history -r \!* | less'
alias psnup     `which psnup` -pa4 -2up -m0.5cm

# Paramètres et variables.
# -------------------------
limit coredumpsize 0  # prevent core files from being written to disc
# A righteous umask
umask 077
set prompt='%B%n%b@%m:%c > '
set prompt2='%B%n%b:>> '
set path = (/usr/local/sbin /usr/local/bin /sbin /bin /usr/sbin \
/usr/bin /usr/X11R6/bin $HOME/bin)
set correct = cmd

/usr/X11R6/bin/xrdb -load ~/.Xdefaults >& /dev/null

if ($?prompt) then
        # An interactive shell -- set some stuff up
        set filec
        set history = 2048
        set savehist = 2048
        set histfile = ~/.history
        set mail = (/var/mail/$USER)
        set notify      
        set addsuffix
        set autolist
        set machbeep = nomatch
        set cdpath = ( ~ ~/bin )
        set symlinks = ignore
        if ( $?tcsh ) then
                set echo_style = both
                set histdup = all
                set savehist = ( 2000 merge )
                bindkey "^W" backward-delete-word
                bindkey -k up history-search-backward
                bindkey -k down history-search-forward
                source ~/.tcsh_comp
        endif
endif

Le fichier ~/.login contient essentiellement la définition des variables d'environnement.

# ~/.login                                                                      

setenv LC_CTYPE fr_FR.ISO8859-15
setenv PAGER less
setenv MOZILLA_HOME /usr/X11R6/bin/mozilla
setenv MACHTYPE i386
setenv EDITOR emacs
setenv HOSTTYPE FreeBSD
setenv CPUTYPE k7
setenv OSTYPE FreeBSD
setenv TEXEDIT emacs
setenv VENDOR amd
setenv SHLVL 1
setenv LSCOLORS "ExFxbxcxBxdxHBhbafacad" 
setenv CLICOLOR 1
setenv CLICOLOR_FORCE 1

# COLORTERM to "rxvt"
setenv COLORTERM "rxvt"

# COLORFGBG to "default" 
setenv COLORFGBG "default" 

setenv RSYNC_RSH /usr/bin/ssh
setenv CVSROOT /home/cvsroot
setenv BLOCKSIZE       K
setenv TERM xterm-color

[ -x /usr/games/fortune ] && /usr/games/fortune freebsd-tips

Le fichier ~/.logout contient essentiellement des commandes de suppression de fichiers inutiles.

# ~/.logout                                                                     

echo -n "clean up before logout ..."
find $HOME \( -type f \
              \( -name a.out -o -name "*.bak" -o -name core  -o \
                 -name "#*#" -o -name "#.*#"  -o -name "*.o" -o \
                 -name "*~"  -o -name ".*~" \) -exec /bin/rm -f {} \; > /dev/nul
l \)
echo "... done" 
echo "last connexion at [`date +%Y-%M-%d` a `date +%H:%I:%S`] pour [`logname`] s
ur [`tty`]" > ~/.deconnex

Il est possible à tout moment et notamment après une modification de réexécuter les fichiers au moyen de la commande source.

$ > source ~/.login                                                             
$ > source ~/.cshrc

On parle de variables d'environnement car elles sont « automatiquement » transmises à tous les processus fils du shell, i.e. tous les processus lancés par ce shell.

Les variables qui suivent ont un sens particulier pour le shell (csh et tcsh), elles sont utilisées par certaines commandes du shell ou du système. Parmi elles, argv, cwd, home, path, prompt, shell et status sont toujours définies par le shell. Si l'on exclut les variables cwd et status, leur positionnement intervient seulement à l'initialisation. Ces variables ne sont plus modifiées, sauf éventuellement par l'utilisateur.

Relations entre variables du shell et les variables d'environnement. En csh comme en tcsh certaines variables du shell et des variables d'environnement sont maintenues à des valeurs identiques par le shell. Ce sont les variables user et USER, group et GROUP, home et HOME, term et TERM, path et PATH, et enfin shlvl et SHLVL.

Les métacaractères jouent le rôle de classe de représentation des fichiers dans le contexte du répertoire courant si rien n'est précisé ou bien dans celui du répertoire explicitement nommé.

Cette commande exécute le fichier (et ces éventuels arguments) qui lui est passé en argument dans le shell courant (i.e. pas de fork et donc modification (éventuelle) du shell courant).

$ source ~/.login                                                               

La commande setenv permet d'initialiser une variable d'environnement, i.e. une variable qui sera transmise à tous les processus fils du shell.

setenv OSTYPE  FreeBSD                                                          
setenv CPUTYPE k7
setenv PAGER   less

La commande unsetenv permet de supprimer une variable d'environnement.

La commande set a deux fonctions :

$ set path=( $path ~/bin )                                                      

Cette déclaration permet d'enrichir la variable path du répertoire bin de l'utilisateur.

$ set ignoreeof                                                                 

Cette option permet d'immuniser csh d'une destruction accidentelle. Il est normalement possible de clôre un terminal avec la séquence ^D (lire <CTRL>-D), mais si on positionne l'option ignoreeof la séquence précédente n'a plus d'effet.

La commande unset a évidement un effet symétrique. Elle permet donc de désarmer une option ou de supprimer une variable.

Ce mécanisme permet de définir ou de redéfinir une commande. Exemple :

$ alias la /bin/ls -aoBG          # definition de l'alias la                    
$ alias rm /bin/rm -i             # definition de l'alias rm
$ alias                           # afficher les alias courants
la      (/bin/ls -aoBG)
rm      (/bin/rm -i)

En général, on place ces alias dans le fichier ~/.cshrc. Si on veut supprimer un alias on utilise la commande unalias comme suit :

$ unalias rm                                                                    
$ alias                                # afficher les alias courants
la      (/bin/ls -aoBG)

Pour ré-accéder à la commande masquée par son alias, comme dans l'exemple précédent où nous avons surchargé la commande classique rm, il suffit de :

Cette commande permet de spécifier (si elle est suivie d'un argument valide) ou d'afficher la valeur du masque de création des objets i.e. des fichiers.

$ umask  # affiche la valeur telle que prédéfinie dans ~/.cshrc                 
77       # autrement dir 0077   
$ umask 0027
$ umask
27       # autrement dit 0027

Ce mécanisme a pour rôle de mémoriser les n dernières commandes entrées, ce nombre étant un paramètre réglable. Cela permet de visualiser, d'éditer et/ou exécuter à nouveau les commandes mémorisées. La commande suivante permet d'activer l'historisation des commandes, elle signifie que les 512 dernières commandes seront mémorisées :

$ set history = 512                                                             

La commande suivante permet en plus de sauvegarder les m dernières commandes dans ~/.history au logout. Il est évident que m est au plus égale à n. Ici, nous ne retenons que les 256 dernières commandes :

$ set savehist = 256                                                            

La commande history permet d'afficher les commandes dans l'ordre de leur mémorisation.

 

$ history                                                                       
...
80  8:57    cp csh/Makefile Makefile.gen
81  9:03    more Makefile.gen
82  9:06    sed -e 's/SRCNAME=C-csh_n_tcsh/SRCNAME=/' Makefile.gen > Makefile   
83  9:07    xemacs createinf.sh
84  9:09    which mkdir
85  9:09    rm -rf html/ && make check && make html
86  9:10    ls -l csh/
87  9:12    echo $$

Pour relancer une commande, il suffit de l'appeler par son numéro (relativement à l'historique) en la préfixant par le caractère !. Par exemple, si on veut relancer la commande 84, il suffit de faire :

$ !84                                                                           
which mkdir
/bin/mkdir

Pour terminer, il peut être intéressant de positionner l'alias suivant dans son ~/.cshrc.

alias h         'history -r \!* | less'                                         

En csh la completion est activée par le positionnement de la variable d'environnement filec (c.f. « Section 1.4, « Variables prédéfinies et d'environnement » »). Ce mécanisme permet, selon le contexte, de compléter les noms de fichiers ou d'utilisateurs à partir de la saisie d'un préfixe suivi de la frappe du caractère « ESC ». Le contexte par défaut étant celui de fichiers.

Supposons, par exemple, que le contenu du répertoire courant soit le suivant :

_merge.pl       check.pl             fdate.sh             mytest.pl
_pidof.pl       crlf.pl              gen-meta-index.pl    replace_header_html.pl
_split.pl       extract.pl           idle.pl              rotate.pl
_test.pl        extract_piste.sh     logfile-1.2.pl       rsync.pl
bidir.pl        fcomp.sh             mylock.sh

Alors la séquence suivante : $ ls l<ESC> est résolue en (seule correspondance possible) : $ ls logfile-1.2.pl

Tandis que la séquence ci-contre : $ ls ext<ESC> est résolue partiellement en : $ ls extract suivit de l'émission d'un bip qui signale que cette expansion est incomplète puisque deux fichiers correspondent au préfixe saisi. La commande précédente suivie du <CTRL>-D permet d'obtenir l'ensemble des réponses potentielles :

$ ls extract<CTRL>-D                                                            
extract.pl*       extract_piste.sh*
$ ls extract

La saisie d'un seul caractère supplémentaire permet dans ce dernier cas de lever l'ambiguïté.

L'utilisation du bip (sonnerie du terminal) pour signaler des erreurs ou des correspondances potentielles peut être désactivée par le positionnement de la variable nobeep. Enfin, il est possible de limiter les correspondances potentielles à la completion en positionnant la variable fignore. Dans l'exemple suivant, on exclut des correspondances possibles les fichiers suffixés en .o, .out et *~.

$ set fignore = (.o .out *~)                                                    

Contexte utilisateur : le mécanisme de completion peut être utilisé pour compléter les noms d'utilisateurs. Il faut utiliser le préfixe ~ (il change le contexte de la completion) :

$ cd ~sys<ESC>                                                                   
$ cd ~sysop

Rapellons que, sous Unix™ en général et sous BSD en particulier, il existe trois canaux d'E/S standard :

Formellement, un descripteur de fichier est un entier non signé utilisé par les processus pour référencer les canaux d'E/S.

La puissance et la flexibilité du concept des canaux standards d'E/S tient essentiellement au fait que le shell peut rediriger ces canaux aussi bien sur des fichiers, que l'écran ou le clavier.

Le positionnement de la variable interne noclobber, permet d'éviter l'écrasement des fichiers existants dans le cas de l'utilisation des commandes de redirection > et >&. De plus les commandes >> et >>& ne peuvent être exécutées que sur des fichiers existants.

Enfin, la sémantique initiale des commandes de redirection (après activation de noclobber) peut être explicitement restituée en utilisant le symbole !. Ainsi, les commandes >!, >>!, >&! et >>&! ont un comportement identique à leurs homologues du tableau précédent (i.e. sans le !, c.f. « Tableau 7, « Redirections » »).

EXEMPLES :

$ cat > file.txt << fin_de_saisie                                               
>> première ligne
>> puis une 2e
>> Encore une autre !
>> C'est pas fini ...
>> fin_de_saisie

$  ll file.txt
-rw-------  1 pascal  gnu  - 65 Aug 1 15:58 file.txt

$ cat < file.txt  # équivalent à cat file.txt
première ligne
puis une 2e
Encore une autre !
C'est pas fini ...

$ ( find /home -name "*~" -print > fout ) >& ferr
                  # séparer les sorties standard (> fout) et d'erreur (>& ferr) 
$ cat fout        # les résultats
/home/pascal/enseignement/NeoTechIII/V2L-PRAI/CS2-csh/toto.sh~
/home/pascal/enseignement/NeoTechIII/V2L-PRAI/Progr-V2L/Progr-V2L.xml~
/home/miji/work/these/annexes/annexes.sxw~
/home/miji/work/these/partie1/part_legende/legendes.sxw~
/home/hosts/corto-home/turing/postfix/main.cf~
/home/hosts/corto-home/euler/ulocal-etc/flexbackup/flexbackup.conf~
/home/hosts/corto-home/euler/ulocal-etc/tripwire/twpol.txt~
/home/hosts/corto-home/euler/etc/ssh/sshd_config~
/home/hosts/corto-home/tux/etc/apache/httpd.conf~
/home/hosts/corto-home/tux/etc/apache-ssl/httpd.conf~

$ cat ferr        # les erreurs
find: /home/miji/.ssh: Permission denied
find: /home/miji/work/lit_reu/Dayot: Permission denied
find: /home/miji/Choices: Permission denied
find: /home/miji/pdf: Permission denied
find: /home/miji/tmp: Permission denied
find: /home/miji/.Eterm: Permission denied
find: /home/miji/.mozilla: Permission denied
find: /home/miji/.mutt: Permission denied
find: /home/miji/.netscape: Permission denied
find: /home/miji/.prefs: Permission denied
find: /home/miji/.vnc: Permission denied
find: /home/miji/.Gabber: Permission denied
find: /home/miji/.wmakerconf: Permission denied

Le mécanisme de pipeline consiste à rediriger la sortie d'une commande vers l'entrée d'une autre. D'un point de vue syntaxique nous avons la structure suivante :

<commandA> | <commandB>                                                         

$ ls -l | sort -k 5n                                                            

Enfin, en postfixant au tube ('|' ou encore pipe) l'ampersand (&), il est possible de combiner les sorties standard et d'erreur vers l'entrée de la commande qui suit (le tube).

<commandA> |& <commandB>                                                        

Ce sont les variables que les utilisateurs peuvent définir. Le shell étant un langage interprété non typé, aucune déclaration n'est nécessaire et la même variable peut contenir tour à tour une chaîne de caractères, un entier, ou un vecteur (tableau d'éléments de type chaîne de caractères ou entier, indexé par des entiers, commençant à 1).

Affectation. Cette opération permet d'associer un contenu à une variable (le contenant). En csh comme en tcsh, l'affectation se fait en utilisant la commande interne set de la manière suivante :

EXEMPLE :

$ set myvar1 = 10                                                               
$ set myvar2 = "chaine de caractère"
$ 

Accès au contenu. L'accès au contenu de la variable se fait en préfixant le nom de la variable par le symbole $.

EXEMPLE (SUITE) :

$ echo $myvar1                                                                  
10
$ echo $myvar2
chaine de caractère

$ echo myvar1     # omission du méta-caractère $
myvar1            # echo affiche le mot myvar1

On peut aussi encadrer la variable par les symboles { et } avant de la préfixer par le symbole $ :

EXEMPLE (SUITE) :

$ set si  = "pas "                                                              
$ echo "c'est vraiment $sidrôle"
sidrôle: Undefined variable.   # le $ porte ici sur le mot sidrôle et non sur si
$ echo "c'est vraiment ${si}drôle"
c'est vraiment pas drôle
$

Effacer une variable. Cette opération permet de libérer la case mémoire occupée par la variable. Cela se fait en csh comme en tcsh, en utilisant la commande interne unset de la manière suivante :

EXEMPLE (SUITE) :

$ echo $myvar1                                                                  
10
$ unset myvar1
$ echo $myvar1
myvar1: Undefined variable.
$ 

Variable de type vecteur. Voici un exemple :

CODE :


#!/bin/csh
# ~/bin/testvect.sh

set vect = ( 2 -2 4 -4 6 -6 8 -8 10 -10 ) 

# afficher les elements du vecteur vect, element par element                    
set i = 1
set sum = 0
echo " -  Affichage element par element"
while ( $i <= ${#vect} )
    echo '$vect[' $i '] = ' $vect[$i]
    @ sum = $sum + $vect[$i]
    @ i++
end

echo " - Somme des elements = " $sum

# acc賠par tranche
set j = 5
echo "Voici le vecteur vect (${#vect} elements)         : " $vect[1-]
echo "Voici les $j premiers elements du vecteur    : " $vect[-$j]
echo "Voici les derniers elements ࠰artir du $j e : " $vect[$j-]

# fin du script


EXEMPLE :

$ ./testvect.sh                                                                 
 -  Affichage élément par élément
$vect[ 1 ] =  2
$vect[ 2 ] =  -2
$vect[ 3 ] =  4
$vect[ 4 ] =  -4
$vect[ 5 ] =  6
$vect[ 6 ] =  -6
$vect[ 7 ] =  8
$vect[ 8 ] =  -8
$vect[ 9 ] =  10
$vect[ 10 ] =  -10
 - Somme des elements =  0
Voici le vecteur vect (10 éléments)         :  2 -2 4 -4 6 -6 8 -8 10 -10
Voici les 5 premiers éléments du vecteur    :  2 -2 4 -4 6
Voici les derniers éléments à partir du 5 e :  6 -6 8 -8 10 -10

$

Modificateurs de variables. Les modificateurs [modifiers] suivants peuvent être appliqués aux variables. On travaillera avec l'exemple (un vecteur) suivant :

$ set mypath = ( /usr/local/src/foo.c /usr/src/bar.cc )   # un vecteur de path  

$ echo $mypath:h                    
/usr/local/src /usr/src/bar.cc
$ echo $mypath:gh
/usr/local/src /usr/src

$ echo $mypath:t                    
foo.c /usr/src/bar.cc
$ echo $mypath:gt
foo.c bar.cc

$ echo $mypath:r
/usr/local/src/foo /usr/src/bar.cc  
$ echo $mypath:gr
/usr/local/src/foo /usr/src/bar

$ echo $mypath:e                    
c /usr/src/bar.cc
$ echo $mypath:ge
c cc

Mécanismes de substitution. 

$ set v = toto
$ echo ${?v}   # renvoit 1 puisque la variable v est définie        
1
$ echo $u
u: Undefined variable.
$ echo ${?u}   # moyen commode pour savoir si une variable est définie          
0 

Le shell définit pour chaque commande un certain nombre de paramètres « automatiques ».

CODE :

#!/bin/csh
# ~/bin/testparm.sh

echo 'je suis le script, $0 = ' $0

if ( ${#argv} > 0 ) then
    echo ' évoqué avec $# (= $#argv = ${#argv}) = ' ${#argv}  ' arguments sur la
 ligne de commande'
    echo 'Voici les paramètres : $* (= $argv[*] = ${argv[*]}) = ' ${argv[*]}
    set i = 1
    foreach param ( $argv[*] ) 
       écho "paramètres ($i) :  $param"
       @ i++
    end
else
    echo ' pas d arguments, nb arg $# (= $#argv = ${#argv}) = ' ${#argv}
endif

# fin du script


EXEMPLE :

$ ./testparam.sh toto titi tutu 147
je suis le script, $0 =  ./testparam.sh
 évoqué avec $# (= $#argv = ${#argv}) =  4  arguments sur la ligne de commande  
Voici les paramètres : $* (= $argv[*]) =  toto titi tutu 147
paramètre (1) :  toto
paramètre (2) :  titi
paramètre (3) :  tutu
paramètre (4) :  147
$
$ ./testparam.sh
je suis le script, $0 =  ./testparam.sh
 pas d arguments, nb arg $# (= $#argv = ${#argv}) =  0
$

Elle se fait en utilisant la variable spéciale $<

CODE :

#!/bin/csh
# ~/bin/testread.sh                                                             

echo -n " Votre réponse (o, n) ? "
set rep = $<

if ( $rep == o ) then 
   echo "réponse oui"
else
   echo autre réponse : $rep
endif


EXEMPLE :

$ ./testread.sh
Votre réponse (o, n) ? yes
autre réponse : yes

$ ./testread.sh
 Votre réponse (o, n) ? o
réponse oui

Règles :

La commande interne @ permet de réaliser des opérations arithmétiques sur des valeurs ou variables entières, attention à respecter l'espace entre le symbole @ et la variable.

$ set v = 3
$ set u = 8
$ set p = 5
$ @ x = $v + $u * $p   # attention à la priorité des opérateurs                 
$ echo $x
43
$ @ x = ( $v + $u ) * $p
55

$ @ q = $u / $p        # division entière
$ @ r = $u % $p
$ echo quotient = $q et reste = $r
quotient = 1 et reste = 3

$ @ v++                # incrémentation d'une unité
$ echo $v
4

$ @ v += 2             # incrémentation de deux unités
$ echo $v
6

$ @ u /= 2             # @ u = u / 2
$ echo $u
4

$ @ u = ( $u <<  3 )   # décalage à gauche de 3 bits, ce qui revient à une x 8  
$ echo $u
32

$ @ v = (( $v + 4 ) >> 2 ) # 10 décaler de 2 bits à droite, soit 10 / 4 = 2
$ echo $v
2

Sous tcsh le mécanisme de completion des noms a été amélioré. Ce shell peut compléter les noms des fichiers, des commandes et des variables. De plus la completion des noms de fichiers est programmable !

La completion est déclenchable par la touche <TAB>, bien que par compatibilité ascendante avec csh, la touche <ESC> reste opérationnelle.

Contexte de variables : Il faut utiliser le préfixe $ (il change le contexte de la completion) :

$ set varia_1=10                                                                
$ echo $var<TAB>
$ echo $varia_1 <ENTREE>
10

Cette commande permet l'édition des commandes en ligne dans un buffer au moyen des contrôles associés aux éditeurs classiques d'Unix, à savoir vi ou emacs. Utilisée seule, elle retourne la liste des associations clés/commandes.

Le positionnement par défaut est souvent le mode emacs, il est déterminé à la compilation. La variable version permet de connaître la version de la commande ainsi que les options de compilation. Dans l'exemple suivant, l'absence de la clé vi, permet d'affirmer que le mode par défaut est emacs.

$ echo $version
tcsh 6.12.00 (Astron) 2002-07-23 (i386-intel-FreeBSD) options 8b,nls,dl,al,kan,s
m,rh,color,dspm,filec

Cette commande permet aussi de commuter entre le mode vi et le mode emacs.

$ bindkey -e   # mode emacs                                                     
$ bindkey -v   # mode vi

Dans le tableau suivant, nous présentons un sous-ensemble des commandes d'édition :

Ce mécanisme est déclenché en postionnant la variable (interne) tcsh correct (valeurs possibles cmd ou all) :

$ set correct = cmd
$ lzss test.csh                          # ooops typo !

CORRECT>less test.csh  (y|n|e|a)? yes    # frappe de la touche y ou <ESPACE>    
#!/bin/csh                               # lecture et affichage du fichier

echo '\nJe suis le programme $0   : ' $0
...