Linux slogan
Visite também: BR-Linux.org · Dicas-L · Doode · NoticiasLinux · SoftwareLivre.org · UnderLinux



» Screenshot
» Login
Login:
Senha:

Se você ainda não possui uma conta, clique aqui.

Esqueci minha senha



Scripts

Linux user

Publicado por Elias Bernabé Turchiello em (última atualização em 21/05/2012)   [ 6203 hits ]

Login: turchiellows, 19141 pontos

Homepage: www.turchiellows.xpg.com.br

Download:


Descrição

Este script escreve por extenso valores numéricos, monetários (moeda brasileira), datas, (levando em consideração anos bissextos), horas, meses do ano e os dias da semana.

Funciona em modo texto devolvendo o resultado na tela do terminal, o qual pode muito bem ser redirecionado com > ou >>

Ex.:
   PARA VALORES NUMÉRICOS: (decimais com vírgula)
   ./numeros-por-extenso-texto.sh -n 123,42
   cento e vinte e três vírgula quarenta e dois
   
   PARA VALORES MONETÁRIOS (em reais): (decimais com vírgula)
   ./numeros-por-extenso-texto.sh -V 99,12
   noventa e nove reais com doze centavos
   
   PARA VALORES DE DATAS:
   ./numeros-por-extenso-texto.sh -D 01/04/1978
   primeiro de abril do ano um mil e novecentos e setenta e oito
   
   PARA VALORES DE HORAS:
   ./numeros-por-extenso-texto.sh -H 00:15:09
   zero hora com quinze minutos e nove segundos
   
   PARA OS MESES DO ANO: (1-12)
   ./numeros-por-extenso-texto.sh -m 9
   setembro
   
   PARA OS DIAS DA SEMANA: (1-7)
   ./numeros-por-extenso-texto.sh -s 4
   quarta-feira




[ Download: numeros-por-extenso-texto.sh ]   [ Enviar nova versão ]

[ Esconder código-fonte ]

#!/bin/bash
# numeros-por-extenso-texto.sh

#-------------------------------------------------------------------------------------
# Versão 1.0 : Elias Bernabé Turchiello - 29/04/2012 : Escreve por extenso um número passado como parâmetro, dando o seu resultado em valor monetário (reais e centavos). Não faz verificação nenhuma e não solicita correção do valor digitado. Desenvolvido para ser chamado silenciosamente por outros scripts e simplesmente devolver a resposta
# Versão 1.1 : Elias Bernabé Turchiello - 12/05/2012 : Passa a escrever valores numéricos, datas, horas, meses e dias da semana
# Versão 1.2 : Elias Bernabé Turchiello - 14/05/2012 : Separado a parte de ajuda em um case a parte que trata somente o primeiro parâmetro. Se nenhum parâmetro for passado simplesmente não faz nada.


#-------------------------------------------------------------------------------------
# Elias Bernabé Turchiello
# Home: www.turchiellows.xpg.com.br

#-------------------------------------------------------------------------------------
# Criando a variável de ajuda sobre a descrição do script:
Ajuda="
[`basename $0`]
* USO : `basename $0` [OPÇÃO] [PARÂMETRO]

* Escreve por extenso valores numéricos, monetários, datas, horas, mêses e os
   dias da semana
* Desenvolvido em Kurumin NG e otimizado para sistemas Debian e derivados
* Funciona em modo texto para ser executado diretamente no terminal ou
   chamado a partir de outro script qualquer
* Aceita números com até duas casas decimais separadas obrigatoriamente por vírgula
* A separação das unidade de milhar pode ou não ser feita por um ponto Ex.: 110.000
"
# Criando a variável de ajuda sobre as opções do script:
Opcoes="
[OPÇÕES]
-h    --help         -mostra esta tela de ajuda e sai
-v    --versao       -mostra a versão, data de criação, o autor, as mudanças da versão e sai
-e    --exemplo      -mostra exemplos de como executar este script e sai
-d    --depende      -mostra a lista de dependências do script e sai
-n    --numero       -escreve por extenso números cardinais
-V    --valor        -escreve por extenso valores de moedas em Reais (moeda brasileira)
-D    --data         -escreve por extenso valores de tadas no formato dd/mm/yyyy
-H    --hora         -escreve por extenso valores de horas no formato hh:mm:ss
-s    --semana       -escreve por extenso o dia da semana numerado de 1-7 (1=domingo)
-m    --mes          -escreve por extenso o mês do ano numerado de 1-12 (1=janeiro)
"
# Criando a variável de ajuda com exemplos de execução do script:
Exemplos="
   PARA VALORES NUMÉRICOS: (decimais com vírgula)
   ./`basename $0` -n 123,42
   cento e vinte e três vírgula quarenta e dois
   
   PARA VALORES MONETÁRIOS (em reais): (decimais com vírgula)
   ./`basename $0` -V 99,12
   noventa e nove reais com dize centavos
   
   PARA VALORES DE DATAS:
   ./`basename $0` -D 01/04/1978
   primeiro de abril do ano um mil e novecentos e setenta e oito
   
   PARA VALORES DE HORAS:
   ./`basename $0` -H 00:15:09
   zero hora com quinze minutos e nove segundos
   
   PARA OS MESES DO ANO: (1-12)
   ./`basename $0` -m 9
   setembro
   
   PARA OS DIAS DA SEMANA: (1-7)
   ./`basename $0` -s 4
   quarta-feira
"

#-------------------------------------------------------------------------------------
# Preparando a variável IFS para ler nomes com espaços:
Ifsvelho="$IFS"
IFS='
'

#-------------------------------------------------------------------------------------
# Preparando as funções para a leitura de unidade, dezena e centena:
# Função para ler somente unidades até 9:
Unidade () {
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$1`
# Processando:
case $Unidade in
   1) echo -n "um" >> /tmp/resultado-$$ ;;
   2) echo -n "dois" >> /tmp/resultado-$$ ;;
   3) echo -n "três" >> /tmp/resultado-$$ ;;
   4) echo -n "quatro" >> /tmp/resultado-$$ ;;
   5) echo -n "cinco" >> /tmp/resultado-$$ ;;
   6) echo -n "seis" >> /tmp/resultado-$$ ;;
   7) echo -n "sete" >> /tmp/resultado-$$ ;;
   8) echo -n "oito" >> /tmp/resultado-$$ ;;
   9) echo -n "nove" >> /tmp/resultado-$$ ;;
esac
}

# Função para ler as unidades de datas. O dia 1 deve ser identificado como primerio:
UnidadeData () {
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$1`
# Processando:
case $Unidade in
   1) echo -n "primeiro" >> /tmp/resultado-$$ ;;
   2) echo -n "dois" >> /tmp/resultado-$$ ;;
   3) echo -n "três" >> /tmp/resultado-$$ ;;
   4) echo -n "quatro" >> /tmp/resultado-$$ ;;
   5) echo -n "cinco" >> /tmp/resultado-$$ ;;
   6) echo -n "seis" >> /tmp/resultado-$$ ;;
   7) echo -n "sete" >> /tmp/resultado-$$ ;;
   8) echo -n "oito" >> /tmp/resultado-$$ ;;
   9) echo -n "nove" >> /tmp/resultado-$$ ;;
esac
}

