script bc et base hexa

Le
Hugolino
Bonjour,

J'utilise un GNU/bc dans un script pour convertir un nombre d'une base
quelconque dans un autre base.

#!/bin/sh

echo -n " Si $VALEUR_SAISIE est en décimal, alors: "
echo `bc << !
obase; "hex="; $VALEUR_SAISIE
obase; "dec="; $VALEUR_SAISIE
obase=8 ; "oct="; $VALEUR_SAISIE
obase=2 ; "bin="; $VALEUR_SAISIE
!
`
Marche bien, le script renvoie:
Si 20 est en décimal, alors: hex dec oct$ bin100


echo -n " Si $VALEUR_SAISIE est en héxa, alors: "
echo `bc << !
ibase; "hex="; $VALEUR_SAISIE
ibase; "dec="; $VALEUR_SAISIE
ibase=8 ; "oct="; $VALEUR_SAISIE
ibase=2 ; "bin="; $VALEUR_SAISIE
!
`
Marche mal, seule la valeur en décimal est juste, le script donne:
Si 20 est en héxa, alors: hex2 dec2 oct bin=2

J'ai cru à un problème de obase, alors j'ai écrit ce qui suit et
effectivement les valeurs en octal et binaire sont justes, mais la
valeur héxadécimale n'est pas affiché avec des lettres.
Et je ne comprends pas les warnings.

echo -n " Si $VALEUR_SAISIE est en héxa, alors: "
echo `bc << !
ibase; obase; "hex="; $VALEUR_SAISIE
ibase; obase; "dec="; $VALEUR_SAISIE
ibase; obase=8 ; "oct="; $VALEUR_SAISIE
ibase; obase=2 ; "bin="; $VALEUR_SAISIE
!
`
Me renvoie:
Si 20 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase
too large, set to 16
Runtime warning (func=(main), adr=6): ibase too large, set to 16
Runtime warning (func=(main), adr=6): ibase too large, set to 16
hex= 01 10 dec oct@ bin0000


Merci de votre aide.

--
> On va peut-être savoir si un FreeBSDiste peut se reproduire avec un
> linuxien.
Ah ! C'est ça HURD ?
-+- fyr in Guide du linuxien pervers - "Linux transgenique" -+-
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
ts
Le #758457
"H" == Hugolino





H> ibase; "hex="; $VALEUR_SAISIE
H> ibase; "dec="; $VALEUR_SAISIE

Si ibase alors 10 vaut 16 (en décimal)

H> ibase; obase; "hex="; $VALEUR_SAISIE
H> ibase; obase; "dec="; $VALEUR_SAISIE

si ibase alors 16 vaut 22 en décimal (pour la deuxième déclaration de
ibase) et dépasse la valeur maximale autorisée pour ibase d'où
l'avertissement

H> Runtime warning (func=(main), adr=6): ibase too large, set to 16


--

Guy Decoux





Hugolino
Le #758149
Le Wed, 20 Jun 2007 08:17:56 +0200, ts a écrit:
"H" == Hugolino






Salut et merci de chercher à m'aider...
Tu as été un peu «brutal» dans ton quotage, je rajoute ce que je suppose
être ce à quoi tu répondais...

echo -n " Si $VALEUR_SAISIE est en héxa, alors: "
echo `bc << !
ibase; "hex="; $VALEUR_SAISIE
ibase; "dec="; $VALEUR_SAISIE
ibase=8 ; "oct="; $VALEUR_SAISIE
ibase=2 ; "bin="; $VALEUR_SAISIE
!
`
Marche mal, seule la valeur en décimal est juste, le script donne:
Si 20 est en héxa, alors: hex2 dec2 oct bin=2


H> ibase; "hex="; $VALEUR_SAISIE
H> ibase; "dec="; $VALEUR_SAISIE

Si ibase alors 10 vaut 16 (en décimal)


Ça, c'est OK, j'ai bien compris ce que tu veux dire, à savoir que si je
passe 10 en argument à mon script et que j'étudie le cas où ibase
(puisque je ne veux pas contraindre le yuser à spécifier la base), alors
il est normal que la première ligne réponde hex puisque je n'ai pas
spécifié la valeur de obase (qui par défaut vaut 10). Et on est bien
d'accord, 10 en base héxa vaut 16 en obase par défaut. On dira que
c'est au yuser de savoir trier la sortie puisque je ne lui impose pas de
spécifier la base dans laquelle est exprimé l'argument. (Ou alors que je
dois imposer au yuser de spécifier la base).

Bref, merci de tes lumières.


Je re-cite le troisème morceau de mon script:
echo -n " Si $VALEUR_SAISIE est en héxa, alors: "
echo `bc << !
ibase; "hex="; $VALEUR_SAISIE
ibase; "dec="; $VALEUR_SAISIE
ibase=8 ; "oct="; $VALEUR_SAISIE
ibase=2 ; "bin="; $VALEUR_SAISIE
!
`


H> ibase; obase; "hex="; $VALEUR_SAISIE
H> ibase; obase; "dec="; $VALEUR_SAISIE

si ibase alors 16 vaut 22 en décimal (pour la deuxième déclaration de
ibase) et dépasse la valeur maximale autorisée pour ibase d'où
l'avertissement

H> Runtime warning (func=(main), adr=6): ibase too large, set to 16


