4744 lines
187 KiB
Python
Executable File
4744 lines
187 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
#
|
|
# MISRA C 2012 checkers
|
|
# Partially reused for "MISRA C++ 2008" checking
|
|
#
|
|
# Example usage of this addon (scan a sourcefile main.cpp)
|
|
# cppcheck --dump main.cpp
|
|
# python misra.py --rule-texts=<path-to-rule-texts> main.cpp.dump
|
|
#
|
|
# Limitations: This addon is released as open source. Rule texts can't be freely
|
|
# distributed. https://www.misra.org.uk/forum/viewtopic.php?f=56&t=1189
|
|
#
|
|
# The MISRA standard documents may be obtained from https://www.misra.org.uk
|
|
#
|
|
# Total number of rules: 143
|
|
|
|
from __future__ import print_function
|
|
|
|
import cppcheckdata
|
|
import itertools
|
|
import json
|
|
import sys
|
|
import re
|
|
import os
|
|
import argparse
|
|
import codecs
|
|
import string
|
|
import copy
|
|
|
|
try:
|
|
from itertools import izip as zip
|
|
except ImportError:
|
|
pass
|
|
|
|
import misra_9
|
|
|
|
def grouped(iterable, n):
|
|
"""s -> (s0,s1,s2,...sn-1), (sn,sn+1,sn+2,...s2n-1), (s2n,s2n+1,s2n+2,...s3n-1), ..."""
|
|
return zip(*[iter(iterable)] * n)
|
|
|
|
|
|
INT_TYPES = ['bool', 'char', 'short', 'int', 'long', 'long long']
|
|
|
|
|
|
STDINT_TYPES = ['%s%d_t' % (n, v) for n, v in itertools.product(
|
|
['int', 'uint', 'int_least', 'uint_least', 'int_fast', 'uint_fast'],
|
|
[8, 16, 32, 64])]
|
|
|
|
|
|
typeBits = {
|
|
'CHAR': None,
|
|
'SHORT': None,
|
|
'INT': None,
|
|
'LONG': None,
|
|
'LONG_LONG': None,
|
|
'POINTER': None
|
|
}
|
|
|
|
|
|
def isUnsignedType(ty):
|
|
return ty == 'unsigned' or ty.startswith('uint')
|
|
|
|
|
|
def simpleMatch(token, pattern):
|
|
return cppcheckdata.simpleMatch(token, pattern)
|
|
|
|
|
|
def rawlink(rawtoken):
|
|
if rawtoken.str == '}':
|
|
indent = 0
|
|
while rawtoken:
|
|
if rawtoken.str == '}':
|
|
indent = indent + 1
|
|
elif rawtoken.str == '{':
|
|
indent = indent - 1
|
|
if indent == 0:
|
|
break
|
|
rawtoken = rawtoken.previous
|
|
else:
|
|
rawtoken = None
|
|
return rawtoken
|
|
|
|
|
|
# Identifiers described in Section 7 "Library" of C90 Standard
|
|
# Based on ISO/IEC9899:1990 Annex D -- Library summary and
|
|
# Annex E -- Implementation limits.
|
|
C90_STDLIB_IDENTIFIERS = {
|
|
# D.1 Errors
|
|
'errno.h': ['EDOM', 'ERANGE', 'errno'],
|
|
# D.2 Common definitions
|
|
'stddef.h': ['NULL', 'offsetof', 'ptrdiff_t', 'size_t', 'wchar_t'],
|
|
# D.3 Diagnostics
|
|
'assert.h': ['NDEBUG', 'assert'],
|
|
# D.4 Character handling
|
|
'ctype.h': [
|
|
'isalnum', 'isalpha', 'isblank', 'iscntrl', 'isdigit',
|
|
'isgraph', 'islower', 'isprint', 'ispunct', 'isspace',
|
|
'isupper', 'isxdigit', 'tolower', 'toupper',
|
|
],
|
|
# D.5 Localization
|
|
'locale.h': [
|
|
'LC_ALL', 'LC_COLLATE', 'LC_CTYPE', 'LC_MONETARY',
|
|
'LC_NUMERIC', 'LC_TIME', 'NULL', 'lconv',
|
|
'setlocale', 'localeconv',
|
|
],
|
|
# D.6 Mathematics
|
|
'math.h': [
|
|
'HUGE_VAL', 'acos', 'asin' , 'atan2', 'cos', 'sin', 'tan', 'cosh',
|
|
'sinh', 'tanh', 'exp', 'frexp', 'ldexp', 'log', 'loglO', 'modf',
|
|
'pow', 'sqrt', 'ceil', 'fabs', 'floor', 'fmod',
|
|
],
|
|
# D.7 Nonlocal jumps
|
|
'setjmp.h': ['jmp_buf', 'setjmp', 'longjmp'],
|
|
# D.8 Signal handling
|
|
'signal.h': [
|
|
'sig_atomic_t', 'SIG_DFL', 'SIG_ERR', 'SIG_IGN', 'SIGABRT', 'SIGFPE',
|
|
'SIGILL', 'SIGINT', 'SIGSEGV', 'SIGTERM', 'signal', 'raise',
|
|
],
|
|
# D.9 Variable arguments
|
|
'stdarg.h': ['va_list', 'va_start', 'va_arg', 'va_end'],
|
|
# D.10 Input/output
|
|
'stdio.h': [
|
|
'_IOFBF', '_IOLBF', '_IONBF', 'BUFSIZ', 'EOF', 'FILE', 'FILENAME_MAX',
|
|
'FOPEN_MAX', 'fpos_t', 'L_tmpnam', 'NULL', 'SEEK_CUR', 'SEEK_END',
|
|
'SEEK_SET', 'size_t', 'stderr', 'stdin', 'stdout', 'TMP_MAX',
|
|
'remove', 'rename', 'tmpfile', 'tmpnam', 'fclose', 'fflush', 'fopen',
|
|
'freopen', 'setbuf', 'setvbuf', 'fprintf', 'fscanf', 'printf',
|
|
'scanf', 'sprintf', 'sscanf', 'vfprintf', 'vprintf', 'vsprintf',
|
|
'fgetc', 'fgets', 'fputc', 'fputs', 'getc', 'getchar', 'gets', 'putc',
|
|
'putchar', 'puts', 'ungetc', 'fread', 'fwrite', 'fgetpos', 'fseek',
|
|
'fsetpos', 'rewind', 'clearerr', 'feof', 'ferror', 'perror',
|
|
],
|
|
# D.11 General utilities
|
|
'stdlib.h': [
|
|
'EXIT_FAILURE', 'EXIT_SUCCESS', 'MB_CUR_MAX', 'NULL', 'RAND_MAX',
|
|
'div_t', 'ldiv_t', 'wchar_t', 'atof', 'atoi', 'strtod', 'rand',
|
|
'srand', 'calloc', 'free', 'malloc', 'realloc', 'abort', 'atexit',
|
|
'exit', 'getenv', 'system', 'bsearch', 'qsort', 'abs', 'div', 'ldiv',
|
|
'mblen', 'mbtowc', 'wctomb', 'mbstowcs', 'wcstombs',
|
|
],
|
|
# D.12 String handling
|
|
'string.h': [
|
|
'NULL', 'size_t', 'memcpy', 'memmove', 'strcpy', 'strncpy', 'strcat',
|
|
'strncat', 'memcmp', 'strcmp', 'strcoll', 'strncmp', 'strxfrm',
|
|
'memchr', 'strchr', 'strcspn', 'strpbrk', 'strrchr', 'strspn',
|
|
'strstr', 'strtok', 'memset', 'strerror', 'strlen',
|
|
],
|
|
# D.13 Date and time
|
|
'time.h': [
|
|
'CLK_TCK', 'NULL', 'clock_t', 'time_t', 'size_t', 'tm', 'clock',
|
|
'difftime', 'mktime', 'time', 'asctime', 'ctime', 'gmtime',
|
|
'localtime', 'strftime',
|
|
],
|
|
# Annex E: Implementation limits
|
|
'limits.h': [
|
|
'CHAR_BIT', 'SCHAR_MIN', 'SCHAR_MAX', 'UCHAR_MAX', 'CHAR_MIN',
|
|
'CHAR_MAX', 'MB_LEN_MAX', 'SHRT_MIN', 'SHRT_MAX', 'USHRT_MAX',
|
|
'INT_MIN', 'INT_MAX', 'UINT_MAX', 'LONG_MIN', 'LONG_MAX', 'ULONG_MAX',
|
|
],
|
|
'float.h': [
|
|
'FLT_ROUNDS', 'FLT_RADIX', 'FLT_MANT_DIG', 'DBL_MANT_DIG',
|
|
'LDBL_MANT_DIG', 'DECIMAL_DIG', 'FLT_DIG', 'DBL_DIG', 'LDBL_DIG',
|
|
'DBL_MIN_EXP', 'LDBL_MIN_EXP', 'FLT_MIN_10_EXP', 'DBL_MIN_10_EXP',
|
|
'LDBL_MIN_10_EXP', 'FLT_MAX_EXP', 'DBL_MAX_EXP', 'LDBL_MAX_EXP',
|
|
'FLT_MAX_10_EXP', 'DBL_MAX_10_EXP', 'LDBL_MAX_10_EXP', 'FLT_MAX',
|
|
'DBL_MAX', 'LDBL_MAX', 'FLT_MIN', 'DBL_MIN', 'LDBL_MIN',
|
|
'FLT_EPSILON', 'DBL_EPSILON', 'LDBL_EPSILON'
|
|
],
|
|
}
|
|
|
|
|
|
# Identifiers described in Section 7 "Library" of C99 Standard
|
|
# Based on ISO/IEC 9899 WF14/N1256 Annex B -- Library summary
|
|
C99_STDLIB_IDENTIFIERS = {
|
|
# B.1 Diagnostics
|
|
'assert.h': C90_STDLIB_IDENTIFIERS['assert.h'],
|
|
# B.2 Complex
|
|
'complex.h': [
|
|
'complex', 'imaginary', 'I', '_Complex_I', '_Imaginary_I',
|
|
'CX_LIMITED_RANGE',
|
|
'cacos', 'cacosf', 'cacosl',
|
|
'casin', 'casinf', 'casinl',
|
|
'catan', 'catanf', 'catanl',
|
|
'ccos', 'ccosf', 'ccosl',
|
|
'csin', 'csinf', 'csinl',
|
|
'ctan', 'ctanf', 'ctanl',
|
|
'cacosh', 'cacoshf', 'cacoshl',
|
|
'casinh', 'casinhf', 'casinhl',
|
|
'catanh', 'catanhf', 'catanhl',
|
|
'ccosh', 'ccoshf', 'ccoshl',
|
|
'csinh', 'csinhf', 'csinhl',
|
|
'ctanh', 'ctanhf', 'ctanhl',
|
|
'cexp', 'cexpf', 'cexpl',
|
|
'clog', 'clogf', 'clogl',
|
|
'cabs', 'cabsf', 'cabsl',
|
|
'cpow', 'cpowf', 'cpowl',
|
|
'csqrt', 'csqrtf', 'csqrtl',
|
|
'carg', 'cargf', 'cargl',
|
|
'cimag', 'cimagf', 'cimagl',
|
|
'conj', 'conjf', 'conjl',
|
|
'cproj', 'cprojf', 'cprojl',
|
|
'creal', 'crealf', 'creall',
|
|
],
|
|
# B.3 Character handling
|
|
'ctype.h': C90_STDLIB_IDENTIFIERS['ctype.h'],
|
|
# B.4 Errors
|
|
'errno.h': C90_STDLIB_IDENTIFIERS['errno.h'] + ['EILSEQ'],
|
|
# B.5 Floating-point environment
|
|
'fenv.h': [
|
|
'fenv_t', 'FE_OVERFLOW', 'FE_TOWARDZERO',
|
|
'fexcept_t', 'FE_UNDERFLOW', 'FE_UPWARD',
|
|
'FE_DIVBYZERO', 'FE_ALL_EXCEPT', 'FE_DFL_ENV',
|
|
'FE_INEXACT', 'FE_DOWNWARD',
|
|
'FE_INVALID', 'FE_TONEAREST',
|
|
'FENV_ACCESS',
|
|
'feclearexcept', 'fegetexceptflag', 'fegetround',
|
|
'fesetround', 'fegetenv', 'feholdexcept',
|
|
'fesetenv', 'feupdateenv',
|
|
],
|
|
# B.6 Characteristics of floating types
|
|
'float.h': C90_STDLIB_IDENTIFIERS['float.h'] + ['FLT_EVAL_METHOD'],
|
|
# B.7 Format conversion of integer types
|
|
'inttypes.h': [
|
|
'imaxdiv_t', 'imaxabs', 'imaxdiv', 'strtoimax',
|
|
'strtoumax', 'wcstoimax', 'wcstoumax',
|
|
],
|
|
# B.8 Alternative spellings
|
|
'iso646.h': [
|
|
'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not', 'not_eq',
|
|
'or', 'or_eq', 'xor', 'xor_eq',
|
|
],
|
|
# B.9 Size of integer types
|
|
'limits.h': C90_STDLIB_IDENTIFIERS['limits.h'] +
|
|
['LLONG_MIN', 'LLONG_MAX', 'ULLONG_MAX'],
|
|
# B.10 Localization
|
|
'locale.h': C90_STDLIB_IDENTIFIERS['locale.h'],
|
|
# B.11 Mathematics
|
|
'math.h': C90_STDLIB_IDENTIFIERS['math.h'] + [
|
|
'float_t', 'double_t', 'HUGE_VAL', 'HUGE_VALF', 'HUGE_VALL',
|
|
'INFINITY', 'NAN', 'FP_INFINITE', 'FP_NAN', 'FP_NORMAL',
|
|
'FP_SUBNORMAL', 'FP_ZERO', 'FP_FAST_FMA', 'FP_FAST_FMAF',
|
|
'FP_FAST_FMAL', 'FP_ILOGB0', 'FP_ILOGBNAN', 'MATH_ERRNO',
|
|
'MATH_ERREXCEPT', 'math_errhandling', 'FP_CONTRACT', 'fpclassify',
|
|
'isfinite', 'isinf', 'isnan', 'isnormal', 'signbit', 'acosf', 'acosl',
|
|
'asinf', 'asinl', 'atanf', 'atanl', 'atan2', 'atan2f', 'atan2l',
|
|
'cosf', 'cosl', 'sinf', 'sinl', 'tanf', 'tanl', 'acosh', 'acoshf',
|
|
'acoshl', 'asinh', 'asinhf', 'asinhl', 'atanh', 'atanhf', 'atanhl',
|
|
'cosh', 'coshf', 'coshl', 'sinh', 'sinhf', 'sinhl', 'tanh', 'tanhf',
|
|
'tanhl', 'expf', 'expl', 'exp2', 'exp2f', 'exp2l', 'expm1', 'expm1f',
|
|
'expm1l', 'frexpf', 'frexpl', 'ilogb', 'ilogbf', 'ilogbl', 'float',
|
|
'ldexpl', 'logf', 'logl', 'log10f', 'log10l', 'log1p', 'log1pf',
|
|
'log1pl', 'log2', 'log2f', 'log2l', 'logb', 'logbf', 'logbl', 'modff',
|
|
'modfl', 'scalbn', 'scalbnf', 'scalbnl', 'scalbln', 'scalblnf',
|
|
'scalblnl', 'hypotl', 'powf', 'powl', 'sqrtf', 'sqrtl', 'erf', 'erff',
|
|
'erfl', 'erfc', 'erfcf', 'erfcl', 'lgamma', 'lgammaf', 'lgammal',
|
|
'tgamma', 'tgammaf', 'tgammal', 'ceilf', 'ceill', 'floorf', 'floorl',
|
|
'nearbyint', 'nearbyintf', 'nearbyintl', 'rint', 'rintf', 'rintl',
|
|
'lrint', 'lrintf', 'lrintl', 'llrint', 'llrintf', 'llrintl', 'round',
|
|
'roundf', 'roundl', 'lround', 'lroundf', 'lroundl', 'llround',
|
|
'llroundf', 'llroundl', 'trunc', 'truncf', 'truncl', 'fmodf', 'fmodl',
|
|
'remainder', 'remainderf', 'remainderl', 'remquo', 'remquof',
|
|
'remquol', 'copysign', 'copysignf', 'copysignl', 'nan', 'nanf',
|
|
'nanl', 'nextafter', 'nextafterf', 'nextafterl', 'nexttoward',
|
|
'nexttowardf', 'nexttowardl', 'fdim', 'fdimf', 'fdiml', 'fmax',
|
|
'fmaxf', 'fmaxl', 'fmin', 'fminf', 'fminl', 'fmal', 'isgreater',
|
|
'isgreaterequal', 'isless', 'islessequal', 'islessgreater',
|
|
'isunordered',
|
|
],
|
|
# B.12 Nonlocal jumps
|
|
'setjmp.h': C90_STDLIB_IDENTIFIERS['setjmp.h'],
|
|
# B.13 Signal handling
|
|
'signal.h': C90_STDLIB_IDENTIFIERS['signal.h'],
|
|
# B.14 Variable arguments
|
|
'stdarg.h': C90_STDLIB_IDENTIFIERS['stdarg.h'] + ['va_copy'],
|
|
# B.15 Boolean type and values
|
|
'stdbool.h': ['bool', 'true', 'false', '__bool_true_false_are_defined'],
|
|
# B.16 Common definitions
|
|
'stddef.h': C90_STDLIB_IDENTIFIERS['stddef.h'],
|
|
# B.17 Integer types
|
|
'stdint.h': [
|
|
'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_t', 'INTN_MIN',
|
|
'INTN_MAX', 'UINTN_MAX', 'INT_LEASTN_MIN', 'INT_LEASTN_MAX',
|
|
'UINT_LEASTN_MAX', 'INT_FASTN_MIN', 'INT_FASTN_MAX', 'UINT_FASTN_MAX',
|
|
'INTPTR_MIN', 'INTPTR_MAX', 'UINTPTR_MAX', 'INTMAX_MIN', 'INTMAX_MAX',
|
|
'UINTMAX_MAX', 'PTRDIFF_MIN', 'PTRDIFF_MAX', 'SIG_ATOMIC_MIN',
|
|
'SIG_ATOMIC_MAX', 'SIZE_MAX', 'WCHAR_MIN', 'WCHAR_MAX', 'WINT_MIN',
|
|
'WINT_MAX', 'INTN_C', 'UINTN_C', 'INTMAX_C', 'UINTMAX_C',
|
|
] + STDINT_TYPES,
|
|
# B.18 Input/output
|
|
'stdio.h': C90_STDLIB_IDENTIFIERS['stdio.h'] + [
|
|
'mode', 'restrict', 'snprintf', 'vfscanf', 'vscanf',
|
|
'vsnprintf', 'vsscanf',
|
|
],
|
|
# B.19 General utilities
|
|
'stdlib.h': C90_STDLIB_IDENTIFIERS['stdlib.h'] + [
|
|
'_Exit', 'labs', 'llabs', 'lldiv', 'lldiv_t', 'strtof', 'strtol',
|
|
'strtold', 'strtoll', 'strtoul', 'strtoull'
|
|
],
|
|
# B.20 String handling
|
|
'string.h': C90_STDLIB_IDENTIFIERS['string.h'],
|
|
# B.21 Type-generic math
|
|
'tgmath.h': [
|
|
'acos', 'asin', 'atan', 'acosh', 'asinh', 'atanh', 'cos', 'sin', 'tan',
|
|
'cosh', 'sinh', 'tanh', 'exp', 'log', 'pow', 'sqrt', 'fabs', 'atan2',
|
|
'cbrt', 'ceil', 'copysign', 'erf', 'erfc', 'exp2', 'expm1', 'fdim',
|
|
'floor', 'fma', 'fmax', 'fmin', 'fmod', 'frexp', 'hypot', 'ilogb',
|
|
'ldexp', 'lgamma', 'llrint', 'llround', 'log10', 'log1p', 'log2',
|
|
'logb', 'lrint', 'lround', 'nearbyint', 'nextafter', 'nexttoward',
|
|
'remainder', 'remquo', 'rint', 'round', 'scalbn', 'scalbln', 'tgamma',
|
|
'trunc', 'carg', 'cimag', 'conj', 'cproj', 'creal',
|
|
],
|
|
# B.22 Date and time
|
|
'time.h': C90_STDLIB_IDENTIFIERS['time.h'] + ['CLOCKS_PER_SEC'],
|
|
# B.23 Extended multibyte/wide character utilities
|
|
'wchar.h': [
|
|
'wchar_t', 'size_t', 'mbstate_t', 'wint_t', 'tm', 'NULL', 'WCHAR_MAX',
|
|
'WCHAR_MIN', 'WEOF', 'fwprintf', 'fwscanf', 'swprintf', 'swscanf',
|
|
'vfwprintf', 'vfwscanf', 'vswprintf', 'vswscanf', 'vwprintf',
|
|
'vwscanf', 'wprintf', 'wscanf', 'fgetwc', 'fgetws', 'fputwc', 'fputws',
|
|
'fwide', 'getwc', 'getwchar', 'putwc', 'putwchar', 'ungetwc', 'wcstod',
|
|
'wcstof', 'double', 'int', 'long', 'long', 'long', 'wcscpy', 'wcsncpy',
|
|
'wmemcpy', 'wmemmove', 'wcscat', 'wcsncat', 'wcscmp', 'wcscoll',
|
|
'wcsncmp', 'wcsxfrm', 'wmemcmp', 'wcschr', 'wcscspn', 'wcspbrk',
|
|
'wcsrchr', 'wcsspn', 'wcsstr', 'wcstok', 'wmemchr', 'wcslen',
|
|
'wmemset', 'wcsftime', 'btowc', 'wctob', 'mbsinit', 'mbrlen',
|
|
'mbrtowc', 'wcrtomb', 'mbsrtowcs', 'wcsrtombs',
|
|
],
|
|
}
|
|
|
|
|
|
def isStdLibId(id_, standard='c99'):
|
|
id_lists = []
|
|
if standard == 'c89':
|
|
id_lists = C90_STDLIB_IDENTIFIERS.values()
|
|
elif standard in ('c99', 'c11'):
|
|
id_lists = C99_STDLIB_IDENTIFIERS.values()
|
|
for l in id_lists:
|
|
if id_ in l:
|
|
return True
|
|
return False
|
|
|
|
|
|
# Reserved keywords defined in ISO/IEC9899:1990 -- ch 6.1.1
|
|
C90_KEYWORDS = {
|
|
'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do',
|
|
'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if',
|
|
'int', 'long', 'register', 'return', 'short', 'signed',
|
|
'sizeof', 'static', 'struct', 'switch', 'typedef', 'union', 'unsigned',
|
|
'void', 'volatile', 'while'
|
|
}
|
|
|
|
|
|
# Reserved keywords defined in ISO/IEC 9899 WF14/N1256 -- ch. 6.4.1
|
|
C99_ADDED_KEYWORDS = {
|
|
'inline', 'restrict', '_Bool', '_Complex', '_Imaginary',
|
|
'bool', 'complex', 'imaginary'
|
|
}
|
|
|
|
C11_ADDED_KEYWORDS = {
|
|
'_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
|
|
'_Statis_assert', '_Thread_local' ,
|
|
'alignas', 'alignof', 'noreturn', 'static_assert'
|
|
}
|
|
|
|
def isKeyword(keyword, standard='c99'):
|
|
kw_set = {}
|
|
if standard == 'c89':
|
|
kw_set = C90_KEYWORDS
|
|
elif standard == 'c99':
|
|
kw_set = copy.copy(C90_KEYWORDS)
|
|
kw_set.update(C99_ADDED_KEYWORDS)
|
|
else:
|
|
kw_set = copy.copy(C90_KEYWORDS)
|
|
kw_set.update(C99_ADDED_KEYWORDS)
|
|
kw_set.update(C11_ADDED_KEYWORDS)
|
|
return keyword in kw_set
|
|
|
|
|
|
def is_source_file(file):
|
|
return file.endswith('.c')
|
|
|
|
|
|
def is_header(file):
|
|
return file.endswith('.h')
|
|
|
|
|
|
def is_errno_setting_function(function_name):
|
|
return function_name and \
|
|
function_name in ('ftell', 'fgetpos', 'fsetpos', 'fgetwc', 'fputwc'
|
|
'strtoimax', 'strtoumax', 'strtol', 'strtoul',
|
|
'strtoll', 'strtoull', 'strtof', 'strtod', 'strtold'
|
|
'wcstoimax', 'wcstoumax', 'wcstol', 'wcstoul',
|
|
'wcstoll', 'wcstoull', 'wcstof', 'wcstod', 'wcstold'
|
|
'wcrtomb', 'wcsrtombs', 'mbrtowc')
|
|
|
|
|
|
def get_type_conversion_to_from(token):
|
|
def get_vartok(expr):
|
|
while expr:
|
|
if isCast(expr):
|
|
if expr.astOperand2 is None:
|
|
expr = expr.astOperand1
|
|
else:
|
|
expr = expr.astOperand2
|
|
elif expr.str in ('.', '::'):
|
|
expr = expr.astOperand2
|
|
elif expr.str == '[':
|
|
expr = expr.astOperand1
|
|
else:
|
|
break
|
|
return expr if (expr and expr.variable) else None
|
|
|
|
if isCast(token):
|
|
vartok = get_vartok(token)
|
|
if vartok:
|
|
return (token.next, vartok.variable.typeStartToken)
|
|
|
|
elif token.str == '=':
|
|
lhs = get_vartok(token.astOperand1)
|
|
rhs = get_vartok(token.astOperand2)
|
|
if lhs and rhs:
|
|
return (lhs.variable.typeStartToken, rhs.variable.typeStartToken)
|
|
|
|
return None
|
|
|
|
|
|
def is_composite_expr(expr, composite_operator=False):
|
|
"""MISRA C 2012, section 8.10.3"""
|
|
if expr is None:
|
|
return False
|
|
|
|
if not composite_operator:
|
|
if (expr.str in ('+', '-', '*', '/', '%', '&', '|', '^', '>>', "<<", "?", ":", '~')):
|
|
return is_composite_expr(expr.astOperand1,True) or is_composite_expr(expr.astOperand2, True)
|
|
if expr.str == '?' and simpleMatch(expr.astOperand2, ':'):
|
|
colon = expr.astOperand2
|
|
return is_composite_expr(colon.astOperand1,True) or is_composite_expr(colon.astOperand2, True)
|
|
return False
|
|
|
|
# non constant expression?
|
|
if expr.isNumber:
|
|
return False
|
|
if expr.astOperand1 or expr.astOperand2:
|
|
return is_composite_expr(expr.astOperand1,True) or is_composite_expr(expr.astOperand2, True)
|
|
return True
|
|
|
|
|
|
def getEssentialTypeCategory(expr):
|
|
if not expr:
|
|
return None
|
|
if expr.str == ',':
|
|
return getEssentialTypeCategory(expr.astOperand2)
|
|
if expr.str in ('<', '<=', '==', '!=', '>=', '>', '&&', '||', '!'):
|
|
return 'bool'
|
|
if expr.str in ('<<', '>>'):
|
|
# TODO this is incomplete
|
|
return getEssentialTypeCategory(expr.astOperand1)
|
|
if len(expr.str) == 1 and expr.str in '+-*/%&|^':
|
|
# TODO this is incomplete
|
|
e1 = getEssentialTypeCategory(expr.astOperand1)
|
|
e2 = getEssentialTypeCategory(expr.astOperand2)
|
|
# print('{0}: {1} {2}'.format(expr.str, e1, e2))
|
|
if e1 and e2 and e1 == e2:
|
|
return e1
|
|
if expr.valueType:
|
|
return expr.valueType.sign
|
|
if expr.valueType and expr.valueType.typeScope and expr.valueType.typeScope.className:
|
|
return "enum<" + expr.valueType.typeScope.className + ">"
|
|
vartok = expr
|
|
while simpleMatch(vartok, '[') or (vartok and vartok.str == '*' and vartok.astOperand2 is None):
|
|
vartok = vartok.astOperand1
|
|
if vartok and vartok.variable:
|
|
typeToken = vartok.variable.typeStartToken
|
|
while typeToken and typeToken.isName:
|
|
if typeToken.str == 'char' and not typeToken.isSigned and not typeToken.isUnsigned:
|
|
return 'char'
|
|
if typeToken.valueType:
|
|
if typeToken.valueType.type == 'bool':
|
|
return typeToken.valueType.type
|
|
if typeToken.valueType.type in ('float', 'double', 'long double'):
|
|
return "float"
|
|
if typeToken.valueType.sign:
|
|
return typeToken.valueType.sign
|
|
typeToken = typeToken.next
|
|
|
|
# See Appendix D, section D.6, Character constants
|
|
if expr.str[0] == "'" and expr.str[-1] == "'":
|
|
if len(expr.str) == 3 or (len(expr.str) == 4 and expr.str[1] == '\\'):
|
|
return 'char'
|
|
return expr.valueType.sign
|
|
|
|
if expr.valueType:
|
|
return expr.valueType.sign
|
|
return None
|
|
|
|
|
|
def getEssentialCategorylist(operand1, operand2):
|
|
if not operand1 or not operand2:
|
|
return None, None
|
|
if (operand1.str in ('++', '--') or
|
|
operand2.str in ('++', '--')):
|
|
return None, None
|
|
if ((operand1.valueType and operand1.valueType.pointer) or
|
|
(operand2.valueType and operand2.valueType.pointer)):
|
|
return None, None
|
|
e1 = getEssentialTypeCategory(operand1)
|
|
e2 = getEssentialTypeCategory(operand2)
|
|
return e1, e2
|
|
|
|
|
|
def get_essential_type_from_value(value, is_signed):
|
|
if value is None:
|
|
return None
|
|
for t in ('char', 'short', 'int', 'long', 'long long'):
|
|
bits = bitsOfEssentialType(t)
|
|
if bits >= 64:
|
|
continue
|
|
if is_signed:
|
|
range_min = -(1 << (bits - 1))
|
|
range_max = (1 << (bits - 1)) - 1
|
|
else:
|
|
range_min = 0
|
|
range_max = (1 << bits) - 1
|
|
sign = 'signed' if is_signed else 'unsigned'
|
|
if is_signed and value < 0 and value >= range_min:
|
|
return '%s %s' % (sign, t)
|
|
if value >= 0 and value <= range_max:
|
|
return '%s %s' % (sign, t)
|
|
return None
|
|
|
|
def getEssentialType(expr):
|
|
if not expr:
|
|
return None
|
|
|
|
# See Appendix D, section D.6, Character constants
|
|
if expr.str[0] == "'" and expr.str[-1] == "'":
|
|
if len(expr.str) == 3 or (len(expr.str) == 4 and expr.str[1] == '\\'):
|
|
return 'char'
|
|
return '%s %s' % (expr.valueType.sign, expr.valueType.type)
|
|
|
|
if expr.variable or isCast(expr):
|
|
typeToken = expr.variable.typeStartToken if expr.variable else expr.next
|
|
while typeToken and typeToken.isName:
|
|
if typeToken.str == 'char' and not typeToken.isSigned and not typeToken.isUnsigned:
|
|
return 'char'
|
|
typeToken = typeToken.next
|
|
if expr.valueType:
|
|
if expr.valueType.type == 'bool':
|
|
return 'bool'
|
|
if expr.valueType.isFloat():
|
|
return expr.valueType.type
|
|
if expr.valueType.isIntegral():
|
|
if (expr.valueType.sign is None) and expr.valueType.type == 'char':
|
|
return 'char'
|
|
return '%s %s' % (expr.valueType.sign, expr.valueType.type)
|
|
|
|
elif expr.isNumber:
|
|
# Appendix D, D.6 The essential type of literal constants
|
|
# Integer constants
|
|
if expr.valueType.type == 'bool':
|
|
return 'bool'
|
|
if expr.valueType.isFloat():
|
|
return expr.valueType.type
|
|
if expr.valueType.isIntegral():
|
|
if expr.valueType.type != 'int':
|
|
return '%s %s' % (expr.valueType.sign, expr.valueType.type)
|
|
return get_essential_type_from_value(expr.getKnownIntValue(), expr.valueType.sign == 'signed')
|
|
|
|
elif expr.str in ('<', '<=', '>=', '>', '==', '!=', '&&', '||', '!'):
|
|
return 'bool'
|
|
|
|
elif expr.astOperand1 and expr.astOperand2 and expr.str in (
|
|
'+', '-', '*', '/', '%', '&', '|', '^', '>>', "<<", "?", ":"):
|
|
if expr.astOperand1.valueType and expr.astOperand1.valueType.pointer > 0:
|
|
return None
|
|
if expr.astOperand2.valueType and expr.astOperand2.valueType.pointer > 0:
|
|
return None
|
|
e1 = getEssentialType(expr.astOperand1)
|
|
e2 = getEssentialType(expr.astOperand2)
|
|
if e1 is None or e2 is None:
|
|
return None
|
|
if is_constant_integer_expression(expr):
|
|
sign1 = e1.split(' ')[0]
|
|
sign2 = e2.split(' ')[0]
|
|
if sign1 == sign2 and sign1 in ('signed', 'unsigned'):
|
|
e = get_essential_type_from_value(expr.getKnownIntValue(), sign1 == 'signed')
|
|
if e:
|
|
return e
|
|
if bitsOfEssentialType(e2) >= bitsOfEssentialType(e1):
|
|
return e2
|
|
else:
|
|
return e1
|
|
|
|
elif expr.str == "~":
|
|
e1 = getEssentialType(expr.astOperand1)
|
|
return e1
|
|
|
|
return None
|
|
|
|
|
|
def bitsOfEssentialType(ty):
|
|
if ty is None:
|
|
return 0
|
|
last_type = ty.split(' ')[-1]
|
|
if last_type == 'Boolean':
|
|
return 1
|
|
if last_type == 'char':
|
|
return typeBits['CHAR']
|
|
if last_type == 'short':
|
|
return typeBits['SHORT']
|
|
if last_type == 'int':
|
|
return typeBits['INT']
|
|
if ty.endswith('long long'):
|
|
return typeBits['LONG_LONG']
|
|
if last_type == 'long':
|
|
return typeBits['LONG']
|
|
for sty in STDINT_TYPES:
|
|
if ty == sty:
|
|
return int(''.join(filter(str.isdigit, sty)))
|
|
return 0
|
|
|
|
|
|
def get_function_pointer_type(tok):
|
|
ret = ''
|
|
par = 0
|
|
while tok and (tok.isName or tok.str == '*'):
|
|
ret += ' ' + tok.str
|
|
tok = tok.next
|
|
if tok is None or tok.str != '(':
|
|
return None
|
|
tok = tok.link
|
|
if not simpleMatch(tok, ') ('):
|
|
return None
|
|
ret += '('
|
|
tok = tok.next.next
|
|
while tok and (tok.str not in '()'):
|
|
ret += ' ' + tok.str
|
|
tok = tok.next
|
|
if (tok is None) or tok.str != ')':
|
|
return None
|
|
return ret[1:] + ')'
|
|
|
|
def isCast(expr):
|
|
if not expr or expr.str != '(' or not expr.astOperand1 or expr.astOperand2:
|
|
return False
|
|
if simpleMatch(expr, '( )'):
|
|
return False
|
|
return True
|
|
|
|
def is_constant_integer_expression(expr):
|
|
if expr is None:
|
|
return False
|
|
if expr.isInt:
|
|
return True
|
|
if not expr.isArithmeticalOp:
|
|
return False
|
|
if expr.astOperand1 and not is_constant_integer_expression(expr.astOperand1):
|
|
return False
|
|
if expr.astOperand2 and not is_constant_integer_expression(expr.astOperand2):
|
|
return False
|
|
return True
|
|
|
|
def isFunctionCall(expr, std='c99'):
|
|
if not expr:
|
|
return False
|
|
if expr.str != '(' or not expr.astOperand1:
|
|
return False
|
|
if expr.astOperand1 != expr.previous:
|
|
return False
|
|
if isKeyword(expr.astOperand1.str, std):
|
|
return False
|
|
return True
|
|
|
|
|
|
def hasExternalLinkage(var):
|
|
return var.isGlobal and not var.isStatic
|
|
|
|
|
|
def countSideEffects(expr):
|
|
if not expr or expr.str in (',', ';'):
|
|
return 0
|
|
ret = 0
|
|
if expr.str in ('++', '--', '='):
|
|
ret = 1
|
|
return ret + countSideEffects(expr.astOperand1) + countSideEffects(expr.astOperand2)
|
|
|
|
|
|
def getForLoopExpressions(forToken):
|
|
if not forToken or forToken.str != 'for':
|
|
return None
|
|
lpar = forToken.next
|
|
if not lpar or lpar.str != '(':
|
|
return None
|
|
if not lpar.astOperand2 or lpar.astOperand2.str != ';':
|
|
return None
|
|
if not lpar.astOperand2.astOperand2 or lpar.astOperand2.astOperand2.str != ';':
|
|
return None
|
|
return [lpar.astOperand2.astOperand1,
|
|
lpar.astOperand2.astOperand2.astOperand1,
|
|
lpar.astOperand2.astOperand2.astOperand2]
|
|
|
|
|
|
def getForLoopCounterVariables(forToken):
|
|
""" Return a set of Variable objects defined in ``for`` statement and
|
|
satisfy requirements to loop counter term from section 8.14 of MISRA
|
|
document.
|
|
"""
|
|
if not forToken or forToken.str != 'for':
|
|
return None
|
|
tn = forToken.next
|
|
if not tn or tn.str != '(':
|
|
return None
|
|
vars_defined = set()
|
|
vars_initialized = set()
|
|
vars_exit = set()
|
|
vars_modified = set()
|
|
cur_clause = 1
|
|
te = tn.link
|
|
while tn and tn != te:
|
|
if tn.variable:
|
|
if cur_clause == 1 and tn.variable.nameToken == tn:
|
|
vars_defined.add(tn.variable)
|
|
elif cur_clause == 2:
|
|
vars_exit.add(tn.variable)
|
|
elif cur_clause == 3:
|
|
if tn.next and countSideEffectsRecursive(tn.next) > 0:
|
|
vars_modified.add(tn.variable)
|
|
elif tn.previous and tn.previous.str in ('++', '--'):
|
|
vars_modified.add(tn.variable)
|
|
if cur_clause == 1 and tn.isAssignmentOp and tn.astOperand1.variable:
|
|
vars_initialized.add(tn.astOperand1.variable)
|
|
if tn.str == ';':
|
|
cur_clause += 1
|
|
tn = tn.next
|
|
return vars_defined | vars_initialized, vars_exit & vars_modified
|
|
|
|
|
|
def findCounterTokens(cond):
|
|
if not cond:
|
|
return []
|
|
if cond.str in ['&&', '||']:
|
|
c = findCounterTokens(cond.astOperand1)
|
|
c.extend(findCounterTokens(cond.astOperand2))
|
|
return c
|
|
ret = []
|
|
if ((cond.isArithmeticalOp and cond.astOperand1 and cond.astOperand2) or
|
|
(cond.isComparisonOp and cond.astOperand1 and cond.astOperand2)):
|
|
if cond.astOperand1.isName:
|
|
ret.append(cond.astOperand1)
|
|
if cond.astOperand2.isName:
|
|
ret.append(cond.astOperand2)
|
|
if cond.astOperand1.isOp:
|
|
ret.extend(findCounterTokens(cond.astOperand1))
|
|
if cond.astOperand2.isOp:
|
|
ret.extend(findCounterTokens(cond.astOperand2))
|
|
return ret
|
|
|
|
|
|
def isFloatCounterInWhileLoop(whileToken):
|
|
if not simpleMatch(whileToken, 'while ('):
|
|
return False
|
|
lpar = whileToken.next
|
|
rpar = lpar.link
|
|
counterTokens = findCounterTokens(lpar.astOperand2)
|
|
whileBodyStart = None
|
|
if simpleMatch(rpar, ') {'):
|
|
whileBodyStart = rpar.next
|
|
elif simpleMatch(whileToken.previous, '} while') and simpleMatch(whileToken.previous.link.previous, 'do {'):
|
|
whileBodyStart = whileToken.previous.link
|
|
else:
|
|
return False
|
|
token = whileBodyStart
|
|
while token != whileBodyStart.link:
|
|
token = token.next
|
|
for counterToken in counterTokens:
|
|
if not counterToken.valueType or not counterToken.valueType.isFloat():
|
|
continue
|
|
if token.isAssignmentOp and token.astOperand1.str == counterToken.str:
|
|
return True
|
|
if token.str == counterToken.str and token.astParent and token.astParent.str in ('++', '--'):
|
|
return True
|
|
return False
|
|
|
|
|
|
def countSideEffectsRecursive(expr):
|
|
if not expr or expr.str == ';':
|
|
return 0
|
|
if expr.str == '=' and expr.astOperand1 and expr.astOperand1.str == '[':
|
|
prev = expr.astOperand1.previous
|
|
if prev and (prev.str == '{' or prev.str == '{'):
|
|
return countSideEffectsRecursive(expr.astOperand2)
|
|
if expr.str == '=' and expr.astOperand1 and expr.astOperand1.str == '.':
|
|
e = expr.astOperand1
|
|
while e and e.str == '.' and e.astOperand2:
|
|
e = e.astOperand1
|
|
if e and e.str == '.':
|
|
return 0
|
|
if expr.isAssignmentOp or expr.str in {'++', '--'}:
|
|
return 1
|
|
# Todo: Check function calls
|
|
return countSideEffectsRecursive(expr.astOperand1) + countSideEffectsRecursive(expr.astOperand2)
|
|
|
|
|
|
def isBoolExpression(expr):
|
|
if not expr:
|
|
return False
|
|
if expr.valueType and (expr.valueType.type == 'bool' or expr.valueType.bits == 1):
|
|
return True
|
|
return expr.str in ['!', '==', '!=', '<', '<=', '>', '>=', '&&', '||', '0', '1', 'true', 'false']
|
|
|
|
|
|
def isEnumConstant(expr):
|
|
if not expr or not expr.values:
|
|
return False
|
|
values = expr.values
|
|
return len(values) == 1 and values[0].valueKind == 'known'
|
|
|
|
|
|
def isConstantExpression(expr):
|
|
if expr.isNumber:
|
|
return True
|
|
if expr.isName and not isEnumConstant(expr):
|
|
return False
|
|
if simpleMatch(expr.previous, 'sizeof ('):
|
|
return True
|
|
if expr.astOperand1 and not isConstantExpression(expr.astOperand1):
|
|
return False
|
|
if expr.astOperand2 and not isConstantExpression(expr.astOperand2):
|
|
return False
|
|
return True
|
|
|
|
|
|
def isUnsignedInt(expr):
|
|
return expr and expr.valueType and expr.valueType.type in ('short', 'int') and expr.valueType.sign == 'unsigned'
|
|
|
|
|
|
def getPrecedence(expr):
|
|
if not expr:
|
|
return 16
|
|
if not expr.astOperand1 or not expr.astOperand2:
|
|
return 16
|
|
if expr.str in ('*', '/', '%'):
|
|
return 12
|
|
if expr.str in ('+', '-'):
|
|
return 11
|
|
if expr.str in ('<<', '>>'):
|
|
return 10
|
|
if expr.str in ('<', '>', '<=', '>='):
|
|
return 9
|
|
if expr.str in ('==', '!='):
|
|
return 8
|
|
if expr.str == '&':
|
|
return 7
|
|
if expr.str == '^':
|
|
return 6
|
|
if expr.str == '|':
|
|
return 5
|
|
if expr.str == '&&':
|
|
return 4
|
|
if expr.str == '||':
|
|
return 3
|
|
if expr.str in ('?', ':'):
|
|
return 2
|
|
if expr.isAssignmentOp:
|
|
return 1
|
|
if expr.str == ',':
|
|
return 0
|
|
return -1
|
|
|
|
|
|
def findRawLink(token):
|
|
tok1 = None
|
|
tok2 = None
|
|
forward = False
|
|
|
|
if token.str in '{([':
|
|
tok1 = token.str
|
|
tok2 = '})]'['{(['.find(token.str)]
|
|
forward = True
|
|
elif token.str in '})]':
|
|
tok1 = token.str
|
|
tok2 = '{(['['})]'.find(token.str)]
|
|
forward = False
|
|
else:
|
|
return None
|
|
|
|
# try to find link
|
|
indent = 0
|
|
while token:
|
|
if token.str == tok1:
|
|
indent = indent + 1
|
|
elif token.str == tok2:
|
|
if indent <= 1:
|
|
return token
|
|
indent = indent - 1
|
|
if forward is True:
|
|
token = token.next
|
|
else:
|
|
token = token.previous
|
|
|
|
# raw link not found
|
|
return None
|
|
|
|
|
|
def numberOfParentheses(tok1, tok2):
|
|
while tok1 and tok1 != tok2:
|
|
if tok1.str == '(' or tok1.str == ')':
|
|
return False
|
|
tok1 = tok1.next
|
|
return tok1 == tok2
|
|
|
|
|
|
def findGotoLabel(gotoToken):
|
|
label = gotoToken.next.str
|
|
tok = gotoToken.next.next
|
|
while tok:
|
|
if tok.str == '}' and tok.scope.type == 'Function':
|
|
break
|
|
if tok.str == label and tok.next.str == ':':
|
|
return tok
|
|
tok = tok.next
|
|
return None
|
|
|
|
|
|
def findInclude(directives, header):
|
|
for directive in directives:
|
|
if directive.str == '#include ' + header:
|
|
return directive
|
|
return None
|
|
|
|
|
|
# Get function arguments
|
|
def getArgumentsRecursive(tok, arguments):
|
|
if tok is None:
|
|
return
|
|
if tok.str == ',':
|
|
getArgumentsRecursive(tok.astOperand1, arguments)
|
|
getArgumentsRecursive(tok.astOperand2, arguments)
|
|
else:
|
|
arguments.append(tok)
|
|
|
|
|
|
def getArguments(ftok):
|
|
arguments = []
|
|
getArgumentsRecursive(ftok.astOperand2, arguments)
|
|
return arguments
|
|
|
|
|
|
def isalnum(c):
|
|
return c in string.digits or c in string.ascii_letters
|
|
|
|
|
|
def isHexEscapeSequence(symbols):
|
|
"""Checks that given symbols are valid hex escape sequence.
|
|
|
|
hexadecimal-escape-sequence:
|
|
\\x hexadecimal-digit
|
|
hexadecimal-escape-sequence hexadecimal-digit
|
|
|
|
Reference: n1570 6.4.4.4"""
|
|
if len(symbols) < 3 or symbols[:2] != '\\x':
|
|
return False
|
|
return all([s in string.hexdigits for s in symbols[2:]])
|
|
|
|
|
|
def isOctalEscapeSequence(symbols):
|
|
r"""Checks that given symbols are valid octal escape sequence:
|
|
|
|
octal-escape-sequence:
|
|
\ octal-digit
|
|
\ octal-digit octal-digit
|
|
\ octal-digit octal-digit octal-digit
|
|
|
|
Reference: n1570 6.4.4.4"""
|
|
if len(symbols) not in range(2, 5) or symbols[0] != '\\':
|
|
return False
|
|
return all([s in string.octdigits for s in symbols[1:]])
|
|
|
|
|
|
def isSimpleEscapeSequence(symbols):
|
|
"""Checks that given symbols are simple escape sequence.
|
|
Reference: n1570 6.4.4.4"""
|
|
if len(symbols) != 2 or symbols[0] != '\\':
|
|
return False
|
|
return symbols[1] in ("'", '"', '?', '\\', 'a', 'b', 'f', 'n', 'r', 't', 'v')
|
|
|
|
|
|
def isTernaryOperator(token):
|
|
if not token:
|
|
return False
|
|
if not token.astOperand2:
|
|
return False
|
|
return token.str == '?' and token.astOperand2.str == ':'
|
|
|
|
|
|
def getTernaryOperandsRecursive(token):
|
|
"""Returns list of ternary operands including nested ones."""
|
|
if not isTernaryOperator(token):
|
|
return []
|
|
result = []
|
|
result += getTernaryOperandsRecursive(token.astOperand2.astOperand1)
|
|
if token.astOperand2.astOperand1 and not isTernaryOperator(token.astOperand2.astOperand1):
|
|
result += [token.astOperand2.astOperand1]
|
|
result += getTernaryOperandsRecursive(token.astOperand2.astOperand2)
|
|
if token.astOperand2.astOperand2 and not isTernaryOperator(token.astOperand2.astOperand2):
|
|
result += [token.astOperand2.astOperand2]
|
|
return result
|
|
|
|
|
|
def hasNumericEscapeSequence(symbols):
|
|
"""Check that given string contains octal or hexadecimal escape sequences."""
|
|
if '\\' not in symbols:
|
|
return False
|
|
for c, cn in grouped(symbols, 2):
|
|
if c == '\\' and cn in ('x' + string.octdigits):
|
|
return True
|
|
return False
|
|
|
|
|
|
def isNoReturnScope(tok):
|
|
if tok is None or tok.str != '}':
|
|
return False
|
|
if tok.previous is None or tok.previous.str != ';':
|
|
return False
|
|
if simpleMatch(tok.previous.previous, 'break ;'):
|
|
return True
|
|
prev = tok.previous.previous
|
|
while prev and prev.str not in ';{}':
|
|
if prev.str in '])':
|
|
prev = prev.link
|
|
prev = prev.previous
|
|
if prev and prev.next.str in ['throw', 'return']:
|
|
return True
|
|
return False
|
|
|
|
|
|
# Return the token which the value is assigned to
|
|
def getAssignedVariableToken(vartok):
|
|
if not vartok:
|
|
return None
|
|
parent = vartok.astParent
|
|
while parent and parent.isArithmeticalOp:
|
|
parent = parent.astParent
|
|
if parent and parent.isAssignmentOp:
|
|
return parent.astOperand1
|
|
return None
|
|
|
|
# If the value is used as a return value, return the function definition
|
|
def getFunctionUsingReturnValue(valueToken):
|
|
if not valueToken:
|
|
return None
|
|
if not valueToken.astParent:
|
|
return None
|
|
operator = valueToken.astParent
|
|
if operator.str == 'return':
|
|
return operator.scope.function
|
|
if operator.isArithmeticalOp:
|
|
return getFunctionUsingReturnValue(operator)
|
|
return None
|
|
|
|
# Return true if the token follows a specific sequence of token str values
|
|
def tokenFollowsSequence(token, sequence):
|
|
if not token:
|
|
return False
|
|
for i in reversed(sequence):
|
|
prev = token.previous
|
|
if not prev:
|
|
return False
|
|
if prev.str != i:
|
|
return False
|
|
token = prev
|
|
return True
|
|
|
|
class Define:
|
|
def __init__(self, directive):
|
|
self.name = ''
|
|
self.args = []
|
|
self.expansionList = ''
|
|
|
|
res = re.match(r'#define ([A-Za-z0-9_]+)\(([A-Za-z0-9_, ]+)\)[ ]+(.*)', directive.str)
|
|
if res:
|
|
self.name = res.group(1)
|
|
self.args = res.group(2).strip().split(',')
|
|
self.expansionList = res.group(3)
|
|
else:
|
|
res = re.match(r'#define ([A-Za-z0-9_]+)[ ]+(.*)', directive.str)
|
|
if res:
|
|
self.name = res.group(1)
|
|
self.expansionList = res.group(2)
|
|
|
|
def __repr__(self):
|
|
attrs = ["name", "args", "expansionList"]
|
|
return "{}({})".format(
|
|
"Define",
|
|
", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
|
|
)
|
|
|
|
|
|
def getAddonRules():
|
|
"""Returns dict of MISRA rules handled by this addon."""
|
|
addon_rules = []
|
|
compiled = re.compile(r'.*def[ ]+misra_([0-9]+)_([0-9]+)[(].*')
|
|
for line in open(__file__):
|
|
res = compiled.match(line)
|
|
if res is None:
|
|
continue
|
|
addon_rules.append(res.group(1) + '.' + res.group(2))
|
|
return addon_rules
|
|
|
|
|
|
def getCppcheckRules():
|
|
"""Returns list of rules handled by cppcheck."""
|
|
return ['1.3', # <most "error">
|
|
'2.1', # alwaysFalse, duplicateBreak
|
|
'2.2', # alwaysTrue, redundantCondition, redundantAssignment, redundantAssignInSwitch, unreadVariable
|
|
'2.6', # unusedLabel
|
|
'5.3', # shadowVariable
|
|
'8.3', # funcArgNamesDifferent
|
|
'8.13', # constPointer
|
|
'9.1', # uninitvar
|
|
'14.3', # alwaysTrue, alwaysFalse, compareValueOutOfTypeRangeError
|
|
'13.2', # unknownEvaluationOrder
|
|
'13.6', # sizeofCalculation
|
|
'17.4', # missingReturn
|
|
'17.5', # argumentSize
|
|
'18.1', # pointerOutOfBounds
|
|
'18.2', # comparePointers
|
|
'18.3', # comparePointers
|
|
'18.6', # danglingLifetime
|
|
'19.1', # overlappingWriteUnion, overlappingWriteFunction
|
|
'20.6', # preprocessorErrorDirective
|
|
'21.13', # invalidFunctionArg
|
|
'21.17', # bufferAccessOutOfBounds
|
|
'21.18', # bufferAccessOutOfBounds
|
|
'22.1', # memleak, resourceLeak, memleakOnRealloc, leakReturnValNotUsed, leakNoVarFunctionCall
|
|
'22.2', # autovarInvalidDeallocation
|
|
'22.3', # incompatibleFileOpen
|
|
'22.4', # writeReadOnlyFile
|
|
'22.6' # useClosedFile
|
|
]
|
|
|
|
|
|
def generateTable():
|
|
# print table
|
|
numberOfRules = {}
|
|
numberOfRules[1] = 3
|
|
numberOfRules[2] = 7
|
|
numberOfRules[3] = 2
|
|
numberOfRules[4] = 2
|
|
numberOfRules[5] = 9
|
|
numberOfRules[6] = 2
|
|
numberOfRules[7] = 4
|
|
numberOfRules[8] = 14
|
|
numberOfRules[9] = 5
|
|
numberOfRules[10] = 8
|
|
numberOfRules[11] = 9
|
|
numberOfRules[12] = 4
|
|
numberOfRules[13] = 6
|
|
numberOfRules[14] = 4
|
|
numberOfRules[15] = 7
|
|
numberOfRules[16] = 7
|
|
numberOfRules[17] = 8
|
|
numberOfRules[18] = 8
|
|
numberOfRules[19] = 2
|
|
numberOfRules[20] = 14
|
|
numberOfRules[21] = 21
|
|
numberOfRules[22] = 10
|
|
|
|
# Rules that can be checked with compilers:
|
|
# compiler = ['1.1', '1.2']
|
|
|
|
addon = getAddonRules()
|
|
cppcheck = getCppcheckRules()
|
|
for i1 in range(1, 23):
|
|
for i2 in range(1, numberOfRules[i1] + 1):
|
|
num = str(i1) + '.' + str(i2)
|
|
s = ''
|
|
if num in addon:
|
|
s = 'X (Addon)'
|
|
elif num in cppcheck:
|
|
s = 'X (Cppcheck)'
|
|
num = num + ' '
|
|
print(num[:8] + s)
|
|
|
|
|
|
def remove_file_prefix(file_path, prefix):
|
|
"""
|
|
Remove a file path prefix from a give path. leftover
|
|
directory separators at the beginning of a file
|
|
after the removal are also stripped.
|
|
|
|
Example:
|
|
'/remove/this/path/file.c'
|
|
with a prefix of:
|
|
'/remove/this/path'
|
|
becomes:
|
|
file.c
|
|
"""
|
|
result = None
|
|
if file_path.startswith(prefix):
|
|
result = file_path[len(prefix):]
|
|
# Remove any leftover directory separators at the
|
|
# beginning
|
|
result = result.lstrip('\\/')
|
|
else:
|
|
result = file_path
|
|
return result
|
|
|
|
|
|
class Rule(object):
|
|
"""Class to keep rule text and metadata"""
|
|
|
|
MISRA_SEVERITY_LEVELS = ['Required', 'Mandatory', 'Advisory']
|
|
|
|
def __init__(self, num1, num2):
|
|
self.num1 = num1
|
|
self.num2 = num2
|
|
self.text = ''
|
|
self.misra_severity = ''
|
|
|
|
@property
|
|
def num(self):
|
|
return self.num1 * 100 + self.num2
|
|
|
|
@property
|
|
def misra_severity(self):
|
|
return self._misra_severity
|
|
|
|
@misra_severity.setter
|
|
def misra_severity(self, val):
|
|
if val in self.MISRA_SEVERITY_LEVELS:
|
|
self._misra_severity = val
|
|
else:
|
|
self._misra_severity = ''
|
|
|
|
@property
|
|
def cppcheck_severity(self):
|
|
return 'style'
|
|
|
|
def __repr__(self):
|
|
return "%d.%d (%s)" % (self.num1, self.num2, self.misra_severity)
|
|
|
|
|
|
class MisraSettings(object):
|
|
"""Hold settings for misra.py script."""
|
|
|
|
__slots__ = ["verify", "quiet", "show_summary"]
|
|
|
|
def __init__(self, args):
|
|
"""
|
|
:param args: Arguments given by argparse.
|
|
"""
|
|
self.verify = False
|
|
self.quiet = False
|
|
self.show_summary = True
|
|
|
|
if args.verify:
|
|
self.verify = True
|
|
if args.cli:
|
|
self.quiet = True
|
|
self.show_summary = False
|
|
if args.quiet:
|
|
self.quiet = True
|
|
if args.no_summary:
|
|
self.show_summary = False
|
|
|
|
def __repr__(self):
|
|
attrs = ["verify", "quiet", "show_summary", "verify"]
|
|
return "{}({})".format(
|
|
"MisraSettings",
|
|
", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
|
|
)
|
|
|
|
|
|
class MisraChecker:
|
|
|
|
def __init__(self, settings, stdversion="c89"):
|
|
"""
|
|
:param settings: misra.py script settings.
|
|
"""
|
|
|
|
self.settings = settings
|
|
|
|
# Test validation rules lists
|
|
self.verify_expected = list()
|
|
self.verify_actual = list()
|
|
|
|
# List of formatted violation messages
|
|
self.violations = dict()
|
|
|
|
# if --rule-texts is specified this dictionary
|
|
# is loaded with descriptions of each rule
|
|
# by rule number (in hundreds).
|
|
# ie rule 1.2 becomes 102
|
|
self.ruleTexts = dict()
|
|
self.ruleText_filename = None
|
|
|
|
# Dictionary of dictionaries for rules to suppress
|
|
# Dict1 is keyed by rule number in the hundreds format of
|
|
# Major * 100 + minor. ie Rule 5.2 = (5*100) + 2
|
|
# Dict 2 is keyed by filename. An entry of None means suppress globally.
|
|
# Each file name entry contains a list of tuples of (lineNumber, symbolName)
|
|
# or an item of None which indicates suppress rule for the entire file.
|
|
# The line and symbol name tuple may have None as either of its elements but
|
|
# should not be None for both.
|
|
self.suppressedRules = dict()
|
|
|
|
# Prefix to ignore when matching suppression files.
|
|
self.filePrefix = None
|
|
|
|
# Number of all violations suppressed per rule
|
|
self.suppressionStats = dict()
|
|
|
|
self.stdversion = stdversion
|
|
|
|
self.severity = None
|
|
|
|
self.existing_violations = set()
|
|
|
|
self._ctu_summary_typedefs = False
|
|
self._ctu_summary_tagnames = False
|
|
self._ctu_summary_identifiers = False
|
|
self._ctu_summary_usage = False
|
|
|
|
self.path_premium_addon = None
|
|
|
|
def __repr__(self):
|
|
attrs = ["settings", "verify_expected", "verify_actual", "violations",
|
|
"ruleTexts", "suppressedRules", "filePrefix",
|
|
"suppressionStats", "stdversion", "severity"]
|
|
return "{}({})".format(
|
|
"MisraChecker",
|
|
", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
|
|
)
|
|
|
|
def get_num_significant_naming_chars(self, cfg):
|
|
if cfg.standards and cfg.standards.c == "c89":
|
|
return 31
|
|
else:
|
|
return 63
|
|
|
|
def _save_ctu_summary_typedefs(self, dumpfile, typedef_info):
|
|
if self._ctu_summary_typedefs:
|
|
return
|
|
|
|
self._ctu_summary_typedefs = True
|
|
|
|
summary = []
|
|
for ti in typedef_info:
|
|
summary.append({ 'name': ti.name, 'file': ti.file, 'line': ti.linenr, 'column': ti.column, 'used': ti.used })
|
|
if len(summary) > 0:
|
|
cppcheckdata.reportSummary(dumpfile, 'MisraTypedefInfo', summary)
|
|
|
|
def _save_ctu_summary_tagnames(self, dumpfile, cfg):
|
|
if self._ctu_summary_tagnames:
|
|
return
|
|
|
|
self._ctu_summary_tagnames = True
|
|
|
|
summary = []
|
|
# structs/enums
|
|
for scope in cfg.scopes:
|
|
if scope.className is None:
|
|
continue
|
|
if scope.className.startswith('Anonymous'):
|
|
continue
|
|
if scope.type not in ('Struct', 'Enum'):
|
|
continue
|
|
used = False
|
|
tok = scope.bodyEnd
|
|
while tok:
|
|
if tok.str == scope.className:
|
|
used = True
|
|
break
|
|
tok = tok.next
|
|
summary.append({'name': scope.className, 'used':used, 'file': scope.bodyStart.file, 'line': scope.bodyStart.linenr, 'column': scope.bodyStart.column})
|
|
if len(summary) > 0:
|
|
cppcheckdata.reportSummary(dumpfile, 'MisraTagName', summary)
|
|
|
|
def _save_ctu_summary_identifiers(self, dumpfile, cfg):
|
|
if self._ctu_summary_identifiers:
|
|
return
|
|
self._ctu_summary_identifiers = True
|
|
|
|
external_identifiers = []
|
|
internal_identifiers = []
|
|
local_identifiers = []
|
|
|
|
def identifier(nameToken):
|
|
return {'name':nameToken.str, 'file':nameToken.file, 'line':nameToken.linenr, 'column':nameToken.column}
|
|
|
|
names = []
|
|
|
|
for var in cfg.variables:
|
|
if var.nameToken is None:
|
|
continue
|
|
if var.access != 'Global':
|
|
if var.nameToken.str in names:
|
|
continue
|
|
names.append(var.nameToken.str)
|
|
local_identifiers.append(identifier(var.nameToken))
|
|
elif var.isStatic:
|
|
names.append(var.nameToken.str)
|
|
i = identifier(var.nameToken)
|
|
i['inlinefunc'] = False
|
|
internal_identifiers.append(i)
|
|
else:
|
|
names.append(var.nameToken.str)
|
|
i = identifier(var.nameToken)
|
|
i['decl'] = var.isExtern
|
|
external_identifiers.append(i)
|
|
|
|
for func in cfg.functions:
|
|
if func.tokenDef is None:
|
|
continue
|
|
if func.isStatic:
|
|
i = identifier(func.tokenDef)
|
|
i['inlinefunc'] = func.isInlineKeyword
|
|
internal_identifiers.append(i)
|
|
else:
|
|
if func.token is None:
|
|
i = identifier(func.tokenDef)
|
|
else:
|
|
i = identifier(func.token)
|
|
i['decl'] = func.token is None
|
|
external_identifiers.append(i)
|
|
|
|
cppcheckdata.reportSummary(dumpfile, 'MisraExternalIdentifiers', external_identifiers)
|
|
cppcheckdata.reportSummary(dumpfile, 'MisraInternalIdentifiers', internal_identifiers)
|
|
cppcheckdata.reportSummary(dumpfile, 'MisraLocalIdentifiers', local_identifiers)
|
|
|
|
def _save_ctu_summary_usage(self, dumpfile, cfg):
|
|
if self._ctu_summary_usage:
|
|
return
|
|
self._ctu_summary_usage = True
|
|
|
|
names = []
|
|
for token in cfg.tokenlist:
|
|
if not token.isName:
|
|
continue
|
|
if token.function and token.scope.isExecutable:
|
|
if (not token.function.isStatic) and (token.str not in names):
|
|
names.append({'name': token.str, 'file': token.file})
|
|
elif token.variable:
|
|
if token == token.variable.nameToken:
|
|
continue
|
|
if token.variable.access == 'Global' and (not token.variable.isStatic) and (token.str not in names):
|
|
names.append({'name': token.str, 'file': token.file})
|
|
|
|
if len(names) > 0:
|
|
cppcheckdata.reportSummary(dumpfile, 'MisraUsage', names)
|
|
|
|
|
|
def misra_1_4(self, cfg):
|
|
for token in cfg.tokenlist:
|
|
if token.str in ('_Atomic', '_Noreturn', '_Generic', '_Thread_local', '_Alignas', '_Alignof'):
|
|
self.reportError(token, 1, 4)
|
|
if token.str.endswith('_s') and isFunctionCall(token.next):
|
|
# See C specification C11 - Annex K, page 578
|
|
if token.str in ('tmpfile_s', 'tmpnam_s', 'fopen_s', 'freopen_s', 'fprintf_s', 'fscanf_s', 'printf_s', 'scanf_s',
|
|
'snprintf_s', 'sprintf_s', 'sscanf_s', 'vfprintf_s', 'vfscanf_s', 'vprintf_s', 'vscanf_s',
|
|
'vsnprintf_s', 'vsprintf_s', 'vsscanf_s', 'gets_s', 'set_constraint_handler_s', 'abort_handler_s',
|
|
'ignore_handler_s', 'getenv_s', 'bsearch_s', 'qsort_s', 'wctomb_s', 'mbstowcs_s', 'wcstombs_s',
|
|
'memcpy_s', 'memmove_s', 'strcpy_s', 'strncpy_s', 'strcat_s', 'strncat_s', 'strtok_s', 'memset_s',
|
|
'strerror_s', 'strerrorlen_s', 'strnlen_s', 'asctime_s', 'ctime_s', 'gmtime_s', 'localtime_s',
|
|
'fwprintf_s', 'fwscanf_s', 'snwprintf_s', 'swprintf_s', 'swscanf_s', 'vfwprintf_s', 'vfwscanf_s',
|
|
'vsnwprintf_s', 'vswprintf_s', 'vswscanf_s', 'vwprintf_s', 'vwscanf_s', 'wprintf_s', 'wscanf_s',
|
|
'wcscpy_s', 'wcsncpy_s', 'wmemcpy_s', 'wmemmove_s', 'wcscat_s', 'wcsncat_s', 'wcstok_s', 'wcsnlen_s',
|
|
'wcrtomb_s', 'mbsrtowcs_s', 'wcsrtombs_s'):
|
|
self.reportError(token, 1, 4)
|
|
|
|
def misra_2_2(self, cfg):
|
|
for token in cfg.tokenlist:
|
|
if token.isExpandedMacro:
|
|
continue
|
|
if (token.str in '+-') and token.astOperand2:
|
|
if simpleMatch(token.astOperand1, '0'):
|
|
self.reportError(token.astOperand1, 2, 2)
|
|
elif simpleMatch(token.astOperand2, '0'):
|
|
self.reportError(token.astOperand2, 2, 2)
|
|
if token.str == '*' and token.astOperand2:
|
|
if simpleMatch(token.astOperand2, '0'):
|
|
self.reportError(token.astOperand1, 2, 2)
|
|
elif simpleMatch(token.astOperand1, '0'):
|
|
self.reportError(token.astOperand2, 2, 2)
|
|
elif simpleMatch(token.astOperand1, '1'):
|
|
self.reportError(token.astOperand1, 2, 2)
|
|
elif simpleMatch(token.astOperand2, '1'):
|
|
self.reportError(token.astOperand2, 2, 2)
|
|
|
|
def misra_2_3(self, dumpfile, typedefInfo):
|
|
self._save_ctu_summary_typedefs(dumpfile, typedefInfo)
|
|
|
|
def misra_2_4(self, dumpfile, cfg):
|
|
self._save_ctu_summary_tagnames(dumpfile, cfg)
|
|
|
|
def misra_2_5(self, dumpfile, cfg):
|
|
used_macros = list()
|
|
for m in cfg.macro_usage:
|
|
used_macros.append(m.name)
|
|
summary = []
|
|
for directive in cfg.directives:
|
|
res = re.match(r'#define[ \t]+([a-zA-Z_][a-zA-Z_0-9]*).*', directive.str)
|
|
if res:
|
|
macro_name = res.group(1)
|
|
summary.append({'name': macro_name, 'used': (macro_name in used_macros), 'file': directive.file, 'line': directive.linenr, 'column': directive.column})
|
|
if len(summary) > 0:
|
|
cppcheckdata.reportSummary(dumpfile, 'MisraMacro', summary)
|
|
|
|
def misra_2_7(self, data):
|
|
for func in data.functions:
|
|
# Skip function with no parameter
|
|
if len(func.argument) == 0:
|
|
continue
|
|
# Setup list of function parameters
|
|
func_param_list = list()
|
|
for arg in func.argument:
|
|
func_arg = func.argument[arg]
|
|
if func_arg.typeStartToken and func_arg.typeStartToken.str == '...':
|
|
continue
|
|
func_param_list.append(func_arg)
|
|
# Search for scope of current function
|
|
for scope in data.scopes:
|
|
if (scope.type == "Function") and (scope.function == func):
|
|
# Search function body: remove referenced function parameter from list
|
|
token = scope.bodyStart
|
|
while token.next is not None and token != scope.bodyEnd and len(func_param_list) > 0:
|
|
if token.variable is not None and token.variable in func_param_list:
|
|
func_param_list.remove(token.variable)
|
|
token = token.next
|
|
# Emit a warning for each unused variable, but no more that one warning per line
|
|
reported_linenrs = set()
|
|
for func_param in func_param_list:
|
|
if func_param.nameToken:
|
|
linenr = func_param.nameToken
|
|
if linenr not in reported_linenrs:
|
|
self.reportError(func_param.nameToken, 2, 7)
|
|
reported_linenrs.add(linenr)
|
|
else:
|
|
linenr = func.tokenDef.linenr
|
|
if linenr not in reported_linenrs:
|
|
self.reportError(func.tokenDef, 2, 7)
|
|
reported_linenrs.add(linenr)
|
|
|
|
def misra_3_1(self, rawTokens):
|
|
for token in rawTokens:
|
|
starts_with_double_slash = token.str.startswith('//')
|
|
starts_with_block_comment = token.str.startswith("/*")
|
|
s = token.str.lstrip('/')
|
|
if (starts_with_double_slash or starts_with_block_comment) and "/*" in s:
|
|
# Block comment inside of regular comment, violation
|
|
self.reportError(token, 3, 1)
|
|
elif starts_with_block_comment and "//" in s:
|
|
# "//" in block comment, check if it's a uri
|
|
while "//" in s:
|
|
possible_uri, s = s.split("//", 1)
|
|
if not re.search(r"\w+:$", possible_uri):
|
|
# Violation if no uri was found
|
|
self.reportError(token, 3, 1)
|
|
break
|
|
|
|
def misra_3_2(self, rawTokens):
|
|
for token in rawTokens:
|
|
if token.str.startswith('//'):
|
|
# Check for comment ends with trigraph which might be replaced
|
|
# by a backslash.
|
|
if token.str.endswith('??/'):
|
|
self.reportError(token, 3, 2)
|
|
# Check for comment which has been merged with subsequent line
|
|
# because it ends with backslash.
|
|
# The last backslash is no more part of the comment token thus
|
|
# check if next token exists and compare line numbers.
|
|
elif (token.next is not None) and (token.linenr == token.next.linenr):
|
|
self.reportError(token, 3, 2)
|
|
|
|
def misra_4_1(self, rawTokens):
|
|
for token in rawTokens:
|
|
if (token.str[0] != '"') and (token.str[0] != '\''):
|
|
continue
|
|
if len(token.str) < 3:
|
|
continue
|
|
|
|
delimiter = token.str[0]
|
|
symbols = token.str[1:-1]
|
|
|
|
# No closing delimiter. This will not compile.
|
|
if token.str[-1] != delimiter:
|
|
continue
|
|
|
|
if len(symbols) < 2:
|
|
continue
|
|
|
|
if not hasNumericEscapeSequence(symbols):
|
|
continue
|
|
|
|
# String literals that contains one or more escape sequences. All of them should be
|
|
# terminated.
|
|
for sequence in ['\\' + t for t in symbols.split('\\')][1:]:
|
|
if (isHexEscapeSequence(sequence) or isOctalEscapeSequence(sequence) or
|
|
isSimpleEscapeSequence(sequence)):
|
|
continue
|
|
else:
|
|
self.reportError(token, 4, 1)
|
|
|
|
def misra_4_2(self, rawTokens):
|
|
for token in rawTokens:
|
|
if (token.str[0] != '"') or (token.str[-1] != '"'):
|
|
continue
|
|
# Check for trigraph sequence as defined by ISO/IEC 9899:1999
|
|
for sequence in ['??=', '??(', '??/', '??)', '??\'', '??<', '??!', '??>', '??-']:
|
|
if sequence in token.str[1:-1]:
|
|
# First trigraph sequence match, report error and leave loop.
|
|
self.reportError(token, 4, 2)
|
|
break
|
|
|
|
def misra_5_1(self, data):
|
|
long_vars = {}
|
|
num_sign_chars = self.get_num_significant_naming_chars(data)
|
|
for var in data.variables:
|
|
if var.nameToken is None:
|
|
continue
|
|
if len(var.nameToken.str) <= num_sign_chars:
|
|
continue
|
|
if not hasExternalLinkage(var):
|
|
continue
|
|
long_vars.setdefault(var.nameToken.str[:num_sign_chars], []).append(var.nameToken)
|
|
for name_prefix in long_vars:
|
|
tokens = long_vars[name_prefix]
|
|
if len(tokens) < 2:
|
|
continue
|
|
for tok in sorted(tokens, key=lambda t: (t.linenr, t.column))[1:]:
|
|
self.reportError(tok, 5, 1)
|
|
|
|
def misra_5_2(self, data):
|
|
scopeVars = {}
|
|
num_sign_chars = self.get_num_significant_naming_chars(data)
|
|
for var in data.variables:
|
|
if var.nameToken is None:
|
|
continue
|
|
if len(var.nameToken.str) <= num_sign_chars:
|
|
continue
|
|
if var.nameToken.scope not in scopeVars:
|
|
scopeVars.setdefault(var.nameToken.scope, {})["varlist"] = []
|
|
scopeVars.setdefault(var.nameToken.scope, {})["scopelist"] = []
|
|
scopeVars[var.nameToken.scope]["varlist"].append(var)
|
|
for scope in data.scopes:
|
|
if scope.nestedIn and scope.className:
|
|
if scope.nestedIn not in scopeVars:
|
|
scopeVars.setdefault(scope.nestedIn, {})["varlist"] = []
|
|
scopeVars.setdefault(scope.nestedIn, {})["scopelist"] = []
|
|
scopeVars[scope.nestedIn]["scopelist"].append(scope)
|
|
for scope in scopeVars:
|
|
if len(scopeVars[scope]["varlist"]) <= 1:
|
|
continue
|
|
for i, variable1 in enumerate(scopeVars[scope]["varlist"]):
|
|
for variable2 in scopeVars[scope]["varlist"][i + 1:]:
|
|
if variable1.isArgument and variable2.isArgument:
|
|
continue
|
|
if hasExternalLinkage(variable1) or hasExternalLinkage(variable2):
|
|
continue
|
|
if (variable1.nameToken.str[:num_sign_chars] == variable2.nameToken.str[:num_sign_chars] and
|
|
variable1 is not variable2):
|
|
if int(variable1.nameToken.linenr) > int(variable2.nameToken.linenr):
|
|
self.reportError(variable1.nameToken, 5, 2)
|
|
else:
|
|
self.reportError(variable2.nameToken, 5, 2)
|
|
for innerscope in scopeVars[scope]["scopelist"]:
|
|
if variable1.nameToken.str[:num_sign_chars] == innerscope.className[:num_sign_chars]:
|
|
if int(variable1.nameToken.linenr) > int(innerscope.bodyStart.linenr):
|
|
self.reportError(variable1.nameToken, 5, 2)
|
|
else:
|
|
self.reportError(innerscope.bodyStart, 5, 2)
|
|
if len(scopeVars[scope]["scopelist"]) <= 1:
|
|
continue
|
|
for i, scopename1 in enumerate(scopeVars[scope]["scopelist"]):
|
|
for scopename2 in scopeVars[scope]["scopelist"][i + 1:]:
|
|
if scopename1.className[:num_sign_chars] == scopename2.className[:num_sign_chars]:
|
|
if int(scopename1.bodyStart.linenr) > int(scopename2.bodyStart.linenr):
|
|
self.reportError(scopename1.bodyStart, 5, 2)
|
|
else:
|
|
self.reportError(scopename2.bodyStart, 5, 2)
|
|
|
|
def misra_5_4(self, data):
|
|
num_sign_chars = self.get_num_significant_naming_chars(data)
|
|
macro = {}
|
|
compile_name = re.compile(r'#define ([a-zA-Z0-9_]+)')
|
|
compile_param = re.compile(r'#define ([a-zA-Z0-9_]+)[(]([a-zA-Z0-9_, ]+)[)]')
|
|
short_names = {}
|
|
macro_w_arg = []
|
|
for dir in data.directives:
|
|
res1 = compile_name.match(dir.str)
|
|
if res1:
|
|
if dir not in macro:
|
|
macro.setdefault(dir, {})["name"] = []
|
|
macro.setdefault(dir, {})["params"] = []
|
|
full_name = res1.group(1)
|
|
macro[dir]["name"] = full_name
|
|
short_name = full_name[:num_sign_chars]
|
|
if short_name in short_names:
|
|
_dir = short_names[short_name]
|
|
if full_name != macro[_dir]["name"]:
|
|
self.reportError(dir, 5, 4)
|
|
else:
|
|
short_names[short_name] = dir
|
|
res2 = compile_param.match(dir.str)
|
|
if res2:
|
|
res_gp2 = res2.group(2).split(",")
|
|
res_gp2 = [macroname.replace(" ", "") for macroname in res_gp2]
|
|
macro[dir]["params"].extend(res_gp2)
|
|
macro_w_arg.append(dir)
|
|
for mvar in macro_w_arg:
|
|
for i, macroparam1 in enumerate(macro[mvar]["params"]):
|
|
for j, macroparam2 in enumerate(macro[mvar]["params"]):
|
|
if j > i and macroparam1[:num_sign_chars] == macroparam2[:num_sign_chars]:
|
|
self.reportError(mvar, 5, 4)
|
|
param = macroparam1
|
|
if param[:num_sign_chars] in short_names:
|
|
m_var1 = short_names[param[:num_sign_chars]]
|
|
if m_var1.linenr > mvar.linenr:
|
|
self.reportError(m_var1, 5, 4)
|
|
else:
|
|
self.reportError(mvar, 5, 4)
|
|
|
|
def misra_5_5(self, data):
|
|
num_sign_chars = self.get_num_significant_naming_chars(data)
|
|
macroNames = {}
|
|
compiled = re.compile(r'#define ([A-Za-z0-9_]+)')
|
|
for dir in data.directives:
|
|
res = compiled.match(dir.str)
|
|
if res:
|
|
macroNames[res.group(1)[:num_sign_chars]] = dir
|
|
for var in data.variables:
|
|
if var.nameToken and var.nameToken.str[:num_sign_chars] in macroNames:
|
|
self.reportError(var.nameToken, 5, 5)
|
|
for scope in data.scopes:
|
|
if scope.className and scope.className[:num_sign_chars] in macroNames:
|
|
self.reportError(scope.bodyStart, 5, 5)
|
|
|
|
|
|
def misra_5_6(self, dumpfile, typedefInfo):
|
|
self._save_ctu_summary_typedefs(dumpfile, typedefInfo)
|
|
|
|
def misra_5_7(self, dumpfile, cfg):
|
|
self._save_ctu_summary_tagnames(dumpfile, cfg)
|
|
|
|
def misra_5_8(self, dumpfile, cfg):
|
|
self._save_ctu_summary_identifiers(dumpfile, cfg)
|
|
|
|
def misra_5_9(self, dumpfile, cfg):
|
|
self._save_ctu_summary_identifiers(dumpfile, cfg)
|
|
|
|
def misra_6_1(self, data):
|
|
# Bitfield type must be bool or explicitly signed/unsigned int
|
|
for token in data.tokenlist:
|
|
if not token.valueType:
|
|
continue
|
|
if token.valueType.bits == 0:
|
|
continue
|
|
if not token.variable:
|
|
continue
|
|
if not token.scope:
|
|
continue
|
|
if token.scope.type not in 'Struct':
|
|
continue
|
|
|
|
if data.standards.c == 'c89':
|
|
if token.valueType.type != 'int' and not isUnsignedType(token.variable.typeStartToken.str):
|
|
self.reportError(token, 6, 1)
|
|
elif data.standards.c == 'c99':
|
|
if token.valueType.type == 'bool':
|
|
continue
|
|
|
|
isExplicitlySignedOrUnsigned = False
|
|
typeToken = token.variable.typeStartToken
|
|
while typeToken:
|
|
if typeToken.isUnsigned or typeToken.isSigned or isUnsignedType(typeToken.str):
|
|
isExplicitlySignedOrUnsigned = True
|
|
break
|
|
|
|
if typeToken is token.variable.typeEndToken:
|
|
break
|
|
|
|
typeToken = typeToken.next
|
|
|
|
if not isExplicitlySignedOrUnsigned:
|
|
self.reportError(token, 6, 1)
|
|
|
|
|
|
def misra_6_2(self, data):
|
|
# Bitfields of size 1 can not be signed
|
|
for token in data.tokenlist:
|
|
if not token.valueType:
|
|
continue
|
|
if not token.scope:
|
|
continue
|
|
if token.scope.type not in 'Struct':
|
|
continue
|
|
if token.valueType.bits == 1 and token.valueType.sign == 'signed':
|
|
self.reportError(token, 6, 2)
|
|
|
|
|
|
def misra_7_1(self, rawTokens):
|
|
compiled = re.compile(r'^0[0-7]+$')
|
|
for tok in rawTokens:
|
|
if compiled.match(tok.str):
|
|
self.reportError(tok, 7, 1)
|
|
|
|
def misra_7_2(self, data):
|
|
for token in data.tokenlist:
|
|
if token.isInt and ('U' not in token.str.upper()) and token.valueType and token.valueType.sign == 'unsigned':
|
|
self.reportError(token, 7, 2)
|
|
|
|
def misra_7_3(self, rawTokens):
|
|
compiled = re.compile(r'^[0-9.]+[Uu]*l+[Uu]*$')
|
|
for tok in rawTokens:
|
|
if compiled.match(tok.str):
|
|
self.reportError(tok, 7, 3)
|
|
|
|
def misra_7_4(self, data):
|
|
# A string literal shall not be assigned to an object unless the object's type
|
|
# is constant.
|
|
def reportErrorIfVariableIsNotConst(variable, stringLiteral):
|
|
if variable.valueType:
|
|
if (variable.valueType.constness % 2) != 1:
|
|
self.reportError(stringLiteral, 7, 4)
|
|
|
|
for token in data.tokenlist:
|
|
if token.isString:
|
|
# Check normal variable assignment
|
|
variable = getAssignedVariableToken(token)
|
|
if variable:
|
|
reportErrorIfVariableIsNotConst(variable, token)
|
|
|
|
# Check use as return value
|
|
function = getFunctionUsingReturnValue(token)
|
|
if function:
|
|
# "Primitive" test since there is no info available on return value type
|
|
if not tokenFollowsSequence(function.tokenDef, ['const', 'char', '*']):
|
|
self.reportError(token, 7, 4)
|
|
|
|
# Check use as function parameter
|
|
if isFunctionCall(token) and token.astOperand1 and token.astOperand1.function:
|
|
functionDeclaration = token.astOperand1.function
|
|
|
|
if functionDeclaration.tokenDef:
|
|
if functionDeclaration.tokenDef is token.astOperand1:
|
|
# Token is not a function call, but it is the definition of the function
|
|
continue
|
|
|
|
parametersUsed = getArguments(token)
|
|
for i in range(len(parametersUsed)):
|
|
usedParameter = parametersUsed[i]
|
|
parameterDefinition = functionDeclaration.argument.get(i+1)
|
|
|
|
if usedParameter.isString and parameterDefinition and parameterDefinition.nameToken:
|
|
reportErrorIfVariableIsNotConst(parameterDefinition.nameToken, usedParameter)
|
|
|
|
def misra_8_1(self, cfg):
|
|
for token in cfg.tokenlist:
|
|
if token.isImplicitInt and not token.isUnsigned and not token.isSigned:
|
|
self.reportError(token, 8, 1)
|
|
|
|
def misra_8_2(self, data, rawTokens):
|
|
def getFollowingRawTokens(rawTokens, token, count):
|
|
following =[]
|
|
for rawToken in rawTokens:
|
|
if (rawToken.file == token.file and
|
|
rawToken.linenr == token.linenr and
|
|
rawToken.column == token.column):
|
|
for _ in range(count):
|
|
rawToken = rawToken.next
|
|
# Skip comments
|
|
while rawToken and (rawToken.str.startswith('/*') or rawToken.str.startswith('//')):
|
|
rawToken = rawToken.next
|
|
if rawToken is None:
|
|
break
|
|
following.append(rawToken)
|
|
return following
|
|
|
|
# Zero arguments should be in form ( void )
|
|
def checkZeroArguments(func, startCall, endCall):
|
|
if not startCall.isRemovedVoidParameter and len(func.argument) == 0:
|
|
if func.tokenDef.next:
|
|
self.reportError(func.tokenDef.next, 8, 2)
|
|
else:
|
|
self.reportError(func.tokenDef, 8, 2)
|
|
|
|
def checkDeclarationArgumentsViolations(func, startCall, endCall):
|
|
# Collect the tokens for the arguments in function definition
|
|
argNameTokens = set()
|
|
for arg in func.argument:
|
|
argument = func.argument[arg]
|
|
typeStartToken = argument.typeStartToken
|
|
if typeStartToken is None:
|
|
continue
|
|
nameToken = argument.nameToken
|
|
if nameToken is None:
|
|
continue
|
|
argNameTokens.add(nameToken)
|
|
|
|
# Check if we have the same number of variables in both the
|
|
# declaration and the definition.
|
|
#
|
|
# TODO: We actually need to check if the names of the arguments are
|
|
# the same. But we can't do this because we have no links to
|
|
# variables in the arguments in function definition in the dump file.
|
|
foundVariables = 0
|
|
while startCall and startCall != endCall:
|
|
if startCall.varId:
|
|
foundVariables += 1
|
|
startCall = startCall.next
|
|
|
|
if len(argNameTokens) != foundVariables:
|
|
if func.tokenDef.next:
|
|
self.reportError(func.tokenDef.next, 8, 2)
|
|
else:
|
|
self.reportError(func.tokenDef, 8, 2)
|
|
|
|
def checkDefinitionArgumentsViolations(func, startCall, endCall):
|
|
for arg in func.argument:
|
|
argument = func.argument[arg]
|
|
typeStartToken = argument.typeStartToken
|
|
if typeStartToken is None:
|
|
continue
|
|
|
|
# Arguments should have a name unless variable length arg
|
|
nameToken = argument.nameToken
|
|
if nameToken is None and typeStartToken.str != '...':
|
|
self.reportError(typeStartToken, 8, 2)
|
|
|
|
# Type declaration on next line (old style declaration list) is not allowed
|
|
if typeStartToken.linenr > endCall.linenr:
|
|
self.reportError(typeStartToken, 8, 2)
|
|
|
|
# Check arguments in function declaration
|
|
for func in data.functions:
|
|
|
|
# Check arguments in function definition
|
|
tokenImpl = func.token
|
|
if tokenImpl:
|
|
startCall = tokenImpl.next
|
|
if startCall is None or startCall.str != '(':
|
|
continue
|
|
endCall = startCall.link
|
|
if endCall is None or endCall.str != ')':
|
|
continue
|
|
checkZeroArguments(func, startCall, endCall)
|
|
checkDefinitionArgumentsViolations(func, startCall, endCall)
|
|
|
|
# Check arguments in function declaration
|
|
tokenDef = func.tokenDef
|
|
if tokenDef:
|
|
startCall = func.tokenDef.next
|
|
if startCall is None or startCall.str != '(':
|
|
continue
|
|
endCall = startCall.link
|
|
if endCall is None or endCall.str != ')':
|
|
continue
|
|
checkZeroArguments(func, startCall, endCall)
|
|
if tokenImpl:
|
|
checkDeclarationArgumentsViolations(func, startCall, endCall)
|
|
else:
|
|
# When there is no function definition, we should execute
|
|
# its checks for the declaration token. The point is that without
|
|
# a known definition we have no Function.argument list required
|
|
# for declaration check.
|
|
checkDefinitionArgumentsViolations(func, startCall, endCall)
|
|
|
|
# Check arguments in pointer declarations
|
|
for var in data.variables:
|
|
if not var.isPointer:
|
|
continue
|
|
|
|
if var.nameToken is None:
|
|
continue
|
|
|
|
rawTokensFollowingPtr = getFollowingRawTokens(rawTokens, var.nameToken, 3)
|
|
if len(rawTokensFollowingPtr) != 3:
|
|
continue
|
|
|
|
# Compliant: returnType (*ptrName) ( ArgType )
|
|
# Non-compliant: returnType (*ptrName) ( )
|
|
if (rawTokensFollowingPtr[0].str == ')' and
|
|
rawTokensFollowingPtr[1].str == '(' and
|
|
rawTokensFollowingPtr[2].str == ')'):
|
|
self.reportError(var.nameToken, 8, 2)
|
|
|
|
|
|
def misra_8_4(self, cfg):
|
|
for func in cfg.functions:
|
|
if func.isStatic:
|
|
continue
|
|
if func.token is None:
|
|
continue
|
|
if not is_source_file(func.token.file):
|
|
continue
|
|
if func.token != func.tokenDef:
|
|
continue
|
|
if func.tokenDef.str == 'main':
|
|
continue
|
|
self.reportError(func.tokenDef, 8, 4)
|
|
|
|
extern_vars = []
|
|
var_defs = []
|
|
|
|
for var in cfg.variables:
|
|
if not var.isGlobal:
|
|
continue
|
|
if var.isStatic:
|
|
continue
|
|
if var.nameToken is None:
|
|
continue
|
|
if var.isExtern:
|
|
extern_vars.append(var.nameToken.str)
|
|
else:
|
|
var_defs.append(var.nameToken)
|
|
for vartok in var_defs:
|
|
if vartok.str not in extern_vars:
|
|
self.reportError(vartok, 8, 4)
|
|
|
|
def misra_8_5(self, dumpfile, cfg):
|
|
self._save_ctu_summary_identifiers(dumpfile, cfg)
|
|
|
|
def misra_8_6(self, dumpfile, cfg):
|
|
self._save_ctu_summary_identifiers(dumpfile, cfg)
|
|
|
|
def misra_8_7(self, dumpfile, cfg):
|
|
self._save_ctu_summary_usage(dumpfile, cfg)
|
|
|
|
def misra_8_8(self, cfg):
|
|
vars = {}
|
|
for var in cfg.variables:
|
|
if var.access != 'Global':
|
|
continue
|
|
if var.nameToken is None:
|
|
continue
|
|
varname = var.nameToken.str
|
|
if varname in vars:
|
|
vars[varname].append(var)
|
|
else:
|
|
vars[varname] = [var]
|
|
for varname, varlist in vars.items():
|
|
static_var = None
|
|
extern_var = None
|
|
for var in varlist:
|
|
if var.isStatic:
|
|
static_var = var
|
|
elif var.isExtern:
|
|
extern_var = var
|
|
if static_var and extern_var:
|
|
self.reportError(extern_var.nameToken, 8, 8)
|
|
|
|
def misra_8_9(self, cfg):
|
|
variables = {}
|
|
for scope in cfg.scopes:
|
|
if scope.type != 'Function':
|
|
continue
|
|
variables_used_in_scope = []
|
|
tok = scope.bodyStart
|
|
while tok != scope.bodyEnd:
|
|
if tok.variable and tok.variable.access == 'Global' and tok.variable.isStatic:
|
|
if tok.variable not in variables_used_in_scope:
|
|
variables_used_in_scope.append(tok.variable)
|
|
tok = tok.next
|
|
for var in variables_used_in_scope:
|
|
if var in variables:
|
|
variables[var] += 1
|
|
else:
|
|
variables[var] = 1
|
|
for var, count in variables.items():
|
|
if count == 1:
|
|
self.reportError(var.nameToken, 8, 9)
|
|
|
|
|
|
def misra_8_10(self, cfg):
|
|
for func in cfg.functions:
|
|
if func.isInlineKeyword and not func.isStatic:
|
|
self.reportError(func.tokenDef, 8, 10)
|
|
|
|
def misra_8_11(self, data):
|
|
for var in data.variables:
|
|
if var.isExtern and simpleMatch(var.nameToken.next, '[ ]') and var.nameToken.scope.type == 'Global':
|
|
self.reportError(var.nameToken, 8, 11)
|
|
|
|
def misra_8_12(self, data):
|
|
for scope in data.scopes:
|
|
if scope.type != 'Enum':
|
|
continue
|
|
enum_values = []
|
|
implicit_enum_values = []
|
|
e_token = scope.bodyStart.next
|
|
while e_token != scope.bodyEnd:
|
|
if e_token.str == '(':
|
|
e_token = e_token.link
|
|
continue
|
|
if e_token.previous.str not in ',{':
|
|
e_token = e_token.next
|
|
continue
|
|
if e_token.isName and e_token.values and e_token.valueType and e_token.valueType.typeScope == scope:
|
|
token_values = [v.intvalue for v in e_token.values]
|
|
enum_values += token_values
|
|
if e_token.next.str != "=":
|
|
implicit_enum_values += token_values
|
|
e_token = e_token.next
|
|
for implicit_enum_value in implicit_enum_values:
|
|
if enum_values.count(implicit_enum_value) != 1:
|
|
self.reportError(scope.bodyStart, 8, 12)
|
|
|
|
def misra_8_14(self, rawTokens):
|
|
for token in rawTokens:
|
|
if token.str == 'restrict':
|
|
self.reportError(token, 8, 14)
|
|
|
|
def misra_9_2(self, data):
|
|
misra_9.misra_9_x(self, data, 902)
|
|
|
|
def misra_9_3(self, data):
|
|
misra_9.misra_9_x(self, data, 903)
|
|
|
|
def misra_9_4(self, data):
|
|
misra_9.misra_9_x(self, data, 904)
|
|
|
|
def misra_9_5(self, data, rawTokens):
|
|
misra_9.misra_9_x(self, data, 905, rawTokens)
|
|
#for token in rawTokens:
|
|
# if simpleMatch(token, '[ ] = { ['):
|
|
# self.reportError(token, 9, 5)
|
|
|
|
def misra_10_1(self, data):
|
|
for token in data.tokenlist:
|
|
if not token.isOp:
|
|
continue
|
|
|
|
for t1, t2 in itertools.product(
|
|
list(getTernaryOperandsRecursive(token.astOperand1) or [token.astOperand1]),
|
|
list(getTernaryOperandsRecursive(token.astOperand2) or [token.astOperand2]),
|
|
):
|
|
e1 = getEssentialTypeCategory(t1)
|
|
e2 = getEssentialTypeCategory(t2)
|
|
if not e1 or not e2:
|
|
continue
|
|
if token.str in ('<<', '>>'):
|
|
if not isUnsignedType(e1):
|
|
self.reportError(token, 10, 1)
|
|
elif not isUnsignedType(e2) and not token.astOperand2.isNumber:
|
|
self.reportError(token, 10, 1)
|
|
elif token.str in ('~', '&', '|', '^'):
|
|
e1_et = getEssentialType(token.astOperand1)
|
|
e2_et = getEssentialType(token.astOperand2)
|
|
if e1_et == 'char' or e2_et == 'char':
|
|
self.reportError(token, 10, 1)
|
|
|
|
def misra_10_2(self, data):
|
|
def isEssentiallySignedOrUnsigned(op):
|
|
e = getEssentialType(op)
|
|
return e and (e.split(' ')[0] in ('unsigned', 'signed'))
|
|
|
|
def isEssentiallyChar(op):
|
|
if op is None:
|
|
return False
|
|
if op.str == '+':
|
|
return isEssentiallyChar(op.astOperand1) or isEssentiallyChar(op.astOperand2)
|
|
return op.isChar
|
|
|
|
for token in data.tokenlist:
|
|
if token.str not in ('+', '-'):
|
|
continue
|
|
|
|
if (not isEssentiallyChar(token.astOperand1)) and (not isEssentiallyChar(token.astOperand2)):
|
|
continue
|
|
|
|
if token.str == '+':
|
|
if isEssentiallyChar(token.astOperand1) and not isEssentiallySignedOrUnsigned(token.astOperand2):
|
|
self.reportError(token, 10, 2)
|
|
if isEssentiallyChar(token.astOperand2) and not isEssentiallySignedOrUnsigned(token.astOperand1):
|
|
self.reportError(token, 10, 2)
|
|
|
|
if token.str == '-':
|
|
e1 = getEssentialType(token.astOperand1)
|
|
if e1 and e1.split(' ')[-1] != 'char':
|
|
self.reportError(token, 10, 2)
|
|
if not isEssentiallyChar(token.astOperand2) and not isEssentiallySignedOrUnsigned(token.astOperand2):
|
|
self.reportError(token, 10, 2)
|
|
|
|
def misra_10_3(self, cfg):
|
|
def get_category(essential_type):
|
|
if essential_type:
|
|
if essential_type in ('bool', 'char'):
|
|
return essential_type
|
|
if essential_type.split(' ')[-1] in ('float', 'double'):
|
|
return 'floating'
|
|
if essential_type.split(' ')[0] in ('unsigned', 'signed'):
|
|
return essential_type.split(' ')[0]
|
|
return None
|
|
for tok in cfg.tokenlist:
|
|
if tok.isAssignmentOp:
|
|
lhs = getEssentialType(tok.astOperand1)
|
|
rhs = getEssentialType(tok.astOperand2)
|
|
#print(lhs)
|
|
#print(rhs)
|
|
if lhs is None or rhs is None:
|
|
continue
|
|
lhs_category = get_category(lhs)
|
|
rhs_category = get_category(rhs)
|
|
if lhs_category and rhs_category and lhs_category != rhs_category and rhs_category not in ('signed','unsigned'):
|
|
self.reportError(tok, 10, 3)
|
|
if bitsOfEssentialType(lhs) < bitsOfEssentialType(rhs):
|
|
self.reportError(tok, 10, 3)
|
|
|
|
|
|
def misra_10_4(self, data):
|
|
op = {'+', '-', '*', '/', '%', '&', '|', '^', '+=', '-=', ':'}
|
|
for token in data.tokenlist:
|
|
if token.str not in op and not token.isComparisonOp:
|
|
continue
|
|
if not token.astOperand1 or not token.astOperand2:
|
|
continue
|
|
if not token.astOperand1.valueType or not token.astOperand2.valueType:
|
|
continue
|
|
if ((token.astOperand1.str in op or token.astOperand1.isComparisonOp) and
|
|
(token.astOperand2.str in op or token.astOperand2.isComparisonOp)):
|
|
e1, e2 = getEssentialCategorylist(token.astOperand1.astOperand2, token.astOperand2.astOperand1)
|
|
elif token.astOperand1.str in op or token.astOperand1.isComparisonOp:
|
|
e1, e2 = getEssentialCategorylist(token.astOperand1.astOperand2, token.astOperand2)
|
|
elif token.astOperand2.str in op or token.astOperand2.isComparisonOp:
|
|
e1, e2 = getEssentialCategorylist(token.astOperand1, token.astOperand2.astOperand1)
|
|
else:
|
|
e1, e2 = getEssentialCategorylist(token.astOperand1, token.astOperand2)
|
|
if token.str == "+=" or token.str == "+":
|
|
if e1 == "char" and (e2 == "signed" or e2 == "unsigned"):
|
|
continue
|
|
if e2 == "char" and (e1 == "signed" or e1 == "unsigned"):
|
|
continue
|
|
if token.str == "-=" or token.str == "-":
|
|
if e1 == "char" and (e2 == "signed" or e2 == "unsigned"):
|
|
continue
|
|
if e1 and e2 and (e1.find('Anonymous') != -1 and (e2 == "signed" or e2 == "unsigned")):
|
|
continue
|
|
if e1 and e2 and (e2.find('Anonymous') != -1 and (e1 == "signed" or e1 == "unsigned")):
|
|
continue
|
|
if e1 and e2 and e1 != e2:
|
|
self.reportError(token, 10, 4)
|
|
|
|
def misra_10_5(self, cfg):
|
|
def _get_essential_category(token):
|
|
essential_type = getEssentialType(token)
|
|
#print(essential_type)
|
|
if essential_type:
|
|
if essential_type in ('bool', 'char'):
|
|
return essential_type
|
|
if essential_type.split(' ')[-1] in ('float', 'double'):
|
|
return 'floating'
|
|
if essential_type.split(' ')[0] in ('unsigned', 'signed'):
|
|
return essential_type.split(' ')[0]
|
|
return None
|
|
for token in cfg.tokenlist:
|
|
if not isCast(token):
|
|
continue
|
|
to_type = _get_essential_category(token)
|
|
#print(to_type)
|
|
if to_type is None:
|
|
continue
|
|
from_type = _get_essential_category(token.astOperand1)
|
|
#print(from_type)
|
|
if from_type is None:
|
|
continue
|
|
if to_type == from_type:
|
|
continue
|
|
if to_type == 'bool' or from_type == 'bool':
|
|
if token.astOperand1.isInt and token.astOperand1.getKnownIntValue() == 1:
|
|
# Exception
|
|
continue
|
|
self.reportError(token, 10, 5)
|
|
continue
|
|
if to_type == 'enum':
|
|
self.reportError(token, 10, 5)
|
|
continue
|
|
if from_type == 'float' and to_type == 'char':
|
|
self.reportError(token, 10, 5)
|
|
continue
|
|
if from_type == 'char' and to_type == 'float':
|
|
self.reportError(token, 10, 5)
|
|
continue
|
|
|
|
def misra_10_6(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str != '=' or not token.astOperand1 or not token.astOperand2:
|
|
continue
|
|
if not is_composite_expr(token.astOperand2):
|
|
continue
|
|
vt1 = token.astOperand1.valueType
|
|
vt2 = token.astOperand2.valueType
|
|
if not vt1 or vt1.pointer > 0:
|
|
continue
|
|
if not vt2 or vt2.pointer > 0:
|
|
continue
|
|
try:
|
|
if isCast(token.astOperand2):
|
|
e = vt2.type
|
|
else:
|
|
e = getEssentialType(token.astOperand2)
|
|
if not e:
|
|
continue
|
|
lhsbits = vt1.bits if vt1.bits else bitsOfEssentialType(vt1.type)
|
|
if lhsbits > bitsOfEssentialType(e):
|
|
self.reportError(token, 10, 6)
|
|
except ValueError:
|
|
pass
|
|
|
|
def misra_10_7(self, cfg):
|
|
for token in cfg.tokenlist:
|
|
if token.astOperand1 is None or token.astOperand2 is None:
|
|
continue
|
|
if not token.isArithmeticalOp:
|
|
continue
|
|
if not is_composite_expr(token):
|
|
continue
|
|
parent = token.astParent
|
|
if parent is None:
|
|
continue
|
|
if not parent.isArithmeticalOp:
|
|
if not parent.isAssignmentOp:
|
|
continue
|
|
if parent.str == '=':
|
|
continue
|
|
token_type = getEssentialType(token)
|
|
if token_type is None:
|
|
continue
|
|
sibling = parent.astOperand1 if (token == parent.astOperand2) else parent.astOperand2
|
|
sibling_type = getEssentialType(sibling)
|
|
if sibling_type is None:
|
|
continue
|
|
b1 = bitsOfEssentialType(token_type)
|
|
b2 = bitsOfEssentialType(sibling_type)
|
|
if b1 > 0 and b1 < b2:
|
|
self.reportError(token, 10, 7)
|
|
|
|
def misra_10_8(self, data):
|
|
for token in data.tokenlist:
|
|
if not isCast(token):
|
|
continue
|
|
if not token.valueType or token.valueType.pointer > 0:
|
|
continue
|
|
if not token.astOperand1.valueType or token.astOperand1.valueType.pointer > 0:
|
|
continue
|
|
if not token.astOperand1.astOperand1:
|
|
continue
|
|
if token.astOperand1.str not in ('+', '-', '*', '/', '%', '&', '|', '^', '>>', "<<", "?", ":", '~'):
|
|
continue
|
|
if token.astOperand1.str != '~' and not token.astOperand1.astOperand2:
|
|
continue
|
|
if token.astOperand1.str == '~':
|
|
e2 = getEssentialTypeCategory(token.astOperand1.astOperand1)
|
|
else:
|
|
e2, e3 = getEssentialCategorylist(token.astOperand1.astOperand1, token.astOperand1.astOperand2)
|
|
if e2 != e3:
|
|
continue
|
|
e1 = getEssentialTypeCategory(token)
|
|
if e1 != e2:
|
|
self.reportError(token, 10, 8)
|
|
else:
|
|
try:
|
|
e = getEssentialType(token.astOperand1)
|
|
if not e:
|
|
continue
|
|
if bitsOfEssentialType(token.valueType.type) > bitsOfEssentialType(e):
|
|
self.reportError(token, 10, 8)
|
|
except ValueError:
|
|
pass
|
|
|
|
def misra_11_1(self, data):
|
|
for token in data.tokenlist:
|
|
to_from = get_type_conversion_to_from(token)
|
|
if to_from is None:
|
|
continue
|
|
from_type = get_function_pointer_type(to_from[1])
|
|
if from_type is None:
|
|
continue
|
|
to_type = get_function_pointer_type(to_from[0])
|
|
if to_type is None or to_type != from_type:
|
|
self.reportError(token, 11, 1)
|
|
|
|
def misra_11_2(self, data):
|
|
def get_pointer_type(type_token):
|
|
while type_token and (type_token.str in ('const', 'struct')):
|
|
type_token = type_token.next
|
|
if type_token is None:
|
|
return None
|
|
if not type_token.isName:
|
|
return None
|
|
return type_token if (type_token.next and type_token.next.str == '*') else None
|
|
|
|
incomplete_types = []
|
|
|
|
for token in data.tokenlist:
|
|
if token.str == 'struct' and token.next and token.next.next and token.next.isName and token.next.next.str == ';':
|
|
incomplete_types.append(token.next.str)
|
|
to_from = get_type_conversion_to_from(token)
|
|
if to_from is None:
|
|
continue
|
|
to_pointer_type_token = get_pointer_type(to_from[0])
|
|
if to_pointer_type_token is None:
|
|
continue
|
|
from_pointer_type_token = get_pointer_type(to_from[1])
|
|
if from_pointer_type_token is None:
|
|
continue
|
|
if to_pointer_type_token.str == from_pointer_type_token.str:
|
|
continue
|
|
if from_pointer_type_token.typeScope is None and (from_pointer_type_token.str in incomplete_types):
|
|
self.reportError(token, 11, 2)
|
|
elif to_pointer_type_token.typeScope is None and (to_pointer_type_token.str in incomplete_types):
|
|
self.reportError(token, 11, 2)
|
|
|
|
def misra_11_3(self, data):
|
|
for token in data.tokenlist:
|
|
if not isCast(token):
|
|
continue
|
|
vt1 = token.valueType
|
|
vt2 = token.astOperand1.valueType
|
|
if not vt1 or not vt2:
|
|
continue
|
|
if vt1.type == 'void' or vt2.type == 'void':
|
|
continue
|
|
if (vt1.pointer > 0 and vt1.type == 'record' and
|
|
vt2.pointer > 0 and vt2.type == 'record' and
|
|
vt1.typeScopeId != vt2.typeScopeId):
|
|
self.reportError(token, 11, 3)
|
|
elif (vt1.pointer == vt2.pointer and vt1.pointer > 0 and
|
|
vt1.type != vt2.type and vt1.type != 'char'):
|
|
self.reportError(token, 11, 3)
|
|
|
|
def misra_11_4(self, data):
|
|
for token in data.tokenlist:
|
|
if not isCast(token):
|
|
continue
|
|
vt1 = token.valueType
|
|
vt2 = token.astOperand1.valueType
|
|
if not vt1 or not vt2:
|
|
continue
|
|
if vt2.pointer > 0 and vt1.pointer == 0 and (vt1.isIntegral() or vt1.isEnum()) and vt2.type != 'void':
|
|
self.reportError(token, 11, 4)
|
|
elif vt1.pointer > 0 and vt2.pointer == 0 and (vt2.isIntegral() or vt2.isEnum()) and vt1.type != 'void':
|
|
self.reportError(token, 11, 4)
|
|
|
|
def misra_11_5(self, data):
|
|
for token in data.tokenlist:
|
|
if not isCast(token):
|
|
if token.astOperand1 and token.astOperand2 and token.str == "=" and token.next.str != "(":
|
|
vt1 = token.astOperand1.valueType
|
|
vt2 = token.astOperand2.valueType
|
|
if not vt1 or not vt2:
|
|
continue
|
|
if vt1.pointer > 0 and vt1.type != 'void' and vt2.pointer == vt1.pointer and vt2.type == 'void':
|
|
self.reportError(token, 11, 5)
|
|
continue
|
|
if token.astOperand1.astOperand1 and token.astOperand1.astOperand1.str in (
|
|
'malloc', 'calloc', 'realloc', 'free'):
|
|
continue
|
|
vt1 = token.valueType
|
|
vt2 = token.astOperand1.valueType
|
|
if not vt1 or not vt2:
|
|
continue
|
|
if vt1.pointer > 0 and vt1.type != 'void' and vt2.pointer == vt1.pointer and vt2.type == 'void':
|
|
self.reportError(token, 11, 5)
|
|
|
|
def misra_11_6(self, data):
|
|
for token in data.tokenlist:
|
|
if not isCast(token):
|
|
continue
|
|
if token.astOperand1.astOperand1:
|
|
continue
|
|
vt1 = token.valueType
|
|
vt2 = token.astOperand1.valueType
|
|
if not vt1 or not vt2:
|
|
continue
|
|
if vt1.pointer == 1 and vt1.type == 'void' and vt2.pointer == 0 and token.astOperand1.str != "0":
|
|
self.reportError(token, 11, 6)
|
|
elif vt1.pointer == 0 and vt1.type != 'void' and vt2.pointer == 1 and vt2.type == 'void':
|
|
self.reportError(token, 11, 6)
|
|
|
|
def misra_11_7(self, data):
|
|
for token in data.tokenlist:
|
|
if not isCast(token):
|
|
continue
|
|
vt1 = token.valueType
|
|
vt2 = token.astOperand1.valueType
|
|
if not vt1 or not vt2:
|
|
continue
|
|
if token.astOperand1.astOperand1:
|
|
continue
|
|
if (vt2.pointer > 0 and vt1.pointer == 0 and
|
|
not vt1.isIntegral() and not vt1.isEnum() and
|
|
vt1.type != 'void'):
|
|
self.reportError(token, 11, 7)
|
|
elif (vt1.pointer > 0 and vt2.pointer == 0 and
|
|
not vt2.isIntegral() and not vt2.isEnum() and
|
|
vt1.type != 'void'):
|
|
self.reportError(token, 11, 7)
|
|
|
|
def misra_11_8(self, data):
|
|
# TODO: reuse code in CERT-EXP05
|
|
for token in data.tokenlist:
|
|
if isCast(token):
|
|
# C-style cast
|
|
if not token.valueType:
|
|
continue
|
|
if not token.astOperand1.valueType:
|
|
continue
|
|
if token.valueType.pointer == 0:
|
|
continue
|
|
if token.astOperand1.valueType.pointer == 0:
|
|
continue
|
|
const1 = token.valueType.constness
|
|
const2 = token.astOperand1.valueType.constness
|
|
if (const1 % 2) < (const2 % 2):
|
|
self.reportError(token, 11, 8)
|
|
|
|
elif token.str == '(' and token.astOperand1 and token.astOperand2 and token.astOperand1.function:
|
|
# Function call
|
|
function = token.astOperand1.function
|
|
arguments = getArguments(token)
|
|
for argnr, argvar in function.argument.items():
|
|
if argnr < 1 or argnr > len(arguments):
|
|
continue
|
|
if not argvar.isPointer:
|
|
continue
|
|
argtok = arguments[argnr - 1]
|
|
if not argtok.valueType:
|
|
continue
|
|
if argtok.valueType.pointer == 0:
|
|
continue
|
|
const1 = argvar.constness
|
|
const2 = arguments[argnr - 1].valueType.constness
|
|
if (const1 % 2) < (const2 % 2):
|
|
self.reportError(token, 11, 8)
|
|
|
|
def misra_11_9(self, data):
|
|
for token in data.tokenlist:
|
|
if token.astOperand1 and token.astOperand2 and token.str in ["=", "==", "!=", "?", ":"]:
|
|
vt1 = token.astOperand1.valueType
|
|
vt2 = token.astOperand2.valueType
|
|
if not vt1 or not vt2:
|
|
continue
|
|
if vt1.pointer > 0 and vt2.pointer == 0 and token.astOperand2.str == "NULL":
|
|
continue
|
|
if (token.astOperand2.values and vt1.pointer > 0 and
|
|
vt2.pointer == 0 and token.astOperand2.values):
|
|
if token.astOperand2.getValue(0):
|
|
self.reportError(token, 11, 9)
|
|
|
|
def misra_12_1_sizeof(self, rawTokens):
|
|
state = 0
|
|
compiled = re.compile(r'^[a-zA-Z_]')
|
|
for tok in rawTokens:
|
|
if tok.str.startswith('//') or tok.str.startswith('/*'):
|
|
continue
|
|
if tok.str == 'sizeof':
|
|
state = 1
|
|
elif state == 1:
|
|
if compiled.match(tok.str):
|
|
state = 2
|
|
else:
|
|
state = 0
|
|
elif state == 2:
|
|
if tok.str in ('+', '-', '*', '/', '%'):
|
|
self.reportError(tok, 12, 1)
|
|
else:
|
|
state = 0
|
|
|
|
def misra_12_1(self, data):
|
|
for token in data.tokenlist:
|
|
p = getPrecedence(token)
|
|
if p < 2 or p > 12:
|
|
continue
|
|
p1 = getPrecedence(token.astOperand1)
|
|
if p < p1 <= 12 and numberOfParentheses(token.astOperand1, token):
|
|
self.reportError(token, 12, 1)
|
|
continue
|
|
p2 = getPrecedence(token.astOperand2)
|
|
if p < p2 <= 12 and numberOfParentheses(token, token.astOperand2):
|
|
self.reportError(token, 12, 1)
|
|
continue
|
|
|
|
def misra_12_2(self, data):
|
|
for token in data.tokenlist:
|
|
if not (token.str in ('<<', '>>')):
|
|
continue
|
|
if (not token.astOperand2) or (not token.astOperand2.values):
|
|
continue
|
|
maxval = 0
|
|
for val in token.astOperand2.values:
|
|
if val.intvalue and val.intvalue > maxval:
|
|
maxval = val.intvalue
|
|
if maxval == 0:
|
|
continue
|
|
sz = bitsOfEssentialType(getEssentialType(token.astOperand1))
|
|
if sz <= 0:
|
|
continue
|
|
if maxval >= sz:
|
|
self.reportError(token, 12, 2)
|
|
|
|
def misra_12_3(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str == ';' and (token.isSplittedVarDeclComma is True):
|
|
self.reportError(token, 12, 3)
|
|
if token.str == ',' and token.astParent and token.astParent.str == ';':
|
|
self.reportError(token, 12, 3)
|
|
if token.str == ',' and token.astParent is None:
|
|
if token.scope.type in ('Class', 'Struct'):
|
|
# Is this initlist..
|
|
tok = token
|
|
while tok and tok.str == ',':
|
|
tok = tok.next
|
|
if tok and tok.next and tok.isName and tok.next.str == '(':
|
|
tok = tok.next.link.next
|
|
if tok.str == '{':
|
|
# This comma is used in initlist, do not warn
|
|
continue
|
|
prev = token.previous
|
|
while prev:
|
|
if prev.str == ';':
|
|
self.reportError(token, 12, 3)
|
|
break
|
|
elif prev.str in ')}]':
|
|
prev = prev.link
|
|
elif prev.str in '({[':
|
|
break
|
|
prev = prev.previous
|
|
|
|
def misra_12_4(self, cfg):
|
|
for expr in cfg.tokenlist:
|
|
if not expr.astOperand2 or not expr.astOperand1:
|
|
continue
|
|
if expr.valueType is None:
|
|
continue
|
|
if expr.valueType.sign is None or expr.valueType.sign != 'unsigned':
|
|
continue
|
|
if expr.valueType.pointer > 0:
|
|
continue
|
|
if not expr.valueType.isIntegral():
|
|
continue
|
|
op1 = expr.astOperand1.getKnownIntValue()
|
|
if op1 is None:
|
|
continue
|
|
op2 = expr.astOperand2.getKnownIntValue()
|
|
if op2 is None:
|
|
continue
|
|
bits = bitsOfEssentialType('unsigned ' + expr.valueType.type)
|
|
if bits <= 0 or bits >= 64:
|
|
continue
|
|
max_value = (1 << bits) - 1
|
|
if not is_constant_integer_expression(expr):
|
|
continue
|
|
if expr.str == '+' and op1 + op2 > max_value:
|
|
self.reportError(expr, 12, 4)
|
|
elif expr.str == '-' and op1 - op2 < 0:
|
|
self.reportError(expr, 12, 4)
|
|
elif expr.str == '*' and op1 * op2 > max_value:
|
|
self.reportError(expr, 12, 4)
|
|
|
|
|
|
def misra_13_1(self, data):
|
|
for token in data.tokenlist:
|
|
if simpleMatch(token, ") {") and token.next.astParent == token.link:
|
|
pass
|
|
elif not simpleMatch(token, '= {'):
|
|
continue
|
|
init = token.next
|
|
end = init.link
|
|
if not end:
|
|
continue # syntax is broken
|
|
|
|
tn = init
|
|
while tn and tn != end:
|
|
if tn.str == '[' and tn.link:
|
|
tn = tn.link
|
|
if tn and tn.next and tn.next.str == '=':
|
|
tn = tn.next.next
|
|
continue
|
|
else:
|
|
break
|
|
if tn.str == '.' and tn.next and tn.next.isName:
|
|
tn = tn.next
|
|
if tn.next and tn.next.str == '=':
|
|
tn = tn.next.next
|
|
continue
|
|
if tn.str in {'++', '--'} or tn.isAssignmentOp:
|
|
self.reportError(init, 13, 1)
|
|
tn = tn.next
|
|
|
|
def misra_13_3(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str not in ('++', '--'):
|
|
continue
|
|
astTop = token
|
|
while astTop.astParent and astTop.astParent.str not in (',', ';'):
|
|
astTop = astTop.astParent
|
|
if countSideEffects(astTop) >= 2:
|
|
self.reportError(astTop, 13, 3)
|
|
|
|
def misra_13_4(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str != '=':
|
|
continue
|
|
if not token.astParent:
|
|
continue
|
|
if (token.astOperand1 is None) or (token.astOperand2 is None):
|
|
continue
|
|
if token.astOperand1.str == '[' and token.astOperand1.previous.str in ('{', ','):
|
|
continue
|
|
if not (token.astParent.str in [',', ';', '{']):
|
|
self.reportError(token, 13, 4)
|
|
|
|
def misra_13_5(self, data):
|
|
for token in data.tokenlist:
|
|
if token.isLogicalOp and countSideEffectsRecursive(token.astOperand2) > 0:
|
|
self.reportError(token, 13, 5)
|
|
|
|
def misra_13_6(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str == 'sizeof' and countSideEffectsRecursive(token.next) > 0:
|
|
self.reportError(token, 13, 6)
|
|
|
|
def misra_14_1(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str == 'for':
|
|
exprs = getForLoopExpressions(token)
|
|
if not exprs:
|
|
continue
|
|
for counter in findCounterTokens(exprs[1]):
|
|
if counter.valueType and counter.valueType.isFloat():
|
|
self.reportError(token, 14, 1)
|
|
elif token.str == 'while':
|
|
if isFloatCounterInWhileLoop(token):
|
|
self.reportError(token, 14, 1)
|
|
|
|
def misra_14_2(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str == 'for':
|
|
expressions = getForLoopExpressions(token)
|
|
if not expressions:
|
|
continue
|
|
if expressions[0] and not expressions[0].isAssignmentOp:
|
|
self.reportError(token, 14, 2)
|
|
if countSideEffectsRecursive(expressions[1]) > 0:
|
|
self.reportError(token, 14, 2)
|
|
if countSideEffectsRecursive(expressions[2]) > 1:
|
|
self.reportError(token, 14, 2)
|
|
|
|
counter_vars_first_clause, counter_vars_exit_modified = getForLoopCounterVariables(token)
|
|
if len(counter_vars_exit_modified) == 0:
|
|
# if it's not possible to identify a loop counter, all 3 clauses must be empty
|
|
for idx in range(len(expressions)):
|
|
if expressions[idx]:
|
|
self.reportError(token, 14, 2)
|
|
break
|
|
elif len(counter_vars_exit_modified) > 1:
|
|
# there shall be a single loop counter
|
|
self.reportError(token, 14, 2)
|
|
else: # len(counter_vars_exit_modified) == 1:
|
|
loop_counter = counter_vars_exit_modified.pop()
|
|
# if the first clause is not empty, then it shall (declare and) initialize the loop counter
|
|
if expressions[0] is not None and loop_counter not in counter_vars_first_clause:
|
|
self.reportError(token, 14, 2)
|
|
|
|
# Inspect modification of loop counter in loop body
|
|
body_scope = token.next.link.next.scope
|
|
if not body_scope:
|
|
continue
|
|
tn = body_scope.bodyStart
|
|
while tn and tn != body_scope.bodyEnd:
|
|
if tn.variable == loop_counter:
|
|
if tn.next:
|
|
# TODO: Check modifications in function calls
|
|
if countSideEffectsRecursive(tn.next) > 0:
|
|
self.reportError(tn, 14, 2)
|
|
tn = tn.next
|
|
|
|
def misra_14_4(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str != '(':
|
|
continue
|
|
if not token.astOperand1 or not (token.astOperand1.str in ['if', 'while']):
|
|
continue
|
|
if not isBoolExpression(token.astOperand2):
|
|
self.reportError(token, 14, 4)
|
|
|
|
def misra_15_1(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str == "goto":
|
|
self.reportError(token, 15, 1)
|
|
|
|
def misra_15_2(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str != 'goto':
|
|
continue
|
|
if (not token.next) or (not token.next.isName):
|
|
continue
|
|
if not findGotoLabel(token):
|
|
self.reportError(token, 15, 2)
|
|
|
|
def misra_15_3(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str != 'goto':
|
|
continue
|
|
if (not token.next) or (not token.next.isName):
|
|
continue
|
|
tok = findGotoLabel(token)
|
|
if not tok:
|
|
continue
|
|
scope = token.scope
|
|
while scope and scope != tok.scope:
|
|
scope = scope.nestedIn
|
|
if not scope:
|
|
self.reportError(token, 15, 3)
|
|
# Jump crosses from one switch-clause to another is non-compliant
|
|
elif scope.type == 'Switch':
|
|
# Search for start of a current case block
|
|
tcase_start = token
|
|
while tcase_start and tcase_start.str not in ('case', 'default'):
|
|
tcase_start = tcase_start.previous
|
|
# Make sure that goto label doesn't occurs in the other
|
|
# switch-clauses
|
|
if tcase_start:
|
|
t = scope.bodyStart
|
|
in_this_case = False
|
|
while t and t != scope.bodyEnd:
|
|
if t == tcase_start:
|
|
in_this_case = True
|
|
if in_this_case and t.str not in ('case', 'default'):
|
|
in_this_case = False
|
|
if t == tok and not in_this_case:
|
|
self.reportError(token, 15, 3)
|
|
break
|
|
t = t.next
|
|
|
|
def misra_15_4(self, data):
|
|
# Return a list of scopes affected by a break or goto
|
|
def getLoopsAffectedByBreak(knownLoops, scope, isGoto):
|
|
if scope and scope.type and scope.type not in ['Global', 'Function']:
|
|
if not isGoto and scope.type == 'Switch':
|
|
return
|
|
if scope.type in ['For', 'While', 'Do']:
|
|
knownLoops.append(scope)
|
|
if not isGoto:
|
|
return
|
|
getLoopsAffectedByBreak(knownLoops, scope.nestedIn, isGoto)
|
|
|
|
loopWithBreaks = {}
|
|
for token in data.tokenlist:
|
|
if token.str not in ['break', 'goto']:
|
|
continue
|
|
|
|
affectedLoopScopes = []
|
|
getLoopsAffectedByBreak(affectedLoopScopes, token.scope, token.str == 'goto')
|
|
for scope in affectedLoopScopes:
|
|
if scope in loopWithBreaks:
|
|
loopWithBreaks[scope] += 1
|
|
else:
|
|
loopWithBreaks[scope] = 1
|
|
|
|
for scope, breakCount in loopWithBreaks.items():
|
|
if breakCount > 1:
|
|
self.reportError(scope.bodyStart, 15, 4)
|
|
|
|
def misra_15_5(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str == 'return' and token.scope.type != 'Function':
|
|
self.reportError(token, 15, 5)
|
|
|
|
def misra_15_6(self, rawTokens):
|
|
state = 0
|
|
indent = 0
|
|
tok1 = None
|
|
def tokAt(tok,i):
|
|
while i < 0 and tok:
|
|
tok = tok.previous
|
|
if tok.str.startswith('//') or tok.str.startswith('/*'):
|
|
continue
|
|
i += 1
|
|
while i > 0 and tok:
|
|
tok = tok.next
|
|
if tok.str.startswith('//') or tok.str.startswith('/*'):
|
|
continue
|
|
i -= 1
|
|
return tok
|
|
|
|
def strtokens(tok, i1, i2):
|
|
tok1 = tokAt(tok, i1)
|
|
tok2 = tokAt(tok, i2)
|
|
tok = tok1
|
|
s = ''
|
|
while tok != tok2:
|
|
if tok.str.startswith('//') or tok.str.startswith('/*'):
|
|
tok = tok.next
|
|
continue
|
|
s += ' ' + tok.str
|
|
tok = tok.next
|
|
s += ' ' + tok.str
|
|
return s[1:]
|
|
|
|
for token in rawTokens:
|
|
if token.str in ['if', 'for', 'while']:
|
|
if strtokens(token,-1,0) == '# if':
|
|
continue
|
|
if strtokens(token,-1,0) == "} while":
|
|
# is there a 'do { .. } while'?
|
|
start = rawlink(tokAt(token,-1))
|
|
if start and strtokens(start, -1, 0) == 'do {':
|
|
continue
|
|
if state == 2:
|
|
self.reportError(tok1, 15, 6)
|
|
state = 1
|
|
indent = 0
|
|
tok1 = token
|
|
elif token.str == 'else':
|
|
if strtokens(token,-1,0) == '# else':
|
|
continue
|
|
if strtokens(token,0,1) == 'else if':
|
|
continue
|
|
if state == 2:
|
|
self.reportError(tok1, 15, 6)
|
|
state = 2
|
|
indent = 0
|
|
tok1 = token
|
|
elif state == 1:
|
|
if indent == 0 and token.str != '(':
|
|
state = 0
|
|
continue
|
|
if token.str == '(':
|
|
indent = indent + 1
|
|
elif token.str == ')':
|
|
if indent == 0:
|
|
state = 0
|
|
elif indent == 1:
|
|
state = 2
|
|
indent = indent - 1
|
|
elif state == 2:
|
|
if token.str.startswith('//') or token.str.startswith('/*'):
|
|
continue
|
|
state = 0
|
|
if token.str not in ('{', '#'):
|
|
self.reportError(tok1, 15, 6)
|
|
|
|
def misra_15_7(self, data):
|
|
for scope in data.scopes:
|
|
if scope.type != 'Else':
|
|
continue
|
|
if not simpleMatch(scope.bodyStart, '{ if ('):
|
|
continue
|
|
if scope.bodyStart.column > 0:
|
|
continue
|
|
tok = scope.bodyStart.next.next.link
|
|
if not simpleMatch(tok, ') {'):
|
|
continue
|
|
tok = tok.next.link
|
|
if not simpleMatch(tok, '} else'):
|
|
self.reportError(tok, 15, 7)
|
|
|
|
def misra_16_1(self, cfg):
|
|
for scope in cfg.scopes:
|
|
if scope.type != 'Switch':
|
|
continue
|
|
in_case_or_default = False
|
|
tok = scope.bodyStart.next
|
|
while tok != scope.bodyEnd:
|
|
if not in_case_or_default:
|
|
if tok.str not in ('case', 'default'):
|
|
self.reportError(tok, 16, 1)
|
|
else:
|
|
in_case_or_default = True
|
|
else:
|
|
if simpleMatch(tok, 'break ;'):
|
|
in_case_or_default = False
|
|
tok = tok.next
|
|
if tok.str == '{':
|
|
tok = tok.link
|
|
if tok.scope.type == 'Unconditional' and simpleMatch(tok.previous.previous, 'break ;'):
|
|
in_case_or_default = False
|
|
tok = tok.next
|
|
|
|
def misra_16_2(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str == 'case' and token.scope.type != 'Switch':
|
|
self.reportError(token, 16, 2)
|
|
|
|
def misra_16_3(self, rawTokens):
|
|
STATE_NONE = 0 # default state, not in switch case/default block
|
|
STATE_BREAK = 1 # break/comment is seen but not its ';'
|
|
STATE_OK = 2 # a case/default is allowed (we have seen 'break;'/'comment'/'{'/attribute)
|
|
STATE_SWITCH = 3 # walking through switch statement scope
|
|
|
|
define = None
|
|
state = STATE_NONE
|
|
end_switch_token = None # end '}' for the switch scope
|
|
for token in rawTokens:
|
|
if simpleMatch(token, '# define'):
|
|
define = token
|
|
if define:
|
|
if token.linenr != define.linenr:
|
|
define = None
|
|
else:
|
|
continue
|
|
|
|
# Find switch scope borders
|
|
if token.str == 'switch':
|
|
state = STATE_SWITCH
|
|
if state == STATE_SWITCH:
|
|
if token.str == '{':
|
|
end_switch_token = findRawLink(token)
|
|
else:
|
|
continue
|
|
|
|
if token.str == 'break' or token.str == 'return' or token.str == 'throw':
|
|
state = STATE_BREAK
|
|
elif token.str == ';':
|
|
if state == STATE_BREAK:
|
|
state = STATE_OK
|
|
elif token.next and token.next == end_switch_token:
|
|
self.reportError(token.next, 16, 3)
|
|
else:
|
|
state = STATE_NONE
|
|
elif token.str.startswith('/*') or token.str.startswith('//'):
|
|
if 'fallthrough' in token.str.lower():
|
|
state = STATE_OK
|
|
elif simpleMatch(token, '[ [ fallthrough ] ] ;'):
|
|
state = STATE_BREAK
|
|
elif token.str == '{':
|
|
state = STATE_OK
|
|
elif token.str == '}' and state == STATE_OK:
|
|
# is this {} an unconditional block of code?
|
|
prev = findRawLink(token)
|
|
if prev:
|
|
prev = prev.previous
|
|
while prev and prev.str[:2] in ('//', '/*'):
|
|
prev = prev.previous
|
|
if (prev is None) or (prev.str not in ':;{}'):
|
|
state = STATE_NONE
|
|
elif token.str == 'case' or token.str == 'default':
|
|
if state != STATE_OK:
|
|
self.reportError(token, 16, 3)
|
|
state = STATE_OK
|
|
|
|
def misra_16_4(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str != 'switch':
|
|
continue
|
|
if not simpleMatch(token, 'switch ('):
|
|
continue
|
|
if not simpleMatch(token.next.link, ') {'):
|
|
continue
|
|
startTok = token.next.link.next
|
|
tok = startTok.next
|
|
while tok and tok.str != '}':
|
|
if tok.str == '{':
|
|
tok = tok.link
|
|
elif tok.str == 'default':
|
|
break
|
|
tok = tok.next
|
|
if tok and tok.str != 'default':
|
|
self.reportError(token, 16, 4)
|
|
|
|
def misra_16_5(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str != 'default':
|
|
continue
|
|
if token.previous and token.previous.str == '{':
|
|
continue
|
|
tok2 = token
|
|
while tok2:
|
|
if tok2.str in ('}', 'case'):
|
|
break
|
|
if tok2.str == '{':
|
|
tok2 = tok2.link
|
|
tok2 = tok2.next
|
|
if tok2 and tok2.str == 'case':
|
|
self.reportError(token, 16, 5)
|
|
|
|
def misra_16_6(self, data):
|
|
for token in data.tokenlist:
|
|
if not (simpleMatch(token, 'switch (') and simpleMatch(token.next.link, ') {')):
|
|
continue
|
|
tok = token.next.link.next.next
|
|
count = 0
|
|
while tok:
|
|
if tok.str in ['break', 'return', 'throw']:
|
|
count = count + 1
|
|
elif tok.str == '{':
|
|
tok = tok.link
|
|
if isNoReturnScope(tok):
|
|
count = count + 1
|
|
elif tok.str == '}':
|
|
break
|
|
tok = tok.next
|
|
if count < 2:
|
|
self.reportError(token, 16, 6)
|
|
|
|
def misra_16_7(self, data):
|
|
for token in data.tokenlist:
|
|
if simpleMatch(token, 'switch (') and isBoolExpression(token.next.astOperand2):
|
|
self.reportError(token, 16, 7)
|
|
|
|
def misra_17_1(self, data):
|
|
for token in data.tokenlist:
|
|
if isFunctionCall(token) and token.astOperand1.str in (
|
|
'va_list', 'va_arg', 'va_start', 'va_end', 'va_copy'):
|
|
self.reportError(token, 17, 1)
|
|
elif token.str == 'va_list':
|
|
self.reportError(token, 17, 1)
|
|
|
|
def misra_17_2(self, data):
|
|
# find recursions..
|
|
def find_recursive_call(search_for_function, direct_call, calls_map, visited=None):
|
|
if visited is None:
|
|
visited = set()
|
|
if direct_call == search_for_function:
|
|
return True
|
|
for indirect_call in calls_map.get(direct_call, []):
|
|
if indirect_call == search_for_function:
|
|
return True
|
|
if indirect_call in visited:
|
|
# This has already been handled
|
|
continue
|
|
visited.add(indirect_call)
|
|
if find_recursive_call(search_for_function, indirect_call, calls_map, visited):
|
|
return True
|
|
return False
|
|
|
|
# List functions called in each function
|
|
function_calls = {}
|
|
for scope in data.scopes:
|
|
if scope.type != 'Function':
|
|
continue
|
|
calls = []
|
|
tok = scope.bodyStart
|
|
while tok != scope.bodyEnd:
|
|
tok = tok.next
|
|
if not isFunctionCall(tok, data.standards.c):
|
|
continue
|
|
f = tok.astOperand1.function
|
|
if f is not None and f not in calls:
|
|
calls.append(f)
|
|
function_calls[scope.function] = calls
|
|
|
|
# Report warnings for all recursions..
|
|
for func in function_calls:
|
|
for call in function_calls[func]:
|
|
if not find_recursive_call(func, call, function_calls):
|
|
# Function call is not recursive
|
|
continue
|
|
# Warn about all functions calls..
|
|
for scope in data.scopes:
|
|
if scope.type != 'Function' or scope.function != func:
|
|
continue
|
|
tok = scope.bodyStart
|
|
while tok != scope.bodyEnd:
|
|
if tok.function and tok.function == call:
|
|
self.reportError(tok, 17, 2)
|
|
tok = tok.next
|
|
|
|
def misra_17_3(self, cfg):
|
|
for w in cfg.clang_warnings:
|
|
if w['message'].endswith('[-Wimplicit-function-declaration]'):
|
|
self.reportError(cppcheckdata.Location(w), 17, 3)
|
|
|
|
def misra_17_6(self, rawTokens):
|
|
for token in rawTokens:
|
|
if simpleMatch(token, '[ static'):
|
|
self.reportError(token, 17, 6)
|
|
|
|
def misra_17_7(self, data):
|
|
for token in data.tokenlist:
|
|
if not token.scope.isExecutable:
|
|
continue
|
|
if token.str != '(' or token.astParent:
|
|
continue
|
|
if not token.previous.isName or token.previous.varId:
|
|
continue
|
|
if token.valueType is None:
|
|
continue
|
|
if token.valueType.type == 'void' and token.valueType.pointer == 0:
|
|
continue
|
|
self.reportError(token, 17, 7)
|
|
|
|
def misra_17_8(self, data):
|
|
for token in data.tokenlist:
|
|
if not (token.isAssignmentOp or (token.str in ('++', '--'))):
|
|
continue
|
|
if not token.astOperand1:
|
|
continue
|
|
var = token.astOperand1.variable
|
|
if var and var.isArgument:
|
|
self.reportError(token, 17, 8)
|
|
|
|
def misra_18_4(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str not in ('+', '-', '+=', '-='):
|
|
continue
|
|
if token.astOperand1 is None or token.astOperand2 is None:
|
|
continue
|
|
vt1 = token.astOperand1.valueType
|
|
vt2 = token.astOperand2.valueType
|
|
if vt1 and vt1.pointer > 0:
|
|
self.reportError(token, 18, 4)
|
|
elif vt2 and vt2.pointer > 0:
|
|
self.reportError(token, 18, 4)
|
|
|
|
def misra_18_5(self, data):
|
|
for var in data.variables:
|
|
if not var.isPointer:
|
|
continue
|
|
typetok = var.nameToken
|
|
count = 0
|
|
while typetok:
|
|
if typetok.str == '*':
|
|
count = count + 1
|
|
elif not typetok.isName:
|
|
break
|
|
typetok = typetok.previous
|
|
if count > 2:
|
|
self.reportError(var.nameToken, 18, 5)
|
|
|
|
def misra_18_7(self, data):
|
|
for scope in data.scopes:
|
|
if scope.type != 'Struct':
|
|
continue
|
|
|
|
token = scope.bodyStart.next
|
|
while token != scope.bodyEnd and token is not None:
|
|
# Handle nested structures to not duplicate an error.
|
|
if token.str == '{':
|
|
token = token.link
|
|
|
|
if cppcheckdata.simpleMatch(token, "[ ]"):
|
|
self.reportError(token, 18, 7)
|
|
break
|
|
token = token.next
|
|
|
|
def misra_18_8(self, data):
|
|
for var in data.variables:
|
|
if not var.isArray or not var.isLocal:
|
|
continue
|
|
# TODO Array dimensions are not available in dump, must look in tokens
|
|
typetok = var.nameToken.next
|
|
if not typetok or typetok.str != '[':
|
|
continue
|
|
# Unknown define or syntax error
|
|
if not typetok.astOperand2:
|
|
continue
|
|
if not isConstantExpression(typetok.astOperand2):
|
|
self.reportError(var.nameToken, 18, 8)
|
|
|
|
def misra_19_2(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str == 'union':
|
|
self.reportError(token, 19, 2)
|
|
|
|
def misra_20_1(self, data):
|
|
token_in_file = {}
|
|
for token in data.tokenlist:
|
|
if token.file not in token_in_file:
|
|
token_in_file[token.file] = int(token.linenr)
|
|
else:
|
|
token_in_file[token.file] = min(token_in_file[token.file], int(token.linenr))
|
|
|
|
for directive in data.directives:
|
|
if not directive.str.startswith('#include'):
|
|
continue
|
|
if directive.file not in token_in_file:
|
|
continue
|
|
if token_in_file[directive.file] < int(directive.linenr):
|
|
self.reportError(directive, 20, 1)
|
|
|
|
def misra_20_2(self, data):
|
|
for directive in data.directives:
|
|
if not directive.str.startswith('#include '):
|
|
continue
|
|
for pattern in ('\\', '//', '/*', ',', "'"):
|
|
if pattern in directive.str:
|
|
self.reportError(directive, 20, 2)
|
|
break
|
|
|
|
def misra_20_3(self, data):
|
|
for directive in data.directives:
|
|
if not directive.str.startswith('#include '):
|
|
continue
|
|
|
|
words = directive.str.split(' ')
|
|
|
|
# If include directive contains more than two words, here would be
|
|
# violation anyway.
|
|
if len(words) > 2:
|
|
self.reportError(directive, 20, 3)
|
|
|
|
# Handle include directives with not quoted argument
|
|
elif len(words) > 1:
|
|
filename = words[1]
|
|
if not ((filename.startswith('"') and
|
|
filename.endswith('"')) or
|
|
(filename.startswith('<') and
|
|
filename.endswith('>'))):
|
|
# We are handle only directly included files in the
|
|
# following format: #include file.h
|
|
# Cases with macro expansion provided by MISRA document are
|
|
# skipped because we don't always have access to directive
|
|
# definition.
|
|
if '.' in filename:
|
|
self.reportError(directive, 20, 3)
|
|
|
|
def misra_20_4(self, data):
|
|
for directive in data.directives:
|
|
res = re.search(r'#define ([a-z][a-z0-9_]+)', directive.str)
|
|
if res and isKeyword(res.group(1), data.standards.c):
|
|
self.reportError(directive, 20, 4)
|
|
|
|
def misra_20_5(self, data):
|
|
for directive in data.directives:
|
|
if directive.str.startswith('#undef '):
|
|
self.reportError(directive, 20, 5)
|
|
|
|
def misra_20_7(self, data):
|
|
def find_string_concat(exp, arg, directive_args):
|
|
# Handle concatenation of string literals, e.g.:
|
|
# #define MACRO(A, B) (A " " B)
|
|
# Addon should not report errors for both macro arguments.
|
|
arg_pos = exp.find(arg, 0)
|
|
need_check = False
|
|
skip_next = False
|
|
state_in_string = False
|
|
pos_search = arg_pos + 1
|
|
directive_args = [a.strip() for a in directive_args if a != arg]
|
|
arg = arg.strip()
|
|
while pos_search < len(exp):
|
|
if exp[pos_search] == '"':
|
|
if state_in_string:
|
|
state_in_string = False
|
|
else:
|
|
state_in_string = True
|
|
pos_search += 1
|
|
elif exp[pos_search].isalnum():
|
|
word = ""
|
|
while pos_search < len(exp) and exp[pos_search].isalnum():
|
|
word += exp[pos_search]
|
|
pos_search += 1
|
|
if word == arg:
|
|
pos_search += 1
|
|
elif word in directive_args:
|
|
skip_next = True
|
|
break
|
|
elif exp[pos_search] == ' ':
|
|
pos_search += 1
|
|
elif state_in_string:
|
|
pos_search += 1
|
|
else:
|
|
need_check = True
|
|
break
|
|
return need_check, skip_next
|
|
|
|
for directive in data.directives:
|
|
d = Define(directive)
|
|
exp = '(' + d.expansionList + ')'
|
|
skip_next = False
|
|
for arg in d.args:
|
|
if skip_next:
|
|
_, skip_next = find_string_concat(exp, arg, d.args)
|
|
continue
|
|
need_check, skip_next = find_string_concat(exp, arg, d.args)
|
|
if not need_check:
|
|
continue
|
|
|
|
pos = 0
|
|
while pos < len(exp):
|
|
pos = exp.find(arg, pos)
|
|
if pos < 0:
|
|
break
|
|
# is 'arg' used at position pos
|
|
pos1 = pos - 1
|
|
pos2 = pos + len(arg)
|
|
pos = pos2
|
|
if pos1 >= 0 and (isalnum(exp[pos1]) or exp[pos1] == '_'):
|
|
continue
|
|
if pos2 < len(exp) and (isalnum(exp[pos2]) or exp[pos2] == '_'):
|
|
continue
|
|
|
|
while pos1 >= 0 and exp[pos1] == ' ':
|
|
pos1 -= 1
|
|
if exp[pos1] == '#':
|
|
continue
|
|
if exp[pos1] not in '([,.':
|
|
self.reportError(directive, 20, 7)
|
|
break
|
|
while pos2 < len(exp) and exp[pos2] == ' ':
|
|
pos2 += 1
|
|
if pos2 < len(exp) and exp[pos2] not in ')]#,':
|
|
self.reportError(directive, 20, 7)
|
|
break
|
|
|
|
def misra_20_8(self, cfg):
|
|
for cond in cfg.preprocessor_if_conditions:
|
|
#print(cond)
|
|
if cond.result and cond.result not in (0,1):
|
|
self.reportError(cond, 20, 8)
|
|
|
|
def misra_20_9(self, cfg):
|
|
for cond in cfg.preprocessor_if_conditions:
|
|
if cond.E is None:
|
|
continue
|
|
defined = []
|
|
for directive in cfg.directives:
|
|
if directive.file == cond.file and directive.linenr == cond.linenr:
|
|
for name in re.findall(r'[^_a-zA-Z0-9]defined[ ]*\([ ]*([_a-zA-Z0-9]+)[ ]*\)', directive.str):
|
|
defined.append(name)
|
|
for name in re.findall(r'[^_a-zA-Z0-9]defined[ ]*([_a-zA-Z0-9]+)', directive.str):
|
|
defined.append(name)
|
|
break
|
|
for s in cond.E.split(' '):
|
|
if (s[0] >= 'A' and s[0] <= 'Z') or (s[0] >= 'a' and s[0] <= 'z'):
|
|
if isKeyword(s):
|
|
continue
|
|
if s in defined:
|
|
continue
|
|
self.reportError(cond, 20, 9)
|
|
|
|
def misra_20_10(self, data):
|
|
for directive in data.directives:
|
|
d = Define(directive)
|
|
if d.expansionList.find('#') >= 0:
|
|
self.reportError(directive, 20, 10)
|
|
|
|
def misra_20_11(self, cfg):
|
|
for directive in cfg.directives:
|
|
d = Define(directive)
|
|
for arg in d.args:
|
|
res = re.search(r'[^#]#[ ]*%s[ ]*##' % arg, ' ' + d.expansionList)
|
|
if res:
|
|
self.reportError(directive, 20, 11)
|
|
|
|
def misra_20_12(self, cfg):
|
|
def _is_hash_hash_op(expansion_list, arg):
|
|
return re.search(r'##[ ]*%s[^a-zA-Z0-9_]' % arg, expansion_list) or \
|
|
re.search(r'[^a-zA-Z0-9_]%s[ ]*##' % arg, expansion_list)
|
|
|
|
def _is_other_op(expansion_list, arg):
|
|
pos = expansion_list.find(arg)
|
|
while pos >= 0:
|
|
pos1 = pos - 1
|
|
pos2 = pos + len(arg)
|
|
pos = expansion_list.find(arg, pos2)
|
|
if isalnum(expansion_list[pos1]) or expansion_list[pos1] == '_':
|
|
continue
|
|
if isalnum(expansion_list[pos2]) or expansion_list[pos2] == '_':
|
|
continue
|
|
while expansion_list[pos1] == ' ':
|
|
pos1 = pos1 - 1
|
|
if expansion_list[pos1] == '#':
|
|
continue
|
|
while expansion_list[pos2] == ' ':
|
|
pos2 = pos2 + 1
|
|
if expansion_list[pos2] == '#':
|
|
continue
|
|
return True
|
|
return False
|
|
|
|
def _is_arg_macro_usage(directive, arg):
|
|
for macro_usage in cfg.macro_usage:
|
|
if macro_usage.file == directive.file and macro_usage.linenr == directive.linenr:
|
|
for macro_usage_arg in cfg.macro_usage:
|
|
if macro_usage_arg == macro_usage:
|
|
continue
|
|
if (macro_usage.usefile == macro_usage_arg.usefile and
|
|
macro_usage.uselinenr == macro_usage_arg.uselinenr and
|
|
macro_usage.usecolumn == macro_usage_arg.usecolumn):
|
|
# TODO: check arg better
|
|
return True
|
|
return False
|
|
|
|
for directive in cfg.directives:
|
|
define = Define(directive)
|
|
expansion_list = '(%s)' % define.expansionList
|
|
for arg in define.args:
|
|
if not _is_hash_hash_op(expansion_list, arg):
|
|
continue
|
|
if not _is_other_op(expansion_list, arg):
|
|
continue
|
|
if _is_arg_macro_usage(directive, arg):
|
|
self.reportError(directive, 20, 12)
|
|
break
|
|
|
|
def misra_20_13(self, data):
|
|
dir_pattern = re.compile(r'#[ ]*([^ (<]*)')
|
|
for directive in data.directives:
|
|
dir = directive.str
|
|
mo = dir_pattern.match(dir)
|
|
if mo:
|
|
dir = mo.group(1)
|
|
if dir not in ['define', 'elif', 'else', 'endif', 'error', 'if', 'ifdef', 'ifndef', 'include',
|
|
'pragma', 'undef', 'warning']:
|
|
self.reportError(directive, 20, 13)
|
|
|
|
def misra_20_14(self, data):
|
|
# stack for #if blocks. contains the #if directive until the corresponding #endif is seen.
|
|
# the size increases when there are inner #if directives.
|
|
ifStack = []
|
|
for directive in data.directives:
|
|
if directive.str.startswith('#if ') or directive.str.startswith('#ifdef ') or directive.str.startswith(
|
|
'#ifndef '):
|
|
ifStack.append(directive)
|
|
elif directive.str == '#else' or directive.str.startswith('#elif '):
|
|
if len(ifStack) == 0:
|
|
self.reportError(directive, 20, 14)
|
|
ifStack.append(directive)
|
|
elif directive.file != ifStack[-1].file:
|
|
self.reportError(directive, 20, 14)
|
|
elif directive.str == '#endif':
|
|
if len(ifStack) == 0:
|
|
self.reportError(directive, 20, 14)
|
|
elif directive.file != ifStack[-1].file:
|
|
self.reportError(directive, 20, 14)
|
|
ifStack.pop()
|
|
|
|
def misra_21_1(self, data):
|
|
re_forbidden_macro = re.compile(r'#(?:define|undef) _[_A-Z]+')
|
|
re_macro_name = re.compile(r'#(?:define|undef) (.+)[ $]')
|
|
|
|
for d in data.directives:
|
|
# Search for forbidden identifiers
|
|
m = re.search(re_forbidden_macro, d.str)
|
|
if m:
|
|
self.reportError(d, 21, 1)
|
|
continue
|
|
|
|
# Search standard library identifiers in macro names
|
|
m = re.search(re_macro_name, d.str)
|
|
if not m:
|
|
continue
|
|
name = m.group(1)
|
|
if isStdLibId(name, data.standards.c):
|
|
self.reportError(d, 21, 1)
|
|
|
|
def misra_21_2(self, cfg):
|
|
for directive in cfg.directives:
|
|
define = Define(directive)
|
|
if re.match(r'_+BUILTIN_.*', define.name.upper()):
|
|
self.reportError(directive, 21, 2)
|
|
for func in cfg.functions:
|
|
if isStdLibId(func.name, cfg.standards.c):
|
|
tok = func.tokenDef if func.tokenDef else func.token
|
|
self.reportError(tok, 21, 2)
|
|
|
|
def misra_21_3(self, data):
|
|
for token in data.tokenlist:
|
|
if isFunctionCall(token) and (token.astOperand1.str in ('malloc', 'calloc', 'realloc', 'free')):
|
|
self.reportError(token, 21, 3)
|
|
|
|
def misra_21_4(self, data):
|
|
directive = findInclude(data.directives, '<setjmp.h>')
|
|
if directive:
|
|
self.reportError(directive, 21, 4)
|
|
|
|
def misra_21_5(self, data):
|
|
directive = findInclude(data.directives, '<signal.h>')
|
|
if directive:
|
|
self.reportError(directive, 21, 5)
|
|
|
|
def misra_21_6(self, data):
|
|
dir_stdio = findInclude(data.directives, '<stdio.h>')
|
|
dir_wchar = findInclude(data.directives, '<wchar.h>')
|
|
if dir_stdio:
|
|
self.reportError(dir_stdio, 21, 6)
|
|
if dir_wchar:
|
|
self.reportError(dir_wchar, 21, 6)
|
|
|
|
def misra_21_7(self, data):
|
|
for token in data.tokenlist:
|
|
if isFunctionCall(token) and (token.astOperand1.str in ('atof', 'atoi', 'atol', 'atoll')):
|
|
self.reportError(token, 21, 7)
|
|
|
|
def misra_21_8(self, data):
|
|
for token in data.tokenlist:
|
|
if isFunctionCall(token) and (token.astOperand1.str in ('abort', 'exit', 'getenv')):
|
|
self.reportError(token, 21, 8)
|
|
|
|
def misra_21_9(self, data):
|
|
for token in data.tokenlist:
|
|
if (token.str in ('bsearch', 'qsort')) and token.next and token.next.str == '(':
|
|
self.reportError(token, 21, 9)
|
|
|
|
def misra_21_10(self, data):
|
|
directive = findInclude(data.directives, '<time.h>')
|
|
if directive:
|
|
self.reportError(directive, 21, 10)
|
|
|
|
for token in data.tokenlist:
|
|
if (token.str == 'wcsftime') and token.next and token.next.str == '(':
|
|
self.reportError(token, 21, 10)
|
|
|
|
def misra_21_11(self, data):
|
|
directive = findInclude(data.directives, '<tgmath.h>')
|
|
if directive:
|
|
self.reportError(directive, 21, 11)
|
|
|
|
def misra_21_12(self, data):
|
|
if findInclude(data.directives, '<fenv.h>'):
|
|
for token in data.tokenlist:
|
|
if token.str == 'fexcept_t' and token.isName:
|
|
self.reportError(token, 21, 12)
|
|
if isFunctionCall(token) and (token.astOperand1.str in (
|
|
'feclearexcept',
|
|
'fegetexceptflag',
|
|
'feraiseexcept',
|
|
'fesetexceptflag',
|
|
'fetestexcept')):
|
|
self.reportError(token, 21, 12)
|
|
|
|
def misra_21_14(self, data):
|
|
# buffers used in strcpy/strlen/etc function calls
|
|
string_buffers = []
|
|
for token in data.tokenlist:
|
|
if token.str[0] == 's' and isFunctionCall(token.next):
|
|
name, args = cppcheckdata.get_function_call_name_args(token)
|
|
if name is None:
|
|
continue
|
|
def _get_string_buffers(match, args, argnum):
|
|
if not match:
|
|
return []
|
|
ret = []
|
|
for a in argnum:
|
|
if a < len(args):
|
|
arg = args[a]
|
|
while arg and arg.str in ('.', '::'):
|
|
arg = arg.astOperand2
|
|
if arg and arg.varId != 0 and arg.varId not in ret:
|
|
ret.append(arg.varId)
|
|
return ret
|
|
string_buffers += _get_string_buffers(name == 'strcpy', args, [0, 1])
|
|
string_buffers += _get_string_buffers(name == 'strncpy', args, [0, 1])
|
|
string_buffers += _get_string_buffers(name == 'strlen', args, [0])
|
|
string_buffers += _get_string_buffers(name == 'strcmp', args, [0, 1])
|
|
string_buffers += _get_string_buffers(name == 'sprintf', args, [0])
|
|
string_buffers += _get_string_buffers(name == 'snprintf', args, [0, 3])
|
|
|
|
for token in data.tokenlist:
|
|
if token.str != 'memcmp':
|
|
continue
|
|
name, args = cppcheckdata.get_function_call_name_args(token)
|
|
if name is None:
|
|
continue
|
|
if len(args) != 3:
|
|
continue
|
|
for arg in args[:2]:
|
|
if arg.str[-1] == '\"':
|
|
self.reportError(arg, 21, 14)
|
|
continue
|
|
while arg and arg.str in ('.', '::'):
|
|
arg = arg.astOperand2
|
|
if arg and arg.varId and arg.varId in string_buffers:
|
|
self.reportError(arg, 21, 14)
|
|
|
|
def misra_21_15(self, data):
|
|
for token in data.tokenlist:
|
|
if token.str not in ('memcpy', 'memmove', 'memcmp'):
|
|
continue
|
|
name, args = cppcheckdata.get_function_call_name_args(token)
|
|
if name is None:
|
|
continue
|
|
if len(args) != 3:
|
|
continue
|
|
if args[0].valueType is None or args[1].valueType is None:
|
|
continue
|
|
if args[0].valueType.type == args[1].valueType.type:
|
|
continue
|
|
if args[0].valueType.type == 'void' or args[1].valueType.type == 'void':
|
|
continue
|
|
self.reportError(token, 21, 15)
|
|
|
|
def misra_21_16(self, cfg):
|
|
for token in cfg.tokenlist:
|
|
if token.str != 'memcmp':
|
|
continue
|
|
name, args = cppcheckdata.get_function_call_name_args(token)
|
|
if name is None:
|
|
continue
|
|
if len(args) != 3:
|
|
continue
|
|
for arg in args[:2]:
|
|
if arg.valueType is None:
|
|
continue
|
|
if arg.valueType.pointer > 1:
|
|
continue
|
|
if arg.valueType.sign in ('unsigned', 'signed'):
|
|
continue
|
|
if arg.valueType.isEnum():
|
|
continue
|
|
self.reportError(token, 21, 16)
|
|
|
|
def misra_21_19(self, cfg):
|
|
for token in cfg.tokenlist:
|
|
if token.str in ('localeconv', 'getenv', 'setlocale', 'strerror') and simpleMatch(token.next, '('):
|
|
name, _ = cppcheckdata.get_function_call_name_args(token)
|
|
if name is None or name != token.str:
|
|
continue
|
|
parent = token.next
|
|
while simpleMatch(parent.astParent, '+'):
|
|
parent = parent.astParent
|
|
# x = f()
|
|
if simpleMatch(parent.astParent, '=') and parent == parent.astParent.astOperand2:
|
|
lhs = parent.astParent.astOperand1
|
|
if lhs and lhs.valueType and lhs.valueType.pointer > 0 and lhs.valueType.constness == 0:
|
|
self.reportError(token, 21, 19)
|
|
if token.str == '=':
|
|
lhs = token.astOperand1
|
|
while simpleMatch(lhs, '*') and lhs.astOperand2 is None:
|
|
lhs = lhs.astOperand1
|
|
if not simpleMatch(lhs, '.'):
|
|
continue
|
|
while simpleMatch(lhs, '.'):
|
|
lhs = lhs.astOperand1
|
|
if lhs and lhs.variable and simpleMatch(lhs.variable.typeStartToken, 'lconv'):
|
|
self.reportError(token, 21, 19)
|
|
|
|
def misra_21_20(self, cfg):
|
|
assigned = {}
|
|
invalid = []
|
|
for token in cfg.tokenlist:
|
|
# No sophisticated data flow analysis, bail out if control flow is "interrupted"
|
|
if token.str in ('{', '}', 'break', 'continue', 'return'):
|
|
assigned = {}
|
|
invalid = []
|
|
continue
|
|
|
|
# When pointer is assigned, remove it from 'assigned' and 'invalid'
|
|
if token.varId and token.varId > 0 and simpleMatch(token.next, '='):
|
|
for name in assigned.keys():
|
|
while token.varId in assigned[name]:
|
|
assigned[name].remove(token.varId)
|
|
while token.varId in invalid:
|
|
invalid.remove(token.varId)
|
|
continue
|
|
|
|
# Calling dangerous function
|
|
if token.str in ('asctime', 'ctime', 'gmtime', 'localtime', 'localeconv', 'getenv', 'setlocale', 'strerror'):
|
|
name, args = cppcheckdata.get_function_call_name_args(token)
|
|
if name and name == token.str:
|
|
# make assigned pointers invalid
|
|
for varId in assigned.get(name, ()):
|
|
if varId not in invalid:
|
|
invalid.append(varId)
|
|
|
|
# assign pointer
|
|
parent = token.next
|
|
while parent.astParent and (parent.astParent.str == '+' or isCast(parent.astParent)):
|
|
parent = parent.astParent
|
|
if simpleMatch(parent.astParent, '='):
|
|
eq = parent.astParent
|
|
vartok = eq.previous
|
|
if vartok and vartok.varId and vartok.varId > 0:
|
|
if name not in assigned:
|
|
assigned[name] = [vartok.varId]
|
|
elif vartok.varId not in assigned[name]:
|
|
assigned[name].append(vartok.varId)
|
|
continue
|
|
|
|
# taking value of invalid pointer..
|
|
if token.astParent and token.varId:
|
|
if token.varId in invalid:
|
|
self.reportError(token, 21, 20)
|
|
|
|
def misra_21_21(self, cfg):
|
|
for token in cfg.tokenlist:
|
|
if token.str == 'system':
|
|
name, args = cppcheckdata.get_function_call_name_args(token)
|
|
if name == 'system' and len(args) == 1:
|
|
self.reportError(token, 21, 21)
|
|
|
|
def misra_22_5(self, cfg):
|
|
for token in cfg.tokenlist:
|
|
if token.isUnaryOp("*") or (token.isBinaryOp() and token.str == '.'):
|
|
fileptr = token.astOperand1
|
|
if fileptr.variable and cppcheckdata.simpleMatch(fileptr.variable.typeStartToken, 'FILE *'):
|
|
self.reportError(token, 22, 5)
|
|
|
|
def misra_22_7(self, cfg):
|
|
for eofToken in cfg.tokenlist:
|
|
if eofToken.str != 'EOF':
|
|
continue
|
|
if eofToken.astParent is None or not eofToken.astParent.isComparisonOp:
|
|
continue
|
|
if eofToken.astParent.astOperand1 == eofToken:
|
|
eofTokenSibling = eofToken.astParent.astOperand2
|
|
else:
|
|
eofTokenSibling = eofToken.astParent.astOperand1
|
|
while isCast(eofTokenSibling) and eofTokenSibling.valueType and eofTokenSibling.valueType.type and eofTokenSibling.valueType.type == 'int':
|
|
eofTokenSibling = eofTokenSibling.astOperand2 if eofTokenSibling.astOperand2 else eofTokenSibling.astOperand1
|
|
if eofTokenSibling is not None and eofTokenSibling.valueType and eofTokenSibling.valueType and eofTokenSibling.valueType.type in ('bool', 'char', 'short'):
|
|
self.reportError(eofToken, 22, 7)
|
|
|
|
def misra_22_8(self, cfg):
|
|
is_zero = False
|
|
for token in cfg.tokenlist:
|
|
if simpleMatch(token, 'errno = 0'):
|
|
is_zero = True
|
|
if token.str == '(' and not simpleMatch(token.link, ') {'):
|
|
name, _ = cppcheckdata.get_function_call_name_args(token.previous)
|
|
if name is None:
|
|
continue
|
|
if is_errno_setting_function(name):
|
|
if not is_zero:
|
|
self.reportError(token, 22, 8)
|
|
else:
|
|
is_zero = False
|
|
|
|
def misra_22_9(self, cfg):
|
|
errno_is_set = False
|
|
for token in cfg.tokenlist:
|
|
if token.str == '(' and not simpleMatch(token.link, ') {'):
|
|
name, args = cppcheckdata.get_function_call_name_args(token.previous)
|
|
if name is None:
|
|
continue
|
|
errno_is_set = is_errno_setting_function(name)
|
|
if errno_is_set and token.str in '{};':
|
|
errno_is_set = False
|
|
tok = token.next
|
|
while tok and tok.str not in ('{','}',';','errno'):
|
|
tok = tok.next
|
|
if tok is None or tok.str != 'errno':
|
|
self.reportError(token, 22, 9)
|
|
elif (tok.astParent is None) or (not tok.astParent.isComparisonOp):
|
|
self.reportError(token, 22, 9)
|
|
|
|
def misra_22_10(self, cfg):
|
|
last_function_call = None
|
|
for token in cfg.tokenlist:
|
|
if token.str == '(' and not simpleMatch(token.link, ') {'):
|
|
name, args = cppcheckdata.get_function_call_name_args(token.previous)
|
|
last_function_call = name
|
|
if token.str == '}':
|
|
last_function_call = None
|
|
if token.str == 'errno' and token.astParent and token.astParent.isComparisonOp:
|
|
if last_function_call is None:
|
|
self.reportError(token, 22, 10)
|
|
elif not is_errno_setting_function(last_function_call):
|
|
self.reportError(token, 22, 10)
|
|
|
|
|
|
def get_verify_expected(self):
|
|
"""Return the list of expected violations in the verify test"""
|
|
return self.verify_expected
|
|
|
|
def get_verify_actual(self):
|
|
"""Return the list of actual violations in for the verify test"""
|
|
return self.verify_actual
|
|
|
|
def get_violations(self, violation_type=None):
|
|
"""Return the list of violations for a normal checker run"""
|
|
if violation_type is None:
|
|
return self.violations.items()
|
|
else:
|
|
return self.violations[violation_type]
|
|
|
|
def get_violation_types(self):
|
|
"""Return the list of violations for a normal checker run"""
|
|
return self.violations.keys()
|
|
|
|
def addSuppressedRule(self, ruleNum,
|
|
fileName=None,
|
|
lineNumber=None,
|
|
symbolName=None):
|
|
"""
|
|
Add a suppression to the suppressions data structure
|
|
|
|
Suppressions are stored in a dictionary of dictionaries that
|
|
contains a list of tuples.
|
|
|
|
The first dictionary is keyed by the MISRA rule in hundreds
|
|
format. The value of that dictionary is a dictionary of filenames.
|
|
If the value is None then the rule is assumed to be suppressed for
|
|
all files.
|
|
If the filename exists then the value of that dictionary contains a list
|
|
with the scope of the suppression. If the list contains an item of None
|
|
then the rule is assumed to be suppressed for the entire file. Otherwise
|
|
the list contains line number, symbol name tuples.
|
|
For each tuple either line number or symbol name can can be none.
|
|
|
|
"""
|
|
normalized_filename = None
|
|
|
|
if fileName is not None:
|
|
normalized_filename = os.path.expanduser(fileName)
|
|
normalized_filename = os.path.normpath(normalized_filename)
|
|
|
|
if lineNumber is not None or symbolName is not None:
|
|
line_symbol = (lineNumber, symbolName)
|
|
else:
|
|
line_symbol = None
|
|
|
|
# If the rule is not in the dict already then add it
|
|
if ruleNum not in self.suppressedRules:
|
|
ruleItemList = list()
|
|
ruleItemList.append(line_symbol)
|
|
|
|
fileDict = dict()
|
|
fileDict[normalized_filename] = ruleItemList
|
|
|
|
self.suppressedRules[ruleNum] = fileDict
|
|
|
|
# Rule is added. Done.
|
|
return
|
|
|
|
# Rule existed in the dictionary. Check for
|
|
# filename entries.
|
|
|
|
# Get the dictionary for the rule number
|
|
fileDict = self.suppressedRules[ruleNum]
|
|
|
|
# If the filename is not in the dict already add it
|
|
if normalized_filename not in fileDict:
|
|
ruleItemList = list()
|
|
ruleItemList.append(line_symbol)
|
|
|
|
fileDict[normalized_filename] = ruleItemList
|
|
|
|
# Rule is added with a file scope. Done
|
|
return
|
|
|
|
# Rule has a matching filename. Get the rule item list.
|
|
|
|
# Check the lists of rule items
|
|
# to see if this (lineNumber, symbolName) combination
|
|
# or None already exists.
|
|
ruleItemList = fileDict[normalized_filename]
|
|
|
|
if line_symbol is None:
|
|
# is it already in the list?
|
|
if line_symbol not in ruleItemList:
|
|
ruleItemList.append(line_symbol)
|
|
else:
|
|
# Check the list looking for matches
|
|
matched = False
|
|
for each in ruleItemList:
|
|
if each is not None:
|
|
if (each[0] == line_symbol[0]) and (each[1] == line_symbol[1]):
|
|
matched = True
|
|
|
|
# Append the rule item if it was not already found
|
|
if not matched:
|
|
ruleItemList.append(line_symbol)
|
|
|
|
def isRuleSuppressed(self, file_path, linenr, ruleNum):
|
|
"""
|
|
Check to see if a rule is suppressed.
|
|
|
|
:param ruleNum: is the rule number in hundreds format
|
|
:param file_path: File path of checked location
|
|
:param linenr: Line number of checked location
|
|
|
|
If the rule exists in the dict then check for a filename
|
|
If the filename is None then rule is suppressed globally
|
|
for all files.
|
|
If the filename exists then look for list of
|
|
line number, symbol name tuples. If the list is None then
|
|
the rule is suppressed for the entire file
|
|
If the list of tuples exists then search the list looking for
|
|
matching line numbers. Symbol names are currently ignored
|
|
because they can include regular expressions.
|
|
TODO: Support symbol names and expression matching.
|
|
|
|
"""
|
|
ruleIsSuppressed = False
|
|
|
|
# Remove any prefix listed in command arguments from the filename.
|
|
filename = None
|
|
if file_path is not None:
|
|
if self.filePrefix is not None:
|
|
filename = remove_file_prefix(file_path, self.filePrefix)
|
|
else:
|
|
filename = os.path.basename(file_path)
|
|
|
|
if ruleNum in self.suppressedRules:
|
|
fileDict = self.suppressedRules[ruleNum]
|
|
|
|
# a file name entry of None means that the rule is suppressed
|
|
# globally
|
|
if None in fileDict:
|
|
ruleIsSuppressed = True
|
|
else:
|
|
# Does the filename match one of the names in
|
|
# the file list
|
|
if filename in fileDict:
|
|
# Get the list of ruleItems
|
|
ruleItemList = fileDict[filename]
|
|
|
|
if None in ruleItemList:
|
|
# Entry of None in the ruleItemList means the rule is
|
|
# suppressed for all lines in the filename
|
|
ruleIsSuppressed = True
|
|
else:
|
|
# Iterate though the the list of line numbers
|
|
# and symbols looking for a match of the line
|
|
# number. Matching the symbol is a TODO:
|
|
for each in ruleItemList:
|
|
if each is not None:
|
|
if each[0] == linenr:
|
|
ruleIsSuppressed = True
|
|
|
|
return ruleIsSuppressed
|
|
|
|
def isRuleGloballySuppressed(self, rule_num):
|
|
"""
|
|
Check to see if a rule is globally suppressed.
|
|
:param rule_num: is the rule number in hundreds format
|
|
"""
|
|
if rule_num not in self.suppressedRules:
|
|
return False
|
|
return None in self.suppressedRules[rule_num]
|
|
|
|
def showSuppressedRules(self):
|
|
"""
|
|
Print out rules in suppression list sorted by Rule Number
|
|
"""
|
|
print("Suppressed Rules List:")
|
|
outlist = list()
|
|
|
|
for ruleNum in self.suppressedRules:
|
|
fileDict = self.suppressedRules[ruleNum]
|
|
|
|
for fname in fileDict:
|
|
ruleItemList = fileDict[fname]
|
|
|
|
for item in ruleItemList:
|
|
if item is None:
|
|
item_str = "None"
|
|
else:
|
|
item_str = str(item[0])
|
|
|
|
outlist.append("%s: %s: %s (%d locations suppressed)" % (
|
|
float(ruleNum) / 100, fname, item_str, self.suppressionStats.get(ruleNum, 0)))
|
|
|
|
for line in sorted(outlist, reverse=True):
|
|
print(" %s" % line)
|
|
|
|
def setFilePrefix(self, prefix):
|
|
"""
|
|
Set the file prefix to ignore from files when matching
|
|
suppression files
|
|
"""
|
|
self.filePrefix = prefix
|
|
|
|
def setSeverity(self, severity):
|
|
"""
|
|
Set the severity for all errors.
|
|
"""
|
|
self.severity = severity
|
|
|
|
def setSuppressionList(self, suppressionlist):
|
|
num1 = 0
|
|
num2 = 0
|
|
rule_pattern = re.compile(r'([0-9]+).([0-9]+)')
|
|
strlist = suppressionlist.split(",")
|
|
|
|
# build ignore list
|
|
for item in strlist:
|
|
res = rule_pattern.match(item)
|
|
if res:
|
|
num1 = int(res.group(1))
|
|
num2 = int(res.group(2))
|
|
ruleNum = (num1 * 100) + num2
|
|
|
|
self.addSuppressedRule(ruleNum)
|
|
|
|
def reportError(self, location, num1, num2):
|
|
ruleNum = num1 * 100 + num2
|
|
|
|
if self.isRuleGloballySuppressed(ruleNum):
|
|
return
|
|
|
|
if self.settings.verify:
|
|
self.verify_actual.append('%s:%d %d.%d' % (location.file, location.linenr, num1, num2))
|
|
elif self.isRuleSuppressed(location.file, location.linenr, ruleNum):
|
|
# Error is suppressed. Ignore
|
|
self.suppressionStats.setdefault(ruleNum, 0)
|
|
self.suppressionStats[ruleNum] += 1
|
|
return
|
|
else:
|
|
errorId = 'c2012-' + str(num1) + '.' + str(num2)
|
|
misra_severity = 'Undefined'
|
|
cppcheck_severity = 'style'
|
|
if ruleNum in self.ruleTexts:
|
|
errmsg = self.ruleTexts[ruleNum].text
|
|
if self.ruleTexts[ruleNum].misra_severity:
|
|
misra_severity = self.ruleTexts[ruleNum].misra_severity
|
|
cppcheck_severity = self.ruleTexts[ruleNum].cppcheck_severity
|
|
elif len(self.ruleTexts) == 0:
|
|
if self.ruleText_filename is None:
|
|
errmsg = 'misra violation (use --rule-texts=<file> to get proper output)'
|
|
else:
|
|
errmsg = 'misra violation (rule-texts-file not found: ' + self.ruleText_filename + ')'
|
|
if self.path_premium_addon:
|
|
for line in cppcheckdata.cmd_output([self.path_premium_addon, '--cli', '--get-rule-text=' + errorId]).split('\n'):
|
|
if len(line) > 1 and not line.startswith('{'):
|
|
errmsg = line.strip()
|
|
break
|
|
else:
|
|
errmsg = 'misra violation %s with no text in the supplied rule-texts-file' % (ruleNum)
|
|
|
|
if self.severity:
|
|
cppcheck_severity = self.severity
|
|
|
|
this_violation = '{}-{}-{}-{}'.format(location.file, location.linenr, location.column, ruleNum)
|
|
|
|
# If this is new violation then record it and show it. If not then
|
|
# skip it since it has already been displayed.
|
|
if this_violation not in self.existing_violations:
|
|
self.existing_violations.add(this_violation)
|
|
cppcheckdata.reportError(location, cppcheck_severity, errmsg, 'misra', errorId, misra_severity)
|
|
|
|
if misra_severity not in self.violations:
|
|
self.violations[misra_severity] = []
|
|
self.violations[misra_severity].append('misra-' + errorId)
|
|
|
|
def loadRuleTexts(self, filename):
|
|
num1 = 0
|
|
num2 = 0
|
|
appendixA = False
|
|
ruleText = False
|
|
expect_more = False
|
|
|
|
Rule_pattern = re.compile(r'^Rule ([0-9]+).([0-9]+)')
|
|
severity_pattern = re.compile(r'.*[ ]*(Advisory|Required|Mandatory)$')
|
|
xA_Z_pattern = re.compile(r'^[#A-Z].*')
|
|
a_z_pattern = re.compile(r'^[a-z].*')
|
|
# Try to detect the file encoding
|
|
file_stream = None
|
|
encodings = ['ascii', 'utf-8', 'windows-1250', 'windows-1252']
|
|
for e in encodings:
|
|
try:
|
|
file_stream = codecs.open(filename, 'r', encoding=e)
|
|
file_stream.readlines()
|
|
file_stream.seek(0)
|
|
except UnicodeDecodeError:
|
|
file_stream = None
|
|
else:
|
|
break
|
|
if not file_stream:
|
|
print('Could not find a suitable codec for "' + filename + '".')
|
|
print('If you know the codec please report it to the developers so the list can be enhanced.')
|
|
print('Trying with default codec now and ignoring errors if possible ...')
|
|
try:
|
|
file_stream = open(filename, 'rt', errors='ignore')
|
|
except TypeError:
|
|
# Python 2 does not support the errors parameter
|
|
file_stream = open(filename, 'rt')
|
|
|
|
rule = None
|
|
have_severity = False
|
|
severity_loc = 0
|
|
|
|
for line in file_stream:
|
|
|
|
line = line.replace('\r', '').replace('\n', '')
|
|
|
|
if not appendixA:
|
|
if line.find('Appendix A') >= 0 and line.find('Summary of guidelines') >= 10:
|
|
appendixA = True
|
|
continue
|
|
if line.find('Appendix B') >= 0:
|
|
break
|
|
if len(line) == 0:
|
|
continue
|
|
|
|
# Parse rule declaration.
|
|
res = Rule_pattern.match(line)
|
|
|
|
if res:
|
|
have_severity = False
|
|
expect_more = False
|
|
severity_loc = 0
|
|
num1 = int(res.group(1))
|
|
num2 = int(res.group(2))
|
|
rule = Rule(num1, num2)
|
|
|
|
if not have_severity and rule is not None:
|
|
res = severity_pattern.match(line)
|
|
|
|
if res:
|
|
rule.misra_severity = res.group(1)
|
|
have_severity = True
|
|
else:
|
|
severity_loc += 1
|
|
|
|
# Only look for severity on the Rule line
|
|
# or the next non-blank line after
|
|
# If it's not in either of those locations then
|
|
# assume a severity was not provided.
|
|
|
|
if severity_loc < 2:
|
|
continue
|
|
else:
|
|
rule.misra_severity = ''
|
|
have_severity = True
|
|
|
|
if rule is None:
|
|
continue
|
|
|
|
# Parse continuing of rule text.
|
|
if expect_more:
|
|
if a_z_pattern.match(line):
|
|
self.ruleTexts[rule.num].text += ' ' + line
|
|
continue
|
|
|
|
expect_more = False
|
|
continue
|
|
|
|
# Parse beginning of rule text.
|
|
if xA_Z_pattern.match(line):
|
|
rule.text = line
|
|
self.ruleTexts[rule.num] = rule
|
|
expect_more = True
|
|
|
|
def verifyRuleTexts(self):
|
|
"""Prints rule numbers without rule text."""
|
|
rule_texts_rules = []
|
|
for rule_num in self.ruleTexts:
|
|
rule = self.ruleTexts[rule_num]
|
|
rule_texts_rules.append(str(rule.num1) + '.' + str(rule.num2))
|
|
|
|
all_rules = list(getAddonRules() + getCppcheckRules())
|
|
|
|
missing_rules = list(set(all_rules) - set(rule_texts_rules))
|
|
if len(missing_rules) == 0:
|
|
print("Rule texts are correct.")
|
|
else:
|
|
print("Missing rule texts: " + ', '.join(missing_rules))
|
|
|
|
def printStatus(self, *args, **kwargs):
|
|
if not self.settings.quiet:
|
|
print(*args, **kwargs)
|
|
|
|
def executeCheck(self, rule_num, check_function, *args):
|
|
"""Execute check function for a single MISRA rule.
|
|
|
|
:param rule_num: Number of rule in hundreds format
|
|
:param check_function: Check function to execute
|
|
:param args: Check function arguments
|
|
"""
|
|
if not self.isRuleGloballySuppressed(rule_num):
|
|
misra_cpp = (
|
|
202, # misra-c2012-2.3 : misra c++2008 0-1-9
|
|
203, # misra-c2012-2.3 : misra c++2008 0-1-5
|
|
402, # misra-c2012-4.2 : misra c++2008 2-3-1
|
|
701, # misra-c2012-7.1 : misra c++2008 2-3-1
|
|
702, # misra-c2012-7.2 : misra c++2008 2-13-2
|
|
1203, # misra-c2012-12.3 : misra c++2008 5-14-1
|
|
1204, # misra-c2012-12.4 : misra c++2008 5-18-1
|
|
1305, # misra-c2012-13.5 : misra c++2008 5-19-1
|
|
1702, # misra-c2012-17.2 : misra c++2008 7-5-4
|
|
1901) # misra-c2012-19.1 : misra c++2008 2-13-3
|
|
|
|
if (not self.is_cpp) or rule_num in misra_cpp:
|
|
check_function(*args)
|
|
|
|
def parseDump(self, dumpfile, path_premium_addon=None):
|
|
def fillVerifyExpected(verify_expected, tok):
|
|
"""Add expected suppressions to verify_expected list."""
|
|
rule_re = re.compile(r'[0-9]+\.[0-9]+')
|
|
if tok.str.startswith('//') and 'TODO' not in tok.str:
|
|
for word in tok.str[2:].split(' '):
|
|
if rule_re.match(word):
|
|
verify_expected.append('%s:%d %s' % (tok.file, tok.linenr, word))
|
|
|
|
data = cppcheckdata.parsedump(dumpfile)
|
|
typeBits['CHAR'] = data.platform.char_bit
|
|
typeBits['SHORT'] = data.platform.short_bit
|
|
typeBits['INT'] = data.platform.int_bit
|
|
typeBits['LONG'] = data.platform.long_bit
|
|
typeBits['LONG_LONG'] = data.platform.long_long_bit
|
|
typeBits['POINTER'] = data.platform.pointer_bit
|
|
|
|
if self.settings.verify:
|
|
# Add suppressions from the current file
|
|
for tok in data.rawTokens:
|
|
fillVerifyExpected(self.verify_expected, tok)
|
|
# Add suppressions from the included headers
|
|
include_re = re.compile(r'^#include [<"]([a-zA-Z0-9]+[a-zA-Z\-_./\\0-9]*)[">]$')
|
|
dump_dir = os.path.dirname(data.filename)
|
|
for conf in data.configurations:
|
|
for directive in conf.directives:
|
|
m = re.match(include_re, directive.str)
|
|
if not m:
|
|
continue
|
|
header_dump_path = os.path.join(dump_dir, m.group(1) + '.dump')
|
|
if not os.path.exists(header_dump_path):
|
|
continue
|
|
header_data = cppcheckdata.parsedump(header_dump_path)
|
|
for tok in header_data.rawTokens:
|
|
fillVerifyExpected(self.verify_expected, tok)
|
|
else:
|
|
self.printStatus('Checking ' + dumpfile + '...')
|
|
|
|
self.is_cpp = data.files and data.files[0].endswith('.cpp')
|
|
|
|
for cfgNumber, cfg in enumerate(data.iterconfigurations()):
|
|
if not self.settings.quiet:
|
|
self.printStatus('Checking %s, config %s...' % (dumpfile, cfg.name))
|
|
|
|
if not path_premium_addon:
|
|
self.executeCheck(104, self.misra_1_4, cfg)
|
|
self.executeCheck(202, self.misra_2_2, cfg)
|
|
self.executeCheck(203, self.misra_2_3, dumpfile, cfg.typedefInfo)
|
|
self.executeCheck(204, self.misra_2_4, dumpfile, cfg)
|
|
self.executeCheck(205, self.misra_2_5, dumpfile, cfg)
|
|
self.executeCheck(207, self.misra_2_7, cfg)
|
|
# data.rawTokens is same for all configurations
|
|
if cfgNumber == 0:
|
|
self.executeCheck(301, self.misra_3_1, data.rawTokens)
|
|
self.executeCheck(302, self.misra_3_2, data.rawTokens)
|
|
self.executeCheck(401, self.misra_4_1, data.rawTokens)
|
|
self.executeCheck(402, self.misra_4_2, data.rawTokens)
|
|
self.executeCheck(501, self.misra_5_1, cfg)
|
|
self.executeCheck(502, self.misra_5_2, cfg)
|
|
self.executeCheck(504, self.misra_5_4, cfg)
|
|
self.executeCheck(505, self.misra_5_5, cfg)
|
|
self.executeCheck(506, self.misra_5_6, dumpfile, cfg.typedefInfo)
|
|
self.executeCheck(507, self.misra_5_7, dumpfile, cfg)
|
|
self.executeCheck(508, self.misra_5_8, dumpfile, cfg)
|
|
self.executeCheck(509, self.misra_5_9, dumpfile, cfg)
|
|
self.executeCheck(601, self.misra_6_1, cfg)
|
|
self.executeCheck(602, self.misra_6_2, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(701, self.misra_7_1, data.rawTokens)
|
|
self.executeCheck(702, self.misra_7_2, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(703, self.misra_7_3, data.rawTokens)
|
|
self.executeCheck(704, self.misra_7_4, cfg)
|
|
self.executeCheck(801, self.misra_8_1, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(802, self.misra_8_2, cfg, data.rawTokens)
|
|
self.executeCheck(804, self.misra_8_4, cfg)
|
|
self.executeCheck(805, self.misra_8_5, dumpfile, cfg)
|
|
self.executeCheck(806, self.misra_8_6, dumpfile, cfg)
|
|
self.executeCheck(807, self.misra_8_7, dumpfile, cfg)
|
|
self.executeCheck(808, self.misra_8_8, cfg)
|
|
self.executeCheck(809, self.misra_8_9, cfg)
|
|
self.executeCheck(810, self.misra_8_10, cfg)
|
|
self.executeCheck(811, self.misra_8_11, cfg)
|
|
self.executeCheck(812, self.misra_8_12, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(814, self.misra_8_14, data.rawTokens)
|
|
self.executeCheck(902, self.misra_9_2, cfg)
|
|
self.executeCheck(903, self.misra_9_3, cfg)
|
|
self.executeCheck(904, self.misra_9_4, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(905, self.misra_9_5, cfg, data.rawTokens)
|
|
if not path_premium_addon:
|
|
self.executeCheck(1001, self.misra_10_1, cfg)
|
|
self.executeCheck(1002, self.misra_10_2, cfg)
|
|
self.executeCheck(1003, self.misra_10_3, cfg)
|
|
self.executeCheck(1004, self.misra_10_4, cfg)
|
|
self.executeCheck(1005, self.misra_10_5, cfg)
|
|
self.executeCheck(1006, self.misra_10_6, cfg)
|
|
self.executeCheck(1007, self.misra_10_7, cfg)
|
|
self.executeCheck(1008, self.misra_10_8, cfg)
|
|
self.executeCheck(1101, self.misra_11_1, cfg)
|
|
self.executeCheck(1102, self.misra_11_2, cfg)
|
|
self.executeCheck(1103, self.misra_11_3, cfg)
|
|
self.executeCheck(1104, self.misra_11_4, cfg)
|
|
self.executeCheck(1105, self.misra_11_5, cfg)
|
|
self.executeCheck(1106, self.misra_11_6, cfg)
|
|
self.executeCheck(1107, self.misra_11_7, cfg)
|
|
self.executeCheck(1108, self.misra_11_8, cfg)
|
|
self.executeCheck(1109, self.misra_11_9, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(1201, self.misra_12_1_sizeof, data.rawTokens)
|
|
self.executeCheck(1201, self.misra_12_1, cfg)
|
|
self.executeCheck(1202, self.misra_12_2, cfg)
|
|
self.executeCheck(1203, self.misra_12_3, cfg)
|
|
self.executeCheck(1204, self.misra_12_4, cfg)
|
|
self.executeCheck(1301, self.misra_13_1, cfg)
|
|
self.executeCheck(1303, self.misra_13_3, cfg)
|
|
self.executeCheck(1304, self.misra_13_4, cfg)
|
|
self.executeCheck(1305, self.misra_13_5, cfg)
|
|
self.executeCheck(1306, self.misra_13_6, cfg)
|
|
self.executeCheck(1401, self.misra_14_1, cfg)
|
|
self.executeCheck(1402, self.misra_14_2, cfg)
|
|
self.executeCheck(1404, self.misra_14_4, cfg)
|
|
self.executeCheck(1501, self.misra_15_1, cfg)
|
|
self.executeCheck(1502, self.misra_15_2, cfg)
|
|
self.executeCheck(1503, self.misra_15_3, cfg)
|
|
self.executeCheck(1504, self.misra_15_4, cfg)
|
|
self.executeCheck(1505, self.misra_15_5, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(1506, self.misra_15_6, data.rawTokens)
|
|
self.executeCheck(1507, self.misra_15_7, cfg)
|
|
self.executeCheck(1601, self.misra_16_1, cfg)
|
|
self.executeCheck(1602, self.misra_16_2, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(1603, self.misra_16_3, data.rawTokens)
|
|
self.executeCheck(1604, self.misra_16_4, cfg)
|
|
self.executeCheck(1605, self.misra_16_5, cfg)
|
|
self.executeCheck(1606, self.misra_16_6, cfg)
|
|
self.executeCheck(1607, self.misra_16_7, cfg)
|
|
self.executeCheck(1701, self.misra_17_1, cfg)
|
|
self.executeCheck(1702, self.misra_17_2, cfg)
|
|
self.executeCheck(1703, self.misra_17_3, cfg)
|
|
if cfgNumber == 0:
|
|
self.executeCheck(1706, self.misra_17_6, data.rawTokens)
|
|
self.executeCheck(1707, self.misra_17_7, cfg)
|
|
self.executeCheck(1708, self.misra_17_8, cfg)
|
|
self.executeCheck(1804, self.misra_18_4, cfg)
|
|
self.executeCheck(1805, self.misra_18_5, cfg)
|
|
self.executeCheck(1807, self.misra_18_7, cfg)
|
|
self.executeCheck(1808, self.misra_18_8, cfg)
|
|
self.executeCheck(1902, self.misra_19_2, cfg)
|
|
self.executeCheck(2001, self.misra_20_1, cfg)
|
|
self.executeCheck(2002, self.misra_20_2, cfg)
|
|
self.executeCheck(2003, self.misra_20_3, cfg)
|
|
self.executeCheck(2004, self.misra_20_4, cfg)
|
|
self.executeCheck(2005, self.misra_20_5, cfg)
|
|
self.executeCheck(2007, self.misra_20_7, cfg)
|
|
self.executeCheck(2008, self.misra_20_8, cfg)
|
|
self.executeCheck(2009, self.misra_20_9, cfg)
|
|
self.executeCheck(2010, self.misra_20_10, cfg)
|
|
self.executeCheck(2011, self.misra_20_11, cfg)
|
|
self.executeCheck(2012, self.misra_20_12, cfg)
|
|
self.executeCheck(2013, self.misra_20_13, cfg)
|
|
self.executeCheck(2014, self.misra_20_14, cfg)
|
|
self.executeCheck(2101, self.misra_21_1, cfg)
|
|
self.executeCheck(2102, self.misra_21_2, cfg)
|
|
self.executeCheck(2103, self.misra_21_3, cfg)
|
|
self.executeCheck(2104, self.misra_21_4, cfg)
|
|
self.executeCheck(2105, self.misra_21_5, cfg)
|
|
self.executeCheck(2106, self.misra_21_6, cfg)
|
|
self.executeCheck(2107, self.misra_21_7, cfg)
|
|
self.executeCheck(2108, self.misra_21_8, cfg)
|
|
self.executeCheck(2109, self.misra_21_9, cfg)
|
|
self.executeCheck(2110, self.misra_21_10, cfg)
|
|
self.executeCheck(2111, self.misra_21_11, cfg)
|
|
self.executeCheck(2112, self.misra_21_12, cfg)
|
|
self.executeCheck(2114, self.misra_21_14, cfg)
|
|
self.executeCheck(2115, self.misra_21_15, cfg)
|
|
self.executeCheck(2116, self.misra_21_16, cfg)
|
|
self.executeCheck(2119, self.misra_21_19, cfg)
|
|
self.executeCheck(2120, self.misra_21_20, cfg)
|
|
self.executeCheck(2121, self.misra_21_21, cfg)
|
|
# 22.4 is already covered by Cppcheck writeReadOnlyFile
|
|
self.executeCheck(2205, self.misra_22_5, cfg)
|
|
self.executeCheck(2207, self.misra_22_7, cfg)
|
|
self.executeCheck(2208, self.misra_22_8, cfg)
|
|
self.executeCheck(2209, self.misra_22_9, cfg)
|
|
self.executeCheck(2210, self.misra_22_10, cfg)
|
|
|
|
def analyse_ctu_info(self, ctu_info_files):
|
|
all_typedef_info = {}
|
|
all_tagname_info = {}
|
|
all_macro_info = {}
|
|
all_external_identifiers_decl = {}
|
|
all_external_identifiers_def = {}
|
|
all_internal_identifiers = {}
|
|
all_local_identifiers = {}
|
|
all_usage_files = {}
|
|
|
|
from cppcheckdata import Location
|
|
|
|
def is_different_location(loc1, loc2):
|
|
return loc1['file'] != loc2['file'] or loc1['line'] != loc2['line']
|
|
|
|
try:
|
|
for filename in ctu_info_files:
|
|
for line in open(filename, 'rt'):
|
|
if not line.startswith('{'):
|
|
continue
|
|
|
|
s = json.loads(line)
|
|
summary_type = s['summary']
|
|
summary_data = s['data']
|
|
|
|
if summary_type == 'MisraTypedefInfo':
|
|
for new_typedef_info in summary_data:
|
|
key = new_typedef_info['name']
|
|
existing_typedef_info = all_typedef_info.get(key, None)
|
|
if existing_typedef_info:
|
|
if is_different_location(existing_typedef_info, new_typedef_info):
|
|
self.reportError(Location(existing_typedef_info), 5, 6)
|
|
self.reportError(Location(new_typedef_info), 5, 6)
|
|
else:
|
|
existing_typedef_info['used'] = existing_typedef_info['used'] or new_typedef_info['used']
|
|
else:
|
|
all_typedef_info[key] = new_typedef_info
|
|
|
|
if summary_type == 'MisraTagName':
|
|
for new_tagname_info in summary_data:
|
|
key = new_tagname_info['name']
|
|
existing_tagname_info = all_tagname_info.get(key, None)
|
|
if existing_tagname_info:
|
|
if is_different_location(existing_tagname_info, new_tagname_info):
|
|
self.reportError(Location(existing_tagname_info), 5, 7)
|
|
self.reportError(Location(new_tagname_info), 5, 7)
|
|
else:
|
|
existing_tagname_info['used'] = existing_tagname_info['used'] or new_tagname_info['used']
|
|
else:
|
|
all_tagname_info[key] = new_tagname_info
|
|
|
|
if summary_type == 'MisraMacro':
|
|
for new_macro in summary_data:
|
|
key = new_macro['name']
|
|
existing_macro = all_macro_info.get(key, None)
|
|
if existing_macro:
|
|
existing_macro['used'] = existing_macro['used'] or new_macro['used']
|
|
else:
|
|
all_macro_info[key] = new_macro
|
|
|
|
if summary_type == 'MisraExternalIdentifiers':
|
|
for s in summary_data:
|
|
is_declaration = s['decl']
|
|
if is_declaration:
|
|
all_external_identifiers = all_external_identifiers_decl
|
|
else:
|
|
all_external_identifiers = all_external_identifiers_def
|
|
|
|
name = s['name']
|
|
if name in all_external_identifiers and is_different_location(s, all_external_identifiers[name]):
|
|
num = 5 if is_declaration else 6
|
|
self.reportError(Location(s), 8, num)
|
|
self.reportError(Location(all_external_identifiers[name]), 8, num)
|
|
all_external_identifiers[name] = s
|
|
|
|
if summary_type == 'MisraInternalIdentifiers':
|
|
for s in summary_data:
|
|
if s['name'] in all_internal_identifiers:
|
|
if not s['inlinefunc'] or s['file'] != all_internal_identifiers[s['name']]['file']:
|
|
self.reportError(Location(s), 5, 9)
|
|
self.reportError(Location(all_internal_identifiers[s['name']]), 5, 9)
|
|
all_internal_identifiers[s['name']] = s
|
|
|
|
if summary_type == 'MisraLocalIdentifiers':
|
|
for s in summary_data:
|
|
all_local_identifiers[s['name']] = s
|
|
|
|
if summary_type == 'MisraUsage':
|
|
for s in summary_data:
|
|
if s['name'] in all_usage_files:
|
|
all_usage_files[s['name']].append(s['file'])
|
|
else:
|
|
all_usage_files[s['name']] = [s['file']]
|
|
|
|
except FileNotFoundError:
|
|
return
|
|
|
|
unused_typedefs = [tdi for tdi in all_typedef_info.values() if not tdi['used']]
|
|
for tdi in unused_typedefs:
|
|
self.reportError(Location(tdi), 2, 3)
|
|
|
|
unused_tags = [tag for tag in all_tagname_info.values() if not tag['used']]
|
|
for tag in unused_tags:
|
|
self.reportError(Location(tag), 2, 4)
|
|
|
|
unused_macros = [m for m in all_macro_info.values() if not m['used']]
|
|
for m in unused_macros:
|
|
self.reportError(Location(m), 2, 5)
|
|
|
|
all_external_identifiers = all_external_identifiers_decl
|
|
all_external_identifiers.update(all_external_identifiers_def)
|
|
for name, external_identifier in all_external_identifiers.items():
|
|
internal_identifier = all_internal_identifiers.get(name)
|
|
if internal_identifier:
|
|
self.reportError(Location(internal_identifier), 5, 8)
|
|
self.reportError(Location(external_identifier), 5, 8)
|
|
|
|
local_identifier = all_local_identifiers.get(name)
|
|
if local_identifier:
|
|
self.reportError(Location(local_identifier), 5, 8)
|
|
self.reportError(Location(external_identifier), 5, 8)
|
|
|
|
for name, files in all_usage_files.items():
|
|
#print('%s:%i' % (name, count))
|
|
count = len(files)
|
|
if count != 1 or name not in all_external_identifiers_def:
|
|
continue
|
|
if files[0] != Location(all_external_identifiers_def[name]).file:
|
|
continue
|
|
if name in all_external_identifiers:
|
|
self.reportError(Location(all_external_identifiers[name]), 8, 7)
|
|
|
|
RULE_TEXTS_HELP = '''Path to text file of MISRA rules
|
|
|
|
If you have the tool 'pdftotext' you might be able
|
|
to generate this textfile with such command:
|
|
|
|
pdftotext MISRA_C_2012.pdf MISRA_C_2012.txt
|
|
|
|
Otherwise you can more or less copy/paste the chapter
|
|
Appendix A Summary of guidelines
|
|
from the MISRA pdf. You can buy the MISRA pdf from
|
|
http://www.misra.org.uk/
|
|
|
|
Format:
|
|
|
|
<..arbitrary text..>
|
|
Appendix A Summary of guidelines
|
|
Rule 1.1 Required
|
|
Rule text for 1.1
|
|
continuation of rule text for 1.1
|
|
Rule 1.2 Mandatory
|
|
Rule text for 1.2
|
|
continuation of rule text for 1.2
|
|
<...>
|
|
|
|
'''
|
|
|
|
SUPPRESS_RULES_HELP = '''MISRA rules to suppress (comma-separated)
|
|
|
|
For example, if you'd like to suppress rules 15.1, 11.3,
|
|
and 20.13, run:
|
|
|
|
python misra.py --suppress-rules 15.1,11.3,20.13 ...
|
|
|
|
'''
|
|
|
|
|
|
def get_args_parser():
|
|
"""Generates list of command-line arguments acceptable by misra.py script."""
|
|
parser = cppcheckdata.ArgumentParser()
|
|
parser.add_argument("--rule-texts", type=str, help=RULE_TEXTS_HELP)
|
|
parser.add_argument("--verify-rule-texts",
|
|
help="Verify that all supported rules texts are present in given file and exit.",
|
|
action="store_true")
|
|
parser.add_argument("--suppress-rules", type=str, help=SUPPRESS_RULES_HELP)
|
|
parser.add_argument("--no-summary", help="Hide summary of violations", action="store_true")
|
|
parser.add_argument("--show-suppressed-rules", help="Print rule suppression list", action="store_true")
|
|
parser.add_argument("-P", "--file-prefix", type=str, help="Prefix to strip when matching suppression file rules")
|
|
parser.add_argument("-generate-table", help=argparse.SUPPRESS, action="store_true")
|
|
parser.add_argument("-verify", help=argparse.SUPPRESS, action="store_true")
|
|
parser.add_argument("--severity", type=str, help="Set a custom severity string, for example 'error' or 'warning'. ")
|
|
return parser
|
|
|
|
|
|
def main():
|
|
parser = get_args_parser()
|
|
args = parser.parse_args()
|
|
settings = MisraSettings(args)
|
|
checker = MisraChecker(settings)
|
|
|
|
checker.path_premium_addon = cppcheckdata.get_path_premium_addon()
|
|
|
|
if args.generate_table:
|
|
generateTable()
|
|
sys.exit(0)
|
|
|
|
if args.rule_texts:
|
|
filename = os.path.expanduser(args.rule_texts)
|
|
filename = os.path.normpath(filename)
|
|
checker.ruleText_filename = filename
|
|
if os.path.isfile(filename):
|
|
checker.loadRuleTexts(filename)
|
|
if args.verify_rule_texts:
|
|
checker.verifyRuleTexts()
|
|
sys.exit(0)
|
|
else:
|
|
if args.verify_rule_texts:
|
|
print('Fatal error: file is not found: ' + filename)
|
|
sys.exit(1)
|
|
|
|
|
|
if args.verify_rule_texts and not args.rule_texts:
|
|
print("Error: Please specify rule texts file with --rule-texts=<file>")
|
|
sys.exit(1)
|
|
|
|
if args.suppress_rules:
|
|
checker.setSuppressionList(args.suppress_rules)
|
|
|
|
if args.file_prefix:
|
|
checker.setFilePrefix(args.file_prefix)
|
|
|
|
dump_files, ctu_info_files = cppcheckdata.get_files(args)
|
|
|
|
if (not dump_files) and (not ctu_info_files):
|
|
if not args.quiet:
|
|
print("No input files.")
|
|
sys.exit(0)
|
|
|
|
if args.severity:
|
|
checker.setSeverity(args.severity)
|
|
|
|
for item in dump_files:
|
|
checker.parseDump(item,checker.path_premium_addon)
|
|
|
|
if settings.verify:
|
|
verify_expected = checker.get_verify_expected()
|
|
verify_actual = checker.get_verify_actual()
|
|
|
|
exitCode = 0
|
|
for expected in verify_expected:
|
|
if expected not in verify_actual:
|
|
print('Expected but not seen: ' + expected)
|
|
exitCode = 1
|
|
for actual in verify_actual:
|
|
if actual not in verify_expected:
|
|
print('Not expected: ' + actual)
|
|
exitCode = 1
|
|
|
|
# Existing behavior of verify mode is to exit
|
|
# on the first un-expected output.
|
|
# TODO: Is this required? or can it be moved to after
|
|
# all input files have been processed
|
|
if exitCode != 0:
|
|
sys.exit(exitCode)
|
|
|
|
checker.analyse_ctu_info(ctu_info_files)
|
|
|
|
if settings.verify:
|
|
sys.exit(exitCode)
|
|
|
|
number_of_violations = len(checker.get_violations())
|
|
if number_of_violations > 0:
|
|
if settings.show_summary:
|
|
print("\nMISRA rules violations found:\n\t%s\n" % (
|
|
"\n\t".join(["%s: %d" % (viol, len(checker.get_violations(viol))) for viol in
|
|
checker.get_violation_types()])))
|
|
|
|
rules_violated = {}
|
|
for severity, ids in checker.get_violations():
|
|
for misra_id in ids:
|
|
rules_violated[misra_id] = rules_violated.get(misra_id, 0) + 1
|
|
print("MISRA rules violated:")
|
|
convert = lambda text: int(text) if text.isdigit() else text
|
|
misra_sort = lambda key: [convert(c) for c in re.split(r'[\.-]([0-9]*)', key)]
|
|
for misra_id in sorted(rules_violated.keys(), key=misra_sort):
|
|
res = re.match(r'misra-c2012-([0-9]+)\\.([0-9]+)', misra_id)
|
|
if res is None:
|
|
num = 0
|
|
else:
|
|
num = int(res.group(1)) * 100 + int(res.group(2))
|
|
severity = '-'
|
|
if num in checker.ruleTexts:
|
|
severity = checker.ruleTexts[num].cppcheck_severity
|
|
print("\t%15s (%s): %d" % (misra_id, severity, rules_violated[misra_id]))
|
|
|
|
if args.show_suppressed_rules:
|
|
checker.showSuppressedRules()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
sys.exit(cppcheckdata.EXIT_CODE)
|