Another syntax error

This is a discussion on Another syntax error within the C Programming forums, part of the General Programming Boards category; this error: "parse error at end of input"...

  1. #1
    Registered User
    Join Date
    Sep 2008
    Posts
    15

    Another syntax error

    this error: "parse error at end of input"

  2. #2
    Registered User
    Join Date
    Sep 2008
    Posts
    15
    At my C code this error apears "parse error at endo of input " can anyone help me?

  3. #3
    Kernel hacker
    Join Date
    Jul 2007
    Location
    Farncombe, Surrey, England
    Posts
    15,677
    "endo" is when you go over the handlebars on a bicycle, but "parse error at end of input" usually means that your code is not complete - something like a missing brace or generally confusing the compiler in some way.

    If you post the code, maybe we can help you.

    --
    Mats
    Compilers can produce warnings - make the compiler programmers happy: Use them!
    Please don't PM me for help - and no, I don't do help over instant messengers.

  4. #4
    Registered User
    Join Date
    Sep 2008
    Posts
    15
    ok thanks wait a moment

  5. #5
    Registered User
    Join Date
    Sep 2008
    Posts
    15
    Code:
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define TRUE            0
    #define FALSE           1
    #define LEN_FICHEIRO      256
    #define FICHEIRO_DEFAULT  "dadosBin.dat"
    
    /* ESTRUTURAS  */
    
    /* estrutura que define  o no */
    
    typedef struct no {
        struct no *prox;
        struct no *ant;
        void *dados;
    }NO;
    typedef NO *PNO;
    
    /* estrutura que define  a especialidade */
    
    typedef struct especialidades {
        char nomeEspecialidade [20+1];
        char descricaoEspecialidade [40+1];
    } ESPECIALIDADES;
    typedef ESPECIALIDADES *PESPECIALIDADES;
    
    /* estrutura que define  os medicos   niom= numero identificacao ordem medico*/
    
    typedef struct medicos {
        int niom;  //num identificacao ordem medicos
        char nomeMedico [40+1];
        char espMedico [20+1];
    } MEDICOS;
    typedef MEDICOS *PMEDICOS;
    
    /* estrutura que define  os utentes */
    
    typedef struct utentes {
        char nomeUtente [40+1];
        char tipoAssistencia [20+1];
    	char nrcartao [20+1];
        char valCartaoUtente[10];
        char dataNascUtente[10];
        char telefone[10];
        char localidade [40+1];
    } UTENTES;
    typedef UTENTES *PUTENTES;
    
    /* estrutura que define  os tipos de assistencia */
    
    typedef struct assistenciamedica {
        char nomeAssUtente [20+1];
        char descAssUtente [40+1];
    } ASSISTENCIAMEDICA;
    typedef ASSISTENCIAMEDICA *PASSISTENCIAMEDICA;
    
    
    /*  VARIAVEIS GLOBAIS */
    PNO cabecaMedico = NULL;
    PNO cabecaEspecialidade = NULL;
    PNO cabecaUtente = NULL;
    PNO cabecaAssistenciamedica = NULL;
    PNO cabecaAgendaConsultas = NULL;
    int listaFicheiroAlterado=FALSE;
    
    /*  FUNCOES */
    
    void fim();
    void MenuEspecialidades();
    void MenuMedicos();
    void MenuAssistenciaMedica();
    void MenuUtentes();
    void MenuConsultas();
    void MenuPesquisas();
    void MenuOrdenar();
    void verificaFicheiro();
    void leFicheiro();
    void gravaFicheiro(PNO *cabecaEspMedicaTemp, PNO *cabecaMedicoTemp, PNO *cabecaAssUtenteTemp, PNO *cabecaUtenteTemp, PNO *cabecaAgendaConsultasTemp);
    
    
    PNO criarNO (void *p);
    void insereAcabeca (PNO *cabeca, PNO elemento);
    void bubbleSort (PNO cabeca, int (*compara)(), char ordem);
    void ordenaNome (PMEDICOS p1, PMEDICOS p2, char ordem);
    void ordenaNomeMedico (PMEDICOS p1, PMEDICOS p2, char ordem);
    void ordenaMedicoEsp (PMEDICOS p1, PMEDICOS p2, char ordem);
    void ordenaUtenteNome (PUTENTES p1, PUTENTES p2, char ordem);
    void ordenaUtenteData (PUTENTES p1, PUTENTES p2, char ordem);
    
    /* ESPECIALIDADES */
    
    void insereEspecialidade();
    int pesquisarEspecialidade(PNO *cabeca, char pesquisaNomeEspecialidade [20+1]);
    void apagarEspecialidade(PNO *cabeca);
    void alterarEspecialidade(PNO *cabeca);
    void listarEspecialidades(PNO *cabeca);
    
    /* Utentes */
    
    void insereUtente();
    int pesquisarUtente(PNO *cabecaUtente, char pesquisaNomeUtente [20+1]);
    void apagarUtente(PNO *cabecaUtente);
    void alterarUtente(PNO *cabecaUtente);
    void listarUtentes(PNO *cabecaUtente);
    
    /* MEDICOS */
    void insereMedico();
    void listarMedicos(PNO *cabeca);
    /* ASSISTENCIA */
    void insereAssistencia();
    int pesquisar_Assistencia(PNO *cabeca, char nomeAssUtentePesq [20+1]);
    void apagarAssistencia(PNO *cabeca);
    void alterarAssistencia(PNO *cabeca);
    void listarAssistencia(PNO *cabeca);
    
    /* FUNCAO PARA AO FINALIZAR, PERGUNTAR, EM CASO DE HAVER INFORMACAO NA MEMORIA, SE QUEREMOS GRAVAR ESSA INFORMACAO*/
    
    void fim(){
        system("cls");
        char grava_Ficheiro[3];
        if (listaFicheiroAlterado==TRUE) {
            printf("\nExistem dados da Memoria que nao foram guardados, deseja garda-los (s/n)?:");
            fflush(stdin);
            fgets(grava_Ficheiro, 3, stdin);
            if(grava_Ficheiro[0] == '\r'  ||  grava_Ficheiro[0] == '\n' || grava_Ficheiro[0] != 's'){
                printf("\nOs registos nao foram gravados" );
            }
            else {
                gravaFicheiro(&cabecaEspecialidade, &cabecaMedico, &cabecaAssistenciamedica, &cabecaUtente, &cabecaAgendaConsultas);
            }
        }
        system("cls");
    
        printf("\tObrigado por utilizar o PGM - Programa de Gestao Medica\n");
        getch();
        system("cls");
    }
    
    /* CRIAR NO */
    
    PNO criarNO (void *p){
        PNO pno;
        pno = (PNO) malloc (sizeof(NO));
        pno->ant=pno->prox=NULL;
        pno->dados=p;
        return pno;
    }
    
    /* INSERIR NA LISTA */
    
    void insereAcabeca (PNO *cabeca, PNO elemento){
        if (*cabeca) (*cabeca)->ant=elemento;   //if cabeca existe , anterior passa a apontar para elemento
        elemento->prox=*cabeca;
        *cabeca=elemento;   // elemento passa a ser o primeiro elemento e &#233; a cabeca
    }
    
    /* ORDENAR AS LISTAS */
    
    void bubbleSort (PNO cabeca, int (*compara)(), char ordem){
        void *tmp;
        PNO ptr1, ptr2;
        for (ptr1=cabeca; ptr1; ptr1=ptr1->prox) { /* apenas procede &#224; contagem*/
            for (ptr2=cabeca; ptr2->prox; ptr2=ptr2->prox) {
                if ((*compara)(ptr2->dados, ptr2->prox->dados, ordem)){
                    tmp=ptr2->dados;
                    ptr2->dados=ptr2->prox->dados;
                    ptr2->prox->dados=tmp;
                }
            }
        }
    }
    
    /*  FUNCOES PARA SEREM UTILIZADAS A QUANDO PEDIDO DE ORDENACAO POR DETERMINADO REGISTO ////////    */
    
    /*ordenar+, ordenar plus+  */
    
    void ordenaNome (PMEDICOS p1, PMEDICOS p2, char ordem){ //ordem decrescente --> d, ordem crescente --> c ou outra
        if (ordem=='decr') { // ordena por ordem decrescente
            return p1->niom < p2->niom;
        } else {
            return p1->niom > p2->niom;
        }
    }
    
    void ordenaNomeMedico (PMEDICOS p1, PMEDICOS p2, char ordem){ //ordem decrescente --> d, ordem crescente --> c ou outra
        if (ordem=='d') { // ordena por ordem decrescente
            return strcmp(p1->nomeMedico, p2->nomeMedico)==-1;
        } else {
            return strcmp(p1->nomeMedico, p2->nomeMedico)==1;
        }
    }
    
    void ordenaMedicoEsp (PMEDICOS p1, PMEDICOS p2, char ordem){ //ordem decrescente --> d, ordem crescente --> c ou outra
        if (ordem=='d') { // ordena por ordem decrescente
            return strcmp(p1->espMedico, p2->espMedico)==-1;
        } else {
            return strcmp(p1->espMedico, p2->espMedico)==1;
        }
    }
    
    void ordenaUtenteNome (PUTENTES p1, PUTENTES p2, char ordem){ //ordem decrescente --> d, ordem crescente --> c ou outra
        if (ordem=='d') { // ordena por ordem decrescente
            return strcmp(p1->nomeUtente, p2->nomeUtente)==-1;
        } else {
            return strcmp(p1->nomeUtente, p2->nomeUtente)==1;
        }
    }
    
    void ordenaUtenteData (PUTENTES p1, PUTENTES p2, char ordem){ //ordem decrescente --> d, ordem crescente --> c ou outra
        if (ordem=='d') { // ordena por ordem decrescente
            return strcmp(p1->dataNascUtente, p2->dataNascUtente)==-1;
        } else {
            return strcmp(p1->dataNascUtente, p2->dataNascUtente)==1;
        }
    }
    
    /*////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
    
    /*     FUNCAO PARA INSERIR ESPECIALIDADES EM MEMORIA  */
    
    void insereEspecialidade(){
        system("cls");
        PNO ptrTempEspecialidade;
        PESPECIALIDADES pEspecialidades;
        char nomeEspecialidadeTemp [20+1];
        printf("\nNome da Especialidade: ");
        fflush(stdin);
        fgets(nomeEspecialidadeTemp, 20+1, stdin);
        if(nomeEspecialidadeTemp[0] == '\r'  ||  nomeEspecialidadeTemp[0] == '\n'){
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu anterior" );
            printf("\nPressione uma tecla para continuar");
            getch();
            }
        else {
            pEspecialidades = (PESPECIALIDADES) malloc (sizeof(ESPECIALIDADES));
            strcpy(pEspecialidades->nomeEspecialidade,nomeEspecialidadeTemp);
            printf("\n\nIndique a Descricao:");
            fflush(stdin);
            fgets(pEspecialidades->descricaoEspecialidade, 40+1, stdin );
            if(pEspecialidades->descricaoEspecialidade[0] == '\r'  ||  pEspecialidades->descricaoEspecialidade[0] == '\n'){
                printf("\nAtencao, deixou o campo vazio" );
            }
            ptrTempEspecialidade = criarNO(pEspecialidades);
            insereAcabeca(&cabecaEspecialidade,ptrTempEspecialidade);
            listaFicheiroAlterado=TRUE;
            getch();
        }
    }
    
    /*  FUNCAO PARA PESQUISAR ESPECIALIDADES POR NOME  */
    
    int pesquisarEspecialidade(PNO *cabeca, char pesquisaNomeEspecialidade [20+1]){
        PNO ptr;
        PESPECIALIDADES ptrTempEspecialidade;
        int encontrado = FALSE;
        if(!*cabeca) {
            printf("\nNao Existem Especialidades na Memoria. Qualquer tecla para continuar");
            getch();
            return encontrado;
            }
        for (ptr=*cabeca; ptr; ptr = ptr->prox ){
            ptrTempEspecialidade=ptr->dados;
            if (strcmp(ptrTempEspecialidade->nomeEspecialidade, pesquisaNomeEspecialidade)==0)
                printf("\nFoi encontrado e tem a Descricao:&#37;s \n", ptrTempEspecialidade->descricaoEspecialidade);
                encontrado=TRUE;
            }
        printf("\nPressione uma tecla para continuar");
        getch();
        return encontrado;
    }
    
    /*  FUNCAO PARA ALTERAR ESPECIALIDADE NUM REGISTO ExISTENTE  */
    
    void alterarEspecialidade(PNO *cabeca){
        system("cls");
        char nomeEspecialidadeTemp [20+1];
        PNO ptr;
        PESPECIALIDADES ptrTempEspecialidade;
        if(!*cabeca) {
            printf("\nNao Existem Especialidades na Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        printf("\nQual o Nome da Especialidade: ");
        fflush(stdin);
        fgets(nomeEspecialidadeTemp, 20+1, stdin);
        if(nomeEspecialidadeTemp[0] == '\r'  ||  nomeEspecialidadeTemp[0] == '\n'){  /* Se n&#227;o colocou nada */
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu anterior" );
            printf("\n\tPressione uma tecla para continuar...");
            getch();
            }
        else {
            for (ptr=*cabeca; ptr; ptr = ptr->prox ){
                ptrTempEspecialidade=ptr->dados;
                if (strcmp(ptrTempEspecialidade->nomeEspecialidade, nomeEspecialidadeTemp)==0) {
                /*   printf("\nFoi encontrado com a Descricao:%s \n", ptrTempEspecialidade->descricaoEspecialidade); */
                    printf("\nNovo nome: ");
                    fflush(stdin);
                    fgets(nomeEspecialidadeTemp, 20+1, stdin);
                    if(nomeEspecialidadeTemp[0] == '\r'  ||  nomeEspecialidadeTemp[0] == '\n'){
                        printf("\nNao Introduziu nenhuma informacao" );
                    }
                    else {
                        strcpy(ptrTempEspecialidade->nomeEspecialidade,nomeEspecialidadeTemp);
                        printf("\nIndique a Descricao:");
                        fflush(stdin);
                        fgets(ptrTempEspecialidade->descricaoEspecialidade, 40+1, stdin );
                        if(ptrTempEspecialidade->descricaoEspecialidade[0] == '\r'  ||  ptrTempEspecialidade->descricaoEspecialidade[0] == '\n')
                            printf("\nAtencao, deixou o campo vazio" );
                        }
                        listaFicheiroAlterado=TRUE;
                }
            }
            printf("\nPressione uma tecla para continuar...");
            getch();
        }
    }
    
    /*  FUNCAO PARA APAGAR ESPECIALIDADE PELO REGISTO DO NOME  */
    
    void apagarEspecialidade(PNO *cabeca){
        system("cls");
        char apagar_Especialidade[3];
        char nomeEspecialidadeTemp [20+1];
        PNO ptr;
        PESPECIALIDADES ptrTempEspecialidade;
        if(!*cabeca) {
            printf("\nNao Existem Especialidades na Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        printf("\nQual o Nome da Especialidade Medica:");
        fflush(stdin);
        fgets(nomeEspecialidadeTemp, 20+1, stdin);
        if(nomeEspecialidadeTemp[0] == '\r'  ||  nomeEspecialidadeTemp[0] == '\n'){
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu" );
            printf("\nPressione uma tecla para continuar");
            getch();
            }
        else {
            for (ptr=*cabeca; ptr; ptr = ptr->prox ){
                ptrTempEspecialidade=ptr->dados;
                if (strcmp(ptrTempEspecialidade->nomeEspecialidade, nomeEspecialidadeTemp)==0) {
                    printf("\nFoi encontrado com a Descricao: %s \n", ptrTempEspecialidade->descricaoEspecialidade);
                    printf("\nTem a certeza que deseja apagar (s/n)? :");
                    fflush(stdin);
                    fgets(apagar_Especialidade, 3, stdin);
                    if(apagar_Especialidade[0] == '\r'  ||  apagar_Especialidade[0] == '\n' || apagar_Especialidade[0] != 's'){
                        printf("\nA informacao existente nao sera alterada" );
                    }
                    else {
                        if(ptr->ant) ptr->ant->prox = ptr->prox;
                        else *cabeca = ptr->prox;
                        if(ptr->prox) ptr->prox->ant = ptr->ant;
                        ptr->ant = ptr->prox = NULL;
                        listaFicheiroAlterado=TRUE;
                        printf("\nA Especialidade  foi apagada com Sucesso\n");
                        }
                }
            }
            printf("\nPressione uma tecla para continuar");
            getch();
        }
    }
    
    /*  FUNCAO PARA LISTAR ESPECIALIDADES , MOSTRA O NOME E DESCRICAO  */
    
    void listarEspecialidades(PNO *cabeca){
        system("cls");
        PNO ptr;
        PESPECIALIDADES ptrTempEspecialidade;
        if(!*cabeca) {
            printf("\nNao Existem Especialidades na Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        for (ptr=*cabeca; ptr; ptr = ptr->prox ){
            ptrTempEspecialidade=ptr->dados;
            printf("\nEspecialidade: %s", ptrTempEspecialidade->nomeEspecialidade);
            printf("Descricao: %s \n", ptrTempEspecialidade->descricaoEspecialidade);
    	    }
        printf("\nPressione uma tecla para continuar");
        getch();
    }
    
    /*  FUNCAO PARA INSERIR MEDICOS EM MEMORIA  */
    
    void insereMedico(){
        system("cls");
        PNO ptrMedico_Temp;
        PMEDICOS pMedicos;
        int niomTemp=0;
        char nomeMedicoTemp [20+1];
        char EspMedTempMed [20+1];
        printf("\nIndique qual o Nr da ordem dos Medicos:");
        fflush(stdin);
        scanf( " %d", &niomTemp);
        printf("\nNome do Medico:");
        fflush(stdin);
        fgets(nomeMedicoTemp, 20+1, stdin);
        if(nomeMedicoTemp[0] == '\r'  ||  nomeMedicoTemp[0] == '\n' || niomTemp==0){
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu anterior" );
            printf("\nPressione uma tecla para continuar");
            getch();
            }
        else {
            printf("\nQual a especialidade do Medico: ");
            fflush(stdin);
            fgets(EspMedTempMed, 20+1, stdin);
            if (pesquisarEspecialidade(&cabecaEspecialidade, EspMedTempMed)==FALSE) {
                printf("\nA especialidade nao existe. Vai regressar ao menu" );
                printf("\nPressione uma tecla para continuar");
                getch();
                return;
            }
            pMedicos = (PMEDICOS) malloc (sizeof(MEDICOS));
            pMedicos->niom=niomTemp;
            strcpy(pMedicos->nomeMedico,nomeMedicoTemp);
            strcpy(pMedicos->espMedico,EspMedTempMed);
            ptrMedico_Temp = criarNO(pMedicos);
            insereAcabeca(&cabecaMedico,ptrMedico_Temp);
            listaFicheiroAlterado=TRUE;
            getch();
        }
    }
    
    /*  FUNCAO PARA LISTAR MEDICOS ExISTENTES PELO NUMERO DA ORDEM DOS MEDICOS, NOME E ESPECIALIDADE */
    
    void listarMedicos(PNO *cabeca){
        system("cls");
        PNO ptr;
        PMEDICOS ptrTempMedicos;
        if(!*cabeca) {
            printf("\nNao Existem Medicos na Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        for (ptr=*cabeca; ptr; ptr = ptr->prox ){
            ptrTempMedicos=ptr->dados;
            printf("\nNumero da Ordem: %d", ptrTempMedicos->niom);
            printf("\nNome: %s", ptrTempMedicos->nomeMedico);
            printf("\nEspecialidade: %s \n", ptrTempMedicos->espMedico);
    	    }
        printf("\nPressione uma tecla para continuar...");
        getch();
    }
    
    /*//////////////////////////////////////////////////////////////////////////////////////*/
    
    /*  FUNCAO PARA PESQUISAR MEDICOS INACABADA  */
    
    
    
    /*
    int pesquisarmedico(PNO *cabeca, int pesquisaNomeMedico [20+1]){
        PNO ptr;
        MEDICOS ptrTempMedicos;
        int encontrado = FALSE;
        if(!*cabeca) {
            printf("\nNao Existem Medicos na Memoria. Qualquer tecla para continuar");
            getch();
            return encontrado;
            }
        for (ptr=*cabeca; ptr; ptr = ptr->prox ){
            ptrTempMedicos=ptr->dados;
            if (strcmp(ptrTempMedicos->nomeMedico, pesquisaNomeMedico)==0)
                printf("\nFoi encontrado e tem a Especialidade:%s \n", ptrTempMedicos->espMedicoTemp);
                encontrado=TRUE;
            }
        printf("\nPressione uma tecla para continuar");
        getch();
        return encontrado;
    }
    
    */
    
    
    
    /*///////////////////////////////////////////////////////////////////////////////////////// */
    
    /*  FUNCAO PARA INSERIR ASSISTENCIAS MEDICAS POR NUMERO E DESCRICAO  */
    
    void insereAssistencia(){
        system("cls");
        PNO ptrAssistencia_Temp;
        PASSISTENCIAMEDICA pAssistencia;
        char nomeAssistenciaTemp [20+1];
        printf("\nNr. do Cartao: ");
        fflush(stdin);
        fgets(nomeAssistenciaTemp, 20+1, stdin);
        if(nomeAssistenciaTemp[0] == '\r'  ||  nomeAssistenciaTemp[0] == '\n'){
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu" );
            printf("\nPressione uma tecla para continuar");
            getch();
            }
        else {
            pAssistencia = (PASSISTENCIAMEDICA) malloc (sizeof(ASSISTENCIAMEDICA));
            strcpy(pAssistencia->nomeAssUtente,nomeAssistenciaTemp);
            printf("\nDescricao: ");
            fflush(stdin);
            fgets(pAssistencia->descAssUtente, 40+1, stdin );
            if(pAssistencia->descAssUtente[0] == '\r'  ||  pAssistencia->descAssUtente[0] == '\n'){
                printf("\n\nAtencao, deixou o campo vazio..." );
            }
            ptrAssistencia_Temp = criarNO(pAssistencia);
            insereAcabeca(&cabecaAssistenciamedica,ptrAssistencia_Temp);
            listaFicheiroAlterado=TRUE;
            getch();
        }
    }
    
    /*  FUNCAO PARA PESQUISAR  CARTOES DE ASSISTENCIA PELO NUMERO
    (TAMBEM SERA PARA ALTERAR A FIM DE PESQUISAR POR DESCRICAO)  */
    
    int pesquisar_Assistencia(PNO *cabeca, char nomeAssUtentePesq [20+1]){
        PNO ptr;
        PASSISTENCIAMEDICA ptrAssistencia_Temp;
        int encontrado = FALSE;
        if(!*cabeca) {
            printf("\nNao Existe Registo de Assistencias em Memoria. Qualquer tecla para continuar");
            getch();
            return encontrado;
            }
        for (ptr=*cabeca; ptr; ptr = ptr->prox ){
            ptrAssistencia_Temp=ptr->dados;
            if (strcmp(ptrAssistencia_Temp->nomeAssUtente, nomeAssUtentePesq)==0)
                printf("\nFoi encontrado o numero: %s \n", ptrAssistencia_Temp->descAssUtente);
                encontrado=TRUE;
            }
        printf("\nPressione uma tecla para continuar");
        getch();
        return encontrado;
    }
    
    /*  FUNCAO PARA APAGAR REGISTO DE CARTOES DE ASSISTENCIA MEDICA PELO NUMERO */
    
    void apagarAssistencia(PNO *cabeca) {
        system("cls");
        char apagar_Assistencia[3];
        char nomeAssistenciaTemp [20+1];
        PNO ptr;
        PASSISTENCIAMEDICA ptrAssistencia_Temp;
        if(!*cabeca) {
            printf("\nNao Existe Registo de Assistencias em Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        printf("\nQual o Numero do cartao: ");
        fflush(stdin);
        fgets(nomeAssistenciaTemp, 20+1, stdin);
        if(nomeAssistenciaTemp[0] == '\r'  ||  nomeAssistenciaTemp[0] == '\n'){
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu" );
            printf("\nPressione uma tecla para continuar");
            getch();
            }
        else {
            for (ptr=*cabeca; ptr; ptr = ptr->prox ){
                ptrAssistencia_Temp=ptr->dados;
                if (strcmp(ptrAssistencia_Temp->nomeAssUtente, nomeAssistenciaTemp)==0) {
                    printf("\nFoi encontrado o numero: %s \n", ptrAssistencia_Temp->descAssUtente);
                    printf("\tTem a certeza que deseja apagar (s/n)? :");
                    fflush(stdin);
                    fgets(apagar_Assistencia, 3, stdin);
                    if(apagar_Assistencia[0] == '\r'  ||  apagar_Assistencia[0] == '\n' || apagar_Assistencia[0] != 's'){
                        printf("\nA informacao existente nao sera alterada" );
                    }
                    else {
                        if(ptr->ant) ptr->ant->prox = ptr->prox;
                        else *cabeca = ptr->prox;
                        if(ptr->prox) ptr->prox->ant = ptr->ant;
                        ptr->ant = ptr->prox = NULL;
                        listaFicheiroAlterado=TRUE;
                        printf("\nO cartao foi apagado apagado com Sucesso\n");
                        }
                }
            }
            printf("\nPressione uma tecla para continuar");
            getch();
        }
    }
    
    /*  FUNCAO PARA ALTERAR DADOS NOS REGISTOS DOS CARTOES DE ASSISTENCIA  */
    
    void alterarAssistencia(PNO *cabeca){
        system("cls");
        char nomeAssistenciaTemp [20+1];
        PNO ptr;
        PASSISTENCIAMEDICA ptrAssistencia_Temp;
    /*    printf("\t\t==========Alterar Tipos de Assistencia=============");  */
        if(!*cabeca) {
            printf("\nNao Existe Registo de Assistencias em Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        printf("\nQual o numero do cartao: ");
        fflush(stdin);
        fgets(nomeAssistenciaTemp, 20+1, stdin);
        if(nomeAssistenciaTemp[0] == '\r'  ||  nomeAssistenciaTemp[0] == '\n'){  /*Se n&#227;o colocou nada */
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu..." );
            printf("\n\tPressione uma tecla para continuar");
            getch();
            }
        else {
            for (ptr=*cabeca; ptr; ptr = ptr->prox ){
                ptrAssistencia_Temp=ptr->dados;
                if (strcmp(ptrAssistencia_Temp->nomeAssUtente, nomeAssistenciaTemp)==0) {
                    printf("\nFoi encontrado o numero: %s \n", ptrAssistencia_Temp->descAssUtente);
                    printf("\nNovo niom:");
                    fflush(stdin);
                    fgets(nomeAssistenciaTemp, 20+1, stdin);
                    if(nomeAssistenciaTemp[0] == '\r'  ||  nomeAssistenciaTemp[0] == '\n'){
                        printf("\nNao Introduziu nenhuma informacao" );
                    }
                    else {
                        strcpy(ptrAssistencia_Temp->nomeAssUtente,nomeAssistenciaTemp);
                        printf("\nDescricao:");
                        fflush(stdin);
                        fgets(ptrAssistencia_Temp->descAssUtente, 40+1, stdin );
                        if(ptrAssistencia_Temp->descAssUtente[0] == '\r'  ||  ptrAssistencia_Temp->descAssUtente[0] == '\n')
                            printf("\nAtencao, deixou o campo vazio" );
                        }
                        listaFicheiroAlterado=TRUE;
                }
            }
            printf("\nPressione uma tecla para continuar...");
            getch();
        }
    }
    
    /*  FUNCAO PARA LISTAR TODOS OS  DE ASSISTENCIA MEDICA  */
    
    void listarAssistencia(PNO *cabeca){
        system("cls");
        PNO ptr;
        PASSISTENCIAMEDICA ptrAssistencia_Temp;
      /*  printf("\t\t========Listagem de Tipo de Assistencia============");  */
        if(!*cabeca) {
            printf("\nNao Existe Registo de Assistencias em Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        for (ptr=*cabeca; ptr; ptr = ptr->prox ){
            ptrAssistencia_Temp=ptr->dados;
            printf("\nCartao numero: %s", ptrAssistencia_Temp->nomeAssUtente);
            printf("Tipo de Assistencia Medica: %s \n", ptrAssistencia_Temp->descAssUtente);
    	    }
        printf("\nPressione uma tecla para continuar");
        getch();
    }
    
    
    /*  FUNCAO PARA VERIFICAR SE JA FORAM GRAVADOS OS DADOS EM MEMORIA PARA FICHEIRO  */
    
    void verificaFicheiro(){
        system("cls");
        char grava_Ficheiro[3];
        if (listaFicheiroAlterado==TRUE) {
            printf("\nExistem dados na Memoria que nao foram gravados, deseja garda-los (s/n)?:");
            fflush(stdin);
            fgets(grava_Ficheiro, 3, stdin);
            if(grava_Ficheiro[0] == '\r'  ||  grava_Ficheiro[0] == '\n' || grava_Ficheiro[0] != 's'){
                printf("\nA informacao existente vai ser descartada e carregada a do Ficheiro de Backup" );
                leFicheiro();
            }
            else {
                gravaFicheiro(&cabecaEspecialidade, &cabecaMedico, &cabecaAssistenciamedica, &cabecaUtente, &cabecaAgendaConsultas);
            }
        }
        else {
            leFicheiro();
        }
    }
    
    /* Inserir utentes*/
    
    void insereUtente(){
        system("cls");
        PNO ptrTempUtente;
        PUTENTES pUtentes;
        char nomeUtenteTemp [20+1];
        //char tipoAssitenciaTemp[30+1];
        printf("\n Insira Nome do Utente: ");
        fflush(stdin);
        fgets(nomeUtenteTemp, 20+1, stdin);
        if(nomeUtenteTemp[0] == '\r'  ||  nomeUtenteTemp[0] == '\n'){
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu anterior" );
            printf("\nPressione uma tecla para continuar");
            getch();
            }
        else {
            pUtentes = (PUTENTES) malloc (sizeof(UTENTES));
            strcpy(pUtentes->nomeUtente,nomeUtenteTemp);
           printf("\n\nIndique o tipo de Assistencia:");
            fflush(stdin);
            /* fgets(ptrTempUtente->tipoAssistencia, 40+1, stdin );
                        if(ptrTempUtente->tipoAssistencia[0] == '\r'  ||  ptrTempUtente->tipoAssistencia[0] == '\n')
                            printf("\nAtencao, deixou o campo vazio" );
                        }
            //fgets(tipoAssistenciaTemp, 30+1, stdin );
            //if(pUtentes->tipoAssistenciaTemp[0] == '\r'  ||  pUtentes->tipoAssistenciaTemp[0] == '\n'){
               // printf("\nAtencao, deixou o campo vazio" );
            //}
    
            ptrTempUtente = criarNO(pUtentes);
            insereAcabeca(&cabecaUtente,ptrTempUtente);
            listaFicheiroAlterado=TRUE;
            getch();
        }
    }
    
    /*  FUNCAO PARA PESQUISAR Utentes POR NOME */
    
    int pesquisarUtente(PNO *cabeca, char pesquisaNomeUtente [20+1]){
        PNO ptr;
        PUTENTES ptrTempUtente;
        int encontrado = FALSE;
        if(!*cabeca) {
            printf("\nNao Existem Utentes na Memoria. Qualquer tecla para continuar");
            getch();
            return encontrado;
            }
        for (ptr=*cabeca; ptr; ptr = ptr->prox ){
            ptrTempUtente=ptr->dados;
            if (strcmp(ptrTempUtente->nomeUtente, pesquisaNomeUtente)==0)
                printf("\nFoi encontrado e tem a Descricao:%s \n", ptrTempUtente->tipoAssistencia);
                encontrado=TRUE;
            }
        printf("\nPressione uma tecla para continuar");
        getch();
        return encontrado;
    }
    
     /*&#170;FUNCAO PARA ALTERAR utente NUM REGISTO ExISTENTE */
    
    void alterarUtente(PNO *cabeca){
        system("cls");
        char nomeUtenteTemp [20+1];
        PNO ptr;
        PUTENTES ptrTempUtente;
        if(!*cabeca) {
            printf("\nNao Existem Utentes na Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        printf("\nQual o Nome do Utente: ");
        fflush(stdin);
        fgets(nomeUtenteTemp, 20+1, stdin);
        if(nomeUtenteTemp[0] == '\r'  ||  nomeUtenteTemp[0] == '\n'){  /* Se n&#227;o colocou nada */
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu anterior" );
            printf("\n\tPressione uma tecla para continuar...");
            getch();
            }
        else {
            for (ptr=*cabeca; ptr; ptr = ptr->prox ){
                ptrTempUtente=ptr->dados;
                if (strcmp(ptrTempUtente->nomeUtente, nomeUtenteTemp)==0) {
                   printf("\nFoi encontrado com o tipo de Assistencia:%s \n", ptrTempUtente->tipoAssistencia);
                    printf("\nNovo nome: ");
                    fflush(stdin);
                    fgets(nomeUtenteTemp, 20+1, stdin);
                    if(nomeUtenteTemp[0] == '\r'  ||  nomeUtenteTemp[0] == '\n'){
                        printf("\nNao Introduziu nenhuma informacao" );
                    }
                    else {
                        strcpy(ptrTempUtente->nomeUtente,nomeUtenteTemp);
                        printf("\nIndique otipo de Assistencia:");
                        fflush(stdin);
                        fgets(ptrTempUtente->tipoAssistencia, 40+1, stdin );
                        if(ptrTempUtente->tipoAssistencia[0] == '\r'  ||  ptrTempUtente->tipoAssistencia[0] == '\n')
                            printf("\nAtencao, deixou o campo vazio" );
                        }
                        listaFicheiroAlterado=TRUE;
                }
            }
            printf("\nPressione uma tecla para continuar...");
            getch();
        }
    }
    
    /*  FUNCAO PARA APAGAR Utente PELO REGISTO DO NOME  */
    
    void apagarUtente(PNO *cabeca){
        system("cls");
        char apagar_Utente[3];
        char nomeUtenteTemp [20+1];
        PNO ptr;
        PUTENTES ptrTempUtente;
        if(!*cabeca) {
            printf("\nNao Existem Utentes na Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        printf("\nQual o Nome do Utente:");
        fflush(stdin);
        fgets(nomeUtenteTemp, 20+1, stdin);
        if(nomeUtenteTemp[0] == '\r'  ||  nomeUtenteTemp[0] == '\n'){
            printf("\nNao Introduziu nenhuma informacao. Vai regressar ao menu" );
            printf("\nPressione uma tecla para continuar");
            getch();
            }
        else {
            for (ptr=*cabeca; ptr; ptr = ptr->prox ){
                ptrTempUtente=ptr->dados;
                if (strcmp(ptrTempUtente->nomeUtente, nomeUtenteTemp)==0) {
                    printf("\nFoi encontrado com o tipo de Assistencia: %s \n", ptrTempUtente->tipoAssistencia);
                    printf("\nTem a certeza que deseja apagar (s/n)? :");
                    fflush(stdin);
                    fgets(apagar_Utente, 3, stdin);
                    if(apagar_Utente[0] == '\r'  ||  apagar_Utente[0] == '\n' || apagar_Utente[0] != 's'){
                        printf("\nA informacao existente nao sera alterada" );
                    }
                    else {
                        if(ptr->ant) ptr->ant->prox = ptr->prox;
                        else *cabeca = ptr->prox;
                        if(ptr->prox) ptr->prox->ant = ptr->ant;
                        ptr->ant = ptr->prox = NULL;
                        listaFicheiroAlterado=TRUE;
                        printf("\nA Utente  foi apagada com Sucesso\n");
                        }
                }
            }
            printf("\nPressione uma tecla para continuar");
            getch();
        }
    }
    
    /*  FUNCAO PARA LISTAR Utentes , MOSTRA O NOME E DESCRICAO  */
    
    void listarUtentes(PNO *cabeca){
        system("cls");
        PNO ptr;
        PUTENTES ptrTempUtente;
        if(!*cabeca) {
            printf("\nNao Existem Utentes na Memoria. Qualquer tecla para continuar");
            getch();
            return;
            }
        for (ptr=*cabeca; ptr; ptr = ptr->prox ){
            ptrTempUtente=ptr->dados;
            printf("\n:Utente %s", ptrTempUtente->nomeUtente);
            printf("Assistencia: %s \n", ptrTempUtente->tipoAssistencia);
    	    }
        printf("\nPressione uma tecla para continuar");
        getch();
    }
    
    
    
    
    /*  FUNCAO PARA LER DADOS DO FICHEIRO EM DISCO  */
    
    void leFicheiro(){
        system("cls");
        int i, Registos_Especialidades=0, Registos_Assistencia=0;
        char ficheiro[LEN_FICHEIRO+3];
        PESPECIALIDADES ptrEspecialidadeMedica_Temp;
        PMEDICOS ptrMedico_Temp;
        PASSISTENCIAMEDICA ptrAssistencia_Temp;
        PUTENTES pTempUtente;
        FILE *fp;
        puts( "\n\tLer dados.\n"
           "Qual o nome do ficheiro a Ler? (vazio para \"" FICHEIRO_DEFAULT "\"):");
        fflush(stdin);
        fgets( ficheiro, sizeof(ficheiro), stdin );
        if(ficheiro[0] == '\r'  ||  ficheiro[0] == '\n')
            strcpy(ficheiro, FICHEIRO_DEFAULT);
        fp = fopen( ficheiro, "rb" );
        if( fp == NULL ) {
            puts( "\nNao foi possivel abrir o ficheiro" );
            getch();
            return;
        }
        fread (&Registos_Especialidades, sizeof(int), 1, fp);
        for(i=0; i<Registos_Especialidades;i++) {
            ptrEspecialidadeMedica_Temp = (PESPECIALIDADES*) malloc (sizeof(ESPECIALIDADES));
            fread(ptrEspecialidadeMedica_Temp, sizeof(ESPECIALIDADES), 1, fp);
            insereAcabeca(&cabecaUtente,ptrEspecialidadeMedica_Temp);
        }
        fread (&Registos_Assistencia, sizeof(int), 1, fp);
        for(i=0; i<Registos_Assistencia;i++) {
            ptrAssistencia_Temp = (PASSISTENCIAMEDICA*) malloc (sizeof(ASSISTENCIAMEDICA));
            fread(ptrAssistencia_Temp, sizeof(ASSISTENCIAMEDICA), 1, fp);
            insereAcabeca(&cabecaAssistenciamedica,ptrAssistencia_Temp);
        }
        fclose(fp);
    
        printf("\nO Ficheiro foi carregado correctamente");
        listaFicheiroAlterado=FALSE;
        printf("\nPressione uma tecla para continuar");
        getch();
    }
    
    /*  FUNCAO PARA GRAVAR DADOS NO FICHEIRO EM DISCO  */
    
    void gravaFicheiro(PNO *cabecaEspMedicaTemp, PNO *cabecaMedicoTemp, PNO *cabecaAssUtenteTemp, PNO *cabecaUtenteTemp, PNO *cabecaAgendaConsultasTemp){
        system("cls");
        int Registos_Especialidades=0, Registos_Assistencia=0;
        char ficheiro[LEN_FICHEIRO+3];
        PNO ptr;
        PESPECIALIDADES ptrEspecialidadeMedica_Temp;
        PMEDICOS ptrMedico_Temp;
        PASSISTENCIAMEDICA ptrAssistencia_Temp;
        PUTENTES pTempUtente;
        FILE *fp;
        puts( "\n\tGravar dados.\n"
           "Qual o nome do ficheiro a gravar? (vazio para \"" FICHEIRO_DEFAULT "\"):");
        fflush(stdin);
        fgets( ficheiro, sizeof(ficheiro), stdin );
        if(ficheiro[0] == '\r'  ||  ficheiro[0] == '\n')
            strcpy(ficheiro, FICHEIRO_DEFAULT);
        /* Grava os dados */
        fp = fopen( ficheiro, "wb" );
        if( fp == NULL ) {
            puts( "\n\tNao foi possivel criar o ficheiro. Processo interrompido..." );
            getch();
            return;
        }
        if(!*cabecaEspMedicaTemp) fwrite(&Registos_Especialidades, sizeof(int), 1, fp);
        else {
            for (ptr=*cabecaEspMedicaTemp; ptr; ptr = ptr->prox, Registos_Especialidades++);
            fwrite(&Registos_Especialidades, sizeof(int), 1, fp);
            for (ptr=*cabecaEspMedicaTemp; ptr; ptr = ptr->prox) fwrite(ptr, sizeof(ESPECIALIDADES), 1, fp);
            }
    
        if(!*cabecaAssUtenteTemp) fwrite(&Registos_Assistencia, sizeof(int), 1, fp);
        else {
            for (ptr=*cabecaAssUtenteTemp; ptr; ptr = ptr->prox, Registos_Assistencia++);
            fwrite(&Registos_Assistencia, sizeof(int), 1, fp);
            for (ptr=*cabecaAssUtenteTemp; ptr; ptr = ptr->prox) fwrite(ptr, sizeof(ASSISTENCIAMEDICA), 1, fp);
            }
    
        fclose(fp);
    
        printf("\n\tA BD foi salva em Ficheiro correctamente...");
        listaFicheiroAlterado=FALSE;
        printf("\n\n\tPressione uma tecla para continuar...");
        getch();
    }
    
    /*  A PARTIR DAQUI TEMOS A PARTE PRINCIPAL DO PROGRAMA, ONDE CHAMA AS FUNCOES NECESSARIAS PARA
    RESPONDER AO SOLICITADO PELO UTILIZADOR , ATRAVEZ DOS MENUS  */
    
    int main()
    {
        char escolha;
        do {
            system("cls");
    		printf("\n   Menu Principal\n");
            printf("\n   1 - Menu Especialidades\n");
            printf("\n   2 - Menu Medicos\n");
            printf("\n   3 - Menu Assistencia\n");
            printf("\n   4 - Menu Utentes\n");
            printf("\n   5 - Menu Consultas\n");
            printf("\n   6 - Menu Pesquisa\n");
    		printf("\n   7 - Menu Ordenar\n");
            printf("\n   8 - Ler Ficheiro\n");
            printf("\n   9 - Gravar Ficheiro\n");
            printf("\n   0 - Sair   do   Programa\n");
            printf("\n   Escolha a Opcao:");
            escolha=getch();
    
            switch(escolha)
            {
            case '1':
                MenuEspecialidades();
                break;
            case '2':
    			MenuMedicos();
    			break;
            case '3':
                MenuAssistenciaMedica();
    			break;
            case '4':
                MenuUtentes();
    			break;
            case '5':
                MenuConsultas();
    			break;
            case '6':
                MenuPesquisas();
                break;
    	    case '7':
                MenuOrdenar();
                break;
            case '8':
                verificaFicheiro();
                break;
            case '9':
                gravaFicheiro(&cabecaEspecialidade, &cabecaMedico, &cabecaAssistenciamedica, &cabecaUtente, &cabecaAgendaConsultas);
                break;
            case '0':
                fim();
                break;
            default:
                getch();
                break;
            }
        } while (escolha!='0');
    
    }
    
    void MenuEspecialidades(){
        char escolhaE;
        do {
            system("cls");
            printf("\n   Menu Especialidades\n");
            printf("\n   1 - Inserir Especialidade\n");
            printf("\n   2 - Alterar Especialidade\n");
            printf("\n   3 - Apagar Especialidade\n");
            printf("\n   4 - Listar Especialidades\n");
            printf("\n   0 - Menu principal\n");
            printf("\n   Escolha a Opcao:");
            escolhaE=getch();
            switch(escolhaE) {
            case '1':
                insereEspecialidade();
                break;
            case '2':
    			alterarEspecialidade(&cabecaEspecialidade);
    			break;
            case '3':
                apagarEspecialidade(&cabecaEspecialidade);
    			break;
            case '4':
                listarEspecialidades(&cabecaEspecialidade);
    			break;
            case '0':
                return;
                break;
            default:
                getch();
                break;
            }
        } while (escolhaE!='0');
    }
    
    void MenuMedicos(){
        char escolhaM;
        do {
            system("cls");
            printf("\n   Menu Medicos\n");
            printf("\n   1 - Inserir Medico\n");
            printf("\n   2 - Alterar Medico\n");
            printf("\n   3 - Apagar Medico\n");
            printf("\n   4 - Listar Medicos\n");
            printf("\n   5 - Ordenar Modicos por Nome\n");
            printf("\n   6 - Ordenar Modicos por Especialidade\n");
            printf("\n   0 - Voltar ao Menu principal\n");
            printf("\n   Escolha a Opcao:");
            escolhaM=getch();
            switch(escolhaM) {
            case '1':
                insereMedico();
                break;
            case '2':
    			break;
            case '3':
    			break;
            case '4':
                listarMedicos(&cabecaMedico);
    			break;
            case '5':
    			break;
            case '6':
    			break;
            case '0':
                return;
                break;
            default:
                getch();
                break;
            }
        } while (escolhaM!='0');
    }
    
    void MenuAssistenciaMedica(){
        char escolhaA;
        do {
            system("cls");
            printf("\n   Menu Assistencia\n");
            printf("\n   1 - Inserir nova Assistencia\n");
            printf("\n   2 - Alterar Assistencia\n");
            printf("\n   3 - Apagar Assistencia\n");
            printf("\n   4 - Listar Assistencias existentes\n");
            printf("\n   0 - Voltar ao Menu principal\n");
            printf("\n   Escolha a Opcao:");
            escolhaA=getch();
            switch(escolhaA) {
            case '1':
                insereAssistencia();
                break;
            case '2':
    			alterarAssistencia(&cabecaAssistenciamedica);
    			break;
            case '3':
                apagarAssistencia(&cabecaAssistenciamedica);
    			break;
            case '4':
                listarAssistencia(&cabecaAssistenciamedica);
    			break;
            case '0':
                return;
                break;
            default:
                getch();
                break;
            }
        } while (escolhaA!='0');
    }
    
    void MenuUtentes(){
        char escolhaU;
        do {
            system("cls");
            printf("\n   Menu Utentes\n");
            printf("\n   1 - Inserir Utente\n");
            printf("\n   2 - Alterar Utente\n");
            printf("\n   3 - Apagar Utente\n");
            printf("\n   4 - Listar Utente\n");
            printf("\n   0 - Voltar ao Menu principal\n");
            printf("\n   Escolha a Opcao:");
            escolhaU=getch();
            switch(escolhaU) {
            case '1':
                insereUtente();
                break;
            case '2':
           alterarUtente(&cabecaUtente);
    			break;
            case '3':
            apagarUtente(&cabecaUtente);
    			break;
            case '4':
    //       listarUtente(&cabecaUtente);
    			break;
            case '0':
                return;
                break;
            default:
                getch();
                break;
            }
        } while (escolhaU!='0');
    }
    
    void MenuConsultas(){
        char escolhaC;
        do {
            system("cls");
            printf("\n   Menu Consultas\n");
            printf("\n   1 - Marcar consulta\n");
            printf("\n   2 - Alterar marcacao de consulta\n");
            printf("\n   3 - Apagar consulta\n");
            printf("\n   4 - Listar consultas\n");
            printf("\n   5 - Pesquisar consultas por data\n");
    		printf("\n   6 - Pesquisar consultas por Medico\n");
            printf("\n   0 - Voltar ao Menu principal\n");
            printf("\n   Escolha a Opcao:");
            escolhaC=getch();
            switch(escolhaC) {
            case '1':
                break;
            case '2':
    			break;
            case '3':
    			break;
            case '4':
    			break;
            case '5':
    			break;
    		case '6':
    			break;
            case '0':
                return;
                break;
            default:
                getch();
                break;
            }
        } while (escolhaC!='0');
    }
    
    void MenuPesquisas(){
        char escolhaP;
        do {
            system("cls");
            printf("\n   Menu Pesquisas\n");
            printf("\n   1 - Pesquisar MEDICOS por Especialidade/Nome\n");
            printf("\n   2 - Pesquisar Utente por Nome/numero de cartao\n");
            printf("\n   3 - Pesquisar Consultas por Data/Medico\n");
            printf("\n   0 - Voltar ao Menu principal\n");
            printf("\n   Escolha a Opcao:");
            escolhaP=getch();
            switch(escolhaP) {
            case '1':
                break;
            case '2':
    			break;
            case '3':
    			break;
            case '0':
                return;
                break;
            default:
                getch();
                break;
            }
        } while (escolhaP!='0');
    }
    
    void MenuOrdenar()
    {
        char escolhaP;
        do {
            system("cls");
            printf("\n   Menu Ordenar\n");
            printf("\n   1 - Ordenar MEDICOS por Especialidade/Nome\n");
            printf("\n   2 - Ordenar Utente por Nome/Data de nascimento\n");
            printf("\n   3 - Ordenar Consultas por Data/hora\n");
            printf("\n   0 - Voltar ao Menu principal\n");
            printf("\n   Escolha a Opcao:");
            escolhaP=getch();
    
            switch(escolhaP)
            {
            case '1':
                break;
            case '2':
    			break;
            case '3':
    			break;
            case '0':
                return;
                break;
            default:
                getch();
                break;
            }
        } while (escolhaP!='0');
        return 0;
    }

  6. #6
    Registered User
    Join Date
    Sep 2008
    Posts
    15
    sorry mat, this is very big! and i'm not very good programmer! so i don&#180;t know...why this error

  7. #7
    Frequently Quite Prolix dwks's Avatar
    Join Date
    Apr 2005
    Location
    Canada
    Posts
    8,047
    Code:
    1.c: In function ‘fim’:
    1.c:137: warning: implicit declaration of function ‘getch’
    1.c:180:16: warning: multi-character character constant
    1.c: In function ‘ordenaNome’:
    1.c:180: warning: comparison is always false due to limited range of data type
    1.c:181: warning: ‘return’ with a value, in function returning void
    1.c:183: warning: ‘return’ with a value, in function returning void
    1.c: In function ‘ordenaNomeMedico’:
    1.c:189: warning: ‘return’ with a value, in function returning void
    1.c:191: warning: ‘return’ with a value, in function returning void
    1.c: In function ‘ordenaMedicoEsp’:
    1.c:197: warning: ‘return’ with a value, in function returning void
    1.c:199: warning: ‘return’ with a value, in function returning void
    1.c: In function ‘ordenaUtenteNome’:
    1.c:205: warning: ‘return’ with a value, in function returning void
    1.c:207: warning: ‘return’ with a value, in function returning void
    1.c: In function ‘ordenaUtenteData’:
    1.c:213: warning: ‘return’ with a value, in function returning void
    1.c:215: warning: ‘return’ with a value, in function returning void
    1.c:713:1: warning: "/*" within comment
    1.c: In function ‘leFicheiro’:
    1.c:877: warning: assignment from incompatible pointer type
    1.c:879: warning: passing argument 2 of ‘insereAcabeca’ from incompatible pointer type
    1.c:883: warning: assignment from incompatible pointer type
    1.c:885: warning: passing argument 2 of ‘insereAcabeca’ from incompatible pointer type
    1.c:861: warning: unused variable ‘pTempUtente’
    1.c:859: warning: unused variable ‘ptrMedico_Temp’
    1.c: In function ‘gravaFicheiro’:
    1.c:905: warning: unused variable ‘pTempUtente’
    1.c:904: warning: unused variable ‘ptrAssistencia_Temp’
    1.c:903: warning: unused variable ‘ptrMedico_Temp’
    1.c:902: warning: unused variable ‘ptrEspecialidadeMedica_Temp’
    1.c: In function ‘insereUtente’:
    1.c:945: warning: ‘main’ is normally a non-static function
    1.c: In function ‘MenuOrdenar’:
    1.c:1242: warning: ‘return’ with a value, in function returning void
    1.c: In function ‘insereUtente’:
    1.c:1243: error: expected declaration or statement at end of input
    1.c:1243: error: expected declaration or statement at end of input
    1.c:680: warning: unused variable ‘ptrTempUtente’
    1.c: At top level:
    1.c:897: warning: unused parameter ‘cabecaMedicoTemp’
    1.c:897: warning: unused parameter ‘cabecaUtenteTemp’
    1.c:897: warning: unused parameter ‘cabecaAgendaConsultasTemp’
    1.c: In function ‘main’:
    1.c:1002: warning: control reaches end of non-void function
    Also consider not using fflush(stdin) . . . .
    dwk

    Seek and ye shall find. quaere et invenies.

    "Simplicity does not precede complexity, but follows it." -- Alan Perlis
    "Testing can only prove the presence of bugs, not their absence." -- Edsger Dijkstra
    "The only real mistake is the one from which we learn nothing." -- John Powell


    Other boards: DaniWeb, TPS
    Unofficial Wiki FAQ: cpwiki.sf.net

    My website: http://dwks.theprogrammingsite.com/
    Projects: codeform, xuni, atlantis, nort, etc.

  8. #8
    Registered User
    Join Date
    Sep 2008
    Posts
    15
    i&#180;ve tryied another IDE and the error is "sintax error at end of input", i&#180;m cheking every line but i din&#180;t find any mistake...

  9. #9
    Banned master5001's Avatar
    Join Date
    Aug 2001
    Location
    Visalia, CA, USA
    Posts
    3,685
    I would try using an IDE that at least has proper spelling in their error messages.

  10. #10
    Registered User
    Join Date
    Sep 2008
    Posts
    15
    dwks , you are telling me that all this warnings are bad and corrupts my program ? thanks for the help. i&#180;m going to follow your advise over the fflush...

  11. #11
    Frequently Quite Prolix dwks's Avatar
    Join Date
    Apr 2005
    Location
    Canada
    Posts
    8,047
    Well, sure. Some of them spell trouble. It's best to fix them if you can. (You should also enable warnings on your compiler if you haven't already.)

    BTW, "parse error at end of input" usually means you have more opening curly braces than closing ones. I'm not sure exactly where.

    A lot of your functions look pretty similar . . . .
    dwk

    Seek and ye shall find. quaere et invenies.

    "Simplicity does not precede complexity, but follows it." -- Alan Perlis
    "Testing can only prove the presence of bugs, not their absence." -- Edsger Dijkstra
    "The only real mistake is the one from which we learn nothing." -- John Powell


    Other boards: DaniWeb, TPS
    Unofficial Wiki FAQ: cpwiki.sf.net

    My website: http://dwks.theprogrammingsite.com/
    Projects: codeform, xuni, atlantis, nort, etc.

  12. #12
    and the hat of wrongness Salem's Avatar
    Join Date
    Aug 2001
    Location
    The edge of the known universe
    Posts
    32,663
    How come you wrote 1000+ lines of code, and have only just noticed there's a compilation problem?

    Consider this for your next program.
    A development process
    That is, before you dig yourself into an even bigger hole without even realising it.
    If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
    If at first you don't succeed, try writing your phone number on the exam paper.
    I support http://www.ukip.org/ as the first necessary step to a free Europe.

  13. #13
    Frequently Quite Prolix dwks's Avatar
    Join Date
    Apr 2005
    Location
    Canada
    Posts
    8,047
    Your problem is here. Be very careful when you comment out curly braces. (Or forget to terminate multi-line comments. And enable syntax highlighting so that you can see when you do this.)
    Code:
    /* Inserir utentes*/
    
    void
    insereUtente ()
    {
      system ("cls");
      PNO ptrTempUtente;
      PUTENTES pUtentes;
      char nomeUtenteTemp[20 + 1];
      //char tipoAssitenciaTemp[30+1];
      printf ("\n Insira Nome do Utente: ");
      fflush (stdin);
      fgets (nomeUtenteTemp, 20 + 1, stdin);
      if (nomeUtenteTemp[0] == '\r' || nomeUtenteTemp[0] == '\n')
        {
          printf
    	("\nNao Introduziu nenhuma informacao. Vai regressar ao menu anterior");
          printf ("\nPressione uma tecla para continuar");
          getch ();
        }
      else
        {
          pUtentes = (PUTENTES) malloc (sizeof (UTENTES));
          strcpy (pUtentes->nomeUtente, nomeUtenteTemp);
          printf ("\n\nIndique o tipo de Assistencia:");
          fflush (stdin);
          /* fgets(ptrTempUtente->tipoAssistencia, 40+1, stdin );
             if(ptrTempUtente->tipoAssistencia[0] == '\r'  ||  ptrTempUtente->tipoAssistencia[0] == '\n')
             printf("\nAtencao, deixou o campo vazio" );
             }
             //fgets(tipoAssistenciaTemp, 30+1, stdin );
             //if(pUtentes->tipoAssistenciaTemp[0] == '\r'  ||  pUtentes->tipoAssistenciaTemp[0] == '\n'){
             // printf("\nAtencao, deixou o campo vazio" );
             //}
    
             ptrTempUtente = criarNO(pUtentes);
             insereAcabeca(&cabecaUtente,ptrTempUtente);
             listaFicheiroAlterado=TRUE;
             getch();
             }
             }
    
             /*  FUNCAO PARA PESQUISAR Utentes POR NOME */
    I agree with Salem, though. At the very least, you could have done a little bit of modularization (putting similar code into functions).
    dwk

    Seek and ye shall find. quaere et invenies.

    "Simplicity does not precede complexity, but follows it." -- Alan Perlis
    "Testing can only prove the presence of bugs, not their absence." -- Edsger Dijkstra
    "The only real mistake is the one from which we learn nothing." -- John Powell


    Other boards: DaniWeb, TPS
    Unofficial Wiki FAQ: cpwiki.sf.net

    My website: http://dwks.theprogrammingsite.com/
    Projects: codeform, xuni, atlantis, nort, etc.

  14. #14
    Registered User
    Join Date
    Sep 2008
    Posts
    15
    i&#180;m sorry i get out... but i&#180;ve tried yours tips same worked bur i have the same error.
    i reduce the number of warnings...

  15. #15
    Registered User
    Join Date
    Sep 2008
    Posts
    15
    okay tomorrow i return and continue to work on this thanks you guys!!!

Page 1 of 3 123 LastLast
Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Compiling sample DarkGDK Program
    By Phyxashun in forum Game Programming
    Replies: 6
    Last Post: 01-27-2009, 02:07 AM
  2. Testing some code, lots of errors...
    By Sparrowhawk in forum C Programming
    Replies: 48
    Last Post: 12-15-2008, 03:09 AM
  3. Game Pointer Trouble?
    By Drahcir in forum C Programming
    Replies: 8
    Last Post: 02-04-2006, 01:53 AM
  4. ras.h errors
    By Trent_Easton in forum Windows Programming
    Replies: 8
    Last Post: 07-15-2005, 10:52 PM
  5. Linking error
    By DockyD in forum C++ Programming
    Replies: 10
    Last Post: 01-20-2003, 04:27 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21