#!/usr/bin/env python3

#

# MISRA C 2012 checkers (including amendment 1 and 2)

#

# 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. We are not allowed by

# MISRA to distribute rule texts openly.

#

# 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 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])]

STDINT_H_DEFINES_MIN = ['%s%d_MIN' % (n, v) for n, v in itertools.product(

['INT', 'INT_LEAST', 'INT_FAST',],

[8, 16, 32, 64])]

STDINT_H_DEFINES_MAX = ['%s%d_MAX' % (n, v) for n, v in itertools.product(

['INT', 'UINT','INT_LEAST','UINT_LEAST', 'INT_FAST', 'UINT_FAST',],

[8, 16, 32, 64])]

STDINT_H_DEFINES_C = ['%s%d_C' % (n, v) for n, v in itertools.product(

['INT', 'UINT'],

[8, 16, 32, 64])]

INTTYPES_H_DEFINES = ['%s%d' % (n, v) for n, v in itertools.product(

['PRId', 'PRIi', 'PRIo', 'PRIu', 'PRIx', 'PRIX', 'SCNd',

'SCNi', 'SCNo', 'SCNu', 'SCNx', 'PRIdLEAST', 'PRIiLEAST',

'PRIoLEAST', 'PRIuLEAST', 'PRIxLEAST', 'PRIXLEAST',

'SCNdLEAST', 'SCNiLEAST', 'SCNoLEAST', 'SCNuLEAST',

'SCNxLEAST', 'PRIdFAST', 'PRIiFAST', 'PRIoFAST', 'PRIuFAST',

'PRIxFAST', 'PRIXFAST', 'SCNdFAST', 'SCNiFAST', 'SCNoFAST',

'SCNuFAST', 'SCNxFAST', ],

[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:1999 (E) Annex B -- Library summary

# (https://www.dii.uchile.cl/~daespino/files/Iso_C_1999_definition.pdf)

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': [

'PRIdMAX', 'PRIiMAX', 'PRIoMAX', 'PRIuMAX', 'PRIxMAX', 'PRIXMAX',

'SCNdMAX', 'SCNiMAX', 'SCNoMAX', 'SCNuMAX', 'SCNxMAX', 'PRIdPTR',

'PRIiPTR', 'PRIoPTR', 'PRIuPTR', 'PRIxPTR', 'PRIXPTR', 'SCNdPTR',

'SCNiPTR', 'SCNoPTR', 'SCNuPTR', 'SCNxPTR',

'imaxdiv_t', 'imaxabs', 'imaxdiv', 'strtoimax',

'strtoumax', 'wcstoimax', 'wcstoumax',

] + INTTYPES_H_DEFINES,

# 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', 'ldexpf',

'ldexpl', 'logf', 'logl', 'log10f', 'log10l', 'log1p', 'log1pf',

'log1pl', 'log2', 'log2f', 'log2l', 'logb', 'logbf', 'logbl', 'modff',

'modfl', 'scalbn', 'scalbnf', 'scalbnl', 'scalbln', 'scalblnf',

'scalblnl','cbrt', 'cbrtf','cbrtl', 'fabs', 'fabsf', 'fabsl',

'hypotl', 'hypotf', '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', 'fmaf','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 + STDINT_H_DEFINES_MIN + STDINT_H_DEFINES_MAX + STDINT_H_DEFINES_C,

# B.18 Input/output

'stdio.h': C90_STDLIB_IDENTIFIERS['stdio.h'] + [

'mode', 'restrict', 'snprintf', 'vfscanf', 'vscanf',

'vsnprintf', 'vsscanf','ftell'

],

# 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', 'wcstold', 'wcstol', 'wcstoll', 'wcstoul', 'wcstoull', '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',

],

# B.24 Wide character classification and mapping utilities

'wctype.h': ['wint_t', 'wctrans_t', 'wctype_t', 'WEOF',

'iswalnum', 'iswalpha', 'iswblank', 'iswcntrl', 'iswdigit',

'iswgraph', 'iswlower', 'iswprint', 'iswpunct', 'iswspace', 'iswupper',

'iswxdigit', 'iswctype', 'wctype', 'towlower', 'towupper', 'towctrans',

'wctrans'],

}

# Identifiers described in Section 7 "Library" of C11 Standard

