Tighten up parenthesization rules with unary prefix operators

lib/complex.neon

@@ -228,7 +228,7 @@ END FUNCTION
  *      http://mathworld.wolfram.com/Cosine.html
  */
 FUNCTION cos(a: Complex): Complex
-    RETURN make(math.cos(a.re)*rcosh(a.im), -math.sin(a.re)*rsinh(a.im))
+    RETURN make(math.cos(a.re)*rcosh(a.im), -(math.sin(a.re)*rsinh(a.im)))
 END FUNCTION
 
 /*  Function: cosh
@@ -288,7 +288,7 @@ END FUNCTION
  */
 FUNCTION inv(a: Complex): Complex
     LET d: Number := (a.re*a.re) + (a.im*a.im)
-    RETURN make(a.re/d, -a.im/d)
+    RETURN make(a.re/d, -(a.im/d))
 END FUNCTION
 
 /*  Function: log
@@ -335,7 +335,7 @@ END FUNCTION
 FUNCTION pow(a, b: Complex): Complex
     LET p: Number := a.arg()
     LET m: Number := a.abs()
-    LET r: Number := (m^b.re) * math.exp(-b.im * p)
+    LET r: Number := (m^b.re) * math.exp(-(b.im * p))
     LET t: Number := (b.re * p) + (b.im * math.log(m))
     RETURN make(r * math.cos(t), r * math.sin(t))
 END FUNCTION
@@ -402,7 +402,7 @@ END FUNCTION
  */
 FUNCTION tan(a: Complex): Complex
     LET u: Complex := make(math.tan(a.re), rtanh(a.im))
