@specs-feup/clava-misra 1.0.0

package/src/misra/sections/Section18_PointersAndArrays.ts

@@ -0,0 +1,108 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, Joinpoint, BinaryOp, Field, Param, Vardecl, FunctionJp, Type, PointerType, QualType, FunctionType } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+
+export default class Section18_PointersAndArrays extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [4, this.r18_4_noPointerArithmetic.bind(this)],
+            [5, this.r18_5_noExcessivePointerNesting.bind(this)],
+            [7, this.r18_7_noFlexibleArrayMembers.bind(this)],
+            [8, this.r18_8_noVariableLengthArrays.bind(this)]
+        ]);
+    }
+
+    private r18_4_noPointerArithmetic($startNode: Joinpoint) {
+        for (const bOp of Query.searchFrom($startNode, BinaryOp, {operator: /(\+=)|(-=)|(\+)|(-)/})) {
+            if (!bOp.type.isPointer) continue;
+            this.logMISRAError(bOp, "Pointer arithmetic is not allowed. The only exception is if two pointers to elements of the same array are subtracted.")
+        }
+    }
+
+    private static getDepth(type: Type) {
+        let depth = 0;
+        let curr = type.desugarAll;
+        while (curr.isPointer === true) {
+            depth++;
+    
+            if(curr instanceof PointerType) {
+                curr = curr.pointee.desugarAll;    
+            } else if(curr instanceof QualType) {
+                curr = (curr.unqualifiedType as PointerType).pointee.desugarAll;    
+            } else {
+                throw new Error(`Not supported for type ${curr.joinPointType}.`);
+            }
+        }
+    
+        return depth;
+    }
+
+    private static getUnderlyingType(type: Type) {
+        let curr = type.desugarAll;
+        while (curr.isPointer === true) {
+    
+            if(curr instanceof PointerType) {
+                curr = curr.pointee.desugarAll;    
+            } else if(curr instanceof QualType) {
+                curr = (curr.unqualifiedType as PointerType).pointee.desugarAll;    
+            } else {
+                throw new Error(`Not supported for type ${curr.joinPointType}.`);
+            }
+        }
+    
+        return curr;
+    }
+
+    private r18_5_noExcessivePointerNesting($startNode: Joinpoint) { //must apply to fields as well
+        Query.searchFrom($startNode, Vardecl).get().forEach(decl => {
+            if (decl instanceof Param) return;
+            const depth = Section18_PointersAndArrays.getDepth(decl.type);
+            const underlyingType = Section18_PointersAndArrays.getUnderlyingType(decl.type);
+            if (underlyingType instanceof FunctionType) {
+                const retDepth = Section18_PointersAndArrays.getDepth(underlyingType.returnType);
+                const paramDepths = underlyingType.paramTypes.map(type => Section18_PointersAndArrays.getDepth(type)).filter(d => d > 2);
+                if (retDepth > 2) {
+                    this.logMISRAError(decl, `Return type of function pointer ${decl.code} has more than two levels of indirection.`);
+                }
+                if (paramDepths.length > 0) {
+                    this.logMISRAError(decl, `One or more parameters of function pointer ${decl.code} have more than two levels of indirection.`);
+                }
+            }
+            if (depth > 2) {
+                this.logMISRAError(decl, `Type ${decl.type.code} has more than two levels of indirection.`)
+            }
+        }, this);
+        
+        Query.searchFrom($startNode, FunctionJp).get().forEach(fun => {
+            const retDepth = Section18_PointersAndArrays.getDepth(fun.functionType.returnType);
+            const paramDepths = fun.functionType.paramTypes.map(type => Section18_PointersAndArrays.getDepth(type)).filter(d => d > 2);
+            if (retDepth > 2) {
+                this.logMISRAError(fun, `Return type of function ${fun.signature} has more than two levels of indirection.`);
+            }
+            if (paramDepths.length > 0) {
+                this.logMISRAError(fun, `One or more parameters of function ${fun.signature} have more than two levels of indirection.`);
+            }
+        }, this);
+    }
+
+    private r18_7_noFlexibleArrayMembers($startNode: Joinpoint) {
+        for (const varDecl of Query.searchFrom($startNode, Field)) {
+            if (!varDecl.type.isArray || varDecl instanceof Param) continue;
+            if (varDecl.type.arraySize === -1) {
+                this.logMISRAError(varDecl, `Array ${varDecl.name} has variable or undefined size.`);
+            }
+        }
+    }
+
+    private r18_8_noVariableLengthArrays($startNode: Joinpoint) {
+        for (const varDecl of Query.searchFrom($startNode, Vardecl)) {
+            if (!varDecl.type.isArray || varDecl.instanceOf("param")) continue;
+            if (varDecl.type.arraySize === -1) {
+                this.logMISRAError(varDecl, `Array ${varDecl.name} has variable or undefined size.`);
+            }
+        }
+    }
+}