# Based on ISO/IEC 9899:201x N1570 (Draft 12.04.2011) Annex B -- Library summary

# (https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf)

C11_STDLIB_IDENTIFIERS = {

# B.1 Diagnostics

'assert.h': C99_STDLIB_IDENTIFIERS['assert.h']+ ['static_assert'],

# B.2 Complex

'complex.h': C99_STDLIB_IDENTIFIERS['complex.h']+['__STDC_NO_COMPLEX__','CMPLX','CMPLXF','CMPLXL'],

# B.3 Character handling

'ctype.h': C99_STDLIB_IDENTIFIERS['ctype.h'],

# B.4 Errors

'errno.h': C99_STDLIB_IDENTIFIERS['errno.h']+['__STDC_WANT_LIB_EXT1__', 'errno_t'],

# B.5 Floating-point environment

'fenv.h': C99_STDLIB_IDENTIFIERS['fenv.h'],

# B.6 Characteristics of floating types

'float.h': C99_STDLIB_IDENTIFIERS['float.h']+[

'FLT_HAS_SUBNORM','DBL_HAS_SUBNORM','LDBL_HAS_SUBNORM',

'FLT_DECIMAL_DIG','DBL_DECIMAL_DIG','LDBL_DECIMAL_DIG',

'FLT_TRUE_MIN','DBL_TRUE_MIN','LDBL_TRUE_MIN'],

# B.7 Format conversion of integer types

'inttypes.h': C99_STDLIB_IDENTIFIERS["inttypes.h"],

# B.8 Alternative spellings

'iso646.h': C99_STDLIB_IDENTIFIERS["iso646.h"],

# B.9 Size of integer types

'limits.h': C99_STDLIB_IDENTIFIERS['limits.h'],

# B.10 Localization

'locale.h': C99_STDLIB_IDENTIFIERS['locale.h'],

# B.11 Mathematics

'math.h': C99_STDLIB_IDENTIFIERS['math.h'],

# B.12 Nonlocal jumps

'setjmp.h': C99_STDLIB_IDENTIFIERS['setjmp.h'],

# B.13 Signal handling

'signal.h': C99_STDLIB_IDENTIFIERS['signal.h'],

# B.14 Alignment

'stdalign.h': ['alignas','__alignas_is_defined'],

# B.15 Variable arguments

'stdarg.h': C99_STDLIB_IDENTIFIERS['stdarg.h'],

# B.16 Atomics

'stdatomic.h': ['ATOMIC_BOOL_LOCK_FREE', 'ATOMIC_CHAR_LOCK_FREE',

'ATOMIC_CHAR16_T_LOCK_FREE', 'ATOMIC_CHAR32_T_LOCK_FREE', 'ATOMIC_WCHAR_T_LOCK_FREE',

'ATOMIC_SHORT_LOCK_FREE', 'ATOMIC_INT_LOCK_FREE', 'ATOMIC_LONG_LOCK_FREE',

'ATOMIC_LLONG_LOCK_FREE', 'ATOMIC_POINTER_LOCK_FREE', 'ATOMIC_FLAG_INIT',

'memory_order', 'atomic_flag', 'memory_order_relaxed', 'memory_order_consume',

'memory_order_acquire', 'memory_order_release', 'memory_order_acq_rel', 'memory_order_seq_cst',

'atomic_bool', 'atomic_char', 'atomic_schar', 'atomic_uchar', 'atomic_short', 'atomic_ushort',

'atomic_int', 'atomic_uint', 'atomic_long', 'atomic_ulong', 'atomic_llong', 'atomic_ullong',

'atomic_char16_t', 'atomic_char32_t', 'atomic_wchar_t', 'atomic_int_least8_t',

'atomic_uint_least8_t', 'atomic_int_least16_t', 'atomic_uint_least16_t',

'atomic_int_least32_t', 'atomic_uint_least32_t', 'atomic_int_least64_t',

'atomic_uint_least64_t', 'atomic_int_fast8_t', 'atomic_uint_fast8_t',

'atomic_int_fast16_t', 'atomic_uint_fast16_t', 'atomic_int_fast32_t',

'atomic_uint_fast32_t', 'atomic_int_fast64_t', 'atomic_uint_fast64_t',

'atomic_intptr_t', 'atomic_uintptr_t', 'atomic_size_t', 'atomic_ptrdiff_t',

'atomic_intmax_t', 'atomic_uintmax_t', 'ATOMIC_VAR_INIT', 'type kill_dependency',

'atomic_thread_fence', 'atomic_signal_fence', 'atomic_is_lock_free',

'atomic_store', 'atomic_store_explicit', 'atomic_load', 'atomic_load_explicit',

'atomic_exchange', 'atomic_exchange_explicit', 'atomic_compare_exchange_strong',

'atomic_compare_exchange_strong_explicit', 'atomic_compare_exchange_weak',

'atomic_compare_exchange_weak_explicit', 'atomic_fetch_key', 'atomic_fetch_key_explicit',

'atomic_flag_test_and_set', 'atomic_flag_test_and_set_explicit',

'atomic_flag_clear', 'atomic_flag_clear_explicit', ],

# B.17 Boolean type and values

'stdbool.h': C99_STDLIB_IDENTIFIERS['stdbool.h'],

# B.18 Common definitions

'stddef.h': C99_STDLIB_IDENTIFIERS['stddef.h'] +

['max_align_t','__STDC_WANT_LIB_EXT1__', 'rsize_t'],

# B.19 Integer types

'stdint.h': C99_STDLIB_IDENTIFIERS['stdint.h']+

['__STDC_WANT_LIB_EXT1__', 'RSIZE_MAX'],

# B.20 Input/output

'stdio.h': C99_STDLIB_IDENTIFIERS['stdio.h'] +

['__STDC_WANT_LIB_EXT1__', 'L_tmpnam_s', 'TMP_MAX_S', 'errno_t', 'rsize_t',

'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', 'vsprintf_s', 'vsscanf_s', 'gets_s'

],

# B.21 General utilities

'stdlib.h': C99_STDLIB_IDENTIFIERS['stdlib.h'] +

['constraint_handler_t', 'set_constraint_handler_s', 'abort_handler_s',

'ignore_handler_s', 'getenv_s', 'bsearch_s', 'qsort_s', 'wctomb_s',

'mbstowcs_s', 'wcstombs_s'],

# B.22 Noretrun

'stdnoreturn.h': ['noreturn'],

# B.23 String handling

'string.h': C99_STDLIB_IDENTIFIERS['string.h'] +

['memcpy_s', 'memmoce_s', 'strcpy_s', 'strncpy_s','strcat_s',

'strtok_s', 'memset_s', 'strerror_s', 'strerrorlen_s', 'strnlen_s'],

# B.24 Type-generic math

'tgmath.h': C99_STDLIB_IDENTIFIERS['tgmath.h'],

# B.25 Threads

'threads.h': ['thread_local', 'ONCE_FLAG_INIT', 'TSS_DTOR_ITERATIONS',

'cnd_t', 'thrd_t', 'tss_t', 'mtx_t', 'tss_dtor_t', 'thrd_start_t',

'once_flag', 'mtx_plain', 'mtx_recursive', 'mtx_timed', 'thrd_timedout',

'thrd_success', 'thrd_busy', 'thrd_error', 'thrd_nomem', 'call_once',

'cnd_broadcast', 'cnd_destroy','cnd_init', 'cnd_signal', 'cnd_timedwait',

'cnd_wait','mtx_destroy', 'mtx_init', 'mtx_lock', 'mtx_timedlock',

'mtx_trylock', 'mtx_unlock', 'thrd_create', 'thrd_current',

'thrd_detach', 'thrd_equal', 'thrd_exit', 'thrd_join', 'thrd_sleep',

'thrd_yield', 'tss_create', 'tss_delete', 'tss_get', 'tss_set' ],

# B.26 Date and time

'time.h': C99_STDLIB_IDENTIFIERS['time.h'] + [

'asctime_s', 'ctime_s', 'gmtime_s', 'localtime_s'

],

# B.27 Unicode utilities

'uchar.h': ['mbstate_t', 'size_t', 'char16_t', 'char32_t',

'mbrtoc16', 'c16rtomb', 'mbrtoc32', 'c32rtomb'

],

# B.28 Extended multibyte/wide character utilities

'wchar.h': C99_STDLIB_IDENTIFIERS["wchar.h"]+[

'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',

],

# B.29 Wide character classification and mapping utilities

'wctype.h': C99_STDLIB_IDENTIFIERS['wctype.h'],

}

