Se hace una prueba del parser_equation() y se corrigen varios bugs.

También se agregan algunas funciones de impresión.

diff --git a/Makefile b/Makefile
index afa2713649f0c88e50d73923ced0f25803c3a7f5..98e04837af99fe72a2ec6996cada46361de83e49 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -18,7 +18,7 @@ CFLAGS=-ansi -pedantic -Wall -g3 -DDEBUG
 CC=gcc-3.2
 
 # Pruebas.
-TESTS=dllist_test memdebug_test
+TESTS=dllist_test memdebug_test parser_equation_test
 # Programa a compilar.
 TARGETS=$(TESTS)
 
@@ -34,6 +34,8 @@ dllist_test: dllist.o
 
 memdebug_test: dllist.o meminfo.o memdebug.o
 
+parser_equation_test: dllist.o parseerror.o equation.o parser_equation.o
+
 tp1: $(TARGETS)
 
 # Regla para borrar.

diff --git a/equation.c b/equation.c
index 3b0e36e4e70b4ff87526a2f0d5e86f4865007458..0565244f7d0e31bcad7dbea73167da3b8227bf3b 100644 (file)
--- a/equation.c
+++ b/equation.c
@@ -65,3 +65,7 @@ void Equation_delete(Equation* eq) {
     free(eq);
 }
 
+size_t Equation_print(Equation* eq, FILE* fp) {
+    return fprintf(fp, "%s = %s\n", eq->variable, eq->expression);
+}
+

diff --git a/equation.h b/equation.h
index 8b5f8f523ed1182699342c94460175aecb99b1b3..e74252463c65fa109cf7f645d09439b3d546f2eb 100644 (file)
--- a/equation.h
+++ b/equation.h
@@ -17,8 +17,8 @@
 #ifndef EQUATION_H
 #define EQUATION_H
 
-/*#include "bool.h"*/
 #include <stdlib.h>
