C Decodificar arquivo em morse

Luis Vilo · 11 de janeiro de 2020

Oi, gente! Como o @arfneto pediu tô postando um código aqui pra ver se ele ou outra pessoa podeolhar o q eu fiz errado e me ajudar, por favor. Tudo isso é um projeto de escola e eu tô tendo um pouco de dificuldade. Eu tenho de codificar um arquivo e decodificar esse arquivo. A parte de codificar eu já fiz, mas a de decodificar não tá dando muito certo. O problema é que eu Não posso usar funçoes como strcmp, sizeof, memcmp,etc.. para comparar as letras em morse(string), tenho de criar minha própria função e tô me embolando um pouco com isso. Além disso cada letra do arquivo que eu tenho de decodificar é separada por tres espaços e cada palavra por cinco (como no arquivo que anexei).

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

/* Constantes */
#define T_MORSE 8
#define Q_LETRAS 26
#define Q_NUMEROS 10
#define Q_MORSE (Q_LETRAS+Q_NUMEROS)
#define MAX_STRING_SIZE 100


typedef struct{
    char letras[5]; /* armazena a letra. A recebe como uma string , mas só usa a primeira letra */
    char letrasMorse[T_MORSE];/* armazena os respectivos simbolos morse */
}alfabeto;
alfabeto l[Q_MORSE];

void decodifica(const char *linha) {
    int j=0, i=0, p=0;
    char letra[6];
    while(i<strlen(linha)-1){ //lee a a frase inteira
        while (linha[i] == ' '){
          i++;
        }
        while((linha[i]) !=' '){
            letra[p]= linha[i]; //coloca o caracter de linha na posição i em letra na posição p
            scanf("%c", letra[p]);
            i++;
            p++;
        }while ((letra!=l[j].letrasMorse)&& (j<Q_MORSE)){
            j++;} //aponta para a proxiam letra ou numero
        for(p=0; letra[p]==l[j].letrasMorse[p] && letra[p]=='\0'; p++); // compara strings
        if (letra == l[j].letrasMorse){
              printf("%c", l[j].letras[0]);
        }
        j=0;
        p=0;
    }
}

int main(){
    int cont=0,j;
    FILE *arch;
    arch = fopen("morse.txt","r");
    if( arch == NULL ){
        printf("ERROR");
        return 0;
    }
    else{
        while(fscanf(arch,"%s%s",l[cont].letras,l[cont].letrasMorse) != EOF){
            l[cont].letras[1] = '\0'; /* elimina caracteres indesejados   */
            for(j=0; l[cont].letrasMorse[j]; j++){
                if(l[cont].letrasMorse[j] == '*'){ /* se encontra un asterisco   */
                   l[cont].letrasMorse[j] = '\0';  /* elimina o asterisco */
                   break;
                }
            }
            cont++;  /* aponta para a proxima posiçao do vetor      */
        }
    }
    fclose(arch);

    FILE *fp;
    char linha[MAX_STRING_SIZE];
    fp = fopen("codifica.txt", "r");
    if (arch==NULL){
    printf("ERROR");}
    while (fgets(linha,MAX_STRING_SIZE,fp) != NULL ) {
    decodifica(linha);
    }
    fclose(fp);

    return 0;
}

codifica.txt

arfneto · 11 de janeiro de 2020

8 horas atrás, Luis Vilo disse:

Além disso cada letra do arquivo que eu tenho de decodificar é separada por tres espaços e cada palavra por cinco (como no arquivo que anexei)

Antes uma convenção: codificar seria converter de texto para Morse. Decodificar seria converter de Morse para texto, recriando o arquivo original. Então já sabemos como testar o programa: a matemática diz que o inverso do inverso é a identidade, então ao codificar um arquivo e gerar um segundo e decodificar o segundo em um terceiro arquivo o primeiro será idêntico ao terceiro...

