From 003a0edc53d4746331688f35005ee07ba4c758e8 Mon Sep 17 00:00:00 2001
From: "Pedro F. Pesserl" <fpesserl7@gmail.com>
Date: Thu, 8 Dec 2022 17:26:49 -0300
Subject: [PATCH] add calculadora with working stack lib
---
calculadora/calc | Bin 0 -> 22672 bytes
calculadora/calculadora.c | 243 ++++++++++++++++++++++++++++++++++++++
calculadora/libpilha.c | 49 ++++++++
calculadora/libpilha.h | 31 +++++
calculadora/makefile | 14 +++
5 files changed, 337 insertions(+)
create mode 100755 calculadora/calc
create mode 100644 calculadora/calculadora.c
create mode 100644 calculadora/libpilha.c
create mode 100644 calculadora/libpilha.h
create mode 100644 calculadora/makefile
diff --git a/calculadora/calc b/calculadora/calc
new file mode 100755
index 0000000000000000000000000000000000000000..8d7a4dac79d6762c834c6c3a97b70f9067d60434
GIT binary patch
literal 22672
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
literal 0
HcmV?d00001
diff --git a/calculadora/calculadora.c b/calculadora/calculadora.c
new file mode 100644
index 0000000..02b4363
--- /dev/null
+++ b/calculadora/calculadora.c
@@ -0,0 +1,243 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include "libpilha.h"
+
+typedef double t_operador;
+
+#define TAM_ENTRADA 256
+#define TAM_PILHA 1024
+
+
+/* Constantes com valores para identificar os operadores. O valor
+ antes do ponto flutuante difine a precedencia entre os operadores,
+ valores maiores tem maior precedencia. */
+#define SOM 10.1
+#define SUB 10.2
+#define MUL 20.1
+#define DIV 20.2
+
+
+/* Identificador de '(' para ser empilhado na pilha de operadores */
+#define PAR 99.0
+
+
+/* Converte os caracteres que representam os operadores na entrada
+ para valores constantes que identificam os operadores.
+ Retorna 1 se o caracter c representa um operador valido e 0 caso
+ contrario. */
+int converte_operador(t_operador *op, char c) {
+ switch(c) {
+ case '+': *op = SOM; break;
+ case '-': *op = SUB; break;
+ case '*': *op = MUL; break;
+ case '/': *op = DIV; break;
+ default : return 0;
+ }
+ return 1;
+}
+
+
+/* Retorna 1 se o operador op1 tem precedencia sobre o operador op2.
+ Retorna 0 caso contrario. */
+int precede(t_operador op1, t_operador op2) {
+ if((op1 - op2) >= 1.0)
+ return 1;
+ return 0;
+}
+
+
+/* Desempilha os dois valores no topo da pilha de valores, aplica o
+ operador sobre esses valores e empilha o resultado na pilha de
+ valores. */
+int opera(t_operador op, t_pilha *valores) {
+ double val_esq, val_dir;
+
+ if(!desempilha(&val_dir, valores))
+ return 0;
+ if(!desempilha(&val_esq, valores))
+ return 0;
+ if(op == SOM)
+ return empilha(val_esq + val_dir, valores);
+ if(op == SUB)
+ return empilha(val_esq - val_dir, valores);
+ if(op == MUL)
+ return empilha(val_esq * val_dir, valores);
+ if(op == DIV && val_dir != 0.0)
+ return empilha(val_esq / val_dir, valores);
+ return 0;
+}
+
+
+/* Imprime na saida de erro (stderr) a mensagem de erro e a linha e
+ a coluna da entrada onde o erro foi detectado. */
+void erro_aborta(char *msg, int col) {
+ fprintf(stderr, "ERRO: %s (coluna %d)\n", msg, col);
+ exit(1);
+}
+
+
+/* Le da entrada padrao, usando fgets, um vetor de caracteres ate o \n.
+ Se o tamanho da entrada for maior que o vetor de leitura, aumenta
+ o tamanho do vetor e continua a leitura ate encontrar o \n.
+ Retorna um ponteiro para o vetor lido ou NULL caso ocorra algum erro
+ ne leitura ou ne alocação de memoria. */
+/*
+char* le_entrada() {
+ char *ent, *ret_realloc, *ret_fgets;
+ int tam, pos;
+
+ ent = NULL;
+ tam = 0;
+ pos = 0;
+
+ do {
+ tam += TAM_ENTRADA;
+ ret_realloc = (char*) realloc(ent, sizeof(char) * tam);
+ if(!ret_realloc) {
+ free(ent);
+ return NULL;
+ }
+ ent = ret_realloc;
+ ent[tam - 1] = ' ';
+ ret_fgets = fgets(ent + pos, tam - pos, stdin);
+ pos = tam - 1;
+ } while(ret_fgets && ent[tam - 1] == '\0' && ent[tam - 2] != '\n');
+
+ if(!ret_fgets && tam == TAM_ENTRADA) {
+ free(ent);
+ return NULL;
+ }
+
+ return ent;
+}
+*/
+
+
+/* Le da entrada padrao, usando fgets, um vetor de caracteres ate o \n.
+ Retorna um ponteiro para o vetor lido ou NULL caso ocorra algum erro
+ ne leitura ou na alocação de memoria. Se o tamanho da entrada for
+ maior que o vetor de leitura, retorna NULL. */
+char* le_entrada() {
+ char *ent, *ret_fgets;
+ int tam;
+
+ tam = TAM_ENTRADA;
+ ent = (char*) malloc(sizeof(char) * tam);
+ if(!ent)
+ return NULL;
+ ent[tam - 1] = ' ';
+ ret_fgets = fgets(ent, tam, stdin);
+ if(!ret_fgets || (ent[tam - 1] == '\0' && ent[tam - 2] != '\n')) {
+ free(ent);
+ return NULL;
+ }
+ return ent;
+}
+
+
+int main() {
+ t_pilha *pilha_valores, *pilha_operadores;
+ t_operador operador, op_topo;
+ double operando, resultado;
+ char *entrada, *c, *prox;
+
+ pilha_valores = cria_pilha(TAM_PILHA);
+ if(!pilha_valores)
+ erro_aborta("erro ao criar pilha de valores", 0);
+
+ pilha_operadores = cria_pilha(TAM_PILHA);
+ if(!pilha_operadores)
+ erro_aborta("erro ao criar pilha de operadores", 0);
+
+ entrada = le_entrada();
+ if(!entrada)
+ erro_aborta("erro de leitura", 0);
+
+ c = entrada;
+ while(*c != '\n') {
+ /* Percorre o ponteiro c pela entrada ate o final de linha. */
+
+ /* Caso 1: separadores */
+ if(*c == ' ' || *c == '\t')
+ /* Se for sepador, passa para o proximo caracter. */
+ c++;
+
+ /* Caso 2: operando */
+ else if(isdigit(*c)) {
+ /* Se for [1..9] le um valor e empilha na pilha de valores. */
+ operando = strtod(c, &prox);
+ if(c == prox)
+ erro_aborta("operando incorreto", c - entrada + 1);
+ if(!empilha(operando, pilha_valores))
+ erro_aborta("pilha de valores cheia", c - entrada + 1);
+ c = prox;
+ }
+
+ /* Caso 3: abre parenteses */
+ else if(*c == '(') {
+ /* Se for abre parenteses, empilha PAR na pilha de operadores. */
+ if(!empilha(PAR, pilha_operadores))
+ erro_aborta("pilha de operadores cheia", c - entrada + 1);
+ c++;
+ }
+
+ /* Caso 4: fecha parenteses */
+ else if(*c == ')') {
+ /* Se for fecha parenteses, processa a pilha de operadores até
+ encontar um PAR. */
+ while(topo(&op_topo, pilha_operadores) && op_topo != PAR) {
+ desempilha(&op_topo, pilha_operadores);
+ if(!opera(op_topo, pilha_valores))
+ erro_aborta("formato incorreto", c - entrada + 1);
+ }
+ if(pilha_vazia(pilha_operadores) ||
+ (desempilha(&op_topo, pilha_operadores) && op_topo != PAR))
+ erro_aborta("formato incorreto", c - entrada + 1);
+ c++;
+ }
+
+ /* Caso 5: operador */
+ else if(converte_operador(&operador, *c)) {
+ /* Se for um operador valido, verifica a precedencia em relacao
+ ao topo da pilha de operadores. */
+ while(topo(&op_topo, pilha_operadores) &&
+ op_topo != PAR &&
+ precede(op_topo, operador)) {
+ /* Enquando o topo da pilha tiver precedencia, desempilha e
+ processa o operador do topo da pilha. */
+ desempilha(&op_topo, pilha_operadores);
+ if(!opera(op_topo, pilha_valores))
+ erro_aborta("formato incorreto", c - entrada + 1);
+ }
+ if(!empilha(operador, pilha_operadores))
+ /* Empilha o novo operador na pilha de operadores. */
+ erro_aborta("pilha de operadores cheia", c - entrada + 1);
+ c++;
+ }
+
+ /* Caso 6: caracter invalido na entrada */
+ else
+ erro_aborta("caracter desconhecido", c - entrada + 1);
+ }
+
+ /* Nesse ponto o processamento da entrada terminou e pode ser o caso da
+ pilha de operadores nao estar vazia. */
+ while(desempilha(&op_topo, pilha_operadores)) {
+ /* Processa os operadores que restaram na pilha. */
+ if(!opera(op_topo, pilha_valores))
+ erro_aborta("formato incorreto", c - entrada + 1);
+ }
+
+ /* Após o processamento, o resultado final da expressao esta no topo da
+ pilha de valores. */
+ if(!desempilha(&resultado, pilha_valores))
+ erro_aborta("formato incorreto", c - entrada + 1);
+ printf("%.16g\n", resultado);
+
+ destroi_pilha(pilha_valores);
+ destroi_pilha(pilha_operadores);
+ free(entrada);
+
+ return 0;
+}
diff --git a/calculadora/libpilha.c b/calculadora/libpilha.c
new file mode 100644
index 0000000..9a43842
--- /dev/null
+++ b/calculadora/libpilha.c
@@ -0,0 +1,49 @@
+#include <stdlib.h>
+#include "libpilha.h"
+
+t_pilha* cria_pilha(int n) {
+ t_pilha *p;
+ if ( !(p = malloc(sizeof(t_pilha) * n)) )
+ return NULL;
+
+ p->tam = n;
+ p->topo = -1;
+
+ if ( !(p->v = malloc(sizeof(double) * n)) )
+ return NULL;
+ return p;
+}
+
+t_pilha* destroi_pilha(t_pilha *p) {
+ free(p->v);
+ free(p);
+ return NULL;
+}
+
+int pilha_vazia(t_pilha *p) {
+ return p->topo == -1;
+}
+
+int empilha(double x, t_pilha *p) {
+ if (p->topo == p->tam)
+ return 0;
+ p->topo++;
+ p->v[p->topo] = x;
+
+ return 1;
+}
+
+int desempilha(double *t, t_pilha *p) {
+ if (pilha_vazia(p))
+ return 0;
+ *t = p->v[p->topo];
+ p->topo--;
+ return 1;
+}
+
+int topo(double *t, t_pilha *p) {
+ if (pilha_vazia(p))
+ return 0;
+ *t = p->v[p->topo];
+ return 1;
+}
diff --git a/calculadora/libpilha.h b/calculadora/libpilha.h
new file mode 100644
index 0000000..3eddf49
--- /dev/null
+++ b/calculadora/libpilha.h
@@ -0,0 +1,31 @@
+struct s_pilha {
+ int tam;
+ int topo;
+ double *v;
+};
+typedef struct s_pilha t_pilha;
+
+
+/* Cria uma pilha com espaço para n elementos do tipo double.
+ Retorna um ponteiro para a pilha ou NULL em caso de erro na
+ alocacao de memoria. */
+t_pilha* cria_pilha(int n);
+
+/* Desaloca a memoria usada pela pilha e retorna NULL */
+t_pilha* destroi_pilha(t_pilha *p);
+
+/* Retorna 1 se a pilha p esta vazia e 0 caso contrario. */
+int pilha_vazia(t_pilha *p);
+
+/* Empilha o double x na pilha p. Retorna 1 se a operacao foi
+ realizada com sucesso e 0 caso contrario. */
+int empilha(double x, t_pilha *p);
+
+/* Retorna em t o elemento do topo da pilha e o desempilha. A funcao
+ retorna 1 se a operacao foi bem sucedida e 0 caso contrario. */
+int desempilha(double *t, t_pilha *p);
+
+/* Retorna em t o elemento do topo da pilha, sem desempilhar.
+ A funcao retorna 1 se a operacao foi bem sucedida e 0 caso
+ contrario. */
+int topo(double *t, t_pilha *p);
diff --git a/calculadora/makefile b/calculadora/makefile
new file mode 100644
index 0000000..0031aa3
--- /dev/null
+++ b/calculadora/makefile
@@ -0,0 +1,14 @@
+CC = gcc
+CFLAGS = -Wall -g -std=c90
+
+calc: calculadora.o libpilha.o
+ $(CC) calculadora.o libpilha.o -o calc
+
+calculadora.o : libpilha.h calculadora.c
+ $(CC) $(CFLAGS) -c calculadora.c
+
+libpilha.o : libpilha.h libpilha.c
+ $(CC) $(CFLAGS) -c libpilha.c
+
+clean :
+ rm -f *.o
--
GitLab