# Função para ler as unidades de horas. Deve ler o valor zero para a zero hora:
UnidadeHora () {
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$1`
# Processando:
case $Unidade in
   0) echo -n "zero" >> /tmp/resultado-$$ ;;
   1) echo -n "uma" >> /tmp/resultado-$$ ;;
   2) echo -n "duas" >> /tmp/resultado-$$ ;;
   3) echo -n "três" >> /tmp/resultado-$$ ;;
   4) echo -n "quatro" >> /tmp/resultado-$$ ;;
   5) echo -n "cinco" >> /tmp/resultado-$$ ;;
   6) echo -n "seis" >> /tmp/resultado-$$ ;;
   7) echo -n "sete" >> /tmp/resultado-$$ ;;
   8) echo -n "oito" >> /tmp/resultado-$$ ;;
   9) echo -n "nove" >> /tmp/resultado-$$ ;;
esac
}

# Função para ler dezena até 99:
Dezena () {
# Coletando o número da dezena:
Dezena=`cat /tmp/valor-$$ | cut -c$1`
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$2`
case $Dezena in
   0) case $Dezena$Unidade in
      0) echo -n "0" > /dev/null ;;
      0*) Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   1) case $Dezena$Unidade in
      10) echo -n "déz" >> /tmp/resultado-$$ ;;
      11) echo -n "onze" >> /tmp/resultado-$$ ;;
      12) echo -n "doze" >> /tmp/resultado-$$ ;;
      13) echo -n "treze" >> /tmp/resultado-$$ ;;
      14) echo -n "catorze" >> /tmp/resultado-$$ ;;
      15) echo -n "quinze" >> /tmp/resultado-$$ ;;
      16) echo -n "dezeseis" >> /tmp/resultado-$$ ;;
      17) echo -n "dezesete" >> /tmp/resultado-$$ ;;
      18) echo -n "dezoito" >> /tmp/resultado-$$ ;;
      19) echo -n "dezenove" >> /tmp/resultado-$$ ;;
   esac ;;
   2) case $Dezena$Unidade in
      20) echo -n "vinte" >> /tmp/resultado-$$ ;;
      2*) echo -n "vinte e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   3) case $Dezena$Unidade in
      30) echo -n "trinta" >> /tmp/resultado-$$ ;;
      3*) echo -n "trinta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   4) case $Dezena$Unidade in
      40) echo -n "quarenta" >> /tmp/resultado-$$ ;;
      4*) echo -n "quarenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   5) case $Dezena$Unidade in
      50) echo -n "cinquenta" >> /tmp/resultado-$$ ;;
      5*) echo -n "cinquenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   6) case $Dezena$Unidade in
      60) echo -n "sessenta" >> /tmp/resultado-$$ ;;
      6*) echo -n "sessenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   7) case $Dezena$Unidade in
      70) echo -n "setenta" >> /tmp/resultado-$$ ;;
      7*) echo -n "setenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   8) case $Dezena$Unidade in
      80) echo -n "oitenta" >> /tmp/resultado-$$ ;;
      8*) echo -n "oitenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   9) case $Dezena$Unidade in
      90) echo -n "noventa" >> /tmp/resultado-$$ ;;
      9*) echo -n "noventa e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
esac
}

# Função para ler as dezenas de datas:
DezenaData () {
# Coletando o número da dezena:
Dezena=`cat /tmp/valor-$$ | cut -c$1`
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$2`
case $Dezena in
   0) case $Dezena$Unidade in
      0) echo -n "0" > /dev/null ;;
      0*) UnidadeData $2 >> /tmp/resultado-$$ ;;
   esac ;;
   1) case $Dezena$Unidade in
      10) echo -n "déz" >> /tmp/resultado-$$ ;;
      11) echo -n "onze" >> /tmp/resultado-$$ ;;
      12) echo -n "doze" >> /tmp/resultado-$$ ;;
      13) echo -n "treze" >> /tmp/resultado-$$ ;;
      14) echo -n "catorze" >> /tmp/resultado-$$ ;;
      15) echo -n "quinze" >> /tmp/resultado-$$ ;;
      16) echo -n "dezeseis" >> /tmp/resultado-$$ ;;
      17) echo -n "dezesete" >> /tmp/resultado-$$ ;;
      18) echo -n "dezoito" >> /tmp/resultado-$$ ;;
      19) echo -n "dezenove" >> /tmp/resultado-$$ ;;
   esac ;;
   2) case $Dezena$Unidade in
      20) echo -n "vinte" >> /tmp/resultado-$$ ;;
      2*) echo -n "vinte e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   3) case $Dezena$Unidade in
      30) echo -n "trinta" >> /tmp/resultado-$$ ;;
      3*) echo -n "trinta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   4) case $Dezena$Unidade in
      40) echo -n "quarenta" >> /tmp/resultado-$$ ;;
      4*) echo -n "quarenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   5) case $Dezena$Unidade in
      50) echo -n "cinquenta" >> /tmp/resultado-$$ ;;
      5*) echo -n "cinquenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   6) case $Dezena$Unidade in
      60) echo -n "sessenta" >> /tmp/resultado-$$ ;;
      6*) echo -n "sessenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   7) case $Dezena$Unidade in
      70) echo -n "setenta" >> /tmp/resultado-$$ ;;
      7*) echo -n "setenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   8) case $Dezena$Unidade in
      80) echo -n "oitenta" >> /tmp/resultado-$$ ;;
      8*) echo -n "oitenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
   9) case $Dezena$Unidade in
      90) echo -n "noventa" >> /tmp/resultado-$$ ;;
      9*) echo -n "noventa e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
   esac ;;
esac
}

# Função para ler as dezenas de horas. A meia noite deve escrever zero hora:
DezenaHora () {
# Coletando o número da dezena:
Dezena=`cat /tmp/valor-$$ | cut -c$1`
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$2`
case $Dezena in
   0) case $Dezena$Unidade in
      0) echo -n "zero" >> /tmp/resultado-$$ ;;
      0*) UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
   1) case $Dezena$Unidade in
      10) echo -n "déz" >> /tmp/resultado-$$ ;;
      11) echo -n "onze" >> /tmp/resultado-$$ ;;
      12) echo -n "doze" >> /tmp/resultado-$$ ;;
      13) echo -n "treze" >> /tmp/resultado-$$ ;;
      14) echo -n "catorze" >> /tmp/resultado-$$ ;;
      15) echo -n "quinze" >> /tmp/resultado-$$ ;;
      16) echo -n "dezeseis" >> /tmp/resultado-$$ ;;
      17) echo -n "dezesete" >> /tmp/resultado-$$ ;;
      18) echo -n "dezoito" >> /tmp/resultado-$$ ;;
      19) echo -n "dezenove" >> /tmp/resultado-$$ ;;
   esac ;;
   2) case $Dezena$Unidade in
      20) echo -n "vinte" >> /tmp/resultado-$$ ;;
      2*) echo -n "vinte e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
   3) case $Dezena$Unidade in
      30) echo -n "trinta" >> /tmp/resultado-$$ ;;
      3*) echo -n "trinta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
   4) case $Dezena$Unidade in
      40) echo -n "quarenta" >> /tmp/resultado-$$ ;;
      4*) echo -n "quarenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
   5) case $Dezena$Unidade in
      50) echo -n "cinquenta" >> /tmp/resultado-$$ ;;
      5*) echo -n "cinquenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
   6) case $Dezena$Unidade in
      60) echo -n "sessenta" >> /tmp/resultado-$$ ;;
      6*) echo -n "sessenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
   7) case $Dezena$Unidade in
      70) echo -n "setenta" >> /tmp/resultado-$$ ;;
      7*) echo -n "setenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
   8) case $Dezena$Unidade in
      80) echo -n "oitenta" >> /tmp/resultado-$$ ;;
      8*) echo -n "oitenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
   9) case $Dezena$Unidade in
      90) echo -n "noventa" >> /tmp/resultado-$$ ;;
      9*) echo -n "noventa e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
   esac ;;
esac
}