-    RETURN u.div(make(1, -u.re*u.im))
+    RETURN u.div(make(1, -(u.re*u.im)))
 END FUNCTION
 
 /*  Function: tanh

neon/lexer.neon

@@ -616,7 +616,7 @@ FUNCTION tokenize_fragment(source_path: String, INOUT line: Number, column_start
                                             DEC nest
                                         END IF
                                     WHEN ":" DO
-                                        IF NOT inquote AND nest = 1 THEN
+                                        IF (NOT inquote) AND nest = 1 THEN
                                             colon := i - 1
                                         END IF
                                     WHEN "\"" DO

neon/parser.neon

@@ -1603,8 +1603,9 @@ FUNCTION Parser.parseAtom(INOUT self: Parser): POINTER TO ParseTreeNode
 END FUNCTION
 
 FUNCTION Parser.parseArithmetic(INOUT self: Parser): POINTER TO ParseTreeNode
+    LET leading_minus := self.token.type = TokenType.minus
     VAR left: POINTER TO ParseTreeNode := self.parseCompoundExpression()
-    LET tokOp: lexer.Token := self.token
+    LET tokOp: lexer.Token := (IF leading_minus THEN lexer.Token(type WITH TokenType.plus) ELSE self.token)
     CASE tokOp.type
         WHEN TokenType.plus DO
             WHILE self.token.type = TokenType.plus DO
@@ -1862,8 +1863,10 @@ FUNCTION Parser.parseMembership(INOUT self: Parser): POINTER TO ParseTreeNode
 END FUNCTION
 
 FUNCTION Parser.parseLogical(INOUT self: Parser): POINTER TO ParseTreeNode
+    LET leading_not := self.token.type = TokenType.not
     VAR left: POINTER TO ParseTreeNode := self.parseMembership()
-    CASE self.token.type
+    LET op: lexer.Token := (IF leading_not THEN lexer.Token(type WITH TokenType.not) ELSE self.token)
+    CASE op.type
         WHEN TokenType.and DO
             WHILE self.token.type = TokenType.and DO
                 LET tokOp: lexer.Token := self.token
@@ -1896,6 +1899,8 @@ FUNCTION Parser.parseLogical(INOUT self: Parser): POINTER TO ParseTreeNode
                     )
                 )
             END WHILE
+        WHEN TokenType.not DO
+            -- pass
         WHEN OTHERS DO
             RETURN left
     END CASE

samples/othello/othello.neon

@@ -251,7 +251,7 @@ FUNCTION main()
         initialize()
         updateBoard()
         VAR game_over: Boolean := FALSE
-        WHILE NOT game_over AND NOT quit DO
+        WHILE (NOT game_over) AND (NOT quit) DO
             LET any: Boolean := displayBoard()
             IF NOT any THEN
                 game_over := TRUE

samples/sudoku/sudoku.neon

@@ -488,7 +488,7 @@ FUNCTION draw_grid(grid: multiarray.ArrayNumber2D, cx, cy: Number)
             curses.mvaddch(2+(2*i), 36, curses.ACS_RTEE())
         END IF
     END FOR
-    IF NOT any_errors AND puzzleFilled(grid) THEN
+    IF (NOT any_errors) AND puzzleFilled(grid) THEN
         curses.mvaddstr(15, 40, "Puzzle completed.")
     ELSE
         curses.move(15, 40)

samples/tetris/tetris.neon

@@ -257,7 +257,7 @@ FUNCTION main()
         VAR new_piece: Boolean := TRUE
         VAR last_drop: Number := 0
         VAR game_over: Boolean := FALSE
-        WHILE NOT game_over AND NOT quit DO
+        WHILE (NOT game_over) AND (NOT quit) DO
             IF new_piece THEN
                 p := next
                 next := 1 + (random.uint32() MOD 7)

src/parser.cpp

@@ -785,9 +785,10 @@ std::unique_ptr<Expression> Parser::parseCompoundExpression()
 
 std::unique_ptr<Expression> Parser::parseArithmetic()
 {
+    bool leading_minus = tokens[i].type == MINUS;
     std::unique_ptr<Expression> left = parseCompoundExpression();
-    auto &tok_op = tokens[i];
-    switch (tokens[i].type) {
+    auto tok_op = leading_minus ? Token(PLUS, "+") : tokens[i];
+    switch (tok_op.type) {
         case PLUS: {
             while (tokens[i].type == PLUS) {
                 auto &tok_op = tokens[i];
@@ -935,8 +936,10 @@ std::unique_ptr<Expression> Parser::parseMembership()
 
 std::unique_ptr<Expression> Parser::parseLogical()
 {
+    bool leading_not = tokens[i].type == NOT;
     std::unique_ptr<Expression> left = parseMembership();
-    switch (tokens[i].type) {
+    auto &tok_op = leading_not ? Token(NOT, "NOT") : tokens[i];
+    switch (tok_op.type) {
         case AND:
             while (tokens[i].type == AND) {
                 auto &tok_op = tokens[i];
@@ -953,6 +956,8 @@ std::unique_ptr<Expression> Parser::parseLogical()
                 left.reset(new DisjunctionExpression(tok_op, std::move(left), std::move(right)));
             }
             break;
+        case NOT:
+            break;
         default:
             return left;
     }

t/expr.neon

@@ -1,7 +1,7 @@
 VAR a: Number
 VAR b: Number
 b := 4
-a := -(-5 * (3 + b))
+a := -(-(5 * (3 + b)))
 print(str(a))
 
 --= 35

t/intdiv.neon

@@ -1,4 +1,4 @@
 TESTCASE 5 INTDIV 2 = 2
 TESTCASE 5 INTDIV -2 = -2
-TESTCASE -5 INTDIV 2 = -2
-TESTCASE -5 INTDIV -2 = 2
+TESTCASE (-5) INTDIV 2 = -2
+TESTCASE (-5) INTDIV -2 = 2

t/modulo.neon

@@ -13,23 +13,23 @@ print(str(3 MOD 3))
 print(str(10 MOD 3))
 --= 1
 
-print(str(-10 MOD 3))
+print(str((-10) MOD 3))
 --= 2
 
 print(str(10 MOD -3))
 --= -2
 
-print(str(-10 MOD -3))
+print(str((-10) MOD -3))
 --= -1
 
 print(str(3.14 MOD 0.7))
 --= 0.34
 
-print(str(-3.14 MOD 0.7))
+print(str((-3.14) MOD 0.7))
 --= 0.36
 
 print(str(3.14 MOD -0.7))
 --= -0.36
 
-print(str(-3.14 MOD -0.7))
+print(str((-3.14) MOD -0.7))
 --= -0.34

tools/helium.py

@@ -1994,8 +1994,9 @@ def parse_compound_expression(self):
         return expr
 
     def parse_arithmetic(self):
+        leading_minus = self.tokens[self.i] is MINUS
         left = self.parse_compound_expression()
-        if self.tokens[self.i] is PLUS:
+        if leading_minus or self.tokens[self.i] is PLUS:
             while self.tokens[self.i] is PLUS:
                 self.i += 1
                 right = self.parse_compound_expression()
@@ -2088,8 +2089,11 @@ def parse_membership(self):
             return left
 
     def parse_logical(self):
+        leading_not = self.tokens[self.i] is NOT
         left = self.parse_membership()
-        if self.tokens[self.i] is AND:
+        if leading_not:
+            pass
+        elif self.tokens[self.i] is AND:
             while self.tokens[self.i] is AND:
                 self.i += 1
                 right = self.parse_membership()