Le shell Bash et plus encore

1.1. Compilation

Avant de vous lancer dans un shell corrigé, vous devez savoir comment compiler depuis le source, étant donné que le correctif s'effectue par rapport à l'arborescence source. Voici les étapes nécessaires pour télécharger et compiler le shell standard Bash 3.0 :

wget ftp://ftp.gnu.org/pub/gnu/bash/bash-3.0.tar.gz
tar -xzf bash-3.0.tar.gz
cd bash-3.0
    ./configure
    make

On a maintenant un bash binaire exécutable qui est comme votre bash actuel, normalement /bin/bash . Vous pouvez l'essayer en saisissant :

./bash              # en utilisant un Bash-3.0 fraîchement compilé
date
ls
exit                # revient à votre session de shell antérieure

1.2. Création du correctif

Pour compiler mon shell corrigé, les étapes sont sensiblement les mêmes que précédemment. Téléchargez une archive tar (tarball), appliquez mon correctif dans l'arborescence source (à partir des étapes précédentes) et compilez. bashdiff.tar.gz pointera toujours sur le dernier correctif, qui est ici bashdiff-1.10.tar.gz.

wget http://home.eol.ca/~parkw/bashdiff/bashdiff-1.10.tar.gz
tar -xzf bashdiff-1.10.tar.gz
mv bash-3.0 bash            # ce n'est plus un Bash-3.0 standard
cd bash
    make distclean
    patch -p1 < ../bashdiff-core-1.10.diff
    patch -p1 < ../bashdiff-william-1.10.diff
    autoconf
    ./configure
    make
    make install            # en tant que root
    cd examples/loadables/william
        make
        make install        # en tant que root
        ldconfig            # en tant que root

Maintenant, vous avez :

• bash, qui est le shell principal exactement comme avant ; il sera installé dans /usr/local/bin/bash et

• william.so, qui est un objet partagé contenant des modules chargeables à la demande (loadables) ; il sera installé dans /usr/local/lib/libwilliam.so avec un lien symbolique vers /usr/local/lib/william.so. Dans la version 1.10, il y a 33 builtins   chargeables à la demande, à savoir :

  • Lsql

  • Msql

  • Psql

  • gdbm

  • xml

  • array

  • arraymap

  • arrayzip

  • arrayunzip

  • basp

  • match

  • vplot

  • pp_append

  • pp_collapse

  • pp_flip

  • pp_overwrite

  • pp_pop

  • pp_push

  • pp_rotateleft

  • pp_rotateright

  • pp_set

  • pp_sort

  • pp_swap

  • pp_transpose

  • sscanf

  • strcat

  • strcpy

  • strlen

  • strcmp

  • tonumber

  • tostring

  • chnumber

  • isnumber

1.3. Builtins dynamiquement chargeables

Si votre shell comporte enable -[fd], alors vous pouvez charger/décharger des commandes builtin dynamiquement, d'où le nom. La procédure est simple. Par exemple :

enable -f william.so vplot

chargera la commande vplot depuis la bibliothèque partagée william.so que vous venez de compiler et d'installer. Utilisez ./william.so si vous ne l'avez pas encore installée. Une fois chargée, vous pouvez l'utiliser exactement comme les builtins standard qui sont liées statiquement dans le shell. Donc :

help vplot
help -s vplot

affichera la version longue et courte du fichier d'aide de la commande, alors que :

vplot [-0 -x columns -y lines -X xtitle -Y ytitle] {xy | x y | x1 y1 x2 y2 ...}

et

x=( `seq -100 100` )
y=( `for i in ${x[*]}; do echo $((i*i)); done` )    # y = x^2
vplot x y

affichera le tracé x-y d'une parabole dans votre terminal. Pour la décharger, saisissez :

enable -d vplot

1.4. Tout-en-un

Les modules chargeables à la demande (loadables) sont pratiques si vous voulez juste charger les builtins dont vous avez besoin et si vous ne souhaitez ou ne pouvez pas changer votre shell de connexion. De plus, les modules chargeables sont plus faciles à compiler à partir d'une version précédente (incrémentiellement), ce qui est important puisque de nouveaux builtins sont ajoutés ou mis à jour plus souvent que le code d'analyse principal du shell.

