@specs-feup/clava-misra 1.0.0 → 1.0.2

package/src/{misra → misra-old}/sections/Section15_ControlFlow.ts

@@ -3,20 +3,20 @@ import { Program, FileJp, GotoStmt, Joinpoint, LabelStmt, Break } from "@specs-f
 import MISRAAnalyser from "../MISRAAnalyser.js";
 
 export default class Section15_ControlFlow extends MISRAAnalyser {
-    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
     
-    constructor(rules: number[]) {
+    constructor(rules?: string[]) {
         super(rules);
         this.ruleMapper = new Map([
-            [1, this.r15_1_noGoto.bind(this)],
-            [2, this.r15_2_noBackJumps.bind(this)],
-            [3, this.r15_3_gotoBlockEnclosed.bind(this)],
-            [4, this.r15_4_loopSingleBreak.bind(this)]
+            ["15.1", this.r15_1_noGoto.bind(this)],
+            ["15.2", this.r15_2_noBackJumps.bind(this)],
+            ["15.3", this.r15_3_gotoBlockEnclosed.bind(this)],
+            ["15.4", this.r15_4_loopSingleBreak.bind(this)]
         ]);
     }
 
     private r15_1_noGoto($startNode: Joinpoint) {
-        Query.searchFrom($startNode, GotoStmt).get().forEach(goto => this.logMISRAError(goto, "goto statements should not be used."), this);
+        Query.searchFrom($startNode, GotoStmt).get().forEach(goto => this.logMISRAError(this.currentRule, goto, "goto statements should not be used."), this);
 
         return [];
     }
@@ -29,7 +29,7 @@ export default class Section15_ControlFlow extends MISRAAnalyser {
     private r15_2_noBackJumps($startNode: Joinpoint) {
         for (const gotoStmt of Query.searchFrom($startNode, GotoStmt)) {
             if (!Section15_ControlFlow.isBeforeInCode(gotoStmt.line, gotoStmt.column, gotoStmt.label.line, gotoStmt.label.column)) {
-                this.logMISRAError(gotoStmt, "Back jumps using goto statements are not allowed.");
+                this.logMISRAError(this.currentRule, gotoStmt, "Back jumps using goto statements are not allowed.");
             } //maybe there is a better way?
         }
     }
@@ -55,7 +55,7 @@ export default class Section15_ControlFlow extends MISRAAnalyser {
             } while (temp.parent.astId !== ancestor.astId);
     
             if (error) {
-                this.logMISRAError(gotoStmt, `Label ${gotoStmt.label.name} is not declared in a block enclosing the goto statement.`);
+                this.logMISRAError(this.currentRule, gotoStmt, `Label ${gotoStmt.label.name} is not declared in a block enclosing the goto statement.`);
             }
         }
     }
@@ -107,7 +107,7 @@ export default class Section15_ControlFlow extends MISRAAnalyser {
     
         exits.forEach((v, k, m) => {
             if (v > 1) {
-                this.logMISRAError(nodes.get(k) as Joinpoint, "Loops should have at most one break/goto statement.")
+                this.logMISRAError(this.currentRule, nodes.get(k) as Joinpoint, "Loops should have at most one break/goto statement.")
             }
         }, this);
     }

package/src/misra-old/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<string, (jp: Program | FileJp) => void>;
+    
+    constructor(rules?: string[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            ["18.4", this.r18_4_noPointerArithmetic.bind(this)],
+            ["18.5", this.r18_5_noExcessivePointerNesting.bind(this)],
+            ["18.7", this.r18_7_noFlexibleArrayMembers.bind(this)],
+            ["18.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(this.currentRule, 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(this.currentRule, decl, `Return type of function pointer ${decl.code} has more than two levels of indirection.`);
+                }
+                if (paramDepths.length > 0) {
+                    this.logMISRAError(this.currentRule, decl, `One or more parameters of function pointer ${decl.code} have more than two levels of indirection.`);
+                }
+            }
+            if (depth > 2) {
+                this.logMISRAError(this.currentRule, 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(this.currentRule, fun, `Return type of function ${fun.signature} has more than two levels of indirection.`);
+            }
+            if (paramDepths.length > 0) {
+                this.logMISRAError(this.currentRule, 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(this.currentRule, 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(this.currentRule, varDecl, `Array ${varDecl.name} has variable or undefined size.`);
+            }
+        }
+    }
+}

package/src/{misra → misra-old}/sections/Section19_OverlappingStorage.ts

@@ -3,16 +3,16 @@ import { Program, FileJp, Joinpoint, Class } from "@specs-feup/clava/api/Joinpoi
 import MISRAAnalyser from "../MISRAAnalyser.js";
 
 export default class Section19_OverlappingStorage extends MISRAAnalyser {
-    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
 
-    constructor(rules: number[]) {
+    constructor(rules?: string[]) {
         super(rules);
         this.ruleMapper = new Map([
-            [2, this.r19_2_noUnion.bind(this)]
+            ["19.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);
+        Query.searchFrom($startNode, Class, {kind: "union"}).get().forEach(union => this.logMISRAError(this.currentRule, union, "The union keyword should not be used."), this);
     }
 }

package/src/misra-old/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<string, (jp: Program | FileJp) => void>;
+
+    constructor(rules?: string[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            ["20.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(this.currentRule, include, `Invalid characters in include for ${include.name}. Invalid characters are ', ", \\, and the sequences /* and //.`)
+            }
+        }, this);
+    }
+}

package/src/misra-old/sections/Section21_StandardLibraries.ts

@@ -0,0 +1,99 @@
+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<string, (jp: FileJp | Program) => void>;
+
+    constructor(rules?: string[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            ["21.3", this.r21_3_noDynamicAllocation.bind(this)],
+            ["21.4", this.r21_4_noSetjmpUsage.bind(this)],
+            ["21.5", this.r21_5_noSignalUsage.bind(this)],
+            ["21.6", this.r21_6_noStandardIO.bind(this)],
+            ["21.7", this.r21_7_noStringFunctions.bind(this)],
+            ["21.8", this.r21_8_noSysFunctions.bind(this)],
+            ["21.9", this.r21_9_noStdAlgos.bind(this)],
+            ["21.10", this.r21_10_noDateUsage.bind(this)],
+            ["21.11", this.r21_11_noTgmathUsage.bind(this)],
+            ["21.12", this.r21_12_noFenvExceptions.bind(this)]
+        ]);
+    }
+    
+    private r21_3_noDynamicAllocation($startNode: Joinpoint) {
+        const calls = Query.searchFrom($startNode, Call, {name: /(malloc|realloc|calloc|free)/}).get();
+        for (const call of calls) {
+            this.logMISRAError(this.currentRule, call, "Use of memory allocation functions provided by <stdlib.h> is not allowed.");
+        }
+    }
+    
+    private r21_4_noSetjmpUsage($startNode: Joinpoint) {
+        const includes = Query.searchFrom($startNode, Include, {name: "setjmp.h", isAngled: true}).get();
+        for (const include of includes) {
+            this.logMISRAError(this.currentRule, include, "Use of <setjmp.h> is not allowed.");
+        }
+    }
+    
+    private r21_5_noSignalUsage($startNode: Joinpoint) {
+        const includes = Query.searchFrom($startNode, Include, {name: "signal.h", isAngled: true}).get();
+        for (const include of includes) {
+            this.logMISRAError(this.currentRule, include, "Use of <signal.h> is not allowed.");
+        }
+    }
+    
+    private r21_6_noStandardIO($startNode: Joinpoint) {
+        const includes = Query.searchFrom($startNode, Include, {name: /(stdio.h|wchar.h)/}).get();
+        for (const include of includes) {
+            this.logMISRAError(this.currentRule, include, "Use of the standard library I/O functions provided by <stdio.h> and <wchar.h> is not allowed.");
+        }
+    }
+    
+    private r21_7_noStringFunctions($startNode: Joinpoint) {
+        const calls = Query.searchFrom($startNode, Call, {name: /(atoi|atof|atol|atoll)/}).get();
+        for (const call of calls) {
+            this.logMISRAError(this.currentRule, call, `Use of function ${call.signature} is not allowed.`);
+        }
+    }
+    
+    private r21_8_noSysFunctions($startNode: Joinpoint) {
+        const calls = Query.searchFrom($startNode, Call, {name: /(system|abort|exit|getenv)/}).get();
+        for (const call of calls) {
+            this.logMISRAError(this.currentRule, call, `Use of function ${call.signature} is not allowed.`);
+        }
+    }
+    
+    private r21_9_noStdAlgos($startNode: Joinpoint) {
+        const calls = Query.searchFrom($startNode, Call, {name: /(qsort|bsearch)/}).get();
+        for (const call of calls) {
+            this.logMISRAError(this.currentRule, call, `Use of function ${call.signature} is not allowed.`);
+        }
+    }
+    
+    private r21_10_noDateUsage($startNode: Joinpoint) {
+        const includes = Query.searchFrom($startNode, Include, {name: "time.h", isAngled: true}).get();
+        for (const include of includes) {
+            this.logMISRAError(this.currentRule, include, "Use of <time.h> is not allowed.");
+        }
+        const calls = Query.searchFrom($startNode, Call, {name: "wcsftime"}).get();
+        for (const call of calls) {
+            this.logMISRAError(this.currentRule, call, "Identifier 'wcsftime' shall not be used.");
+        }
+    }
+    
+    private r21_11_noTgmathUsage($startNode: Joinpoint) {
+        const includes = Query.searchFrom($startNode, Include, {name: "tgmath.h", isAngled: true}).get();
+        for (const include of includes) {
+            this.logMISRAError(this.currentRule, include, "Use of <tgmath.h> is not allowed.");
+        }
+    }
+    
+    private r21_12_noFenvExceptions($startNode: Joinpoint) {
+        const calls = Query.searchFrom($startNode, Call, {name: /(feclearexcept|fegetexceptflag|feraiseexcept|fesetexceptflag|fetestexcept)/}).get();
+        for (const call of calls) {
+            this.logMISRAError(this.currentRule, call, `Use of function ${call.signature} is not allowed.`);
+        }
+    }
+    
+    
+}

package/src/{misra → misra-old}/sections/Section5_Identifiers.ts

@@ -4,15 +4,15 @@ 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>;
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
 
-    constructor(rules: number[]) {
+    constructor(rules?: string[]) {
         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)]
+            ["5.1", this.r5_1_externalIdentifierLength.bind(this)],
+            ["5.6", this.r5_6_uniqueTypedefs.bind(this)],
+            ["5.7", this.r5_7_uniqueTags.bind(this)],
+            ["5.8", this.r5_8_uniqueExternalIds.bind(this)]
         ]);
     }
 
@@ -25,7 +25,7 @@ export default class Section5_Identifiers extends MISRAAnalyser {
         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) => {
+                    this.logMISRAError(this.currentRule, vardecl, `External identifier ${vardecl.name} is not distinct.`, new Fix(vardecl, ($jp) => {
                         ($jp as Vardecl).name = "a_" + ($jp as Vardecl).name;
                     }));
                 }
@@ -38,7 +38,7 @@ export default class Section5_Identifiers extends MISRAAnalyser {
         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) => {
+                    this.logMISRAError(this.currentRule, fun, `External identifier ${fun.name} is not distinct.`, new Fix(fun, ($jp) => {
                         ($jp as FunctionJp).name = "a_" + ($jp as FunctionJp).name;
                     }));
                 }
@@ -54,7 +54,7 @@ export default class Section5_Identifiers extends MISRAAnalyser {
 
         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 => {
+                this.logMISRAError(this.currentRule, 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;
                 }));
@@ -72,7 +72,7 @@ export default class Section5_Identifiers extends MISRAAnalyser {
                 }
             }
             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 => {
+                this.logMISRAError(this.currentRule, 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;
                 }));
@@ -86,7 +86,7 @@ export default class Section5_Identifiers extends MISRAAnalyser {
         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.");
+                    this.logMISRAError(this.currentRule, classJp, "Tag names must be unique across all translation units.");
                 }
                 else {
                     tags.add(classJp.type.name);
@@ -97,7 +97,7 @@ export default class Section5_Identifiers extends MISRAAnalyser {
         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.");
+                    this.logMISRAError(this.currentRule, enumDecl, "Tag names must be unique across all translation units.");
                 }
                 else {
                     tags.add(enumDecl.type.name);
@@ -114,7 +114,7 @@ export default class Section5_Identifiers extends MISRAAnalyser {
             }
             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 => {
+                this.logMISRAError(this.currentRule, 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;
                 }));
@@ -124,9 +124,10 @@ export default class Section5_Identifiers extends MISRAAnalyser {
 
     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) => {
+                    this.logMISRAError(this.currentRule, 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;
                     }));
                 }
@@ -137,7 +138,7 @@ export default class Section5_Identifiers extends MISRAAnalyser {
 
         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) => {
+                this.logMISRAError(this.currentRule, 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;
                 }));
             }

package/src/{misra → misra-old}/sections/Section6_Types.ts

@@ -3,12 +3,12 @@ import { Program, FileJp, Joinpoint, Field, IntLiteral, BuiltinType } from "@spe
 import MISRAAnalyser from "../MISRAAnalyser.js";
 
 export default class Section6_Types extends MISRAAnalyser {
-    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
 
-    constructor(rules: number[]) {
+    constructor(rules?: string[]) {
         super(rules);
         this.ruleMapper = new Map([
-            [2, this.r6_2_noSingleBitSignedFields.bind(this)],
+            ["6.2", this.r6_2_noSingleBitSignedFields.bind(this)],
 
         ]);
     }
@@ -18,7 +18,7 @@ export default class Section6_Types extends MISRAAnalyser {
             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.logMISRAError(this.currentRule, field, `Single-bit named bit field ${field.name} must not have a signed type.`);
                 }
             }
         }, this);

package/src/misra-old/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<string, (jp: Program | FileJp) => void>;
+
+    constructor(rules?: string[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            ["7.1", this.r7_1_noOctalConstants.bind(this)],
+            ["7.3", this.r7_3_noLowercaseLSuffix.bind(this)],
+            ["7.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(this.currentRule, 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(this.currentRule, 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(this.currentRule, 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(this.currentRule, 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(this.currentRule, 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(this.currentRule, call.children[i], `String literal passed as non-const qualified parameter in call of ${call.function.name}`);
+                }
+            }
+        }
+    }
+}

package/src/misra-old/sections/Section8_DeclarationsDefinitions.ts

@@ -0,0 +1,133 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, Param, FunctionJp, StorageClass, Vardecl, EnumDecl, IntLiteral, Joinpoint, DeclStmt, Varref } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+
+export default class Section8_DeclarationsDefinitions extends MISRAAnalyser {
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
+    
+    constructor(rules?: string[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            ["8.2", this.r8_2_functionPrototype.bind(this)],
+            ["8.3", this.r8_3_compatibleDefinitions.bind(this)],
+            ["8.7", this.r8_7_noUnnecessaryExternalLinkage.bind(this)],
+            ["8.10", this.r8_10_onlyStaticInline.bind(this)],
+            ["8.11", this.r8_11_externArrayExplicitSize.bind(this)],
+            ["8.12", this.r8_12_implicitExplicitEnumMatching.bind(this)]
+        ]);
+    }
+
+    private r8_2_functionPrototype($startNode: Joinpoint) { //needs to apply to function pointers, void info lost
+        Query.searchFrom($startNode, Param).get().filter(param => !param.name)
+            .forEach(param => this.logMISRAError(this.currentRule, param, `Parameter of type ${param.type.code} lacks a name.`), this);
+    }
+
+    private r8_3_compatibleDefinitions($startNode: Joinpoint) { //what if no impl?
+        Query.searchFrom($startNode, FunctionJp, {isImplementation: true}).get().forEach(fun => {
+            fun.declarationJps.forEach(decl => {
+                for (let i = 0; i < fun.params.length; i++) {
+                    if (fun.paramNames[i] !== decl.paramNames[i]) {
+                        this.logMISRAError(this.currentRule, fun, `Mismatch in name of parameters with declaration on ${decl.filename}@${decl.line}:${decl.column}.`);
+                    }
+                    if (fun.params[i].type.code !== decl.params[i].type.code) {
+                        this.logMISRAError(this.currentRule, fun, `Mismatch in parameter types with declaration on ${decl.filename}@${decl.line}:${decl.column}`);
+                    }
+                }
+            }, this);
+        }, this);
+    }
+
+    private static hasExternalLinkage(jp: FunctionJp | Vardecl) {
+        return jp.storageClass !== StorageClass.STATIC && jp.storageClass !== StorageClass.EXTERN;
+    }
+
+    private r8_7_noUnnecessaryExternalLinkage($startNode: Joinpoint) { //finish
+        const globals = new Map();
+    
+        Query.searchFrom($startNode, FileJp).get().forEach(file => {
+            file.children.forEach(jp => {
+                if (jp instanceof FunctionJp && jp.name !== "main" && Section8_DeclarationsDefinitions.hasExternalLinkage(jp)) {
+                    let hasExternals = false;
+                    jp.calls.forEach(call => {
+                        if (call.filename !== jp.filename) {
+                            hasExternals = true;
+                        }
+                    }, this);
+                    if (!hasExternals) {
+                        this.logMISRAError(this.currentRule, jp, `Function ${jp.name} has external linkage but it is only referenced in its file.`);
+                    }
+                }
+    
+                if (jp instanceof DeclStmt) {
+                    jp.decls.filter(decl => decl instanceof Vardecl && Section8_DeclarationsDefinitions.hasExternalLinkage(decl)).forEach(decl => {
+                        //globals.push({decl: decl as Vardecl, file: decl.filename});
+                        globals.set(decl.astId, {decl: decl as Vardecl, file: decl.filename});
+                    }, this);
+                }
+            });
+        }, this);
+
+        Query.searchFrom($startNode, Varref).get().forEach(ref => {
+            if (globals.has(ref.astId)) {
+                const declFile = globals.get(ref.astId).file;
+                if (declFile !== ref.filename) {
+                    globals.delete(ref.astId);
+                }
+            }
+        }, this);
+
+        globals.forEach((v, k, m) => {
+            this.logMISRAError(this.currentRule, v.decl, `Variable ${v.decl.name} is declared with external linkage but is not referenced outside its file.`);
+        }, this);
+    }
+
+    private r8_10_onlyStaticInline($startNode: Joinpoint) {
+        Query.searchFrom($startNode, FunctionJp, {isInline: true}).get().forEach(fun => {
+            if (fun.storageClass !== StorageClass.STATIC) {
+                this.logMISRAError(this.currentRule, fun, "Inline functions must always be declared static.");
+            }
+        });
+    }
+
+    private r8_11_externArrayExplicitSize($startNode: Joinpoint) {
+        for (const varDecl of Query.searchFrom($startNode, Vardecl, {storageClass: StorageClass.EXTERN})) {
+            if (varDecl.type.isArray && varDecl.type.arraySize === -1) {
+                this.logMISRAError(this.currentRule, varDecl, `Size of external array ${varDecl.name} is not explicit.`)
+            }
+        }
+    }
+
+    private setEnumMap(map: Map<number, boolean>, newValue: number, isExplicit: boolean, jp: EnumDecl) {
+        if (map.has(newValue) && !(isExplicit && map.get(newValue))) {
+            this.logMISRAError(this.currentRule, jp, `An implicitly numbered identifier in enum ${jp.name} shares a value with another identifier.`, new Fix(jp, jp => {
+                
+            }));
+        }
+        map.set(newValue, isExplicit);
+    }
+    
+    private r8_12_implicitExplicitEnumMatching($startNode: Joinpoint) {
+        for (const enumDecl of Query.searchFrom($startNode, EnumDecl)) {
+            const map = new Map();
+    
+            let index = 0;
+            for (const enumerator of enumDecl.enumerators) {
+                if (enumerator.children.length > 0) {
+                    if (enumerator.children[0].children[0] instanceof IntLiteral) {
+                        index = Number(enumerator.children[0].children[0].value);
+                        this.setEnumMap(map, index, true, enumDecl);
+                    }
+                    else {
+                        console.log(`Warning! Could not analyse the entirety of enum ${enumDecl.name} due to non-constant expressions`);
+                        return;
+                    }
+                }
+                else {
+                    this.setEnumMap(map, index, false, enumDecl);
+                }
+                index++;
+            }
+        }
+    }
+}