Escrever números, datas, horas e outros por extenso
Publicado por Elias Bernabé Turchiello (última atualização em 21/05/2012)
[ Hits: 19.936 ]
Homepage: www.turchiellows.xpg.com.br
Download numeros-por-extenso-texto.sh
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
#!/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 para renomear vários arquivos ao mesmo tempo.
Instalador de novas versões do Java no Debian
Somatório de valores do comando ps
Instalação do Ubuntu com Criptografia Total
Comentários
Patrocínio
Site hospedado pelo provedor RedeHost.
Destaques
Artigos
Enviar mensagem ao usuário trabalhando com as opções do php.ini
Meu Fork do Plugin de Integração do CVS para o KDevelop
Compartilhando a tela do Computador no Celular via Deskreen
Como Configurar um Túnel SSH Reverso para Acessar Sua Máquina Local a Partir de uma Máquina Remota
Configuração para desligamento automatizado de Computadores em um Ambiente Comercial
Dicas
Compartilhamento de Rede com samba em modo Público/Anônimo de forma simples, rápido e fácil
Cups: Mapear/listar todas as impressoras de outro Servidor CUPS de forma rápida e fácil
Criando uma VPC na AWS via CLI
Tópicos
Tem como instalar o gerenciador AMD Adrenalin no Ubuntu 24.04? (6)
Top 10 do mês
-
Xerxes
1° lugar - 67.556 pts -
Fábio Berbert de Paula
2° lugar - 49.930 pts -
Renato Michnik de Carvalho
3° lugar - 27.312 pts -
Buckminster
4° lugar - 17.120 pts -
Mauricio Ferrari
5° lugar - 14.988 pts -
Alberto Federman Neto.
6° lugar - 14.195 pts -
Diego Mendes Rodrigues
7° lugar - 13.587 pts -
Daniel Lara Souza
8° lugar - 13.577 pts -
edps
9° lugar - 11.504 pts -
Andre (pinduvoz)
10° lugar - 11.292 pts
Scripts
A maior comunidade GNU/Linux da América Latina! Artigos, dicas, tutoriais, fórum, scripts e muito mais. Ideal para quem busca auto-ajuda.
Site hospedado por:
