[{"data":1,"prerenderedAt":5755},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar":28,"surround-\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar":4321,"sidebar-sei-cert-c-coding-standard":4330},[4,8],{"title":5,"path":6,"_path":6,"fromAppConfig":7},"Home","\u002F",true,{"title":9,"path":10,"children":11,"_path":27,"fromAppConfig":7},"Coding Standards","\u002Fcoding-standards\u002F",[12,15,18,21,24],{"title":13,"path":14},"Android Coding Standard","\u002Fandroid-secure-coding-standard\u002F",{"title":16,"path":17},"C Coding Standard","\u002Fsei-cert-c-coding-standard\u002F",{"title":19,"path":20},"C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002F",{"title":22,"path":23},"Java Coding Standard","\u002Fsei-cert-oracle-coding-standard-for-java\u002F",{"title":25,"path":26},"Perl Coding Standard","\u002Fsei-cert-perl-coding-standard\u002F","\u002Fcoding-standards",{"id":29,"title":30,"body":31,"description":41,"extension":4313,"meta":4314,"navigation":7,"path":4317,"seo":4318,"stem":4319,"__hash__":4320},"content\u002F4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F13.codesonar.md","CodeSonar",{"type":32,"value":33,"toc":4309},"minimark",[34,38,42,45,48,55],[35,36,30],"h1",{"id":37},"codesonar",[39,40,41],"p",{},"This page was automatically generated and should not be edited.",[39,43,44],{},"The information on this page was provided by outside contributors and has not been verified by SEI CERT.",[39,46,47],{},"The table below can be re-ordered, by clicking column headers.",[39,49,50,54],{},[51,52,53],"strong",{},"Tool Version:"," 9.1p0",[56,57,58,69],"table",{},[59,60,61],"thead",{},[62,63,64,67],"tr",{},[65,66],"th",{},[65,68],{},[70,71,72,81,93,103,113,123,133,143,153,163,173,183,193,203,213,223,234,244,254,265,275,286,296,306,314,322,333,343,353,363,373,382,390,400,408,416,424,433,441,449,457,465,473,483,492,500,508,516,524,535,543,553,561,572,582,592,603,611,622,630,641,650,659,668,677,688,698,708,719,728,739,748,759,770,779,789,800,811,822,831,840,851,860,871,881,892,901,912,922,932,942,952,962,973,983,992,1003,1012,1020,1029,1037,1046,1057,1068,1078,1087,1098,1107,1118,1129,1140,1149,1160,1171,1181,1191,1201,1211,1222,1233,1241,1252,1261,1272,1282,1291,1301,1309,1317,1328,1338,1347,1358,1369,1379,1390,1400,1409,1418,1426,1435,1443,1454,1462,1471,1480,1490,1501,1511,1519,1528,1537,1546,1557,1566,1577,1585,1593,1602,1611,1621,1630,1638,1648,1656,1667,1676,1685,1694,1703,1714,1724,1735,1744,1755,1764,1774,1783,1794,1804,1813,1823,1831,1839,1847,1856,1865,1875,1886,1896,1907,1916,1924,1933,1942,1953,1962,1970,1978,1986,1997,2007,2016,2024,2035,2046,2055,2063,2073,2082,2093,2103,2114,2125,2134,2143,2154,2162,2171,2180,2189,2198,2207,2216,2225,2235,2245,2255,2263,2273,2281,2291,2299,2309,2318,2326,2334,2342,2350,2358,2369,2378,2386,2394,2402,2410,2418,2426,2434,2442,2451,2459,2467,2475,2483,2491,2499,2508,2516,2524,2532,2540,2551,2561,2572,2582,2593,2602,2613,2624,2634,2643,2652,2663,2671,2680,2689,2698,2706,2715,2724,2733,2744,2755,2763,2774,2785,2794,2803,2812,2823,2834,2845,2854,2865,2873,2884,2893,2903,2914,2923,2934,2945,2954,2965,2974,2985,2994,3002,3010,3018,3026,3035,3043,3051,3059,3067,3078,3087,3095,3103,3111,3119,3130,3138,3146,3157,3168,3177,3185,3196,3206,3215,3226,3235,3244,3254,3263,3271,3280,3291,3300,3309,3317,3328,3339,3350,3361,3370,3379,3387,3396,3406,3415,3424,3433,3442,3451,3460,3471,3480,3489,3500,3511,3522,3533,3544,3554,3564,3573,3584,3594,3604,3612,3623,3634,3642,3653,3664,3673,3684,3695,3704,3713,3724,3733,3742,3751,3760,3769,3778,3787,3796,3805,3814,3823,3831,3840,3849,3858,3867,3875,3884,3893,3903,3914,3922,3931,3939,3947,3955,3964,3972,3980,3988,3996,4004,4012,4020,4029,4037,4045,4053,4062,4070,4078,4086,4095,4103,4111,4122,4132,4142,4152,4161,4172,4181,4190,4201,4210,4219,4228,4237,4246,4255,4264,4273,4282,4291,4300],"tbody",{},[62,73,74,78],{},[75,76,77],"td",{},"Checker",[75,79,80],{},"Guideline",[62,82,83,86],{},[75,84,85],{},"(customization)",[75,87,88],{},[89,90,92],"a",{"href":91},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio44-c","FIO44-C. Only use values for fsetpos() that are returned from fgetpos()",[62,94,95,97],{},[75,96,85],{},[75,98,99],{},[89,100,102],{"href":101},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr34-c","ERR34-C. Detect errors when converting a string to a number",[62,104,105,107],{},[75,106,85],{},[75,108,109],{},[89,110,112],{"href":111},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos34-c","POS34-C. Do not call putenv() with a pointer to an automatic variable as the argument",[62,114,115,117],{},[75,116,85],{},[75,118,119],{},[89,120,122],{"href":121},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl03-c","DCL03-C. Use a static assertion to test the value of a constant expression",[62,124,125,127],{},[75,126,85],{},[75,128,129],{},[89,130,132],{"href":131},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio06-c","FIO06-C. Create files with appropriate access permissions",[62,134,135,137],{},[75,136,85],{},[75,138,139],{},[89,140,142],{"href":141},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio08-c","FIO08-C. Take care when calling remove() on an open file",[62,144,145,147],{},[75,146,85],{},[75,148,149],{},[89,150,152],{"href":151},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio10-c","FIO10-C. Take care when using the rename() function",[62,154,155,157],{},[75,156,85],{},[75,158,159],{},[89,160,162],{"href":161},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio13-c","FIO13-C. Never push back anything other than one read character",[62,164,165,167],{},[75,166,85],{},[75,168,169],{},[89,170,172],{"href":171},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio24-c","FIO24-C. Do not open a file that is already open",[62,174,175,177],{},[75,176,85],{},[75,178,179],{},[89,180,182],{"href":181},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem03-c","MEM03-C. Clear sensitive information stored in reusable resources",[62,184,185,187],{},[75,186,85],{},[75,188,189],{},[89,190,192],{"href":191},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem04-c","MEM04-C. Beware of zero-length allocations",[62,194,195,197],{},[75,196,85],{},[75,198,199],{},[89,200,202],{"href":201},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc24-c","MSC24-C. Do not use deprecated or obsolescent functions",[62,204,205,207],{},[75,206,85],{},[75,208,209],{},[89,210,212],{"href":211},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr06-c","STR06-C. Do not assume that strtok() leaves the parse string unchanged",[62,214,215,217],{},[75,216,85],{},[75,218,219],{},[89,220,222],{"href":221},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin01-c","WIN01-C. Do not forcibly terminate execution",[62,224,225,228],{},[75,226,227],{},"(general)",[75,229,230],{},[89,231,233],{"href":232},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env\u002Fenv01-c","ENV01-C. Do not make assumptions about the size of an environment variable",[62,235,236,238],{},[75,237,227],{},[75,239,240],{},[89,241,243],{"href":242},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint04-c","INT04-C. Enforce limits on integer values originating from tainted sources",[62,245,246,248],{},[75,247,227],{},[75,249,250],{},[89,251,253],{"href":252},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem11-c","MEM11-C. Do not assume infinite heap space",[62,255,256,259],{},[75,257,258],{},"ALLOC.DF",[75,260,261],{},[89,262,264],{"href":263},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem00-c","MEM00-C. Allocate and free memory in the same module, at the same level of abstraction",[62,266,267,269],{},[75,268,258],{},[75,270,271],{},[89,272,274],{"href":273},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem01-c","MEM01-C. Store a new value in pointers immediately after free()",[62,276,277,280],{},[75,278,279],{},"ALLOC.LEAK",[75,281,282],{},[89,283,285],{"href":284},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem31-c","MEM31-C. Free dynamically allocated memory when no longer needed",[62,287,288,290],{},[75,289,279],{},[75,291,292],{},[89,293,295],{"href":294},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio42-c","FIO42-C. Close files when they are no longer needed",[62,297,298,300],{},[75,299,279],{},[75,301,302],{},[89,303,305],{"href":304},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon30-c","CON30-C. Clean up thread-specific storage",[62,307,308,310],{},[75,309,279],{},[75,311,312],{},[89,313,264],{"href":263},[62,315,316,318],{},[75,317,279],{},[75,319,320],{},[89,321,253],{"href":252},[62,323,324,327],{},[75,325,326],{},"ALLOC.SIZE.ADDOFLOW",[75,328,329],{},[89,330,332],{"href":331},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint30-c","INT30-C. Ensure that unsigned integer operations do not wrap",[62,334,335,337],{},[75,336,326],{},[75,338,339],{},[89,340,342],{"href":341},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint32-c","INT32-C. Ensure that operations on signed integers do not result in overflow",[62,344,345,347],{},[75,346,326],{},[75,348,349],{},[89,350,352],{"href":351},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem35-c","MEM35-C. Allocate sufficient memory for an object",[62,354,355,357],{},[75,356,326],{},[75,358,359],{},[89,360,362],{"href":361},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint08-c","INT08-C. Verify that all integer values are in range",[62,364,365,367],{},[75,366,326],{},[75,368,369],{},[89,370,372],{"href":371},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint18-c","INT18-C. Evaluate integer expressions in a larger size before comparing or assigning to that size",[62,374,375,378],{},[75,376,377],{},"ALLOC.SIZE.IOFLOW",[75,379,380],{},[89,381,332],{"href":331},[62,383,384,386],{},[75,385,377],{},[75,387,388],{},[89,389,342],{"href":341},[62,391,392,394],{},[75,393,377],{},[75,395,396],{},[89,397,399],{"href":398},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr32-c","ARR32-C. Ensure size arguments for variable length arrays are in a valid range",[62,401,402,404],{},[75,403,377],{},[75,405,406],{},[89,407,352],{"href":351},[62,409,410,412],{},[75,411,377],{},[75,413,414],{},[89,415,362],{"href":361},[62,417,418,420],{},[75,419,377],{},[75,421,422],{},[89,423,372],{"href":371},[62,425,426,429],{},[75,427,428],{},"ALLOC.SIZE.MULOFLOW",[75,430,431],{},[89,432,332],{"href":331},[62,434,435,437],{},[75,436,428],{},[75,438,439],{},[89,440,342],{"href":341},[62,442,443,445],{},[75,444,428],{},[75,446,447],{},[89,448,399],{"href":398},[62,450,451,453],{},[75,452,428],{},[75,454,455],{},[89,456,352],{"href":351},[62,458,459,461],{},[75,460,428],{},[75,462,463],{},[89,464,362],{"href":361},[62,466,467,469],{},[75,468,428],{},[75,470,471],{},[89,472,372],{"href":371},[62,474,475,477],{},[75,476,428],{},[75,478,479],{},[89,480,482],{"href":481},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem07-c","MEM07-C. Ensure that the arguments to calloc(), when multiplied, do not wrap",[62,484,485,488],{},[75,486,487],{},"ALLOC.SIZE.SUBUFLOW",[75,489,490],{},[89,491,332],{"href":331},[62,493,494,496],{},[75,495,487],{},[75,497,498],{},[89,499,342],{"href":341},[62,501,502,504],{},[75,503,487],{},[75,505,506],{},[89,507,352],{"href":351},[62,509,510,512],{},[75,511,487],{},[75,513,514],{},[89,515,362],{"href":361},[62,517,518,520],{},[75,519,487],{},[75,521,522],{},[89,523,372],{"href":371},[62,525,526,529],{},[75,527,528],{},"ALLOC.SIZE.TRUNC",[75,530,531],{},[89,532,534],{"href":533},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint31-c","INT31-C. Ensure that integer conversions do not result in lost or misinterpreted data",[62,536,537,539],{},[75,538,528],{},[75,540,541],{},[89,542,352],{"href":351},[62,544,545,547],{},[75,546,528],{},[75,548,549],{},[89,550,552],{"href":551},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint02-c","INT02-C. Understand integer conversion rules",[62,554,555,557],{},[75,556,528],{},[75,558,559],{},[89,560,372],{"href":371},[62,562,563,566],{},[75,564,565],{},"ALLOC.TM",[75,567,568],{},[89,569,571],{"href":570},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem34-c","MEM34-C. Only free memory allocated dynamically",[62,573,574,576],{},[75,575,565],{},[75,577,578],{},[89,579,581],{"href":580},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmicrosoft-windows-win\u002Fwin30-c","WIN30-C. Properly pair allocation and deallocation functions",[62,583,584,586],{},[75,585,565],{},[75,587,588],{},[89,589,591],{"href":590},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi07-c","API07-C. Enforce type safety",[62,593,594,597],{},[75,595,596],{},"ALLOC.UAF",[75,598,599],{},[89,600,602],{"href":601},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem30-c","MEM30-C. Do not access freed memory",[62,604,605,607],{},[75,606,596],{},[75,608,609],{},[89,610,274],{"href":273},[62,612,613,616],{},[75,614,615],{},"BADFUNC.*",[75,617,618],{},[89,619,621],{"href":620},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc23-c","MSC23-C. Beware of vendor-specific library and language differences",[62,623,624,626],{},[75,625,615],{},[75,627,628],{},[89,629,202],{"href":201},[62,631,632,635],{},[75,633,634],{},"BADFUNC.ABORT",[75,636,637],{},[89,638,640],{"href":639},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv32-c","ENV32-C. All exit handlers must return normally",[62,642,643,646],{},[75,644,645],{},"BADFUNC.ATOF",[75,647,648],{},[89,649,102],{"href":101},[62,651,652,655],{},[75,653,654],{},"BADFUNC.ATOI",[75,656,657],{},[89,658,102],{"href":101},[62,660,661,664],{},[75,662,663],{},"BADFUNC.ATOL",[75,665,666],{},[89,667,102],{"href":101},[62,669,670,673],{},[75,671,672],{},"BADFUNC.ATOLL",[75,674,675],{},[89,676,102],{"href":101},[62,678,679,682],{},[75,680,681],{},"BADFUNC.BO.*",[75,683,684],{},[89,685,687],{"href":686},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr30-c","ARR30-C. Do not form or use out-of-bounds pointers or array subscripts",[62,689,690,692],{},[75,691,681],{},[75,693,694],{},[89,695,697],{"href":696},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr31-c","STR31-C. Guarantee that storage for strings has sufficient space for character data and the null terminator",[62,699,700,702],{},[75,701,681],{},[75,703,704],{},[89,705,707],{"href":706},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi02-c","API02-C. Functions that read or write to or from an array should take an argument to specify the source or target size",[62,709,710,713],{},[75,711,712],{},"BADFUNC.CHROOT",[75,714,715],{},[89,716,718],{"href":717},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos05-c","POS05-C. Limit access to files by creating a jail",[62,720,721,724],{},[75,722,723],{},"BADFUNC.CREATEFILE",[75,725,726],{},[89,727,132],{"href":131},[62,729,730,733],{},[75,731,732],{},"BADFUNC.CREATEPROCESS",[75,734,735],{},[89,736,738],{"href":737},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin02-c","WIN02-C. Restrict privileges when spawning child processes",[62,740,741,744],{},[75,742,743],{},"BADFUNC.EXIT",[75,745,746],{},[89,747,640],{"href":639},[62,749,750,753],{},[75,751,752],{},"BADFUNC.FORK",[75,754,755],{},[89,756,758],{"href":757},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos38-c","POS38-C. Beware of race conditions when using fork and file descriptors",[62,760,761,764],{},[75,762,763],{},"BADFUNC.GETENV",[75,765,766],{},[89,767,769],{"href":768},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv30-c","ENV30-C. Do not modify the object referenced by the return value of certain functions",[62,771,772,775],{},[75,773,774],{},"BADFUNC.LONGJMP",[75,776,777],{},[89,778,640],{"href":639},[62,780,781,783],{},[75,782,774],{},[75,784,785],{},[89,786,788],{"href":787},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc22-c","MSC22-C. Use the setjmp(), longjmp() facility securely",[62,790,791,794],{},[75,792,793],{},"BADFUNC.MEMCMP",[75,795,796],{},[89,797,799],{"href":798},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp42-c","EXP42-C. Do not compare padding data",[62,801,802,805],{},[75,803,804],{},"BADFUNC.MEMSET",[75,806,807],{},[89,808,810],{"href":809},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc06-c","MSC06-C. Beware of compiler optimizations",[62,812,813,816],{},[75,814,815],{},"BADFUNC.PATH.AFXLOADLIBRARY",[75,817,818],{},[89,819,821],{"href":820},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin00-c","WIN00-C. Be specific when dynamically loading libraries",[62,823,824,827],{},[75,825,826],{},"BADFUNC.PATH.COLOADLIBRARY",[75,828,829],{},[89,830,821],{"href":820},[62,832,833,836],{},[75,834,835],{},"BADFUNC.PATH.LOADLIBRARY",[75,837,838],{},[89,839,821],{"href":820},[62,841,842,845],{},[75,843,844],{},"BADFUNC.PATH.SYSTEM",[75,846,847],{},[89,848,850],{"href":849},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv33-c","ENV33-C. Do not call system()",[62,852,853,856],{},[75,854,855],{},"BADFUNC.PUTENV",[75,857,858],{},[89,859,112],{"href":111},[62,861,862,865],{},[75,863,864],{},"BADFUNC.RANDOM.RAND",[75,866,867],{},[89,868,870],{"href":869},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon33-c","CON33-C. Avoid race conditions when using library functions",[62,872,873,875],{},[75,874,864],{},[75,876,877],{},[89,878,880],{"href":879},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc30-c","MSC30-C. Do not use the rand() function for generating pseudorandom numbers",[62,882,883,886],{},[75,884,885],{},"BADFUNC.REALLOC",[75,887,888],{},[89,889,891],{"href":890},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem36-c","MEM36-C. Do not modify the alignment of objects by calling realloc()",[62,893,894,897],{},[75,895,896],{},"BADFUNC.SETJMP",[75,898,899],{},[89,900,788],{"href":787},[62,902,903,906],{},[75,904,905],{},"BADFUNC.SIGNAL",[75,907,908],{},[89,909,911],{"href":910},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig30-c","SIG30-C. Call only asynchronous-safe functions within signal handlers",[62,913,914,916],{},[75,915,905],{},[75,917,918],{},[89,919,921],{"href":920},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig34-c","SIG34-C. Do not call signal() from within interruptible signal handlers",[62,923,924,926],{},[75,925,905],{},[75,927,928],{},[89,929,931],{"href":930},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon37-c","CON37-C. Do not call signal() in a multithreaded program",[62,933,934,936],{},[75,935,905],{},[75,937,938],{},[89,939,941],{"href":940},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig00-c","SIG00-C. Mask signals handled by noninterruptible signal handlers",[62,943,944,946],{},[75,945,905],{},[75,947,948],{},[89,949,951],{"href":950},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig01-c","SIG01-C. Understand implementation-specific details regarding signal handler persistence",[62,953,954,956],{},[75,955,905],{},[75,957,958],{},[89,959,961],{"href":960},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig02-c","SIG02-C. Avoid using signals to implement normal functionality",[62,963,964,967],{},[75,965,966],{},"BADFUNC.TEMP.*",[75,968,969],{},[89,970,972],{"href":971},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio01-c","FIO01-C. Be careful using functions that use file names for identification",[62,974,975,977],{},[75,976,966],{},[75,978,979],{},[89,980,982],{"href":981},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio21-c","FIO21-C. Do not create temporary files in shared directories",[62,984,985,988],{},[75,986,987],{},"BADFUNC.TEMP.TMPNAM",[75,989,990],{},[89,991,870],{"href":869},[62,993,994,997],{},[75,995,996],{},"BADFUNC.TIME_H",[75,998,999],{},[89,1000,1002],{"href":1001},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc33-c","MSC33-C. Do not pass invalid data to the asctime() function",[62,1004,1005,1008],{},[75,1006,1007],{},"BADFUNC.TMPFILE_S",[75,1009,1010],{},[89,1011,972],{"href":971},[62,1013,1014,1016],{},[75,1015,1007],{},[75,1017,1018],{},[89,1019,982],{"href":981},[62,1021,1022,1025],{},[75,1023,1024],{},"BADFUNC.TMPNAM_S",[75,1026,1027],{},[89,1028,972],{"href":971},[62,1030,1031,1033],{},[75,1032,1024],{},[75,1034,1035],{},[89,1036,982],{"href":981},[62,1038,1039,1042],{},[75,1040,1041],{},"BADFUNC.TTYNAME",[75,1043,1044],{},[89,1045,870],{"href":869},[62,1047,1048,1051],{},[75,1049,1050],{},"BADFUNC.WEAKCRYPTO",[75,1052,1053],{},[89,1054,1056],{"href":1055},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc25-c","MSC25-C. Do not use insecure or weak cryptographic algorithms",[62,1058,1059,1062],{},[75,1060,1061],{},"BADMACRO.STDARG_H",[75,1063,1064],{},[89,1065,1067],{"href":1066},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc38-c","MSC38-C. Do not treat a predefined identifier as an object if it might only be implemented as a macro",[62,1069,1070,1072],{},[75,1071,1061],{},[75,1073,1074],{},[89,1075,1077],{"href":1076},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc39-c","MSC39-C. Do not call va_arg() on a va_list that has an indeterminate value",[62,1079,1080,1083],{},[75,1081,1082],{},"BADMACRO.WEAK_CRYPTO",[75,1084,1085],{},[89,1086,1056],{"href":1055},[62,1088,1089,1092],{},[75,1090,1091],{},"BUILD.WALL",[75,1093,1094],{},[89,1095,1097],{"href":1096},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc00-c","MSC00-C. Compile cleanly at high warning levels",[62,1099,1100,1103],{},[75,1101,1102],{},"BUILD.WERROR",[75,1104,1105],{},[89,1106,1097],{"href":1096},[62,1108,1109,1112],{},[75,1110,1111],{},"CONCURRENCY.BADFUNC.CNDSIGNAL",[75,1113,1114],{},[89,1115,1117],{"href":1116},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon38-c","CON38-C. Preserve thread safety and liveness when using condition variables",[62,1119,1120,1123],{},[75,1121,1122],{},"CONCURRENCY.BADFUNC.CNDWAIT",[75,1124,1125],{},[89,1126,1128],{"href":1127},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon36-c","CON36-C. Wrap functions that can spuriously wake up in a loop",[62,1130,1131,1134],{},[75,1132,1133],{},"CONCURRENCY.BADFUNC.PTHREAD_KILL",[75,1135,1136],{},[89,1137,1139],{"href":1138},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos44-c","POS44-C. Do not use signals to terminate threads",[62,1141,1142,1145],{},[75,1143,1144],{},"CONCURRENCY.C_ATOMIC",[75,1146,1147],{},[89,1148,621],{"href":620},[62,1150,1151,1154],{},[75,1152,1153],{},"CONCURRENCY.C_THREAD.ISD",[75,1155,1156],{},[89,1157,1159],{"href":1158},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon34-c","CON34-C. Declare objects shared between threads with appropriate storage durations",[62,1161,1162,1165],{},[75,1163,1164],{},"CONCURRENCY.DATARACE",[75,1166,1167],{},[89,1168,1170],{"href":1169},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig31-c","SIG31-C. Do not access shared objects in signal handlers",[62,1172,1173,1175],{},[75,1174,1164],{},[75,1176,1177],{},[89,1178,1180],{"href":1179},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon32-c","CON32-C. Prevent data races when accessing bit-fields from multiple threads",[62,1182,1183,1185],{},[75,1184,1164],{},[75,1186,1187],{},[89,1188,1190],{"href":1189},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon43-c","CON43-C. Do not allow data races in multithreaded code",[62,1192,1193,1195],{},[75,1194,1164],{},[75,1196,1197],{},[89,1198,1200],{"href":1199},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos49-c","POS49-C. When data must be accessed by multiple threads, provide a mutex and guarantee no adjacent data is also accessed",[62,1202,1203,1205],{},[75,1204,1164],{},[75,1206,1207],{},[89,1208,1210],{"href":1209},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon07-c","CON07-C. Ensure that compound operations on shared variables are atomic",[62,1212,1213,1216],{},[75,1214,1215],{},"CONCURRENCY.DU",[75,1217,1218],{},[89,1219,1221],{"href":1220},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos48-c","POS48-C. Do not unlock or destroy another POSIX thread's mutex",[62,1223,1224,1227],{},[75,1225,1226],{},"CONCURRENCY.LOCALARG",[75,1228,1229],{},[89,1230,1232],{"href":1231},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon31-c","CON31-C. Do not destroy a mutex while it is locked",[62,1234,1235,1237],{},[75,1236,1226],{},[75,1238,1239],{},[89,1240,1159],{"href":1158},[62,1242,1243,1246],{},[75,1244,1245],{},"CONCURRENCY.LOCK.NOLOCK",[75,1247,1248],{},[89,1249,1251],{"href":1250},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon01-c","CON01-C. Acquire and release synchronization primitives in the same module, at the same level of abstraction",[62,1253,1254,1257],{},[75,1255,1256],{},"CONCURRENCY.LOCK.NOUNLOCK",[75,1258,1259],{},[89,1260,1251],{"href":1250},[62,1262,1263,1266],{},[75,1264,1265],{},"CONCURRENCY.LOCK.ORDER",[75,1267,1268],{},[89,1269,1271],{"href":1270},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon35-c","CON35-C. Avoid deadlock by locking in a predefined order",[62,1273,1274,1276],{},[75,1275,1265],{},[75,1277,1278],{},[89,1279,1281],{"href":1280},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos51-c","POS51-C. Avoid deadlock with POSIX threads by locking in predefined order",[62,1283,1284,1287],{},[75,1285,1286],{},"CONCURRENCY.MAA",[75,1288,1289],{},[89,1290,1180],{"href":1179},[62,1292,1293,1295],{},[75,1294,1286],{},[75,1296,1297],{},[89,1298,1300],{"href":1299},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon40-c","CON40-C. Do not refer to an atomic variable twice in an expression",[62,1302,1303,1305],{},[75,1304,1286],{},[75,1306,1307],{},[89,1308,1190],{"href":1189},[62,1310,1311,1313],{},[75,1312,1286],{},[75,1314,1315],{},[89,1316,1200],{"href":1199},[62,1318,1319,1322],{},[75,1320,1321],{},"CONCURRENCY.STARVE.BLOCKING",[75,1323,1324],{},[89,1325,1327],{"href":1326},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos52-c","POS52-C. Do not perform operations that can block while holding a POSIX lock",[62,1329,1330,1332],{},[75,1331,1321],{},[75,1333,1334],{},[89,1335,1337],{"href":1336},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon05-c","CON05-C. Do not perform operations that can block while holding a lock",[62,1339,1340,1343],{},[75,1341,1342],{},"CONCURRENCY.THREADLOCAL",[75,1344,1345],{},[89,1346,621],{"href":620},[62,1348,1349,1352],{},[75,1350,1351],{},"CONCURRENCY.TNJ",[75,1353,1354],{},[89,1355,1357],{"href":1356},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon39-c","CON39-C. Do not join or detach a thread that was previously joined or detached",[62,1359,1360,1363],{},[75,1361,1362],{},"DIAG.UNEX.*",[75,1364,1365],{},[89,1366,1368],{"href":1367},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc07-c","MSC07-C. Detect and remove dead code",[62,1370,1371,1373],{},[75,1372,1362],{},[75,1374,1375],{},[89,1376,1378],{"href":1377},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc12-c","MSC12-C. Detect and remove code that has no effect or is never executed",[62,1380,1381,1384],{},[75,1382,1383],{},"HARDCODED.AUTH",[75,1385,1386],{},[89,1387,1389],{"href":1388},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc41-c","MSC41-C. Never hard code sensitive information",[62,1391,1392,1394],{},[75,1393,1383],{},[75,1395,1396],{},[89,1397,1399],{"href":1398},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc18-c","MSC18-C. Be careful while handling sensitive data, such as passwords, in program code",[62,1401,1402,1405],{},[75,1403,1404],{},"HARDCODED.DNS",[75,1406,1407],{},[89,1408,1389],{"href":1388},[62,1410,1411,1414],{},[75,1412,1413],{},"HARDCODED.KEY",[75,1415,1416],{},[89,1417,1389],{"href":1388},[62,1419,1420,1422],{},[75,1421,1413],{},[75,1423,1424],{},[89,1425,1399],{"href":1398},[62,1427,1428,1431],{},[75,1429,1430],{},"HARDCODED.SALT",[75,1432,1433],{},[89,1434,1389],{"href":1388},[62,1436,1437,1439],{},[75,1438,1430],{},[75,1440,1441],{},[89,1442,1399],{"href":1398},[62,1444,1445,1448],{},[75,1446,1447],{},"HARDCODED.SEED",[75,1449,1450],{},[89,1451,1453],{"href":1452},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc32-c","MSC32-C. Properly seed pseudorandom number generators",[62,1455,1456,1458],{},[75,1457,1447],{},[75,1459,1460],{},[89,1461,1389],{"href":1388},[62,1463,1464,1467],{},[75,1465,1466],{},"IO.BRAW",[75,1468,1469],{},[89,1470,172],{"href":171},[62,1472,1473,1476],{},[75,1474,1475],{},"IO.INJ.COMMAND",[75,1477,1478],{},[89,1479,850],{"href":849},[62,1481,1482,1484],{},[75,1483,1475],{},[75,1485,1486],{},[89,1487,1489],{"href":1488},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr02-c","STR02-C. Sanitize data passed to complex subsystems",[62,1491,1492,1495],{},[75,1493,1494],{},"IO.INJ.FMT",[75,1496,1497],{},[89,1498,1500],{"href":1499},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio30-c","FIO30-C. Exclude user input from format strings",[62,1502,1503,1505],{},[75,1504,1494],{},[75,1506,1507],{},[89,1508,1510],{"href":1509},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio47-c","FIO47-C. Use valid format strings",[62,1512,1513,1515],{},[75,1514,1494],{},[75,1516,1517],{},[89,1518,1489],{"href":1488},[62,1520,1521,1524],{},[75,1522,1523],{},"IO.INJ.LDAP",[75,1525,1526],{},[89,1527,1489],{"href":1488},[62,1529,1530,1533],{},[75,1531,1532],{},"IO.INJ.LIB",[75,1534,1535],{},[89,1536,1489],{"href":1488},[62,1538,1539,1542],{},[75,1540,1541],{},"IO.INJ.SQL",[75,1543,1544],{},[89,1545,1489],{"href":1488},[62,1547,1548,1551],{},[75,1549,1550],{},"IO.IOWOP",[75,1552,1553],{},[89,1554,1556],{"href":1555},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio39-c","FIO39-C. Do not alternately input and output from a stream without an intervening flush or positioning call",[62,1558,1559,1562],{},[75,1560,1561],{},"IO.OIWOP",[75,1563,1564],{},[89,1565,1556],{"href":1555},[62,1567,1568,1571],{},[75,1569,1570],{},"IO.RACE",[75,1572,1573],{},[89,1574,1576],{"href":1575},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio45-c","FIO45-C. Avoid TOCTOU race conditions while accessing files",[62,1578,1579,1581],{},[75,1580,1570],{},[75,1582,1583],{},[89,1584,972],{"href":971},[62,1586,1587,1589],{},[75,1588,1570],{},[75,1590,1591],{},[89,1592,172],{"href":171},[62,1594,1595,1598],{},[75,1596,1597],{},"IO.TAINT.ADDR",[75,1599,1600],{},[89,1601,243],{"href":242},[62,1603,1604,1607],{},[75,1605,1606],{},"IO.TAINT.FNAME",[75,1608,1609],{},[89,1610,972],{"href":971},[62,1612,1613,1615],{},[75,1614,1606],{},[75,1616,1617],{},[89,1618,1620],{"href":1619},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio02-c","FIO02-C. Canonicalize path names originating from tainted sources",[62,1622,1623,1626],{},[75,1624,1625],{},"IO.TAINT.SIZE",[75,1627,1628],{},[89,1629,352],{"href":351},[62,1631,1632,1634],{},[75,1633,1625],{},[75,1635,1636],{},[89,1637,243],{"href":242},[62,1639,1640,1642],{},[75,1641,1625],{},[75,1643,1644],{},[89,1645,1647],{"href":1646},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem05-c","MEM05-C. Avoid large stack allocations",[62,1649,1650,1652],{},[75,1651,1625],{},[75,1653,1654],{},[89,1655,253],{"href":252},[62,1657,1658,1661],{},[75,1659,1660],{},"IO.UAC",[75,1662,1663],{},[89,1664,1666],{"href":1665},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio46-c","FIO46-C. Do not access a closed file",[62,1668,1669,1672],{},[75,1670,1671],{},"IO.UT.HOST",[75,1673,1674],{},[89,1675,243],{"href":242},[62,1677,1678,1681],{},[75,1679,1680],{},"IO.UT.LIB",[75,1682,1683],{},[89,1684,1489],{"href":1488},[62,1686,1687,1690],{},[75,1688,1689],{},"IO.UT.PORT",[75,1691,1692],{},[89,1693,243],{"href":242},[62,1695,1696,1699],{},[75,1697,1698],{},"IO.UT.PROC",[75,1700,1701],{},[89,1702,1489],{"href":1488},[62,1704,1705,1708],{},[75,1706,1707],{},"LANG.ARITH.BIGSHIFT",[75,1709,1710],{},[89,1711,1713],{"href":1712},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint34-c","INT34-C. Do not shift an expression by a negative number of bits or by greater than or equal to the number of bits that exist in the operand",[62,1715,1716,1718],{},[75,1717,1707],{},[75,1719,1720],{},[89,1721,1723],{"href":1722},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint35-c","INT35-C. Use correct integer precisions",[62,1725,1726,1729],{},[75,1727,1728],{},"LANG.ARITH.DIVZERO",[75,1730,1731],{},[89,1732,1734],{"href":1733},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint33-c","INT33-C. Ensure that division and remainder operations do not result in divide-by-zero errors",[62,1736,1737,1740],{},[75,1738,1739],{},"LANG.ARITH.FDIVZERO",[75,1741,1742],{},[89,1743,1734],{"href":1733},[62,1745,1746,1749],{},[75,1747,1748],{},"LANG.ARITH.FMULOFLOW",[75,1750,1751],{},[89,1752,1754],{"href":1753},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp00-c","FLP00-C. Understand the limitations of floating-point numbers",[62,1756,1757,1760],{},[75,1758,1759],{},"LANG.ARITH.FPEQUAL",[75,1761,1762],{},[89,1763,1754],{"href":1753},[62,1765,1766,1768],{},[75,1767,1759],{},[75,1769,1770],{},[89,1771,1773],{"href":1772},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp02-c","FLP02-C. Avoid using floating-point numbers when precise computation is needed",[62,1775,1776,1779],{},[75,1777,1778],{},"LANG.ARITH.NEGSHIFT",[75,1780,1781],{},[89,1782,1713],{"href":1712},[62,1784,1785,1788],{},[75,1786,1787],{},"LANG.CAST.ARRAY.TEMP",[75,1789,1790],{},[89,1791,1793],{"href":1792},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp35-c","EXP35-C. Do not modify objects with temporary lifetime",[62,1795,1796,1798],{},[75,1797,1787],{},[75,1799,1800],{},[89,1801,1803],{"href":1802},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr00-c","ARR00-C. Understand how arrays work",[62,1805,1806,1809],{},[75,1807,1808],{},"LANG.CAST.COERCE",[75,1810,1811],{},[89,1812,534],{"href":533},[62,1814,1815,1817],{},[75,1816,1808],{},[75,1818,1819],{},[89,1820,1822],{"href":1821},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio34-c","FIO34-C. Distinguish between characters read from a file and EOF or WEOF",[62,1824,1825,1827],{},[75,1826,1808],{},[75,1828,1829],{},[89,1830,591],{"href":590},[62,1832,1833,1835],{},[75,1834,1808],{},[75,1836,1837],{},[89,1838,552],{"href":551},[62,1840,1841,1843],{},[75,1842,1808],{},[75,1844,1845],{},[89,1846,372],{"href":371},[62,1848,1849,1852],{},[75,1850,1851],{},"LANG.CAST.PC.AV",[75,1853,1854],{},[89,1855,534],{"href":533},[62,1857,1858,1861],{},[75,1859,1860],{},"LANG.CAST.PC.CONST2PTR",[75,1862,1863],{},[89,1864,534],{"href":533},[62,1866,1867,1869],{},[75,1868,1860],{},[75,1870,1871],{},[89,1872,1874],{"href":1873},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint36-c","INT36-C. Converting a pointer to integer or integer to pointer",[62,1876,1877,1880],{},[75,1878,1879],{},"LANG.CAST.PC.CRCQ",[75,1881,1882],{},[89,1883,1885],{"href":1884},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl00-c","DCL00-C. Const-qualify immutable objects",[62,1887,1888,1890],{},[75,1889,1879],{},[75,1891,1892],{},[89,1893,1895],{"href":1894},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp05-c","EXP05-C. Do not cast away a const qualification",[62,1897,1898,1901],{},[75,1899,1900],{},"LANG.CAST.PC.DCVBASE",[75,1902,1903],{},[89,1904,1906],{"href":1905},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp36-c","EXP36-C. Do not cast pointers into more strictly aligned pointer types",[62,1908,1909,1912],{},[75,1910,1911],{},"LANG.CAST.PC.INT",[75,1913,1914],{},[89,1915,534],{"href":533},[62,1917,1918,1920],{},[75,1919,1911],{},[75,1921,1922],{},[89,1923,1874],{"href":1873},[62,1925,1926,1929],{},[75,1927,1928],{},"LANG.CAST.PC.OBJ",[75,1930,1931],{},[89,1932,1906],{"href":1905},[62,1934,1935,1938],{},[75,1936,1937],{},"LANG.CAST.PC.VBASE",[75,1939,1940],{},[89,1941,1906],{"href":1905},[62,1943,1944,1947],{},[75,1945,1946],{},"LANG.CAST.RIP",[75,1948,1949],{},[89,1950,1952],{"href":1951},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp14-c","EXP14-C. Beware of integer promotion when performing bitwise operations on integer types smaller than int",[62,1954,1955,1958],{},[75,1956,1957],{},"LANG.CAST.VALUE",[75,1959,1960],{},[89,1961,534],{"href":533},[62,1963,1964,1966],{},[75,1965,1957],{},[75,1967,1968],{},[89,1969,591],{"href":590},[62,1971,1972,1974],{},[75,1973,1957],{},[75,1975,1976],{},[89,1977,552],{"href":551},[62,1979,1980,1982],{},[75,1981,1957],{},[75,1983,1984],{},[89,1985,372],{"href":371},[62,1987,1988,1991],{},[75,1989,1990],{},"LANG.ERRCODE.NOTEST",[75,1992,1993],{},[89,1994,1996],{"href":1995},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr33-c","ERR33-C. Detect and handle standard library errors",[62,1998,1999,2001],{},[75,2000,1990],{},[75,2002,2003],{},[89,2004,2006],{"href":2005},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos54-c","POS54-C. Detect and handle POSIX library errors",[62,2008,2009,2012],{},[75,2010,2011],{},"LANG.ERRCODE.NZ",[75,2013,2014],{},[89,2015,1996],{"href":1995},[62,2017,2018,2020],{},[75,2019,2011],{},[75,2021,2022],{},[89,2023,2006],{"href":2005},[62,2025,2026,2029],{},[75,2027,2028],{},"LANG.FUNCS.APM",[75,2030,2031],{},[89,2032,2034],{"href":2033},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp37-c","EXP37-C. Call functions with the correct number and type of arguments",[62,2036,2037,2040],{},[75,2038,2039],{},"LANG.FUNCS.ASSERTS",[75,2041,2042],{},[89,2043,2045],{"href":2044},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc11-c","MSC11-C. Incorporate diagnostic tests using assertions",[62,2047,2048,2051],{},[75,2049,2050],{},"LANG.FUNCS.IRV",[75,2052,2053],{},[89,2054,1996],{"href":1995},[62,2056,2057,2059],{},[75,2058,2050],{},[75,2060,2061],{},[89,2062,2006],{"href":2005},[62,2064,2065,2067],{},[75,2066,2050],{},[75,2068,2069],{},[89,2070,2072],{"href":2071},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp12-c","EXP12-C. Do not ignore values returned by functions",[62,2074,2075,2078],{},[75,2076,2077],{},"LANG.FUNCS.NORETURN",[75,2079,2080],{},[89,2081,621],{"href":620},[62,2083,2084,2087],{},[75,2085,2086],{},"LANG.FUNCS.PROT",[75,2088,2089],{},[89,2090,2092],{"href":2091},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl07-c","DCL07-C. Include the appropriate type information in function declarators",[62,2094,2095,2097],{},[75,2096,2086],{},[75,2098,2099],{},[89,2100,2102],{"href":2101},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl20-c","DCL20-C. Explicitly specify void when a function accepts no arguments",[62,2104,2105,2108],{},[75,2106,2107],{},"LANG.ID.AMBIG",[75,2109,2110],{},[89,2111,2113],{"href":2112},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl02-c","DCL02-C. Use visually distinct identifiers",[62,2115,2116,2119],{},[75,2117,2118],{},"LANG.ID.ND.EXT",[75,2120,2121],{},[89,2122,2124],{"href":2123},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl23-c","DCL23-C. Guarantee that mutually visible identifiers are unique",[62,2126,2127,2130],{},[75,2128,2129],{},"LANG.ID.ND.MM",[75,2131,2132],{},[89,2133,2124],{"href":2123},[62,2135,2136,2139],{},[75,2137,2138],{},"LANG.ID.ND.MO",[75,2140,2141],{},[89,2142,2124],{"href":2123},[62,2144,2145,2148],{},[75,2146,2147],{},"LANG.ID.ND.NEST",[75,2149,2150],{},[89,2151,2153],{"href":2152},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl01-c","DCL01-C. Do not reuse variable names in subscopes",[62,2155,2156,2158],{},[75,2157,2147],{},[75,2159,2160],{},[89,2161,2124],{"href":2123},[62,2163,2164,2167],{},[75,2165,2166],{},"LANG.ID.ND.SS",[75,2168,2169],{},[89,2170,2124],{"href":2123},[62,2172,2173,2176],{},[75,2174,2175],{},"LANG.ID.NU.EXT",[75,2177,2178],{},[89,2179,2124],{"href":2123},[62,2181,2182,2185],{},[75,2183,2184],{},"LANG.ID.NU.INT",[75,2186,2187],{},[89,2188,2124],{"href":2123},[62,2190,2191,2194],{},[75,2192,2193],{},"LANG.ID.NU.LIBFN",[75,2195,2196],{},[89,2197,2124],{"href":2123},[62,2199,2200,2203],{},[75,2201,2202],{},"LANG.ID.NU.TAG",[75,2204,2205],{},[89,2206,2124],{"href":2123},[62,2208,2209,2212],{},[75,2210,2211],{},"LANG.ID.NU.TYPE",[75,2213,2214],{},[89,2215,2124],{"href":2123},[62,2217,2218,2221],{},[75,2219,2220],{},"LANG.MEM.BO",[75,2222,2223],{},[89,2224,687],{"href":686},[62,2226,2227,2229],{},[75,2228,2220],{},[75,2230,2231],{},[89,2232,2234],{"href":2233},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr37-c","ARR37-C. Do not add or subtract an integer to a pointer to a non-array object",[62,2236,2237,2239],{},[75,2238,2220],{},[75,2240,2241],{},[89,2242,2244],{"href":2243},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr38-c","ARR38-C. Guarantee that library functions do not form invalid pointers",[62,2246,2247,2249],{},[75,2248,2220],{},[75,2250,2251],{},[89,2252,2254],{"href":2253},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr39-c","ARR39-C. Do not add or subtract a scaled integer to a pointer",[62,2256,2257,2259],{},[75,2258,2220],{},[75,2260,2261],{},[89,2262,697],{"href":696},[62,2264,2265,2267],{},[75,2266,2220],{},[75,2268,2269],{},[89,2270,2272],{"href":2271},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr38-c","STR38-C. Do not confuse narrow and wide character strings and functions",[62,2274,2275,2277],{},[75,2276,2220],{},[75,2278,2279],{},[89,2280,352],{"href":351},[62,2282,2283,2285],{},[75,2284,2220],{},[75,2286,2287],{},[89,2288,2290],{"href":2289},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos30-c","POS30-C. Use the readlink() function properly",[62,2292,2293,2295],{},[75,2294,2220],{},[75,2296,2297],{},[89,2298,233],{"href":232},[62,2300,2301,2303],{},[75,2302,2220],{},[75,2304,2305],{},[89,2306,2308],{"href":2307},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp08-c","EXP08-C. Ensure pointer arithmetic is used correctly",[62,2310,2311,2314],{},[75,2312,2313],{},"LANG.MEM.BU",[75,2315,2316],{},[89,2317,687],{"href":686},[62,2319,2320,2322],{},[75,2321,2313],{},[75,2323,2324],{},[89,2325,2234],{"href":2233},[62,2327,2328,2330],{},[75,2329,2313],{},[75,2331,2332],{},[89,2333,2244],{"href":2243},[62,2335,2336,2338],{},[75,2337,2313],{},[75,2339,2340],{},[89,2341,2254],{"href":2253},[62,2343,2344,2346],{},[75,2345,2313],{},[75,2347,2348],{},[89,2349,352],{"href":351},[62,2351,2352,2354],{},[75,2353,2313],{},[75,2355,2356],{},[89,2357,2308],{"href":2307},[62,2359,2360,2363],{},[75,2361,2362],{},"LANG.MEM.NPD",[75,2364,2365],{},[89,2366,2368],{"href":2367},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp34-c","EXP34-C. Do not dereference null pointers",[62,2370,2371,2374],{},[75,2372,2373],{},"LANG.MEM.TBA",[75,2375,2376],{},[89,2377,534],{"href":533},[62,2379,2380,2382],{},[75,2381,2373],{},[75,2383,2384],{},[89,2385,687],{"href":686},[62,2387,2388,2390],{},[75,2389,2373],{},[75,2391,2392],{},[89,2393,2234],{"href":2233},[62,2395,2396,2398],{},[75,2397,2373],{},[75,2399,2400],{},[89,2401,2254],{"href":2253},[62,2403,2404,2406],{},[75,2405,2373],{},[75,2407,2408],{},[89,2409,2272],{"href":2271},[62,2411,2412,2414],{},[75,2413,2373],{},[75,2415,2416],{},[89,2417,352],{"href":351},[62,2419,2420,2422],{},[75,2421,2373],{},[75,2423,2424],{},[89,2425,2290],{"href":2289},[62,2427,2428,2430],{},[75,2429,2373],{},[75,2431,2432],{},[89,2433,2308],{"href":2307},[62,2435,2436,2438],{},[75,2437,2373],{},[75,2439,2440],{},[89,2441,243],{"href":242},[62,2443,2444,2447],{},[75,2445,2446],{},"LANG.MEM.TO",[75,2448,2449],{},[89,2450,687],{"href":686},[62,2452,2453,2455],{},[75,2454,2446],{},[75,2456,2457],{},[89,2458,2234],{"href":2233},[62,2460,2461,2463],{},[75,2462,2446],{},[75,2464,2465],{},[89,2466,2254],{"href":2253},[62,2468,2469,2471],{},[75,2470,2446],{},[75,2472,2473],{},[89,2474,697],{"href":696},[62,2476,2477,2479],{},[75,2478,2446],{},[75,2480,2481],{},[89,2482,352],{"href":351},[62,2484,2485,2487],{},[75,2486,2446],{},[75,2488,2489],{},[89,2490,233],{"href":232},[62,2492,2493,2495],{},[75,2494,2446],{},[75,2496,2497],{},[89,2498,2308],{"href":2307},[62,2500,2501,2504],{},[75,2502,2503],{},"LANG.MEM.TU",[75,2505,2506],{},[89,2507,687],{"href":686},[62,2509,2510,2512],{},[75,2511,2503],{},[75,2513,2514],{},[89,2515,2234],{"href":2233},[62,2517,2518,2520],{},[75,2519,2503],{},[75,2521,2522],{},[89,2523,2254],{"href":2253},[62,2525,2526,2528],{},[75,2527,2503],{},[75,2529,2530],{},[89,2531,352],{"href":351},[62,2533,2534,2536],{},[75,2535,2503],{},[75,2537,2538],{},[89,2539,2308],{"href":2307},[62,2541,2542,2545],{},[75,2543,2544],{},"LANG.MEM.UVAR",[75,2546,2547],{},[89,2548,2550],{"href":2549},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp33-c","EXP33-C. Do not read uninitialized memory",[62,2552,2553,2555],{},[75,2554,2544],{},[75,2556,2557],{},[89,2558,2560],{"href":2559},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio40-c","FIO40-C. Reset strings on fgets() or fgetws() failure",[62,2562,2563,2566],{},[75,2564,2565],{},"LANG.PREPROC.FUNCMACRO",[75,2567,2568],{},[89,2569,2571],{"href":2570},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre31-c","PRE31-C. Avoid side effects in arguments to unsafe macros",[62,2573,2574,2576],{},[75,2575,2565],{},[75,2577,2578],{},[89,2579,2581],{"href":2580},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre00-c","PRE00-C. Prefer inline or static functions to function-like macros",[62,2583,2584,2587],{},[75,2585,2586],{},"LANG.PREPROC.HASH",[75,2588,2589],{},[89,2590,2592],{"href":2591},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre05-c","PRE05-C. Understand macro replacement when concatenating tokens or performing stringification",[62,2594,2595,2598],{},[75,2596,2597],{},"LANG.PREPROC.INCL.TGMATH_H",[75,2599,2600],{},[89,2601,621],{"href":620},[62,2603,2604,2607],{},[75,2605,2606],{},"LANG.PREPROC.MACROARG",[75,2608,2609],{},[89,2610,2612],{"href":2611},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre32-c","PRE32-C. Do not use preprocessor directives in invocations of function-like macros",[62,2614,2615,2618],{},[75,2616,2617],{},"LANG.PREPROC.MACROEND",[75,2619,2620],{},[89,2621,2623],{"href":2622},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre02-c","PRE02-C. Macro replacement lists should be parenthesized",[62,2625,2626,2628],{},[75,2627,2617],{},[75,2629,2630],{},[89,2631,2633],{"href":2632},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre11-c","PRE11-C. Do not conclude macro definitions with a semicolon",[62,2635,2636,2639],{},[75,2637,2638],{},"LANG.PREPROC.MACROSTART",[75,2640,2641],{},[89,2642,2623],{"href":2622},[62,2644,2645,2648],{},[75,2646,2647],{},"LANG.PREPROC.MARGME",[75,2649,2650],{},[89,2651,2592],{"href":2591},[62,2653,2654,2657],{},[75,2655,2656],{},"LANG.PREPROC.PASTE",[75,2658,2659],{},[89,2660,2662],{"href":2661},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c","PRE30-C. Do not create a universal character name through concatenation",[62,2664,2665,2667],{},[75,2666,2656],{},[75,2668,2669],{},[89,2670,2592],{"href":2591},[62,2672,2673,2676],{},[75,2674,2675],{},"LANG.PREPROC.PASTEHASH",[75,2677,2678],{},[89,2679,2662],{"href":2661},[62,2681,2682,2685],{},[75,2683,2684],{},"LANG.STRUCT.ALIGNAS",[75,2686,2687],{},[89,2688,621],{"href":620},[62,2690,2691,2694],{},[75,2692,2693],{},"LANG.STRUCT.ALIGNAS.EZA",[75,2695,2696],{},[89,2697,1378],{"href":1377},[62,2699,2700,2702],{},[75,2701,2693],{},[75,2703,2704],{},[89,2705,621],{"href":620},[62,2707,2708,2711],{},[75,2709,2710],{},"LANG.STRUCT.ALIGNAS.IAS",[75,2712,2713],{},[89,2714,621],{"href":620},[62,2716,2717,2720],{},[75,2718,2719],{},"LANG.STRUCT.ALIGNAS.TMAS",[75,2721,2722],{},[89,2723,621],{"href":620},[62,2725,2726,2729],{},[75,2727,2728],{},"LANG.STRUCT.ALIGNOF",[75,2730,2731],{},[89,2732,621],{"href":620},[62,2734,2735,2738],{},[75,2736,2737],{},"LANG.STRUCT.CONDASSIG",[75,2739,2740],{},[89,2741,2743],{"href":2742},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp45-c","EXP45-C. Do not perform assignments in selection statements",[62,2745,2746,2749],{},[75,2747,2748],{},"LANG.STRUCT.CUP",[75,2750,2751],{},[89,2752,2754],{"href":2753},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr36-c","ARR36-C. Do not subtract or compare two pointers that do not refer to the same array",[62,2756,2757,2759],{},[75,2758,2748],{},[75,2760,2761],{},[89,2762,2308],{"href":2307},[62,2764,2765,2768],{},[75,2766,2767],{},"LANG.STRUCT.DECL.FAM",[75,2769,2770],{},[89,2771,2773],{"href":2772},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem33-c","MEM33-C. Allocate and copy structures containing a flexible array member dynamically",[62,2775,2776,2779],{},[75,2777,2778],{},"LANG.STRUCT.DECL.IF",[75,2780,2781],{},[89,2782,2784],{"href":2783},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl40-c","DCL40-C. Do not create incompatible declarations of the same function or object",[62,2786,2787,2790],{},[75,2788,2789],{},"LANG.STRUCT.DECL.IMPFN",[75,2791,2792],{},[89,2793,621],{"href":620},[62,2795,2796,2799],{},[75,2797,2798],{},"LANG.STRUCT.DECL.IO",[75,2800,2801],{},[89,2802,2784],{"href":2783},[62,2804,2805,2808],{},[75,2806,2807],{},"LANG.STRUCT.DECL.MGT",[75,2809,2810],{},[89,2811,2124],{"href":2123},[62,2813,2814,2817],{},[75,2815,2816],{},"LANG.STRUCT.DECL.ML",[75,2818,2819],{},[89,2820,2822],{"href":2821},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl04-c","DCL04-C. Do not declare more than one variable per declaration",[62,2824,2825,2828],{},[75,2826,2827],{},"LANG.STRUCT.DECL.NOEXT",[75,2829,2830],{},[89,2831,2833],{"href":2832},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl36-c","DCL36-C. Do not declare an identifier with conflicting linkage classifications",[62,2835,2836,2839],{},[75,2837,2838],{},"LANG.STRUCT.DECL.RESERVED",[75,2840,2841],{},[89,2842,2844],{"href":2843},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl37-c","DCL37-C. Do not declare or define a reserved identifier",[62,2846,2847,2850],{},[75,2848,2849],{},"LANG.STRUCT.DECL.VLA",[75,2851,2852],{},[89,2853,621],{"href":620},[62,2855,2856,2859],{},[75,2857,2858],{},"LANG.STRUCT.EBS",[75,2860,2861],{},[89,2862,2864],{"href":2863},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp15-c","EXP15-C. Do not place a semicolon on the same line as an if, for, or while statement",[62,2866,2867,2869],{},[75,2868,2858],{},[75,2870,2871],{},[89,2872,1378],{"href":1377},[62,2874,2875,2878],{},[75,2876,2877],{},"LANG.STRUCT.ELLIPSIS",[75,2879,2880],{},[89,2881,2883],{"href":2882},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl11-c","DCL11-C. Understand the type issues associated with variadic functions",[62,2885,2886,2889],{},[75,2887,2888],{},"LANG.STRUCT.ICOL",[75,2890,2891],{},[89,2892,1128],{"href":1127},[62,2894,2895,2897],{},[75,2896,2888],{},[75,2898,2899],{},[89,2900,2902],{"href":2901},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon41-c","CON41-C. Wrap functions that can fail spuriously in a loop",[62,2904,2905,2908],{},[75,2906,2907],{},"LANG.STRUCT.INIT.ENUM",[75,2909,2910],{},[89,2911,2913],{"href":2912},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint09-c","INT09-C. Ensure enumeration constants map to unique values",[62,2915,2916,2919],{},[75,2917,2918],{},"LANG.STRUCT.INIT.UADI",[75,2920,2921],{},[89,2922,621],{"href":620},[62,2924,2925,2928],{},[75,2926,2927],{},"LANG.STRUCT.LOOP.FPC",[75,2929,2930],{},[89,2931,2933],{"href":2932},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp30-c","FLP30-C. Do not use floating-point variables as loop counters",[62,2935,2936,2939],{},[75,2937,2938],{},"LANG.STRUCT.LOOP.HR",[75,2940,2941],{},[89,2942,2944],{"href":2943},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc21-c","MSC21-C. Use robust loop termination conditions",[62,2946,2947,2950],{},[75,2948,2949],{},"LANG.STRUCT.LOOP.UB",[75,2951,2952],{},[89,2953,2944],{"href":2943},[62,2955,2956,2959],{},[75,2957,2958],{},"LANG.STRUCT.MRS",[75,2960,2961],{},[89,2962,2964],{"href":2963},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc37-c","MSC37-C. Ensure that control never reaches the end of a non-void function",[62,2966,2967,2970],{},[75,2968,2969],{},"LANG.STRUCT.NTAD",[75,2971,2972],{},[89,2973,2368],{"href":2367},[62,2975,2976,2979],{},[75,2977,2978],{},"LANG.STRUCT.PARENS",[75,2980,2981],{},[89,2982,2984],{"href":2983},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp00-c","EXP00-C. Use parentheses for precedence of operation",[62,2986,2987,2990],{},[75,2988,2989],{},"LANG.STRUCT.PARITH",[75,2991,2992],{},[89,2993,687],{"href":686},[62,2995,2996,2998],{},[75,2997,2989],{},[75,2999,3000],{},[89,3001,2234],{"href":2233},[62,3003,3004,3006],{},[75,3005,2989],{},[75,3007,3008],{},[89,3009,2254],{"href":2253},[62,3011,3012,3014],{},[75,3013,2989],{},[75,3015,3016],{},[89,3017,352],{"href":351},[62,3019,3020,3022],{},[75,3021,2989],{},[75,3023,3024],{},[89,3025,2308],{"href":2307},[62,3027,3028,3031],{},[75,3029,3030],{},"LANG.STRUCT.PBB",[75,3032,3033],{},[89,3034,687],{"href":686},[62,3036,3037,3039],{},[75,3038,3030],{},[75,3040,3041],{},[89,3042,2234],{"href":2233},[62,3044,3045,3047],{},[75,3046,3030],{},[75,3048,3049],{},[89,3050,2254],{"href":2253},[62,3052,3053,3055],{},[75,3054,3030],{},[75,3056,3057],{},[89,3058,352],{"href":351},[62,3060,3061,3063],{},[75,3062,3030],{},[75,3064,3065],{},[89,3066,2308],{"href":2307},[62,3068,3069,3072],{},[75,3070,3071],{},"LANG.STRUCT.PIT",[75,3073,3074],{},[89,3075,3077],{"href":3076},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl05-c","DCL05-C. Use typedefs of non-pointer types only",[62,3079,3080,3083],{},[75,3081,3082],{},"LANG.STRUCT.PPE",[75,3084,3085],{},[89,3086,687],{"href":686},[62,3088,3089,3091],{},[75,3090,3082],{},[75,3092,3093],{},[89,3094,2234],{"href":2233},[62,3096,3097,3099],{},[75,3098,3082],{},[75,3100,3101],{},[89,3102,2254],{"href":2253},[62,3104,3105,3107],{},[75,3106,3082],{},[75,3108,3109],{},[89,3110,352],{"href":351},[62,3112,3113,3115],{},[75,3114,3082],{},[75,3116,3117],{},[89,3118,2308],{"href":2307},[62,3120,3121,3124],{},[75,3122,3123],{},"LANG.STRUCT.RC",[75,3125,3126],{},[89,3127,3129],{"href":3128},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr30-c","ERR30-C. Take care when reading errno",[62,3131,3132,3134],{},[75,3133,3123],{},[75,3135,3136],{},[89,3137,1368],{"href":1367},[62,3139,3140,3142],{},[75,3141,3123],{},[75,3143,3144],{},[89,3145,1378],{"href":1377},[62,3147,3148,3151],{},[75,3149,3150],{},"LANG.STRUCT.RFCESH",[75,3152,3153],{},[89,3154,3156],{"href":3155},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig35-c","SIG35-C. Do not return from a computational exception signal handler",[62,3158,3159,3162],{},[75,3160,3161],{},"LANG.STRUCT.RPL",[75,3163,3164],{},[89,3165,3167],{"href":3166},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl30-c","DCL30-C. Declare objects with appropriate storage durations",[62,3169,3170,3173],{},[75,3171,3172],{},"LANG.STRUCT.RPNTC",[75,3174,3175],{},[89,3176,769],{"href":768},[62,3178,3179,3181],{},[75,3180,3172],{},[75,3182,3183],{},[89,3184,1885],{"href":1884},[62,3186,3187,3190],{},[75,3188,3189],{},"LANG.STRUCT.SCOPE.FILE",[75,3191,3192],{},[89,3193,3195],{"href":3194},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl15-c","DCL15-C. Declare file-scope objects or functions that do not need external linkage as static",[62,3197,3198,3200],{},[75,3199,3189],{},[75,3201,3202],{},[89,3203,3205],{"href":3204},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl19-c","DCL19-C. Minimize the scope of variables and functions",[62,3207,3208,3211],{},[75,3209,3210],{},"LANG.STRUCT.SCOPE.LOCAL",[75,3212,3213],{},[89,3214,3205],{"href":3204},[62,3216,3217,3220],{},[75,3218,3219],{},"LANG.STRUCT.SE.CGEN",[75,3221,3222],{},[89,3223,3225],{"href":3224},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp44-c","EXP44-C. Do not rely on side effects in operands to sizeof, _Alignof, or _Generic",[62,3227,3228,3231],{},[75,3229,3230],{},"LANG.STRUCT.SE.COND",[75,3232,3233],{},[89,3234,2743],{"href":2742},[62,3236,3237,3240],{},[75,3238,3239],{},"LANG.STRUCT.SE.DEC",[75,3241,3242],{},[89,3243,2571],{"href":2570},[62,3245,3246,3248],{},[75,3247,3239],{},[75,3249,3250],{},[89,3251,3253],{"href":3252},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp30-c","EXP30-C. Do not depend on the order of evaluation for side effects",[62,3255,3256,3259],{},[75,3257,3258],{},"LANG.STRUCT.SE.INC",[75,3260,3261],{},[89,3262,2571],{"href":2570},[62,3264,3265,3267],{},[75,3266,3258],{},[75,3268,3269],{},[89,3270,3253],{"href":3252},[62,3272,3273,3276],{},[75,3274,3275],{},"LANG.STRUCT.SE.INIT",[75,3277,3278],{},[89,3279,3253],{"href":3252},[62,3281,3282,3285],{},[75,3283,3284],{},"LANG.STRUCT.SE.IOE",[75,3286,3287],{},[89,3288,3290],{"href":3289},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp10-c","EXP10-C. Do not depend on the order of evaluation of subexpressions or the order in which side effects take place",[62,3292,3293,3296],{},[75,3294,3295],{},"LANG.STRUCT.SE.SIZEOF",[75,3297,3298],{},[89,3299,3225],{"href":3224},[62,3301,3302,3305],{},[75,3303,3304],{},"LANG.STRUCT.SUP",[75,3306,3307],{},[89,3308,2754],{"href":2753},[62,3310,3311,3313],{},[75,3312,3304],{},[75,3314,3315],{},[89,3316,2308],{"href":2307},[62,3318,3319,3322],{},[75,3320,3321],{},"LANG.STRUCT.SW.BAD",[75,3323,3324],{},[89,3325,3327],{"href":3326},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl41-c","DCL41-C. Do not declare variables inside a switch statement before the first case label",[62,3329,3330,3333],{},[75,3331,3332],{},"LANG.STRUCT.SW.MB",[75,3334,3335],{},[89,3336,3338],{"href":3337},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc17-c","MSC17-C. Finish every set of statements associated with a case label with a break statement",[62,3340,3341,3344],{},[75,3342,3343],{},"LANG.STRUCT.SW.MPC",[75,3345,3346],{},[89,3347,3349],{"href":3348},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc20-c","MSC20-C. Do not use a switch statement to transfer control into a complex block",[62,3351,3352,3355],{},[75,3353,3354],{},"LANG.STRUCT.SW.SWNEE",[75,3356,3357],{},[89,3358,3360],{"href":3359},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl06-c","DCL06-C. Use meaningful symbolic constants to represent literal values",[62,3362,3363,3366],{},[75,3364,3365],{},"LANG.STRUCT.UA",[75,3367,3368],{},[89,3369,1378],{"href":1377},[62,3371,3372,3375],{},[75,3373,3374],{},"LANG.STRUCT.UC",[75,3376,3377],{},[89,3378,1368],{"href":1367},[62,3380,3381,3383],{},[75,3382,3374],{},[75,3384,3385],{},[89,3386,1378],{"href":1377},[62,3388,3389,3392],{},[75,3390,3391],{},"LANG.STRUCT.UPD",[75,3393,3394],{},[89,3395,2368],{"href":2367},[62,3397,3398,3400],{},[75,3399,3391],{},[75,3401,3402],{},[89,3403,3405],{"href":3404},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi00-c","API00-C. Functions should validate their parameters",[62,3407,3408,3411],{},[75,3409,3410],{},"LANG.STRUCT.USEASSIGN",[75,3412,3413],{},[89,3414,2743],{"href":2742},[62,3416,3417,3420],{},[75,3418,3419],{},"LANG.STRUCT.UULABEL",[75,3421,3422],{},[89,3423,1378],{"href":1377},[62,3425,3426,3429],{},[75,3427,3428],{},"LANG.STRUCT.UUMACRO",[75,3430,3431],{},[89,3432,1378],{"href":1377},[62,3434,3435,3438],{},[75,3436,3437],{},"LANG.STRUCT.UUPARAM",[75,3439,3440],{},[89,3441,1378],{"href":1377},[62,3443,3444,3447],{},[75,3445,3446],{},"LANG.STRUCT.UUTAG",[75,3448,3449],{},[89,3450,1378],{"href":1377},[62,3452,3453,3456],{},[75,3454,3455],{},"LANG.STRUCT.UUTYPE",[75,3457,3458],{},[89,3459,1378],{"href":1377},[62,3461,3462,3465],{},[75,3463,3464],{},"LANG.STRUCT.UUVAL",[75,3466,3467],{},[89,3468,3470],{"href":3469},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc13-c","MSC13-C. Detect and remove unused values",[62,3472,3473,3476],{},[75,3474,3475],{},"LANG.STRUCT.UUVAR",[75,3477,3478],{},[89,3479,1378],{"href":1377},[62,3481,3482,3485],{},[75,3483,3484],{},"LANG.TYPE.AWID",[75,3486,3487],{},[89,3488,372],{"href":371},[62,3490,3491,3494],{},[75,3492,3493],{},"LANG.TYPE.BASIC",[75,3495,3496],{},[89,3497,3499],{"href":3498},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint01-c","INT01-C. Use size_t or rsize_t for all integer values representing the size of an object",[62,3501,3502,3505],{},[75,3503,3504],{},"LANG.TYPE.BFSIGN",[75,3506,3507],{},[89,3508,3510],{"href":3509},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint12-c","INT12-C. Do not make assumptions about the type of a plain int bit-field when used in an expression",[62,3512,3513,3516],{},[75,3514,3515],{},"LANG.TYPE.CBCONST",[75,3517,3518],{},[89,3519,3521],{"href":3520},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl13-c","DCL13-C. Declare function parameters that are pointers to values not changed by the function as const",[62,3523,3524,3527],{},[75,3525,3526],{},"LANG.TYPE.CSUF",[75,3528,3529],{},[89,3530,3532],{"href":3531},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl16-c","DCL16-C. Use \"L,\" not \"l,\" to indicate a long value",[62,3534,3535,3538],{},[75,3536,3537],{},"LANG.TYPE.IAT",[75,3539,3540],{},[89,3541,3543],{"href":3542},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp34-c","FLP34-C. Ensure that floating-point conversions are within range of the new type",[62,3545,3546,3548],{},[75,3547,3537],{},[75,3549,3550],{},[89,3551,3553],{"href":3552},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp36-c","FLP36-C. Preserve precision when converting integral values to floating-point type",[62,3555,3556,3558],{},[75,3557,3537],{},[75,3559,3560],{},[89,3561,3563],{"href":3562},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr04-c","STR04-C. Use plain char for characters in the basic character set",[62,3565,3566,3569],{},[75,3567,3568],{},"LANG.TYPE.ICA",[75,3570,3571],{},[89,3572,3563],{"href":3562},[62,3574,3575,3578],{},[75,3576,3577],{},"LANG.TYPE.IOT",[75,3579,3580],{},[89,3581,3583],{"href":3582},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp46-c","EXP46-C. Do not use a bitwise operator with a Boolean-like operand",[62,3585,3586,3588],{},[75,3587,3577],{},[75,3589,3590],{},[89,3591,3593],{"href":3592},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint07-c","INT07-C. Use only explicitly signed or unsigned char type for numeric values",[62,3595,3596,3598],{},[75,3597,3577],{},[75,3599,3600],{},[89,3601,3603],{"href":3602},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint13-c","INT13-C. Use bitwise operators only on unsigned operands",[62,3605,3606,3608],{},[75,3607,3577],{},[75,3609,3610],{},[89,3611,3563],{"href":3562},[62,3613,3614,3617],{},[75,3615,3616],{},"LANG.TYPE.IVD",[75,3618,3619],{},[89,3620,3622],{"href":3621},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon02-c","CON02-C. Do not use volatile as a synchronization primitive",[62,3624,3625,3628],{},[75,3626,3627],{},"LANG.TYPE.MOT",[75,3629,3630],{},[89,3631,3633],{"href":3632},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp06-c","FLP06-C. Convert integers to floating point for floating-point operations",[62,3635,3636,3638],{},[75,3637,3627],{},[75,3639,3640],{},[89,3641,3563],{"href":3562},[62,3643,3644,3647],{},[75,3645,3646],{},"LANG.TYPE.NCS",[75,3648,3649],{},[89,3650,3652],{"href":3651},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr05-c","STR05-C. Use pointers to const when referring to string literals",[62,3654,3655,3658],{},[75,3656,3657],{},"LANG.TYPE.OC",[75,3659,3660],{},[89,3661,3663],{"href":3662},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl18-c","DCL18-C. Do not begin integer constants with 0 when specifying a decimal value",[62,3665,3666,3669],{},[75,3667,3668],{},"LANG.TYPE.OWID",[75,3670,3671],{},[89,3672,372],{"href":371},[62,3674,3675,3678],{},[75,3676,3677],{},"LANG.TYPE.RESTRICT",[75,3679,3680],{},[89,3681,3683],{"href":3682},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp43-c","EXP43-C. Avoid undefined behavior when using restrict-qualified pointers",[62,3685,3686,3689],{},[75,3687,3688],{},"LANG.TYPE.SAP",[75,3690,3691],{},[89,3692,3694],{"href":3693},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr01-c","ARR01-C. Do not apply the sizeof operator to a pointer when taking the size of an array",[62,3696,3697,3700],{},[75,3698,3699],{},"LANG.TYPE.VCBC",[75,3701,3702],{},[89,3703,1885],{"href":1884},[62,3705,3706,3709],{},[75,3707,3708],{},"LANG.TYPE.VMAT",[75,3710,3711],{},[89,3712,621],{"href":620},[62,3714,3715,3718],{},[75,3716,3717],{},"MATH.DOMAIN",[75,3719,3720],{},[89,3721,3723],{"href":3722},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp32-c","FLP32-C. Prevent or detect domain and range errors in math functions",[62,3725,3726,3729],{},[75,3727,3728],{},"MATH.DOMAIN.ATAN",[75,3730,3731],{},[89,3732,3723],{"href":3722},[62,3734,3735,3738],{},[75,3736,3737],{},"MATH.DOMAIN.FE_INVALID",[75,3739,3740],{},[89,3741,3723],{"href":3722},[62,3743,3744,3747],{},[75,3745,3746],{},"MATH.DOMAIN.LOG",[75,3748,3749],{},[89,3750,3723],{"href":3722},[62,3752,3753,3756],{},[75,3754,3755],{},"MATH.DOMAIN.POW",[75,3757,3758],{},[89,3759,3723],{"href":3722},[62,3761,3762,3765],{},[75,3763,3764],{},"MATH.DOMAIN.SQRT",[75,3766,3767],{},[89,3768,3723],{"href":3722},[62,3770,3771,3774],{},[75,3772,3773],{},"MATH.DOMAIN.TOOHIGH",[75,3775,3776],{},[89,3777,3723],{"href":3722},[62,3779,3780,3783],{},[75,3781,3782],{},"MATH.DOMAIN.TOOLOW",[75,3784,3785],{},[89,3786,3723],{"href":3722},[62,3788,3789,3792],{},[75,3790,3791],{},"MATH.RANGE",[75,3793,3794],{},[89,3795,3723],{"href":3722},[62,3797,3798,3801],{},[75,3799,3800],{},"MATH.RANGE.COSH.TOOHIGH",[75,3802,3803],{},[89,3804,3723],{"href":3722},[62,3806,3807,3810],{},[75,3808,3809],{},"MATH.RANGE.COSH.TOOLOW",[75,3811,3812],{},[89,3813,3723],{"href":3722},[62,3815,3816,3819],{},[75,3817,3818],{},"MATH.RANGE.GAMMA",[75,3820,3821],{},[89,3822,3723],{"href":3722},[62,3824,3825,3827],{},[75,3826,3818],{},[75,3828,3829],{},[89,3830,621],{"href":620},[62,3832,3833,3836],{},[75,3834,3835],{},"MATH.RANGE.LOG",[75,3837,3838],{},[89,3839,3723],{"href":3722},[62,3841,3842,3845],{},[75,3843,3844],{},"MISC.CHROOT.NOCHDIR",[75,3846,3847],{},[89,3848,718],{"href":717},[62,3850,3851,3854],{},[75,3852,3853],{},"MISC.CRYPTO.TIMESEED",[75,3855,3856],{},[89,3857,1453],{"href":1452},[62,3859,3860,3863],{},[75,3861,3862],{},"MISC.FMT",[75,3864,3865],{},[89,3866,1500],{"href":1499},[62,3868,3869,3871],{},[75,3870,3862],{},[75,3872,3873],{},[89,3874,1510],{"href":1509},[62,3876,3877,3880],{},[75,3878,3879],{},"MISC.FMTTYPE",[75,3881,3882],{},[89,3883,1510],{"href":1509},[62,3885,3886,3889],{},[75,3887,3888],{},"MISC.MEM.NTERM",[75,3890,3891],{},[89,3892,697],{"href":696},[62,3894,3895,3897],{},[75,3896,3888],{},[75,3898,3899],{},[89,3900,3902],{"href":3901},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr03-c","STR03-C. Do not inadvertently truncate a string",[62,3904,3905,3908],{},[75,3906,3907],{},"MISC.MEM.NTERM.CSTRING",[75,3909,3910],{},[89,3911,3913],{"href":3912},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr32-c","STR32-C. Do not pass a non-null-terminated character sequence to a library function that expects a string",[62,3915,3916,3918],{},[75,3917,3907],{},[75,3919,3920],{},[89,3921,2290],{"href":2289},[62,3923,3924,3927],{},[75,3925,3926],{},"MISC.MEM.SIZE.ADDOFLOW",[75,3928,3929],{},[89,3930,332],{"href":331},[62,3932,3933,3935],{},[75,3934,3926],{},[75,3936,3937],{},[89,3938,342],{"href":341},[62,3940,3941,3943],{},[75,3942,3926],{},[75,3944,3945],{},[89,3946,362],{"href":361},[62,3948,3949,3951],{},[75,3950,3926],{},[75,3952,3953],{},[89,3954,372],{"href":371},[62,3956,3957,3960],{},[75,3958,3959],{},"MISC.MEM.SIZE.BAD",[75,3961,3962],{},[89,3963,332],{"href":331},[62,3965,3966,3968],{},[75,3967,3959],{},[75,3969,3970],{},[89,3971,342],{"href":341},[62,3973,3974,3976],{},[75,3975,3959],{},[75,3977,3978],{},[89,3979,399],{"href":398},[62,3981,3982,3984],{},[75,3983,3959],{},[75,3985,3986],{},[89,3987,352],{"href":351},[62,3989,3990,3992],{},[75,3991,3959],{},[75,3993,3994],{},[89,3995,362],{"href":361},[62,3997,3998,4000],{},[75,3999,3959],{},[75,4001,4002],{},[89,4003,372],{"href":371},[62,4005,4006,4008],{},[75,4007,3959],{},[75,4009,4010],{},[89,4011,1647],{"href":1646},[62,4013,4014,4016],{},[75,4015,3959],{},[75,4017,4018],{},[89,4019,253],{"href":252},[62,4021,4022,4025],{},[75,4023,4024],{},"MISC.MEM.SIZE.MULOFLOW",[75,4026,4027],{},[89,4028,332],{"href":331},[62,4030,4031,4033],{},[75,4032,4024],{},[75,4034,4035],{},[89,4036,342],{"href":341},[62,4038,4039,4041],{},[75,4040,4024],{},[75,4042,4043],{},[89,4044,362],{"href":361},[62,4046,4047,4049],{},[75,4048,4024],{},[75,4050,4051],{},[89,4052,372],{"href":371},[62,4054,4055,4058],{},[75,4056,4057],{},"MISC.MEM.SIZE.SUBUFLOW",[75,4059,4060],{},[89,4061,332],{"href":331},[62,4063,4064,4066],{},[75,4065,4057],{},[75,4067,4068],{},[89,4069,342],{"href":341},[62,4071,4072,4074],{},[75,4073,4057],{},[75,4075,4076],{},[89,4077,362],{"href":361},[62,4079,4080,4082],{},[75,4081,4057],{},[75,4083,4084],{},[89,4085,372],{"href":371},[62,4087,4088,4091],{},[75,4089,4090],{},"MISC.MEM.SIZE.TRUNC",[75,4092,4093],{},[89,4094,534],{"href":533},[62,4096,4097,4099],{},[75,4098,4090],{},[75,4100,4101],{},[89,4102,552],{"href":551},[62,4104,4105,4107],{},[75,4106,4090],{},[75,4108,4109],{},[89,4110,372],{"href":371},[62,4112,4113,4116],{},[75,4114,4115],{},"MISC.NEGCHAR",[75,4117,4118],{},[89,4119,4121],{"href":4120},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr34-c","STR34-C. Cast characters to unsigned char before converting to larger integer sizes",[62,4123,4124,4126],{},[75,4125,4115],{},[75,4127,4128],{},[89,4129,4131],{"href":4130},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr37-c","STR37-C. Arguments to character-handling functions must be representable as an unsigned char",[62,4133,4134,4136],{},[75,4135,4115],{},[75,4137,4138],{},[89,4139,4141],{"href":4140},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint05-c","INT05-C. Do not use input functions to convert character data if they cannot handle all possible inputs",[62,4143,4144,4146],{},[75,4145,4115],{},[75,4147,4148],{},[89,4149,4151],{"href":4150},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr00-c","STR00-C. Represent characters using an appropriate type",[62,4153,4154,4157],{},[75,4155,4156],{},"MISC.NOEFFECT",[75,4158,4159],{},[89,4160,1378],{"href":1377},[62,4162,4163,4166],{},[75,4164,4165],{},"MISC.PADDING.POTB",[75,4167,4168],{},[89,4169,4171],{"href":4170},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl39-c","DCL39-C. Avoid information leakage when passing a structure across a trust boundary",[62,4173,4174,4177],{},[75,4175,4176],{},"MISC.PWD.PLAIN",[75,4178,4179],{},[89,4180,1399],{"href":1398},[62,4182,4183,4186],{},[75,4184,4185],{},"MISC.PWD.PLAINTRAN",[75,4187,4188],{},[89,4189,1399],{"href":1398},[62,4191,4192,4195],{},[75,4193,4194],{},"PARSE.BAD.TOKEN",[75,4196,4197],{},[89,4198,4200],{"href":4199},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fuse-subset-of-ascii-for-safety","MSC09-C. Character encoding: Use subset of ASCII for safety",[62,4202,4203,4206],{},[75,4204,4205],{},"PARSE.BIH",[75,4207,4208],{},[89,4209,3349],{"href":3348},[62,4211,4212,4215],{},[75,4213,4214],{},"PARSE.BITB",[75,4216,4217],{},[89,4218,3349],{"href":3348},[62,4220,4221,4224],{},[75,4222,4223],{},"PARSE.DBNR",[75,4225,4226],{},[89,4227,1378],{"href":1377},[62,4229,4230,4233],{},[75,4231,4232],{},"PARSE.DE",[75,4234,4235],{},[89,4236,202],{"href":201},[62,4238,4239,4242],{},[75,4240,4241],{},"PARSE.IMPLICIT.IOM",[75,4243,4244],{},[89,4245,2092],{"href":2091},[62,4247,4248,4251],{},[75,4249,4250],{},"PARSE.MISSING.DS",[75,4252,4253],{},[89,4254,2092],{"href":2091},[62,4256,4257,4260],{},[75,4258,4259],{},"PARSE.MISSING.TS",[75,4261,4262],{},[89,4263,2092],{"href":2091},[62,4265,4266,4269],{},[75,4267,4268],{},"PARSE.NONSTD.II",[75,4270,4271],{},[89,4272,2092],{"href":2091},[62,4274,4275,4278],{},[75,4276,4277],{},"PARSE.PCLB",[75,4279,4280],{},[89,4281,1874],{"href":1873},[62,4283,4284,4287],{},[75,4285,4286],{},"PARSE.PCTSSI",[75,4288,4289],{},[89,4290,1874],{"href":1873},[62,4292,4293,4296],{},[75,4294,4295],{},"PARSE.PILNFD",[75,4297,4298],{},[89,4299,2092],{"href":2091},[62,4301,4302,4305],{},[75,4303,4304],{},"PARSE.UNDECLPARAM",[75,4306,4307],{},[89,4308,2092],{"href":2091},{"title":4310,"searchDepth":4311,"depth":4311,"links":4312},"",2,[],"md",{"tags":4315},[4316],"analyzer","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar",{"title":30,"description":41},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F13.codesonar","HOM5WIluh5U_7d8tQ0ba9bHfQUw-61x_cW0eQhSaDl4",[4322,4326],{"title":4323,"path":4324,"stem":4325,"children":-1},"Codee_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodee_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F12.codee_v",{"title":4327,"path":4328,"stem":4329,"children":-1},"CodeSonar_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F14.codesonar_v",[4331],{"title":4332,"path":4333,"stem":4334,"children":4335},"SEI CERT C Coding Standard","\u002Fsei-cert-c-coding-standard","4.sei-cert-c-coding-standard\u002F01.index",[4336,4337,4409,4805,5093,5107,5111,5115,5119,5751],{"title":4332,"path":4333,"stem":4334},{"title":4338,"path":4339,"stem":4340,"children":4341},"Front Matter","\u002Fsei-cert-c-coding-standard\u002Ffront-matter","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F1.index",[4342,4343],{"title":4338,"path":4339,"stem":4340},{"title":4344,"path":4345,"stem":4346,"children":4347},"Introduction","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[4348,4349,4353,4357,4361,4365,4369,4373,4377,4381,4385,4389,4393,4397,4401,4405],{"title":4344,"path":4345,"stem":4346},{"title":4350,"path":4351,"stem":4352},"Scope","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.scope",{"title":4354,"path":4355,"stem":4356},"Audience","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F02.audience",{"title":4358,"path":4359,"stem":4360},"How this Coding Standard is Organized","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F03.how-this-coding-standard-is-organized",{"title":4362,"path":4363,"stem":4364},"History","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhistory","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F04.history",{"title":4366,"path":4367,"stem":4368},"ISO\u002FIEC TS 17961 C Secure Coding Rules","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fisoiec-ts-17961-c-secure-coding-rules","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F05.isoiec-ts-17961-c-secure-coding-rules",{"title":4370,"path":4371,"stem":4372},"Tool Selection and Validation","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Ftool-selection-and-validation","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F06.tool-selection-and-validation",{"title":4374,"path":4375,"stem":4376},"Taint Analysis","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Ftaint-analysis","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F07.taint-analysis",{"title":4378,"path":4379,"stem":4380},"Rules versus Recommendations","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Frules-versus-recommendations","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F08.rules-versus-recommendations",{"title":4382,"path":4383,"stem":4384},"Conformance Testing","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fconformance-testing","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F09.conformance-testing",{"title":4386,"path":4387,"stem":4388},"Development Process","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fdevelopment-process","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F10.development-process",{"title":4390,"path":4391,"stem":4392},"Usage","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F11.usage",{"title":4394,"path":4395,"stem":4396},"System Qualities","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fsystem-qualities","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F12.system-qualities",{"title":4398,"path":4399,"stem":4400},"Automatically Generated Code","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fautomatically-generated-code","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F13.automatically-generated-code",{"title":4402,"path":4403,"stem":4404},"Government Regulations","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fgovernment-regulations","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F14.government-regulations",{"title":4406,"path":4407,"stem":4408},"Acknowledgments","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F15.acknowledgments",{"title":4410,"path":4411,"stem":4412,"children":4413},"Rules","\u002Fsei-cert-c-coding-standard\u002Frules","4.sei-cert-c-coding-standard\u002F03.rules\u002F01.index",[4414,4415,4419,4437,4457,4493,4519,4539,4555,4599,4617,4657,4677,4695,4703,4727,4779,4791],{"title":4410,"path":4411,"stem":4412},{"title":4416,"path":4417,"stem":4418},"Application Programming Interfaces (API)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fapplication-programming-interfaces-api","4.sei-cert-c-coding-standard\u002F03.rules\u002F02.application-programming-interfaces-api",{"title":4420,"path":4421,"stem":4422,"children":4423},"Arrays (ARR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F1.index",[4424,4425,4427,4429,4431,4433,4435],{"title":4420,"path":4421,"stem":4422},{"title":687,"path":686,"stem":4426},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F2.arr30-c",{"title":399,"path":398,"stem":4428},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F3.arr32-c",{"title":2754,"path":2753,"stem":4430},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F4.arr36-c",{"title":2234,"path":2233,"stem":4432},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F5.arr37-c",{"title":2244,"path":2243,"stem":4434},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F6.arr38-c",{"title":2254,"path":2253,"stem":4436},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F7.arr39-c",{"title":4438,"path":4439,"stem":4440,"children":4441},"Characters and Strings (STR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F1.index",[4442,4443,4447,4449,4451,4453,4455],{"title":4438,"path":4439,"stem":4440},{"title":4444,"path":4445,"stem":4446},"STR30-C. Do not attempt to modify string literals","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F2.str30-c",{"title":697,"path":696,"stem":4448},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F3.str31-c",{"title":3913,"path":3912,"stem":4450},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F4.str32-c",{"title":4121,"path":4120,"stem":4452},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F5.str34-c",{"title":4131,"path":4130,"stem":4454},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F6.str37-c",{"title":2272,"path":2271,"stem":4456},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F7.str38-c",{"title":4458,"path":4459,"stem":4460,"children":4461},"Concurrency (CON)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F01.index",[4462,4463,4465,4467,4469,4471,4473,4475,4477,4479,4481,4483,4485,4487,4491],{"title":4458,"path":4459,"stem":4460},{"title":305,"path":304,"stem":4464},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F02.con30-c",{"title":1232,"path":1231,"stem":4466},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F03.con31-c",{"title":1180,"path":1179,"stem":4468},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F04.con32-c",{"title":870,"path":869,"stem":4470},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F05.con33-c",{"title":1159,"path":1158,"stem":4472},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F06.con34-c",{"title":1271,"path":1270,"stem":4474},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F07.con35-c",{"title":1128,"path":1127,"stem":4476},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F08.con36-c",{"title":931,"path":930,"stem":4478},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F09.con37-c",{"title":1117,"path":1116,"stem":4480},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F10.con38-c",{"title":1357,"path":1356,"stem":4482},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F11.con39-c",{"title":1300,"path":1299,"stem":4484},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F12.con40-c",{"title":2902,"path":2901,"stem":4486},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F13.con41-c",{"title":4488,"path":4489,"stem":4490},"CON42-C. Don't allow attackers to influence environment variables that control concurrency parameters","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon42-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F14.con42-c",{"title":1190,"path":1189,"stem":4492},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F15.con43-c",{"title":4494,"path":4495,"stem":4496,"children":4497},"Declarations and Initialization (DCL)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F1.index",[4498,4499,4501,4505,4507,4509,4513,4515,4517],{"title":4494,"path":4495,"stem":4496},{"title":3167,"path":3166,"stem":4500},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F2.dcl30-c",{"title":4502,"path":4503,"stem":4504},"DCL31-C. Declare identifiers before using them","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F3.dcl31-c",{"title":2833,"path":2832,"stem":4506},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F4.dcl36-c",{"title":2844,"path":2843,"stem":4508},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F5.dcl37-c",{"title":4510,"path":4511,"stem":4512},"DCL38-C. Use the correct syntax when declaring a flexible array member","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F6.dcl38-c",{"title":4171,"path":4170,"stem":4514},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F7.dcl39-c",{"title":2784,"path":2783,"stem":4516},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F8.dcl40-c",{"title":3327,"path":3326,"stem":4518},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F9.dcl41-c",{"title":4520,"path":4521,"stem":4522,"children":4523},"Environment (ENV)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F1.index",[4524,4525,4527,4531,4533,4535],{"title":4520,"path":4521,"stem":4522},{"title":769,"path":768,"stem":4526},"4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F2.env30-c",{"title":4528,"path":4529,"stem":4530},"ENV31-C. Do not rely on an environment pointer following an operation that may invalidate it","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F3.env31-c",{"title":640,"path":639,"stem":4532},"4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F4.env32-c",{"title":850,"path":849,"stem":4534},"4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F5.env33-c",{"title":4536,"path":4537,"stem":4538},"ENV34-C. Do not store pointers returned by certain functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F6.env34-c",{"title":4540,"path":4541,"stem":4542,"children":4543},"Error Handling (ERR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F1.index",[4544,4545,4547,4551,4553],{"title":4540,"path":4541,"stem":4542},{"title":3129,"path":3128,"stem":4546},"4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F2.err30-c",{"title":4548,"path":4549,"stem":4550},"ERR32-C. Do not rely on indeterminate values of errno","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F3.err32-c",{"title":1996,"path":1995,"stem":4552},"4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F4.err33-c",{"title":102,"path":101,"stem":4554},"4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F5.err34-c",{"title":4556,"path":4557,"stem":4558,"children":4559},"Expressions (EXP)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F01.index",[4560,4561,4563,4567,4569,4571,4573,4575,4577,4581,4585,4587,4589,4591,4593,4595],{"title":4556,"path":4557,"stem":4558},{"title":3253,"path":3252,"stem":4562},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F02.exp30-c",{"title":4564,"path":4565,"stem":4566},"EXP32-C. Do not access a volatile object through a nonvolatile reference","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F03.exp32-c",{"title":2550,"path":2549,"stem":4568},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F04.exp33-c",{"title":2368,"path":2367,"stem":4570},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F05.exp34-c",{"title":1793,"path":1792,"stem":4572},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F06.exp35-c",{"title":1906,"path":1905,"stem":4574},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F07.exp36-c",{"title":2034,"path":2033,"stem":4576},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F08.exp37-c",{"title":4578,"path":4579,"stem":4580},"EXP39-C. Do not access a variable through a pointer of an incompatible type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F09.exp39-c",{"title":4582,"path":4583,"stem":4584},"EXP40-C. Do not modify constant objects","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F10.exp40-c",{"title":799,"path":798,"stem":4586},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F11.exp42-c",{"title":3683,"path":3682,"stem":4588},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F12.exp43-c",{"title":3225,"path":3224,"stem":4590},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F13.exp44-c",{"title":2743,"path":2742,"stem":4592},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F14.exp45-c",{"title":3583,"path":3582,"stem":4594},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F15.exp46-c",{"title":4596,"path":4597,"stem":4598},"EXP47-C. Do not call va_arg with an argument of the incorrect type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp47-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F16.exp47-c",{"title":4600,"path":4601,"stem":4602,"children":4603},"Floating Point (FLP)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F1.index",[4604,4605,4607,4609,4611,4613],{"title":4600,"path":4601,"stem":4602},{"title":2933,"path":2932,"stem":4606},"4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F2.flp30-c",{"title":3723,"path":3722,"stem":4608},"4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F3.flp32-c",{"title":3543,"path":3542,"stem":4610},"4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F4.flp34-c",{"title":3553,"path":3552,"stem":4612},"4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F5.flp36-c",{"title":4614,"path":4615,"stem":4616},"FLP37-C. Do not use object representations to compare floating-point values","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F6.flp37-c",{"title":4618,"path":4619,"stem":4620,"children":4621},"Input Output (FIO)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F01.index",[4622,4623,4625,4629,4631,4635,4639,4641,4643,4647,4649,4651,4653,4655],{"title":4618,"path":4619,"stem":4620},{"title":1500,"path":1499,"stem":4624},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F02.fio30-c",{"title":4626,"path":4627,"stem":4628},"FIO32-C. Do not perform operations on devices that are only appropriate for files","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F03.fio32-c",{"title":1822,"path":1821,"stem":4630},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F04.fio34-c",{"title":4632,"path":4633,"stem":4634},"FIO37-C. Do not assume that fgets() or fgetws() returns a nonempty string when successful","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F05.fio37-c",{"title":4636,"path":4637,"stem":4638},"FIO38-C. Do not copy a FILE object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F06.fio38-c",{"title":1556,"path":1555,"stem":4640},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F07.fio39-c",{"title":2560,"path":2559,"stem":4642},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F08.fio40-c",{"title":4644,"path":4645,"stem":4646},"FIO41-C. Do not call getc(), putc(), getwc(), or putwc() with a stream argument that has side effects","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F09.fio41-c",{"title":295,"path":294,"stem":4648},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F10.fio42-c",{"title":92,"path":91,"stem":4650},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F11.fio44-c",{"title":1576,"path":1575,"stem":4652},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F12.fio45-c",{"title":1666,"path":1665,"stem":4654},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F13.fio46-c",{"title":1510,"path":1509,"stem":4656},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F14.fio47-c",{"title":4658,"path":4659,"stem":4660,"children":4661},"Integers (INT)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F1.index",[4662,4663,4665,4667,4669,4671,4673,4675],{"title":4658,"path":4659,"stem":4660},{"title":332,"path":331,"stem":4664},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F2.int30-c",{"title":534,"path":533,"stem":4666},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F3.int31-c",{"title":342,"path":341,"stem":4668},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F4.int32-c",{"title":1734,"path":1733,"stem":4670},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F5.int33-c",{"title":1713,"path":1712,"stem":4672},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F6.int34-c",{"title":1723,"path":1722,"stem":4674},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F7.int35-c",{"title":1874,"path":1873,"stem":4676},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F8.int36-c",{"title":4678,"path":4679,"stem":4680,"children":4681},"Memory Management (MEM)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F1.index",[4682,4683,4685,4687,4689,4691,4693],{"title":4678,"path":4679,"stem":4680},{"title":602,"path":601,"stem":4684},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F2.mem30-c",{"title":285,"path":284,"stem":4686},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F3.mem31-c",{"title":2773,"path":2772,"stem":4688},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F4.mem33-c",{"title":571,"path":570,"stem":4690},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F5.mem34-c",{"title":352,"path":351,"stem":4692},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F6.mem35-c",{"title":891,"path":890,"stem":4694},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F7.mem36-c",{"title":4696,"path":4697,"stem":4698,"children":4699},"Microsoft Windows (WIN)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmicrosoft-windows-win","4.sei-cert-c-coding-standard\u002F03.rules\u002F14.microsoft-windows-win\u002F1.index",[4700,4701],{"title":4696,"path":4697,"stem":4698},{"title":581,"path":580,"stem":4702},"4.sei-cert-c-coding-standard\u002F03.rules\u002F14.microsoft-windows-win\u002F2.win30-c",{"title":4704,"path":4705,"stem":4706,"children":4707},"Miscellaneous (MSC)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F1.index",[4708,4709,4711,4713,4715,4717,4719,4721,4725],{"title":4704,"path":4705,"stem":4706},{"title":880,"path":879,"stem":4710},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F2.msc30-c",{"title":1453,"path":1452,"stem":4712},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F3.msc32-c",{"title":1002,"path":1001,"stem":4714},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F4.msc33-c",{"title":2964,"path":2963,"stem":4716},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F5.msc37-c",{"title":1067,"path":1066,"stem":4718},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F6.msc38-c",{"title":1077,"path":1076,"stem":4720},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F7.msc39-c",{"title":4722,"path":4723,"stem":4724},"MSC40-C. Do not violate constraints","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F8.msc40-c",{"title":1389,"path":1388,"stem":4726},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F9.msc41-c",{"title":4728,"path":4729,"stem":4730,"children":4731},"POSIX (POS)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F01.index",[4732,4733,4735,4737,4741,4745,4749,4751,4755,4757,4761,4763,4765,4769,4771,4773,4777],{"title":4728,"path":4729,"stem":4730},{"title":2290,"path":2289,"stem":4734},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F02.pos30-c",{"title":112,"path":111,"stem":4736},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F03.pos34-c",{"title":4738,"path":4739,"stem":4740},"POS35-C. Avoid race conditions while checking for the existence of a symbolic link","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F04.pos35-c",{"title":4742,"path":4743,"stem":4744},"POS36-C. Observe correct revocation order while relinquishing privileges","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F05.pos36-c",{"title":4746,"path":4747,"stem":4748},"POS37-C. Ensure that privilege relinquishment is successful","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F06.pos37-c",{"title":758,"path":757,"stem":4750},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F07.pos38-c",{"title":4752,"path":4753,"stem":4754},"POS39-C. Use the correct byte ordering when transferring data between systems","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F08.pos39-c",{"title":1139,"path":1138,"stem":4756},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F09.pos44-c",{"title":4758,"path":4759,"stem":4760},"POS47-C. Do not use threads that can be canceled asynchronously","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos47-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F10.pos47-c",{"title":1221,"path":1220,"stem":4762},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F11.pos48-c",{"title":1200,"path":1199,"stem":4764},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F12.pos49-c",{"title":4766,"path":4767,"stem":4768},"POS50-C. Declare objects shared between POSIX threads with appropriate storage durations","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos50-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F13.pos50-c",{"title":1281,"path":1280,"stem":4770},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F14.pos51-c",{"title":1327,"path":1326,"stem":4772},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F15.pos52-c",{"title":4774,"path":4775,"stem":4776},"POS53-C. Do not use more than one mutex for concurrent waiting operations on a condition variable","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos53-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F16.pos53-c",{"title":2006,"path":2005,"stem":4778},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F17.pos54-c",{"title":4780,"path":4781,"stem":4782,"children":4783},"Preprocessor (PRE)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F1.index",[4784,4785,4787,4789],{"title":4780,"path":4781,"stem":4782},{"title":2662,"path":2661,"stem":4786},"4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F2.pre30-c",{"title":2571,"path":2570,"stem":4788},"4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F3.pre31-c",{"title":2612,"path":2611,"stem":4790},"4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F4.pre32-c",{"title":4792,"path":4793,"stem":4794,"children":4795},"Signals (SIG)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F1.index",[4796,4797,4799,4801,4803],{"title":4792,"path":4793,"stem":4794},{"title":911,"path":910,"stem":4798},"4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F2.sig30-c",{"title":1170,"path":1169,"stem":4800},"4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F3.sig31-c",{"title":921,"path":920,"stem":4802},"4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F4.sig34-c",{"title":3156,"path":3155,"stem":4804},"4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F5.sig35-c",{"title":4806,"path":4807,"stem":4808,"children":4809},"Back Matter","\u002Fsei-cert-c-coding-standard\u002Fback-matter","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F1.index",[4810,4811,4815,4819,4823,4827,5032,5089],{"title":4806,"path":4807,"stem":4808},{"title":4812,"path":4813,"stem":4814},"AA. Bibliography","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F2.aa-bibliography",{"title":4816,"path":4817,"stem":4818},"BB. Definitions","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F3.bb-definitions",{"title":4820,"path":4821,"stem":4822},"CC. Undefined Behavior","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fcc-undefined-behavior","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F4.cc-undefined-behavior",{"title":4824,"path":4825,"stem":4826},"DD. Unspecified Behavior","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fdd-unspecified-behavior","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F5.dd-unspecified-behavior",{"title":4828,"path":4829,"stem":4830,"children":4831},"EE. Analyzers","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F01.index",[4832,4833,4837,4841,4845,4849,4853,4857,4861,4865,4869,4873,4874,4875,4876,4880,4884,4888,4892,4896,4900,4904,4908,4912,4916,4920,4924,4928,4932,4936,4940,4944,4948,4952,4956,4960,4964,4968,4972,4976,4980,4984,4988,4992,4996,5000,5004,5008,5012,5016,5020,5024,5028],{"title":4828,"path":4829,"stem":4830},{"title":4834,"path":4835,"stem":4836},"Astrée","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fastree","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F02.astree",{"title":4838,"path":4839,"stem":4840},"Astrée_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fastree_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F03.astree_v",{"title":4842,"path":4843,"stem":4844},"Axivion Bauhaus Suite","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Faxivion-bauhaus-suite","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F04.axivion-bauhaus-suite",{"title":4846,"path":4847,"stem":4848},"Axivion Bauhaus Suite_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Faxivion-bauhaus-suite_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F05.axivion-bauhaus-suite_v",{"title":4850,"path":4851,"stem":4852},"Clang","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F06.clang",{"title":4854,"path":4855,"stem":4856},"Clang_38_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang_38_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F07.clang_38_v",{"title":4858,"path":4859,"stem":4860},"Clang_39_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang_39_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F08.clang_39_v",{"title":4862,"path":4863,"stem":4864},"Clang_40_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang_40_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F09.clang_40_v",{"title":4866,"path":4867,"stem":4868},"Clang_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F10.clang_v",{"title":4870,"path":4871,"stem":4872},"Codee","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodee","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F11.codee",{"title":4323,"path":4324,"stem":4325},{"title":30,"path":4317,"stem":4319},{"title":4327,"path":4328,"stem":4329},{"title":4877,"path":4878,"stem":4879},"Coverity","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcoverity","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F15.coverity",{"title":4881,"path":4882,"stem":4883},"Coverity_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcoverity_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F16.coverity_v",{"title":4885,"path":4886,"stem":4887},"Cppcheck","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F17.cppcheck",{"title":4889,"path":4890,"stem":4891},"Cppcheck Premium","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck-premium","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F18.cppcheck-premium",{"title":4893,"path":4894,"stem":4895},"Cppcheck Premium_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck-premium_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F19.cppcheck-premium_v",{"title":4897,"path":4898,"stem":4899},"Cppcheck_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F20.cppcheck_v",{"title":4901,"path":4902,"stem":4903},"ECLAIR","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Feclair","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F21.eclair",{"title":4905,"path":4906,"stem":4907},"ECLAIR_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Feclair_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F22.eclair_v",{"title":4909,"path":4910,"stem":4911},"EDG","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fedg","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F23.edg",{"title":4913,"path":4914,"stem":4915},"EDG_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fedg_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F24.edg_v",{"title":4917,"path":4918,"stem":4919},"GCC","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fgcc","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F25.gcc",{"title":4921,"path":4922,"stem":4923},"GCC_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fgcc_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F26.gcc_v",{"title":4925,"path":4926,"stem":4927},"Helix QAC","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fhelix-qac","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F27.helix-qac",{"title":4929,"path":4930,"stem":4931},"Helix QAC_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fhelix-qac_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F28.helix-qac_v",{"title":4933,"path":4934,"stem":4935},"Klocwork","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fklocwork","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F29.klocwork",{"title":4937,"path":4938,"stem":4939},"Klocwork_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fklocwork_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F30.klocwork_v",{"title":4941,"path":4942,"stem":4943},"LDRA","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fldra","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F31.ldra",{"title":4945,"path":4946,"stem":4947},"LDRA_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fldra_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F32.ldra_v",{"title":4949,"path":4950,"stem":4951},"Parasoft","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fparasoft","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F33.parasoft",{"title":4953,"path":4954,"stem":4955},"Parasoft_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fparasoft_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F34.parasoft_v",{"title":4957,"path":4958,"stem":4959},"PC-lint Plus","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpc-lint-plus","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F35.pc-lint-plus",{"title":4961,"path":4962,"stem":4963},"PC-lint Plus_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpc-lint-plus_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F36.pc-lint-plus_v",{"title":4965,"path":4966,"stem":4967},"Polyspace Bug Finder","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpolyspace-bug-finder","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F37.polyspace-bug-finder",{"title":4969,"path":4970,"stem":4971},"Polyspace Bug Finder_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpolyspace-bug-finder_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F38.polyspace-bug-finder_v",{"title":4973,"path":4974,"stem":4975},"PVS-Studio","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpvs-studio","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F39.pvs-studio",{"title":4977,"path":4978,"stem":4979},"PVS-Studio_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpvs-studio_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F40.pvs-studio_v",{"title":4981,"path":4982,"stem":4983},"Rose","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frose","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F41.rose",{"title":4985,"path":4986,"stem":4987},"Rose_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frose_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F42.rose_v",{"title":4989,"path":4990,"stem":4991},"Rosecheckers Code","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frosecheckers-code","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F43.rosecheckers-code",{"title":4993,"path":4994,"stem":4995},"RuleChecker","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frulechecker","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F44.rulechecker",{"title":4997,"path":4998,"stem":4999},"RuleChecker_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frulechecker_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F45.rulechecker_v",{"title":5001,"path":5002,"stem":5003},"Security Reviewer - Static Reviewer","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F46.security-reviewer-static-reviewer",{"title":5005,"path":5006,"stem":5007},"Security Reviewer - Static Reviewer_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F47.security-reviewer-static-reviewer_v",{"title":5009,"path":5010,"stem":5011},"SonarQube C\u002FC++ Plugin","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsonarqube-ccpp-plugin","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F48.sonarqube-ccpp-plugin",{"title":5013,"path":5014,"stem":5015},"SonarQube C\u002FC++ Plugin_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsonarqube-ccpp-plugin_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F49.sonarqube-ccpp-plugin_v",{"title":5017,"path":5018,"stem":5019},"Splint","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsplint","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F50.splint",{"title":5021,"path":5022,"stem":5023},"Splint_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsplint_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F51.splint_v",{"title":5025,"path":5026,"stem":5027},"TrustInSoft Analyzer","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Ftrustinsoft-analyzer","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F52.trustinsoft-analyzer",{"title":5029,"path":5030,"stem":5031},"TrustInSoft Analyzer_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Ftrustinsoft-analyzer_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F53.trustinsoft-analyzer_v",{"title":5033,"path":5034,"stem":5035,"children":5036},"FF. Related Guidelines","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F01.index",[5037,5038,5042,5046,5050,5054,5058,5062,5066,5070,5073,5077,5081,5085],{"title":5033,"path":5034,"stem":5035},{"title":5039,"path":5040,"stem":5041},"2003","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F02.2003","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F02.2003",{"title":5043,"path":5044,"stem":5045},"2006","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F03.2006","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F03.2006",{"title":5047,"path":5048,"stem":5049},"2007","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F04.2007","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F04.2007",{"title":5051,"path":5052,"stem":5053},"2008","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F05.2008","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F05.2008",{"title":5055,"path":5056,"stem":5057},"2010","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F06.2010","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F06.2010",{"title":5059,"path":5060,"stem":5061},"2011","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F07.2011","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F07.2011",{"title":5063,"path":5064,"stem":5065},"2012","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F08.2012","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F08.2012",{"title":5067,"path":5068,"stem":5069},"2013","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F09.2013","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F09.2013",{"title":5067,"path":5071,"stem":5072},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F10.2013","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F10.2013",{"title":5074,"path":5075,"stem":5076},"MITRE CWE","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002Fmitre-cwe","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F11.mitre-cwe",{"title":5078,"path":5079,"stem":5080},"MITRE CWE 2.11","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002Fmitre-cwe-211","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F12.mitre-cwe-211",{"title":5082,"path":5083,"stem":5084},"MITRE CWE 3.1","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002Fmitre-cwe-31","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F13.mitre-cwe-31",{"title":5086,"path":5087,"stem":5088},"MITRE CWE 3.11","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002Fmitre-cwe-311","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F14.mitre-cwe-311",{"title":5090,"path":5091,"stem":5092},"GG. Risk Assessments","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fgg-risk-assessments","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F8.gg-risk-assessments",{"title":5094,"path":5095,"stem":5096,"children":5097},"Admin","\u002Fsei-cert-c-coding-standard\u002Fadmin","4.sei-cert-c-coding-standard\u002F05.admin\u002F1.index",[5098,5099,5103],{"title":5094,"path":5095,"stem":5096},{"title":5100,"path":5101,"stem":5102},"TODO List","\u002Fsei-cert-c-coding-standard\u002Fadmin\u002Ftodo-list","4.sei-cert-c-coding-standard\u002F05.admin\u002F2.todo-list",{"title":5104,"path":5105,"stem":5106},"Undefined and implementation-defined behaviors not deemed ruleworthy","\u002Fsei-cert-c-coding-standard\u002Fadmin\u002Fundefined-and-implementation-defined-behaviors-not-deemed-ruleworthy","4.sei-cert-c-coding-standard\u002F05.admin\u002F3.undefined-and-implementation-defined-behaviors-not-deemed-ruleworthy",{"title":5108,"path":5109,"stem":5110},"Coding Style Guidelines","\u002Fsei-cert-c-coding-standard\u002Fcoding-style-guidelines","4.sei-cert-c-coding-standard\u002F05.coding-style-guidelines",{"title":5112,"path":5113,"stem":5114},"Errata for SEI CERT C Coding Standard (2016 Edition)","\u002Fsei-cert-c-coding-standard\u002Ferrata-for-sei-cert-c-coding-standard-2016-edition","4.sei-cert-c-coding-standard\u002F06.errata-for-sei-cert-c-coding-standard-2016-edition",{"title":5116,"path":5117,"stem":5118},"Wiki Contents","\u002Fsei-cert-c-coding-standard\u002Fwiki-contents","4.sei-cert-c-coding-standard\u002F06.wiki-contents",{"title":5120,"path":5121,"stem":5122,"children":5123},"Recommendations","\u002Fsei-cert-c-coding-standard\u002Frecommendations","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F01.index",[5124,5125,5160,5173,5206,5239,5304,5319,5352,5407,5438,5507,5554,5589,5608,5672,5691,5740],{"title":5120,"path":5121,"stem":5122},{"title":4416,"path":5126,"stem":5127,"children":5128},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F01.index",[5129,5130,5132,5136,5138,5142,5146,5150,5152,5156],{"title":4416,"path":5126,"stem":5127},{"title":3405,"path":3404,"stem":5131},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F02.api00-c",{"title":5133,"path":5134,"stem":5135},"API01-C. Avoid laying out strings in memory directly before sensitive data","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F03.api01-c",{"title":707,"path":706,"stem":5137},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F04.api02-c",{"title":5139,"path":5140,"stem":5141},"API03-C. Create consistent interfaces and capabilities across related functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F05.api03-c",{"title":5143,"path":5144,"stem":5145},"API04-C. Provide a consistent and usable error-checking mechanism","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F06.api04-c",{"title":5147,"path":5148,"stem":5149},"API05-C. Use conformant array parameters","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F07.api05-c",{"title":591,"path":590,"stem":5151},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F08.api07-c",{"title":5153,"path":5154,"stem":5155},"API09-C. Compatible values should have the same type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F09.api09-c",{"title":5157,"path":5158,"stem":5159},"API10-C. APIs should have security options enabled by default","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F10.api10-c",{"title":4420,"path":5161,"stem":5162,"children":5163},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F1.index",[5164,5165,5167,5169],{"title":4420,"path":5161,"stem":5162},{"title":1803,"path":1802,"stem":5166},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F2.arr00-c",{"title":3694,"path":3693,"stem":5168},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F3.arr01-c",{"title":5170,"path":5171,"stem":5172},"ARR02-C. Explicitly specify array bounds, even if implicitly defined by an initializer","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F4.arr02-c",{"title":4438,"path":5174,"stem":5175,"children":5176},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F01.index",[5177,5178,5180,5184,5186,5188,5190,5192,5194,5198,5202],{"title":4438,"path":5174,"stem":5175},{"title":4151,"path":4150,"stem":5179},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F02.str00-c",{"title":5181,"path":5182,"stem":5183},"STR01-C. Adopt and implement a consistent plan for managing strings","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F03.str01-c",{"title":1489,"path":1488,"stem":5185},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F04.str02-c",{"title":3902,"path":3901,"stem":5187},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F05.str03-c",{"title":3563,"path":3562,"stem":5189},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F06.str04-c",{"title":3652,"path":3651,"stem":5191},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F07.str05-c",{"title":212,"path":211,"stem":5193},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F08.str06-c",{"title":5195,"path":5196,"stem":5197},"STR09-C. Don't assume numeric values for expressions with type plain character","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F09.str09-c",{"title":5199,"path":5200,"stem":5201},"STR10-C. Do not concatenate different type of string literals","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F10.str10-c",{"title":5203,"path":5204,"stem":5205},"STR11-C. Do not specify the bound of a character array initialized with a string literal","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F11.str11-c",{"title":4458,"path":5207,"stem":5208,"children":5209},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F01.index",[5210,5211,5213,5215,5219,5223,5225,5229,5231,5235],{"title":4458,"path":5207,"stem":5208},{"title":1251,"path":1250,"stem":5212},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F02.con01-c",{"title":3622,"path":3621,"stem":5214},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F03.con02-c",{"title":5216,"path":5217,"stem":5218},"CON03-C. Ensure visibility when accessing shared variables","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F04.con03-c",{"title":5220,"path":5221,"stem":5222},"CON04-C. Join or detach threads even if their exit status is unimportant","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F05.con04-c",{"title":1337,"path":1336,"stem":5224},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F06.con05-c",{"title":5226,"path":5227,"stem":5228},"CON06-C. Ensure that every mutex outlives the data it protects","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F07.con06-c",{"title":1210,"path":1209,"stem":5230},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F08.con07-c",{"title":5232,"path":5233,"stem":5234},"CON08-C. Do not assume that a group of calls to independently atomic methods is atomic","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F09.con08-c",{"title":5236,"path":5237,"stem":5238},"CON09-C. Avoid the ABA problem when using lock-free algorithms","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F10.con09-c",{"title":4494,"path":5240,"stem":5241,"children":5242},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F01.index",[5243,5244,5246,5248,5250,5252,5254,5256,5258,5260,5264,5268,5272,5274,5278,5280,5282,5284,5288,5290,5292,5294,5298,5302],{"title":4494,"path":5240,"stem":5241},{"title":1885,"path":1884,"stem":5245},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F02.dcl00-c",{"title":2153,"path":2152,"stem":5247},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F03.dcl01-c",{"title":2113,"path":2112,"stem":5249},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F04.dcl02-c",{"title":122,"path":121,"stem":5251},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F05.dcl03-c",{"title":2822,"path":2821,"stem":5253},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F06.dcl04-c",{"title":3077,"path":3076,"stem":5255},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F07.dcl05-c",{"title":3360,"path":3359,"stem":5257},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F08.dcl06-c",{"title":2092,"path":2091,"stem":5259},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F09.dcl07-c",{"title":5261,"path":5262,"stem":5263},"DCL08-C. Properly encode relationships in constant definitions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F10.dcl08-c",{"title":5265,"path":5266,"stem":5267},"DCL09-C. Declare functions that return errno with a return type of errno_t","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F11.dcl09-c",{"title":5269,"path":5270,"stem":5271},"DCL10-C. Maintain the contract between the writer and caller of variadic functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F12.dcl10-c",{"title":2883,"path":2882,"stem":5273},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F13.dcl11-c",{"title":5275,"path":5276,"stem":5277},"DCL12-C. Implement abstract data types using opaque types","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F14.dcl12-c",{"title":3521,"path":3520,"stem":5279},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F15.dcl13-c",{"title":3195,"path":3194,"stem":5281},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F16.dcl15-c",{"title":3532,"path":3531,"stem":5283},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F17.dcl16-c",{"title":5285,"path":5286,"stem":5287},"DCL17-C. Beware of miscompiled volatile-qualified variables","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F18.dcl17-c",{"title":3663,"path":3662,"stem":5289},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F19.dcl18-c",{"title":3205,"path":3204,"stem":5291},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F20.dcl19-c",{"title":2102,"path":2101,"stem":5293},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F21.dcl20-c",{"title":5295,"path":5296,"stem":5297},"DCL21-C. Understand the storage of compound literals","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl21-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F22.dcl21-c",{"title":5299,"path":5300,"stem":5301},"DCL22-C. Use volatile for data that cannot be cached","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl22-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F23.dcl22-c",{"title":2124,"path":2123,"stem":5303},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F24.dcl23-c",{"title":4520,"path":5305,"stem":5306,"children":5307},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F1.index",[5308,5309,5311,5315],{"title":4520,"path":5305,"stem":5306},{"title":233,"path":232,"stem":5310},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F2.env01-c",{"title":5312,"path":5313,"stem":5314},"ENV02-C. Beware of multiple environment variables with the same effective name","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env\u002Fenv02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F3.env02-c",{"title":5316,"path":5317,"stem":5318},"ENV03-C. Sanitize the environment when invoking external programs","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env\u002Fenv03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F4.env03-c",{"title":4540,"path":5320,"stem":5321,"children":5322},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F1.index",[5323,5324,5328,5332,5336,5340,5344,5348],{"title":4540,"path":5320,"stem":5321},{"title":5325,"path":5326,"stem":5327},"ERR00-C. Adopt and implement a consistent and comprehensive error-handling policy","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F2.err00-c",{"title":5329,"path":5330,"stem":5331},"ERR01-C. Use ferror() rather than errno to check for FILE stream errors","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F3.err01-c",{"title":5333,"path":5334,"stem":5335},"ERR02-C. Avoid in-band error indicators","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F4.err02-c",{"title":5337,"path":5338,"stem":5339},"ERR04-C. Choose an appropriate termination strategy","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F5.err04-c",{"title":5341,"path":5342,"stem":5343},"ERR05-C. Application-independent code should provide error detection without dictating error handling","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F6.err05-c",{"title":5345,"path":5346,"stem":5347},"ERR06-C. Understand the termination behavior of assert() and abort()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F7.err06-c",{"title":5349,"path":5350,"stem":5351},"ERR07-C. Prefer functions that support error checking over equivalent functions that don't","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F8.err07-c",{"title":4556,"path":5353,"stem":5354,"children":5355},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F01.index",[5356,5357,5359,5363,5367,5369,5373,5375,5379,5381,5385,5387,5391,5393,5395,5399,5403],{"title":4556,"path":5353,"stem":5354},{"title":2984,"path":2983,"stem":5358},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F02.exp00-c",{"title":5360,"path":5361,"stem":5362},"EXP02-C. Be aware of the short-circuit behavior of the logical AND and OR operators","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F03.exp02-c",{"title":5364,"path":5365,"stem":5366},"EXP03-C. Do not assume the size of a structure is the sum of the sizes of its members","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F04.exp03-c",{"title":1895,"path":1894,"stem":5368},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F05.exp05-c",{"title":5370,"path":5371,"stem":5372},"EXP07-C. Do not diminish the benefits of constants by assuming their values in expressions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F06.exp07-c",{"title":2308,"path":2307,"stem":5374},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F07.exp08-c",{"title":5376,"path":5377,"stem":5378},"EXP09-C. Use sizeof to determine the size of a type or variable","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F08.exp09-c",{"title":3290,"path":3289,"stem":5380},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F09.exp10-c",{"title":5382,"path":5383,"stem":5384},"EXP11-C. Do not make assumptions regarding the layout of structures with bit-fields","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F10.exp11-c",{"title":2072,"path":2071,"stem":5386},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F11.exp12-c",{"title":5388,"path":5389,"stem":5390},"EXP13-C. Treat relational and equality operators as if they were nonassociative","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F12.exp13-c",{"title":1952,"path":1951,"stem":5392},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F13.exp14-c",{"title":2864,"path":2863,"stem":5394},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F14.exp15-c",{"title":5396,"path":5397,"stem":5398},"EXP16-C. Do not compare function pointers to constant values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp16-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F15.exp16-c",{"title":5400,"path":5401,"stem":5402},"EXP19-C. Use braces for the body of an if, for, or while statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F16.exp19-c",{"title":5404,"path":5405,"stem":5406},"EXP20-C. Perform explicit tests to determine success, true and false, and equality","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp20-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F17.exp20-c",{"title":4600,"path":5408,"stem":5409,"children":5410},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F1.index",[5411,5412,5414,5418,5420,5424,5428,5432,5434],{"title":4600,"path":5408,"stem":5409},{"title":1754,"path":1753,"stem":5413},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F2.flp00-c",{"title":5415,"path":5416,"stem":5417},"FLP01-C. Take care in rearranging floating-point expressions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F3.flp01-c",{"title":1773,"path":1772,"stem":5419},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F4.flp02-c",{"title":5421,"path":5422,"stem":5423},"FLP03-C. Detect and handle floating-point errors","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F5.flp03-c",{"title":5425,"path":5426,"stem":5427},"FLP04-C. Check floating-point inputs for exceptional values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F6.flp04-c",{"title":5429,"path":5430,"stem":5431},"FLP05-C. Do not use denormalized numbers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F7.flp05-c",{"title":3633,"path":3632,"stem":5433},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F8.flp06-c",{"title":5435,"path":5436,"stem":5437},"FLP07-C. Cast the return value of a function that returns a floating-point type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F9.flp07-c",{"title":4618,"path":5439,"stem":5440,"children":5441},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F01.index",[5442,5443,5445,5447,5451,5455,5457,5459,5463,5465,5469,5471,5475,5479,5483,5487,5491,5495,5497,5501,5505],{"title":4618,"path":5439,"stem":5440},{"title":972,"path":971,"stem":5444},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F02.fio01-c",{"title":1620,"path":1619,"stem":5446},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F03.fio02-c",{"title":5448,"path":5449,"stem":5450},"FIO03-C. Do not make assumptions about fopen() and file creation","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F04.fio03-c",{"title":5452,"path":5453,"stem":5454},"FIO05-C. Identify files using multiple file attributes","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F05.fio05-c",{"title":132,"path":131,"stem":5456},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F06.fio06-c",{"title":142,"path":141,"stem":5458},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F07.fio08-c",{"title":5460,"path":5461,"stem":5462},"FIO09-C. Be careful with binary data when transferring data across systems","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F08.fio09-c",{"title":152,"path":151,"stem":5464},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F09.fio10-c",{"title":5466,"path":5467,"stem":5468},"FIO11-C. Take care when specifying the mode parameter of fopen()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F10.fio11-c",{"title":162,"path":161,"stem":5470},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F11.fio13-c",{"title":5472,"path":5473,"stem":5474},"FIO14-C. Understand the difference between text mode and binary mode with file streams","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio14-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F12.fio14-c",{"title":5476,"path":5477,"stem":5478},"FIO15-C. Ensure that file operations are performed in a secure directory","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F13.fio15-c",{"title":5480,"path":5481,"stem":5482},"FIO17-C. Do not rely on an ending null character when using fread()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F14.fio17-c",{"title":5484,"path":5485,"stem":5486},"FIO18-C. Never expect fwrite() to terminate the writing process at a null character","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F15.fio18-c",{"title":5488,"path":5489,"stem":5490},"FIO19-C. Do not use fseek() and ftell() to compute the size of a regular file","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F16.fio19-c",{"title":5492,"path":5493,"stem":5494},"FIO20-C. Avoid unintentional truncation when using fgets() or fgetws()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio20-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F17.fio20-c",{"title":982,"path":981,"stem":5496},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F18.fio21-c",{"title":5498,"path":5499,"stem":5500},"FIO22-C. Close files before spawning processes","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio22-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F19.fio22-c",{"title":5502,"path":5503,"stem":5504},"FIO23-C. Do not exit with unflushed data in stdout or stderr","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio23-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F20.fio23-c",{"title":172,"path":171,"stem":5506},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F21.fio24-c",{"title":4658,"path":5508,"stem":5509,"children":5510},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F01.index",[5511,5512,5516,5518,5520,5522,5524,5526,5528,5532,5534,5536,5540,5544,5548,5552],{"title":4658,"path":5508,"stem":5509},{"title":5513,"path":5514,"stem":5515},"INT00-C. Understand the data model used by your implementation(s)","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F02.int00-c",{"title":3499,"path":3498,"stem":5517},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F03.int01-c",{"title":243,"path":242,"stem":5519},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F05.int04-c",{"title":4141,"path":4140,"stem":5521},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F06.int05-c",{"title":3593,"path":3592,"stem":5523},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F07.int07-c",{"title":362,"path":361,"stem":5525},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F08.int08-c",{"title":2913,"path":2912,"stem":5527},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F09.int09-c",{"title":5529,"path":5530,"stem":5531},"INT10-C. Do not assume a positive remainder when using the % operator","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F10.int10-c",{"title":3510,"path":3509,"stem":5533},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F11.int12-c",{"title":3603,"path":3602,"stem":5535},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F12.int13-c",{"title":5537,"path":5538,"stem":5539},"INT14-C. Avoid performing bitwise and arithmetic operations on the same data","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint14-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F13.int14-c",{"title":5541,"path":5542,"stem":5543},"INT15-C. Use intmax_t or uintmax_t for formatted IO on programmer-defined integer types","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F14.int15-c",{"title":5545,"path":5546,"stem":5547},"INT16-C. Do not make assumptions about representation of signed integers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint16-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F15.int16-c",{"title":5549,"path":5550,"stem":5551},"INT17-C. Define integer constants in an implementation-independent manner","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F16.int17-c",{"title":372,"path":371,"stem":5553},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F17.int18-c",{"title":4678,"path":5555,"stem":5556,"children":5557},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F01.index",[5558,5559,5561,5563,5567,5569,5571,5573,5577,5579,5583,5585],{"title":4678,"path":5555,"stem":5556},{"title":264,"path":263,"stem":5560},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F02.mem00-c",{"title":274,"path":273,"stem":5562},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F03.mem01-c",{"title":5564,"path":5565,"stem":5566},"MEM02-C. Immediately cast the result of a memory allocation function call into a pointer to the allocated type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F04.mem02-c",{"title":182,"path":181,"stem":5568},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F05.mem03-c",{"title":192,"path":191,"stem":5570},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F06.mem04-c",{"title":1647,"path":1646,"stem":5572},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F07.mem05-c",{"title":5574,"path":5575,"stem":5576},"MEM06-C. Ensure that sensitive data is not written out to disk","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F08.mem06-c",{"title":482,"path":481,"stem":5578},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F09.mem07-c",{"title":5580,"path":5581,"stem":5582},"MEM10-C. Define and use a pointer validation function","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F10.mem10-c",{"title":253,"path":252,"stem":5584},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F11.mem11-c",{"title":5586,"path":5587,"stem":5588},"MEM12-C. Consider using a goto chain when leaving a function on error when using and releasing resources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F12.mem12-c",{"title":4696,"path":5590,"stem":5591,"children":5592},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F1.index",[5593,5594,5596,5598,5600,5604],{"title":4696,"path":5590,"stem":5591},{"title":821,"path":820,"stem":5595},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F2.win00-c",{"title":222,"path":221,"stem":5597},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F3.win01-c",{"title":738,"path":737,"stem":5599},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F4.win02-c",{"title":5601,"path":5602,"stem":5603},"WIN03-C. Understand HANDLE inheritance","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F5.win03-c",{"title":5605,"path":5606,"stem":5607},"WIN04-C. Consider encrypting function pointers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F6.win04-c",{"title":4704,"path":5609,"stem":5610,"children":5611},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F01.index",[5612,5613,5615,5619,5623,5627,5629,5631,5635,5637,5639,5641,5645,5649,5651,5653,5657,5659,5661,5663,5665,5667,5669],{"title":4704,"path":5609,"stem":5610},{"title":1097,"path":1096,"stem":5614},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F02.msc00-c",{"title":5616,"path":5617,"stem":5618},"MSC01-C. Strive for logical completeness","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F03.msc01-c",{"title":5620,"path":5621,"stem":5622},"MSC04-C. Use comments consistently and in a readable fashion","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F04.msc04-c",{"title":5624,"path":5625,"stem":5626},"MSC05-C. Do not manipulate time_t typed values directly","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F05.msc05-c",{"title":810,"path":809,"stem":5628},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F06.msc06-c",{"title":1368,"path":1367,"stem":5630},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F07.msc07-c",{"title":5632,"path":5633,"stem":5634},"UTF8-related issues","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Futf8-related-issues","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F08.utf8-related-issues",{"title":2045,"path":2044,"stem":5636},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F09.msc11-c",{"title":1378,"path":1377,"stem":5638},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F10.msc12-c",{"title":3470,"path":3469,"stem":5640},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F11.msc13-c",{"title":5642,"path":5643,"stem":5644},"MSC14-C. Do not introduce unnecessary platform dependencies","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc14-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F12.msc14-c",{"title":5646,"path":5647,"stem":5648},"MSC15-C. Do not depend on undefined behavior","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F13.msc15-c",{"title":3338,"path":3337,"stem":5650},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F14.msc17-c",{"title":1399,"path":1398,"stem":5652},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F15.msc18-c",{"title":5654,"path":5655,"stem":5656},"MSC19-C. For functions that return an array, prefer returning an empty array over a null value","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F16.msc19-c",{"title":3349,"path":3348,"stem":5658},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F17.msc20-c",{"title":2944,"path":2943,"stem":5660},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F18.msc21-c",{"title":788,"path":787,"stem":5662},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F19.msc22-c",{"title":621,"path":620,"stem":5664},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F20.msc23-c",{"title":202,"path":201,"stem":5666},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F21.msc24-c",{"title":1056,"path":1055,"stem":5668},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F22.msc25-c",{"title":5670,"path":4199,"stem":5671},"Use subset of ASCII for safety","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F23.use-subset-of-ascii-for-safety",{"title":4728,"path":5673,"stem":5674,"children":5675},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F1.index",[5676,5677,5681,5685,5689],{"title":4728,"path":5673,"stem":5674},{"title":5678,"path":5679,"stem":5680},"POS01-C. Check for the existence of links when dealing with files","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F2.pos01-c",{"title":5682,"path":5683,"stem":5684},"POS02-C. Follow the principle of least privilege","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F3.pos02-c",{"title":5686,"path":5687,"stem":5688},"POS04-C. Avoid using PTHREAD_MUTEX_NORMAL type mutex locks","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F4.pos04-c",{"title":718,"path":717,"stem":5690},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F5.pos05-c",{"title":4780,"path":5692,"stem":5693,"children":5694},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F01.index",[5695,5696,5698,5702,5704,5708,5710,5714,5718,5722,5726,5730,5732,5736],{"title":4780,"path":5692,"stem":5693},{"title":2581,"path":2580,"stem":5697},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F02.pre00-c",{"title":5699,"path":5700,"stem":5701},"PRE01-C. Use parentheses within macros around parameter names","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F03.pre01-c",{"title":2623,"path":2622,"stem":5703},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F04.pre02-c",{"title":5705,"path":5706,"stem":5707},"PRE04-C. Do not reuse a standard header file name","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F05.pre04-c",{"title":2592,"path":2591,"stem":5709},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F06.pre05-c",{"title":5711,"path":5712,"stem":5713},"PRE06-C. Enclose header files in an include guard","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F07.pre06-c",{"title":5715,"path":5716,"stem":5717},"PRE07-C. Avoid using repeated question marks","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F08.pre07-c",{"title":5719,"path":5720,"stem":5721},"PRE08-C. Guarantee that header file names are unique","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F09.pre08-c",{"title":5723,"path":5724,"stem":5725},"PRE09-C. Do not replace secure functions with deprecated or obsolescent functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F10.pre09-c",{"title":5727,"path":5728,"stem":5729},"PRE10-C. Wrap multistatement macros in a do-while loop","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F11.pre10-c",{"title":2633,"path":2632,"stem":5731},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F12.pre11-c",{"title":5733,"path":5734,"stem":5735},"PRE12-C. Do not define unsafe macros","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F13.pre12-c",{"title":5737,"path":5738,"stem":5739},"PRE13-C. Use the Standard predefined macros to test for versions and features.","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F14.pre13-c",{"title":4792,"path":5741,"stem":5742,"children":5743},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F1.index",[5744,5745,5747,5749],{"title":4792,"path":5741,"stem":5742},{"title":941,"path":940,"stem":5746},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F2.sig00-c",{"title":951,"path":950,"stem":5748},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F3.sig01-c",{"title":961,"path":960,"stem":5750},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F4.sig02-c",{"title":5752,"path":5753,"stem":5754},"CERT manifest files","\u002Fsei-cert-c-coding-standard\u002Fcert-manifest-files","4.sei-cert-c-coding-standard\u002F09.cert-manifest-files",1775657851643]