def getStdLib(standard):

if standard == 'c89':

return C90_STDLIB_IDENTIFIERS

if standard == 'c99':

return C99_STDLIB_IDENTIFIERS

return C11_STDLIB_IDENTIFIERS

def isStdLibId(id_, standard='c99'):

id_lists = getStdLib(standard).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 Section 6.4.1 "Language" of C99 Standard

# Based on ISO/IEC 9899:1999 (E) 6.4.1 Keywords

# Adding the expanding macros from Section 7 too

# (https://www.dii.uchile.cl/~daespino/files/Iso_C_1999_definition.pdf)

C99_ADDED_KEYWORDS = {

'inline', 'restrict', '_Bool', '_Complex', '_Imaginary',

'bool', 'complex', 'imaginary'

}

# Reserved keywords defined in Section 6.4.1 "Language" of C11 Standard

# Based on ISO/IEC 9899:201x N1570 (Draft 12.04.2011) 6.4.1 Keywords

# Adding the expanding macros from Section 7 too

# (https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf)

C11_ADDED_KEYWORDS = {

'_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',

'_Static_assert', '_Thread_local' ,

'alignas', 'alignof', 'noreturn', 'static_assert','thread_local'

}

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 == '?' and simpleMatch(expr.astOperand2, ':'):

colon = expr.astOperand2

