//Empilha a pilha um em cima da pilha2 void uniaodepilhas(Pilha* pilha1, Pilha* pilha2){ Pilha aux; int elem; limpa(&aux); while(ehvazia(pilha1) != 1){ desempilha(&elem, pilha1); empilha(elem, &aux); } while(ehvazia(&aux)!= 1){ desempilha(&elem, &aux); empilha(elem, pilha2); } }
int main(void){ char frase[]="akila a baleia dos 7 mares ."; ld pilha; int cont=0; char aux; define(&pilha); //scanf("%[^\n]",&frase); printf("%s\n",frase ); while(frase[cont]!='.'){ printf(" "); while(frase[cont]!=' '){ empilha(&pilha,frase[cont]); cont++; } while(pilha.quant>0){ aux=desempilha(&pilha); printf("%c",aux ); } cont++; } return 0; }
int main(){ PilhaInt f; inicializa(&f); int x, OP=1; while((OP >= 1) && (OP <= 3)){ printf("\t\t-- Pilha Simples Com Vetor - By Genicleito Goncalves--\n\n"); printf("\n1. Empilhar;"); printf("\n2. Desempilhar."); printf("\n\nOpcao Desejada: "); scanf("%d", &OP); if(OP == 1){ printf("\nNumero para empilhar: "); scanf("%d", &x); if(empilha(&f, x)){ printf("\nEmpilhado %d com sucesso!\n", x); }else printf("\nNao foi possivel empilhar o numero %d.\n", x); } else if(OP == 2){ if(desempilha(&f, &x)) printf("\nO valor %d foi desempilhado!\n", x); else printf("\nA Pilha esta vazia!\n"); } } return 0; }
void alteraLista(Lista *original, Lista *alterada) { destroyLista(alterada); Fila letras; iniciaFila(&letras); Pilha numeros; iniciaPilha(&numeros); // analisa os elementos da lista original struct elementoLista *aux = original->inicio; while(aux != NULL) { if(isalpha(aux->info)) enfileira(&letras, aux->info); else if(isdigit(aux->info)) empilha(&numeros, aux->info); else printf("Invalid character (%c).\n", aux->info); aux = aux->next; } //adiciona os valores a lista alterada while(emptyFila(&letras) != 1) pushBackLista(alterada, desenfileira(&letras)); while(sizePilha(&numeros) != 0) pushBackLista(alterada, desempilha(&numeros)); destroyFila(&letras); destroyPilha(&numeros); }
void produtor(Shared *shm) { int i, j, n; /* Total de unidades produzidas */ int produzidos = 0; for(i = 1; i <= LIMITE; i++) { /* Aguarda ate semaforo ficar verde */ sem_wait(&shm->p_sem); /* produz entre 0 e 9 vezes por ciclo */ n = randomNumber(0, 9); printf("[PID: %d] Produzir: %d vezes\n", getpid(), n); /* Produz N produtos por ciclo */ for(j = 0; j < n; j++) { if(!pilhaCheia(&shm->pilha)) { printf("[PID: %d] Produzindo: %d - Lote: %d\n", getpid(), ++produzidos, i); empilha(&shm->pilha, produzidos); } else { printf("[PID: %d] Pilha encheu! O lote %d teve %d unidades\n", getpid(), i, j); break; } } /* Sinaliza que nao vai mais produzir caso tenha executado todos os ciclos */ if(i == LIMITE) { shm->termina = 1; printf("[PID: %d] Não vai mais produzir\n", getpid()); } /* Libera consumidores */ sem_post(&shm->c_sem); } }
void empilha_erd (arvore r) { if (r != NULL) { empilha_erd (r->esq); empilha (r->valor); empilha_erd (r->dir); } }
/** * Função responsável por analisar o tabuleiro referenciado em "atual" para * gerar e empilhar todos os novos estados possíveis no momento. Caso pelo * menos um novo estado tenha sido empilhado, retorna TRUE, senão, FALSE. */ int empilhaCandidatos(jogo oJogo, estado *atual){ int i, j, k, empilhou = FALSE; char direcoes[] = {'N', 'S', 'L', 'O'}; movimento mov; estado *novo; if(atual->numMov == oJogo.maxMov) return FALSE; for(i = 0; i < oJogo.l; i++){ for(j = 0; j < oJogo.c; j++){ if(atual->tabuleiro[i][j] != PINO) continue; for(k = 0; k < 4; k++){ mov = geraMovimento(i, j, direcoes[k]); if(movimentoValido(oJogo, atual, mov)){ novo = executaMovimento(oJogo, atual, mov); empilha(oJogo.candidatos, novo); empilhou = TRUE; } } } } return empilhou; }
int main(){ int i, remove; float aux; Pilha filha; inicializa_pilha(&filha, 5, sizeof(float)); for(i=0;i<5;i++){ scanf("%f", &aux); empilha(&filha, &aux); } mostra_pilha(filha, mostra_float); printf("\nRemover quantos elementos? (0 ate 5): "); scanf("%d", &remove); for(i=0;i<remove;i++) desempilha(&filha); mostra_pilha(filha, mostra_float); system("PAUSE"); }
void eB() { empilha(eC,pilha_estados, &posicao_pilha); // chamada da própria máquina eA(); }
int main(){ int n, i, j, cont = 0, aux; Pilha *s = malloc(sizeof(Pilha)); char v[] = { 'F', 'A', 'C', 'E' }, v2[4]; inicPilha(s); for(i = 0; i < 4; i++) empilha(s, v[i]); scanf("%d", &n); getchar(); for(i = 0; i < n; i++){ scanf("%c %c %c %c", &v[0], &v[1], &v[2], &v[3]); getchar(); for(j = 0; j < 4; j++){ v2[j] = desempilha(s); } aux = 0; for(j = 0; j < 4; j++){ if(v[j] == v2[j]); aux++; } if(aux == 4){ cont++; for(j = 0; j < 4; j++){ empilha(s, v2[j]); } } else{ for(j = 0; j < 4; j++){ empilha(s, v[j]); } } } printf("%d\n", cont); return 0; }
void resolve() { int mov, topo, passos, x,y; item local, aux; posicao atual; item pilha[32]; topo = 0; passos = 1; x = 0, y = 0, mov = 1; atual.x = 3; atual.y = 3; local.pos.x = 0; local.pos.y = 0; local.mov = 1; while ( passos < 32 ) { while ( mov <= 4 ) { desenha(); printf(" %d ", podemov( atual, mov ) ); if ( podemov( &atual, mov ) ) { printf("Testando uma posicao... \n "); break; } else mov++; } if ( mov < 5 ) { local.pos.x = atual.x; local.pos.y = atual.y; local.mov = mov; printf("Empilhando uma posicao... \n"); empilha( pilha, &topo, local ); x = 0; y = 0; passos++; mov = 1; } else if ( mov == 5 ) { printf("Procurando uma posicao... \n"); for ( ; x < MAX, x++ ) { for ( ; y < MAX, y++ ) { if ( achaoutro( x, y ) ) { atual.x = x; atual.y = y; break; } } } } if ( x == 6 && y == 6 && mov == 5 ) { if ( topo == 0 ) printf("Sem Solucao. /n"); else { aux = topodapilha( pilha, topo ); atual.x = aux.pos.x; atual.y = aux.pos.y; mov = aux.mov + 1; passos--; printf("Desempilhando uma posicao... \n"); desempilha( &topo ); } } }
int main( void ) { char op; // opcao do menu PILHA* p; // declaracao da pilha // variavel do tipo pilha = pilha de ponteiros while( 1 ){ printf( "\n /---------------------------------------------------/" ); printf( "\n Programa de cadastro academico - Menu " ); printf( "\n [1] Cria pilha " ); printf( "\n [2] Empilha " ); printf( "\n [3] Desempilha " ); printf( "\n [4] Imprime pilha " ); printf( "\n [5] Para sair do programa " ); printf( "\n /---------------------------------------------------/" ); printf( "\n Opcao: " ); op = getchar();// tecla de opcao do menu switch( op ) { case '1': // rotina cria pilha cria_pilha( &p ); break; case '2': // rotina empilha empilha( &p ); break; case '3': // rotina desempilha desempilha( &p ); break; case '4': // rotina imprime pilha imprime_pilha( p ); break; case '5': // t�rmino do programa exit( 1 ); break; default : printf( "\n Digite uma opcao!" ); break; } // switch( op ) __fpurge(stdin); fflush( stdin ); // limpa buffer do teclado, funciona junto com entrada de dados getchar(); // parada da tela printf( "\n" ); } // fim do while( 1 ) return 0; } // fim do programa principal
int recorta_pilha(tp_pilha *pMain, tp_pilha *pDestiny){ //printf("\n=============\nCheguei no Recorta Pilha\n=============\n"); tp_item e; int i; for(i = pMain->topo; i >= 0; i--){ desempilha(pMain, &e); //printf("\nO Valor [%d] foi Removido da Pilha Principal!",e); empilha(pDestiny,e); //printf("\nO Valor [%d] foi Inserido na Pilha Destino!",e); } return 1; }
void removerValor(pilha *p, int x){ if(!pilhaVazia(*p)){ pilha aux; if(p->conteudo[p->topo] == x){ p->topo--; }else{ int i = p->topo; criaPilha(&aux); while(p->conteudo[i] != x){ empilha(&aux,p->conteudo[i]); desenpilha(p); i--; } i = aux.topo-1; while(i > 0){ empilha(p,aux.conteudo[i]); i--; } } } }
int empilhaTipoT(PilhaT *pilha, TipoT novo_tipo) { TipoT *tipo_aux; tipo_aux = malloc (sizeof (TipoT)); if (tipo_aux == NULL) { trataErro(ERRO_ALOCACAO, ""); } *tipo_aux = novo_tipo; empilha(pilha, tipo_aux); return 0; }
int busca(int j, int i, grafo *g) { int v, u, *visitado, k; pilha *P; P = constroi_pilha(); cor = (int *) calloc(g->n_vertices, sizeof(int)); cor[i] = 1; empilha(i, P); while(!vazia_pilha(P)) { v = topo_da_pilha(P); for (u = 0; u < g->n_vertices; u++) { //tem aresta de do vertice v para vertice count if(!visitado[count] && (g->matriz[v][u])) { if (count == j) { // ACHOU! tem caminho de i para j. printf("Destruindo arestas\n"); while(v>=0){ g->matriz[v][count] = 0;//retiramos a aresta que nos fez chegar ao vertice j. g->matriz[count][v] = 0; count=v; v=desempilha(P); } destroi_pilha(P); return 1; } else { visitado[count] = 1; empilha(count,P); } } } printf("Imprimindo vertice"); for (i = 0; i < g->n_vertices; i++) printf("%d->", visitado[i]); printf("\n"); } destroi_pilha(P); return 0; }
int geraRotulo(char **novo_rotulo, int *contador, PilhaT *pilha_rot) { char *rot; *novo_rotulo = malloc (sizeof (char [ROTULO_TAM])); if (*novo_rotulo == NULL) { trataErro(ERRO_ALOCACAO, ""); } sprintf(*novo_rotulo, "R%02d", *contador); *contador = *contador + 1; empilha(pilha_rot, *novo_rotulo); return 0; }
float notacao_polonesa(char ex[]){ tp_pilha pilha; float calc, num1, num2, numAux; int i; char aux[1]; inicia_pilha(&pilha); for(i = 0; i < 9; i++){ aux[0] = ex[i]; if(isdigit(aux[0])){ numAux = strtof(aux,NULL); empilha(&pilha, numAux); //printf("\nEmpilhei: %.0f\n",numAux); } else{ desempilha(&pilha, &num2); desempilha(&pilha, &num1); switch(aux[0]){ case '+': calc = num1 + num2; //printf("\n%f + %f = &f",num1,num2,calc); break; case '-': calc = num1 - num2; //printf("\n%f - %f = &f",num1,num2,calc); break; case '*': calc = num1 * num2; //printf("\n%f * %f = &f",num1,num2,calc); break; case '/': calc = num1 / num2; //printf("\n%f / %f = &f",num1,num2,calc); break; } empilha(&pilha, calc); } // printf("\nPassei do Switch, calc = %f\n",calc); } desempilha(&pilha, &calc); return calc; }
//Nome: MatrizAdjacenciaBuscaProfund //Função: Realiza uma busca em profundidade em um grafo a partir de um nó, para descobrir se é conexo //Entrada: Ponteiro para a estrutura de um grafo, nó inicial //Saída: Retorna TRUE se o grafo é conexo e FALSE caso contrário int MatrizAdjacenciaBuscaProfund(GrafoAdj *grafo, int valor){ int marca = 1; int i, no; int compConex = FALSE; Pilha *p = cria(); visitados = (int*) malloc(sizeof(int) * grafo->vertices); for (i = 0; i < grafo->vertices; i++) visitados[i] = 0; visitados[valor-1] = marca; empilha(p, valor-1); //while (compConex == TRUE){ while (!vazia(p)){ no = desempilha(p); visitados[no] = marca; for (i = 0; i < grafo->vertices; i++){ if (grafo->matrizAdj[no][i] != 0){ if(visitados[i] == 0) empilha(p, i); } } } compConex = TRUE; //marca++; for (i = 0; i < grafo->vertices; i++){ if (visitados[i] == 0) { compConex = FALSE; break; } } //if (compConex == TRUE) empilha(p, i); //} free(visitados); destroi(p); return compConex; }
void resolve() { int topo, passos, x, y; item atual; item pilha[32]; topo = 0; passos = 0; x = 0; y = 0; atual.pos.x = 0; atual.pos.y = 0; atual = procura( atual, &x, &y ); while ( ganhou() ) { getchar(); printf("X = %d Y = %d Mov = %d x = %d y = %d P = %d \n", atual.pos.x, atual.pos.y, atual.mov, x, y, passos); desenha(); while ( atual.mov <= 4 ) { if ( podemov(atual) ) { printf("Empilhando - \n"); empilha( pilha, &topo, atual ); atualizatab( atual, &atual ); x = 0; y = 0; passos++; getchar(); printf("X = %d Y = %d Mov = %d x = %d y = %d P = %d \n", atual.pos.x, atual.pos.y, atual.mov, x, y, passos); desenha(); } else atual.mov++; } if ( atual.mov > 4 ) { if ( x >= 6 && y >= 4 ) { if ( topo == 0 ) { printf("Sem Solucao."); break; } else { printf("Backtrack - \n"); atual = topodapilha( pilha, topo ); desatualizatab( atual ); x = atual.pos.x; y = atual.pos.y; atual.mov++; desempilha( &topo ); passos--; } } } } imprimesol(pilha, topo); }
int main(void){ LD lista; int cont=0, aux; char chave[] = "ESTE EXERCICIO E MUITO FACIL ."; DefineS(&lista); while(chave[cont]!='.'){ empilha(&lista,chave[cont]); if(chave[cont]== ' ' || chave[cont]=='.'){ while(lista.quant>0) desempilha(&lista); } cont++; } return 0; }
void busca(int v) { int i, aux, min = low[v] = pre[v] = cont++; empilha(v); for (i = 0; i < nviz[v]; i++) { aux = grafo[v][i]; if (pre[aux] == -1) busca(aux); if (low[aux] < min) min = low[aux]; } if (min < low[v]) { low[v] = min; return; } do { id[i = desempilha()] = numcomp; low[i] = n; } while (i != v); numcomp++; }
int main(void){ char s[]="tudo puta e viado."; clock_t Ti, Tf; //scanf("%[^\n]",&s); printf("%s\n",s ); Ti=clock(); string_inverte(s); Tf=clock(); printf("%s\nem tempo: %f",s,(Tf-Ti) ); //usando pilha char t[]="tudo puta e viado."; lista pilha; int cont=0; char aux; printf("\npilha\n"); Ti=clock(); define(&pilha); while(t[cont]!='.'){ while(t[cont]!=' ' && t[cont]!='.'){ empilha(&pilha,t[cont]); cont++; } while(pilha.total>0){ aux=desempilha(&pilha); printf("%c",aux ); } printf(" "); if(t[cont]!='.'){ cont++; } } Tf=clock(); printf("\npilha com tempo: %f\n",(Tf-Ti) ); return 0; }
int main(){ PILHA *pilha; int escolha; int num; int flag; pilha = criaPilha();//pilha é topo for (;;){ escolha=menu(); switch (escolha){ case 1: printf ("Informe o número que deseja empilhar:\n"); scanf ("%d", &num); pilha=empilha(pilha, num); break; case 2: pilha=desempilha (pilha); break; case 3: tamanhoDaPilha(pilha); break; case 4: flag = mostraTopo(pilha); if (flag == -1){ printf ("A pilha está vazia\n"); } else{ printf ("Elemento do Topo: %d\n", pilha->elemento); } break; case 5: return 0;; } } return 0; }
int retira_impar(tp_pilha *p){ ///1) Implementar uma função que receba uma pilha como parâmetro /// e retire todos os elementos ímpares dessa pilha. (Use uma pilha auxiliar). tp_pilha pilhaAux; inicia_pilha(&pilhaAux); int e; int i; recorta_pilha(p,&pilhaAux); //printf("\n=============\nRecortei os elementos da Pilha Principal e Colei na Pilha Auxiliar\n=============\n"); for(i = pilhaAux.topo; i >= 0; i--){ //desempilha(&pilhaAux, &e); printf("\nO Valor [%d] foi Removido da Pilha Auxiliar!",e); if(e % 2 == 0){ empilha(p,e); //printf("\nO Valor [%d] foi Inserido na Pilha!",e); // verifica_topo(p,&e); printf("\nO Valor [%d] foi Inserido na Pilha Principal!\n",e); } } return 1; }
//algoritmo de movimentacao de disco void movediscos(int n, int torreI, int torreF) { //variaveis locais int torreAux = 3 - (torreI + torreF); int tam; //se existe apenas um disco a ser movido if(n == 1) { tam = desempilha(torreI); empilha(tam,torreF); apaga_disco(tam,torreI); desenha_disco(tam,torreF); delay(500); } else { movediscos(n-1,torreI, torreAux); movediscos(1, torreI, torreF); movediscos(n-1,torreAux,torreF); } }
int main() { Token *token; token = (Token*) malloc(sizeof(Token)); FILE *entrada; entrada = fopen("./ENTRADA.txt", "r"); //verificando se arquivo existe if(entrada == NULL) { printf("arquivo nao encontrado\n\n"); return 1; } StackInit(&pilhaEstado, MAX_SIZE); // Escreve o cabeçalho antes mesmo de entrar // em algum estado, já que não existe um "main" // em Kipple. inicializaSemantico(); imprimeCabecalho(); declaraVariaveis(); Submaquina ultimaSubmaquina; Estado estadoCorrente = CODE_INICIAL; Estado estadoAnterior = 0; token = getNextToken(entrada); while (token->tipo != EoF) { transicao trans; chamadaSubmaquina chamada; // Procura transição if(!procuraTransicao(estadoCorrente, token, &trans)) { // Se não encontrar transição procura chamada de submáquina if(!procuraChamadaSubmaquina(estadoCorrente, token, &chamada)) { // Caso não encontra chamada de submáquina, verifica se é estado final, // se for aceita, senão dá erro if(estadoFinal(estadoCorrente)) { ultimaSubmaquina = obterSubmaquina(estadoCorrente); estadoAnterior = estadoCorrente; estadoCorrente = desempilha(); executarAcaoSemantica(estadoAnterior, estadoCorrente, ultimaSubmaquina, token); } else { printf("Erro no reconhecimento de sintaxe, linha %d", token->linha); getchar(); exit(1); } } else { // Se acha chamada de submáquina ultimaSubmaquina = obterSubmaquina(estadoCorrente); estadoAnterior = estadoCorrente; estadoCorrente = chamada.estadoDestino; executarAcaoSemantica(estadoAnterior, estadoCorrente, ultimaSubmaquina, token); empilha(chamada.estadoRetorno); } } else { // Se encontrar transição estadoAnterior = estadoCorrente; estadoCorrente = trans.estadoDestino; executarAcaoSemantica(estadoAnterior, estadoCorrente, ultimaSubmaquina, token); token = getNextToken(entrada); } } // Dump das variáveis e constantes no fim do programa //declararVariaveisConstantes(); //escreveFuncoesMvn(); imprimeFim(); free(token); return 0; }
// funçao que checa se existe a transicao na matriz e realiza transicao caso tenha char busca_e_realiza_transicao_automato( automato *A , char token[TAMANHO_MAX_NOME_ELEMENTO] , Pilha *Pilha_submaquina, Pilha *Pilha_estado, char cadeia_parcial[TAMANHO_MAX_NOME_ELEMENTO]){ int i=0; int submaquina=0; char teve_transicao; char nome_submaquina_chamada[TAMANHO_MAX_NOME_ELEMENTO]; char nome_submaquina_retorno[TAMANHO_MAX_NOME_ELEMENTO]; char estado_retorno[TAMANHO_MAX_NOME_ELEMENTO]; for( i=0 ; i<(*A).numero_submaquinas ; i++ ){ // obtem o indice da submaquina if(strcmp((*A).submaquina_atual, (*A).nome_submaq[i] )==0) submaquina=i; } //checa se é estado de transicao para submaquina if(check_se_eh_transicao_para_submaquina( &(*A).sub_maquina[submaquina] , A, &nome_submaquina_chamada, &estado_retorno)=='T'){ //se teve transicao para submaquina empilha((*A).submaquina_atual, Pilha_submaquina); //empilha submaquina atual empilha(estado_retorno, Pilha_estado); //empilha estado de retorno for( i=0 ; i<(*A).numero_submaquinas ; i++ ){ // obtem o indice da nova submaquina if(strcmp(nome_submaquina_chamada, (*A).nome_submaq[i] )==0) submaquina=i; } strcpy((*A).estado_atual, (*A).sub_maquina[submaquina].estado_inicial ); // atualiza estado atual do automato com estado inicial da submaquina chamada strcpy((*A).submaquina_atual, nome_submaquina_chamada ); // atualiza submaquina atual no automato } printf("\n|\t%s\t|\t%s\t| (%s,%s)\t|\t", (*A).estado_atual , (*A).submaquina_atual, cadeia_parcial,token); teve_transicao = busca_e_realiza_transicao_lendo_vetor( &(*A).sub_maquina[submaquina] , (*A).estado_atual, token ); printf("%s\t", (*A).estado_atual ); if((*Pilha_submaquina).topo != -1){ printf("|\t%s\t", (*Pilha_submaquina).elementos->info); } if((*Pilha_estado).topo!=-1){ printf("|\t%s\t\t|", (*Pilha_estado).elementos->info); } if((*Pilha_submaquina).topo == -1){ printf("|\tvazio\t"); } if((*Pilha_estado).topo==-1){ printf("|\tvazio\t\t|"); } while(teve_transicao=='F'){ desempilha( &nome_submaquina_retorno , Pilha_submaquina ); // desempillha submaquina desempilha( &estado_retorno , Pilha_estado ); //desempilha estado de retorno for( i=0 ; i<(*A).numero_submaquinas ; i++ ){ // obtem o indice da nova submaquina if(strcmp(nome_submaquina_retorno, (*A).nome_submaq[i] )==0) submaquina=i; } strcpy((*A).estado_atual, estado_retorno ); // atualiza estado atual do automato com estado inicial da submaquina de retorno strcpy((*A).submaquina_atual, nome_submaquina_retorno ); // atualiza submaquina atual no automato printf("\n|\t%s\t|\t%s\t| (%s,%s)\t|\t", (*A).estado_atual , (*A).submaquina_atual, cadeia_parcial,token); teve_transicao = busca_e_realiza_transicao_lendo_vetor( &(*A).sub_maquina[submaquina] , (*A).estado_atual, token ); printf("%s\t", (*A).estado_atual ); if((*Pilha_submaquina).topo != -1){ printf("|\t%s\t", (*Pilha_submaquina).elementos->info); } if((*Pilha_estado).topo!=-1){ printf("|\t%s\t\t|", (*Pilha_estado).elementos->info); } if((*Pilha_submaquina).topo == -1){ printf("|\tvazio\t"); } if((*Pilha_estado).topo==-1){ printf("|\tvazio\t\t|"); } } }
int main() { Token *token; token = (Token*) malloc(sizeof(Token)); // Inicializando lista de tokens e escopos tokens.tamanho = 0; escopos.tamanho = 0; constTab.tamanho = 0; // Inicializando pilhas de ifs, whiles e expressoes StackInit(&pilhaIfs, MAX_SIZE); StackInit(&pilhaWhiles, MAX_SIZE); StackInit(&pilhaElses, MAX_SIZE); StackTokenInit(&pilhaOperandos, MAX_SIZE); StackTokenInit(&pilhaOperadores, MAX_SIZE); FILE *entrada; entrada = fopen("ENTRADA.txt", "r"); //verificando se arquivo existe if(entrada == NULL) { printf("arquivo nao encontrado\n\n"); return 1; } // Abre o arquivo de saída out = fopen("SAIDA.txt", "wr"); InicializaLexico(); //Lendo o Arquivo pegando todos os Tokens até terminar o arquivo o ch deve iniciar com NULL StackInit(&pilha, MAX_SIZE); Estado estadoCorrente = PROGRAM_INICIAL; Estado estadoAnterior = 0; token = getNextToken(entrada); while (token->tipo != EoF && estadoCorrente != PROGRAM_6_AC) { transicao trans; chamadaSubmaquina chamada; // Procura transição if(!procuraTransicao(estadoCorrente, token, &trans)) { // Se não encontrar transição procura chamada de submáquina if(!procuraChamadaSubmaquina(estadoCorrente, token, &chamada)) { // Caso não encontra chamada de submáquina, verifica se é estado final, // se for aceita, senão dá erro if(estadoFinal(estadoCorrente)) { estadoAnterior = estadoCorrente; estadoCorrente = desempilha(); executarAcaoSemantica(estadoAnterior, estadoCorrente, token); } else { printf("Erro no reconhecimento de sintaxe, linha %d", token->linha); getchar(); exit(1); } } else { // Se acha chamada de submáquina estadoAnterior = estadoCorrente; estadoCorrente = chamada.estadoDestino; executarAcaoSemantica(estadoAnterior, estadoCorrente, token); empilha(chamada.estadoRetorno); } } else { // Se encontrar transição estadoAnterior = estadoCorrente; estadoCorrente = trans.estadoDestino; executarAcaoSemantica(estadoAnterior, estadoCorrente, token); token = getNextToken(entrada); } } // Dump das variáveis e constantes no fim do programa escreveFuncoesMvn(); declararVariaveisConstantes(); imprimeFim(); free(token); return 0; }
//metodo que carrega o arquivo de avaliacoes void carregar_requisicoes(){ FILE *arq1; arq1 = fopen("requisicoes.txt","r"); char separador; if(arq1==NULL){ printf("Erro ao abrir o arquivo de requisicoes\n\n"); }else{ if(condicao_requisicao==0){ while(!feof(arq1)){ int cartao; int codigo,posicao; float valor; struct NodoPilha *aux2 = malloc(sizeof(struct NodoPilha)); fscanf(arq1,"%d\n",&codigo); fscanf(arq1,"%d\n",&cartao); fscanf(arq1,"%f\n",&valor); fscanf(arq1,"%c\n",&separador); posicao=posicaoNoHash(cartao);//posicao da tabelahash que possui esse cartao if(hashTable[posicao]!=NULL){//a avaliacao apenas ocorre se a posicao na tabelahash for diferente de null if(hashTable[posicao]->requisicao.cartao==cartao){ //se o valor da compra for menor ou igual ao saldo do cartao o resultado da avaliacao eh aceito //e o saldo do cartao eh atualizado senao eh negado if(valor<=hashTable[posicao]->requisicao.saldo){ printf("Requisicao numero: %d do cartao %d foi aceita\n",codigo,cartao); aux2->avaliacao.resultado='A'; hashTable[posicao]->requisicao.saldo -=valor; }else{ printf("Requisicao numero: %d do cartao %d foi negada\n",codigo,cartao); aux2->avaliacao.resultado='N'; } aux2->avaliacao.codigo=cod;//codigo da operacao empilha(aux2);//empilha o nodo da avaliacao free(aux2);//libera memoria alocada cod++; } } condicao_requisicao++; } }else{ printf("Requisicoes ja avaliadas\n"); } } fclose(arq1); printf("\n\n"); printf("Arquivo de requisicoes carregado com sucesso\n"); printf("Aperte uma tecla para continuar:"); getch(); limpa(); }