Segue abaixo o src de algumas funções que estava trabalhando hoje a tarde, elas efetuam a conversão de bases, como decimal para binário, octal para hexadecimal. Utilizei a “calculadora” bc para efetuar as conversões.

Não vou entrar muito nos detalhes sobre as funções. Só precisa compreender o funcionamento do bc. No caso pegaremos como exemplo a primeira função a bin2hex.

Utilizei as “” ao chama o bc de calculadora, pois o bc e bem mais que uma calculadora e um linguagem de programação (sim ele tem suporte a for, if-else, funções). Não vou entrar agora no por menores do bc, isso fica para um artigo no futuro. O bc possui algumas variáveis padrões ou especiais (como preferir), como por exemplo: ibase, obase, scala.

Para realizamos uma operação matemática com o bc basta jogar uma string contendo a operação para ele. por exemplo:

$ echo "2+2" | bc

Opa então se posso jogar uma string que ele resolve então é bem fácil de usar!

Lembram que falei agora pouco sobre as variáveis especiais que ele trabalha? Pois é delas iremos precisar somente de 2 a ibase e obase.

• Na ibase, você define a base da entrada (por isso o i no inicio da variável, i vem de input significa entrada em inglês) ou seja se os números inseridos serão na base 10 (decimal), 2 (binária) e etc.
• Na obase, você define a base da saída da operação, por exemplo se você deseja que o resultado da operação 2 + 2 não seja dado em base 10, seja dado em binário, então vai utilizar essa variável.

Então se resolvemos uma operação fazendo um echo “2+2″ | bc podemos setar a variáveis especiais via echo também! Por exemplo:

$ echo "ibase=16" | bc

Viram como e simples trabalhar com o bc? Agora que conhece o minimo dele podemos prosseguir. Existe outra forma de utilizar o bc, e atrás do próprio bc! Executando o bc temos acesso ao seu shell. O funcionamento dele não tem mistério basta digitar 1+1 e pressionar enter que ele vai jogar a resposta da operação na linha seguinte.

Opa temos algo interessante agora, se precisamos pressionar enter então precisamos jogar um \n pelo echo para o bc entender o comando passado. O echo já faz isso naturalmente, por default (padrão) ele salta uma linha ou seja u ultimo caractere que o echo escreve e um \n.

Se explorar mais um pouco o bc, vai perceber que as variáveis especiais precisam ser setadas um por linha! Então quando formos usá-las precisamos colocar somente uma por linha. Como fazemos isso pelo echo? Simples! Usamos o parâmetro -e do echo, ele permite que o echo utilize caracteres de controle como \t, \n, \r e etc.

Então vai ficar assim o echo:

$ echo -e "ibase=$ENTRADA\nobase=$SAIDA"

Setando ENTRADA=1 e SAIDA=2 teremos a seguinte saída:

v0rtex@0fx66:~/Source/shellscript$ ENTRADA=1
v0rtex@0fx66:~/Source/shellscript$ SAIDA=2
v0rtex@0fx66:~/Source/shellscript$ echo -e "ibase=$ENTRADA\nobase=$SAIDA"
ibase=1
obase=2

v0rtex@0fx66:~/Source/shellscript$ ENTRADA=10
v0rtex@0fx66:~/Source/shellscript$ SAIDA=2
v0rtex@0fx66:~/Source/shellscript$ VAR=30
v0rtex@0fx66:~/Source/shellscript$ echo -e "ibase=$ENTRADA\nobase=$SAIDA\n$VAR"
ibase=10
obase=2
30

Viram o resultado echo: Então agora que ele está bonito e o melhor de tudo no formato certo só joga a saída dele no bc.

v0rtex@0fx66:~/Source/shellscript$ ENTRADA=10
v0rtex@0fx66:~/Source/shellscript$ SAIDA=2
v0rtex@0fx66:~/Source/shellscript$ VAR=30
v0rtex@0fx66:~/Source/shellscript$ echo -e "ibase=$ENTRADA\nobase=$SAIDA\n$VAR"
ibase=10
obase=2
30
v0rtex@0fx66:~/Source/shellscript$ echo -e "ibase=$ENTRADA\nobase=$SAIDA\n$VAR" | bc
11110

Pronto, agora só usar a criatividade, eu transportei isso para um pequeno script.

########################
## CONVERSAO DE BASE  ##
########################

# bin2hex - Converte binario para hexadecimal.
function bin2hex () {
	echo -e "obase=16\nibase=2\n$1" | bc
}

# bin2dec - Converte binario para decimal.
function bin2dec() {
	echo -e "obase=10\nibase=2\n$1" | bc
}

# bin2oct - Converte binario para octal.
function bin2oct () {
	echo -e "obase=8\nibase=2\n$1" | bc
}

# dec2bin - Converte decimal para binario.
function dec2bin () {
	echo -e "obase=2\nibase=10\n$1" | bc
}

# dec2oct -Converte decimal para octal.
function dec2oct () {
	echo -e "obase=8\nibase=10\n$1" | bc
}	

# dec2hex - Converte de decimal para hexadecimal
function dec2hex () {
	echo -e "obase=16\nibase=10\n$1" | bc
}

# oct2bin - Converte octal para binario.
function oct2bin () {
	echo -e "obase=2\nibase=8\n$1" | bc
}

# oct2dec - Converte octal para decimal.
function oct2dec () {
	echo -e "obase=8\nibase=10\n$1" | bc
}

# oct2hex - Converte octal para hexadecimal.
function oct2hex () {
	echo -e "obase=8\nibase=16\n$1" | bc
}

# hex2bin - Converte hexadecimal para binario.
function hex2bin () {
	echo -e "obase=16\nibase=2\n$1" | bc
}

# hex2oct - Converte hexadecimal para octal.
function hex2oct () {
	echo -e "obase=16\nibase=8\n$1" | bc
}

# hex2dec - Converte hexadecimal para decimal.
function hex2dec() {
	echo -e "obase=16\nibase=10\n$1" | bc
}

Poderia otimizar o uso das funções passando a base original e a resultando por parâmetros, mas preferi dessa forma, não sei por que, mas achei mais divertido assim e melhor para praticar a sintaxe do bc + echo.

Bom por hoje e só pessoal, bom final de semana e excelentes estudos. É lembre-se o shell é poder!