On Sun, 8 Dec 2002 05:10:00 +0100
nono <[EMAIL PROTECTED]> wrote:
> Why not !!!
oki :)
le script:
#######################################################################
#!/bin/bash
#bacon
#jipe-2002
help ()
{
echo " #################+Aide+Pour+Bacon+#################"
echo " # � l'invite > entrer un nombre et une base #"
echo " # - exemples: > 1954 2 ou > 2#1011001 8 #"
echo " # format du nombre: base#nombre #"
echo " # cas particuliers: #"
echo " # - base 8: 8#nombre ou 0nombre #"
echo " # - base 10: 10#nombre ou nombre #"
echo " # - base 16: 16#nombre ou 0xnombre #"
echo " # nombres accept�s: entiers positifs #"
echo " # - les nombres doivent �tre valides pour la base #"
echo " # - 2#1201 ou 8#2581 sont invalides #"
echo " # bases accept�es: de 2 � 64 #"
echo " # pour sortir taper exit #"
echo " ###################################################"
}
c=0
for i in 0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z A B C
D E F G H I J K L M N O P Q R S T U V W X Y Z _ @
do
eval d$c=$i
((c++))
done
while true
do
e=
echo -n "> "
read a b; if ((b)) 2>/dev/null; then :; else b=0; fi
if [ $a = exit ] 2>/dev/null; then break; fi
if [ $a = aide ] 2>/dev/null; then help; continue; fi
if [ $b -lt 2 -o $b -gt 64 ] 2>/dev/null; then echo "mauvais
param�tres: taper aide"; continue; fi
if [ $a = 0 ] 2>/dev/null; then e=0; fi
if ((0<$a && $a<=2147483647)) 2>/dev/null
then a=$((a)); until [ $a = 0 ]; do d=$((a%b)); eval d=\$d$d;
e=$d$e; a=$((a/b)); done
else if [ $a != 0 ] 2>/dev/null; then echo "mauvais
param�tres: taper aide"; continue; fi
fi
case $b in 8) b=0 ;; 10) b= ;; 16) b=0x ;; *) b="$b#" ;; esac
echo "$b$e"
done
exit 0
########################################################################
la 1�re partie:
#!/bin/bash
#bacon
#jipe-2002
c'est donc un script bash qui de plus n'utilise que des commandes internes de bash :P
il s'appelle bacon parce que base converter re :P
et c'est moi que je l'ai fait avec mes grosses mains velues en 2002 ...
la 2�me partie:
help ()
{
echo " #################+Aide+Pour+Bacon+#################"
echo " # � l'invite > entrer un nombre et une base #"
echo " # - exemples: > 1954 2 ou > 2#1011001 8 #"
echo " # format du nombre: base#nombre #"
echo " # cas particuliers: #"
echo " # - base 8: 8#nombre ou 0nombre #"
echo " # - base 10: 10#nombre ou nombre #"
echo " # - base 16: 16#nombre ou 0xnombre #"
echo " # nombres accept�s: entiers positifs #"
echo " # - les nombres doivent �tre valides pour la base #"
echo " # - 2#1201 ou 8#2581 sont invalides #"
echo " # bases accept�es: de 2 � 64 #"
echo " # pour sortir taper exit #"
echo " ###################################################"
}
d�claration de la fonction help qui servira � afficher un message d'aide dans les
conditions d�finies plus tard. la structure d'une fonctions est
fonction () { commandes }
elle est interne au script et s'appelle simplement par son nom.
la 3�me partie:
c=0
for i in 0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z A B C
D E F G H I J K L M N O P Q R S T U V W X Y Z _ @
do
eval d$c=$i
((c++))
done
les bases sup�rieures � 10 utilisent des caract�res autres que des chiffres pour tous
les chiffres sup�rieurs � 9. il faut donc donner une correspondance. les caract�res
utilis�s sont 10 chiffres, 26 minuscules, 26 majuscules, _ et @. ce qui fait
10+26+26+1+1=64. on peut donc aller jusqu'� la base 64.
la correspondance se fait ainsi: les caract�res de 0 � @ vont �tre affect�s comme
valeur des variables de d0 � d63 grace � une boucle for et un appel indirect grace �
eval.
eval va permettre d'affecter la valeur $i (de 0 � @) � d$c (de d0 � d63).
$c est incr�ment� de 1 � chaque boucle avec ((c++)) qui est une autre mani�re d'�crire
c=$((c+1)) ou let c+=1 ou etc...
la 4�me partie
while true
do
e=
echo -n "> "
read a b; if ((b)) 2>/dev/null; then b=$((b)); else b=0; fi
if [ $a = exit ] 2>/dev/null; then break; fi
if [ $a = aide ] 2>/dev/null; then help; continue; fi
if [ $b -lt 2 -o $b -gt 64 ] 2>/dev/null; then echo "mauvais
param�tres: taper aide"; continue; fi
if [ $a = 0 ] 2>/dev/null; then e=0; fi
if ((0<$a && $a<=2147483647)) 2>/dev/null
then a=$((a)); until [ $a = 0 ]; do d=$((a%b)); eval d=\$d$d;
e=$d$e; a=$((a/b)); done
else if [ $a != 0 ] 2>/dev/null; then echo "mauvais
param�tres: taper aide"; continue; fi
fi
case $b in 8) b=0 ;; 10) b= ;; 16) b=0x ;; *) b="$b#" ;; esac
echo "$b$e"
done
une boucle while avec true comme condition puis:
e=
$e est d�finie mais n'a pas de valeur affect�e. elle sera compl�t�e ensuite.
echo -n ">"
une invite > s'affiche pour taper � la suite (option -n de echo) les param�tres �
analyser. cad le nombre et la base. (NB: le script est int�ractif)
read a b; if ((b)) 2>/dev/null; then b=$((b)); else b=0; fi
read a b permet de distinguer les 2 param�tres s�par�s par un espace et ainsi
d'attribuer une valeur � $a et $b. read sans rien derri�re aurait attribu� � $REPLY
(variable interne) l'ensemble de la saisie clavier, espace compris.
la condition suivante if ((b)) permet de v�rifier si $b est bien un entier diff�rent
de 0 auquel cas $b garde sa valeur �ventuellement ramen�e en base dix au cas o� on ait
l'id�e saugrenue de l'exprimer dans une autre valeur. sinon la valeur 0 est affect�e �
$b.
<appart�>
echo $((nombre)) renvoie la valeur en base dix de tout nombre correctement exprim�
dans toute base de 2 � 64. pour �tre valide, ce nombre doit �tre compos� comme suit:
base#nombre. base est un nombre de 2 � 64 exprim� en base dix et nombre doit utiliser
les caract�res valides pour la base. les cas particuliers sont:
- base 8: 8#nombre ou 0nombre
- base 10: 10#nombre ou nombre
- base 16: 16#nombre ou 0xnombre ou 0Xnombre
dans les bases inf�rieures � 37 (10 caract�res num�riques et 26 caract�res
alphab�tiques) la casse est indiff�rente. il n'en est plus de m�me ensuite.
echo $((36#a)) et echo $((36#A)) renvoient 10
echo $((37#a)) renvoie 10 et echo $((37#A)) renvoie 36
</appart�>
if [ $a = exit ] 2>/dev/null; then break; fi
if [ $a = aide ] 2>/dev/null; then help; continue; fi
2 conditions qui permettent de rechercher 2 valeurs particuli�res de $a et d'executer
les actions qui en d�coulent.
si $a = exit, on sort de la boucle while grace � break et le script se termine
si $a = aide, on affiche le message d'aide grace � help puis on recommence au d�but de
la boucle grace � continue et on se retrouve avec une nouvelle invite >.
if [ $b -lt 2 -o $b -gt 64 ] 2>/dev/null; then echo "mauvais param�tres: taper aide";
continue; fi
double condition avec "ou" (-o). on peut coupler les conditions de diff�rentes
mani�res. dans les [] ou [[]] avec -o (ou) et -a (et) ou avec || (ou) et && (et) �
l'ext�rieur des crochets. ici la condition coupl�e est la suivante:
si $b est plus petit que 2 ou si $b est plus grand que 64, un message d'erreur est
affich� et on recommence au d�but de la boucle (continue).
if [ $a = 0 ] 2>/dev/null; then e=0; fi
cette condition permet de donner la valeur 0 � $e au cas o� on voudrait savoir comment
s'�crit 0 dans une base quelconque :)
if ((0<$a && $a<=2147483647)) 2>/dev/null
une condition double exprim�e entre doubles parenth�ses. les diff�rents �lements ne
doivent �tre que des entiers. les $ de $a ne sont pas n�cessaires. la double condition:
si $a est strictement sup�rieure � 0 et inf�rieure ou �gale � 2147483647
ce dernier chiffre est la limite sup�rieure pour les calculs arithm�tiques dans bash.
<appart�>
la construction (()) permet d'�crire des conditions et leurs actions qui en d�coulent
de fa�on tr�s concise � condition de n'utiliser que des valeurs enti�res pour les
variables.
((a=b%2==0?0:1));echo $a
renvoie 0 si $b est paire et 1 si $b est impaire.
elle se d�compose ainsi:
((a= b%2==0? 0:1))
et se lit ainsi:
a=
$a sera �gale �
b%2==0? condition
si $b modulo 2 �gal 0 cad si le reste de $b divis� par 2 est 0
0:1 valeurs de $a
0 si vrai et 1 si faux
</appart�>
then a=$((a)); until [ $a = 0 ]; do d=$((a%b)); eval d=\$d$d; e=$d$e; a=$((a/b)); done
si la condition pr�c�dente du script est vraie. (0<$a<=2147483647)
* a=$((a))
conversion de $a en base 10
* until [ $a = 0 ]
boucle until.jusqu'� ce que $a soit �gale � 0
cette boucle est imbriqu�e dans la boucle while
* do d=$((a%b))
$d vaut $a modulo $b cad reste de $a divis�e par $b
* eval d=\$d$d
assignation � $d de la valeur correspondant � d$d. r�f�rence indirecte � une variable
contenant une variable dans son nom permise par eval. les variables d0 � d63 ont �t�
d�finies au d�but du script en dehors de la boucle while.
par exemple si d=10, d10 valant a -> d=a. permet donc d'affecter les caract�res non
num�riques pour les bases sup�rieures � 10
* e=$d$e
$e se remplit caract�re par caract�re � chaque passage dans la boucle en ajoutant $d �
gauche de la valeur pr�c�dente de $e.
* a=$((a/b))
modification de la valeur de $a pour le prochain passage dans la boucle. $a vaudra $a
divis� par $b en valeur enti�re. cad sans le reste de la division.
* done
fin de la boucle until lorsque la condition $a=0 est remplie
<explication du m�canisme>
chaque chiffre d'un nombre est le reste de la division de ce chiffre par sa base puis
du r�sultat de la division pr�c�dente par la base etc ... jusqu'� ce que le r�sultat
de la division par base soit 0.
exemple: 1234 en base 10
1234 divis� par 10 -> 123 reste 4
123 divis� par 10 -> 12 reste 3
12 divis� par 10 -> 1 reste 2
1 divis� par 10 -> 0 reste 1
en assemblant les restes successifs de droite � gauche, on obtient 1234.
</explication du m�canisme>
else if [ $a != 0 ] 2>/dev/null; then echo "mauvais param�tres: taper aide"; continue;
fi
si la condition 0<$a<=2147483647 n'est pas remplie
* if [ $a != 0 ] 2>/dev/null
nouvelle condition imbriqu�e. le 2</dev/null prot�ge des messages d'erreur. si $a est
diff�rent de 0. le cas o� $a �gal 0 a �t� pr�vu pr�c�demment. en fait tous les autres
cas ne r�pondant � aucune des conditions pr�c�dentes:
a=exit
a=aide
a=0
0<$a<=2147483647
* then echo "mauvais param�tres: taper aide"
afficher le message d'erreur
* continue
retourner au d�but de la boucle while et afficher l'invite >
* fi
fin de la condition
fi
fin de la condition 0<$a<=2147483647
case $b in 8) b=0 ;; 10) b= ;; 16) b=0x ;; *) b="$b#" ;; esac
un case �crit sur une ligne. dans le cas ou $b (base) vaut 8 -> b=0, 10 -> b="rien",
16 -> b=0x, et n'importe quoi d'autre -> b=$b#
permet l'affichage du r�sultat grace � la commande suivante dans un format
correspondant � la base.
echo "$b$e"
affichage du r�sultat
$b pour la base et puis $e
done
fin de la boucle while. la sortie est obtenue en tapant exit, condition si $a = exit.
derni�re partie:
exit 0
condition de sortie du script. celui-ci renvoie 0
vala. en esp�rant avoir fait plaisir :)
bye
jipe
Vous souhaitez acquerir votre Pack ou des Services MandrakeSoft?
Rendez-vous sur "http://www.mandrakestore.com";
