Reinforce 7-4 to consider wchar_t

Author: jeongsoolee09

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

@@ -13,9 +13,32 @@
 import cpp
 import codingstandards.c.misra
 
+/** Pointer to Wide character type, i.e. `wchar_t*`. */
+class WideCharPointerType extends PointerType {
+  WideCharPointerType() { this.getBaseType() instanceof Wchar_t }
+
+  override string getAPrimaryQlClass() { result = "WideCharPointerType" }
+}
+
+class GenericCharPointerType extends PointerType {
+  GenericCharPointerType() {
+    /* This type resolves to wchar_t* (which is in turn a typedef depending on its implementation) */
+    this.resolveTypedefs*() instanceof WideCharPointerType
+    or
+    /* This type eventually resolves to char* */
+    this.resolveTypedefs*() instanceof CharPointerType
+  }
+
+  predicate isWideCharPointerType() { this.resolveTypedefs*() instanceof WideCharPointerType }
+
+  override string toString() {
+    if this.isWideCharPointerType() then result = "wchar_t*" else result = "char*"
+  }
+}
+
 class NonConstCharStarType extends Type {
   NonConstCharStarType() {
-    this instanceof CharPointerType and
+    this instanceof GenericCharPointerType and
     not this.isDeeplyConstBelow()
   }
 }
@@ -24,40 +47,48 @@ class NonConstCharStarType extends Type {
 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.getType() instanceof GenericCharPointerType and
+  not decl.getType().isDeeplyConstBelow() and
+  /* But it's declared to hold a string literal. */
   decl.getInitializer().getExpr() instanceof StringLiteral and
-  message = "char* variable " + decl + " is declared with a string literal."
+  message =
+    decl.getType().(GenericCharPointerType) + " variable " + decl +
+      " is declared with a string literal."
 }
 
 /* String literal being assigned to a non-const-char* variable */
 predicate assignmentToNonConstCharVar(Assignment assign, string message) {
   /* The variable being assigned is char* */
-  assign.getLValue().getUnderlyingType() instanceof NonConstCharStarType and
+  assign.getLValue().getType() instanceof NonConstCharStarType and
   /* But the rvalue is a string literal */
-  exists(Expr rvalue | rvalue = assign.getRValue() | rvalue instanceof StringLiteral) and
-  message = "char* variable " + assign.getLValue() + " is assigned a string literal. "
+  assign.getRValue() instanceof StringLiteral and
+  message =
+    assign.getLValue().getType().(GenericCharPointerType) + " variable " + assign.getLValue() +
+      " is assigned a string literal. "
 }
 
 /* String literal being passed to a non-const-char* parameter */
 predicate assignmentToNonConstCharParam(FunctionCall call, string message) {
   exists(int index |
     /* Param at index is a char* */
-    call.getTarget().getParameter(index).getUnderlyingType() instanceof NonConstCharStarType and
+    call.getTarget().getParameter(index).getType() 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."
+    call.getArgument(index) instanceof StringLiteral and
+    message =
+      call.getTarget().getParameter(index).getType().(GenericCharPointerType) + " parameter of " +
+        call.getTarget() + " is passed a string literal."
+  )
 }
 
 /* String literal being returned by a non-const-char* function */
 predicate returningNonConstCharVar(ReturnStmt return, string message) {
   /* The function is declared to return a char* */
-  return.getEnclosingFunction().getType().resolveTypedefs() instanceof NonConstCharStarType and
+  return.getEnclosingFunction().getType() instanceof NonConstCharStarType and
   /* But in reality it returns a string literal */
   return.getExpr() instanceof StringLiteral and
-  message = "char* function " + return.getEnclosingFunction() + " is returning a string literal."
+  message =
+    return.getEnclosingFunction().getType().(GenericCharPointerType) + " function " +
+      return.getEnclosingFunction() + " is returning a string literal."
 }
 
 from Element elem, string message

c/misra/test/rules/RULE-7-4/StringLiteralAssignedToNonConstChar.expected

