//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();
}