package/src/misra/sections/Section19_OverlappingStorage.ts

@@ -0,0 +1,18 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, Joinpoint, Class } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+
+export default class Section19_OverlappingStorage extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [2, this.r19_2_noUnion.bind(this)]
+        ]);
+    }
+    
+    private r19_2_noUnion($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Class, {kind: "union"}).get().forEach(union => this.logMISRAError(union, "The union keyword should not be used."), this);
+    }
+}

package/src/misra/sections/Section20_PreprocessingDirectives.ts

@@ -0,0 +1,22 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, Joinpoint, Include } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+
+export default class Section20_PreprocessingDirectives extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [2, this.r20_2_noInvalidCharsInInclude.bind(this)]
+        ]);
+    }
+    
+    private r20_2_noInvalidCharsInInclude($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Include).get().forEach(include => {
+            if (/.*('|"|\\|\/\*|\/\/).*/.test(include.name)) {
+                this.logMISRAError(include, `Invalid characters in include for ${include.name}. Invalid characters are ', ", \\, and the sequences /* and //.`)
+            }
+        }, this);
+    }
+}

package/src/misra/sections/Section21_StandardLibraries.ts

@@ -0,0 +1,65 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Call, FileJp, Include, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+
+export default class Section21_StandardLibraries extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: FileJp | Program) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [3, this.r21_3_noDynamicAllocation.bind(this)],
+            [4, this.r21_4_noSetjmpUsage.bind(this)],
+            [5, this.r21_5_noSignalUsage.bind(this)],
+            [6, this.r21_6_noStandardIO.bind(this)],
+            [7, this.r21_7_noStringFunctions.bind(this)],
+            [8, this.r21_8_noSysFunctions.bind(this)],
+            [9, this.r21_9_noStdAlgos.bind(this)],
+            [10, this.r21_10_noDateUsage.bind(this)],
+            [11, this.r21_11_noTgmathUsage.bind(this)],
+            [12, this.r21_12_noFenvExceptions.bind(this)]
+        ]);
+    }
+
+    private r21_3_noDynamicAllocation($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Call, {name: /(malloc|realloc|calloc|free)/}).get().forEach(call => this.logMISRAError(call, "Use of memory allocation functions provided by <stdlib.h> is not allowed."), this);
+    }
+
+    private r21_4_noSetjmpUsage($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Include, {name: "setjmp.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <setjmp.h> is not allowed."), this);
+    }
+    
+    private r21_5_noSignalUsage($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Include, {name: "signal.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <setjmp.h> is not allowed."), this);
+    }
+
+    private r21_6_noStandardIO($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Include, {name: /(stdio.h|wchar.h)/}).get().forEach(include => this.logMISRAError(include, "Use of the standard library I/O functions provided by <stdio.h> and <wchar.h> is not allowed."), this);
+    }
+
+    //how to avoid triggering errors for functions with the same name?
+    private r21_7_noStringFunctions($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Call, {name: /(atoi|atof|atol|atoll)/}).get().forEach(call => this.logMISRAError(call, `Use of function ${call.signature} is not allowed.`), this);
+    }
+
+    private r21_8_noSysFunctions($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Call, {name: /(system|abort|exit|getenv)/}).get().forEach(call => this.logMISRAError(call, `Use of function ${call.signature} is not allowed.`), this);
+    }
+
+    private r21_9_noStdAlgos($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Call, {name: /(qsort|bsearch)/}).get().forEach(call => this.logMISRAError(call, `Use of function ${call.signature} is not allowed.`), this);
+    }
+
+    private r21_10_noDateUsage($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Include, {name: "time.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <time.h> is not allowed."), this);
+        Query.searchFrom($startNode, Call, {name: "wcsftime"}).get().forEach(call => this.logMISRAError(call, "Identifier 'wcsftime' shall not be used."), this);
+    }
+    
+    private r21_11_noTgmathUsage($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Include, {name: "tgmath.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <tgmath.h> is not allowed."), this);
+    }
+
+    private r21_12_noFenvExceptions($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Call, {name : /(feclearexcept|fegetexceptflag|feraiseexcept|fesetexceptflag|fetestexcept)/}).get().forEach(call => this.logMISRAError(call, `Use of function ${call.signature} is not allowed`), this);
+    }
+}

