fix some memory leaks reported by valgrindHEADmaster

6 files changed, 75 insertions, 28 deletions

diff --git a/src/lexer.c b/src/lexer.c
index 10bfe36..4a05d65 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -441,78 +441,102 @@ LETTER_STATE:
             }
             else if(type == PL_SUB_DIGIT)
             {
+                LexerToken* ret;
+                gchar* sub;
                 while(pl_get_next_token(state) == PL_SUB_DIGIT);
                 pl_roll_back(state);
-                tmp = g_ascii_strdown(pl_get_marked_substring(state), -1);
+                sub = pl_get_marked_substring(state);
+                tmp = g_ascii_strdown(sub, -1);
+                g_free(sub);
                 if(g_strcmp0(tmp, "mod") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_MOD);
                 }
                 if(g_strcmp0(tmp, "and") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_AND);
                 }
                 if(g_strcmp0(tmp, "or") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_OR);
                 }
                 if(g_strcmp0(tmp, "xor") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_XOR);
                 }
                 if(g_strcmp0(tmp, "not") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_NOT);
                 }
                 if(g_strcmp0(tmp, "in") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_IN);
                 }
+                g_free(tmp);
                 if(l_check_if_function(lstate))
                 {
-                    return l_insert_token(lstate, T_FUNCTION);
+                    ret = l_insert_token(lstate, T_FUNCTION);
                 }
                 else
                 {
-                    return l_insert_token(lstate, T_VARIABLE);
+                    ret = l_insert_token(lstate, T_VARIABLE);
                 }
+                return ret;
             }
             else
             {
+                LexerToken* ret;
+                gchar* sub;
                 pl_roll_back(state);
-                tmp = g_ascii_strdown(pl_get_marked_substring(state), -1);
+                sub = pl_get_marked_substring(state);
+                tmp = g_ascii_strdown(sub, -1);
+                g_free(sub);
                 if(g_strcmp0(tmp, "mod") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_MOD);
                 }
                 if(g_strcmp0(tmp, "and") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_AND);
                 }
                 if(g_strcmp0(tmp, "or") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_OR);
                 }
                 if(g_strcmp0(tmp, "xor") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_XOR);
                 }
                 if(g_strcmp0(tmp, "not") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_NOT);
                 }
                 if(g_strcmp0(tmp, "in") == 0)
                 {
+                    g_free(tmp);
                     return l_insert_token(lstate, T_IN);
                 }
+                g_free(tmp);
                 if(l_check_if_function(lstate))
                 {
-                    return l_insert_token(lstate, T_FUNCTION);
+                    ret = l_insert_token(lstate, T_FUNCTION);
                 }
                 else
                 {
-                    return l_insert_token(lstate, T_VARIABLE);
+                    ret = l_insert_token(lstate, T_VARIABLE);
                 }
+                return ret;
             }
         }
     }
diff --git a/src/mate-calc-cmd.c b/src/mate-calc-cmd.c
index 842eab5..a13c4aa 100644
--- a/src/mate-calc-cmd.c
+++ b/src/mate-calc-cmd.c
@@ -91,6 +91,7 @@ main(void)
         solve(equation);
     }
     free(equation);
+    g_object_unref(result_serializer);
 
     return 0;
 }
diff --git a/src/mate-calc.c b/src/mate-calc.c
index da95462..a3eb87c 100644
--- a/src/mate-calc.c
+++ b/src/mate-calc.c
@@ -68,8 +68,11 @@ solve(const char *equation)
         exit(1);
     }
     else {
-        result_str = mp_serializer_to_string(mp_serializer_new(MP_DISPLAY_FORMAT_AUTOMATIC, 10, 9), &result);
+        MpSerializer *serializer = mp_serializer_new(MP_DISPLAY_FORMAT_AUTOMATIC, 10, 9);
+        result_str = mp_serializer_to_string(serializer, &result);
+        g_object_unref(serializer);
         printf("%s\n", result_str);
+        g_free(result_str);
         mp_clear(&result);
         exit(0);
     }
@@ -165,8 +168,10 @@ get_options(int argc, char *argv[])
                 g_free(progname);
                 exit(1);
             }
