Make ~ the set invert operator, and use _ as the negation placeholder

Author: joethephish

ink-engine-runtime/NativeFunctionCall.cs

@@ -10,7 +10,7 @@ internal class NativeFunctionCall : Runtime.Object
         public const string Divide   = "/";
         public const string Multiply = "*";
         public const string Mod      = "%";
-        public const string Negate   = "~";
+        public const string Negate   = "_"; // distinguish from "-" for subtraction
 
         public const string Equal    = "==";
         public const string Greater  = ">";
@@ -19,6 +19,7 @@ internal class NativeFunctionCall : Runtime.Object
         public const string LessThanOrEquals = "<=";
         public const string NotEquals   = "!=";
         public const string Not      = "!";
+        public const string Invert   = "~";
 
         public const string And      = "&&";
         public const string Or       = "||";
@@ -87,7 +88,7 @@ public Runtime.Object Call(List<Runtime.Object> parameters)
             // Special case:
             //  - Set inverse (!set) requires knowledge of origin set, not just
             //    the raw set dictionary.
-            if (parameters.Count == 1 && parameters [0] is SetValue && name == "!") {
+            if (parameters.Count == 1 && parameters [0] is SetValue && name == Invert) {
                 var setValue = (SetValue)parameters [0];
                 var inv = setValue.inverse;
                 if (inv == null) return new SetValue ("UNKNOWN", 0);
@@ -319,18 +320,20 @@ static void GenerateNativeFunctionsIfNecessary()
                 //AddSetBinaryOp (Multiply, (x, y) => x * y);
                 //AddSetBinaryOp (Divide, (x, y) => x / y);
                 //AddSetBinaryOp (Mod, (x, y) => x % y); // TODO: Is this the operation we want for floats?
-                //AddSetUnaryOp (Negate, x => -x);
+                //AddSetUnaryOp (Negate, x => x.Inverse());
 
                 AddSetBinaryOp (Equal, (x, y) => x.Equals(y) ? (int)1 : (int)0);
                 AddSetBinaryOp (Greater, (x, y) => x.Count > 0 && x.maxItem.Value > y.maxItem.Value ? (int)1 : (int)0);
                 AddSetBinaryOp (Less, (x, y) => y.Count > 0 && x.maxItem.Value < y.maxItem.Value ? (int)1 : (int)0);
                 AddSetBinaryOp (GreaterThanOrEquals, (x, y) => x.Count > 0 && x.maxItem.Value >= y.maxItem.Value ? (int)1 : (int)0);
                 AddSetBinaryOp (LessThanOrEquals, (x, y) => y.Count > 0 && x.maxItem.Value <= y.maxItem.Value ? (int)1 : (int)0);
                 AddSetBinaryOp (NotEquals, (x, y) => !x.Equals(y) ? (int)1 : (int)0);
-                //AddSetUnaryOp (Not, x => !x);
 
-                AddSetBinaryOp (And, (x, y) => x.IntersectWith(y));
-                AddSetBinaryOp (Or, (x, y) => x.UnionWith (y));
+                // Placeholder to ensure that Invert gets created at all,
+                // since this function is never actually run, and is special cased in Call
+                AddSetUnaryOp (Invert, x => x);
+
+                AddSetBinaryOp (And, (x, y) => x.UnionWith(y));
 
                 //AddSetBinaryOp (Max, (x, y) => Math.Max (x, y));
                 //AddSetBinaryOp (Min, (x, y) => Math.Min (x, y));
@@ -389,6 +392,11 @@ static void AddSetBinaryOp (string name, BinaryOp<SetDictionary> op)
             AddOpToNativeFunc (name, 2, ValueType.Set, op);
         }
 
+        static void AddSetUnaryOp (string name, UnaryOp<SetDictionary> op)
+        {
+            AddOpToNativeFunc (name, 1, ValueType.Set, op);
+        }
+
         static void AddFloatUnaryOp(string name, UnaryOp<float> op)
         {
             AddOpToNativeFunc (name, 1, ValueType.Float, op);

inklecate/InkParser/InkParser_Expressions.cs

@@ -168,7 +168,7 @@ protected Expression ExpressionUnary()
                 return divertTarget;
             }
 
-            var prefixOp = (string) OneOf (String ("-"), String ("!"));
+            var prefixOp = (string) OneOf (String ("-"), String("~"), String ("!"));
 
             // Don't parse like the string rules above, in case its actually 
             // a variable that simply starts with "not", e.g. "notable".
@@ -427,7 +427,15 @@ protected Parsed.Subset ExpressionSubset ()
 
             Whitespace ();
 
-            Expect (String (")"), "closing ')' for set");
+            if (subsetList != null && subsetList.Count > 0)
+                Expect (String (")"), "closing ')' for set");
+
+            // Rather than parsing nothing, the subset list may have *failed* to
+            // parse due to the parentheses containing something else, in which
+            // case we cope with that here.
+            else if (ParseString (")") == null) 
+                return null;
+                
 
             return new Subset (subsetList);
         }

inklecate/ParsedHierarchy/Expression.cs

@@ -151,9 +151,9 @@ public override string ToString ()
         string nativeNameForOp
         {
             get {
-                // Replace "-" with "~" to make it unique
+                // Replace "-" with "_" to make it unique (compared to subtraction)
                 if (op == "-")
-                    return "~";
+                    return "_";
                 if (op == "not")
                     return "!";
                 return op;