#!/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 = []