-            else
+            else {
+                g_free(progname);
                 solve(argv[i]);
+            }
         }
         else {
             fprintf(stderr,
diff --git a/src/mp-equation.c b/src/mp-equation.c
index 0c9e204..ad2ab39 100644
--- a/src/mp-equation.c
+++ b/src/mp-equation.c
@@ -291,11 +291,11 @@ mp_equation_parse(const char *expression, MPEquationOptions *options, MPNumber *
     int ret;
     int err;
     ParserState* state;
-    state = p_create_parser (expression, options);
-
     if (!(expression && result) || strlen(expression) == 0)
         return PARSER_ERR_INVALID;
 
+    state = p_create_parser (expression, options);
+
     state->variable_is_defined = variable_is_defined;
     state->get_variable = get_variable;
     state->set_variable = set_variable;
@@ -307,6 +307,7 @@ mp_equation_parse(const char *expression, MPEquationOptions *options, MPNumber *
     ret = p_parse (state);
     if (state->error_token != NULL && error_token != NULL) {
         *error_token = state->error_token;
+        state->error_token = NULL;
     }
     /* Error during parsing */
     if (state->error) {
diff --git a/src/parser.c b/src/parser.c
index c9d711b..6aeba9e 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -238,6 +238,7 @@ p_create_parser(const gchar* input, MPEquationOptions* options)
     state->options = options;
     state->error = 0;
     state->error_token = NULL;
+    state->ret = mp_new();
     return state;
 }
 
@@ -276,7 +277,6 @@ p_parse(ParserState* state)
     ans = (MPNumber *) (*(state->root->evaluate))(state->root);
     if(ans)
     {
-        state->ret = mp_new();
         mp_set_from_mp(ans, &state->ret);
         mp_free(ans);
         return PARSER_ERR_NONE;
@@ -294,6 +294,8 @@ p_destroy_parser(ParserState* state)
         p_destroy_all_nodes(state->root);
     }
     l_destroy_lexer(state->lexer);
+    mp_clear(&state->ret);
+    free(state->error_token);
     free(state);
 }
 
diff --git a/src/parserfunc.c b/src/parserfunc.c
index 1d45467..a7ea8f1 100644
--- a/src/parserfunc.c
+++ b/src/parserfunc.c
@@ -11,8 +11,10 @@ void
 set_error(ParserState* state, gint errorno, const gchar *token)
 {
     state->error = errorno;
-    if(token)
+    if(token) {
+        free(state->error_token);
         state->error_token = strdup(token);
+    }
 }
 
 /* Unused function pointer. This won't be called anytime. */
@@ -177,13 +179,17 @@ pf_get_variable(ParseNode* self)
 
     if(!(self->state->get_variable))
     {
-        free(ans);
+        mp_clear(&value);
+        mp_clear(&t);
+        mp_free(ans);
         return NULL;
     }
 
     /* If defined, then get the variable */
     if((*(self->state->get_variable))(self->state, self->token->string, ans))
     {
+        mp_clear(&value);
+        mp_clear(&t);
         return ans;
     }
 
@@ -208,9 +214,11 @@ pf_get_variable(ParseNode* self)
         if(result)
             mp_set_from_mp(&value, ans);
     }
+    mp_clear(&value);
+    mp_clear(&t);
     if(!result)
     {
-        free (ans);
+        mp_free(ans);
         ans = NULL;
         set_error(self->state, PARSER_ERR_UNKNOWN_VARIABLE, self->token->string);
     }
@@ -237,13 +245,17 @@ pf_get_variable_with_power(ParseNode* self)
 
     if(!(self->state->get_variable))
     {
-        free(ans);
+        mp_clear(&value);
+        mp_clear(&t);
+        mp_free(ans);
         return NULL;
     }
 
     /* If defined, then get the variable */
     if((*(self->state->get_variable))(self->state, self->token->string, ans))
     {
+        mp_clear(&value);
+        mp_clear(&t);
         mp_xpowy_integer(ans, pow, ans);
         return ans;
     }
@@ -273,9 +285,11 @@ pf_get_variable_with_power(ParseNode* self)
         if(result)
             mp_set_from_mp(&value, ans);
     }
+    mp_clear(&value);
+    mp_clear(&t);
     if(!result)
     {
-        free(ans);
+        mp_free(ans);
         ans = NULL;
         set_error(self->state, PARSER_ERR_UNKNOWN_VARIABLE, self->token->string);
     }
@@ -291,23 +305,23 @@ pf_apply_func(ParseNode* self)
     val = (MPNumber*) (*(self->right->evaluate))(self->right);
     if(!(self->state->get_function))
     {
-        free(val);
-        free(ans);
+        mp_free(val);
+        mp_free(ans);
         return NULL;
     }
     if(!val)
     {
-        free(ans);
+        mp_free(ans);
         return NULL;
     }
     if(!(*(self->state->get_function))(self->state, self->token->string, val, ans))
     {
-        free(val);
-        free(ans);
+        mp_free(val);
+        mp_free(ans);
         set_error(self->state, PARSER_ERR_UNKNOWN_FUNCTION, self->token->string);
         return NULL;
     }
-    free(val);
+    mp_free(val);
     return ans;
 }
 
@@ -432,11 +446,11 @@ pf_do_sqrt(ParseNode* self)
     val = (MPNumber*) (*(self->right->evaluate))(self->right);
     if(!val)
     {
-        free(ans);
+        mp_free(ans);
         return NULL;
     }
     mp_sqrt(val, ans);
-    free(val);
+    mp_free(val);
     return ans;
 }
 
@@ -758,7 +772,7 @@ pf_do_subtract(ParseNode* self)
             mp_free(left);
         if(right)
             mp_free(right);
-        free(ans);
+        mp_free(ans);
         return NULL;
     }
     mp_subtract(left, right, ans);
@@ -782,7 +796,7 @@ pf_do_add(ParseNode* self)
             mp_free(left);
         if(right)
             mp_free(right);
-        free(ans);
+        mp_free(ans);
         return NULL;
     }
     mp_add(left, right, ans);
@@ -832,7 +846,7 @@ pf_do_subtract_percent(ParseNode* self)
             mp_free(val);
         if(per)
             mp_free(per);
-        free(ans);
+        mp_free(ans);
         return NULL;
     }
     mp_add_integer(per, -100, per);
@@ -947,7 +961,7 @@ pf_do_xor(ParseNode* self)
             mp_free(left);
         if(right)
             mp_free(right);
-        free(ans);
+        mp_free(ans);
         return NULL;
     }
     mp_xor(left, right, ans);