+#include <stdio.h>
 
 typedef struct {
     char* variable;
@@ -30,4 +30,6 @@ Equation* Equation_new(const char* line, size_t var_start, size_t var_len,
 
 void Equation_delete(Equation* eq);
 
+size_t Equation_print(Equation* eq, FILE* fp);
+
 #endif /* EQUATION_H */

diff --git a/parseerror.c b/parseerror.c
index 398143a87bf3465502b4fee82656036b56cbc3d7..71f00f413b0c1eea0b5eb644785023398f38704a 100644 (file)
--- a/parseerror.c
+++ b/parseerror.c
@@ -51,6 +51,8 @@ bool ParseError_set_message(ParseError* pe, const char* msg) {
 
 bool ParseError_set_pos_message(ParseError* pe, const char* msg, size_t pos,
         char wrong_char) {
+    /* Pongo la posición */
+    pe->pos = pos;
     /* Si había otro mensaje, liberamos la memoria */
     if (pe->message) {
         free(pe->message);
@@ -69,8 +71,32 @@ bool ParseError_set_pos_message(ParseError* pe, const char* msg, size_t pos,
     if (pe->message) {
         /* Copio el nuevo mensaje. */
         sprintf(pe->message, "Se buscaba %s pero se encontró '%c' (0x%02X)",
-                msg, wrong_char, pos);
+                msg, wrong_char, wrong_char);
     }
     return pe->message ? TRUE : FALSE;
 }
 
+size_t ParseError_print(ParseError* pe, FILE* fp) {
+    /* No es un error de interpretación específico. */
+    if (!pe->pos) {
+        /* Si hay mensaje. */
+        if (pe->message) {
+            return fprintf(fp, "Error: %s.\n", pe->message);
+        /* Si no hay mensaje. */
+        } else {
+            return fprintf(fp, "Error no especificado.\n");
+        }
+    /* Es un error de interpretación en una posición específica. */
+    } else {
+        /* Si hay mensaje. */
+        if (pe->message) {
+            return fprintf(fp, "Error en la línea %u, posición %u: %s.\n",
+                    pe->line, pe->pos, pe->message);
+        /* Si no hay mensaje. */
+        } else {
+            return fprintf(fp,
+                    "Error en la línea %u, posición %u no especificado.\n",
+                    pe->line, pe->pos);
+        }
+    }
+}

diff --git a/parseerror.h b/parseerror.h
index 9678584ae769da2851e26e6c5b57622fa39984d1..63f3d8cc506aef98fd13a31c9acffc42908a03b1 100644 (file)
--- a/parseerror.h
+++ b/parseerror.h
@@ -19,6 +19,7 @@
 
 #include "bool.h"
 #include <stdlib.h>
+#include <stdio.h>
 
 typedef struct {
     size_t  line;
@@ -41,4 +42,6 @@ bool ParseError_set_message(ParseError* pe, const char* msg);
 bool ParseError_set_pos_message(ParseError* pe, const char* msg, size_t pos,
         char wrong_char);
 
+size_t ParseError_print(ParseError* pe, FILE* fp);
+
 #endif /* PARSEERROR_H */

diff --git a/parser_equation.c b/parser_equation.c
index 479c9e7f0ec0cf5caf30e1a1ec28173f07db893d..a84925ee90b7eacd53b9419a48439423e35c4803 100644 (file)
--- a/parser_equation.c
+++ b/parser_equation.c
@@ -27,18 +27,27 @@ bool is_space(char c) {
 }
 
 bool is_number(char c) {
-    return ('0' < c) && (c < '9');
+    return ('0' <= c) && (c <= '9');
 }
 
 bool is_alpha(char c) {
-    return (c == '_') || (('a' < c) && (c < 'z')) || (('A' < c) && (c < 'Z'));
+    return (c == '_') || (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z'));
 }
 
 bool is_alpha_num(c) {
     return is_number(c) || is_alpha(c);
 }
 
-#define PARSE_ERROR(str) ParseError_set_pos_message(error, str, i, c)
+size_t DLList_equation_print(DLList* l, FILE* fp) {
+    size_t cant = 0;
+    Equation* eq;
+    for (eq = DLList_begin(l); DLList_have_more(l); eq = DLList_next(l)) {
+        cant += Equation_print(eq, fp);
+    }
+    return cant;
+}
+
+#define PARSE_ERROR(str) ParseError_set_pos_message(error, str, i + 1, c)
 
 bool parser_equation(const char* line, size_t len, DLList* equation_list,
         ParseError* error) {
@@ -49,6 +58,7 @@ bool parser_equation(const char* line, size_t len, DLList* equation_list,
     char c;
     Equation* eq;
     for (i = 0; i < len; i++) {
+        c = line[i];
         switch (state) {
             case SEARCH_VAR: /* Busca el comienzo de una variable. */
                 if (!is_space(c)) {
@@ -73,6 +83,8 @@ bool parser_equation(const char* line, size_t len, DLList* equation_list,
                     } else if (c == '=') {
                         /* Es igual, empieza la expresión. */
                         state = EXP;
+                        /* Calculo la longitud de la variable. */
+                        var_len = i - var_start;
                     } else { /* es otra cosa */
                         PARSE_ERROR(
                                 "un espacio, una letra, un número o un igual");

diff --git a/parser_equation.h b/parser_equation.h
index a26089329448292c97f36a7516242436b56bdf19..9fa2f3dcc3ce85fd80b9c9c8c957d877e84dea15 100644 (file)
--- a/parser_equation.h
+++ b/parser_equation.h
@@ -22,6 +22,8 @@
 #include "dllist.h"
 #include <stdlib.h>
 
+size_t DLList_equation_print(DLList* l, FILE* fp);
+
 /* TODO:
  *
  * opcion1:

diff --git a/parser_equation_test.c b/parser_equation_test.c
new file mode 100644 (file)
index 0000000..0f6cae2
--- /dev/null
+++ b/parser_equation_test.c
@@ -0,0 +1,69 @@
+/* vim: set et sts=4 sw=4 fdm=indent fdl=1 fdn=0 fo+=t:
+ *
+ * Taller de Programación (75.42).
+ *
+ * Ejercicio Número 2:
+ * Programa calculadora.
+ *
+ * Copyleft 2003 - Leandro Lucarella <llucare@fi.uba.ar>
+ * Puede copiar, modificar y distribuir este programa bajo los términos de
+ * la licencia GPL (http://www.gnu.org/).
+ *
+ * Creado: sáb ago 30 18:24:31 ART 2003
+ *
+ * $Id$
+ */
+
+/**
+ * \file
+ *      Hace varios chequeos para probar si anda bien la función
+ *      parser_equation().
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "memdebug_debugger.h"
+#include "parser_equation.h"
+
+/**
+ * Programa para probar parser_equation().
+ *
+ * \return EXIT_SUCCESS si se realizó bien, EXIT_FAILURE si no.
+ */
+int main(int argc, char* argv[]) {
+    /* Declaración de variables. */
+    DLList* lista;
+    ParseError* error;
+
+    if (argc != 2) {
+        fprintf(stderr, "Debe pasar la ecuación a evaluar como parámetro.\n");
+        fprintf(stderr, "Ejemplo: %s 'b = 50 + h*2'\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    lista = DLList_new();
+    if (!lista) {
+        fprintf(stderr, "No se pudo crear la lista.\n");
+        return EXIT_FAILURE;
+    }
+
+    error = ParseError_new();
+    if (!error) {
+        fprintf(stderr, "No se pudo crear el error.\n");
+        return EXIT_FAILURE;
+    }
+
+    if (!parser_equation(argv[1], strlen(argv[1]), lista, error)) {
+        ParseError_print(error, stderr);
+        return EXIT_FAILURE;
+    }
+
+    DLList_equation_print(lista, stdout);
+
+    DLList_delete(lista);
+
+    return EXIT_SUCCESS;
+}
+