Néanmoins, vous pouvez être amené à compiler et inclure le tout dans un seul exécutable, comme sous Windows par exemple. Pour compiler un fichier binaire « tout-en-un », vous devez saisir quelques lignes de code supplémentaires. Il faut générer le fichier binaire par défaut du bash, car nous avons besoin de tous les fichiers .h et .o.

cd bash
    make bash
    make bash+william       # tout en un
    make install-bin        # installe seulement 'bash', 'bashbug', 'bash+william'

Ici, bash+william est identique au bash, sauf que tous les builtins sont liés statiquement dedans. Je recommande le fichier binaire simple bash+william aux débutants, car il évite d'avoir à se rappeler de ce qu'il faut charger et décharger. Tout est là sous la main.

4.1. sscanf

Une des premières choses que l'on apprend dans tout langage est la lecture et l'affichage. En C, on utilise les fonctions printf(3), scanf(3) et autres définies dans <stdio.h>. Pour afficher dans le shell, on fait appel aux builtins echo et printf. Curieusement, pourtant, il manque une version shell de scanf(3). Par exemple, pour analyser les 4 nombres de 11.22.33.44, vous pouvez saisir :

IFS=. read a b c d <<< 11.22.33.44

Cependant, si votre champ n'est pas aussi bien délimité que ci-dessus, les choses se compliquent.

J'ai ajouté la version shell de la fonction C sscanf(3) :

• sscanf input format var1 [... var9]

Du fait que le shell n'a que des données de type chaînes de caractères, il ne prend en charge que des formats de chaînes, c'est-à-dire %s, %c, %[...], %[^...] et jusqu'à 9 variables. Donc, vous pouvez analyser des chaînes formatées tout comme vous le feriez en C, par exemple :

sscanf 11.22.33.44 '%[0-9].%[0-9].%[0-9].%[0-9]' a b c d
declare -p a b c d          # a=11 b=22 c=33 d=44

sscanf 'abc 123 45xy' '%s %s %[0-9]%[a-z]' a b c d
declare -p a b c d          # a=abc b=123 c=45 d=xy

4.2. Lecture et affichage de lignes DOS

De temps en temps, il est nécessaire d'afficher et de lire des lignes DOS qui se terminent par \r\n (CR/NL). Bien que vous puissiez afficher \r explicitement, l'insertion automatique de \r juste devant \n est difficile à réaliser en shell. Pour la lecture, vous devez explicitement supprimer le \r de fin.

J'ai créé un correctif des builtins standard echo et read   pour qu'ils puissent lire et écrire des lignes DOS :

• echo [-....] -D [arg ...]

• read [-...] -D [nom ...]

Par exemple :

echo abc | od -c                    # a b c \n
echo -D abc | od -c                 # a b c \r \n

read a b <<< $'11 22 \r'            # a=11 b=$'22 \r'
read -D a b <<< $'11 22 \r'         # a=11 b=22

4.3. Émulation simple de Awk

Souvent, il est nécessaire d'analyser des lignes et de travailler avec des variables de type Awk comme NF, NR, $1, $2, ..., $NF. Cependant, quand vous utilisez Awk, il est difficile de ramener ces variables dans le shell ; vous devez les écrir en syntaxe shell dans un fichier temporaire pour ensuite le reprendre. Cela rend fastidieux de faire des allers-retours entre le shell et Awk.

J'ai créé un correctif du builtin standard read pour offrir une émulation simple de Awk, en créant les variables NF et NR, et en affectant les champs à $1, $2, ..., $NF.

• read [-...] -A [nom ...]

Par exemple :

IFS=. read -A <<< 11.22.33.44
echo $#: $*                 # 4: 11 22 33 44
declare -p NF NR

En outre, comme dans Awk, chaque appel pour lire -A incrémentera NR.

4.4. Indentation dans << here-document

