Tweak operators

Add back unary `+` and `-` as prefix operators (with `!` these are the natural, and currently only, prefix operators)
Add recognizing `*` or `&` as must-be-binary if followed by a literal (as when followed by `(` or an identifier)

Author: hsutter

source/cppfront.cpp

@@ -1830,10 +1830,14 @@ class cppfront
         auto suffix = std::string{};
         for (auto const& x : n.ops) {
             assert(x);
-            assert(x->type() == lexeme::Not);   // should be the only prefix operator
-            printer.add_pad_in_this_line(-3);
-            printer.print_cpp2("!(", n.position());
-            suffix += ")";
+            if (x->type() == lexeme::Not) {
+                printer.print_cpp2("!(", n.position());
+                printer.add_pad_in_this_line(-3);
+                suffix += ")";
+            }
+            else {
+                printer.print_cpp2(*x, x->position());
+            }
         }
         assert(n.expr);
         emit(*n.expr);

source/lex.h

@@ -95,6 +95,18 @@ enum class lexeme : std::int8_t {
     Identifier
 };
 
+auto is_literal(lexeme l) {
+    switch (l) {
+    break;case lexeme::FloatLiteral:        
+          case lexeme::BinaryLiteral:       
+          case lexeme::DecimalLiteral:      
+          case lexeme::HexadecimalLiteral:  
+          case lexeme::StringLiteral:       
+          case lexeme::CharacterLiteral:    return true;
+    break;default:                          return false;
+    }
+}
+
 //  TODO: Remove the duplication above/below with a variadic macro,
 //        but for now it's simpler just to write it out
 

source/parse.h

@@ -37,7 +37,14 @@ auto violates_lifetime_safety = false;
 //G
 auto is_prefix_operator(lexeme l) -> bool
 {
-    return l == lexeme::Not;
+    switch (l) {
+    break;case lexeme::Not:
+          case lexeme::Minus:
+          case lexeme::Plus:
+        return true;
+    break;default:
+        return false;
+    }
 }
 
 
@@ -1389,9 +1396,10 @@ class parser
             curr().type() == lexeme::Dot
             )
         {
-            //  * & and ~ can't be a unary operator if followed by ( or identifier
-            if ((curr().type() == lexeme::Multiply || curr().type() == lexeme::Ampersand || curr().type() == lexeme::Tilde) &&
-                (peek(1)->type() == lexeme::LeftParen || peek(1)->type() == lexeme::Identifier))
+            //  * and & can't be a unary operator if followed by a (, identifier, or literal
+            if ((curr().type() == lexeme::Multiply || curr().type() == lexeme::Ampersand) &&
+                peek(1) &&
+                (peek(1)->type() == lexeme::LeftParen || peek(1)->type() == lexeme::Identifier || is_literal(peek(1)->type())))
             {
                 break;
             }