Calculadora RPN - Implementação Ligada de Pilhas (Listas ligadas)

Olá, estou com um problema para implementar as funções pop, push e empty. O código contém mais erros, pois estou adaptando o código de uma calculadora RPN com implementação de pilhas. Gostaria de ajuda com essa parte e/ou com o código por inteiro. //-------------------------------------------------------------------------// // Arquivos de cabeçalho // //-------------------------------------------------------------------------// #include <stdio.h> #include <math.h> #include <stdlib.h> //-------------------------------------------------------------------------// // Constantes e variáveis globais // //-------------------------------------------------------------------------// #define NUMNODE 5 //dimensão da lista struct nodetype{

 float info. int next. }. struct nodetype node[NUMNODE]. 

int avail. // endereço para início da lista livre int s. // endereço para o top da pilha //-------------------------------------------------------------------------// // Função getnode // //-------------------------------------------------------------------------// //Remove o primeiro nó da lista livre e retorna um ponteiro para ele // int fc_getnode(){ if (avail == -1) { // Teste de estouro da lista livre

 printf("Estouro \n"). exit(1). } int p. 

avail = node[avail].next. //Ponteiro para o nó p = avail. // Atualiza lista livre return(p). // Retorna ponteiro } //-------------------------------------------------------------------------// // Função Freenode // //-------------------------------------------------------------------------// //Aceita um ponteiro para um nó e o retorna para a lista livre // int fc_freenode(int p){ node[p].next = avail. // Faz p apontar para a lista livre avail = p. // Faz avail apontar para 'p'

 return(0). }

//-------------------------------------------------------------------------// // Função push // //-------------------------------------------------------------------------// //Adiciona um dado ao topo da pilha int fc_push (int p){ p=fc_getnode(). // Cria novo nó info(p)=x. // Salva o dado x no nó next(p)=s. // Conecta ao próximo nó s = p. // Informa novo endereço de início } /int fc_push (pnt_s,x)

 struct stack *pnt_s. float x. 

{

 int wait. if (pnt_s -> top == STACKSIZE-1){ //Testa overflow printf(">> Erro: estouro de pilha."). scanf("%d", &wait). //Aguarda leitura exit(1). // Encerra o programa } else { pnt_s -> items [++(pnt_s -> top)] = x. }

} / //-------------------------------------------------------------------------// // Função empty // //-------------------------------------------------------------------------// //Verifica se a pilha está vazia

 if (p == null){ printf(A pilha está vazia). } else{ printf(A pilha contém dados). }

/int fc_empty(pnt_s) struct stack pnt_s. {

 if (pnt_s -> top == -1) return (1). //A pilha está vazia else return (0). //A pilha contém dados

} / //-------------------------------------------------------------------------// // Função pop // //-------------------------------------------------------------------------// //Retira um dado do topo da pilha int fc_pop(pnt_s) struct stack pnt_s. {

 int wait. if (fc_empty(pnt_s)){ //Teste de underflow printf(">> Erro: A pilha esta vazia."). scanf("%d", &wait). //Aguarda leitura exit(1). //Encerra programa } else { return( pnt_s -> items [(pnt_s -> top)--]). //Desempilhar } }

//-------------------------------------------------------------------------// // Função principal // //-------------------------------------------------------------------------// int main () { avail = 0. // Ponteiro externo para a lista-livre (primeiro elemento do vetor node) for (i = 0. i < NUMNODE-1. i++) { // Organização dos endereços em ordem crescente node.next = i + 1. node[NUMNODE-1].next = -1. // Definição do final da lista livre (null)     //---------------------------------// // Declaração das variáveis // //---------------------------------//   struct stack s. //Declaração pilha "s"   float x,x1,x2,y. // Variaveis numéricas (X = entrada de dados, y = resultados) char c.   int flag_float.   s.top = -1. //Inicializando pilha vazia         //---------------------------------// // Interface com o usuário // //---------------------------------//   printf("------------------\n"). printf(" CALCULADORA RPN \n"). printf("------------------\n"). printf("\n").       while (c!= 'q'){ printf(">> "). scanf(" %c",&c). //---------------------------------// // Identifica operação // //---------------------------------//     //Testa se o operador é valido if (c=='+' || c=='-' || c=='' || c=='/') {   x1 = fc_pop(&s). x2 = fc_pop(&s).     switch©{ //Executa a operação case '+': y = x2+x1. break. //Adição case '-': y = x2-x1. break. // Subtração case '': y = x2x1. break. //Produto case '/': y = x2/x1. break. // Divisão   } fc_push(&s,y). //Empilha resultado printf(">> %0.3f\n",y). //Exibe Resultado     }   //---------------------------------// // Identifica o dado // //---------------------------------//   else {   ungetc(c, stdin). //Devolve dado ao prompt   flag_float=scanf("%f", &x). //Lê dado e retorna estado da função "scanf"   if (flag_float = 1){ fc_push(&s,x). } else { printf(">> Dado invalido.\n"). scanf("%c", &c). //Lê novamente o dado }   }   }   printf(">> "). scanf("%c",&c). //-------------------------------------------------------------------------// }*