Merge lp:~embik/pantheon-calculator/bug-1412890 into lp:~elementary-apps/pantheon-calculator/trunk

[Marvin Beckers]

fixes bug 1412890 (segfault on specific scenario) and corrects the way Shunting Yard works

This branch fixes bug 1412890 [segfault on sin(1/4pi)] and a subsequently discovered bug in Shunting Yard which did the token reorder wrong.

[lp:~embik/pantheon-calculator/bug-1412890]

88. By Marvin Beckers on 2015-01-20

some little code beautifying

89. By Marvin Beckers on 2015-01-20

removed kind of redundant do-while-construction

[Marvin Beckers (embik)]

review: Approve

=== modified file 'src/Core/Evaluation.vala'
--- src/Core/Evaluation.vala	2015-01-14 19:50:02 +0000
+++ src/Core/Evaluation.vala	2015-01-20 22:04:30 +0000
@@ -83,10 +83,10 @@
                     tokenlist = e.shunting_yard (tokenlist);
                     try {
                         d = e.eval_postfix (tokenlist);
-                    } catch (EVAL_ERROR e) { throw new OUT_ERROR.EVAL_ERROR (e.message); }
-                } catch (SHUNTING_ERROR e) { throw new OUT_ERROR.SHUNTING_ERROR (e.message); }
+                    } catch (Error e) { throw new OUT_ERROR.EVAL_ERROR (e.message); }
+                } catch (Error e) { throw new OUT_ERROR.SHUNTING_ERROR (e.message); }
                 return e.cut (d, d_places);
-            } catch (SCANNER_ERROR e) { throw new OUT_ERROR.SCANNER_ERROR (e.message); }
+            } catch (Error e) { throw new OUT_ERROR.SCANNER_ERROR (e.message); }
         }
 
         //Djikstra's Shunting Yard algorithm for ordering a tokenized list into Reverse Polish Notation
@@ -107,9 +107,8 @@
                     break;
 
                 case TokenType.SEPARATOR:
-                    while (opStack.peek ().token_type != TokenType.P_LEFT && !opStack.empty ()) {
+                    while (opStack.peek ().token_type != TokenType.P_LEFT && !opStack.empty ())
                         output.append (opStack.pop ());
-                    }
 
                     if (opStack.peek ().token_type != TokenType.P_LEFT)
                         throw new SHUNTING_ERROR.MISMATCHED_P ("Content of parentheses is mismatched.");
@@ -119,16 +118,21 @@
                     if (!opStack.empty ()) {
                         Operator op1 = get_operator (t);
                         Operator op2 = Operator ();
-                        try { op2 = get_operator (opStack.peek ());
+
+                        try {
+                            op2 = get_operator (opStack.peek ());
                         } catch (SHUNTING_ERROR e) { }
 
-                        while (!opStack.empty () &&
+                        while (!opStack.empty () && opStack.peek ().token_type == TokenType.OPERATOR &&
                         ((op2.fixity == "LEFT" && op1.prec <= op2.prec) ||
                         (op2.fixity == "RIGHT" && op1.prec < op2.prec))) {
                             output.append (opStack.pop ());
-                            if (!opStack.empty ())
-                                try { op2 = get_operator (opStack.peek ());
+
+                            if (!opStack.empty ()) {
+                                try {
+                                    op2 = get_operator (opStack.peek ());
                                 } catch (SHUNTING_ERROR e) { }
+                            }
                         }
                     }
                     opStack.push (t);
@@ -139,25 +143,32 @@
                     break;
 
                 case TokenType.P_RIGHT:
-                    while (!(opStack.peek ().token_type == TokenType.P_LEFT) && !opStack.empty ())
-                        output.append (opStack.pop ());
+                    while (!opStack.empty ()) {
+                        if (!(opStack.peek ().token_type == TokenType.P_LEFT))
+                            output.append (opStack.pop ());
+                        else
+                            break;
+                    }
 
-                    if (!(opStack.empty ()))
+                    if (!(opStack.empty ()) && opStack.peek ().token_type == TokenType.P_LEFT)
                         opStack.pop ();
 
-                    if (!opStack.empty () && opStack.peek ().token_type == TokenType.FUNCTION) 
+                    if (!opStack.empty () && opStack.peek ().token_type == TokenType.FUNCTION)
                         output.append (opStack.pop ());
+
                     break;
                 default:
                         throw new SHUNTING_ERROR.UNKNOWN_TOKEN ("'%s' is unknown.", t.content);
                 }
             }
+
             while (!opStack.empty ()) {
-                if (opStack.peek ().token_type == TokenType.P_LEFT)
-                    throw new SHUNTING_ERROR.MISMATCHED_P ("Mismatched left parenthesis.");
+                if (opStack.peek ().token_type == TokenType.P_LEFT || opStack.peek ().token_type == TokenType.P_RIGHT)
+                    throw new SHUNTING_ERROR.MISMATCHED_P ("Mismatched parenthesis.");
                 else
                     output.append (opStack.pop ());
             }
+
             return output;
         }
 
@@ -201,7 +212,7 @@
         //checks for real TokenType (which are TokenType.ALPHA at the moment)
         public bool is_operator (Token t) {
             foreach (Operator o in operators) {
-                if (t.content == o.symbol) 
+                if (t.content == o.symbol)
                     return true;
             }
             return false;
@@ -209,7 +220,7 @@
 
         public bool is_function (Token t) {
             foreach (Function f in functions) {
-                if (t.content == f.symbol) 
+                if (t.content == f.symbol)
                     return true;
             }
             return false;

=== modified file 'src/Core/Scanner.vala'
--- src/Core/Scanner.vala	2015-01-14 19:50:02 +0000
+++ src/Core/Scanner.vala	2015-01-20 22:04:30 +0000
@@ -84,8 +84,12 @@
                         next_number_negative = false;
                     }
 
-                    //checking if last token was a number and token now is a function, constant or parenthesis (left)
-                    if (last_token != null && last_token.token_type == TokenType.NUMBER && 
+                    /*
+                    * checking if last token was a number or parenthesis right
+                    * and token now is a function, constant or parenthesis (left)
+                    */
+                    if (last_token != null && 
+                    (last_token.token_type == TokenType.NUMBER || last_token.token_type == TokenType.P_RIGHT) && 
                     (t.token_type == TokenType.FUNCTION || t.token_type == TokenType.CONSTANT || t.token_type == TokenType.P_LEFT))
                         tokenlist.append (new Token ("*", TokenType.OPERATOR));