# Função para ler até 999:
Centena () {
# Coletando o número da centena:
Centena=`cat /tmp/valor-$$ | cut -c$1`
# Coletando o número da dezena:
Dezena=`cat /tmp/valor-$$ | cut -c$2`
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$3`
case $Centena in
   0) case $Centena$Dezena$Unidade in
      0)  echo -n "0" > /dev/null ;;
      0*) Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   1) case $Centena$Dezena$Unidade in
      100) echo -n "cem" >> /tmp/resultado-$$ ;;
      1*) echo -n "cento e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   2)case $Centena$Dezena$Unidade in
      200) echo -n "duzentos" >> /tmp/resultado-$$ ;;
      2*) echo -n "duzentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   3) case $Centena$Dezena$Unidade in
      300) echo -n "trezentos" >> /tmp/resultado-$$ ;;
      3*) echo -n "trezentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   4) case $Centena$Dezena$Unidade in
      400) echo -n "quatrocentos" >> /tmp/resultado-$$ ;;
      4*) echo -n "quatrocentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   5) case $Centena$Dezena$Unidade in
      500) echo -n "quinhentos" >> /tmp/resultado-$$ ;;
      5*) echo -n "quinhentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   6) case $Centena$Dezena$Unidade in
      600) echo -n "seiscentos" >> /tmp/resultado-$$ ;;
      6*) echo -n "seiscentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   7) case $Centena$Dezena$Unidade in
      700) echo -n "setecentos" >> /tmp/resultado-$$ ;;
      7*) echo -n "setecentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   8) case $Centena$Dezena$Unidade in
      800) echo -n "oitocentos" >> /tmp/resultado-$$ ;;
      8*) echo -n "oitocentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
   9) case $Centena$Dezena$Unidade in
      900) echo -n "novecentos" >> /tmp/resultado-$$ ;;
      9*) echo -n "novecentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
   esac ;;
esac
}

# Função para inserir as concordâncias nominais após os valores numéricos lidos em cada unidade, dezena ou centena.
# NOTE - Deve ser chamada sempre após a leitura da unidade, dezena ou centena, nunca antes da leitura.
ConcordanciaCentenaNumerica () {
   # Deve receber como parâmetro a posição da centena que está sendo lida:
   case $1 in
      1) case $ValorCentena in
         1) echo -n "" >>/tmp/resultado-$$ ;;
         *) echo -n "" >>/tmp/resultado-$$ ;;
      esac ;;
      2) case $ValorCentena in
         000) echo -n " de " >>/tmp/resultado-$$ ;;
         *) echo -n " mil e " >>/tmp/resultado-$$ ;;
      esac ;;
      3) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " milhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " milhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      4) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " bilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " bilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      5) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " trilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " trilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      6) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " quadrilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " quadrilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      7) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " quintilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " quintilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      8) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " sextilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " sextilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      9) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " setilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " setilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      10) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " octilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " octilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      11) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " nonilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " nonilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      12) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " decilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " decilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      13) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " undecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " undecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      14) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " duodecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " duodecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      15) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " tredecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " tredecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      16) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " quatordecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " quatordecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      17) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " quindecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " quindecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      18) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " sexdecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " sexdecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      19) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " setedecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " setedecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      20) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " octodecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " octodecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      21) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " novedecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " novedecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      21) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " vigesilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " vigesilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
   esac   
}

# Função para inserir as concordâncias nominais após os valores monetários lidos em cada unidade, dezena ou centena.
# NOTE - Deve ser chamada sempre após a leitura da unidade, dezena ou centena, nunca antes da leitura.
ConcordanciaCentenaMonetaria () {
   # Deve receber como parâmetro a posição da centena que está sendo lida:
   case $1 in
      1) case $ValorCentena in
         1) echo -n " real " >>/tmp/resultado-$$ ;;
         *) echo -n " reais " >>/tmp/resultado-$$ ;;
      esac ;;
      2) case $ValorCentena in
         000) echo -n " de " >>/tmp/resultado-$$ ;;
         *) echo -n " mil e " >>/tmp/resultado-$$ ;;
      esac ;;
      3) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " milhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " milhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      4) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " bilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " bilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      5) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " trilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " trilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      6) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " quadrilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " quadrilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      7) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " quintilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " quintilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      8) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " sextilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " sextilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      9) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " setilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " setilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      10) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " octilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " octilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      11) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " nonilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " nonilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      12) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " decilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " decilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      13) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " undecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " undecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      14) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " duodecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " duodecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      15) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " tredecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " tredecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      16) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " quatordecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " quatordecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      17) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " quindecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " quindecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      18) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " sexdecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " sexdecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      19) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " setedecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " setedecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      20) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " octodecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " octodecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      21) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " novedecilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " novedecilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
      21) case $ValorCentena in
         000) echo -n "" > /dev/null ;;
         1) echo -n " vigesilhão, " >>/tmp/resultado-$$ ;;
         *) echo -n " vigesilhões, " >>/tmp/resultado-$$ ;;
      esac ;;
   esac   
}

# Função para ler os meses do ano:
Meses () {
# O número do mês deve ser passado por parâmetro em $1
case $1 in
   1|01) echo -n "Janeiro" >> /tmp/resultado-$$ ;;
   2|02) echo -n "fevereiro" >> /tmp/resultado-$$ ;;
   3|03) echo -n "março" >> /tmp/resultado-$$ ;;
   4|04) echo -n "abril" >> /tmp/resultado-$$ ;;
   5|05) echo -n "maio" >> /tmp/resultado-$$ ;;
   6|06) echo -n "junho" >> /tmp/resultado-$$ ;;
   7|07) echo -n "julho" >> /tmp/resultado-$$ ;;
   8|08) echo -n "agosto" >> /tmp/resultado-$$ ;;
   9|09) echo -n "setembro" >> /tmp/resultado-$$ ;;
   10) echo -n "outubro" >> /tmp/resultado-$$ ;;
   11) echo -n "novembro" >> /tmp/resultado-$$ ;;
   12) echo -n "dezembro" >> /tmp/resultado-$$ ;;
   *) echo "ERRO [ $2 ] parâmetro incorreto para meses do ano (1-12)" > /tmp/resultado-$$ ;;
esac
}

# Função que mostra o resultado na tela depois que os valores foram lidos:
MostraResultado () {
# Exibindo o resultado:
Resultado=`cat /tmp/resultado-$$`
echo "$Resultado"
}

# Função que remove todos os arquivos temporários criados durante a execução do script:
RemoveTemporarios () {
# Removendo os arquivos temporários:
rm -Rf /tmp/*-$$
}

#-------------------------------------------------------------------------------------
# Tratando somene as opções de ajuda:
case $1 in
#-------------------------------------------------------------------------------------
# Mostra a ajuda geral e sai do script:
   -h|--help)
   clear
   echo "$Ajuda $Opcoes"
   echo
   exit 0 ;;
#-------------------------------------------------------------------------------------
# Mostra a versão atual do script e sai:
   -v|--versao)
   clear
   echo " [`basename $0`]"
   echo
   # Buscando a versão:
   grep '^# Versão ' "$0" | tail -1 | cut -d : -f 1 | tr -d \#
   # Buscando o autor e a data:
   grep '^# Versão ' "$0" | tail -1 | cut -d : -f 2 | tr -d \#
   echo
   # Buscando a descrição da versão:
   grep '^# Versão ' "$0" | tail -1 | cut -d : -f 3 | tr -d \#
   echo
   exit 0 ;;
#-------------------------------------------------------------------------------------
# Mostra exemplos de execução do script e sai:
   -e|--exemplo)
   clear
   echo " [`basename $0`]"
   echo
   echo " Voce pode executar este script das seguntes formas:"
   echo "$Exemplos"
   echo
   exit 0 ;;
#-------------------------------------------------------------------------------------
# Lista todas as dependências do script e verifica quais estão faltando. Após sai:
   -d|--depende)
   clear
   echo " [`basename $0`]"
   echo
   # Aqui está a lista de dependências do script:
   Dependencias="
   cat
   tac
   seq
   grep
   mv
   cut
   sed
   wc
   bc
   tee
   rm
   "
   # Exibindo a lista de dependências:
   echo "   =============================================================="
   echo "   Este script posui as seguintes dependências:"
   echo "   $Dependencias"
   echo "   =============================================================="
   echo "   Verificando se todas as dependênicas estão satisfeitas:"
   echo
   # Retornando o IFS normal para o for poder trabalhar com espaços como delimitadores de string:
   IFS="$Ifsvelho"
   for x in "$Dependencias" ; do
      # Verificando se a dependência está instalada:
      which $x >&2> /dev/null
      if [ $? = 0 ]; then
         touch /tmp/depende-$$
      else
         echo "$x" >> /tmp/depende-$$
      fi
   done
   # Modificando novamente o IFS para ler nomes com espaços:
   IFS='
'
   # Caso foi encontrado alguma dependência faltando no sistema, coloca-se elas em uma variável e se da a mensagem final antes de sair do script:
   Depende=`cat /tmp/depende-$$`
   if [ ! -z $Depende ]; then
      echo "   ÔÔPss!"
      echo "   Foram ecnontradas as seguintes dependências em seu sistema:"
      echo "   $Depende"
      echo "   Caso o script não consiga resolvê-las, instalá-las manualmente"
      echo
      rm -Rf /tmp/*-$$
   else
      echo "   OK"
      echo "   Todas as dependências necessárias foram satisfeitas"
      echo
      rm -Rf /tmp/*-$$
   fi
   exit 0 ;;
#-------------------------------------------------------------------------------------
# Aqui ele simplismente ignora a opção e passa a diante entrando no while de processamento, pois todas as opções a baixo são as opções de leitura de números. Se ele sair aqui ele nunca irá processar nada a não ser as opções de ajuda:
      -n|--numero) echo "" > /dev/null ;;
      -V|--valor) echo "" > /dev/null ;;
      -D|--data) echo "" > /dev/null ;;
      -H|--hora) echo "" > /dev/null ;;
      -s|--semana) echo "" > /dev/null ;;
      -m|--mes) echo "" > /dev/null ;;
#-------------------------------------------------------------------------------------
# Caso seja passado uma opção desconhecida, da a mensagem de erro e sai:
      *)
      if test -n "$1" ; then # Ou if [ -n "$1" ]; then
         clear
         echo "Opção inválida [ $1 ]"
         echo "Utilize as seguntes opções $Opcoes"
         echo
         exit 1
      fi ;;
esac

# Fazendo a leitura dos dados de acordo com as opções passadas:
# Se o usuário não passou a opção e o parâmetro necessário para o processamento, simplesmente não faz nada:
while [ -n "$1" ] && [ -n "$2" ] ; do
   case "$1" in
#-------------------------------------------------------------------------------------
      -n|--numero)
      # Preparando o número a ser escrito por extenso:
      echo $2 > /tmp/valor-$$
      # Verificando se o usuário digitou algo:
      grep [0123456789] /tmp/valor-$$ > /dev/null
      [ $? != 0 ] && echo "ERRO = Nenhum número encontrado para processar" > /tmp/resultado-$$
      # Verificando se o usuário digitou letras:
      grep -i [abcdefghijlmnopqrstuvxzywk] /tmp/valor-$$ > /dev/null
      [ $? = 0 ] && echo "ERRO = Número inválido, possui letras" > /tmp/resultado-$$
      # Apagando todos os zeros que por ventura o usuário tenha digitado a esquerda e que não possuem valor. Ex.: 000010,32
      cat /tmp/valor-$$ | sed 's/^0\+//g' > /tmp/sem-zeros-esquerda-$$
      mv /tmp/sem-zeros-esquerda-$$ /tmp/valor-$$
      # Iniciando a leitura dos números:
      # Verificando se tem vírgula, se tiver pega só o que está após a vírgula e processa:
      grep "\," /tmp/valor-$$ > /dev/null
      # Caso o número digitado tenha vírgula:
      if [ $? = 0 ] ; then
         # Pegando somente as casas decimais para guardar para ser processado depois:
         CasasDecimais=`cat /tmp/valor-$$ | cut -d',' -f2`
         # Pegando os números inteiros sem os pontos para processar agora:
         Numero=`cat /tmp/valor-$$ | sed 's/\.//g' | cut -d',' -f1`
         # Colocando somente os números inteiros no arquivo de /tmp/valor-$$:
         echo "$Numero" > /tmp/valor-$$
         # Contando os caracteres dos números inteiros:
         Caracteres=`cat /tmp/valor-$$ | wc -c`
         CaracteresReal=$((Caracteres - 1))
         # Se a quantidade de caracteres for maior do que três então divide em blocos de três:
         if [ "$CaracteresReal" -ge 4 ] ; then
            # Zerando a contágem dos arquivos temporários de referência:
            CentenaInteiros="0"
            # Dividindo de três em três para fazer a leiutura:
            while [ "$CaracteresReal" -ge 3 ] ; do
               # Contando a centena de inteiros:
               CentenaInteiros=$((CentenaInteiros + 1))
               # Diminuindo 3 caracteres do total e marcando no nome de um arquivo temporário só como referência:
               CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
            done   
            # Contando quantas centena inteiras de três dígitos temos para ler:
            CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
            # Caso tenha sobrado algo, inicie a leitura por aqui:
            [ "$CaracteresReal" != "0" ] && {
               # Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 e o final é igual ao número de caracteres que sobrou dentro da variável CaracteresReal:
               CaracterFinal=$CaracteresReal
               # Pegando somente os dígitos que sobraram na última centena:
               ValorCentena=`echo $Numero | cut -c1-$CaracterFinal`
               # Colocando o valor da centena no arquivo /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
               echo "$ValorCentena" > /tmp/valor-$$
               # Chamando a função corespondente para leitura:
               case $CaracteresReal in
                  1) Unidade 1 ;;
                  2) Dezena 1 2 ;;
                  3) Centena 1 2 3 ;;
               esac
               # Encontrando a posição da centena para inserir a concordância correta:
               PosicaoCentena=$((CentenasInteiraALer + 1))
               # Inserindo a concordância:
               ConcordanciaCentenaNumerica $PosicaoCentena >> /tmp/resultado-$$
               #Definindo o caracter inicial para a próxima centena:
               CaracterInicial=$((CaracterFinal + 1))
            }
            # Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:
            for x in `seq 1 $CentenasInteiraALer | tac` ; do
               # Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
               [ "$CaracterInicial" ] || CaracterInicial="1"
               # Definindo o caracter final para esta centena que está sendo processada:
               CaracterFinal=$((CaracterInicial + 2))
               # Coletando os caracteres para serem lidos:
               ValorCentena=`echo $Numero | cut -c$CaracterInicial-$CaracterFinal`
               # Colocando o valor da centena no arquivo /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
               echo "$ValorCentena" > /tmp/valor-$$
               # Como aqui dentro do for todas as centenas terão 3 dígitos, basta chamar a função Centena com seus parâmetros necessários:
               Centena 1 2 3      
               # Inserindo a concordância de acordo com a sequência gerada pelo seq e invertida pelo tac:
               ConcordanciaCentenaNumerica $x # >> /tmp/resultado-$$
               #Definindo o caracter inicial para a próxima centena:
               CaracterInicial=$((CaracterFinal + 1))
            done
         else
            # Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso divií-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
            case $CaracteresReal in
               1) Unidade 1 ; ConcordanciaCentenaNumerica 1 ;;
               2) Dezena 1 2 ; ConcordanciaCentenaNumerica 1 ;;
               3) Centena 1 2 3 ; ConcordanciaCentenaNumerica 1 ;;
            esac
         fi
         # Feito a leitura de todas as centenas dos números inteiros e já inserido suas respectivas concordâncias, agora é hora de ler as casas decimais pois o número possuia uma vírgula.
         # Se o valor das casas decimais for 00 não deve executar a leitura:
         [ "$CasasDecimais" != "00" ] && {
            # Contando quantos caracteres possui a casa decimal:
            CaracterDecimal=`echo "$CasasDecimais" | wc -c`
            CaracterDecimalReal=$((CaracterDecimal - 1))
            # Se o valor das casas decimais só tiver um único dígito (ex.: 14,3), então complete com zero:
            [ $CaracterDecimalReal -lt 2 ] && CasasDecimais=`echo $CasasDecimais{FONTE}`
            # Colocando somente as casas decimais no arquivo de /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
            echo "$CasasDecimais" > /tmp/valor-$$
            # Inserindo a concordância entre os números inteiros e as casas decimais no arquivo de resultado:
            echo -n " vígula " >>/tmp/resultado-$$
            # Fazendo a leitura do valor das casas decimais. Como será lido somente dois dígitos, então basta chamar a função Dezena com seus parâmetros necessários:
            Dezena 1 2
         }
      # Caso o número digitado não tenha vírgula:
      else
         # Eliminando os pontos separadores de milhar caso o usuário os tenha digitado:
         Numero=`cat /tmp/valor-$$ | sed 's/\.//g'`
         # Colocando somente os números inteiros no arquivo de /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
         echo "$Numero" > /tmp/valor-$$
         # Contando quantos caracteres compões o número:
         Caracteres=`cat /tmp/valor-$$ | wc -c`
         # Diminuindo o caracter de espaço ou nova linha que é inserido automaticamente quando se redireciona algo para um arquivo de texto:
         CaracteresReal=$((Caracteres - 1))
         # Se a quantidade de caracteres for maior do que três então divide em blocos de três:
         if [ "$CaracteresReal" -ge 4 ] ; then
            # Zerando a contágem das centenas dos números inteiros:
            CentenaInteiros="0"
            # Dividindo de três em três para fazer a leiutura:
            while [ "$CaracteresReal" -ge 3 ] ; do
               # Contando a centena de inteiros:
               CentenaInteiros=$((CentenaInteiros + 1))
               # Diminuindo 3 caracteres do total e marcando em um arquivo temporário:
               CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
            done   
            # Contando quantas centena inteiras de três dígitos temos para ler:
            CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
            # Caso tenha sobrado algo, inicie a leitura por aqui:
            [ "$CaracteresReal" != "0" ] && {
               # Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 o o final é igual ao número de caracteres que sobrou:
               CaracterFinal=$CaracteresReal
               # Pegando somente os dígitos que sobraram na última centena:
               ValorCentena=`echo $Numero | cut -c1-$CaracterFinal`
               # Colocando o valor da centena no arquivo /tmp/valor-$$:
               echo "$ValorCentena" > /tmp/valor-$$
               # Chamando a função corespondente para leitura:
               case $CaracteresReal in
                  1) Unidade 1 ;;
                  2) Dezena 1 2 ;;
                  3) Centena 1 2 3 ;;
               esac
               # Encontrando a posição da centena para inserir a concordância:
               PosicaoCentena=$((CentenasInteiraALer + 1))
               # Inserindo a concordância:
               ConcordanciaCentenaNumerica $PosicaoCentena >> /tmp/resultado-$$
               #Definindo o caracter inicial para a próxima centena:
               CaracterInicial=$((CaracterFinal + 1))
            }
            # Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:   
            for x in `seq 1 $CentenasInteiraALer | tac` ; do
               # Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
               [ "$CaracterInicial" ] || CaracterInicial="1"
               # Definindo o caracter final para esta centena que está sendo processada:
               CaracterFinal=$((CaracterInicial + 2))
               # Coletando os caracteres para serem lidos:
               ValorCentena=`echo $Numero | cut -c$CaracterInicial-$CaracterFinal`
               # Colocando o valor da centena no arquivo /tmp/valor-$$:
               echo "$ValorCentena" > /tmp/valor-$$
               # Chamando a função corespondente para leitura:
               Centena 1 2 3
               # Inserindo a concordância:
               ConcordanciaCentenaNumerica $x # >> /tmp/resultado-$$
               #Definindo o caracter inicial para a próxima centena:
               CaracterInicial=$((CaracterFinal + 1))
            done
         else
            # Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso dividí-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
            # Coletando o valor da centena para servir de referência para a função ConcordanciaCentena:
            ValorCentena=`cat /tmp/valor-$$`
            # Aqui é preciso analizar quantos caracteres tem (unidade, dezena ou centena), chamar a função corespondente para fazer a leitura do número, e depois chamar a função ConcordanciaCentena para inserir a concordância final:
            case $CaracteresReal in
               1) Unidade 1 ; ConcordanciaCentenaNumerica 1 ;;
               2) Dezena 1 2 ; ConcordanciaCentenaNumerica 1 ;;
               3) Centena 1 2 3 ; ConcordanciaCentenaNumerica 1 ;;
            esac
         fi
      fi
      # Exibindo o resultado:
      MostraResultado ;;
#-------------------------------------------------------------------------------------
      -V|--valor)
      # Preparando o número a ser escrito por extenso:
      echo $2 > /tmp/valor-$$
      # Verificando se o usuário digitou algo:
      grep [0123456789] /tmp/valor-$$ > /dev/null
      [ $? != 0 ] && echo "ERRO = Nenhum número encontrado para processar" > /tmp/resultado-$$
      # Verificando se o usuário digitou letras:
      grep -i [abcdefghijlmnopqrstuvxzywk] /tmp/valor-$$ > /dev/null
      [ $? = 0 ] && echo "ERRO = Número inválido, possui letras" > /tmp/resultado-$$
      # Apagando todos os zeros que por ventura o usuário tenha digitado a esquerda e que não possuem valor. Ex.: 000010,32
      cat /tmp/valor-$$ | sed 's/^0\+//g' > /tmp/sem-zeros-esquerda-$$
      mv /tmp/sem-zeros-esquerda-$$ /tmp/valor-$$
      # Iniciando a leitura dos números:
      # Verificando se tem vírgula, se tiver pega só o que está após a vírgula e processa:
      grep "\," /tmp/valor-$$ > /dev/null
      # Caso o número digitado tenha vírgula:
      if [ $? = 0 ] ; then
         # Pegando somente as casas decimais para guardar para ser processado depois:
         CasasDecimais=`cat /tmp/valor-$$ | cut -d',' -f2`
         # Pegando os números inteiros sem os pontos para processar agora:
         Numero=`cat /tmp/valor-$$ | sed 's/\.//g' | cut -d',' -f1`
         # Colocando somente os números inteiros no arquivo de /tmp/valor-$$:
         echo "$Numero" > /tmp/valor-$$
         # Contando os caracteres dos números inteiros:
         Caracteres=`cat /tmp/valor-$$ | wc -c`
         CaracteresReal=$((Caracteres - 1))
         # Se a quantidade de caracteres for maior do que três então divide em blocos de três:
         if [ "$CaracteresReal" -ge 4 ] ; then
            # Zerando a contágem dos arquivos temporários de referência:
            CentenaInteiros="0"
            # Dividindo de três em três para fazer a leiutura:
            while [ "$CaracteresReal" -ge 3 ] ; do
               # Contando a centena de inteiros:
               CentenaInteiros=$((CentenaInteiros + 1))
               # Diminuindo 3 caracteres do total e marcando no nome de um arquivo temporário só como referência:
               CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
            done   
            # Contando quantas centena inteiras de três dígitos temos para ler:
            CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
            # Caso tenha sobrado algo, inicie a leitura por aqui:
            [ "$CaracteresReal" != "0" ] && {
               # Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 e o final é igual ao número de caracteres que sobrou dentro da variável CaracteresReal:
               CaracterFinal=$CaracteresReal
               # Pegando somente os dígitos que sobraram na última centena:
               ValorCentena=`echo $Numero | cut -c1-$CaracterFinal`
               # Colocando o valor da centena no arquivo /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
               echo "$ValorCentena" > /tmp/valor-$$
               # Chamando a função corespondente para leitura:
               case $CaracteresReal in
                  1) Unidade 1 ;;
                  2) Dezena 1 2 ;;
                  3) Centena 1 2 3 ;;
               esac
               # Encontrando a posição da centena para inserir a concordância correta:
               PosicaoCentena=$((CentenasInteiraALer + 1))
               # Inserindo a concordância:
               ConcordanciaCentenaMonetaria $PosicaoCentena >> /tmp/resultado-$$
               #Definindo o caracter inicial para a próxima centena:
               CaracterInicial=$((CaracterFinal + 1))
            }
            # Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:
            for x in `seq 1 $CentenasInteiraALer | tac` ; do
               # Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
               [ "$CaracterInicial" ] || CaracterInicial="1"
               # Definindo o caracter final para esta centena que está sendo processada:
               CaracterFinal=$((CaracterInicial + 2))
               # Coletando os caracteres para serem lidos:
               ValorCentena=`echo $Numero | cut -c$CaracterInicial-$CaracterFinal`
               # Colocando o valor da centena no arquivo /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
               echo "$ValorCentena" > /tmp/valor-$$
               # Como aqui dentro do for todas as centenas terão 3 dígitos, basta chamar a função Centena com seus parâmetros necessários:
               Centena 1 2 3      
               # Inserindo a concordância de acordo com a sequência gerada pelo seq e invertida pelo tac:
               ConcordanciaCentenaMonetaria $x # >> /tmp/resultado-$$
               #Definindo o caracter inicial para a próxima centena:
               CaracterInicial=$((CaracterFinal + 1))
            done
         else
            # Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso divií-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
            case $CaracteresReal in
               1) Unidade 1 ; ConcordanciaCentenaMonetaria 1 ;;
               2) Dezena 1 2 ; ConcordanciaCentenaMonetaria 1 ;;
               3) Centena 1 2 3 ; ConcordanciaCentenaMonetaria 1 ;;
            esac
         fi
         # Feito a leitura de todas as centenas dos números inteiros e já inserido suas respectivas concordâncias, agora é hora de ler as casas decimais pois o número possuia uma vírgula.
         # Se o valor das casas decimais for 00 não deve executar a leitura:
         [ "$CasasDecimais" != "00" ] && {
            # Contando quantos caracteres possui a casa decimal:
            CaracterDecimal=`echo "$CasasDecimais" | wc -c`
            CaracterDecimalReal=$((CaracterDecimal - 1))
            # Se o valor das casas decimais só tiver um único dígito (ex.: 14,3), então complete com zero:
            [ $CaracterDecimalReal -lt 2 ] && CasasDecimais=`echo $CasasDecimais{FONTE}`
            # Colocando somente as casas decimais no arquivo de /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
            echo "$CasasDecimais" > /tmp/valor-$$
            # Inserindo a concordância entre os números inteiros e as casas decimais no arquivo de resultado:
            echo -n "com " >>/tmp/resultado-$$
            # Fazendo a leitura do valor das casas decimais. Como será lido somente dois dígitos, então basta chamar a função Dezena com seus parâmetros necessários:
            Dezena 1 2
            # Inserindo a finalização de concordância:
            echo -n " centavos" >>/tmp/resultado-$$
         }
      # Caso o número digitado não tenha vírgula:
      else
         # Eliminando os pontos separadores de milhar caso o usuário os tenha digitado:
         Numero=`cat /tmp/valor-$$ | sed 's/\.//g'`
         # Colocando somente os números inteiros no arquivo de /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
         echo "$Numero" > /tmp/valor-$$
         # Contando quantos caracteres compões o número:
         Caracteres=`cat /tmp/valor-$$ | wc -c`
         # Diminuindo o caracter de espaço ou nova linha que é inserido automaticamente quando se redireciona algo para um arquivo de texto:
         CaracteresReal=$((Caracteres - 1))
         # Se a quantidade de caracteres for maior do que três então divide em blocos de três:
         if [ "$CaracteresReal" -ge 4 ] ; then
            # Zerando a contágem das centenas dos números inteiros:
            CentenaInteiros="0"
            # Dividindo de três em três para fazer a leiutura:
            while [ "$CaracteresReal" -ge 3 ] ; do
               # Contando a centena de inteiros:
               CentenaInteiros=$((CentenaInteiros + 1))
               # Diminuindo 3 caracteres do total e marcando em um arquivo temporário:
               CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
            done   
            # Contando quantas centena inteiras de três dígitos temos para ler:
            CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
            # Caso tenha sobrado algo, inicie a leitura por aqui:
            [ "$CaracteresReal" != "0" ] && {
               # Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 o o final é igual ao número de caracteres que sobrou:
               CaracterFinal=$CaracteresReal
               # Pegando somente os dígitos que sobraram na última centena:
               ValorCentena=`echo $Numero | cut -c1-$CaracterFinal`
               # Colocando o valor da centena no arquivo /tmp/valor-$$:
               echo "$ValorCentena" > /tmp/valor-$$
               # Chamando a função corespondente para leitura:
               case $CaracteresReal in
                  1) Unidade 1 ;;
                  2) Dezena 1 2 ;;
                  3) Centena 1 2 3 ;;
               esac
               # Encontrando a posição da centena para inserir a concordância:
               PosicaoCentena=$((CentenasInteiraALer + 1))
               # Inserindo a concordância:
               ConcordanciaCentenaMonetaria $PosicaoCentena >> /tmp/resultado-$$
               #Definindo o caracter inicial para a próxima centena:
               CaracterInicial=$((CaracterFinal + 1))
            }
            # Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:   
            for x in `seq 1 $CentenasInteiraALer | tac` ; do
               # Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
               [ "$CaracterInicial" ] || CaracterInicial="1"
               # Definindo o caracter final para esta centena que está sendo processada:
               CaracterFinal=$((CaracterInicial + 2))
               # Coletando os caracteres para serem lidos:
               ValorCentena=`echo $Numero | cut -c$CaracterInicial-$CaracterFinal`
               # Colocando o valor da centena no arquivo /tmp/valor-$$:
               echo "$ValorCentena" > /tmp/valor-$$
               # Chamando a função corespondente para leitura:
               Centena 1 2 3
               # Inserindo a concordância:
               ConcordanciaCentenaMonetaria $x # >> /tmp/resultado-$$
               #Definindo o caracter inicial para a próxima centena:
               CaracterInicial=$((CaracterFinal + 1))
            done
         else
            # Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso dividí-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
            # Coletando o valor da centena para servir de referência para a função ConcordanciaCentena:
            ValorCentena=`cat /tmp/valor-$$`
            # Aqui é preciso analizar quantos caracteres tem (unidade, dezena ou centena), chamar a função corespondente para fazer a leitura do número, e depois chamar a função ConcordanciaCentena para inserir a concordância final:
            case $CaracteresReal in
               1) Unidade 1 ; ConcordanciaCentenaMonetaria 1 ;;
               2) Dezena 1 2 ; ConcordanciaCentenaMonetaria 1 ;;
               3) Centena 1 2 3 ; ConcordanciaCentenaMonetaria 1 ;;
            esac
         fi
      fi
      # Exibindo o resultado:
      MostraResultado ;;
#-------------------------------------------------------------------------------------
      -D|--data)
      # Separando as partes de dia, mês e ano:
      Dia=`echo $2 | cut -d'/' -f1`
      Mes=`echo $2 | cut -d'/' -f2`
      Ano=`echo $2 | cut -d'/' -f3`
      # Verificando o mês inforamdo não maior do que 12:
      [ $Mes -gt 12 ] && { echo "ERRO, UM ANO SÓ TEM 12 MÊSES" ; RemoveTemporarios ; exit 1 ; }
      # Verificando se o ano é ou não bissexto:
      if(( ("$Ano"%400)=="0")) || (( ("$Ano"%4=="0")&&("$Ano"%100!="0") )); then
         # É bisexto:
         Bissexto=1
      else
         # Não é bisexto:
         Bissexto=0
      fi
      # Verificando o dia informado na data de acordo com a quantidade de dias do mês:
      # Janeiro:
      [ "$Mes" = "01" -a "$Dia" -gt 31 ] && { echo "ERRO, JANEIRO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Fevereiro:
      case $Bissexto in
         0) [ "$Mes" = "02" -a "$Dia" -gt 28 ] && { echo "ERRO, FEVEREIRO EM ANOS NÃO BISEXTO SÓ TEM 28 DIAS" ; RemoveTemporarios ; exit 1 ; } ;;
         1) [ "$Mes" = "02" -a "$Dia" -gt 29 ] && { echo "ERRO, FEVEREIRO EM ANOS BISEXTOS SÓ TEM 29 DIAS" ; RemoveTemporarios ; exit 1 ; } ;;
      esac
      # Março:
      [ "$Mes" = "03" -a "$Dia" -gt 31 ] && { echo "ERRO, MARÇO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Abril:
      [ "$Mes" = "04" -a "$Dia" -gt 30 ] && { echo "ERRO, ABRIL SÓ TEM 30 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Maio:
      [ "$Mes" = "05" -a "$Dia" -gt 31 ] && { echo "ERRO, MAIO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Junho:
      [ "$Mes" = "06" -a "$Dia" -gt 30 ] && { echo "ERRO, JUNHO SÓ TEM 30 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Julho:
      [ "$Mes" = "07" -a "$Dia" -gt 31 ] && { echo "ERRO, JULHO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Agosto:
      [ "$Mes" = "08" -a "$Dia" -gt 31 ] && { echo "ERRO, AGOSTO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Setembro:
      [ "$Mes" = "09" -a "$Dia" -gt 30 ] && { echo "ERRO, SETEMBRO SÓ TEM 30 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Outubro:
      [ "$Mes" = "10" -a "$Dia" -gt 31 ] && { echo "ERRO, OUTUBRO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Novembro:
      [ "$Mes" = "11" -a "$Dia" -gt 30 ] && { echo "ERRO, NOVEMBRO SÓ TEM 30 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Dezembro:
      [ "$Mes" = "12" -a "$Dia" -gt 31 ] && { echo "ERRO, DEZEMBRO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
      # Fazendo a leitura do dia:
      echo $Dia > /tmp/valor-$$
      DezenaData 1 2
      # Inserindo a concordância:
      echo -n " de " >> /tmp/resultado-$$
      # Fazendo a leitura do mês:
      Meses $Mes
      # Inserindo a concordância:
      echo -n " do ano " >> /tmp/resultado-$$
      # Fazendo a leitura do ano:
      echo $Ano | sed 's/[0]\+/0/g' > /tmp/valor-$$
      # Contando quantos caracteres compões o número:
      Caracteres=`cat /tmp/valor-$$ | wc -c`
      # Diminuindo o caracter de espaço ou nova linha que é inserido automaticamente quando se redireciona algo para um arquivo de texto:
      CaracteresReal=$((Caracteres - 1))
      # Se a quantidade de caracteres for maior do que três então divide em blocos de três:
      if [ "$CaracteresReal" -ge 4 ] ; then
         # Zerando a contágem das centenas dos números inteiros:
         CentenaInteiros="0"
         # Dividindo de três em três para fazer a leiutura:
         while [ "$CaracteresReal" -ge 3 ] ; do
            # Contando a centena de inteiros:
            CentenaInteiros=$((CentenaInteiros + 1))
            # Diminuindo 3 caracteres do total e marcando em um arquivo temporário:
            CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
         done   
         # Contando quantas centena inteiras de três dígitos temos para ler:
         CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
         # Caso tenha sobrado algo, inicie a leitura por aqui:
         [ "$CaracteresReal" != "0" ] && {
            # Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 o o final é igual ao número de caracteres que sobrou:
            CaracterFinal=$CaracteresReal
            # Pegando somente os dígitos que sobraram na última centena:
            ValorCentena=`echo $Ano | cut -c1-$CaracterFinal`
            # Colocando o valor da centena no arquivo /tmp/valor-$$:
            echo "$ValorCentena" > /tmp/valor-$$
            # Chamando a função corespondente para leitura:
            case $CaracteresReal in
               1) Unidade 1 ;;
               2) Dezena 1 2 ;;
               3) Centena 1 2 3 ;;
            esac
            # Encontrando a posição da centena para inserir a concordância:
            PosicaoCentena=$((CentenasInteiraALer + 1))
            # Inserindo a concordância:
            ConcordanciaCentenaNumerica $PosicaoCentena >> /tmp/resultado-$$
            #Definindo o caracter inicial para a próxima centena:
            CaracterInicial=$((CaracterFinal + 1))
         }
         # Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:   
         for x in `seq 1 $CentenasInteiraALer | tac` ; do
            # Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
            [ "$CaracterInicial" ] || CaracterInicial="1"
            # Definindo o caracter final para esta centena que está sendo processada:
            CaracterFinal=$((CaracterInicial + 2))
            # Coletando os caracteres para serem lidos:
            ValorCentena=`echo $Ano | cut -c$CaracterInicial-$CaracterFinal`
            # Colocando o valor da centena no arquivo /tmp/valor-$$:
            echo "$ValorCentena" > /tmp/valor-$$
            # Chamando a função corespondente para leitura:
            Centena 1 2 3
            # Inserindo a concordância:
# NOTE Mudar para concordancia de números não monetários
            ConcordanciaCentenaNumerica $x # >> /tmp/resultado-$$
            #Definindo o caracter inicial para a próxima centena:
            CaracterInicial=$((CaracterFinal + 1))
         done
      else
         # Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso dividí-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
         case $CaracteresReal in
            1) Unidade 1 ;;
            2) Dezena 1 2 ;;
            3) Centena 1 2 3 ;;
         esac
      fi
      # Exibindo o resultado:
      MostraResultado ;;
#-------------------------------------------------------------------------------------
      -H|--hora)
      # Separando as partes de hora, minutos, e segundos:
      Hora="`echo $2 | cut -d':' -f1`"
      Minutos="`echo $2 | cut -d':' -f2`"
      Segundos="`echo $2 | cut -d':' -f3`"
      # Verificando se foi digitado letras na hora, se foi, remove os arquivos temporários e para tudo:
      echo "$Hora" | grep -i [abcdefghijlmnopqrstuvxzywkç] > /dev/null && { echo "HORA INCORRETA, POSSUI LETRAS" ; RemoveTemporarios ; break ; }
      # Verificando se foi digitado letras nos minutos, se foi, remove os arquivos temporários e para tudo:
      echo "$Minutos" | grep -i [abcdefghijlmnopqrstuvxzywkç] > /dev/null && { echo "MINUTOS INCORRETOS, POSSUEM LETRAS" ; RemoveTemporarios ; break ; }
      # Verificando se foi digitado letras nos segundo, se foi, remove o s arquivos temporários e para tudo:
      echo "$Segundos" | grep -i [abcdefghijlmnopqrstuvxzywkç] > /dev/null && { echo "SEGUNDOS INCORRETOS, POSSUEM LETRAS" ; RemoveTemporarios ; break ; }
      # Verificando se foi digitado mais de dois números para cada campo de hora/minuto/segundos:
      # Hora:
      [ `echo $Hora | wc -c` -gt 3 ] && { echo "HORA INCORRETA, POSSUI MUITOS NÚMEROS" ; RemoveTemporarios ; break ; }
      # Minutos:
      [ `echo $Minutos | wc -c` -gt 3 ] && { echo "MINUTOS INCORRETO, POSSUI MUITOS NÚMEROS" ; RemoveTemporarios ; break ; }
      # Segundos:
      [ `echo $Segundos | wc -c` -gt 3 ] && { echo "SEGUNDOS INCORRETOS, POSSUI MUITOS NÚMEROS" ; RemoveTemporarios ; break ; }
      # Fazendo a verificação se a hora informada não é maior do que 23 e fazendo a leitura da hora:
      if [ "$Hora" -le 23 ] ; then
         # Inserindo a hora no arquivo /tmp/valor-$$ e retirando os zeros repetidos a esquerda:
         echo $Hora | sed 's/[0]\+/0/g' > /tmp/valor-$$
         # Lendo a hora:
         DezenaHora 1 2
         # Inserindo a concordância:
         if [ "$Minutos" = "00" ] && [ "$Segundos" = "00" ] ; then
            case $Hora in
               00|01) echo -n " hora" >> /tmp/resultado-$$ ;;
               *) echo -n " horas" >> /tmp/resultado-$$ ;;
            esac
         else
            case $Hora in
               00|01) echo -n " hora com " >> /tmp/resultado-$$ ;;
               *) echo -n " horas com " >> /tmp/resultado-$$ ;;
            esac
         fi
      else
         # Da a mensagem de erro:
         echo "ERRO NAS HORAS, O DIA SÓ TEM 24 HORAS"
         # Remove todos os arquivos temporários:
         RemoveTemporarios
         # Para a execução do script:
         break
      fi
      # Fazendo a verificação se os minutos informados não são maiores do que 59 e fazendo a leitura dos minutos:
      if [ "$Minutos" -le 59 ] ; then
         # Inserindo os minutos no arquivo /tmp/valor-$$ e retirando os zeros repetidos a esquerda:
         echo $Minutos | sed 's/[0]\+/0/g' > /tmp/valor-$$
         # Lendo a hora:
         Dezena 1 2
         # Inserindo a concordância:
         if [ "$Segundos" = "00" ] ; then
            case $Minutos in
               00|01) echo -n " minuto" >> /tmp/resultado-$$ ;;
               *) echo -n " minutos" >> /tmp/resultado-$$ ;;
            esac
         else
            case $Minutos in
               00|01) echo -n " minuto e " >> /tmp/resultado-$$ ;;
               *) echo -n " minutos e " >> /tmp/resultado-$$ ;;
            esac
         fi
      else
         # Da a mensagem de erro:
         echo "ERRO NOS MINUTOS, UMA HORA SÓ TEM 60 MINUTOS"
         # Remove os arquivos temporários:
         RemoveTemporarios
         # Para a execução do script:
         break
      fi
      # Fazendo a verificação se os segundos informados não são maiores do que 59 e fazendo a leitura dos segundos:
      if [ "$Segundos" -le 59 ] ; then
         # Inserindo os segundos no arquivo /tmp/valor-$$:
         echo $Segundos | sed 's/[0]\+/0/g' > /tmp/valor-$$
         # Lendo a hora:
         Dezena 1 2
         # Inserindo a concordância:
         case $Segundos in
            0|00) echo -n "" >> /dev/null ;;
            1|01) echo -n " segundo" >> /tmp/resultado-$$ ;;
            *) echo -n " segundos" >> /tmp/resultado-$$ ;;
         esac
      else
         # Da a mensagem de erro:
         echo "ERRO NOS SEGUNDOS, UM MINUTO SÓ TEM 60 SEGUNDOS"
         # Remove os arquivos temporários:
         RemoveTemporarios
         # Para a execução do script:
         break
      fi
      # Exibindo o resultado:
      MostraResultado ;;
#-------------------------------------------------------------------------------------
      -o|--ordem)
      # Preparando o número a ser escrito por extenso:
      echo $2 > /tmp/valor-$$
      # Verificando se o usuário digitou algo:
      grep [0123456789] /tmp/valor-$$ > /dev/null
      [ $? != 0 ] && echo "ERRO = Nenhum número encontrado para processar" > /tmp/resultado-$$
      # Verificando se o usuário digitou letras:
      grep -i [abcdefghijlmnopqrstuvxzywk] /tmp/valor-$$ > /dev/null
      [ $? = 0 ] && echo "ERRO = Número inválido, possui letras" > /tmp/resultado-$$
      # Apagando todos os zeros que por ventura o usuário tenha digitado a esquerda e que não possuem valor. Ex.: 000010,32
      cat /tmp/valor-$$ | sed 's/^0\+//g' > /tmp/sem-zeros-esquerda-$$
      mv /tmp/sem-zeros-esquerda-$$ /tmp/valor-$$
      DezenaOrdemMacho 1 2
      # Exibindo o resultado:
      MostraResultado ;;
#-------------------------------------------------------------------------------------
      -s|--semana)
      case $2 in
         1) echo "domingo" > /tmp/resultado-$$ ;;
         2) echo "segunda-feira" > /tmp/resultado-$$ ;;
         3) echo "terça-feira" > /tmp/resultado-$$ ;;
         4) echo "quarta-feira" > /tmp/resultado-$$ ;;
         5) echo "quinta-feira" > /tmp/resultado-$$ ;;
         6) echo "sexta-feira" > /tmp/resultado-$$ ;;
         7) echo "sábado" > /tmp/resultado-$$ ;;
         *) echo "ERRO [ $2 ] UMA SEMANA SÓ TEM 7 DIAS (1-7)" > /tmp/resultado-$$ ;;
      esac
      # Exibindo o resultado:
      MostraResultado ;;
   esac
#-------------------------------------------------------------------------------------
# Faz a fila de opções andar dois passos, pois cada opção necessita de seu parâmetro que deve ser processado juntamento com a opção chamada.
shift 2
done

#-------------------------------------------------------------------------------------
# Removendo os arquivos temporários:
RemoveTemporarios



Scripts recomendados
   Script Linux recomendado Iptables com Roteando via NAT
   Script Linux recomendado Enviar e-mails
   Script Linux recomendado Armazenando Endereços Web
   Script Linux recomendado Acessando o localhost pelo quanta
   Script Linux recomendado Instalando o REAPER no Ubuntu e Elementary OS

Comentários
[1] Comentário enviado por daemonio em 22/05/2012 - 13:17h:

Muito bom mesmo! Parabéns.



Contribuir com comentário


  
Para executar esta ação você precisa estar logado no site, caso contrário, tudo o que for digitado será perdido.
Responsável pelo site: Fábio Berbert de Paula - Conteúdo distribuído sob licença GNU FDL
Site hospedado por:

Viva o Linux

A maior comunidade Linux da América Latina! Artigos, dicas, tutoriais, fórum, scripts e muito mais. Ideal para quem busca auto-ajuda em Linux.