diff --git a/src/test/resources/com/absint/astree/report-24.10.xml b/src/test/resources/com/absint/astree/report-24.10.xml new file mode 100644 index 0000000..d4e9fcf --- /dev/null +++ b/src/test/resources/com/absint/astree/report-24.10.xml @@ -0,0 +1,2323 @@ + + + + + + + + + + + + + 11 Nov 2024 14:03:23 +0100 + 11 Nov 2024 14:03:26 +0100 + + + + + + 4 + 4 + 4 + 1 + 1 + 8 + 4 + 4 + 4 + 4 + 8 + 8 + 4 + 2 + no + no + no + no + no + no + no + no + no + no + no + no + no + no + signed + 8 + 8 + unsigned short + unsigned int + unsigned + big + unsigned + int + long long int + long int + 0 + + + + long int + all + int + long unsigned int + 4 + 4 + 4 + 1 + 8 + 4 + 4 + 4 + 4 + 8 + 8 + 4 + 2 + int + int + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + __ASTREE_volatile_input((SPEED_SENSOR; [0, 40000])); + __ASTREE_volatile_input((vx; [-1, 1])); + __ASTREE_volatile_input((vy; [-1, 1])); + __ASTREE_assert((0 <= msgId && msgId <= 99)); + __ASTREE_assert((0 <= msgId && msgId <= 99)); + __ASTREE_assert((-2 <= z && z <= 2)); + __ASTREE_volatile_input((select; [4, 5])); + __ASTREE_assert((seconds == 600)); + __ASTREE_volatile_input((rand)); + __ASTREE_modify((table2[]; [-1000, 1000])); + __ASTREE_modify((input; [-10000, 10000])); + __ASTREE_import(()); + __ASTREE_log_vars((result; inter)); + __ASTREE_log_vars((result; inter)); + __ASTREE_log_vars((result; inter)); + __ASTREE_unroll((6000)) + __ASTREE_log_vars((seconds; inter)); + + + + + conversion between two incompatible pointer types: from <RecordType *> (aka <struct Record *>) to <char *> + ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11) + + + conversion between two incompatible pointer types: from <struct Record *> to <char *> + ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11) + + + conversion between two incompatible pointer types: from <struct Record *> to <RecordPtr *> (aka <struct Record **>) + ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11) + + + conversion between two incompatible pointer types: from <struct Record *> to <char *> + ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11) + + + conversion between two incompatible pointer types: from <RecordType *> (aka <struct Record *>) to <char *> + ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11) + + + ALARM (A) conversion_overflow_unpredictable: [0, 40000] not included in double->signed short conversion range [-32768, 32767] + + + ALARM (A) uninitialized_variable_use: reading 4 byte(s) at offset(s) 0 in variable uninitialized_1 + + + ALARM (A) array_out_of_bounds: {10} not included in array index range [0, 9] + + + ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context + + + ALARM (A) uninitialized_variable_use: reading 4 byte(s) at offset(s) 0 in variable uninitialized_2 + + + ALARM (A) overflow_upon_dereference: dereferencing 1 byte(s) at offset(s) 10 may overflow the variable ArrayBlock of byte-size 10 + + + ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context + + + ALARM (A) assert_failure: assertion failed + + + ALARM (A) uninitialized_variable_use: reading 4 byte(s) at offset(s) 0 in variable i + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (A) arithmetic_overflow_unpredictable: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647] + + + ALARM (D) infinite_loop: loop never terminates for this context + + + ALARM (D) control_flow_anomaly: call to basic_examples never returns in this context + + + ALARM (D) infinite_loop: loop never terminates for this context + + + ALARM (D) control_flow_anomaly: call to loop_with_filter never returns in this context + + + ALARM (A) int_division_by_zero: divisor in {0} + + + ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context + + + ALARM (A) int_division_by_zero: divisor in {0} + + + ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context + + + ALARM (A) int_division_by_zero: divisor in {0} + + + ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context + + + ALARM (D) unbounded_loop: loop may not terminate + + + ALARM (D) unbounded_loop: loop may not terminate + + + + + memcpy_x(&((*(PtrParIn->PtrComp))), &(*PtrGlb), sizeof((*(PtrParIn->PtrComp)))); + ~~~~~~~~~~ + + + memcpy_x(&((*(PtrParIn->PtrComp))), &(*PtrGlb), sizeof((*(PtrParIn->PtrComp)))); + ~~~~~~~~~~~~~~~~~~~~~~~~~ + + + Proc3((*(PtrParIn->PtrComp)).PtrComp); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + + memcpy_x(&(*PtrParIn), &((*(PtrParIn->PtrComp))), sizeof(*PtrParIn)); + ~~~~~~~~~~~~~~~~~~~~~~~~~ + + + memcpy_x(&(*PtrParIn), &((*(PtrParIn->PtrComp))), sizeof(*PtrParIn)); + ~~~~~~~~~~~~ + + + s = SPEED_SENSOR; + ~~~~~~~~~~~~~~~~ + + + if (uninitialized_1) { + ~~~~~~~~~~~~~~~ + + + ArrayBlock[i] = i; + ~ + + + ArrayBlock[i] = i; + ~~~~~~~~~~~~~~~~~ + + + if (uninitialized_2) { + ~~~~~~~~~~~~~~~ + + + *ptr++=i; + ~~~~~~ + + + *ptr++=i; + ~~~~~~~~ + + + __ASTREE_assert(( seconds == 600 )); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + + i++; + ~ + + + i++; + ~~~ + + + while (i++) { + ~~~~~ + + + basic_examples(); + ~~~~~~~~~~~~~~~~ + + + while (1) { + ~~~~~ + + + loop_with_filter(); + ~~~~~~~~~~~~~~~~~~ + + + IntLoc = IntParI1/0; + ~~~~~~~~~~ + + + IntLoc = IntParI1/0; + ~~~~~~~~~~~~~~~~~~~ + + + while (0 != SPEED_SENSOR) { + ~~~~~ + + + while (1) { + ~~~~~ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Failed coding rule checks + Invalid usage of pointers and arrays + Invalid shift argument + Invalid ranges and overflows + Division or modulo by zero + Failed or invalid directives + Invalid function calls + Uninitialized variables + Data and control flow alarms + Invalid concurrent behavior + Errors + + + Assignment + Backjump + Bitfield signed size + Bitop recast + Bitop type + Boolean invariant expression + Case clause + Cast pointer void + Comma operator + Compound ifelse + Compound loop + Compound switch + Dangling elsegroup + Defined generation + Define in block + Definition duplicate + Embedded directive + Enum definition + Expression result unused + External file spreading + Extra tokens + Error information unused + Float bits from pointer + Float comparison + Floating point loop counter + Function ellipsis + Function local declarator + Function name usage + Function pointer cast + Function return unused + Goto nesting + Hash macro multiple + Hash macro + Identifier unique tag + Identifier unique typedef + Include characters + Include characters backslash + Include characters sline + Include errno + Include guard missing + Include position + Include setjmp + Include signal + Include stdio + Include syntax + Include time + Initializer complete strict + Initializer shape + Integer suffix + Integral type name + Keyword override + Logop side effect + Long suffix + Loop counter modification + Loop termination + Loose asm + Macro function like + Macro parameter parentheses + Macro undefined + Missing else + Mmline comment + Multiple loop counters + Non directive + Non standard escape sequence + Null statement + Numeric char usage + Octal constant + Octal escape sequence + Offsetof + Parameter name match + Plain char operator + Plain char usage + Pointer arithmetic + Pointer depth + Pointer qualifier cast const + Pointer qualifier cast volatile + Pragma usage + Precedence + Reserved identifier + Return implicit + Return position + Return reference local + Shift width constant + Sizeof + Stdlib use + Stdlib use alloc + Stdlib use ato + Stdlib use getenv + Stdlib use system + Switch clause break + Switch skipped code + Switch label + Static function declaration + Trigraph + Type compatibility + Unary assign separation + Unclosed ifgroup + Undef + Undefined extern + Underlying minus + Union + Union assignment + Union object + Unused internal variable + Unused label + Unused local variable + Unused parameter + Unsigned suffix + Float suffix + Alignof side effect + Alloc without cast + Alloc without sizeof + Alignof void + Analysis run + Array index range constant + Array index range + Array index + Incompatible function pointer conversion + Incompatible object pointer conversion + Array initialization + Array parameter static size + Array size designator + Array size external + Array size global + Array size + Assembler + Assignment boolean + Assignment conditional + Assignment overlapping + Assignment to non modifiable lvalue + At location + Attribute + Bad function + Binary constant + Bitfield name max length + Bitfield name min length + Bitfield name + Bitfield type + Bitfield typing + Bitfield + Boolean control + Boolean invariant + Boolean operation + Boolean switch + Break in loop + Breaks in loop + Cast float implicit + Cast float + Cast implicit + Cast integer implicit + Cast integer + Cast pointer incomplete + Cast pointer void arithmetic implicit + Cast pointer void arithmetic + Chained comparison + Char sign conversion + Character set + Composite assign + Composite cast + Composite type width + Compound alignment + Compound brace alignment + Compound indentation + Conditional macro + Conditional + Const parameter + Constant expression extended + Constant expression wrap around + Continue + Controlling invariant expression + Controlling invariant + Counter manipulation + Ctype limits + Defined usage + Defined + Digraph + Directive syntax + Distinct extern + Distinct identifier hidden + Distinct identifiers macros + Distinct label + Distinct macro parameter + Distinct macro + Distinct member + Distinct ordinary + Distinct tags + Double lvalue assignment + Else if + Empty body + Encoding mismatch + Empty parameter list + Enum implicit value + Enum tag max length + Enum tag min length + Enum tag spelling + Enum + Enumeration constant name max length + Enumeration constant name min length + Enumeration constant name + Errno reset + Error information unused computed + Escape termination + Essential arithmetic conversion + Essential shift width constant + Essential shift width + Essential type assign + Essentially boolean switch + Evaluation order initializer + Evaluation order + Excessive interval + Expanded hash parameter + Explicit cast overflow + Expression statement dead + Extern function declaration + Extern object declaration + Extern + External redeclaration + Field overflow upon dereference + File dereference + Filename + Flexible array member assignment + Flexible array member declaration + Float division by zero + For loop condition sideeffect + For loop control + For loop expression type + For loop float + Forward declared enum + Function body order + Function body size + Function like macro name max length + Function like macro name min length + Function like macro name + Function name length + Function parameter name max length + Function parameter name min length + Function parameter name + Function name constant comparison + Function pointer integer cast implicit + Function pointer integer cast + Function pointer + Function prototype + Function return type + Function type mismatch + Future library use + Generic selection side effect + Global function name max length + Global function name min length + Global function name + Global object name max length + Global object name min length + Global object name + Global object name const + Global object scope + Global variable + Goto + Has include + Has include next + Hash macro order + Header definition + Hexadecimal escape sequence + Identifier hidden + Identifier significance + Identifier unique extern + Identifier unique extern relaxed + Identifier unique macro + Identifier unique + Identifier unique relaxed + If condition lvalue + If value + Ifgroup + Implicit designation + Implicit function declaration + Implicit zero comparison + Inappropriate bool + Inappropriate cast + Inappropriate char usage + Inappropriate char + Inappropriate enum + Inappropriate int + Inappropriate pointer cast implicit + Inappropriate pointer cast + Include assert + Include file extension + Include malloc + Include next + Include relative + Include stdarg + Incompatible argument type + Indentation level + Infinite loop + Initializer complete + Initializer excess + Initializer exists + Initializer multiple + Inline static + Inline + Int division by zero + Int modulo by zero + Integer overflow + Integral type name extended + Invalid array size + Invalid directive + Invalid free + Invalid pointer init + Invalid pointer return + Invalid usage of os service + Jump in switch + Label in switch + Label reuse + Language override + Language undefine + Line comment + Literal assignment + Local object name max length + Local object name min length + Local object name + Local object name const + Local object scope + Local static + Logical expression alignment + Logical operators + Logop primary operand + Lvalue cast + Macro argument hash + Macro expansion + Macro final semicolon + Macro identifier length + Macro identifier reuse + Macro parameter match + Macro parameter multiplied + Macro parameter unparenthesized expression + Macro parameter unused + Macro unparenthesized + Malloc size insufficient + Max arguments macro + Max case labels + Max condition nesting + Maximum control nesting depth + Maximum control nesting depth ('else if' is one level) + Maximum cyclomatic complexity + Max declarator depth + Max declarator nesting + Max enums + Max expression nesting + Max externals + Maximum number of goto statements + Max include nesting + Maximum number of instructions + Maximum language scope + Max locals + Maximum number of local variables + Max logical line length + Max macros defined + Maximum number of maintainable code lines + Max members + Maximum number of called functions + Maximum number of functions calling a function + Maximum number of execution paths + Maximum number of recursive paths in the call graph + Max parameters macro + Maximum number of parameters + Maximum number of return statements + Maximum size of statement + Max statement nesting + Max string length + Max struct nesting + Member name reuse + Memcmp argument types + Memcmp on string + Memcmp with float + Memcmp with padding + Memcpy overlapping + Memory function compatible + Minimum Comment Density - HIS Definition + Minimum comment density + Minimum cyclomatic complexity + Minimum number of instructions + Minimum number of functions calling a function + Missing else strict + Multi character constant + Multiple atomic accesses + Multiple include + Multiple volatile accesses + Multiple writes in full expr + Named declaration parameter + Namespace overlap + No whitespace after prefix + No whitespace before postfix + Non standard identifier + Non standard keyword + Null dereferencing + Null pointer constant + Null statement strict + Object like macro name max length + Object like macro name min length + Object like macro name + Object pointer cast + Object pointer diff cast implicit + Object pointer diff cast strict implicit + Object pointer diff cast strict + Object pointer diff cast + Object type mismatch + Overflow upon dereference + Overlong line + Overlong src line + Parameter assignment + Parameter match computed + Parameter match type + Parameter match + Parameter missing const + Parameter name + Parameters + Pointer attribute + Pointer cast alignment + Pointer cast + Pointer comparison + Pointer counting + Pointer integral cast implicit + Pointer integral cast + Pointer qualifier cast const implicit + Pointer qualifier cast volatile implicit + Pointer subscript + Pointer subtraction + Pointer to pointer + Pointer typedef + Pointered deallocation + Pragma + Precision shift width constant + Precision shift width + Preprocessor wrap around + Promoted bitop type + Read data race + Recursion + Redeclaration + Reserved declaration + Restrict + Return empty + Return value + Scaled pointer arithmetic + Shift width + Side effect in initializer list + Side effect in logical exp + Signal handler shared access + Signal handler signal call + Signal handler unsafe call + Simple escape sequence + Sizeof array parameter + Sizeof non object + Sizeof parenthesized + Sizeof void + Sline comment + Sline splicing + Smline comment + Statement expression + Statement line + Statement sideeffect + Statement whitespace + Static assert + Static function name max length + Static function name min length + Static function name + Static identifier reuse + Static object declaration + Static object name max length + Static object name min length + Static object name + Static object name const + Stdlib const pointer assign + Stdlib limits + Stdlib macro alloc + Stdlib macro ato + Stdlib macro atoll + Stdlib macro compar + Stdlib macro getenv + Stdlib macro stdio + Stdlib macro wchar + Stdlib macro + Stdlib use atoll + Stdlib use compar + Stdlib use fenv + Stdlib use rand + Stdlib use signal + Stdlib use wchar + Stream argument with side effects + String literal modification + Struct member name max length + Struct member name min length + Struct member name + Struct tag max length + Struct tag min length + Struct tag spelling + Struct type incomplete + Struct typedef name max length + Struct typedef name min length + Struct typedef name + Switch clause count + Switch clause empty compound + Switch clause empty + Switch clause syntax + Switch clauses + Switch default position + Switch default + Switch enum default + Switch final default + Switch in switch + Switch multiple default + Tabulator + Type compatibility link + Type specifier + Typedef name max length + Typedef name min length + Typedef name + Unary assign detachment + Unary minus + Undeclared parameter + Uninitialized local read + Uninitialized variable use + Union member name max length + Union member name min length + Union member name + Union tag max length + Union tag min length + Union tag spelling + Union typedef name max length + Union typedef name min length + Union typedef name + Universal character name + Universal character name concatenation + Unnamed constant + Unreachable code + Unsupported language feature + Unsupported language feature fatal + Unused macro + Unused tag + Unused typedef + Variable array length + Variable name length + Wcsftime + Whitespaces around binary + Whitespaces around function call + Wide narrow string cast implicit + Wide narrow string cast + Write data race + Write to constant memory + Write to string literal + Literal assignment type + Header filename + Implementation filename + Bad macro expansion + Register + Bad include + Hexadecimal lower case digit + Local static object name + Local static object name const + Macro parameter unparenthesized expression strict + Non constant static assert + Composite cast width + Switch clause break continue + Switch clause break return + Clang warning + Annotation insertion failed + Conflicting absolute addresses + Missing rulechecking phases + Unused suppress directives + Ignored volatile + Empty struct + Return non empty + Pointer arithmetic void + Expression statement pure + Flexible array member + Enumerator value + Alignas extended + Packed specifier + Unnamed parameter + Invalid noreturn + Generic selection + Noreturn + Atomic specifier + Atomic qualifier + Thread local + Alignas + Alignof + Side effect in conditional + Comma in constant expression + Local function storage class + Non empty identifier list + Parameter missing declarator + Tentative type incomplete + Hash operator + Double hash placement + Undef syntax + Local object incomplete + Unsigned bitfield promotion + Address of void + Pointer arithmetic function + Sizeof incomplete type + Invalid lvalue + Pointer arithmetic incomplete + Invalid pointer comparison + Function definition storage class + Zero sized bitfield with declarator + Element type incomplete + Initialized local variable with linkage + Function declaration with initializer + Label without statement + Constant expression extended pp + Escape sequence out of range pp + Define syntax + Unreachable code after jump + Local function typedef + Long long c90 + Temporary object modification + Array argument size + Untrusted return use + Eof small int comparison + Stdlib string size + Strcpy limits + Function documentation + Undocumented asm + Chained errno function calls + Errno test after wrong call + Closed file pointer use + Invalidated system pointer use + Write to read only stream + Simultaneous read and write stream + Dead assignment + First enumerator value + Ambiguous label + Ambiguous member + Ambiguous ordinary + Ambiguous tag + Max suppressed lines + Suppressed file + Dead initializer + Max commented lines + Commented file + Builtin function + Internal and external linkage + Config function unknown + Struct pointer not opaque + Signed bitfield promotion + Signed bitfield cast + Unsigned bitfield cast + Autosar inclusion order + Constant out of range + Invalid pointer arithmetics + Dangling pointer use + Left shift negative first argument + Undefined shift width + Offset overflow + Function pointer wrong argument count + Misaligned dereference + Function pointer incompatible return type + Invalid function pointer + Int undefined modulo + Empty initializer list + Newline eof + Bad header macro expansion + Redundant operation + Unused function + Function argument with padding + Side effect not expanded + Expanded side effect not evaluated + Expanded side effect multiplied + Mixed const qualification + Floating type name + Imprecise memcpy + Ignored partitioning + Ignored states track + Function like macro expansion + Inappropriate switch case + Unary plus + Compound brace line begin + Compound brace line end + Conditional in non header + Extern object definition in header + Extern function definition in header + Long suffix missing + Hex prefix + No whitespace around member access + No whitespace before array subscript + No whitespace after logical negation + Local record definition with initializer + Return value type + Global object declaration + Multiple decls per line + Multiple instructions per line + Loop index modification + Unary assign conflict + Unknown component + Macro function like strict + Final default clause + Legacy alarm annotation + Include guard pragma once + Generic selection outside macro + Generic selection without non default + Generic association qualified type + Generic association type + Generic selection pointer conversion + Generic selection essential type mismatch + Generic selection default position + Union bitfield member + Stdint constant macro argument + Alignas zero + Multiple alignas + Noreturn void + Qualified function type + Temporary array to pointer conversion + Bad macro use + Bad pragma use + Bad type use + Bad function use + Missing noreturn + Storage class placement + Stdbool redefine + Realloc zero + Inappropriate type tgmath + Tgmath argument type compatible + Inconsistent alignment specification + Alignment specification mismatch + Inappropriate float + Inconsistent alignment specification link + Alignment specification mismatch link + Generic selection ignores parameters + Precedence pp + Unreachable code invariant + Character constant + String literal + Member type incomplete + Unsigned bitfield promotion boolean + Signed integer demotion + Signed integer demotion in assignment + Stdint constant macro small + Atomic void + Chained designation + Atomic member access + Pointer to vla + Memory order + Thread resource storage duration + Invalid thread object use + Deadlock + Multiple atomic accesses between sequence points + Pointer qualifier cast atomic + Pointer qualifier cast atomic implicit + Enable bounds checking interfaces + No declarator in struct + Controlling invariant static + Comparison with subnormal constant + Address of volatile anonymous union member + Accessing volatile member of packed + Erroneous condition in nested loops + Erroneous min max conditional with cast + Erroneous min max if with cast + Erroneous min max conditional + Erroneous pointer arithmetic with local address + Erroneous pointer arithmetic with local address inlined + Conditional operand omitted + Invalid pointer comparison + Subtraction of invalid pointers + Arithmetics on invalid pointers + Dereference of null or invalid pointer + Possible overflow upon dereference + Incorrect field dereference + Dereference of mis-aligned pointer + Pointer to invalid or null function + Out-of-bound array access + Use of dangling pointer + Attempt to write to a constant + Invalid argument in dynamic memory allocation, free or resize + Wrong range of second shift argument + Wrong range of first shift argument + Float argument can be NaN or infinity + Offset range overflow + Overflow in arithmetic + Overflow in conversion + Overflow in conversion (with unpredictable result) + Constant out of range + Global assertion failure + Float to unsigned conversion trap + Overflow in arithmetic (with unpredictable result) + Integer division by zero + Integer modulo by zero + Undefined integer modulo + Float division by zero + Invalid memcpy/bzero/access/trash + Assertion failure + Check failure + Square root of negative number + Invalid interval + User defined alarm + Ignored recursive call + Function call with wrong number of arguments + Incompatible parameter type in a function call + Incompatible function return type + Stub invocation + Reinterpreting incompatible parameter type in a function call + Reinterpreting incompatible function return type + Use of uninitialized variables + Control flow anomaly + Reading global/static variable without explicit initializer or prior assignment + Write after write + Infinite loop + Taint sink + Spectre vulnerability + Unbounded loop + Memory leak + Invalid usage of concurrency intrinsic + Invalid usage of OS service + Read/write data race + Write/write data race + Deadlock + Other + Analysis stopped in critical context + Analysis stopped unexpectedly + Analysis ignored directive + Frontend clang + Frontend c + Frontend source + + + Two declarations that declare the same entity must be of compatible type (ISO/IEC 9899:1999 6.2.7p2) + If the size expression of an array declarator is constant, it shall have a value greater than zero (ISO/IEC 9899:1999 6.7.5.2p1) + At least one type specifier shall be given in a declaration (ISO/IEC 9899:1999 6.7.2p2) + No implicit conversion shall be performed between pointer types and integer types (ISO/IEC 9899:1999 6.5.4p3) + The number of arguments shall agree with the number of parameters (ISO/IEC 9899:1999 6.5.2.2p2) + The constant expression of a static assert shall compare unequal to zero (ISO/IEC 9899:2011 6.7.10p2) + The lvalue of a unary or binary assignment operator shall be a modifiable lvalue (ISO/IEC 9899:1999 6.5.16p2) + No initializer shall attempt to provide a value for an object not contained within the entity being initialized (ISO/IEC 9899:1999 6.7.8p2) + If an identifier has no linkage, there shall be no more than one declaration of the identifier with the same scope and in the same name space, except for tags (ISO/IEC 9899:1999 6.7p3) + Every parameter identifier in a function definition with identifier-list shall be declared (ISO/IEC 9899:1999 6.9.1p6) + A pointer type shall not be implicitly converted into an incompatible pointer type (ISO/IEC 9899:1999 6.5.16.1p1) + A return statement shall only define a return value if and only if the containing function has non-void return type (ISO/IEC 9899:2011 6.8.6.4p1) + The alignment specifier _Alignas shall only be used as specified by the C standard (ISO/IEC 9899:2011 6.7.5) + The declaration of each parameter in a function definition shall include an identifier (ISO/IEC 9899:2011 6.9.1p5) + The element type of an array shall not be an incomplete type (ISO/IEC 9899:2011 6.7.6.2p1) + A struct-declaration that does not declare an anonymous structure or anonymous union shall contain a struct-declarator-list (ISO/IEC 9899:2011 6.7.2.1p2) + Implicit function declaration shall not be used (ISO/IEC 9899:1999 6.5.1p2) + Assembler code shall be avoided (ISO/IEC 9899:1999 4p5) + Data placement at an absolute location shall be avoided (ISO/IEC 9899:1999 4p5) + Only integer constant expressions stricly conforming to the C standard shall be used (ISO/IEC 9899:1999 6.6p10) + Enums shall not be forward-declared, i.e. used as complete type before being defined (ISO/IEC 9899:1999 4p5) + Lvalue casts shall be avoided (ISO/IEC 9899:1999 4p5) + Non-standard keywords shall not be used (ISO/IEC 9899:1999 4p5) + Pointer attributes shall be avoided (ISO/IEC 9899:1999 4p5) + GCC's statement expressions shall not be used (ISO/IEC 9899:1999 4p5) + GCC's binary constants shall not be used (ISO/IEC 9899:1999 4p5) + Non-standard escape sequences shall not be used (ISO/IEC 9899:1999 6.4.4.4) + Identifiers containing characters not provided for by the C standard shall not be used (ISO/IEC 9899:1999 6.4.2.1) + The sizeof and _Alignof operator shall not be applied to type void (ISO/IEC 9899:2011 6.5.3.4p1) + GCC's #include_next directive shall not be used (ISO/IEC 9899:1999 4p5) + The include file checking macros __has_include and __has_include_next shall not be used (ISO/IEC 9899:1999 4p5) + __attribute__((...)) and __attribute((...)) shall not be used (ISO/IEC 9899:1999 4p5) + A struct type shall have at least one member (ISO/IEC 9899:1999 6.7.2.1) + Pointer arithmetic shall not be applied to pointer to incomplete type (ISO/IEC 9899:2011 6.5.6p2+3) + Enumerators shall have a value representable as an int (ISO/IEC 9899:2011 6.7.2.2p2+3) + Compiler-specific builtin functions shall not be used (ISO/IEC 9899:1999 4p5) + The compiler-specific __packed__ type specifier shall not be used (ISO/IEC 9899:1999 4p5) + The signed or unsigned integer type long long shall not be used with language version C90 + A braced initializer list shall not be empty (ISO/IEC 9899:1999 6.7.9) + Non-standard #pragma directives affecting semantics shall be avoided (ISO/IEC 9899:2011 6.10.6p1) + GCC's conditionals with omitted operands shall not be used (ISO/IEC 9899:1999 4p5) + No cast shall be performed between pointer types and integer types (ISO/IEC 9899:1999 6.3.2.3p5+6) + The value of an integer character constant containing more than one character is implementation-defined (ISO/IEC 9899:1999 6.4.4.4p10) + A bit-field shall have a type _Bool, signed int, unsigned int, or some other implementation-defined type (ISO/IEC 9899:1999 6.7.2.1) + The result of the evaluation of an expression shall not depend on the order of evaluation of subexpressions (ISO/IEC 9899:1999 6.5) + The result of the evaluation of an initializer list expression shall not depend on the order of evaluation of elements and subexpressions (ISO/IEC 9899:1999 6.7.8) + Directives are required to follow the syntax and constraints specified in the manual + Language features not supported by Astree that are discarded by the frontend should be avoided + Language features not supported by Astree should be avoided + Analyzer configuration + Illegal header inclusion order in Autosar project + Mixed const and non-const qualification on shared bytes in struct/union will be ignored by Astrée + Unknown component specification + Runtime error analysis configuration + Clang warnings + Within a translation unit, the same identifier shall not appear with both internal and external linkage (ISO/IEC 9899:2011 6.2.2p7) + + + If objects or functions are declared more than once their types shall be compatible. + If objects or functions are declared more than once their types shall be compatible. + If the size expression of an array declarator is constant, it shall have a value greater than zero. + A function definition shall comprise the return type. + Every variable declaration statement shall comprise the data type. + Conversions shall not be performed between a pointer to a function and an integer type. + An Implicit cast shall not be performed between a pointer to object type and an integral type. + The number of arguments at a function call shall match the number of parameters according to the type of the function designator. + The condition of _Static_assert shall be a constant expression. + The constant expression of a static assert (_Static_assert) shall compare unequal to zero. + The lvalue to which an assignment is applied to shall be a modifiable lvalue. + An array initializer shall not exceed the size of the object initialized. + Entities with no linkage shall not be redeclared in the same scope. + Every parameter identifier in a function definition with identifier-list shall be declared. + A (function) pointer type shall not be implicitly converted into an incompatible (function) pointer type. + An object pointer type shall not be implicitly converted into an incompatible object pointer type. + In functions with non-void return type, a return statement shall define a return value. + In functions with void return type, a return statement shall not define a return value. + The alignment specifier _Alignas shall only be used as specified by the C standard. + There shall be no unnamed parameters in function definitions. + The element type of an array shall be complete whenever the array type is specified. + A struct member declaration that does not declare an anonymous structure or anonymous union shall declare at least one member. + Functions shall not be declared implicitly. + Assembler code shall be avoided. + Data placement at an absolute address using @ notation shall be avoided. + Only strictly conforming constant expressions shall be used. + Only strictly conforming constant expressions shall be used in preprocessor directives. + Enums shall not be forward-declared. + Lvalue casts shall be avoided. + Non-standard keywords shall not be used. + Pointer attributes shall be avoided. + GCC's statement expressions shall be avoided. + GCC's binary constants shall be avoided. + Non-standard escape sequences shall not be used. + Identifiers containing characters not provided for by the C standard shall not be used. + The _Alignof operator shall not be applied to type void. + The sizeof operator shall not be applied to type void. + #include_next directives shall be avoided. + The include file checking macro __has_include shall not be used. + The include file checking macro __has_include_next shall not be used. + __attribute__((...)) and __attribute((...)) shall not be used. + A struct type shall have at least one member. + Poitner arithmetic shall not be used with pointers to void. + The value of an enumerator shall be representable as a signed int. + Compiler-specific builtin functions shall not be used. + The compiler-specific type specifier __packed__ shall not be used. + The type (unsigned) long long shall not be used in C90. + A braced initializer list shall not be empty. + Pragma directives matching the given regular expression shall not be used. + GCC's conditionals with omitted operands shall be avoided. + Conversions shall not be performed between a pointer to a function and an integer type. + A cast shall not be performed between a pointer to object type and an integral type. + Character constant containing more than one c-char. + Bitfields shall be of signed or unsigned integer type. + The value of an expression and its persistent side effects shall be the same under all evaluation orders. + The values of initializer lists shall not depend on the order of evaluation of its elements and their subexpressions. + Intervals specified in directives shall not exceed the range of values of the affected type. + Directives that do not comply with the constraints are dropped by the frontend. + #pragma directives shall only be used in the specified manner. + Unsupported language features shall not be used. + Language features that are not supported by the analyzer shall not be used. + AAL annotations shall address valid source locations. + Rule checks which depend on an analysis phase which is not active cannot be executed. + Autosar projects shall include headers from the stub library first. + One or more bytes in the object are declared both const and non-const. + Components not declared by __ASTREE_attributes directives shall not be used. + The separate function specificaion shall only refer to functions present in the project. + Memory areas declared with absolute addresses shall not partially overlap. + Warning issued by the clang frontend. + Within a translation unit, the same identifier shall not appear with both internal and external linkage. + + + Number of files + Number of function definitions + Number of source lines + Number of physical lines of code + Number of recursive paths in the call graph + Comment density + Number of function definitions + Number of source lines + Number of physical lines of code + Number of functions calling a function + Maximum number of distinct subfunctions called + Comment density (HIS) + Cyclomatic complexity + Number of goto statements + Maximum nesting of control structures + Number of local variables + Language scope + Number of maintainable code lines + Number of parameters + Maximum number of execution paths + Number of return statements + Number of instructions + +