<< est l'opérateur de redirection d'entrée, où l'entrée standard est tirée du texte même du source du script. << conservera les espaces blancs de début et <<- supprimera toutes les tabulations de début. Le problème avec <<- est que l'indentation relative est perdue.

J'ai ajouté un nouvel opérateur <<+ qui conserve l'indentation par tabulation du here-document par rapport à la première ligne. Il est accessible directement via le shell (c'est-à-dire ./bash ou /usr/local/bin/bash), parce que le correctif est intégré dans le code d'analyse syntaxique principal. Donc :

cat <<+ EOF
        first line
        second line
EOF

affichera

first line
        second line

5.1. Séquence d'entiers {a..b}

Bash 3..0 (et Zsh) comportent l'expression {a..b} qui génère une séquence d'entiers en tant qu'élément de l'expansion d'accolades, mais on ne peut pas utiliser la substitution de variables car l'expression {a..b} doit contenir explicitement des entiers.

Mon correctif étend l'expansion d'accolades de façon à inclure la substitution de variables, de paramètres et de tableaux, de même qu'un générateur de séquences de lettres uniques. Par exemple ;:

a=1 b=10 x=a y=b
    echo {1..10}
    echo {a..b}
    echo {!x..!y}           # utiliser 'set +H' pour supprimer l'expansion de !
set -- `seq 10`
    echo {**}
    echo {##}
    echo {1..#}
z=( `seq 10` )
    echo {^z}

donneront toutes le même résultat, c'est-à-dire 1 2 ... 10. D'autres détails sont disponibles dbayes_token (id, token, spam_count, ham_count, atime) VALUES ('1',' «Ôä[','0','1','1224827012') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827012')¶`
I
¾
,žjE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) VALUES ('1','_š)','0','1','1224827014') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827014')¶`
I
¾
êžfE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) VALUES ('1','­Btj6','0','1','1224827010') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827010')¶`
I
¾
¨žiE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) VALUES ('1','¨4•H','0','1','1224827012') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827012')¶`
I
¾
fžfE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) VALUES ('1','&P¤¼Í','0','1','1224827010') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827010')¶`
I
¾
$žjE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) VALUES ('1',';,`Œ7','0','1','1224827014') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827014')¶`
I
¾
âžiE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) VALUES ('1','šÔÊ4ÿ','0','1','1224827012') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827012')¶`
I
¾
 žfE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) VALUES ('1','õ’&â}','0','1','1224827010') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827010')¶`