package/src/misra/sections/Section2_UnusedCode.ts

@@ -0,0 +1,47 @@
+import { Program, FileJp, Joinpoint, FunctionJp, Varref, Param, LabelStmt, GotoStmt } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+
+export default class Section2_UnusedCode extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [6, this.r2_6_noUnusedLabels.bind(this)],
+            [7, this.r2_7_noUnusedParams.bind(this)]
+        ]);
+    }
+
+    private r2_6_noUnusedLabels($startNode: Joinpoint) {
+        Query.searchFrom($startNode, FunctionJp).get().forEach(fun => {
+            Query.searchFrom(fun, LabelStmt).get().forEach(label => {
+                if (Query.searchFrom(fun, GotoStmt, {label: jp => jp.astId == label.decl.astId}).get().length === 0) {
+                    this.logMISRAError(label, `Label ${label.decl.name} is unused in function ${fun.name}.`);
+                }
+            },this);
+        }, this);
+    }
+
+    private r2_7_noUnusedParams($startNode: Joinpoint) {
+        Query.searchFrom($startNode, FunctionJp).get().forEach(fun => {
+            const params: Map<string, Param> = new Map();
+            for (const param of fun.params) {
+                params.set(param.astId, param);
+            }
+
+            Query.searchFrom(fun, Varref).get().forEach(ref => {
+                params.delete(ref.decl?.astId);
+            }, this);
+
+            params.forEach((v, k, m) => {
+                this.logMISRAError(v, `Parameter ${v.name} is unused.`, new Fix(v, $jp => {
+                    const fun = $jp.getAncestor("function") as FunctionJp;
+                    const params = fun.params.filter(param => param.astId !== $jp.astId);
+                    fun.setParams(params);
+                }));
+            }, this);
+        }, this);
+    }
+}

package/src/misra/sections/Section3_Comments.ts

@@ -0,0 +1,23 @@
+import { Program, FileJp, Joinpoint, Comment } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+
+export default class Section3_Comments extends MISRAAnalyser {
+    protected ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [3, this.r3_1_fixComments.bind(this)]
+        ]);
+    }
+
+    private static removeCommentSequences(str: string) {
+        return str.replace(/(\/\/||\/\*)/g, '');
+    }
+    
+    private r3_1_fixComments($startNode: Joinpoint) { //inlines
+        Query.search(Comment).get().forEach(comment => comment.setText(Section3_Comments.removeCommentSequences(comment.text)));
+        //Query.searchFrom(Query.root()).get().forEach(jp => jp.setInlineComments(jp.inlineComments.map(comment => removeCommentSequences(comment.text).toString())));
+    }
+}

package/src/misra/sections/Section5_Identifiers.ts