@@ -1,4 +1,8 @@
-| test.c:9:9:9:10 | s3 | char* variable s3 is declared with a string literal. |
-| test.c:11:3:12:15 | ... = ... | char* variable s3 is assigned a string literal.  |
-| test.c:26:5:26:21 | return ... | char* function sample3 is returning a string literal. |
-| test.c:38:3:38:9 | call to sample4 | char* parameter of sample4 is passed a string literal. |
+| test.c:11:9:11:10 | s3 | char* variable s3 is declared with a string literal. |
+| test.c:13:3:14:15 | ... = ... | char* variable s3 is assigned a string literal.  |
+| test.c:23:12:23:14 | ws3 | char* variable ws3 is declared with a string literal. |
+| test.c:25:3:25:23 | ... = ... | char* variable ws3 is assigned a string literal.  |
+| test.c:50:5:50:21 | return ... | char* function sample3 is returning a string literal. |
+| test.c:58:5:58:22 | return ... | char* function w_sample3 is returning a string literal. |
+| test.c:69:3:69:9 | call to sample4 | char* parameter of sample4 is passed a string literal. |
+| test.c:78:3:78:11 | call to w_sample4 | char* parameter of w_sample4 is passed a string literal. |

c/misra/test/rules/RULE-7-4/test.c

@@ -1,6 +1,8 @@
+#include <wchar.h>
 #include <stdio.h>
 
 void sample1() {
+  /* Test for plain char type */
   const char *s1 =
       "string1"; // COMPLIANT: string literal assigned to a const char* variable
   const register volatile char *s2 =
@@ -11,8 +13,21 @@ void sample1() {
   s3 =
       "string4"; // NON_COMPLIANT: char* variable assigned a string literal
                  // (not likely to be seen in production, since there is strcpy)
+
+  /* Test for wide char type */
+  const wchar_t *ws1 = L"wide string1"; // COMPLIANT: string literal assigned to
+                                       // a const char* variable
+  const register volatile wchar_t *ws2 =
+      L"wide string2"; // COMPLIANT: string literal assigned to a const char*
+                      // variable, don't care about the qualifiers
+  wchar_t *ws3 = L"wide string3"; // NON_COMPLIANT: char* variable declared to hold
+                              // a string literal
+  ws3 = L"wide string4";       // NON_COMPLIANT: char* variable assigned a string
+                        // literal (not likely to be seen in production, since
+                        // there is strcpy)
 }
 
+/* Testing returning a plain string literal */
 const char *sample2(int x) {
   if (x == 1)
     return "string5"; // COMPLIANT: can return a string literal with return type
@@ -21,6 +36,15 @@ const char *sample2(int x) {
     return NULL;
 }
 
+/* Testing returning a wide string literal */
+const wchar_t *w_sample2(int x) {
+  if (x == 1)
+    return L"string5"; // COMPLIANT: can return a string literal with return type
+                      // being const char* being const char*
+  else
+    return NULL;
+}
+
 char *sample3(int x) {
   if (x == 1)
     return "string6"; // NON_COMPLIANT: can return a string literal with return
@@ -29,14 +53,30 @@ char *sample3(int x) {
     return NULL;
 }
 
+wchar_t *w_sample3(int x) {
+  if (x == 1)
+    return L"string6"; // NON_COMPLIANT: can return a string literal with return
+                      // type being char*
+  else
+    return NULL;
+}
+
 void sample4(char *string) {}
 
 void sample5(const char *string) {}
 
 void call45() {
-  const char *literal = "string7";
   sample4("string8"); // NON_COMPLIANT: can't pass string literal to char*
   sample5("string9"); // COMPLIANT: passing string literal to const char*
 }
 
-int main() { return 0; }
+void w_sample4(wchar_t *string) {}
+
+void w_sample5(const wchar_t *string) {}
+
+void w_call45() {
+  w_sample4(L"string8"); // NON_COMPLIANT: can't pass string literal to char*
+  w_sample5(L"string9"); // COMPLIANT: passing string literal to const char*
+}
+
+int main() { return 0; }