I
¾
^žjE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) VALUES ('1','QöÔ^','0','1','1224827014') ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + '0', 0), ham_count = GREATEST(ham_count + '1', 0), atime = GREATEST(atime, '1224827014')¶`
I
¾
!žiE @
stdpourrielsINSERT INTO bayes_token (id, token, spam_count, ham_count, atime) ="literal" >?, alors la chaîne originelle est incluse dans l'expansion de paramètres uniquement si command var renvoie success (0). Si tel n'est pas le cas, alors elle est supprimée de l'expansion. Le contenu reste inchangé mais pouvez décider de l'inclure ou non. Par conséquent, ${var|?true} sera équivalent à ${var}, puisque true renvoie toujours success (0). Par exemple :

b=( `date` )
func () { [[ $1 == [A-Z]* ]]; }
echo ${b[*]|?func}          # seulement des mots en majuscules

set -- `date`
func () { [[ $1 == *[!0-9]* ]]; }
echo ${*|?func}             # seulement des caractères autres que des nombres

b=( `date` )
echo ${b[*]|=[A-Z]*}        # seulement des mots en majuscules

set -- `date`
echo ${*|=*[!0-9]*}         # seulement des caractères autres que des nombres

a=0123456789
echo ${a|::3} ${a|:-3:} ${a|:1:-1}          # 012 789 12345678

set -- {a--z}
echo ${*|::3} ${*|:-3:} ${*|:1:-1}

a=abc123
echo ${a|*3}                # 3 fois

set -- a b c
echo ${*|*2+3}              # 5 fois

7. Instruction case

case WORD in
    glob [| glob]...) COMMANDS ;;
        ...
esac

case WORD in
    glob [| glob]...) COMMANDS ;;
    regex [| regex]...)) COMMANDS ;;
    ...
esac

case .abc123. in
    '([a-z]+)([0-9]+)' )) echo yes ;;
esac
declare -p SUBMATCH

case WORD in
   motif1) commande1 ;;&
   motif2) commande2 ;;
    ...
easc

case WORD in
   motif1) commande1 ;;&
   motif2) commande2 ;;
    ...
easc

case ... in             case ... in             case ... in
    ...                     ...                     ...
esac then               esac then               esac else
    COMMANDS                COMMANDS                COMMANDS
else                    fi                      fi
    COMMANDS
fi

case abc123 in
    [A-Z]*) echo matched ;;
esac then
    echo yes
else
    echo no         # pas de correspondance
fi

case Xabc123 in
    [A-Z]*) echo matched ;;         # correspondance
esac then
    echo yes                        # correspondance
else
    echo no
fi

8. Les boucles for/while/until

for a,b,c in {1..10}; do
    echo $a $b $c
done

1 2 3
4 5 6
7 8 9
10

[for|while|until] ...; do       [for|while|until] ...; do       [for|while|until] ...; do
    ...                             ...                             ...
done then                       done then                       done else
    COMMANDS                        COMMANDS                        COMMANDS
else                            fi                              fi
    COMMANDS
fi

for i in 1 2 3; do
    echo $i
    break
done then
    echo normal
else
    echo used break         # 1 
fi

for i in 1 2 3; do
    echo $i
done then
    echo normal             # 1 2 3
else
    echo used break
fi

9. Exception et bloc try

En pratique, tous les langages modernes ont la capacité de lever une exception pour sortir d'un code très imbriqué, traiter les erreurs ou faire des sauts multipoint. J'ai ajouté un nouveau bloc try au Bash qui saisira les exceptions levées par le nouveau builtin raise.

• raise [n]

• try

  COMMANDS done in NUMBER [| NUMBER].... ) COMMANDS ;; ... esac

  où done in ne peut pas être séparé par ; ou par un retour à la ligne. En outre, la liste de motif, dans l'instruction de type « instruction case », doit être explicitement un nombre entier.

Ceci combine les éléments des boucles, le builtin de sortie et l'instruction cas. À l'intérieur d'un bloc try, le builtin raise peut être utilisé pour lever une exception sur un entier. L'exécution sortie ensuite du bloc try, exactement comme pour quitter les boucles for/until/while. On peut utiliser une instruction de type case pour prendre capturer l'exception. Si l'exception est capturée, alors elle est réinitialisée et l'exécution continue en suivant le bloc try. Si l'exception n'est pas capturée, alors l'exécution repart jusqu'à ce qu'elle soit capturée ou jusqu'à ce qu'il n'y ait plus de blocs try.

Par exemple :

try
    echo a
        while true; do  # infinite loop
            echo aa
            raise
            echo bb
        done
        echo b
    done

affichera a aa et

    try
        echo a
        raise 2
        echo b
    done in
        0) echo normal ;;
        1) echo raised one ;;
        2) echo raised two ;;   # raise 2
    esac

affichera a et l'exception sera 2.

10. Récapitulatif

Dans le prochain article, j'aborderai les builtins dynamiquement chargeables liés aux tableaux, le découpage des expressions régulières, l'interfaçage avec des bibliothèques externes comme une base de données SQL et un analyseur syntaxique XML et je traiterai aussi d'autres applications intéressantes comme les modèles (templates) HTML et d'un système de blocage de spam POP3.

J'ai appris Unix avec le shell Bourne originel. Et, après une expédition dans la jungle des langages, je suis revenu au shell. Dernièrement, j'ai contribué à de nouvelles fonctionnalités de Bash, rendant la monnaie de leur pièce aux autres langages de scriptage. Slackware est ma distribution favorite depuis le début, parce que je peux saisir au clavier. Dans ma boite à outils, j'ai Vim, Bash, Mutt, Tin, Tex/Latex, Python, Awk et Sed. Même ma ligne de commande est en mode Vi.