File encoding error

Question

Hello, I have a file encoding problem with my program that I made in C. It is writing in a format full of special characters which before was not writing this way. The Program is a Numerical Turing Machine and this writing in the file is the transitions of the machine and shows whether it rejects it or not. This is how I was supposed to get out:

{q0}B111B...
B{q1}111B...
B1{q1}11B...
B11{q1}1B...
B111{q1}B...
B11{q2}11B...
B1{q2}111B...
B{q2}1111B...
{q2}B1111B...
encerra com sucesso

But it’s coming out like this:

{q0}B111BX40nR·ËPV·
{q0}B111BX40nR·ËPV·
Rejeita

Can anyone help me? Note: I already used the command -finput-charset=UTF-8. From now on, thank you.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//Função para o usuário entrar com as tuplas
int inserirTuplas(char alfab[50],char salvando[50][50], char estados[50],             char funcao[50][50], char estInicial[3], char estsFinais[50], char*argv[3])
{
   int i = 0;
// ordem: conjunto de estados, alfabeto, alfabeto da fita, transições, estado inicial, estado final
char info[50];
FILE *arq;
arq = fopen(argv[1], "r");
if(arq == NULL){
    printf("Erro, nao foi possivel abrir o arquivo\n");
}
else{
    while((fgets(info, sizeof(info), arq)) != NULL ){
        strcpy(salvando[i],info);
        i++;
    }
}
fclose(arq);
int diferenca;
diferenca = i-9;
printf("%d", diferenca);
//Na ordem do arquivo de entrada, o conjunto de estado esta na 4 linha, pos3
strcpy(alfab,salvando[3]);
//Na ordem do arquivo de entrada, o conjunto de estados esta na 2 linha, pos1
strcpy(estados,salvando[1]);
//Aqui o usuário especifica as transições
int k = 0;
int cont = 0;
for(cont = 5; cont < 5 + diferenca; cont++){
    strcpy(funcao[k],salvando[cont]);
    k++;
}
//Dentre os estados informados, o usuário especifica o estado inicial
strcpy(estInicial,salvando[i-3]);
//Aqui o usuário entra com o conjunto de estados finais
strcpy(estsFinais,salvando[i-2]);
return diferenca;

}