return is_composite_expr(colon.astOperand1,True) or is_composite_expr(colon.astOperand2, True)

if (expr.str in ('+', '-', '*', '/', '%', '&', '|', '^', '>>', "<<", "?", ":", '~')):

return is_composite_expr(expr.astOperand1,True) or is_composite_expr(expr.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 + ">"

# Unwrap membership, dereferences and array indexing

vartok = expr

while True:

if simpleMatch(vartok, '[') or (vartok and vartok.str == '*' and vartok.astOperand2 is None):

vartok = vartok.astOperand1

elif simpleMatch(vartok, '.'):

vartok = vartok.astOperand2

else:

break

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.isCast and expr.str == "("):

castTok = expr.next

while castTok.isName or castTok.str == "*":

if castTok.str == 'char' and not castTok.isSigned and not castTok.isUnsigned:

return 'char'

castTok = castTok.next

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

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 = ''

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 get_function_scope(cfg, func):

if func:

for scope in cfg.scopes:

if scope.function == func:

return scope

return None

def is_variable_changed(start_token, end_token, var):

"""Check if variable is updated between body_start and body_end"""

tok = start_token

while tok != end_token:

if tok.isAssignmentOp:

vartok = tok.astOperand1

while vartok.astOperand1:

vartok = vartok.astOperand1

if vartok and vartok.variable == var:

return True

tok = tok.next

return False

def getForLoopCounterVariables(forToken, cfg):

""" 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 ('++', '--'):

tn_ast = tn.astParent

if tn_ast and tn_ast == tn.previous:

vars_modified.add(tn.variable)

elif tn_ast and tn_ast.str == '.' and tn_ast.astOperand2 and tn_ast.astOperand2.variable:

vars_modified.add(tn_ast.astOperand2.variable)

if cur_clause == 1 and tn.isAssignmentOp:

var_token = tn.astOperand1

while var_token and var_token.str == '.':

var_token = var_token.astOperand2

if var_token and var_token.variable:

vars_initialized.add(var_token.variable)

if cur_clause == 1 and tn.isName and tn.next.str == '(':

function_args_in_init = getArguments(tn.next)

function_scope = get_function_scope(cfg, tn.function)

for arg_nr in range(len(function_args_in_init)):

init_arg = function_args_in_init[arg_nr]

if init_arg is None or not init_arg.isUnaryOp('&'):

continue

var_token = init_arg.astOperand1

while var_token and var_token.str == '.':

var_token = var_token.astOperand2

if var_token is None or var_token.variable is None:

continue

changed = False

if function_scope is None:

changed = True

elif tn.function is None:

changed = True

else:

function_body_start = function_scope.bodyStart

function_body_end = function_scope.bodyEnd

args = tn.function.argument[arg_nr + 1]

if function_scope is None or is_variable_changed(function_body_start, function_body_end, args):

changed = True

if changed:

vars_initialized.add(var_token.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)

tok_varid = tuple(tok.varId for tok in counterTokens if tok.varId)

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

if not token.varId: