@specs-feup/clava-misra 1.0.0

package/src/misra/passes/S15_ControlFlowPass.ts

@@ -0,0 +1,108 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRAPass from "../MISRAPass.js";
+import { PreprocessingReqs } from "../MISRAReporter.js";
+import { Break, GotoStmt, Joinpoint, LabelStmt, Loop } from "@specs-feup/clava/api/Joinpoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+
+export default class S15_ControlFlowPass extends MISRAPass {
+    protected _preprocessingReqs: PreprocessingReqs[] = [];
+    private _labelMap: Map<string, Joinpoint> | undefined;
+
+    initRuleMapper(): void {
+        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)]
+        ]);
+    }
+
+    matchJoinpoint($jp: LaraJoinPoint): boolean {
+        return $jp instanceof GotoStmt || $jp instanceof Loop;
+    }
+
+    private r15_1_noGoto($startNode: Joinpoint) {
+        if (!($startNode instanceof GotoStmt)) return;
+        this.logMISRAError("Goto statements should not be used");
+    }
+
+    private static isBeforeInCode(line1: number, col1: number, line2: number, col2: number): boolean {
+        if (line1 < line2) return true;
+        else return col1 < col2;
+    }
+
+    private r15_2_noBackJumps($startNode: Joinpoint) {
+        if (!($startNode instanceof GotoStmt)) return;
+        if (!S15_ControlFlowPass.isBeforeInCode($startNode.line, $startNode.column, $startNode.label.line, $startNode.label.column)) {
+            this.logMISRAError("Goto statements must not jump backwards in the code.");
+        } 
+    }
+
+    private computeLabelMap() {
+        this._labelMap = new Map();
+        Query.search(LabelStmt).get().forEach(stmt => this._labelMap?.set(stmt.decl.astId, stmt), this);
+    }
+
+    private r15_3_gotoBlockEnclosed($startNode: Joinpoint) { 
+        if (!($startNode instanceof GotoStmt)) return;
+        if (!this._labelMap) this.computeLabelMap();
+
+    
+        let curr = $startNode.getAncestor("scope");
+        const ancestor = $startNode.getAncestor("function");
+        let error = true;
+        let temp;
+
+        do {
+            temp = curr;
+            if (curr.children.map(n => n.astId).includes(this._labelMap?.get($startNode.label.astId)?.astId as string)) {
+                error = false;
+                break;
+            }
+            curr = curr.getAncestor("scope");
+        } while (temp.parent.astId !== ancestor.astId);
+
+        if (error) {
+            this.logMISRAError("The label of a goto statement must be declared in a block or switch clause enclosing the goto.");
+        }
+    }
+
+    private static countBreakExits($startNode: Joinpoint): number {
+        let count = 0;
+        for (const goto of Query.searchFrom($startNode, Break)) {
+            const ancestor = goto.getAncestor("loop");
+            const switchAncestor = goto.getAncestor("switch");
+            if (ancestor.astId === $startNode.astId && !(switchAncestor && $startNode.contains(switchAncestor))) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+    
+    private static countGotoExits($startNode: Joinpoint, labels: Map<string, Joinpoint>) {
+        let count = 0;
+        for (const goto of Query.searchFrom($startNode, GotoStmt)) {
+            if (!($startNode.contains(labels.get(goto.label.astId) as Joinpoint))) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    private r15_4_loopSingleBreak($startNode: Joinpoint) {
+        if (!($startNode instanceof Loop)) return;
+        if (!this._labelMap) this.computeLabelMap();
+    
+        const breakExits = S15_ControlFlowPass.countBreakExits($startNode);
+        const gotoExits = S15_ControlFlowPass.countGotoExits($startNode, this._labelMap as Map<string, Joinpoint>);
+
+        if (breakExits + gotoExits > 1) {
+            this.logMISRAError("Loops must only have one exit");
+        }
+    }
+
+    protected _name: string = "Control Flow";
+    
+}

package/src/misra/passes/S16_SwitchStatementPass.ts

@@ -0,0 +1,168 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRAPass from "../MISRAPass.js";
+import { PreprocessingReqs } from "../MISRAReporter.js";
+import { BinaryOp, Break, BuiltinType, Case, Expression, Joinpoint, Switch } from "@specs-feup/clava/api/Joinpoints.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+export default class S16_SwitchStatementPass extends MISRAPass {
+    protected _preprocessingReqs: PreprocessingReqs[] = [];
+    private _wellFormedSwitch: boolean = false;
+
+    initRuleMapper(): void {
+        this._ruleMapper = new Map([
+            [1, this.r16_1_16_3_wellFormedSwitch.bind(this)],
+            [2, this.r16_2_topLevelSwitchLabels.bind(this)],
+            [4, this.r16_4_switchHasDefault.bind(this)],
+            [5, this.r16_5_defaultFirstOrLast.bind(this)],
+            [6, this.r16_6_noTwoClauses.bind(this)],
+            [7, this.r16_7_noEssentialBooleanInSwitch.bind(this)]
+        ]);
+    }
+    
+    matchJoinpoint($jp: LaraJoinPoint): boolean {
+        return $jp instanceof Switch || $jp instanceof Case;
+    }
+
+    private r16_1_16_3_wellFormedSwitch($startNode: Joinpoint) {
+        if (!($startNode instanceof Switch)) return;
+        this._wellFormedSwitch = true;
+
+        let foundStmt = false;
+        let first = true;
+        for (const child of $startNode.children[1].children) {
+            if (child instanceof Break) {;
+                foundStmt = false;
+            }
+            else if (child instanceof Case) {
+                first = false;
+            }
+            else {
+                foundStmt = true;
+            }
+
+            if (foundStmt && child instanceof Case) {
+                this.logMISRAError(`A break is missing before ${child.code}`);
+                this._wellFormedSwitch = false;
+            }
+        }
+        if (!($startNode.children[1].lastChild instanceof Break)) {
+            this.logMISRAError("A break is missing at the end of the switch statement.");
+            this._wellFormedSwitch = false;
+        }  
+    }
+
+    private r16_2_topLevelSwitchLabels($startNode: Joinpoint) {
+        if (!($startNode instanceof Case)) return;
+
+        if (!($startNode.currentRegion instanceof Switch)) {
+            this.logMISRAError("A switch label can only be used if its enclosing compound statement is the switch statement itself.");
+        }
+    }
+
+    private r16_4_switchHasDefault($startNode: Joinpoint) {
+        if (!($startNode instanceof Switch && !$startNode.hasDefaultCase)) return;
+
+        this.logMISRAError("Switch statement is missing a default case.");
+    }
+    
+
+    private r16_5_defaultFirstOrLast($startNode: Joinpoint) {
+        if (!($startNode instanceof Switch)) return;
+
+        for (let i = 0; i < $startNode.cases.length; i++) {
+            if ($startNode.cases[i].isDefault && (i == 0 || i == $startNode.cases.length-1)) {
+                return;
+            }
+            else if ($startNode.cases[i].isDefault) {
+                this.logMISRAError("The default case of a switch statement must be the first or last label.");
+                return;
+            }
+        }
+    }
+
+    private r16_6_noTwoClauses($startNode: Joinpoint) {
+        if (!($startNode instanceof Switch)) return;
+        this.dependsOn(1, $startNode);
+        if (this._wellFormedSwitch === false) return; 
+
+        let clauses = 0;
+        for (const child of $startNode.children[1].children) {
+            if (child instanceof Break) {
+                clauses++;
+            }
+        }
+
+        if (clauses <= 2) {
+            this.logMISRAError("Switch statements should have more than two clauses.", new Fix(
+                $startNode,
+                (switchStmt: Joinpoint) => {
+                    const switchJp = switchStmt as Switch;
+                    let firstClauseExpr: Expression | undefined = undefined;
+                    let secondClauseExpr: Expression | undefined = undefined;
+                    let firstClause: Joinpoint[] = [];
+                    let secondClause: Joinpoint[] = [];
+                    let currClauseExpr: Expression | undefined = undefined;
+                    let currClause: Joinpoint[] = [];
+                    let clauseHasDefault: boolean = false;
+                    let filledFirstClause: boolean = false;
+                    const newVar = ClavaJoinPoints.varDecl("switchToIf_" + switchJp.astId, switchJp.condition);
+                    switchJp.insertBefore(newVar.stmt);
+                    for (const child of switchStmt.children[1].children) {
+                            if (child instanceof Case) {
+                                let tempOp: BinaryOp;
+                                if (child.isDefault) {
+                                    clauseHasDefault = true;
+                                    continue;
+                                }
+                                else if (child.values.length === 1) {
+                                    tempOp = ClavaJoinPoints.binaryOp("eq", newVar.varref(), child.values[0]);
+                                }
+                                else {
+                                    tempOp = ClavaJoinPoints.binaryOp("l_or", ClavaJoinPoints.binaryOp("ge", newVar.varref(), child.values[0]), ClavaJoinPoints.binaryOp("le", newVar.varref(), child.values[1]));
+                                }
+                                currClauseExpr = currClauseExpr ? ClavaJoinPoints.binaryOp("l_or", currClauseExpr, tempOp) : tempOp;
+                            }
+                            else if (child instanceof Break) {
+                                if (clauseHasDefault) {
+                                    secondClause = currClause;
+                                    secondClauseExpr = undefined;
+                                }
+                                else if (filledFirstClause) {
+                                    secondClause = currClause;
+                                    secondClauseExpr = currClauseExpr;
+                                }
+                                else {
+                                    firstClause = currClause;
+                                    firstClauseExpr = currClauseExpr;
+                                    filledFirstClause = true;
+                                }
+                                clauseHasDefault = false;
+                                currClause = [];
+                                currClauseExpr = undefined;
+                            }
+                            else {
+                                currClause.push(child);
+                            }
+                    }
+
+                    const elseStmt = secondClauseExpr ? ClavaJoinPoints.ifStmt(secondClauseExpr, ClavaJoinPoints.scope(...secondClause)) : ClavaJoinPoints.scope(...secondClause);
+                    switchJp.replaceWith(ClavaJoinPoints.ifStmt(firstClauseExpr ?? "", ClavaJoinPoints.scope(...firstClause), elseStmt));
+                }
+            ));
+        }
+    }
+
+    private r16_7_noEssentialBooleanInSwitch($startNode: Joinpoint) { //UNFINISHED, can have transformation
+        if (!($startNode instanceof Switch)) return;
+        this.dependsOn(1, $startNode);
+        if (this._wellFormedSwitch === false) return;
+
+        if ($startNode.condition.type.desugarAll instanceof BuiltinType && $startNode.condition.type.desugarAll.builtinKind === "Bool") {
+            this.logMISRAError("The controlling expression of a switch statement must not have essentially boolean type.");
+        }
+    }
+
+    protected _name: string = "Switch statements";
+
+}

package/src/misra/passes/S17_FunctionPass.ts

@@ -0,0 +1,43 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRAPass from "../MISRAPass.js";
+import { PreprocessingReqs } from "../MISRAReporter.js";
+import { BuiltinType, Call, ExprStmt, Include, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+export default class S17_FunctionPass extends MISRAPass {
+    protected _preprocessingReqs: PreprocessingReqs[] = [];
+
+    initRuleMapper(): void {
+        this._ruleMapper = new Map([
+            [1, this.r17_1_noStdargUsage.bind(this)],
+            [7, this.r17_7_returnValuesAreUsed.bind(this)]
+        ]);
+    }
+    matchJoinpoint($jp: LaraJoinPoint): boolean {
+        return $jp instanceof Include || $jp instanceof Call;
+    }
+
+    private r17_1_noStdargUsage($startNode: Joinpoint) {
+        if (!($startNode instanceof Include)) return;;
+
+        if ($startNode.name === "stdarg.h" && $startNode.isAngled) {
+            this.logMISRAError("Use of <stdarg.h> is not allowed.");
+        }
+    }
+
+    private r17_7_returnValuesAreUsed($startNode: Joinpoint) {
+        if (!($startNode instanceof Call)) return;
+        if ($startNode.returnType instanceof BuiltinType && $startNode.returnType.isVoid) return;
+
+        if ($startNode.parent instanceof ExprStmt) {
+            this.logMISRAError(`Return value of ${$startNode.signature} must be used. It can be discarded with an explicit cast to void.`, new Fix($startNode, ($jp) => {
+                const newJp = ClavaJoinPoints.cStyleCast(ClavaJoinPoints.type("void"), $jp as Call);
+                $jp.replaceWith(newJp);
+            }));
+        }
+    }
+
+    protected _name: string = "Functions";
+    
+}

package/src/misra/passes/S18_PointersArraysPass.ts

@@ -0,0 +1,126 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRAPass from "../MISRAPass.js";
+import { PreprocessingReqs } from "../MISRAReporter.js";
+import { BinaryOp, Field, FunctionJp, FunctionType, Joinpoint, Param, PointerType, QualType, Type, Vardecl } from "@specs-feup/clava/api/Joinpoints.js";
+
+export default class S18_PointersArraysPass extends MISRAPass {
+    protected _preprocessingReqs: PreprocessingReqs[] = [];
+
+    initRuleMapper(): void {
+        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)]
+        ]);
+    }
+    matchJoinpoint($jp: LaraJoinPoint): boolean {
+        return $jp instanceof BinaryOp || $jp instanceof Vardecl || $jp instanceof FunctionJp || $jp instanceof Field;
+    }
+
+    private static isPointerType($type: Type): boolean {
+        const newT = $type.desugarAll
+        if (newT instanceof QualType) {
+            return this.isPointerType(newT.unqualifiedType);
+        }
+        else return newT.isPointer;
+    }
+
+    private r18_4_noPointerArithmetic($startNode: Joinpoint) {
+        if (!($startNode instanceof BinaryOp && /(\+=)|(-=)|(\+)|(-)/.test($startNode.operator))) return;
+
+        const leftT = $startNode.left.type;
+        const rightT = $startNode.right.type;
+
+        if ((S18_PointersArraysPass.isPointerType(leftT) && !S18_PointersArraysPass.isPointerType(rightT))
+            || (S18_PointersArraysPass.isPointerType(rightT) && !S18_PointersArraysPass.isPointerType(leftT))) {
+            this.logMISRAError("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
+        if (($startNode instanceof Vardecl && !($startNode instanceof Param)) || $startNode instanceof Field) {
+            const depth = S18_PointersArraysPass.getDepth($startNode.type);
+            const underlyingType = S18_PointersArraysPass.getUnderlyingType($startNode.type);
+            if (underlyingType instanceof FunctionType) {
+                const retDepth = S18_PointersArraysPass.getDepth(underlyingType.returnType);
+                const paramDepths = underlyingType.paramTypes.map(type => S18_PointersArraysPass.getDepth(type)).filter(d => d > 2);
+                if (retDepth > 2) {
+                    this.logMISRAError(`Return type of function pointer ${$startNode.code} has more than two levels of indirection.`);
+                }
+                if (paramDepths.length > 0) {
+                    this.logMISRAError(`One or more parameters of function pointer ${$startNode.code} have more than two levels of indirection.`);
+                }
+            }
+            if (depth > 2) {
+                this.logMISRAError(`Type ${$startNode.type.code} has more than two levels of indirection.`)
+            }
+        }
+        else if ($startNode instanceof FunctionJp) {
+            const retDepth = S18_PointersArraysPass.getDepth($startNode.functionType.returnType);
+            const paramDepths = $startNode.functionType.paramTypes.map(type => S18_PointersArraysPass.getDepth(type)).filter(d => d > 2);
+            if (retDepth > 2) {
+                this.logMISRAError(`Return type of function ${$startNode.signature} has more than two levels of indirection.`);
+            }
+            if (paramDepths.length > 0) {
+                this.logMISRAError(`One or more parameters of function ${$startNode.signature} have more than two levels of indirection.`);
+            }
+        }
+    }
+
+    private r18_7_noFlexibleArrayMembers($startNode: Joinpoint) {
+        if (!($startNode instanceof Field)) return;
+        if (!$startNode.type.desugarAll.isArray || $startNode instanceof Param) return;
+
+        if ($startNode.type.desugarAll.arraySize === -1) {
+            this.logMISRAError(`Array ${$startNode.name} has variable or undefined size.`);
+        }
+    }
+
+    private r18_8_noVariableLengthArrays($startNode: Joinpoint) {
+        if (!($startNode instanceof Vardecl)) return;
+        if (!$startNode.type.desugarAll.isArray || $startNode.instanceOf("param")) return;
+
+        if ($startNode.type.desugarAll.arraySize === -1) {
+            this.logMISRAError(`Array ${$startNode.name} has variable or undefined size.`);
+        }
+    }
+
+
+    protected _name: string = "Pointers and arrays";
+    
+}

package/src/misra/passes/S19_OverlappingStoragePass.ts

@@ -0,0 +1,27 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRAPass from "../MISRAPass.js";
+import { PreprocessingReqs } from "../MISRAReporter.js";
+import { Class, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+
+export default class S19_OverlappingStoragePass extends MISRAPass {
+    protected _preprocessingReqs: PreprocessingReqs[] = [];
+
+    initRuleMapper(): void {
+        this._ruleMapper = new Map([
+            [2, this.r19_2_noUnion.bind(this)]
+        ]);
+    }
+
+    matchJoinpoint($jp: LaraJoinPoint): boolean {
+        return $jp instanceof Class;
+    }
+
+    private r19_2_noUnion($startNode: Joinpoint) {
+        if (!($startNode instanceof Class && $startNode.kind === "union")) return;
+
+        this.logMISRAError("The union keyword should not be used.");
+    }
+
+    protected _name: string = "Overlapping storage";
+    
+}

package/src/misra/passes/S21_StandardLibPass.ts

@@ -0,0 +1,92 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRAPass from "../MISRAPass.js";
+import { PreprocessingReqs } from "../MISRAReporter.js";
+import { Call, Include, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+
+export default class S21_StandardLibPass extends MISRAPass {
+    protected _preprocessingReqs: PreprocessingReqs[] = [];
+
+    initRuleMapper(): void {
+        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)]
+        ]);
+    }
+
+    matchJoinpoint($jp: LaraJoinPoint): boolean {
+        return $jp instanceof Call || $jp instanceof Include;
+    }
+
+    private r21_3_noDynamicAllocation($startNode: Joinpoint) {
+        if (!($startNode instanceof Call && /(malloc|realloc|calloc|free)/.test($startNode.name))) return;
+
+        this.logMISRAError("Use of memory allocation functions provided by <stdlib.h> is not allowed.");
+    }
+
+    private r21_4_noSetjmpUsage($startNode: Joinpoint) {
+        if (!($startNode instanceof Include && $startNode.isAngled && $startNode.name === "setjmp.h")) return;
+
+        this.logMISRAError("Use of <setjmp.h> is not allowed.");
+    }
+    
+    private r21_5_noSignalUsage($startNode: Joinpoint) {
+        if (!($startNode instanceof Include && $startNode.isAngled && $startNode.name === "signal.h")) return;
+
+        this.logMISRAError("Use of <signal.h> is not allowed.");    
+    }
+
+    private r21_6_noStandardIO($startNode: Joinpoint) {
+        if (!($startNode instanceof Include && $startNode.isAngled && /(stdio.h|wchar.h)/.test($startNode.name))) return;
+
+        this.logMISRAError("Use of the standard library I/O functions provided by <stdio.h> and <wchar.h> is not allowed.");
+    }
+
+    private r21_7_noStringFunctions($startNode: Joinpoint) {
+        if (!($startNode instanceof Call && /(atoi|atof|atol|atoll)/.test($startNode.name))) return;
+
+        this.logMISRAError(`Use of function ${$startNode.signature} is not allowed.`);
+    }
+
+    private r21_8_noSysFunctions($startNode: Joinpoint) {
+        if (!($startNode instanceof Call && /(system|abort|exit|getenv)/.test($startNode.name))) return;
+        
+        this.logMISRAError(`Use of function ${$startNode.signature} is not allowed.`);
+    }
+
+    private r21_9_noStdAlgos($startNode: Joinpoint) {
+        if (!($startNode instanceof Call && /(qsort|bsearch)/.test($startNode.name))) return;
+        
+        this.logMISRAError(`Use of function ${$startNode.signature} is not allowed.`);
+    }
+
+    private r21_10_noDateUsage($startNode: Joinpoint) {
+        if ($startNode instanceof Include && $startNode.isAngled && $startNode.name === "time.h") {
+            this.logMISRAError("Use of <time.h> is not allowed.");
+        }
+        else if ($startNode instanceof Call && $startNode.name === "wcsftime") {
+            this.logMISRAError("Identifier 'wcsftime' shall not be used.");
+        }
+    }
+    
+    private r21_11_noTgmathUsage($startNode: Joinpoint) {
+        if (!($startNode instanceof Include && $startNode.isAngled && $startNode.name === "tgmath.h")) return;
+
+        this.logMISRAError("Use of <tgmath.h> is not allowed."); 
+    }
+
+    private r21_12_noFenvExceptions($startNode: Joinpoint) {
+        if (!($startNode instanceof Call && /(feclearexcept|fegetexceptflag|feraiseexcept|fesetexceptflag|fetestexcept)/.test($startNode.name))) return;
+        
+        this.logMISRAError(`Use of function ${$startNode.signature} is not allowed.`);
+    }
+
+    protected _name: string = "Standard libraries";
+}

package/src/misra/passes/S3_CommentPass.ts

@@ -0,0 +1,40 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRAPass from "../MISRAPass.js";
+import { PreprocessingReqs } from "../MISRAReporter.js";
+import { Comment, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+
+export default class S3_CommentPass extends MISRAPass {
+    protected _preprocessingReqs: PreprocessingReqs[] = [];
+
+    initRuleMapper(): void {
+        this._ruleMapper = new Map([
+            [3, this.r3_1_fixComments.bind(this)]
+        ]);
+    }
+
+    matchJoinpoint($jp: LaraJoinPoint): boolean {
+        return true;
+    }
+
+    private static removeCommentSequences(str: string) {
+        return str.replace(/(\/\/|\/\*)/g, '');
+    }
+    
+    private r3_1_fixComments($startNode: Joinpoint) { //inlines
+        if ($startNode instanceof Comment && /(\/\/|\/\*)/g.test($startNode.text)) {
+            this.logMISRAError(`Comment ${$startNode.text} contains invalid character sequences.`, new Fix(
+                $startNode,
+                $jp => ($jp as Comment).setText(S3_CommentPass.removeCommentSequences($startNode.text))
+            ));
+        } 
+        $startNode.inlineComments.filter(comment => /(\/\/|\/\*)/g.test(comment.text)).forEach(comment => {
+            this.logMISRAError(`Comment ${comment.text} contains invalid character sequences.`, new Fix(
+                $startNode,
+                $jp => ($jp as Comment).setText(S3_CommentPass.removeCommentSequences(comment.text))
+            ));
+        });
+    }
+
+    protected _name: string = "Comments";
+}

package/src/misra/passes/S5_IdentifierPass.ts

@@ -0,0 +1,66 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRAPass from "../MISRAPass.js";
+import { PreprocessingReqs } from "../MISRAReporter.js";
+import { Class, FileJp, FunctionJp, Joinpoint, NamedDecl, StorageClass, TypedefDecl, TypedefNameDecl, Vardecl } from "@specs-feup/clava/api/Joinpoints.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+
+export default class S5_IdentifierPass extends MISRAPass {
+    protected _preprocessingReqs: PreprocessingReqs[] = [PreprocessingReqs.EXTERNAL_LINKAGE_DECLS];
+    
+    initRuleMapper(): void {
+        throw new Error("Method not implemented.");
+    }
+
+    matchJoinpoint($jp: LaraJoinPoint): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    private static hasExternalLinkage($class: StorageClass) {
+        return $class !== StorageClass.STATIC && $class !== StorageClass.EXTERN;
+    }
+
+    private r5_1_externalIdentifierLength($startNode: Joinpoint) {
+        if (!(($startNode instanceof FunctionJp || $startNode instanceof Vardecl) && $startNode.parent instanceof FileJp)) return;
+        if (!S5_IdentifierPass.hasExternalLinkage($startNode.storageClass)) return;
+
+        if (!this._preprocessing?.externalLinkageDecls) {
+            throw new Error("Preprocessing has not been initialized properly.");
+        }
+
+        if (this._preprocessing.externalLinkageDecls.filter(jp => jp.astId !== $startNode.astId).map(jp => jp.name.substring(0, 31)).includes($startNode.name.substring(0, 31))) {
+            this.logMISRAError(`Identifier ${$startNode.name} is not distinct from other external identifiers.`, new Fix($startNode, $jp => {
+                ($jp as FunctionJp || Vardecl).name = "a_" + ($jp as FunctionJp || Vardecl).name;
+            }));
+        }
+    }
+
+    private r5_6_uniqueTypedefs($startNode: Joinpoint) {
+        if (!this._preprocessing?.typedefDecls) {
+            throw new Error("Preprocessing has not been initialized properly.");
+        }
+        if ($startNode instanceof NamedDecl && !($startNode instanceof TypedefNameDecl)) {
+            if ($startNode instanceof Class) {
+                const typedefChildren = $startNode.getDescendants("typedefDecl") as TypedefDecl[];
+                for (const child of typedefChildren) {
+                    if ($startNode.name === child.name) return;
+                }
+            }
+            if (this._preprocessing.typedefDecls.some(jp => jp.name === $startNode.name)) {
+                this.logMISRAError(`${$startNode.name} is also the name of a typedef. Typedef identifiers must not be reused.`, new Fix($startNode, jp => {
+                    const declJp = jp as NamedDecl;
+                    declJp.name = declJp.name + "_" + declJp.astId;
+                }));
+            }
+        }
+        else if ($startNode instanceof TypedefNameDecl) {
+            if (this._preprocessing.typedefDecls.filter(jp => jp.astId !== $startNode.astId).some(jp => jp.name === $startNode.name)) {
+                this.logMISRAError("Typedef names must be unique across all translation units.", new Fix($startNode, jp => {
+                    const typedefJp = jp as TypedefDecl;
+                    typedefJp.name = typedefJp.name + "_" + typedefJp.astId;
+                }));
+            }
+        }
+    }
+
+    protected _name: string = "Identifiers";
+}