int confereTipo(PilhaT *pilha, OperacaoT op, TipoT tipo_esperado) {
TipoT tipo_esquerda, tipo_direita;
int i;
if (pilha == NULL ) {
trataErro(ERRO_PILHA_N_EXISTE, "");
}
else {
tipo_direita= *(TipoT *)desempilha(pilha);
tipo_esquerda= *(TipoT *)desempilha(pilha);
switch (op) {
case OP_CALCULO:
empilhaTipoT(pilha, tipo_direita);
break;
case OP_COMPARACAO:
empilhaTipoT(pilha, T_BOOLEAN);
break;
case OP_ATRIBUICAO:
empilhaTipoT(pilha, tipo_esquerda);
break;
}
debug_print("[TipoT Tests] tipo_esquerda= %d - tipo_direita= %d\n", tipo_esquerda, tipo_direita);
if (tipo_esquerda == tipo_direita)
return 1;
else
trataErro(ERRO_TIPO, "");
return 0;
}
return 0;
}
//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(){
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");
}
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 consumidor(Shared *shm) {
int j, n;
while(1) {
/* Se o produtor nao vai mais produzir, o proprio consumidor tem que liberar o seu semaforo */
if(shm->termina) {
sem_post(&shm->c_sem);
/* Se a pilha ficar vazia e o produtor nao vai mais produzir, terminou a tarefa */
if(pilhaVazia(&shm->pilha)) break;
}
/* Aguarda ate semaforo ficar verde */
sem_wait(&shm->c_sem);
/* Cada consumidor vai consumir entre 0 e 9 vezes por ciclo */
n = randomNumber(0, 9);
printf("[PID: %d] Consumir: %d vezes\n", getpid(), n);
/* Consome N vezes por ciclo */
for(j = 0; j < n; j++) {
if(!pilhaVazia(&shm->pilha)) {
printf("[PID: %d] Consumindo: %d\n", getpid(), topoPilha(&shm->pilha));
desempilha(&shm->pilha);
} else {
printf("[PID: %d] Pilha esvaziou! Lote teve %d unidades\n", getpid(), j);
break;
}
}
/* Libera produtor */
sem_post(&shm->p_sem);
}
}
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;
}
void eD() {
char simbolo = palavra[posicaoPalavra];
if (!ehFinalPalavra(simbolo)) {
if (ehOperador(simbolo)) {
posicaoPalavra++;
eA();
} else {
if (!pilhaEstaVazia(pilha_estados)) {
ptr_estado estado_desempilhado = desempilha(pilha_estados, &posicao_pilha);
estado_desempilhado();
} else {
if (verificaAceitacao(pilha_estados, simbolo)) {
printf("\nACEITO!\n");
} else {
printf("\nNÃO ACEITO!\n");
}
}
}
} else {
if (verificaAceitacao(pilha_estados, simbolo)) {
printf("\nACEITO!\n");
} else {
printf("\nNÃO ACEITO!\n");
}
}
}
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 );
}
}
}
Pilha* desempilha(Pilha* p, Pilha* o)
{
char t;
Pop(o,&t);
if(t == '('){
return p;
}else{
Push(p,t);
return (desempilha(p,o));
}
}
int ver_pilha(tp_pilha p){
tp_item e;
int i;
for(i = p.topo; i >= 0; i--){
desempilha(&p,&e);
printf("---\n");
printf("|%d|\n",e);
}
printf("--- \n");
return 1;
}
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;
}
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 pilhas_iguais(tp_pilha p1,tp_pilha p2){
///2) Implementar uma função que receba duas pilhas como parâmetro
/// e retorna 1 caso sejam idênticas ou zero caso contrário.
tp_item e1, e2;
int i;
if(p1.topo != p2.topo){
printf("\n\t\t\tTAMANHO DAS PILHAS DIFERENTES!");
return 0;
}
for(i = p1.topo; i >= 0; i--){
//while(!(pilha_vazia(&p1))){
desempilha(&p1, &e1);
desempilha(&p2, &e2);
//printf("\nO Valor [%d] foi Removido da Pilha Auxiliar!",e);
if(e1 != e2){
return 0;
}
}
return 1;
}
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;
}
/**
* Função responsável por implementar o algoritmo de backtracking propriamente dito
* de maneira iterativa para varrer o espaço de estados. Se encontrar uma
* resposta válida retorna um vetor com maxMov posições contendo os passos a serem
* seguidos, senão retorna NULL.
*/
movimento* buscaSolucao(jogo oJogo, estado *inicial){
estado *atual = inicial;
do {
if(!empilhaCandidatos(oJogo, atual)) {
if(matrizesIguais(oJogo.obj, atual->tabuleiro, oJogo.l, oJogo.c))
return atual->passos;
if(pilhaVazia(oJogo.candidatos))
return NULL;
}
desalocaEstado(atual, oJogo.l);
atual = desempilha(oJogo.candidatos);
} while(TRUE);
}
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(){
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;
}
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;
}
int main(){
Pilha *posfixa = criaPilha();
Pilha *operadores = criaPilha();
Pilha *infixa = criaPilha();
char inf[MAX],letra,t;
int testes,n,i,j,f=0;
scanf("%d",&testes);
while(testes > 0){
testes--;
scanf("%s",&inf);
n = strlen(inf);
for(i = n-1;i>=0;i--){
Push(infixa,inf[i]);
}
while(!isEmpty(infixa))
{
Pop(infixa,&letra);
if(letra != '+' && letra != '-' && letra != '*' && letra != '/' && letra != '^' && letra != '(' && letra != ')'){
Push(posfixa,letra);
}else if(letra == '('){
Push(operadores,letra);
}else if(letra == ')'){
desempilha(posfixa,operadores);
}else{
while(precedencia(Topo(operadores)) > precedencia(letra) || precedencia(Topo(operadores)) == precedencia(letra)){
Pop(operadores,&t);
Push(posfixa,t);
}
Push(operadores,letra);
}
}
if(!isEmpty(operadores))
{
desempilha_op(posfixa,operadores);
}
exibe(posfixa);
Empty(posfixa);
Empty(operadores);
};
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 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;
}
//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);
}
}
//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;
}
/**
* Função responsável por desalocar todas estruturas de dados remanecentes do
* cálculo da resposta ao jogo dado.
*/
void encerraJogo(jogo oJogo){
while(!pilhaVazia(oJogo.candidatos))
desalocaEstado(desempilha(oJogo.candidatos), oJogo.l);
desalocaMatriz(oJogo.obj, oJogo.l);
free(oJogo.candidatos);
}
/*!
\sa PilhaEnc(), ~PilhaEnc(), PilhaVazia()
*/
void limparPilha() {
while (!PilhaVazia()) {
desempilha();
}
}
// 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));
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;
}