Some minor comment adjustments

Author: jeongsoolee09

c/cert/src/rules/INT34-C/ExprShiftedbyNegativeOrGreaterPrecisionOperand.ql

@@ -13,7 +13,11 @@
 import cpp
 import codingstandards.c.cert
 
-/* Precision predicate based on a sample implementaion from https://wiki.sei.cmu.edu/confluence/display/c/INT35-C.+Use+correct+integer+precisions */
+/*
+ * Precision predicate based on a sample implementaion from
+ * https://wiki.sei.cmu.edu/confluence/display/c/INT35-C.+Use+correct+integer+precisions
+ */
+
 int getPrecision(BuiltInType type) {
   type.(CharType).isExplicitlyUnsigned() and result = 8
   or
@@ -36,6 +40,7 @@ int getPrecision(BuiltInType type) {
   type instanceof LongLongType and not type.(LongLongType).isExplicitlyUnsigned() and result = 63
 }
 
+/* The -1 number literal. */
 class MinusNumberLiteral extends UnaryMinusExpr {
   MinusNumberLiteral() { this.getOperand() instanceof Literal }
 
@@ -45,17 +50,18 @@ class MinusNumberLiteral extends UnaryMinusExpr {
 class ForbiddenShiftExpr extends BinaryBitwiseOperation {
   ForbiddenShiftExpr() {
     (
-      /* Precision mismatch between operands */
+      /* First Case: Precision mismatch between operands */
       getPrecision(this.(LShiftExpr).getLeftOperand().getUnderlyingType()) <=
         getPrecision(this.(LShiftExpr).getRightOperand().getUnderlyingType()) or
       getPrecision(this.(RShiftExpr).getLeftOperand().getUnderlyingType()) <=
         getPrecision(this.(RShiftExpr).getRightOperand().getUnderlyingType()) or
-      /* Shifting by a negative number literal */
+      /* Second Case: Shifting by a negative number literal */
       this.(LShiftExpr).getRightOperand() instanceof MinusNumberLiteral or
       this.(RShiftExpr).getRightOperand() instanceof MinusNumberLiteral
     )
   }
 
+  /* Second Case: Shifting by a negative number literal */
   predicate hasNegativeOperand() {
     this.(LShiftExpr).getRightOperand() instanceof MinusNumberLiteral or
     this.(RShiftExpr).getRightOperand() instanceof MinusNumberLiteral

c/misra/src/rules/RULE-7-4/StringLiteralAssignedToNonConstChar.ql

@@ -21,80 +21,55 @@ class NonConstCharStarType extends Type {
 }
 
 /* A non-const-char* variable declared with a string literal */
-predicate declaringNonConstCharVar(Variable decl) {
+predicate declaringNonConstCharVar(Variable decl, string message) {
   not decl instanceof Parameter and // exclude parameters
   /* It should be declaring a char* type variable */
   decl.getUnspecifiedType() instanceof CharPointerType and
   not decl.getUnderlyingType().isDeeplyConstBelow() and
   /* But it's declared to hold a string literal.  */
-  decl.getInitializer().getExpr() instanceof StringLiteral
+  decl.getInitializer().getExpr() instanceof StringLiteral and
+  message = "char* variable " + decl + " is declared with a string literal."
 }
 
 /* String literal being assigned to a non-const-char* variable */
-predicate assignmentToNonConstCharVar(Assignment assign) {
+predicate assignmentToNonConstCharVar(Assignment assign, string message) {
   /* The variable being assigned is char* */
   assign.getLValue().getUnderlyingType() instanceof NonConstCharStarType and
   /* But the rvalue is a string literal */
-  exists(Expr rvalue | rvalue = assign.getRValue() | rvalue instanceof StringLiteral)
+  exists(Expr rvalue | rvalue = assign.getRValue() | rvalue instanceof StringLiteral) and
+  message = "char* variable " + assign.getLValue() + " is assigned a string literal. "
 }
 
 /* String literal being passed to a non-const-char* parameter */
-predicate assignmentToNonConstCharParam(FunctionCall call) {
+predicate assignmentToNonConstCharParam(FunctionCall call, string message) {
   exists(int index |
     /* Param at index is a char* */
     call.getTarget().getParameter(index).getUnderlyingType() instanceof NonConstCharStarType and
     /* But a string literal is passed */
     call.getArgument(index) instanceof StringLiteral
-  )
+  ) and
+  message = "char* parameter of " + call.getTarget() + " is passed a string literal."
 }
 
 /* String literal being returned by a non-const-char* function */
-predicate returningNonConstCharVar(ReturnStmt return) {
+predicate returningNonConstCharVar(ReturnStmt return, string message) {
   /* The function is declared to return a char* */
   return.getEnclosingFunction().getType().resolveTypedefs() instanceof NonConstCharStarType and
   /* But in reality it returns a string literal */
-  return.getExpr() instanceof StringLiteral
+  return.getExpr() instanceof StringLiteral and
+  message = "char* function " + return.getEnclosingFunction() + " is returning a string literal."
 }
 
-// newtype TProblematicElem =
-//   TVar(Variable decl) or
-//   TAssign(Assignment assign) or
-//   TFunCall(FunctionCall call) or
-//   TReturnStmt(ReturnStmt return)
-// class ProblematicElem extends TProblematicElem {
-//   Variable getVariable() { this = TVar(result) }
-//   Assignment getAssign() { this = TAssign(result) }
-//   FunctionCall getFunCall() { this = TFunCall(result) }
-//   ReturnStmt getReturnStmt() { this = TReturnStmt(result) }
-//   override string toString() {
-//     this instanceof TVar and result = this.getVariable().toString()
-//     or
-//     this instanceof TAssign and result = this.getAssign().toString()
-//     or
-//     this instanceof TFunCall and result = this.getFunCall().toString()
-//     or
-//     this instanceof TReturnStmt and result = this.getReturnStmt().toString()
-//   }
-// }
-// class ProblematicElem = Variable or Assignment or FunctionCall or ReturnStmt;
-// ^ Nope!
-from Variable decl, Assignment assign, FunctionCall call, ReturnStmt return, string message
+from Element elem, string message
 where
-  not isExcluded(decl, TypesPackage::stringLiteralAssignedToNonConstCharQuery()) and
-  not isExcluded(assign, TypesPackage::stringLiteralAssignedToNonConstCharQuery()) and
-  not isExcluded(call, TypesPackage::stringLiteralAssignedToNonConstCharQuery()) and
-  not isExcluded(return, TypesPackage::stringLiteralAssignedToNonConstCharQuery()) and
+  not isExcluded(elem, TypesPackage::stringLiteralAssignedToNonConstCharQuery()) and
   (
-    declaringNonConstCharVar(decl) and
-    message = "char* variable " + decl + " is declared with a string literal."
+    declaringNonConstCharVar(elem, message)
     or
-    assignmentToNonConstCharVar(assign) and
-    message = "char* variable " + assign.getLValue() + " is assigned a string literal. "
+    assignmentToNonConstCharVar(elem, message)
     or
-    assignmentToNonConstCharParam(call) and
-    message = "char* parameter of " + call.getTarget() + " is passed a string literal."
+    assignmentToNonConstCharParam(elem, message)
     or
-    returningNonConstCharVar(return) and
-    message = "char* function " + return.getEnclosingFunction() + " is returning a string literal."
+    returningNonConstCharVar(elem, message)
   )
 select message