Acho que pela norma era pra ser de 7 espaços o intervalo e não cinco mas não faz diferença lógico. Eu usaria o que se chama de FST ou autômato finito em português, percorrendo essa árvore aí. Não é complicado, eu acho. Dê uma lida e volte a escrever. Ou uma estrutura inversa à que codifica.

Acompanhe.

Não precisa de fato das rotinas de manipulação de string apesar de poder querer usar.

Veja esse desenho que pode ajudar ... Era usado no treinamento e faz muito sentido

Este desenho está na wikipedia em https://pt.wikipedia.org/wiki/Código_Morse#/media/Ficheiro:Morse_code_tree3.svg

Ponto a esquerda, traço a direita. Mostra o caminho da codificação. E vai te dar uma ideia do que fazer, ainda que ao contrário. Era usado para treinamento.

Lembro que eu havia usado essa "estrutura" mínima abaixo para gravar os códigos:

struct morse
{
    char* valor[127];
};
typedef struct morse		Codigo_Morse;

Então para codificar em Morse está quase pronto porque é só um array de strings. Para tocar o código Morse a tabela está em ordem alfabética, o próprio código ASCII da letra. Você acessa a tabela com valor[ 'A' ] e tem um ponteiro para a string que representa o 'A' em Morse. Muito cômodo. Sem stress nem cálculos de deslocamento. Assim está no programa.

Agora o contrário pode ser feito, entre outras maneiras:

criando outra estrutura invertida, onde a string Morse aponta para a letra, usando aquele mesmo arquivo de entrada.
criando uma árvore como aquela que tem na figura, mas partindo do código, e escrevendo uma simples máquina de estados para percorrer.

Com qual se sentiria melhor? Qual sua ideia atual se diferente?

Veja uma possibilidade para a struct (a primeira opção)

struct morseToText
{ 
    char*   Morse;
    char    letra;
};
typedef struct morseToText		Decode;

Decode*    Matriz_Decode[127];

Como criar uma dessas?

Você tem a tabela normal, que mostra a string para a letra:

    Codigo_Morse    codigo;

Apenas copie os valores de codigo para a nova Matriz_Decode usando insertion sort, o mais simples: insere na ordem um a um.

Como usar?

Trivial: pega cada string que leu do arquivo a decodificar e procura nessa tabela. Seja

    char*    valor_morse
    char     valor_texto;

Na verdade estamos falando de apenas 36 valores então talvez seja frescura classificar Matriz_Decode. É só ir olhando até achar a igual. Compara letra a letra até o zero. strlen() acharia o zero, strcmp() compararia mas não precisamos de fato delas. Estamos falando de comparar meia dúzia de pontos e traços em uma tabela em que se sabe que tem o valor...

E assim dada a string valor_morse a letra correspondente vai ser

    valor_texto = Matriz_Decode[i] onde Matriz_Decode[i]->M_morse == valor_texto;

E decodificar Morse seria só ler as strings e mostrar esses valores, certo?

E a outra opção?

Seria apenas o caso de por exemplo colocar aqueles códigos do arquivo inicial em uma planilha e classificar não pela primeira mas sim pela segunda coluna e escrever um switch() para ir seguindo os pontos e traços até a letra. Se não entendeu e quer seguir esse caminho eu posso escrever um exemplo para umas poucas letras.

adicionado 6 minutos depois

Seu programa parece um pouco complicado para esse problema.

Sobre essa struct

typedef struct{
    char letras[5]; /* armazena a letra. A recebe como uma string , mas só usa a primeira letra */
    char letrasMorse[T_MORSE];/* armazena os respectivos simbolos morse */
}alfabeto;

É mais ou menos uma das opções que indiquei há pouco. Mas eu usaria

    char    letra;
    char*   letrasMorse[T_MORSE];

dentro da struct. Mais simples.

Ansi C · 12 de janeiro de 2020

@Luis Vilo Bom Dia !!

Em 11/01/2020 às 08:41, Luis Vilo disse:

