Erro de Codificação de Arquivo

[Augustow]

Olá, estou com um problema de codificação de arquivo com o meu programa que fiz em C. Ele está escrevendo em um formato cheio de caracteres especiais sendo que antes não estava escrevendo desta forma. O Programa é uma Máquina de Turing Numérica sendo que esta escrita no arquivo são as transições da máquina e mostra se ela rejeita ou não. Era pra sair da seguinte forma:

 

{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

 

Mas está saindo assim:

 

{q0}B111B X40nR·ËPV·
{q0}B111B X40nR·ËPV·
Rejeita

 

Será que alguém pode me ajudar? Obs: já usei o comando -finput-charset=UTF-8. Desde já, agradeço.

 

Código:

 

#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]);
//-------------------------------------------------Colocando branco em todas as posições da fita------------------------------------------------------------------
    for(i=0; i<strlen(palavra)+6;i++){
        palavraAux[i] = 'B';
    }
//----------------------------------------------colocando o estado inicial na primeira posicao antes da palavra---------------------------------------------------------
        palavraAux[49] = '\0';
        palavraAux[0] = '{';
        palavraAux[1] = estInicial[0];
        palavraAux[2] = estInicial[1];
        palavraAux[3] = '}';
        palavraAux[4] = 'B';
//-----------------------------------------------------passando palavra original para a palavraAux, dps----------------------------------------------------------------
    for(i = 5; i< strlen(palavra) + 5; i++){
        palavraAux[i] = palavra[j];
        j++;
    }
    j=4;    // cabeça de leitura
//-----------------------------------------------tirar virgula do estado inicial ----------------------------------------------------------------------------------
	char InicioAux[2];
	InicioAux[0] = estInicial[0];
	InicioAux[1] = estInicial[1];
//-----------------------------------------------copiando o estado inicial para o estadoAtual ----------------------------------------------------------------------------------
    strcpy(estadoAtual, InicioAux);
//--------------------------------------------------arquivo de gravação --------------------------------------------------------------------------------
    FILE *saida;
	saida = fopen(argv[3], "w");
	fprintf(saida,"%s\n", palavraAux);
//-----------------------------Sera executado enquanto o estadoCorrente n for estado final--------------------------------------------------------------
//-------------------- antes de entrar no while, correto seria gravar a primeira palavraAux no arquivo, sem modificação---------------------------------
    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){ 			// se for igual, vou usar essa transição
// -------------------------- comparando estado atual com o da transição -----------------------------------------------------
                        if(palavraAux[j] == funcao[i][4]){ 			// arrumado
// -------------------------- comparando a letra da palavra com a que você vai ler no estado -----------------------------------
                            flag3 = 1;
                            palavraAux[j] = funcao[i][12]; 			// Grava na fita
//----------------------- Próximo estado ou seja q0 vai pra q1 então tem que gravar q1 como estado atual agr------------------
                            estadoAtual[0] = funcao[i][9];     		// certo
                            estadoAtual[1] = funcao[i][10];    		// certo
                            estadoAtual[2] = '\0';
//------------------------------------- Fazer um por um a transferencia {q0}BaabaaBBBBB -->   B{q1}aabaaBBBBB -----------------
//------------------------------------  Fazer passagem de 4 posições, vai depender do lado que vai(D, E)-----------------------
                            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--;
							}
//------------------------------------------------------ testa as flags -------------------------------------------------------
								if(j<0){
									flag2 = 1;
									break;
								}
                            break;
                        }
                }
/* ------------------------------------imprimir no arquivo a palavra Aux ------------------------------------------------------*/
            }
            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;
}

A descrição do arquivo de entrada, onde mostra o alfabeto, os estados e transições, é da seguinte maneira:

 

(
{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}
)

 

A forma de execução é feita pelo argv, assim, para executá-lo seria da seguinte forma:

 

./exec desc_mt3.txt 111 saida.txt

 

O primeiro argumento é as descrição que citei acima e "111" é uma entrada.