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



» Screenshot
Linux: Sabayon 10 Cinnamon no pendrive.
Por JJSantos
» 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)   [ 7341 hits ]

Login: turchiellows, 21306 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 Armazenando Endereços Web
   Script Linux recomendado Procura Arquivos
   Script Linux recomendado Adicionando Chaves de Repositórios Facilmente
   Script Linux recomendado Antiprotetor de links
   Script Linux recomendado Aprenda a falar os números de 0 a 99 em Inglês

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.