Implement binary "!=" operator in status file parser.

tools/testing/dart/status_expression.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library status_expression;
 
 /**
  * Parse and evaluate expressions in a .status file for Dart and V8.
  * There are set expressions and Boolean expressions in a .status file.
  * The grammar is:
- *   BooleanExpression := $variableName == value | $variableName |
- *                        (BooleanExpression) |
+ *   BooleanExpression := $variableName == value | $variableName != value |
+ *                        $variableName | (BooleanExpression) |
  *                        BooleanExpression && BooleanExpression |
  *                        BooleanExpression || BooleanExpression
  *
  *   SetExpression := value | (SetExpression) |
  *                    SetExpression || SetExpression |
  *                    SetExpression if BooleanExpression |
  *                    SetExpression , SetExpression
  *
  *  Productions are listed in order of precedence, and the || and , operators
  *  both evaluate to set union, but with different precedence.
  *
  *  Values and variableNames are non-empty strings of word characters, matching
  *  the RegExp \w+.
  *
  *  Expressions evaluate as expected, with values of variables found in
  *  an environment passed to the evaluator.  The SetExpression "value"
  *  evaluates to a singleton set containing that value. "A if B" evaluates
  *  to A if B is true, and to the empty set if B is false.
  */
 
 
 class Token {
   static const String LEFT_PAREN = "(";
   static const String RIGHT_PAREN = ")";
   static const String DOLLAR_SYMBOL = r"$";
   static const String UNION = ",";
   static const String EQUALS = "==";
+  static const String NOT_EQUALS = "!=";
   static const String AND = "&&";
   static const String OR = "||";
 }
 
 
 class Tokenizer {
   String expression;
   List<String> tokens;
 
   Tokenizer(String this.expression)
     : tokens = new List<String>();
 
-  //  Tokens are : "(", ")", "$", ",", "&&", "||", "==", and (maximal) \w+.
+  //  Tokens are : "(", ")", "$", ",", "&&", "||", "==", "!=", and (maximal) \w+.

[ricow1, 2013/05/24 10:54:38]

Long line

[kustermann, 2013/05/24 11:00:34]

Done.

   static final testRegexp =
-      new RegExp(r"^([()$\w\s,]|(\&\&)|(\|\|)|(\=\=))+$");
-  static final regexp = new RegExp(r"[()$,]|(\&\&)|(\|\|)|(\=\=)|\w+");
+      new RegExp(r"^([()$\w\s,]|(\&\&)|(\|\|)|(\=\=)|(\!\=))+$");
+  static final regexp = new RegExp(r"[()$,]|(\&\&)|(\|\|)|(\=\=)|(\!\=)|\w+");
 
   List<String> tokenize() {
     if (!testRegexp.hasMatch(expression)) {
       throw new FormatException("Syntax error in '$expression'");
     }
     for (Match match in regexp.allMatches(expression)) tokens.add(match[0]);
     return tokens;
   }
 }
 
 
 abstract class BooleanExpression {
   bool evaluate(Map<String, String> environment);
 }
 
 
 abstract class SetExpression {
   Set<String> evaluate(Map<String, String> environment);
 }
 
 
 class Comparison implements BooleanExpression {
   TermVariable left;
   TermConstant right;
+  bool negate;
 
-  Comparison(this.left, this.right);
+  Comparison(this.left, this.right, this.negate);
 
-  bool evaluate(environment) =>
-      left.termValue(environment) == right.termValue(environment);
-  String toString() => "(\$${left.name} == ${right.value})";
+  bool evaluate(environment) {
+    var equals = left.termValue(environment) == right.termValue(environment);
+    return negate ? !equals : equals;

[Bill Hesse, 2013/05/24 10:53:23]

How about
return negate != (left... == right....);

[kustermann, 2013/05/24 11:00:34]

Done.

+  }
+
+  String toString() =>
+      "(\$${left.name} ${negate ? '!=' : '=='} ${right.value})";
 }
 
 
 class TermVariable {
   String name;
 
   TermVariable(this.name);
 
   String termValue(environment) => environment[name].toString();
 }
@@ skipping 187 matching lines @@
       throw new RuntimeError(
           "Expected \$ in expression, got ${scanner.current}");
     }
     scanner.advance();
     if (!new RegExp(r"^\w+$").hasMatch(scanner.current)) {
       throw new RuntimeError(
           "Expected identifier in expression, got ${scanner.current}");
     }
     TermVariable left = new TermVariable(scanner.current);
     scanner.advance();
-    if (scanner.current == Token.EQUALS) {
+    if (scanner.current == Token.EQUALS ||
+        scanner.current == Token.NOT_EQUALS) {
+      bool negate = scanner.current == Token.NOT_EQUALS;
       scanner.advance();
       if (!new RegExp(r"^\w+$").hasMatch(scanner.current)) {
         throw new RuntimeError(
             "Expected identifier in expression, got ${scanner.current}");
       }
       TermConstant right = new TermConstant(scanner.current);
       scanner.advance();
-      return new Comparison(left, right);
+      return new Comparison(left, right, negate);
     } else {
       return new BooleanVariable(left);
     }
   }
 }