@@ -0,0 +1,149 @@
+import { Program, FileJp, Joinpoint, StorageClass, Vardecl, FunctionJp, TypedefDecl, NamedDecl, TypedefNameDecl, Class, TagType, EnumDecl } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+
+export default class Section5_Identifiers extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [1, this.r5_1_externalIdentifierLength.bind(this)],
+            [6, this.r5_6_uniqueTypedefs.bind(this)],
+            [7, this.r5_7_uniqueTags.bind(this)],
+            [8, this.r5_8_uniqueExternalIds.bind(this)]
+        ]);
+    }
+
+    private static hasExternalLinkage($class: StorageClass) {
+        return $class !== StorageClass.STATIC && $class !== StorageClass.EXTERN;
+    }
+
+    private r5_1_externalIdentifierLength($startNode: Joinpoint) {
+        const prefixes: Set<string> = new Set();
+        for (const vardecl of  Query.searchFrom($startNode, Vardecl, {storageClass: (sC: StorageClass) => Section5_Identifiers.hasExternalLinkage(sC)})) {
+            if (vardecl.name.length >= 31) {
+                if (prefixes.has(vardecl.name.substring(0, 32))) {
+                    this.logMISRAError(vardecl, `External identifier ${vardecl.name} is not distinct.`, new Fix(vardecl, ($jp) => {
+                        ($jp as Vardecl).name = "a_" + ($jp as Vardecl).name;
+                    }));
+                }
+                else {
+                    prefixes.add(vardecl.name.substring(0, 32));
+                }
+            }
+        }
+
+        for (const fun of Query.searchFrom($startNode, FunctionJp, {storageClass: (sC: StorageClass) => Section5_Identifiers.hasExternalLinkage(sC)})) {
+            if (fun.name.length >= 31) {
+                if (prefixes.has(fun.name.substring(0, 32))) {
+                    this.logMISRAError(fun, `External identifier ${fun.name} is not distinct.`, new Fix(fun, ($jp) => {
+                        ($jp as FunctionJp).name = "a_" + ($jp as FunctionJp).name;
+                    }));
+                }
+                else {
+                    prefixes.add(fun.name.substring(0, 32));
+                }
+            }
+        }
+    }
+
+    private r5_6_uniqueTypedefs($startNode: Joinpoint) { //exception is missing
+        const typedefs: Set<string> = new Set();
+
+        for (const typedef of Query.searchFrom($startNode, TypedefDecl)) {
+            if (typedefs.has(typedef.name)) {
+                this.logMISRAError(typedef, "Typedef names must be unique across all translation units.", new Fix(typedef, jp => {
+                    const typedefJp = jp as TypedefDecl;
+                    typedefJp.name = typedef.name + "_" + typedefJp.astId;
+                }));
+            }
+            else {
+                typedefs.add(typedef.name);
+            }
+        }
+
+        Query.searchFrom($startNode, NamedDecl).get().filter(decl => !(decl instanceof TypedefNameDecl)).forEach(decl => {
+            if (decl instanceof Class) {
+                const typedefChildren = decl.getDescendants("typedefDecl") as TypedefDecl[];
+                for (const child of typedefChildren) {
+                    if (decl.name === child.name) return;
+                }
+            }
+            if (typedefs.has(decl.name)) {
+                this.logMISRAError(decl, `${decl.name} is also the name of a typedef. Typedef identifiers must not be reused.`, new Fix(decl, jp => {
+                    const declJp = jp as NamedDecl;
+                    declJp.name = declJp.name + "_" + declJp.astId;
+                }));
+            }
+        }, this);
+    }
+
+    private r5_7_uniqueTags($startNode: Joinpoint) {
+        const tags: Set<string> = new Set();
+
+        for (const classJp of Query.searchFrom($startNode, Class)) {
+            if (classJp.type instanceof TagType) {
+                if (tags.has(classJp.type.name)) {
+                    this.logMISRAError(classJp, "Tag names must be unique across all translation units.");
+                }
+                else {
+                    tags.add(classJp.type.name);
+                }
+            }
+        }
+
+        for (const enumDecl of Query.searchFrom($startNode, EnumDecl)) {
+            if (enumDecl.type instanceof TagType) {
+                if (tags.has(enumDecl.type.name)) {
+                    this.logMISRAError(enumDecl, "Tag names must be unique across all translation units.");
+                }
+                else {
+                    tags.add(enumDecl.type.name);
+                }
+            }
+        }
+
+        Query.searchFrom($startNode, NamedDecl).get().filter(decl => !(decl instanceof TypedefNameDecl)).forEach(decl => {
+            if (decl instanceof Class) {
+                const typedefChildren = decl.getDescendants("typedefDecl") as TypedefDecl[];
+                for (const child of typedefChildren) {
+                    if (decl.name === child.name) return;
+                }
+            }
+            if (decl.type instanceof TagType) return;
+            if (tags.has(decl.name)) {
+                this.logMISRAError(decl, `${decl.name} is also the name of a tag. Tag identifiers must not be reused.`, new Fix(decl, jp => {
+                    const declJp = jp as NamedDecl;
+                    declJp.name = declJp.name + "_" + declJp.astId;
+                }));
+            }
+        }, this);
+    }
+
+    private r5_8_uniqueExternalIds($startNode: Joinpoint) {
+        const ids: Set<string> = new Set();
+        for (const vardecl of  Query.searchFrom($startNode, Vardecl, {storageClass: (sC: StorageClass) => Section5_Identifiers.hasExternalLinkage(sC)})) {
+                if (ids.has(vardecl.name)) {
+                    this.logMISRAError(vardecl, `External identifier ${vardecl.name} must be unique across all translation units.`, new Fix(vardecl, ($jp) => {
+                        ($jp as Vardecl).name = "a_" + ($jp as Vardecl).name;
+                    }));
+                }
+                else {
+                    ids.add(vardecl.name);
+                }
+        }
+
+        for (const fun of Query.searchFrom($startNode, FunctionJp, {storageClass: (sC: StorageClass) => Section5_Identifiers.hasExternalLinkage(sC)})) {
+            if (ids.has(fun.name)) {
+                this.logMISRAError(fun, `External identifier ${fun.name} must be unique across all translation units.`, new Fix(fun, ($jp) => {
+                    ($jp as FunctionJp).name = "a_" + ($jp as FunctionJp).name;
+                }));
+            }
+            else {
+                ids.add(fun.name);
+            }
+        }
+    }
+}