Tu veux dire qu'une fois que j'ai posé ibase (première ligne), alors
je dois uiliser une base héxadécimale à la deuxième ligne pour dire que
je veux une base 16, soit ibase.
('tain, c(est ultra-vicieux, j'aurais jamais trouvé tout seul :)

donc je corrige mon script bc qui devient:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
echo -n ${GREEN}" Si ${YELLOW}$VALEUR_SAISIE${GREEN} est en héxa, alors:
${CYAN} "
echo `bc << !
ibase; obase; "hex="; $VALEUR_SAISIE
ibase; obase; "dec="; $VALEUR_SAISIE
ibase; obase=8 ; "oct="; $VALEUR_SAISIE
ibase; obase=2 ; "bin="; $VALEUR_SAISIE
!
`
8<-----------8<---------8<----------8<----------8<----------8<----------8<

Et si je lui passe 10 en argument, ça donne ça:
Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase
too large, set to 16
Runtime warning (func=(main), adr=6): ibase too large, set to 16
hex= 16 dec oct bin000

Et là je ne comprends plus. Je m'attendais bien à avoir un warning pour
le passage de la 3ème à la quatrième ligne à cause de cette histoire de
16 qui en base 16 vaut 22 alors que bc ne gère pas de base 22, mais
pourquoi deux warnings ? À cause du passage de la 2ème à la troisième
ligne ? Mais à la fin de la 2ème ligne ibase vaut 10, donc j'ai bien le
droit d'écrire ibase au début de la 3ème ligne...
Si je supprime cette troisième ligne, je n'ai bien qu'un seul warning,
la sortie est:

Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase
too large, set to 16
hex= 16 dec bin000

Mais je ne compreds toujours pas pourquoi je n'aurais pas le droit
d'écrire ibase alors que la base vaut 10 (ibase de la ligne 2).

Je sens bien que ton explication est sans doute la bonne mais il y a
un truc qui cloche.

Merci.

--
Faut avoir du temps à perdre.
Lorsqu'il est proféré sur Usenet, cet argument n'a absolument

aucune valeur.
Hugo (né il y a 1 361 838 501 secondes)






Jogo
Le #758148
Sur fr.comp.os.unix, Hugolino disait :

Je sens bien que ton explication est sans doute la bonne mais il y a
un truc qui cloche.


C'est pourtant très simple : à partir du moment où tu lui as dit
ibase, toutes les valeurs numériques sont interprétées en base hexa.
Il faut donc lui dire :

ibase
obase; "hex="; $VALEUR_SAISIE
obase=A; "dec="; $VALEUR_SAISIE
obase=8; "oct="; $VALEUR_SAISIE
obase=2; "bin="; $VALEUR_SAISIE

--
Jogo

ts
Le #755422
"H" == Hugolino





Bon, une meilleure réponse a été donnée par Jogo, mais vous faites
toujours la même erreur

H> donc je corrige mon script bc qui devient:
H> 8<-----------8<---------8<----------8<----------8<----------8<----------8<
H> echo -n ${GREEN}" Si ${YELLOW}$VALEUR_SAISIE${GREEN} est en héxa, alors:
H> ${CYAN} "
H> echo `bc << !
H> ibase; obase; "hex="; $VALEUR_SAISIE
H> ibase; obase; "dec="; $VALEUR_SAISIE
H> ibase; obase=8 ; "oct="; $VALEUR_SAISIE
H> ibase; obase=2 ; "bin="; $VALEUR_SAISIE
H> !
H> `
H> 8<-----------8<---------8<----------8<----------8<----------8<----------8<

H> Et si je lui passe 10 en argument, ça donne ça:
H> Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase
H> too large, set to 16
H> Runtime warning (func=(main), adr=6): ibase too large, set to 16
H> hex= 16 dec oct bin000

H> Et là je ne comprends plus. Je m'attendais bien à avoir un warning pour
H> le passage de la 3ème à la quatrième ligne à cause de cette histoire de
H> 16 qui en base 16 vaut 22 alors que bc ne gère pas de base 22, mais
H> pourquoi deux warnings ? À cause du passage de la 2ème à la troisième
H> ligne ? Mais à la fin de la 2ème ligne ibase vaut 10, donc j'ai bien le
H> droit d'écrire ibase au début de la 3ème ligne...

À la fin de la deuxième ligne ibase vaut 10 en *hexadécimal*, la valeur
que vous lui donnez est interprétée en fonction de la base qu'il a et que
vous avez changé à 16 en première ligne.

Donc faire

moulon% bc -q
# a cette étape il est en base 10, les valeurs que vous lui donnerez seront
# interprétées dans cette base
ibase
# il s'est mis en base 16, les valeurs d'entrée seront interprétées dans
# cette base
ibase
# vous lui avez donné la valeur 10 en *hexa* donc 16 en décimal ==> il n'a
# pas changé la valeur d'ibase
ibase
# ce 16 est toujours interpreté en *hexa*, donc il a la valeur 22 en
# décimal ce qui ne lui plait pas
moulon%

Vous faites la même erreur avec obase

moulon% bc -q
ibase # en entrée en base 16
obase # en sortie en base 22 (16 en *hexa*, il a changé ibase)
16 # 16 en hexa
01 00 # donne 10 en base 22
10 # 10 en hexa
16 # donne 16 en base 22
moulon%



--

Guy Decoux





Publicité
Poster une réponse
Anonyme