int EstadoAtualFazParteConjFim(char estadoAtual[3], char estsFinais[50]){
//Essa string "aux" vai guardar o estado do conjundo de estados finais, a ser comparado com o estado atual
char aux[3];
int i = 0;
int j = 0;
//Aqui nós temos um for que percorre toda a string de estados finais
for(i = 0; i < strlen(estsFinais); i++){
    //Aqui verfica se o caracter da string é uma virgula, caso seja o 'j' usado na string aux é zerado,
    //para que a ariavel aux receba o estado i+1
    if((estsFinais[i] == ',') || (estsFinais[i] == '{') || (estsFinais[i] == '}')){
       j = 0;
       continue;
    }
    //Aqui a variavel aux recebe os valores do estado a ser comparado com o estadoAtual
    aux[j] = estsFinais[i];
    j++;
    //Se j for igual a 2, é porque a aux ja foi totalmente preenchida com o estado a ser verificado
    //A strcmp compara o estado atual da MT, com o estado guardado em aux, caso sejam iguais a função retorna 1
    if(j == 2){
        aux[2] = '\0';
        if(strcmp(estadoAtual,aux) == 0){
            return 1;
        }
    }
}
//Se percorrer todo o for e o estado atual não estiver no conjunto de estados finais a função retorna 0
return 0;

}

 void reconhecerPalavra(char alfab[50], char estados[50], char funcao[50][50], char estInicial[3], char estsFinais[50], int quant, char *argv[3]){
int flag2 = 0;
int i = 0;
char palavraAux[100];
char palavra [100];
char aux;
char estadoAtual[3];
char estadoAux[3];
int j = 0;
int flag3 = 0;
// copia para a palavra o argv[2], que seria a entrada. Ex{aaabbb}
   strcpy (palavra, argv[2]);

    for(i=0; i<strlen(palavra)+6;i++){
      palavraAux[i] = 'B';
}

    palavraAux[49] = '\0';
    palavraAux[0] = '{';
    palavraAux[1] = estInicial[0];
    palavraAux[2] = estInicial[1];
    palavraAux[3] = '}';
    palavraAux[4] = 'B';
for(i = 5; i< strlen(palavra) + 5; i++){
    palavraAux[i] = palavra[j];
    j++;
}
      j=4;    // cabeça de leitura

    char InicioAux[2];
     InicioAux[0] = estInicial[0];
     InicioAux[1] = estInicial[1];

     strcpy(estadoAtual, InicioAux);

    FILE *saida;
  saida = fopen(argv[3], "w");
  fprintf(saida,"%s\n", palavraAux);

  while(EstadoAtualFazParteConjFim(estadoAtual, estsFinais)==0){
        flag3 = 0;
           for(i=0; i < quant; i++){
              estadoAux[0] = funcao[i][1];
              estadoAux[1] = funcao[i][2];
              estadoAux[2] = '\0';
              if(strcmp(estadoAtual, estadoAux) == 0){          
                          flag3 = 1;
                            palavraAux[j] = funcao[i][12];          // Grava na fita

                         estadoAtual[0] = funcao[i][9];             // certo
                         estadoAtual[1] = funcao[i][10];            // certo
                          estadoAtual[2] = '\0';

                           if(funcao[i][14] == 'D'){
                              palavraAux[j-3] = estadoAtual[0];     // trocou o estado de passado para o atual, trocou o q
                               palavraAux[j-2] = estadoAtual[1];    // trocou o numero
                               aux = palavraAux[j];             // exemplo de fita {q1}BaaaB
                               palavraAux[j] = palavraAux[j-1];     // {q1}}aaaB
                               palavraAux[j-1] = palavraAux[j-2];   // {q11}aaaB
                                palavraAux[j-2] = palavraAux[j-3];  // {qq1}aaaB
                                palavraAux[j-3] = palavraAux[j-4];  // {{q1}aaaB
                                palavraAux[j-4] = aux;              // B{q1}aaaB
                               ++j;
                        }
                           if(funcao[i][14] == 'E'){
                              palavraAux[j-3] = estadoAtual[0];     // trocou o estado de passado para o atual, trocou o q
                              palavraAux[j-2] = estadoAtual[1];     // trocou o numero
                              aux = palavraAux[j-5];                // exemplo de fita B{q1}aaaB
                              palavraAux[j-5] = palavraAux[j-4];  // {{q1}aaaB
                              palavraAux[j-4] = palavraAux[j-3];    // {qq1}aaaB
                              palavraAux[j-3] = palavraAux[j-2];    // {q11}aaaB
                              palavraAux[j-2] = palavraAux[j-1];    // {q1}aaaB
                              palavraAux[j-1] = aux;            // {q1}BaaaB
                              j--;
                          }

                              if(j<0){
                                 flag2 = 1;
                                 break;
                              }
                          break;
                     }
             }

        }
        fprintf(saida,"%s\n", palavraAux);
        if(flag2==1)
            break;
         if(flag3==0)
             break;
 }
 if(flag2 == 1 || flag3 == 0 || (EstadoAtualFazParteConjFim(estadoAtual,  estsFinais) == 0)){
      fprintf(saida, "Rejeita\n");
 }
 else{
     if((EstadoAtualFazParteConjFim(estadoAtual, estsFinais)==1)){
          fprintf(saida, "Aceita\n");
      }
  }
  fclose(saida);

}

int main(int argc, char *argv[]){

char alfab[50];
char estados[50];
char funcao[50][50];
char estInicial[3];
char estsFinais[50];
int quant;
char salvando[50][50];
quant = inserirTuplas (alfab, salvando, estados, funcao, estInicial, estsFinais,argv);
reconhecerPalavra(alfab, estados, funcao, estInicial, estsFinais, quant,argv);
return 0;

}

The description of the input file, which shows the alphabet, states and transitions, is as follows::

(
 {q0,q1,q2},
 {1},
 {B,1},
 {
   (q0,B)->(q1,B,D),
   (q1,1)->(q1,1,D),
   (q1,B)->(q2,1,E),
   (q2,1)->(q2,1,E)
 },
 q0,
{q2}
)

The form of execution is made by argv, so to execute it would be as follows:

./exec desc_mt3.txt 111 saida.txt

The first argument is the description I quoted above and "111" is an entry.