package/src/misra/sections/Section6_Types.ts

@@ -0,0 +1,26 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, Joinpoint, Field, IntLiteral, BuiltinType } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+
+export default class Section6_Types extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [2, this.r6_2_noSingleBitSignedFields.bind(this)],
+
+        ]);
+    }
+    
+    private r6_2_noSingleBitSignedFields($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Field).get().forEach(field => {
+            if (field.children.length > 0 && field.name) {
+                const width = new Number((field.children[0].children[0] as IntLiteral).value);
+                if (width == 1 && (field.type as BuiltinType).isSigned) {
+                    this.logMISRAError(field, `Single-bit named bit field ${field.name} must not have a signed type.`);
+                }
+            }
+        }, this);
+    }
+}

package/src/misra/sections/Section7_LiteralsConstants.ts

@@ -0,0 +1,76 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, IntLiteral, Type, PointerType, QualType, Vardecl, BinaryOp, ReturnStmt, FunctionJp, Call, Varref, ArrayAccess, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+
+export default class Section7_LiteralsConstants extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [1, this.r7_1_noOctalConstants.bind(this)],
+            [3, this.r7_3_noLowercaseLSuffix.bind(this)],
+            [4, this.r7_4_constStringLiterals.bind(this)]
+        ]);
+    }
+    
+    private r7_1_noOctalConstants($startNode: Joinpoint) {
+        for (const intLit of Query.searchFrom($startNode, IntLiteral)) {
+            if (intLit.code.match(/0[0-9]+/g)) {
+                this.logMISRAError(intLit, `The octal constant ${intLit.code} was used. Its decimal value is ${intLit.value}`);
+            }
+        }
+    }
+    
+    private r7_3_noLowercaseLSuffix($startNode: Joinpoint) {
+        for (const intLit of Query.searchFrom($startNode, IntLiteral)) {
+            if (intLit.code.includes('l')) {
+                this.logMISRAError(intLit, `A lowercase 'l' was used as a suffix in ${intLit.code}.`);
+            }
+        }
+    }
+    
+    private static checkPointerConst(type: Type) {
+        if (type instanceof PointerType) {
+            return type.pointee.constant;
+        }
+        else if (type instanceof QualType && type.unqualifiedType instanceof PointerType) {
+            return type.unqualifiedType.pointee.constant;
+        }
+        else return undefined;
+    }
+    
+    private r7_4_constStringLiterals($startNode: Joinpoint) { 
+        for (const varDecl of Query.searchFrom($startNode, Vardecl)) {
+            if (!varDecl.type.isPointer) continue;
+    
+            if (varDecl.children.length > 0 && varDecl.children[0].joinPointType === "literal"
+                && !Section7_LiteralsConstants.checkPointerConst(varDecl.type)) {
+                    this.logMISRAError(varDecl, `String literal assigned to non-const qualified variable ${varDecl.name}`);
+            }
+        }
+        
+        Query.searchFrom($startNode, BinaryOp, {isAssignment: true}).get().forEach(bOp => {
+            if (bOp.right.joinPointType === "literal" && !Section7_LiteralsConstants.checkPointerConst(bOp.left.type)) {
+                this.logMISRAError(bOp, `String literal assigned to non-const qualified variable ${(bOp.left as Varref | ArrayAccess).name}`);
+            }
+        }, this);
+    
+        for (const ret of Query.searchFrom($startNode, ReturnStmt)) {
+            const ancestor = ret.getAncestor("function") as FunctionJp;
+            const retType = ancestor.functionType.returnType;
+            if (ret.returnExpr?.joinPointType === "literal" && !Section7_LiteralsConstants.checkPointerConst(retType)) {
+                this.logMISRAError(ret, `String literal returned in non-const qualified return value for function ${ancestor.name}`);
+            }
+        }
+    
+        for (const call of Query.searchFrom($startNode, Call)) {
+            const paramTypes = call.function.functionType.paramTypes;
+            for (let i = 1; i < call.children.length; i++) {
+                if (call.children[i].joinPointType === "literal" && !Section7_LiteralsConstants.checkPointerConst(paramTypes[i-1])) {
+                    this.logMISRAError(call.children[i], `String literal passed as non-const qualified parameter in call of ${call.function.name}`);
+                }
+            }
+        }
+    }
+}