O problema é que eu Não posso usar funçoes como strcmp, sizeof, memcmp,etc.. para comparar as letras em morse(string), tenho de criar minha própria função e tô me embolando um pouco com isso.

Tu "se atolou" na decodificação por causa do requisito de exame que nos proíbe o uso de funções prontas e disponíveis na biblioteca padrão (e outras) de tal maneira que implemente tu, por exemplo uma só para comparar strings ??

Pergunto (Mesmo Que Já Evidente E Objetiva A Sua Dúvida).

Aguarde Só Mais Um Pouco Que Alguém Ajuda-te !!!

arfneto · 13 de janeiro de 2020

@Luis Vilo

Pensando nesse caso de converter uma string em Morse na letra correspondente, achei meio exagerado fazer como eu sugeri. As duas sugestões. E comecei a pensar que deve ter uma maneira linear de escrever isso, mais simples, como uma função assim

    char    char_from_Morse(char* Codigo, Morse_to_Text* cod);

que recebe a string com o código Morse e retorna a letra, consultando uma tabela cod. E assim fica bem simples resolver a parada.

Claro que as duas maneiras que sugeri funcionam, mas estamos afinal usando só 36 códigos a partir de 2 possíveis símbolos: 26 letras e 10 dígitos gerados a partir dois símbolos: ponto e traço.

Mas dois símbolos é binário e 36 é 32 + 4 em potências de 2, e assim seria 1 0 0 1 0 0 em binário. Seis bits. Seis bits dá no máximo 111 111 ou seja 64 valores, de 0 a 111 111.

Se a gente usar ponto = zero e traço = 1 e converter para binário a gente podia usar uma tabela assim

struct morse
{
    char fromMorse[64];
};
typedef struct morse        Morse_to_Text;

E caberia todo mundo
E sobrariam ainda 64 - 36 = 28 posições.
E não teria que fazer mais nenhum cálculo no programa, só copiar da tabela.
E então deve ser o caminho.

Claro que não precisa sequer de struct nem nada. Deixei assim porque acho que o certo seria usar a mesma struct para codificar e decodificar e copiei do outro programa, o que codifica. Nesse caso a estrutura poderia ser assim

struct morse
{	
    char* valor[127];    // tem a string correspondente a letra
    char fromMorse[64];  // tem a letra correspondente a string, convertida pra binário
};
typedef struct morse        Morse_to_Text;

e o mesmo programa faria as duas coisas, o que faz mais sentido eu acho: lendo uma única vez o "dicionário" Morse cria as duas tabelas

Mas tem uma pegadinha

Vendo na árvore abaixo e indo pra esquerda

Temos por exemplo que

E .
I ..
X ...
H ....
5 .....

e se ponto é zero converter isso pra binário vai dar zero nos 5 casos: 0, 00, 000, 0000 e 00000. Zero é tudo zero.

Como resolver?

Por exemplo, colocando um '1' na frente de todos eles, porque qualquer zero a esquerda iria zoar tudo

E .      10        
I ..     100
X ...    1000
H ....   10000
5 .....  100000

Zero a esquerda não muda nada, mas 1 a esquerda sim. Multiplica por 2. E termina com a ambiguidade: podemos calcular o valor em binário fácil assim. E em decimal ficaria

E .      10      2        
I ..     100     4     
X ...    1000    8
H ....   10000  16
5 .....  100000 32

Então como codificar?

Nosso maior valor seria "-----" o zero, que daria 111 111, seis bits '1', 63 em decimal, e seria claro o último valor da tabela, em fromMorse[64].

O menor seria o próprio E, na posição 2 da tabela, como está na tabela acima. Como forçamos o '1' no início não estamos usando os dois primeiros valores. E podíamos ter declarado fromMorse[62]. Mas para economizar 2 char teríamos que fazer muita continha no programa. Não compensa.

Esse trecho calcula o valor, se em Codigo[] estiver o valor em Morse como "-----" por exemplo.

	int i = 1;
	int peso;
	if (Codigo[0] == '.')
		peso = 2;
	else
		peso = 3;
	while (Codigo[i] != 0) // substitui strlen()
	{	peso = 2 * peso;
	    if (Codigo[i] == '-') peso = peso + 1;
	i = i + 1;
	};	// while
	return cod->fromMorse[peso];

Só isso. Nesse exemplo peso = 63, tudo 1 porque são cinco '-' o valor de 0 em Morse, certo?

E na hora de decodificar?

Trivial. Temos um valor em Morse, e precisamos da letra. Então basta calcular o valor em binário e pegar a letra na tabela:

Se a tabela está em

Morse_to_Text c;

E o código em

char* valor_morse;

basta escrever

char letra = char_from_Morse( valor_morse, c);

É só matemática. Se a gente carregar a tabela com '?' no início só pra ficar mais visível, teremos

        Tabela no Inicio

?  ?  ?  ?  ?  ?  ?  ?  ?  ?
?  ?  ?  ?  ?  ?  ?  ?  ?  ?
?  ?  ?  ?  ?  ?  ?  ?  ?  ?
?  ?  ?  ?  ?  ?  ?  ?  ?  ?
?  ?  ?  ?  ?  ?  ?  ?  ?  ?
?  ?  ?  ?  ?  ?  ?  ?  ?  ?
?  ?  ?  ?

E depois de preencher

        Tabela preenchida

?  ?  E  T  I  A  N  M  S  U
R  W  D  K  G  O  H  V  F  ?
L  ?  P  J  B  X  C  Y  Z  Q
?  ?  5  4  ?  3  ?  ?  ?  2
?  ?  ?  ?  ?  ?  ?  1  6  ?
?  ?  ?  ?  ?  ?  7  ?  ?  ?
8  ?  9  0

E claro que temos 28 '?' e 36 símbolos nas 64 possíveis letras na tabela.

Porque dá certo?

Exemplo: o 'L' na posição 20.

O L em Morse é ".-.."
Se o '.' vale zero e o traço 1 temos 0100
Zero na esquerda vai dar m$%da então colocamos 1 na frente e temos 10100. Na verdade colocamos 1 na frente de todos os valores, o que equivale a multiplicar por 2, certo?
10100 é 16 + 4 = 20 e por isso o 'L' está na posição 20. Só isso.

Entendeu a ideia? Quer ver um exemplo?

Feliz 2020

Luis Vilo · 14 de janeiro de 2020

@arfneto entendi a lógica, inclusive achei massa! Vou tentar fazer aqui, mas gostaria sim de ver um exemplo! Muito obrigado mais uma vez e feliz 2020!

arfneto · 18 de janeiro de 2020

Em 14/01/2020 às 10:58, Luis Vilo disse:

entendi a lógica, inclusive achei massa! Vou tentar fazer aqui, mas gostaria sim de ver um exemplo!

Esse é o código do programa de teste

struct morse
{
    char fromMorse[64];
};
typedef struct morse        Morse_to_Text;

void    apaga_tabela(Morse_to_Text*);
char    char_from_Morse(char*, Morse_to_Text*);
void    carrega_tabela(char*, Morse_to_Text*);
void    inicia_tabela(Morse_to_Text*);
void    morse(char*, Morse_to_Text*);
void    mostra_tabela(char*, Morse_to_Text*);


int main()
{
    Morse_to_Text   codigo;
    char*           arquivo_morse = "morse.txt";
    inicia_tabela(&codigo);
    mostra_tabela("Tabela no Inicio", &codigo);
    carrega_tabela(arquivo_morse, &codigo);
    mostra_tabela("Tabela preenchida", &codigo);
    morse("texto2.txt", &codigo); // codifica o arquivo
    return 0;
}    // main()

A lógica disso já foi discutida. A struct{} só está aí porque é pra ser um programa só para codificar e decodificar Morse, e com a opção de tocar o som. A primeira parte está no outro tópico. Podia ser só um char[64]. A implementação do teste a seguir certamente não é a melhor e nem vou dizer que é boa, claro. Mas tem um propósito ilustrativo apenas. Talvez eu junte os dois programas e poste depois.

Prosseguindo...

O arquivo de entrada, "morse.txt" é o mesmo, claro. aquele com os asteriscos e que você postou no primieiro tópico. Eis um trecho:

6-....*
7--...*
8---..*
9----.*
A.-*
B-...*
C-.-.*
D-..*
E.*

O arquivo a ser codificado é a saída do primeiro programa, que lia

CLUBE
Clube do Hardware
2 MAIS 3 SAO 5
ESTAMOS EM 2019
MEU NOME EH LUIS

E gravava em Morse. Então ao codificar deve mostrar de volta isso mesmo e assim um programa testa o outro.

Texto a ser decodificado

-.-.  .-..  ..-  -...  . 
-.-.  .-..  ..-  -...  .      -..  ---      ....  .-  .-.  -..  .--  .-  .-.  . 
..---      --  .-  ..  ...      ...--      ...  .-  ---      ..... 
.  ...  -  .- --  ---  ...      .  --      ..---  ----- .----  ----. 
--  .  ..-      -.  ---  --  .      .  ....      .-..  ..-  ..  ...

O arquivo de teste tem umas linhas em branco pra testar também...

A saída do programa

x

Iniciar a tabela toda com '?' e mostrar antes de continuar dá uma segurança em relação aos dados e por isso escrevi assim.

As funções

    inicia_tabela(&codigo);

Nem precisava disso assim, mas a função recebe o endereço de uma tabela de decodificação e coloca as tais '?' para ter algo mostrável na tela. E a gente sabe que são 64 posições e só vamos usar 26 + 10 = 36 então tem que sobrar 28 '?' depois e assim o programa vai se testando sozinho enquanto decodifica o que o primeiro codificou.

void    inicia_tabela(Morse_to_Text* c)
{
    char* p = (char*) c->fromMorse;
    for (int i = 0; i < sizeof(c->fromMorse); i = i + 1)
    {
        *(i + p) = '?';
    };    // for
    return;
};    // inicia_tabela()

    mostra_tabela("Tabela no Inicio", &codigo);

Essa mostra a tabela com a mensagem antes, assim fica fácil de mostrar várias vezes a tabela durante o desenvolvimento e sem escrever outros printf() para explicar o que está mostrando...
Para simplificar, recebe o endereço da mensagem e o endereço da tabela. Eis o código, com nada de especial

void    mostra_tabela(char* msg, Morse_to_Text* cod)
{
    char* p = (char*)cod->fromMorse;
    printf("\n\n\t%s\n\n", msg);
    for (int i = 0; i < 64; i++)
    {
        printf("%c  ", *(p + i));
        if ((i % 10) == 9) printf("\n");
    };    // for
    printf("\n\n");
    return;
};    // mostra_tabela()

void    carrega_tabela(char*, Morse_to_Text*);

Essa abre o arquivo com a tabela Morse e carrega a tabela from_Morse. Então recebe o nome do arquivo e o endereço de uma tabela Morse/Texto. Eis o código

void    carrega_tabela(char* arquivo, Morse_to_Text* cod)
{
    const char* mascara = "%c%[^*]%c ";
    char        Valor; // o caracter lido a cada linha
    char        Algo; // para 'comer' o asterisco no final das linhas
    char        Codigo[80]; // para o valor em Morse
    int            n; // o total de valores lidos por scanf()
    int            peso;
    FILE* tabela;

    tabela = fopen(arquivo, "r");
    if (tabela == NULL)
    {
        perror("Erro ao abrir tabela:");
        return;
    }    // if

    while (1)
    {
        n = fscanf(tabela, mascara, &Valor, Codigo, &Algo);
        if (n != 3) break;
        int i = 1;
        if (Codigo[0] == '.')
            peso = 2;
        else
            peso = 3;
        while (Codigo[i] != 0)
        {    // substitui stren()
            peso = 2 * peso;
            if(Codigo[i] == '-') peso = peso + 1;
            i = i + 1;
        };
        cod->fromMorse[peso] = Valor;
    };    // while()

    fclose(tabela);
    return;
};    // cria_tabela()

Nada especial, e copiado do outro programa, o que convertia o texto pra Morse. Só que aqui se calcula o valor usando a técnica descrita antes: convertendo o valor Morse pra binário e colocando um 1 na frente, pegando esse valor como posição e colocando a letra original na tabela. Isso é constante então podia ser feito uma única vez por um outro programa, e simplesmente se usar a tabela preenchida, que é essa

        Tabela preenchida

?  ?  E  T  I  A  N  M  S  U
R  W  D  K  G  O  H  V  F  ?
L  ?  P  J  B  X  C  Y  Z  Q
?  ?  5  4  ?  3  ?  ?  ?  2
?  ?  ?  ?  ?  ?  ?  1  6  ?
?  ?  ?  ?  ?  ?  7  ?  ?  ?
8  ?  9  0

E declarar essa tabela como constante e pronto.

    morse("texto2.txt", &codigo); // codifica o arquivo

Afinal essa é a função que decodifica o texto. Recebe o nome do arquivo e o endereço de uma tabela preenchida, faz a conversão e mostra na tela. Eis o código

void    morse(char* texto, Morse_to_Text* cod)
{
    char    codigo[10];
    int        c, espaco, ix, len;
    FILE*   txt;

    txt = fopen(texto, "r");
    if (txt == NULL)
    {
        perror("Erro ao abrir txt:");
        return;
    }    // if
    espaco = 0;
    len = 0; // string vazia
    ix = 0; // aponta para o início
    while (!feof(txt))
    {
        c = fgetc(txt);
        switch (c)
        {
        case 45:
        case 46:
            if (espaco > 4)    printf(" ");
            espaco = 0;
            codigo[ix] = c; // . ou -
            ix = ix + 1; // adianta o ponteiro
            codigo[ix] = 0; // termina a string
            len = len + 1; // comprimento da string
            break;

        case EOF:
        case 10:
            if (len > 0) printf("%c", char_from_Morse(codigo, cod));
            printf("\n");
            espaco = 0; len = 0; ix = 0; // reinicia
            break;

        case 32: 
            if (len > 0) printf("%c", char_from_Morse(codigo, cod));
            espaco += 1;
            len = 0; ix = 0; // reinicia
            break;

        default:
            if (len > 0) printf("%c", char_from_Morse(codigo, cod));
            espaco = 0;    len = 0; ix = 0; // reinicia
            break;
        }
    };    // while
    fclose(txt);
    return;
};    // morse()

Achei mais simples usar fgetc() e ler o arquivo todo e tratar em um simples switch() o caracter lido. Fica mais fácil de ler e testar. Só precisamos tratar '.' e '-', espaço, '\n' e o fim do arquivo na verdade. A lógica é simples: apenas monta a string com o valor em Morse, como "....." por exemplo, e chama char_from_Morse() com essa string. A função devolve a letra e a vida continua.

Para ficar mais fácil de conferir quando pula uma linha na entrada pula uma linha na saída.

Eis o programa todo. Roda em Windows. O primeiro #define é só pra contentar meu compilador...

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"

struct morse
{
    char fromMorse[64];
};
typedef struct morse        Morse_to_Text;

void    apaga_tabela(Morse_to_Text*);
char    char_from_Morse(char*, Morse_to_Text*);
void    carrega_tabela(char*, Morse_to_Text*);
void    inicia_tabela(Morse_to_Text*);
void    morse(char*, Morse_to_Text*);
void    mostra_tabela(char*, Morse_to_Text*);


