Implicit Predicate Atom

src/atom_finder/classifier.clj

@@ -43,7 +43,7 @@
 
 (def atoms
   [
-   (ValidatedAtom :preprocessor-in-statement define-parent?              non-toplevel-defines)
+   (ValidatedAtom :preprocessor-in-statement preprocessor-parent?        all-non-toplevel-preprocessors)
    (ValidatedAtom :logic-as-control-flow     logic-as-control-flow-atom? logic-as-control-flow-atoms)
    (ValidatedAtom :conditional               conditional-atom?           (default-finder conditional-atom?))
    (ValidatedAtom :reversed-subscript        reversed-subscript-atom?    (default-finder reversed-subscript-atom?))
@@ -53,6 +53,7 @@
    (ValidatedAtom :omitted-curly-braces      omitted-curly-braces-atom?  (default-finder omitted-curly-braces-atom?))
    (ValidatedAtom :assignment-as-value       assignment-as-value-atom?   (default-finder assignment-as-value-atom?))
    (ValidatedAtom :macro-operator-precedence macro-def-precedence-atom?  macro-operator-precedence-atoms)
+   (ValidatedAtom :implicit-predicate        implicit-predicate-atom?    (default-finder implicit-predicate-atom?))
    ]
   )
 

src/atom_finder/classifier/implicit-predicate.clj

@@ -0,0 +1,38 @@
+(in-ns 'atom-finder.classifier)
+(import '(org.eclipse.cdt.core.dom.ast  IASTIfStatement IASTForStatement IASTWhileStatement IASTDoStatement IASTBinaryExpression IASTUnaryExpression))
+
+(def implicit-types #{IASTIfStatement IASTForStatement IASTWhileStatement IASTDoStatement IASTConditionalExpression})
+; If statement as an implicit type:  C99 6.8.4.1/1
+; For/While/Do statements as implicit types:  C99 6.8.5/2
+; Ternary operator as an implicit type:  C99 6.5.15/1
+
+(declare implicit-expression?)
+
+(defn remove-parentheses
+[expr]
+(cond
+  (== IASTUnaryExpression/op_not (.getOperator expr)) true
+  (== IASTUnaryExpression/op_bracketedPrimary (.getOperator expr))
+    (not (implicit-expression? (.getOperand expr)))
+  :else false))
+
+(defn implicit-expression?
+  "Does this expression have a logical operator in it?"
+  [expr]  
+  (not (cond
+    (instance? IASTBinaryExpression expr)
+      (contains? logical-operators (.getOperator expr))
+    (instance? IASTUnaryExpression  expr)
+      (remove-parentheses expr)
+    :else false)))
+
+(defn implicit-predicate-atom?
+  "Does this AST node have an implicit predicate atom"
+  [node]
+  (cond
+    (instance? IASTForStatement node) (implicit-expression? (.getConditionExpression node))
+    (instance? IASTIfStatement node) (implicit-expression? (.getConditionExpression node))
+    (instance? IASTWhileStatement node) (implicit-expression? (.getCondition node))
+    (instance? IASTDoStatement node) (implicit-expression? (.getCondition node))
+    (instance? IASTConditionalExpression node) (implicit-expression? (.getLogicalConditionExpression node))
+    :else false))

src/atom_finder/classifier_util.clj

@@ -129,4 +129,13 @@
   (if (or (nil? node)
           (instance? IASTFunctionDefinition node))
     node
-    (enclosing-function (parent node))))
+    (enclosing-function (parent node))))
+
+(def logical-operators #{IASTBinaryExpression/op_equals
+                        IASTBinaryExpression/op_greaterEqual
+                        IASTBinaryExpression/op_greaterThan
+                        IASTBinaryExpression/op_lessThan
+                        IASTBinaryExpression/op_lessEqual
+                        IASTBinaryExpression/op_logicalAnd
+                        IASTBinaryExpression/op_logicalOr
+                        IASTBinaryExpression/op_notequals})

src/test/resources/implicit-predicate.c

@@ -0,0 +1,43 @@
+int main()
+{
+  int y = 5;
+
+  (y == 5) ? y = 5 : y == 7;
+
+  for (int x = 4; 4 != 4; x++);
+
+  for (int x = 5; 4 - 4; x++); // <true>
+
+  for (int x = 4; 4 == 4; x++);
+
+  (y = 4) ? y : y++; // <true>
+
+  for (int x = 4; 8 * 9 + 4; x++); // <true>
+
+  if (3 < 6)
+    if (3 | 6); // <true>
+
+  if (6 & 8) // <true>
+    if (2 ^ 9); // <true>
+
+  if (3 > 6);
+
+  ((y != 5)) ? y : y;
+
+  if (sizeof(34)); // <true>
+
+  if ((y >= 6));
+
+  while (y || 3)
+    while (y); // <true>
+
+  while (y <= 34);
+
+  (((y = 2))) ? 4 : 5; // <true>
+
+  while (!(y && y));
+
+  if (!(5 == y));
+
+  return;
+}

test/atom_finder/classifier_test.clj

@@ -151,3 +151,7 @@
 (deftest test-assignment-as-value-atom?
   (testing "assignment-as-value-atom? finds all atoms in snippet study code"
     (test-atom-lines "assignment-as-value.c" "<true>" (default-finder assignment-as-value-atom?))))
+
+(deftest test-implicit-predicate-atom?
+  (testing "implicit-predicate-atom? finds all atoms in sample code")
+    (test-atom-lines "implicit-predicate.c" "<true>" (default-finder implicit-predicate-atom?)))