int main()
{
    Morse_to_Text    codigo;
    char*           arquivo_morse = "morse.txt";
    inicia_tabela(&codigo);
    mostra_tabela("Tabela no Inicio", &codigo);
    carrega_tabela(arquivo_morse, &codigo);
    mostra_tabela("Tabela preenchida", &codigo);
    morse("texto2.txt", &codigo); // codifica o arquivo
    return 0;
}    // main()


char    char_from_Morse(char* Codigo, Morse_to_Text* cod)
{
    int i = 1;
    int peso;
    if (Codigo[0] == '.')
        peso = 2;
    else
        peso = 3;
    while (Codigo[i] != 0) // substitui strlen()
    {    peso = 2 * peso;
        if (Codigo[i] == '-') peso = peso + 1;
    i = i + 1;
    };    // while
    return cod->fromMorse[peso];
};    // char_from_Morse()


void    carrega_tabela(char* arquivo, Morse_to_Text* cod)
{
    const char* mascara = "%c%[^*]%c ";
    char        Valor; // o caracter lido a cada linha
    char        Algo; // para 'comer' o asterisco no final das linhas
    char        Codigo[80]; // para o valor em Morse
    int            n; // o total de valores lidos por scanf()
    int            peso;
    FILE* tabela;

    tabela = fopen(arquivo, "r");
    if (tabela == NULL)
    {
        perror("Erro ao abrir tabela:");
        return;
    }    // if

    while (1)
    {
        n = fscanf(tabela, mascara, &Valor, Codigo, &Algo);
        if (n != 3) break;
        int i = 1;
        if (Codigo[0] == '.')
            peso = 2;
        else
            peso = 3;
        while (Codigo[i] != 0)
        {    // substitui stren()
            peso = 2 * peso;
            if(Codigo[i] == '-') peso = peso + 1;
            i = i + 1;
        };
        cod->fromMorse[peso] = Valor;
    };    // while()

    fclose(tabela);
    return;
};    // cria_tabela()


void    inicia_tabela(Morse_to_Text* c)
{
    char* p = (char*) c->fromMorse;
    for (int i = 0; i < sizeof(c->fromMorse); i = i + 1)
        *(i + p) = '?';
    return;
};    // inicia_tabela()


void    morse(char* texto, Morse_to_Text* cod)
{
    char    codigo[10];
    int        c, espaco, ix, len;
    FILE*   txt;

    txt = fopen(texto, "r");
    if (txt == NULL)
    {
        perror("Erro ao abrir txt:");
        return;
    }    // if
    espaco = 0;
    len = 0; // string vazia
    ix = 0; // aponta para o início
    while (!feof(txt))
    {
        c = fgetc(txt);
        switch (c)
        {
        case 45:
        case 46:
            if (espaco > 4)    printf(" ");
            espaco = 0;
            codigo[ix] = c; // . ou -
            ix = ix + 1; // adianta o ponteiro
            codigo[ix] = 0; // termina a string
            len = len + 1; // comprimento da string
            break;

        case EOF:
        case 10:
            if (len > 0) printf("%c", char_from_Morse(codigo, cod));
            printf("\n");
            espaco = 0; len = 0; ix = 0; // reinicia
            break;

        case 32: 
            if (len > 0) printf("%c", char_from_Morse(codigo, cod));
            espaco += 1;
            len = 0; ix = 0; // reinicia
            break;

        default:
            if (len > 0) printf("%c", char_from_Morse(codigo, cod));
            espaco = 0;    len = 0; ix = 0; // reinicia
            break;
        }
    };    // while
    fclose(txt);
    return;
};    // morse()


void    mostra_tabela(char* msg, Morse_to_Text* cod)
{
    char* p = (char*)cod->fromMorse;
    printf("\n\n\t%s\n\n", msg);
    for (int i = 0; i < 64; i++)
    {
        printf("%c  ", *(p + i));
        if ((i % 10) == 9) printf("\n");
    };    // for
    printf("\n\n");
    return;
};    // mostra_tabela()


// fim do texto