[{"data":1,"prerenderedAt":3988},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer":28,"surround-\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer":2338,"sidebar-sei-cert-c-coding-standard":2347},[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":2330,"meta":2331,"navigation":7,"path":2334,"seo":2335,"stem":2336,"__hash__":2337},"content\u002F4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F46.security-reviewer-static-reviewer.md","Security Reviewer - Static Reviewer",{"type":32,"value":33,"toc":2326},"minimark",[34,38,42,45,48,55],[35,36,30],"h1",{"id":37},"security-reviewer-static-reviewer",[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:"," 6.02",[56,57,58,69],"table",{},[59,60,61],"thead",{},[62,63,64,67],"tr",{},[65,66],"th",{},[65,68],{},[70,71,72,81,93,104,113,122,131,140,149,158,167,176,185,194,203,211,220,229,240,251,262,271,280,291,302,313,324,335,344,353,362,373,382,393,404,413,422,433,444,453,464,475,485,496,505,514,523,532,541,550,558,569,578,587,598,608,619,628,639,648,657,666,675,684,693,702,711,720,731,740,749,760,769,778,787,798,809,819,830,839,848,857,866,876,887,896,905,913,922,931,940,948,959,970,981,990,1001,1012,1021,1032,1041,1050,1059,1068,1077,1086,1095,1104,1113,1122,1131,1140,1151,1162,1171,1180,1189,1198,1207,1216,1225,1236,1245,1254,1263,1272,1281,1290,1299,1308,1317,1326,1337,1348,1357,1366,1375,1384,1393,1402,1413,1424,1435,1446,1457,1468,1479,1490,1501,1512,1521,1530,1539,1548,1557,1566,1575,1586,1597,1606,1615,1624,1633,1642,1653,1664,1675,1686,1695,1704,1713,1722,1731,1740,1749,1758,1767,1776,1785,1794,1803,1812,1821,1832,1843,1854,1865,1876,1887,1898,1907,1916,1925,1934,1943,1952,1961,1970,1979,1988,1997,2006,2015,2024,2033,2042,2051,2060,2069,2078,2087,2096,2105,2116,2127,2138,2149,2158,2169,2180,2191,2202,2213,2224,2235,2246,2255,2264,2275,2286,2297,2306,2315],"tbody",{},[62,73,74,78],{},[75,76,77],"td",{},"Checker",[75,79,80],{},"Guideline",[62,82,83,86],{},[75,84,85],{},"arithOperationsOnVoidPointer",[75,87,88],{},[89,90,92],"a",{"href":91},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi04-c","API04-C. Provide a consistent and usable error-checking mechanism",[62,94,95,98],{},[75,96,97],{},"arrayIndexOutOfBoundsCond",[75,99,100],{},[89,101,103],{"href":102},"\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,105,106,109],{},[75,107,108],{},"assignmentInAssert",[75,110,111],{},[89,112,103],{"href":102},[62,114,115,118],{},[75,116,117],{},"autoVariables",[75,119,120],{},[89,121,103],{"href":102},[62,123,124,127],{},[75,125,126],{},"autovarInvalidDeallocation",[75,128,129],{},[89,130,103],{"href":102},[62,132,133,136],{},[75,134,135],{},"C01",[75,137,138],{},[89,139,103],{"href":102},[62,141,142,145],{},[75,143,144],{},"C02",[75,146,147],{},[89,148,103],{"href":102},[62,150,151,154],{},[75,152,153],{},"C03",[75,155,156],{},[89,157,103],{"href":102},[62,159,160,163],{},[75,161,162],{},"C04",[75,164,165],{},[89,166,103],{"href":102},[62,168,169,172],{},[75,170,171],{},"C05",[75,173,174],{},[89,175,103],{"href":102},[62,177,178,181],{},[75,179,180],{},"C06",[75,182,183],{},[89,184,103],{"href":102},[62,186,187,190],{},[75,188,189],{},"C07",[75,191,192],{},[89,193,103],{"href":102},[62,195,196,199],{},[75,197,198],{},"C08",[75,200,201],{},[89,202,103],{"href":102},[62,204,205,207],{},[75,206,198],{},[75,208,209],{},[89,210,103],{"href":102},[62,212,213,216],{},[75,214,215],{},"C09",[75,217,218],{},[89,219,103],{"href":102},[62,221,222,225],{},[75,223,224],{},"C10",[75,226,227],{},[89,228,103],{"href":102},[62,230,231,234],{},[75,232,233],{},"C11",[75,235,236],{},[89,237,239],{"href":238},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon02-c","CON02-C. Do not use volatile as a synchronization primitive",[62,241,242,245],{},[75,243,244],{},"C12",[75,246,247],{},[89,248,250],{"href":249},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon05-c","CON05-C. Do not perform operations that can block while holding a lock",[62,252,253,256],{},[75,254,255],{},"C13",[75,257,258],{},[89,259,261],{"href":260},"\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,263,264,267],{},[75,265,266],{},"C14",[75,268,269],{},[89,270,261],{"href":260},[62,272,273,276],{},[75,274,275],{},"C15",[75,277,278],{},[89,279,261],{"href":260},[62,281,282,285],{},[75,283,284],{},"C16",[75,286,287],{},[89,288,290],{"href":289},"\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,292,293,296],{},[75,294,295],{},"C17",[75,297,298],{},[89,299,301],{"href":300},"\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,303,304,307],{},[75,305,306],{},"C18",[75,308,309],{},[89,310,312],{"href":311},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl30-c","DCL30-C. Declare objects with appropriate storage durations",[62,314,315,318],{},[75,316,317],{},"C19",[75,319,320],{},[89,321,323],{"href":322},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl31-c","DCL31-C. Declare identifiers before using them",[62,325,326,329],{},[75,327,328],{},"C20",[75,330,331],{},[89,332,334],{"href":333},"\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,336,337,340],{},[75,338,339],{},"C21",[75,341,342],{},[89,343,334],{"href":333},[62,345,346,349],{},[75,347,348],{},"C22",[75,350,351],{},[89,352,334],{"href":333},[62,354,355,358],{},[75,356,357],{},"C23",[75,359,360],{},[89,361,334],{"href":333},[62,363,364,367],{},[75,365,366],{},"C24",[75,368,369],{},[89,370,372],{"href":371},"\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,374,375,378],{},[75,376,377],{},"C25",[75,379,380],{},[89,381,334],{"href":333},[62,383,384,387],{},[75,385,386],{},"C26",[75,388,389],{},[89,390,392],{"href":391},"\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,394,395,398],{},[75,396,397],{},"C27",[75,399,400],{},[89,401,403],{"href":402},"\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,405,406,409],{},[75,407,408],{},"C28",[75,410,411],{},[89,412,403],{"href":402},[62,414,415,418],{},[75,416,417],{},"C29",[75,419,420],{},[89,421,403],{"href":402},[62,423,424,427],{},[75,425,426],{},"C31",[75,428,429],{},[89,430,432],{"href":431},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr04-c","ERR04-C. Choose an appropriate termination strategy",[62,434,435,438],{},[75,436,437],{},"C32",[75,439,440],{},[89,441,443],{"href":442},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr05-c","ERR05-C. Application-independent code should provide error detection without dictating error handling",[62,445,446,449],{},[75,447,448],{},"C33",[75,450,451],{},[89,452,443],{"href":442},[62,454,455,458],{},[75,456,457],{},"C34",[75,459,460],{},[89,461,463],{"href":462},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr32-c","ERR32-C. Do not rely on indeterminate values of errno",[62,465,466,469],{},[75,467,468],{},"C37",[75,470,471],{},[89,472,474],{"href":473},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp00-c","EXP00-C. Use parentheses for precedence of operation",[62,476,477,479],{},[75,478,468],{},[75,480,481],{},[89,482,484],{"href":483},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp08-c","EXP08-C. Ensure pointer arithmetic is used correctly",[62,486,487,490],{},[75,488,489],{},"C38",[75,491,492],{},[89,493,495],{"href":494},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp09-c","EXP09-C. Use sizeof to determine the size of a type or variable",[62,497,498,501],{},[75,499,500],{},"C39",[75,502,503],{},[89,504,495],{"href":494},[62,506,507,510],{},[75,508,509],{},"C40",[75,511,512],{},[89,513,495],{"href":494},[62,515,516,519],{},[75,517,518],{},"C42",[75,520,521],{},[89,522,495],{"href":494},[62,524,525,528],{},[75,526,527],{},"C44",[75,529,530],{},[89,531,495],{"href":494},[62,533,534,537],{},[75,535,536],{},"C45",[75,538,539],{},[89,540,495],{"href":494},[62,542,543,546],{},[75,544,545],{},"C46",[75,547,548],{},[89,549,495],{"href":494},[62,551,552,554],{},[75,553,545],{},[75,555,556],{},[89,557,495],{"href":494},[62,559,560,563],{},[75,561,562],{},"C47",[75,564,565],{},[89,566,568],{"href":567},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp12-c","EXP12-C. Do not ignore values returned by functions",[62,570,571,574],{},[75,572,573],{},"C48",[75,575,576],{},[89,577,568],{"href":567},[62,579,580,583],{},[75,581,582],{},"C49",[75,584,585],{},[89,586,103],{"href":102},[62,588,589,592],{},[75,590,591],{},"C50",[75,593,594],{},[89,595,597],{"href":596},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp30-c","EXP30-C. Do not depend on the order of evaluation for side effects",[62,599,600,602],{},[75,601,591],{},[75,603,604],{},[89,605,607],{"href":606},"\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,609,610,613],{},[75,611,612],{},"C51",[75,614,615],{},[89,616,618],{"href":617},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp19-c","EXP19-C. Use braces for the body of an if, for, or while statement",[62,620,621,624],{},[75,622,623],{},"C52",[75,625,626],{},[89,627,261],{"href":260},[62,629,630,633],{},[75,631,632],{},"C54",[75,634,635],{},[89,636,638],{"href":637},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp33-c","EXP33-C. Do not read uninitialized memory",[62,640,641,644],{},[75,642,643],{},"C55",[75,645,646],{},[89,647,638],{"href":637},[62,649,650,653],{},[75,651,652],{},"C56",[75,654,655],{},[89,656,638],{"href":637},[62,658,659,662],{},[75,660,661],{},"C57",[75,663,664],{},[89,665,638],{"href":637},[62,667,668,671],{},[75,669,670],{},"C58",[75,672,673],{},[89,674,638],{"href":637},[62,676,677,680],{},[75,678,679],{},"C59",[75,681,682],{},[89,683,638],{"href":637},[62,685,686,689],{},[75,687,688],{},"C60",[75,690,691],{},[89,692,638],{"href":637},[62,694,695,698],{},[75,696,697],{},"C61",[75,699,700],{},[89,701,638],{"href":637},[62,703,704,707],{},[75,705,706],{},"C62",[75,708,709],{},[89,710,638],{"href":637},[62,712,713,716],{},[75,714,715],{},"C63",[75,717,718],{},[89,719,638],{"href":637},[62,721,722,725],{},[75,723,724],{},"C64",[75,726,727],{},[89,728,730],{"href":729},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp34-c","EXP34-C. Do not dereference null pointers",[62,732,733,736],{},[75,734,735],{},"C65",[75,737,738],{},[89,739,730],{"href":729},[62,741,742,745],{},[75,743,744],{},"C66",[75,746,747],{},[89,748,730],{"href":729},[62,750,751,754],{},[75,752,753],{},"C67",[75,755,756],{},[89,757,759],{"href":758},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp36-c","EXP36-C. Do not cast pointers into more strictly aligned pointer types",[62,761,762,765],{},[75,763,764],{},"C68",[75,766,767],{},[89,768,759],{"href":758},[62,770,771,774],{},[75,772,773],{},"C69",[75,775,776],{},[89,777,759],{"href":758},[62,779,780,783],{},[75,781,782],{},"C70",[75,784,785],{},[89,786,759],{"href":758},[62,788,789,792],{},[75,790,791],{},"C71",[75,793,794],{},[89,795,797],{"href":796},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp37-c","EXP37-C. Call functions with the correct number and type of arguments",[62,799,800,803],{},[75,801,802],{},"C73",[75,804,805],{},[89,806,808],{"href":807},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp40-c","EXP40-C. Do not modify constant objects",[62,810,811,813],{},[75,812,802],{},[75,814,815],{},[89,816,818],{"href":817},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp46-c","EXP46-C. Do not use a bitwise operator with a Boolean-like operand",[62,820,821,824],{},[75,822,823],{},"C76",[75,825,826],{},[89,827,829],{"href":828},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio21-c","FIO21-C. Do not create temporary files in shared directories",[62,831,832,835],{},[75,833,834],{},"C77",[75,836,837],{},[89,838,301],{"href":300},[62,840,841,844],{},[75,842,843],{},"C78",[75,845,846],{},[89,847,301],{"href":300},[62,849,850,853],{},[75,851,852],{},"C79",[75,854,855],{},[89,856,301],{"href":300},[62,858,859,862],{},[75,860,861],{},"C80",[75,863,864],{},[89,865,301],{"href":300},[62,867,868,870],{},[75,869,861],{},[75,871,872],{},[89,873,875],{"href":874},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio42-c","FIO42-C. Close files when they are no longer needed",[62,877,878,881],{},[75,879,880],{},"C81",[75,882,883],{},[89,884,886],{"href":885},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio47-c","FIO47-C. Use valid format strings",[62,888,889,892],{},[75,890,891],{},"C82",[75,893,894],{},[89,895,886],{"href":885},[62,897,898,901],{},[75,899,900],{},"C83",[75,902,903],{},[89,904,886],{"href":885},[62,906,907,909],{},[75,908,900],{},[75,910,911],{},[89,912,886],{"href":885},[62,914,915,918],{},[75,916,917],{},"C84",[75,919,920],{},[89,921,886],{"href":885},[62,923,924,927],{},[75,925,926],{},"C85",[75,928,929],{},[89,930,886],{"href":885},[62,932,933,936],{},[75,934,935],{},"C86",[75,937,938],{},[89,939,886],{"href":885},[62,941,942,944],{},[75,943,935],{},[75,945,946],{},[89,947,886],{"href":885},[62,949,950,953],{},[75,951,952],{},"C87",[75,954,955],{},[89,956,958],{"href":957},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp03-c","FLP03-C. Detect and handle floating-point errors",[62,960,961,964],{},[75,962,963],{},"C88",[75,965,966],{},[89,967,969],{"href":968},"\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,971,972,975],{},[75,973,974],{},"C101",[75,976,977],{},[89,978,980],{"href":979},"\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,982,983,986],{},[75,984,985],{},"C107",[75,987,988],{},[89,989,372],{"href":371},[62,991,992,995],{},[75,993,994],{},"C109",[75,996,997],{},[89,998,1000],{"href":999},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr38-c","ARR38-C. Guarantee that library functions do not form invalid pointers",[62,1002,1003,1006],{},[75,1004,1005],{},"C122",[75,1007,1008],{},[89,1009,1011],{"href":1010},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon40-c","CON40-C. Do not refer to an atomic variable twice in an expression",[62,1013,1014,1017],{},[75,1015,1016],{},"C123",[75,1018,1019],{},[89,1020,1011],{"href":1010},[62,1022,1023,1026],{},[75,1024,1025],{},"C126",[75,1027,1028],{},[89,1029,1031],{"href":1030},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl01-c","DCL01-C. Do not reuse variable names in subscopes",[62,1033,1034,1037],{},[75,1035,1036],{},"C127",[75,1038,1039],{},[89,1040,1031],{"href":1030},[62,1042,1043,1046],{},[75,1044,1045],{},"C129",[75,1047,1048],{},[89,1049,261],{"href":260},[62,1051,1052,1055],{},[75,1053,1054],{},"C130",[75,1056,1057],{},[89,1058,261],{"href":260},[62,1060,1061,1064],{},[75,1062,1063],{},"C132",[75,1065,1066],{},[89,1067,261],{"href":260},[62,1069,1070,1073],{},[75,1071,1072],{},"C133",[75,1074,1075],{},[89,1076,261],{"href":260},[62,1078,1079,1082],{},[75,1080,1081],{},"C135",[75,1083,1084],{},[89,1085,261],{"href":260},[62,1087,1088,1091],{},[75,1089,1090],{},"C154",[75,1092,1093],{},[89,1094,261],{"href":260},[62,1096,1097,1100],{},[75,1098,1099],{},"C155",[75,1101,1102],{},[89,1103,261],{"href":260},[62,1105,1106,1109],{},[75,1107,1108],{},"C176",[75,1110,1111],{},[89,1112,312],{"href":311},[62,1114,1115,1118],{},[75,1116,1117],{},"C177",[75,1119,1120],{},[89,1121,312],{"href":311},[62,1123,1124,1127],{},[75,1125,1126],{},"C178",[75,1128,1129],{},[89,1130,312],{"href":311},[62,1132,1133,1136],{},[75,1134,1135],{},"C179",[75,1137,1138],{},[89,1139,312],{"href":311},[62,1141,1142,1145],{},[75,1143,1144],{},"C999",[75,1146,1147],{},[89,1148,1150],{"href":1149},"\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,1152,1153,1156],{},[75,1154,1155],{},"CbOB",[75,1157,1158],{},[89,1159,1161],{"href":1160},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint02-c","INT02-C. Understand integer conversion rules",[62,1163,1164,1167],{},[75,1165,1166],{},"CconstVariable",[75,1168,1169],{},[89,1170,1161],{"href":1160},[62,1172,1173,1176],{},[75,1174,1175],{},"CdLT",[75,1177,1178],{},[89,1179,1161],{"href":1160},[62,1181,1182,1185],{},[75,1183,1184],{},"CdoubleFree",[75,1186,1187],{},[89,1188,1161],{"href":1160},[62,1190,1191,1194],{},[75,1192,1193],{},"CduplicateCondition",[75,1195,1196],{},[89,1197,1161],{"href":1160},[62,1199,1200,1203],{},[75,1201,1202],{},"CE6",[75,1204,1205],{},[89,1206,1161],{"href":1160},[62,1208,1209,1212],{},[75,1210,1211],{},"CE6_S",[75,1213,1214],{},[89,1215,1161],{"href":1160},[62,1217,1218,1221],{},[75,1219,1220],{},"CE7",[75,1222,1223],{},[89,1224,1161],{"href":1160},[62,1226,1227,1230],{},[75,1228,1229],{},"CE8",[75,1231,1232],{},[89,1233,1235],{"href":1234},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc25-c","MSC25-C. Do not use insecure or weak cryptographic algorithms",[62,1237,1238,1241],{},[75,1239,1240],{},"CE11",[75,1242,1243],{},[89,1244,1161],{"href":1160},[62,1246,1247,1250],{},[75,1248,1249],{},"CE12",[75,1251,1252],{},[89,1253,1161],{"href":1160},[62,1255,1256,1259],{},[75,1257,1258],{},"CE13",[75,1260,1261],{},[89,1262,1161],{"href":1160},[62,1264,1265,1268],{},[75,1266,1267],{},"CE256",[75,1269,1270],{},[89,1271,1161],{"href":1160},[62,1273,1274,1277],{},[75,1275,1276],{},"CfCO",[75,1278,1279],{},[89,1280,1161],{"href":1160},[62,1282,1283,1286],{},[75,1284,1285],{},"CinvalidLifetime",[75,1287,1288],{},[89,1289,1161],{"href":1160},[62,1291,1292,1295],{},[75,1293,1294],{},"CinvalidScanfArgType_int",[75,1296,1297],{},[89,1298,1161],{"href":1160},[62,1300,1301,1304],{},[75,1302,1303],{},"CiRV",[75,1305,1306],{},[89,1307,1161],{"href":1160},[62,1309,1310,1313],{},[75,1311,1312],{},"CiSFW",[75,1314,1315],{},[89,1316,1161],{"href":1160},[62,1318,1319,1322],{},[75,1320,1321],{},"CknownConditionTrueFalse",[75,1323,1324],{},[89,1325,1161],{"href":1160},[62,1327,1328,1331],{},[75,1329,1330],{},"clarifyCalculation",[75,1332,1333],{},[89,1334,1336],{"href":1335},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint08-c","INT08-C. Verify that all integer values are in range",[62,1338,1339,1342],{},[75,1340,1341],{},"ClRVNU",[75,1343,1344],{},[89,1345,1347],{"href":1346},"\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,1349,1350,1353],{},[75,1351,1352],{},"CmAD",[75,1354,1355],{},[89,1356,1347],{"href":1346},[62,1358,1359,1362],{},[75,1360,1361],{},"CmemleakOnRealloc",[75,1363,1364],{},[89,1365,1347],{"href":1346},[62,1367,1368,1371],{},[75,1369,1370],{},"CmissingReturn",[75,1372,1373],{},[89,1374,1347],{"href":1346},[62,1376,1377,1380],{},[75,1378,1379],{},"CMR",[75,1381,1382],{},[89,1383,1347],{"href":1346},[62,1385,1386,1389],{},[75,1387,1388],{},"CmVOOR",[75,1390,1391],{},[89,1392,1347],{"href":1346},[62,1394,1395,1398],{},[75,1396,1397],{},"CnAS",[75,1399,1400],{},[89,1401,1347],{"href":1346},[62,1403,1404,1407],{},[75,1405,1406],{},"CNI",[75,1408,1409],{},[89,1410,1412],{"href":1411},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint32-c","INT32-C. Ensure that operations on signed integers do not result in overflow",[62,1414,1415,1418],{},[75,1416,1417],{},"CPP_02",[75,1419,1420],{},[89,1421,1423],{"href":1422},"\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,1425,1426,1429],{},[75,1427,1428],{},"CPP_03",[75,1430,1431],{},[89,1432,1434],{"href":1433},"\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,1436,1437,1440],{},[75,1438,1439],{},"CPP_05",[75,1441,1442],{},[89,1443,1445],{"href":1444},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint36-c","INT36-C. Converting a pointer to integer or integer to pointer",[62,1447,1448,1451],{},[75,1449,1450],{},"CPP_07",[75,1452,1453],{},[89,1454,1456],{"href":1455},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem03-c","MEM03-C. Clear sensitive information stored in reusable resources",[62,1458,1459,1462],{},[75,1460,1461],{},"CPP_08",[75,1463,1464],{},[89,1465,1467],{"href":1466},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem04-c","MEM04-C. Beware of zero-length allocations",[62,1469,1470,1473],{},[75,1471,1472],{},"CPP_010",[75,1474,1475],{},[89,1476,1478],{"href":1477},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem05-c","MEM05-C. Avoid large stack allocations",[62,1480,1481,1484],{},[75,1482,1483],{},"CPP_11",[75,1485,1486],{},[89,1487,1489],{"href":1488},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem10-c","MEM10-C. Define and use a pointer validation function",[62,1491,1492,1495],{},[75,1493,1494],{},"CPP_12",[75,1496,1497],{},[89,1498,1500],{"href":1499},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem30-c","MEM30-C. Do not access freed memory",[62,1502,1503,1506],{},[75,1504,1505],{},"CPP_17",[75,1507,1508],{},[89,1509,1511],{"href":1510},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem31-c","MEM31-C. Free dynamically allocated memory when no longer needed",[62,1513,1514,1517],{},[75,1515,1516],{},"CPP_18",[75,1518,1519],{},[89,1520,1511],{"href":1510},[62,1522,1523,1526],{},[75,1524,1525],{},"CPP_22",[75,1527,1528],{},[89,1529,1511],{"href":1510},[62,1531,1532,1535],{},[75,1533,1534],{},"CPP_23",[75,1536,1537],{},[89,1538,1511],{"href":1510},[62,1540,1541,1544],{},[75,1542,1543],{},"CPP_24",[75,1545,1546],{},[89,1547,1511],{"href":1510},[62,1549,1550,1553],{},[75,1551,1552],{},"CPP_25",[75,1554,1555],{},[89,1556,1511],{"href":1510},[62,1558,1559,1562],{},[75,1560,1561],{},"CPP_26",[75,1563,1564],{},[89,1565,1511],{"href":1510},[62,1567,1568,1571],{},[75,1569,1570],{},"CPP_27",[75,1572,1573],{},[89,1574,1511],{"href":1510},[62,1576,1577,1580],{},[75,1578,1579],{},"CPP_028",[75,1581,1582],{},[89,1583,1585],{"href":1584},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem33-c","MEM33-C. Allocate and copy structures containing a flexible array member dynamically",[62,1587,1588,1591],{},[75,1589,1590],{},"CPP_31",[75,1592,1593],{},[89,1594,1596],{"href":1595},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem34-c","MEM34-C. Only free memory allocated dynamically",[62,1598,1599,1602],{},[75,1600,1601],{},"CPP_32",[75,1603,1604],{},[89,1605,1596],{"href":1595},[62,1607,1608,1611],{},[75,1609,1610],{},"CPP_33",[75,1612,1613],{},[89,1614,1596],{"href":1595},[62,1616,1617,1620],{},[75,1618,1619],{},"CPP_34",[75,1621,1622],{},[89,1623,1596],{"href":1595},[62,1625,1626,1629],{},[75,1627,1628],{},"CPP_35",[75,1630,1631],{},[89,1632,1596],{"href":1595},[62,1634,1635,1638],{},[75,1636,1637],{},"CPP_36",[75,1639,1640],{},[89,1641,1596],{"href":1595},[62,1643,1644,1647],{},[75,1645,1646],{},"CPP_039",[75,1648,1649],{},[89,1650,1652],{"href":1651},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem35-c","MEM35-C. Allocate sufficient memory for an object",[62,1654,1655,1658],{},[75,1656,1657],{},"CPP_44",[75,1659,1660],{},[89,1661,1663],{"href":1662},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc01-c","MSC01-C. Strive for logical completeness",[62,1665,1666,1669],{},[75,1667,1668],{},"CPP_48",[75,1670,1671],{},[89,1672,1674],{"href":1673},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem12-c","MEM12-C. Consider using a goto chain when leaving a function on error when using and releasing resources",[62,1676,1677,1680],{},[75,1678,1679],{},"CPP_57",[75,1681,1682],{},[89,1683,1685],{"href":1684},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc07-c","MSC07-C. Detect and remove dead code",[62,1687,1688,1691],{},[75,1689,1690],{},"CPP_58",[75,1692,1693],{},[89,1694,1685],{"href":1684},[62,1696,1697,1700],{},[75,1698,1699],{},"CPP_59",[75,1701,1702],{},[89,1703,1685],{"href":1684},[62,1705,1706,1709],{},[75,1707,1708],{},"CPP_60",[75,1710,1711],{},[89,1712,1685],{"href":1684},[62,1714,1715,1718],{},[75,1716,1717],{},"CPP_61",[75,1719,1720],{},[89,1721,1685],{"href":1684},[62,1723,1724,1727],{},[75,1725,1726],{},"CPP_62",[75,1728,1729],{},[89,1730,1685],{"href":1684},[62,1732,1733,1736],{},[75,1734,1735],{},"CPP_uninitvar",[75,1737,1738],{},[89,1739,1685],{"href":1684},[62,1741,1742,1745],{},[75,1743,1744],{},"CPPCrypt",[75,1746,1747],{},[89,1748,1685],{"href":1684},[62,1750,1751,1754],{},[75,1752,1753],{},"CPPDSLHardcoded",[75,1755,1756],{},[89,1757,1685],{"href":1684},[62,1759,1760,1763],{},[75,1761,1762],{},"CPPDSLRAND",[75,1764,1765],{},[89,1766,1685],{"href":1684},[62,1768,1769,1772],{},[75,1770,1771],{},"CPPDSLWES",[75,1773,1774],{},[89,1775,1685],{"href":1684},[62,1777,1778,1781],{},[75,1779,1780],{},"CpPED",[75,1782,1783],{},[89,1784,1685],{"href":1684},[62,1786,1787,1790],{},[75,1788,1789],{},"CPPEnterCriticalSection",[75,1791,1792],{},[89,1793,1685],{"href":1684},[62,1795,1796,1799],{},[75,1797,1798],{},"CPPIsBadWritePtr",[75,1800,1801],{},[89,1802,1685],{"href":1684},[62,1804,1805,1808],{},[75,1806,1807],{},"CPPLoadLibrary",[75,1809,1810],{},[89,1811,1685],{"href":1684},[62,1813,1814,1817],{},[75,1815,1816],{},"CPPLoop",[75,1818,1819],{},[89,1820,1685],{"href":1684},[62,1822,1823,1826],{},[75,1824,1825],{},"CPPOftenMisured",[75,1827,1828],{},[89,1829,1831],{"href":1830},"\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,1833,1834,1837],{},[75,1835,1836],{},"CPPPBE",[75,1838,1839],{},[89,1840,1842],{"href":1841},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc11-c","MSC11-C. Incorporate diagnostic tests using assertions",[62,1844,1845,1848],{},[75,1846,1847],{},"CPtr",[75,1849,1850],{},[89,1851,1853],{"href":1852},"\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,1855,1856,1859],{},[75,1857,1858],{},"CsFPC",[75,1860,1861],{},[89,1862,1864],{"href":1863},"\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,1866,1867,1870],{},[75,1868,1869],{},"ctuNullPointer",[75,1871,1872],{},[89,1873,1875],{"href":1874},"\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,1877,1878,1881],{},[75,1879,1880],{},"ctuOneDefinitionRuleViolation",[75,1882,1883],{},[89,1884,1886],{"href":1885},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc21-c","MSC21-C. Use robust loop termination conditions",[62,1888,1889,1892],{},[75,1890,1891],{},"CuEV",[75,1893,1894],{},[89,1895,1897],{"href":1896},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc24-c","MSC24-C. Do not use deprecated or obsolescent functions",[62,1899,1900,1903],{},[75,1901,1902],{},"CvariableScope",[75,1904,1905],{},[89,1906,1897],{"href":1896},[62,1908,1909,1912],{},[75,1910,1911],{},"CWE395TEST_2_CPP",[75,1913,1914],{},[89,1915,1897],{"href":1896},[62,1917,1918,1921],{},[75,1919,1920],{},"CWE561P25",[75,1922,1923],{},[89,1924,1897],{"href":1896},[62,1926,1927,1930],{},[75,1928,1929],{},"CwPSPPE",[75,1931,1932],{},[89,1933,1897],{"href":1896},[62,1935,1936,1939],{},[75,1937,1938],{},"CzDC",[75,1940,1941],{},[89,1942,1897],{"href":1896},[62,1944,1945,1948],{},[75,1946,1947],{},"deallocret",[75,1949,1950],{},[89,1951,1897],{"href":1896},[62,1953,1954,1957],{},[75,1955,1956],{},"integerOverflowCond",[75,1958,1959],{},[89,1960,1897],{"href":1896},[62,1962,1963,1966],{},[75,1964,1965],{},"invalidContainer",[75,1967,1968],{},[89,1969,1897],{"href":1896},[62,1971,1972,1975],{},[75,1973,1974],{},"invalidFunctionArg",[75,1976,1977],{},[89,1978,1897],{"href":1896},[62,1980,1981,1984],{},[75,1982,1983],{},"leakUnsafeArgAlloc",[75,1985,1986],{},[89,1987,1897],{"href":1896},[62,1989,1990,1993],{},[75,1991,1992],{},"memleak",[75,1994,1995],{},[89,1996,1897],{"href":1896},[62,1998,1999,2002],{},[75,2000,2001],{},"memleakOnRealloc",[75,2003,2004],{},[89,2005,1897],{"href":1896},[62,2007,2008,2011],{},[75,2009,2010],{},"noCopyConstructor",[75,2012,2013],{},[89,2014,1897],{"href":1896},[62,2016,2017,2020],{},[75,2018,2019],{},"noOperatorEq",[75,2021,2022],{},[89,2023,1897],{"href":1896},[62,2025,2026,2029],{},[75,2027,2028],{},"nullPointerRedundantCheck",[75,2030,2031],{},[89,2032,1897],{"href":1896},[62,2034,2035,2038],{},[75,2036,2037],{},"oppositeExpression",[75,2039,2040],{},[89,2041,1235],{"href":1234},[62,2043,2044,2047],{},[75,2045,2046],{},"redundantPointerOp",[75,2048,2049],{},[89,2050,1235],{"href":1234},[62,2052,2053,2056],{},[75,2054,2055],{},"RTOS_01",[75,2057,2058],{},[89,2059,1235],{"href":1234},[62,2061,2062,2065],{},[75,2063,2064],{},"RTOS_02",[75,2066,2067],{},[89,2068,1235],{"href":1234},[62,2070,2071,2074],{},[75,2072,2073],{},"RTOS_03",[75,2075,2076],{},[89,2077,1235],{"href":1234},[62,2079,2080,2083],{},[75,2081,2082],{},"RTOS_04",[75,2084,2085],{},[89,2086,1235],{"href":1234},[62,2088,2089,2092],{},[75,2090,2091],{},"RTOS_05",[75,2093,2094],{},[89,2095,1235],{"href":1234},[62,2097,2098,2101],{},[75,2099,2100],{},"RTOS_06",[75,2102,2103],{},[89,2104,1235],{"href":1234},[62,2106,2107,2110],{},[75,2108,2109],{},"RTOS_07",[75,2111,2112],{},[89,2113,2115],{"href":2114},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc30-c","MSC30-C. Do not use the rand() function for generating pseudorandom numbers",[62,2117,2118,2121],{},[75,2119,2120],{},"RTOS_09",[75,2122,2123],{},[89,2124,2126],{"href":2125},"\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,2128,2129,2132],{},[75,2130,2131],{},"RTOS_13",[75,2133,2134],{},[89,2135,2137],{"href":2136},"\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,2139,2140,2143],{},[75,2141,2142],{},"RTOS_14",[75,2144,2145],{},[89,2146,2148],{"href":2147},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc41-c","MSC41-C. Never hard code sensitive information",[62,2150,2151,2154],{},[75,2152,2153],{},"RTOS_18",[75,2155,2156],{},[89,2157,1235],{"href":1234},[62,2159,2160,2163],{},[75,2161,2162],{},"RTOS_19",[75,2164,2165],{},[89,2166,2168],{"href":2167},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos01-c","POS01-C. Check for the existence of links when dealing with files",[62,2170,2171,2174],{},[75,2172,2173],{},"RTOS_20",[75,2175,2176],{},[89,2177,2179],{"href":2178},"\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,2181,2182,2185],{},[75,2183,2184],{},"RTOS_22",[75,2186,2187],{},[89,2188,2190],{"href":2189},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre04-c","PRE04-C. Do not reuse a standard header file name",[62,2192,2193,2196],{},[75,2194,2195],{},"RTOS_26",[75,2197,2198],{},[89,2199,2201],{"href":2200},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre13-c","PRE13-C. Use the Standard predefined macros to test for versions and features.",[62,2203,2204,2207],{},[75,2205,2206],{},"RTOS_27",[75,2208,2209],{},[89,2210,2212],{"href":2211},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c","PRE30-C. Do not create a universal character name through concatenation",[62,2214,2215,2218],{},[75,2216,2217],{},"RTOS_28",[75,2219,2220],{},[89,2221,2223],{"href":2222},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre31-c","PRE31-C. Avoid side effects in arguments to unsafe macros",[62,2225,2226,2229],{},[75,2227,2228],{},"RTOS_31",[75,2230,2231],{},[89,2232,2234],{"href":2233},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr05-c","STR05-C. Use pointers to const when referring to string literals",[62,2236,2237,2240],{},[75,2238,2239],{},"RTOS_33",[75,2241,2242],{},[89,2243,2245],{"href":2244},"\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,2247,2248,2251],{},[75,2249,2250],{},"RTOS_34",[75,2252,2253],{},[89,2254,2245],{"href":2244},[62,2256,2257,2260],{},[75,2258,2259],{},"shadowVariable",[75,2261,2262],{},[89,2263,2245],{"href":2244},[62,2265,2266,2269],{},[75,2267,2268],{},"shiftTooManyBits",[75,2270,2271],{},[89,2272,2274],{"href":2273},"\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,2276,2277,2280],{},[75,2278,2279],{},"UNSAFE_01",[75,2281,2282],{},[89,2283,2285],{"href":2284},"\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,2287,2288,2291],{},[75,2289,2290],{},"UNSAFE_02",[75,2292,2293],{},[89,2294,2296],{"href":2295},"\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,2298,2299,2302],{},[75,2300,2301],{},"UNSAFE_03",[75,2303,2304],{},[89,2305,2245],{"href":2244},[62,2307,2308,2311],{},[75,2309,2310],{},"UNSAFE_04",[75,2312,2313],{},[89,2314,2245],{"href":2244},[62,2316,2317,2320],{},[75,2318,2319],{},"UNSAFE_05",[75,2321,2322],{},[89,2323,2325],{"href":2324},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin02-c","WIN02-C. Restrict privileges when spawning child processes",{"title":2327,"searchDepth":2328,"depth":2328,"links":2329},"",2,[],"md",{"tags":2332},[2333],"analyzer","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer",{"title":30,"description":41},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F46.security-reviewer-static-reviewer","f5nDnuE0p6RL2_1lhoLxnfsslIjjCT_H9KS4VsBbcmg",[2339,2343],{"title":2340,"path":2341,"stem":2342,"children":-1},"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":2344,"path":2345,"stem":2346,"children":-1},"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",[2348],{"title":2349,"path":2350,"stem":2351,"children":2352},"SEI CERT C Coding Standard","\u002Fsei-cert-c-coding-standard","4.sei-cert-c-coding-standard\u002F01.index",[2353,2354,2426,2930,3218,3232,3236,3240,3244,3984],{"title":2349,"path":2350,"stem":2351},{"title":2355,"path":2356,"stem":2357,"children":2358},"Front Matter","\u002Fsei-cert-c-coding-standard\u002Ffront-matter","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F1.index",[2359,2360],{"title":2355,"path":2356,"stem":2357},{"title":2361,"path":2362,"stem":2363,"children":2364},"Introduction","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[2365,2366,2370,2374,2378,2382,2386,2390,2394,2398,2402,2406,2410,2414,2418,2422],{"title":2361,"path":2362,"stem":2363},{"title":2367,"path":2368,"stem":2369},"Scope","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.scope",{"title":2371,"path":2372,"stem":2373},"Audience","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F02.audience",{"title":2375,"path":2376,"stem":2377},"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":2379,"path":2380,"stem":2381},"History","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhistory","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F04.history",{"title":2383,"path":2384,"stem":2385},"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":2387,"path":2388,"stem":2389},"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":2391,"path":2392,"stem":2393},"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":2395,"path":2396,"stem":2397},"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":2399,"path":2400,"stem":2401},"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":2403,"path":2404,"stem":2405},"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":2407,"path":2408,"stem":2409},"Usage","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F11.usage",{"title":2411,"path":2412,"stem":2413},"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":2415,"path":2416,"stem":2417},"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":2419,"path":2420,"stem":2421},"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":2423,"path":2424,"stem":2425},"Acknowledgments","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F15.acknowledgments",{"title":2427,"path":2428,"stem":2429,"children":2430},"Rules","\u002Fsei-cert-c-coding-standard\u002Frules","4.sei-cert-c-coding-standard\u002F03.rules\u002F01.index",[2431,2432,2436,2458,2480,2540,2570,2594,2614,2666,2690,2742,2766,2786,2796,2826,2894,2908],{"title":2427,"path":2428,"stem":2429},{"title":2433,"path":2434,"stem":2435},"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":2437,"path":2438,"stem":2439,"children":2440},"Arrays (ARR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F1.index",[2441,2442,2444,2446,2448,2452,2454],{"title":2437,"path":2438,"stem":2439},{"title":103,"path":102,"stem":2443},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F2.arr30-c",{"title":980,"path":979,"stem":2445},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F3.arr32-c",{"title":372,"path":371,"stem":2447},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F4.arr36-c",{"title":2449,"path":2450,"stem":2451},"ARR37-C. Do not add or subtract an integer to a pointer to a non-array object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F5.arr37-c",{"title":1000,"path":999,"stem":2453},"4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F6.arr38-c",{"title":2455,"path":2456,"stem":2457},"ARR39-C. Do not add or subtract a scaled integer to a pointer","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F7.arr39-c",{"title":2459,"path":2460,"stem":2461,"children":2462},"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",[2463,2464,2468,2470,2472,2476,2478],{"title":2459,"path":2460,"stem":2461},{"title":2465,"path":2466,"stem":2467},"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":2245,"path":2244,"stem":2469},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F3.str31-c",{"title":2274,"path":2273,"stem":2471},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F4.str32-c",{"title":2473,"path":2474,"stem":2475},"STR34-C. Cast characters to unsigned char before converting to larger integer sizes","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F5.str34-c",{"title":2285,"path":2284,"stem":2477},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F6.str37-c",{"title":2296,"path":2295,"stem":2479},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F7.str38-c",{"title":2481,"path":2482,"stem":2483,"children":2484},"Concurrency (CON)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F01.index",[2485,2486,2490,2494,2498,2502,2506,2510,2514,2518,2522,2526,2528,2532,2536],{"title":2481,"path":2482,"stem":2483},{"title":2487,"path":2488,"stem":2489},"CON30-C. Clean up thread-specific storage","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F02.con30-c",{"title":2491,"path":2492,"stem":2493},"CON31-C. Do not destroy a mutex while it is locked","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F03.con31-c",{"title":2495,"path":2496,"stem":2497},"CON32-C. Prevent data races when accessing bit-fields from multiple threads","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F04.con32-c",{"title":2499,"path":2500,"stem":2501},"CON33-C. Avoid race conditions when using library functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F05.con33-c",{"title":2503,"path":2504,"stem":2505},"CON34-C. Declare objects shared between threads with appropriate storage durations","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F06.con34-c",{"title":2507,"path":2508,"stem":2509},"CON35-C. Avoid deadlock by locking in a predefined order","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F07.con35-c",{"title":2511,"path":2512,"stem":2513},"CON36-C. Wrap functions that can spuriously wake up in a loop","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F08.con36-c",{"title":2515,"path":2516,"stem":2517},"CON37-C. Do not call signal() in a multithreaded program","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F09.con37-c",{"title":2519,"path":2520,"stem":2521},"CON38-C. Preserve thread safety and liveness when using condition variables","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F10.con38-c",{"title":2523,"path":2524,"stem":2525},"CON39-C. Do not join or detach a thread that was previously joined or detached","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F11.con39-c",{"title":1011,"path":1010,"stem":2527},"4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F12.con40-c",{"title":2529,"path":2530,"stem":2531},"CON41-C. Wrap functions that can fail spuriously in a loop","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F13.con41-c",{"title":2533,"path":2534,"stem":2535},"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":2537,"path":2538,"stem":2539},"CON43-C. Do not allow data races in multithreaded code","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon43-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F15.con43-c",{"title":2541,"path":2542,"stem":2543,"children":2544},"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",[2545,2546,2548,2550,2554,2558,2562,2564,2566],{"title":2541,"path":2542,"stem":2543},{"title":312,"path":311,"stem":2547},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F2.dcl30-c",{"title":323,"path":322,"stem":2549},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F3.dcl31-c",{"title":2551,"path":2552,"stem":2553},"DCL36-C. Do not declare an identifier with conflicting linkage classifications","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F4.dcl36-c",{"title":2555,"path":2556,"stem":2557},"DCL37-C. Do not declare or define a reserved identifier","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F5.dcl37-c",{"title":2559,"path":2560,"stem":2561},"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":334,"path":333,"stem":2563},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F7.dcl39-c",{"title":392,"path":391,"stem":2565},"4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F8.dcl40-c",{"title":2567,"path":2568,"stem":2569},"DCL41-C. Do not declare variables inside a switch statement before the first case label","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F9.dcl41-c",{"title":2571,"path":2572,"stem":2573,"children":2574},"Environment (ENV)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F1.index",[2575,2576,2578,2582,2586,2590],{"title":2571,"path":2572,"stem":2573},{"title":403,"path":402,"stem":2577},"4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F2.env30-c",{"title":2579,"path":2580,"stem":2581},"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":2583,"path":2584,"stem":2585},"ENV32-C. All exit handlers must return normally","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F4.env32-c",{"title":2587,"path":2588,"stem":2589},"ENV33-C. Do not call system()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F5.env33-c",{"title":2591,"path":2592,"stem":2593},"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":2595,"path":2596,"stem":2597,"children":2598},"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",[2599,2600,2604,2606,2610],{"title":2595,"path":2596,"stem":2597},{"title":2601,"path":2602,"stem":2603},"ERR30-C. Take care when reading errno","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F2.err30-c",{"title":463,"path":462,"stem":2605},"4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F3.err32-c",{"title":2607,"path":2608,"stem":2609},"ERR33-C. Detect and handle standard library errors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F4.err33-c",{"title":2611,"path":2612,"stem":2613},"ERR34-C. Detect errors when converting a string to a number","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F5.err34-c",{"title":2615,"path":2616,"stem":2617,"children":2618},"Expressions (EXP)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F01.index",[2619,2620,2622,2626,2628,2630,2634,2636,2638,2642,2644,2648,2652,2656,2660,2662],{"title":2615,"path":2616,"stem":2617},{"title":597,"path":596,"stem":2621},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F02.exp30-c",{"title":2623,"path":2624,"stem":2625},"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":638,"path":637,"stem":2627},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F04.exp33-c",{"title":730,"path":729,"stem":2629},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F05.exp34-c",{"title":2631,"path":2632,"stem":2633},"EXP35-C. Do not modify objects with temporary lifetime","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F06.exp35-c",{"title":759,"path":758,"stem":2635},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F07.exp36-c",{"title":797,"path":796,"stem":2637},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F08.exp37-c",{"title":2639,"path":2640,"stem":2641},"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":808,"path":807,"stem":2643},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F10.exp40-c",{"title":2645,"path":2646,"stem":2647},"EXP42-C. Do not compare padding data","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp42-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F11.exp42-c",{"title":2649,"path":2650,"stem":2651},"EXP43-C. Avoid undefined behavior when using restrict-qualified pointers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp43-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F12.exp43-c",{"title":2653,"path":2654,"stem":2655},"EXP44-C. Do not rely on side effects in operands to sizeof, _Alignof, or _Generic","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F13.exp44-c",{"title":2657,"path":2658,"stem":2659},"EXP45-C. Do not perform assignments in selection statements","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp45-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F14.exp45-c",{"title":818,"path":817,"stem":2661},"4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F15.exp46-c",{"title":2663,"path":2664,"stem":2665},"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":2667,"path":2668,"stem":2669,"children":2670},"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",[2671,2672,2676,2680,2682,2686],{"title":2667,"path":2668,"stem":2669},{"title":2673,"path":2674,"stem":2675},"FLP30-C. Do not use floating-point variables as loop counters","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F2.flp30-c",{"title":2677,"path":2678,"stem":2679},"FLP32-C. Prevent or detect domain and range errors in math functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F3.flp32-c",{"title":969,"path":968,"stem":2681},"4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F4.flp34-c",{"title":2683,"path":2684,"stem":2685},"FLP36-C. Preserve precision when converting integral values to floating-point type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F5.flp36-c",{"title":2687,"path":2688,"stem":2689},"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":2691,"path":2692,"stem":2693,"children":2694},"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",[2695,2696,2700,2704,2708,2712,2716,2718,2722,2726,2728,2732,2736,2740],{"title":2691,"path":2692,"stem":2693},{"title":2697,"path":2698,"stem":2699},"FIO30-C. Exclude user input from format strings","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F02.fio30-c",{"title":2701,"path":2702,"stem":2703},"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":2705,"path":2706,"stem":2707},"FIO34-C. Distinguish between characters read from a file and EOF or WEOF","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F04.fio34-c",{"title":2709,"path":2710,"stem":2711},"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":2713,"path":2714,"stem":2715},"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":301,"path":300,"stem":2717},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F07.fio39-c",{"title":2719,"path":2720,"stem":2721},"FIO40-C. Reset strings on fgets() or fgetws() failure","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F08.fio40-c",{"title":2723,"path":2724,"stem":2725},"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":875,"path":874,"stem":2727},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F10.fio42-c",{"title":2729,"path":2730,"stem":2731},"FIO44-C. Only use values for fsetpos() that are returned from fgetpos()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F11.fio44-c",{"title":2733,"path":2734,"stem":2735},"FIO45-C. Avoid TOCTOU race conditions while accessing files","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio45-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F12.fio45-c",{"title":2737,"path":2738,"stem":2739},"FIO46-C. Do not access a closed file","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio46-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F13.fio46-c",{"title":886,"path":885,"stem":2741},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F14.fio47-c",{"title":2743,"path":2744,"stem":2745,"children":2746},"Integers (INT)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F1.index",[2747,2748,2752,2754,2756,2758,2760,2764],{"title":2743,"path":2744,"stem":2745},{"title":2749,"path":2750,"stem":2751},"INT30-C. Ensure that unsigned integer operations do not wrap","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F2.int30-c",{"title":1347,"path":1346,"stem":2753},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F3.int31-c",{"title":1412,"path":1411,"stem":2755},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F4.int32-c",{"title":1423,"path":1422,"stem":2757},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F5.int33-c",{"title":1434,"path":1433,"stem":2759},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F6.int34-c",{"title":2761,"path":2762,"stem":2763},"INT35-C. Use correct integer precisions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F7.int35-c",{"title":1445,"path":1444,"stem":2765},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F8.int36-c",{"title":2767,"path":2768,"stem":2769,"children":2770},"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",[2771,2772,2774,2776,2778,2780,2782],{"title":2767,"path":2768,"stem":2769},{"title":1500,"path":1499,"stem":2773},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F2.mem30-c",{"title":1511,"path":1510,"stem":2775},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F3.mem31-c",{"title":1585,"path":1584,"stem":2777},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F4.mem33-c",{"title":1596,"path":1595,"stem":2779},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F5.mem34-c",{"title":1652,"path":1651,"stem":2781},"4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F6.mem35-c",{"title":2783,"path":2784,"stem":2785},"MEM36-C. Do not modify the alignment of objects by calling realloc()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F7.mem36-c",{"title":2787,"path":2788,"stem":2789,"children":2790},"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",[2791,2792],{"title":2787,"path":2788,"stem":2789},{"title":2793,"path":2794,"stem":2795},"WIN30-C. Properly pair allocation and deallocation functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmicrosoft-windows-win\u002Fwin30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F14.microsoft-windows-win\u002F2.win30-c",{"title":2797,"path":2798,"stem":2799,"children":2800},"Miscellaneous (MSC)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F1.index",[2801,2802,2804,2808,2812,2814,2818,2820,2824],{"title":2797,"path":2798,"stem":2799},{"title":2115,"path":2114,"stem":2803},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F2.msc30-c",{"title":2805,"path":2806,"stem":2807},"MSC32-C. Properly seed pseudorandom number generators","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F3.msc32-c",{"title":2809,"path":2810,"stem":2811},"MSC33-C. Do not pass invalid data to the asctime() function","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F4.msc33-c",{"title":2126,"path":2125,"stem":2813},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F5.msc37-c",{"title":2815,"path":2816,"stem":2817},"MSC38-C. Do not treat a predefined identifier as an object if it might only be implemented as a macro","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F6.msc38-c",{"title":2137,"path":2136,"stem":2819},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F7.msc39-c",{"title":2821,"path":2822,"stem":2823},"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":2148,"path":2147,"stem":2825},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F9.msc41-c",{"title":2827,"path":2828,"stem":2829,"children":2830},"POSIX (POS)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F01.index",[2831,2832,2836,2840,2844,2848,2852,2856,2860,2864,2868,2872,2876,2880,2884,2886,2890],{"title":2827,"path":2828,"stem":2829},{"title":2833,"path":2834,"stem":2835},"POS30-C. Use the readlink() function properly","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F02.pos30-c",{"title":2837,"path":2838,"stem":2839},"POS34-C. Do not call putenv() with a pointer to an automatic variable as the argument","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F03.pos34-c",{"title":2841,"path":2842,"stem":2843},"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":2845,"path":2846,"stem":2847},"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":2849,"path":2850,"stem":2851},"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":2853,"path":2854,"stem":2855},"POS38-C. Beware of race conditions when using fork and file descriptors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F07.pos38-c",{"title":2857,"path":2858,"stem":2859},"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":2861,"path":2862,"stem":2863},"POS44-C. Do not use signals to terminate threads","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F09.pos44-c",{"title":2865,"path":2866,"stem":2867},"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":2869,"path":2870,"stem":2871},"POS48-C. Do not unlock or destroy another POSIX thread's mutex","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos48-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F11.pos48-c",{"title":2873,"path":2874,"stem":2875},"POS49-C. When data must be accessed by multiple threads, provide a mutex and guarantee no adjacent data is also accessed","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos49-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F12.pos49-c",{"title":2877,"path":2878,"stem":2879},"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":2881,"path":2882,"stem":2883},"POS51-C. Avoid deadlock with POSIX threads by locking in predefined order","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos51-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F14.pos51-c",{"title":2179,"path":2178,"stem":2885},"4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F15.pos52-c",{"title":2887,"path":2888,"stem":2889},"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":2891,"path":2892,"stem":2893},"POS54-C. Detect and handle POSIX library errors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos54-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F17.pos54-c",{"title":2895,"path":2896,"stem":2897,"children":2898},"Preprocessor (PRE)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F1.index",[2899,2900,2902,2904],{"title":2895,"path":2896,"stem":2897},{"title":2212,"path":2211,"stem":2901},"4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F2.pre30-c",{"title":2223,"path":2222,"stem":2903},"4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F3.pre31-c",{"title":2905,"path":2906,"stem":2907},"PRE32-C. Do not use preprocessor directives in invocations of function-like macros","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F4.pre32-c",{"title":2909,"path":2910,"stem":2911,"children":2912},"Signals (SIG)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F1.index",[2913,2914,2918,2922,2926],{"title":2909,"path":2910,"stem":2911},{"title":2915,"path":2916,"stem":2917},"SIG30-C. Call only asynchronous-safe functions within signal handlers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F2.sig30-c",{"title":2919,"path":2920,"stem":2921},"SIG31-C. Do not access shared objects in signal handlers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F3.sig31-c",{"title":2923,"path":2924,"stem":2925},"SIG34-C. Do not call signal() from within interruptible signal handlers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F4.sig34-c",{"title":2927,"path":2928,"stem":2929},"SIG35-C. Do not return from a computational exception signal handler","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F5.sig35-c",{"title":2931,"path":2932,"stem":2933,"children":2934},"Back Matter","\u002Fsei-cert-c-coding-standard\u002Fback-matter","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F1.index",[2935,2936,2940,2944,2948,2952,3157,3214],{"title":2931,"path":2932,"stem":2933},{"title":2937,"path":2938,"stem":2939},"AA. Bibliography","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F2.aa-bibliography",{"title":2941,"path":2942,"stem":2943},"BB. Definitions","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F3.bb-definitions",{"title":2945,"path":2946,"stem":2947},"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":2949,"path":2950,"stem":2951},"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":2953,"path":2954,"stem":2955,"children":2956},"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",[2957,2958,2962,2966,2970,2974,2978,2982,2986,2990,2994,2998,3002,3006,3010,3014,3018,3022,3026,3030,3034,3038,3042,3046,3050,3054,3058,3062,3066,3070,3074,3078,3082,3086,3090,3094,3098,3102,3106,3110,3114,3118,3122,3126,3130,3131,3132,3133,3137,3141,3145,3149,3153],{"title":2953,"path":2954,"stem":2955},{"title":2959,"path":2960,"stem":2961},"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":2963,"path":2964,"stem":2965},"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":2967,"path":2968,"stem":2969},"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":2971,"path":2972,"stem":2973},"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":2975,"path":2976,"stem":2977},"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":2979,"path":2980,"stem":2981},"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":2983,"path":2984,"stem":2985},"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":2987,"path":2988,"stem":2989},"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":2991,"path":2992,"stem":2993},"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":2995,"path":2996,"stem":2997},"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":2999,"path":3000,"stem":3001},"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":3003,"path":3004,"stem":3005},"CodeSonar","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F13.codesonar",{"title":3007,"path":3008,"stem":3009},"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",{"title":3011,"path":3012,"stem":3013},"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":3015,"path":3016,"stem":3017},"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":3019,"path":3020,"stem":3021},"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":3023,"path":3024,"stem":3025},"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":3027,"path":3028,"stem":3029},"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":3031,"path":3032,"stem":3033},"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":3035,"path":3036,"stem":3037},"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":3039,"path":3040,"stem":3041},"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":3043,"path":3044,"stem":3045},"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":3047,"path":3048,"stem":3049},"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":3051,"path":3052,"stem":3053},"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":3055,"path":3056,"stem":3057},"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":3059,"path":3060,"stem":3061},"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":3063,"path":3064,"stem":3065},"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":3067,"path":3068,"stem":3069},"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":3071,"path":3072,"stem":3073},"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":3075,"path":3076,"stem":3077},"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":3079,"path":3080,"stem":3081},"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":3083,"path":3084,"stem":3085},"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":3087,"path":3088,"stem":3089},"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":3091,"path":3092,"stem":3093},"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":3095,"path":3096,"stem":3097},"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":3099,"path":3100,"stem":3101},"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":3103,"path":3104,"stem":3105},"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":3107,"path":3108,"stem":3109},"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":3111,"path":3112,"stem":3113},"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":3115,"path":3116,"stem":3117},"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":3119,"path":3120,"stem":3121},"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":3123,"path":3124,"stem":3125},"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":3127,"path":3128,"stem":3129},"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":2340,"path":2341,"stem":2342},{"title":30,"path":2334,"stem":2336},{"title":2344,"path":2345,"stem":2346},{"title":3134,"path":3135,"stem":3136},"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":3138,"path":3139,"stem":3140},"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":3142,"path":3143,"stem":3144},"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":3146,"path":3147,"stem":3148},"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":3150,"path":3151,"stem":3152},"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":3154,"path":3155,"stem":3156},"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":3158,"path":3159,"stem":3160,"children":3161},"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",[3162,3163,3167,3171,3175,3179,3183,3187,3191,3195,3198,3202,3206,3210],{"title":3158,"path":3159,"stem":3160},{"title":3164,"path":3165,"stem":3166},"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":3168,"path":3169,"stem":3170},"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":3172,"path":3173,"stem":3174},"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":3176,"path":3177,"stem":3178},"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":3180,"path":3181,"stem":3182},"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":3184,"path":3185,"stem":3186},"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":3188,"path":3189,"stem":3190},"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":3192,"path":3193,"stem":3194},"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":3192,"path":3196,"stem":3197},"\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":3199,"path":3200,"stem":3201},"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":3203,"path":3204,"stem":3205},"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":3207,"path":3208,"stem":3209},"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":3211,"path":3212,"stem":3213},"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":3215,"path":3216,"stem":3217},"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":3219,"path":3220,"stem":3221,"children":3222},"Admin","\u002Fsei-cert-c-coding-standard\u002Fadmin","4.sei-cert-c-coding-standard\u002F05.admin\u002F1.index",[3223,3224,3228],{"title":3219,"path":3220,"stem":3221},{"title":3225,"path":3226,"stem":3227},"TODO List","\u002Fsei-cert-c-coding-standard\u002Fadmin\u002Ftodo-list","4.sei-cert-c-coding-standard\u002F05.admin\u002F2.todo-list",{"title":3229,"path":3230,"stem":3231},"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":3233,"path":3234,"stem":3235},"Coding Style Guidelines","\u002Fsei-cert-c-coding-standard\u002Fcoding-style-guidelines","4.sei-cert-c-coding-standard\u002F05.coding-style-guidelines",{"title":3237,"path":3238,"stem":3239},"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":3241,"path":3242,"stem":3243},"Wiki Contents","\u002Fsei-cert-c-coding-standard\u002Fwiki-contents","4.sei-cert-c-coding-standard\u002F06.wiki-contents",{"title":3245,"path":3246,"stem":3247,"children":3248},"Recommendations","\u002Fsei-cert-c-coding-standard\u002Frecommendations","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F01.index",[3249,3250,3289,3306,3349,3386,3477,3494,3523,3580,3615,3698,3759,3798,3821,3895,3914,3967],{"title":3245,"path":3246,"stem":3247},{"title":2433,"path":3251,"stem":3252,"children":3253},"\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",[3254,3255,3259,3263,3267,3271,3273,3277,3281,3285],{"title":2433,"path":3251,"stem":3252},{"title":3256,"path":3257,"stem":3258},"API00-C. Functions should validate their parameters","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F02.api00-c",{"title":3260,"path":3261,"stem":3262},"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":3264,"path":3265,"stem":3266},"API02-C. Functions that read or write to or from an array should take an argument to specify the source or target size","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F04.api02-c",{"title":3268,"path":3269,"stem":3270},"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":92,"path":91,"stem":3272},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F06.api04-c",{"title":3274,"path":3275,"stem":3276},"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":3278,"path":3279,"stem":3280},"API07-C. Enforce type safety","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F08.api07-c",{"title":3282,"path":3283,"stem":3284},"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":3286,"path":3287,"stem":3288},"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":2437,"path":3290,"stem":3291,"children":3292},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F1.index",[3293,3294,3298,3302],{"title":2437,"path":3290,"stem":3291},{"title":3295,"path":3296,"stem":3297},"ARR00-C. Understand how arrays work","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F2.arr00-c",{"title":3299,"path":3300,"stem":3301},"ARR01-C. Do not apply the sizeof operator to a pointer when taking the size of an array","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F3.arr01-c",{"title":3303,"path":3304,"stem":3305},"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":2459,"path":3307,"stem":3308,"children":3309},"\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",[3310,3311,3315,3319,3323,3327,3331,3333,3337,3341,3345],{"title":2459,"path":3307,"stem":3308},{"title":3312,"path":3313,"stem":3314},"STR00-C. Represent characters using an appropriate type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F02.str00-c",{"title":3316,"path":3317,"stem":3318},"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":3320,"path":3321,"stem":3322},"STR02-C. Sanitize data passed to complex subsystems","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F04.str02-c",{"title":3324,"path":3325,"stem":3326},"STR03-C. Do not inadvertently truncate a string","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F05.str03-c",{"title":3328,"path":3329,"stem":3330},"STR04-C. Use plain char for characters in the basic character set","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F06.str04-c",{"title":2234,"path":2233,"stem":3332},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F07.str05-c",{"title":3334,"path":3335,"stem":3336},"STR06-C. Do not assume that strtok() leaves the parse string unchanged","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F08.str06-c",{"title":3338,"path":3339,"stem":3340},"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":3342,"path":3343,"stem":3344},"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":3346,"path":3347,"stem":3348},"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":2481,"path":3350,"stem":3351,"children":3352},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F01.index",[3353,3354,3358,3360,3364,3368,3370,3374,3378,3382],{"title":2481,"path":3350,"stem":3351},{"title":3355,"path":3356,"stem":3357},"CON01-C. Acquire and release synchronization primitives in the same module, at the same level of abstraction","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F02.con01-c",{"title":239,"path":238,"stem":3359},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F03.con02-c",{"title":3361,"path":3362,"stem":3363},"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":3365,"path":3366,"stem":3367},"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":250,"path":249,"stem":3369},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F06.con05-c",{"title":3371,"path":3372,"stem":3373},"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":3375,"path":3376,"stem":3377},"CON07-C. Ensure that compound operations on shared variables are atomic","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F08.con07-c",{"title":3379,"path":3380,"stem":3381},"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":3383,"path":3384,"stem":3385},"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":2541,"path":3387,"stem":3388,"children":3389},"\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",[3390,3391,3395,3397,3401,3403,3407,3411,3415,3419,3423,3427,3431,3435,3439,3441,3445,3449,3453,3457,3461,3465,3469,3473],{"title":2541,"path":3387,"stem":3388},{"title":3392,"path":3393,"stem":3394},"DCL00-C. Const-qualify immutable objects","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F02.dcl00-c",{"title":1031,"path":1030,"stem":3396},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F03.dcl01-c",{"title":3398,"path":3399,"stem":3400},"DCL02-C. Use visually distinct identifiers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F04.dcl02-c",{"title":261,"path":260,"stem":3402},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F05.dcl03-c",{"title":3404,"path":3405,"stem":3406},"DCL04-C. Do not declare more than one variable per declaration","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F06.dcl04-c",{"title":3408,"path":3409,"stem":3410},"DCL05-C. Use typedefs of non-pointer types only","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F07.dcl05-c",{"title":3412,"path":3413,"stem":3414},"DCL06-C. Use meaningful symbolic constants to represent literal values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F08.dcl06-c",{"title":3416,"path":3417,"stem":3418},"DCL07-C. Include the appropriate type information in function declarators","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F09.dcl07-c",{"title":3420,"path":3421,"stem":3422},"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":3424,"path":3425,"stem":3426},"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":3428,"path":3429,"stem":3430},"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":3432,"path":3433,"stem":3434},"DCL11-C. Understand the type issues associated with variadic functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F13.dcl11-c",{"title":3436,"path":3437,"stem":3438},"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":290,"path":289,"stem":3440},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F15.dcl13-c",{"title":3442,"path":3443,"stem":3444},"DCL15-C. Declare file-scope objects or functions that do not need external linkage as static","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F16.dcl15-c",{"title":3446,"path":3447,"stem":3448},"DCL16-C. Use \"L,\" not \"l,\" to indicate a long value","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl16-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F17.dcl16-c",{"title":3450,"path":3451,"stem":3452},"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":3454,"path":3455,"stem":3456},"DCL18-C. Do not begin integer constants with 0 when specifying a decimal value","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F19.dcl18-c",{"title":3458,"path":3459,"stem":3460},"DCL19-C. Minimize the scope of variables and functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F20.dcl19-c",{"title":3462,"path":3463,"stem":3464},"DCL20-C. Explicitly specify void when a function accepts no arguments","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl20-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F21.dcl20-c",{"title":3466,"path":3467,"stem":3468},"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":3470,"path":3471,"stem":3472},"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":3474,"path":3475,"stem":3476},"DCL23-C. Guarantee that mutually visible identifiers are unique","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl23-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F24.dcl23-c",{"title":2571,"path":3478,"stem":3479,"children":3480},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F1.index",[3481,3482,3486,3490],{"title":2571,"path":3478,"stem":3479},{"title":3483,"path":3484,"stem":3485},"ENV01-C. Do not make assumptions about the size of an environment variable","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env\u002Fenv01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F2.env01-c",{"title":3487,"path":3488,"stem":3489},"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":3491,"path":3492,"stem":3493},"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":2595,"path":3495,"stem":3496,"children":3497},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F1.index",[3498,3499,3503,3507,3511,3513,3515,3519],{"title":2595,"path":3495,"stem":3496},{"title":3500,"path":3501,"stem":3502},"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":3504,"path":3505,"stem":3506},"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":3508,"path":3509,"stem":3510},"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":432,"path":431,"stem":3512},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F5.err04-c",{"title":443,"path":442,"stem":3514},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F6.err05-c",{"title":3516,"path":3517,"stem":3518},"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":3520,"path":3521,"stem":3522},"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":2615,"path":3524,"stem":3525,"children":3526},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F01.index",[3527,3528,3530,3534,3538,3542,3546,3548,3550,3554,3558,3560,3564,3566,3570,3574,3576],{"title":2615,"path":3524,"stem":3525},{"title":474,"path":473,"stem":3529},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F02.exp00-c",{"title":3531,"path":3532,"stem":3533},"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":3535,"path":3536,"stem":3537},"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":3539,"path":3540,"stem":3541},"EXP05-C. Do not cast away a const qualification","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F05.exp05-c",{"title":3543,"path":3544,"stem":3545},"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":484,"path":483,"stem":3547},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F07.exp08-c",{"title":495,"path":494,"stem":3549},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F08.exp09-c",{"title":3551,"path":3552,"stem":3553},"EXP10-C. Do not depend on the order of evaluation of subexpressions or the order in which side effects take place","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F09.exp10-c",{"title":3555,"path":3556,"stem":3557},"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":568,"path":567,"stem":3559},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F11.exp12-c",{"title":3561,"path":3562,"stem":3563},"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":607,"path":606,"stem":3565},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F13.exp14-c",{"title":3567,"path":3568,"stem":3569},"EXP15-C. Do not place a semicolon on the same line as an if, for, or while statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F14.exp15-c",{"title":3571,"path":3572,"stem":3573},"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":618,"path":617,"stem":3575},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F16.exp19-c",{"title":3577,"path":3578,"stem":3579},"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":2667,"path":3581,"stem":3582,"children":3583},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F1.index",[3584,3585,3589,3593,3597,3599,3603,3607,3611],{"title":2667,"path":3581,"stem":3582},{"title":3586,"path":3587,"stem":3588},"FLP00-C. Understand the limitations of floating-point numbers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F2.flp00-c",{"title":3590,"path":3591,"stem":3592},"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":3594,"path":3595,"stem":3596},"FLP02-C. Avoid using floating-point numbers when precise computation is needed","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F4.flp02-c",{"title":958,"path":957,"stem":3598},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F5.flp03-c",{"title":3600,"path":3601,"stem":3602},"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":3604,"path":3605,"stem":3606},"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":3608,"path":3609,"stem":3610},"FLP06-C. Convert integers to floating point for floating-point operations","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F8.flp06-c",{"title":3612,"path":3613,"stem":3614},"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":2691,"path":3616,"stem":3617,"children":3618},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F01.index",[3619,3620,3624,3628,3632,3636,3640,3644,3648,3652,3656,3660,3664,3668,3672,3676,3680,3684,3686,3690,3694],{"title":2691,"path":3616,"stem":3617},{"title":3621,"path":3622,"stem":3623},"FIO01-C. Be careful using functions that use file names for identification","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F02.fio01-c",{"title":3625,"path":3626,"stem":3627},"FIO02-C. Canonicalize path names originating from tainted sources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F03.fio02-c",{"title":3629,"path":3630,"stem":3631},"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":3633,"path":3634,"stem":3635},"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":3637,"path":3638,"stem":3639},"FIO06-C. Create files with appropriate access permissions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F06.fio06-c",{"title":3641,"path":3642,"stem":3643},"FIO08-C. Take care when calling remove() on an open file","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F07.fio08-c",{"title":3645,"path":3646,"stem":3647},"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":3649,"path":3650,"stem":3651},"FIO10-C. Take care when using the rename() function","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F09.fio10-c",{"title":3653,"path":3654,"stem":3655},"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":3657,"path":3658,"stem":3659},"FIO13-C. Never push back anything other than one read character","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F11.fio13-c",{"title":3661,"path":3662,"stem":3663},"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":3665,"path":3666,"stem":3667},"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":3669,"path":3670,"stem":3671},"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":3673,"path":3674,"stem":3675},"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":3677,"path":3678,"stem":3679},"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":3681,"path":3682,"stem":3683},"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":829,"path":828,"stem":3685},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F18.fio21-c",{"title":3687,"path":3688,"stem":3689},"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":3691,"path":3692,"stem":3693},"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":3695,"path":3696,"stem":3697},"FIO24-C. Do not open a file that is already open","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio24-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F21.fio24-c",{"title":2743,"path":3699,"stem":3700,"children":3701},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F01.index",[3702,3703,3707,3709,3713,3717,3721,3723,3727,3731,3735,3739,3743,3747,3751,3755],{"title":2743,"path":3699,"stem":3700},{"title":3704,"path":3705,"stem":3706},"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":1150,"path":1149,"stem":3708},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F03.int01-c",{"title":3710,"path":3711,"stem":3712},"INT04-C. Enforce limits on integer values originating from tainted sources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F05.int04-c",{"title":3714,"path":3715,"stem":3716},"INT05-C. Do not use input functions to convert character data if they cannot handle all possible inputs","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F06.int05-c",{"title":3718,"path":3719,"stem":3720},"INT07-C. Use only explicitly signed or unsigned char type for numeric values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F07.int07-c",{"title":1336,"path":1335,"stem":3722},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F08.int08-c",{"title":3724,"path":3725,"stem":3726},"INT09-C. Ensure enumeration constants map to unique values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F09.int09-c",{"title":3728,"path":3729,"stem":3730},"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":3732,"path":3733,"stem":3734},"INT12-C. Do not make assumptions about the type of a plain int bit-field when used in an expression","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F11.int12-c",{"title":3736,"path":3737,"stem":3738},"INT13-C. Use bitwise operators only on unsigned operands","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F12.int13-c",{"title":3740,"path":3741,"stem":3742},"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":3744,"path":3745,"stem":3746},"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":3748,"path":3749,"stem":3750},"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":3752,"path":3753,"stem":3754},"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":3756,"path":3757,"stem":3758},"INT18-C. Evaluate integer expressions in a larger size before comparing or assigning to that size","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F17.int18-c",{"title":2767,"path":3760,"stem":3761,"children":3762},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F01.index",[3763,3764,3768,3772,3776,3778,3780,3782,3786,3790,3792,3796],{"title":2767,"path":3760,"stem":3761},{"title":3765,"path":3766,"stem":3767},"MEM00-C. Allocate and free memory in the same module, at the same level of abstraction","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F02.mem00-c",{"title":3769,"path":3770,"stem":3771},"MEM01-C. Store a new value in pointers immediately after free()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F03.mem01-c",{"title":3773,"path":3774,"stem":3775},"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":1456,"path":1455,"stem":3777},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F05.mem03-c",{"title":1467,"path":1466,"stem":3779},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F06.mem04-c",{"title":1478,"path":1477,"stem":3781},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F07.mem05-c",{"title":3783,"path":3784,"stem":3785},"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":3787,"path":3788,"stem":3789},"MEM07-C. Ensure that the arguments to calloc(), when multiplied, do not wrap","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F09.mem07-c",{"title":1489,"path":1488,"stem":3791},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F10.mem10-c",{"title":3793,"path":3794,"stem":3795},"MEM11-C. Do not assume infinite heap space","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F11.mem11-c",{"title":1674,"path":1673,"stem":3797},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F12.mem12-c",{"title":2787,"path":3799,"stem":3800,"children":3801},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F1.index",[3802,3803,3807,3811,3813,3817],{"title":2787,"path":3799,"stem":3800},{"title":3804,"path":3805,"stem":3806},"WIN00-C. Be specific when dynamically loading libraries","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F2.win00-c",{"title":3808,"path":3809,"stem":3810},"WIN01-C. Do not forcibly terminate execution","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F3.win01-c",{"title":2325,"path":2324,"stem":3812},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F4.win02-c",{"title":3814,"path":3815,"stem":3816},"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":3818,"path":3819,"stem":3820},"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":2797,"path":3822,"stem":3823,"children":3824},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F01.index",[3825,3826,3830,3832,3836,3840,3844,3846,3850,3852,3854,3858,3862,3866,3870,3872,3876,3878,3880,3884,3888,3890,3892],{"title":2797,"path":3822,"stem":3823},{"title":3827,"path":3828,"stem":3829},"MSC00-C. Compile cleanly at high warning levels","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F02.msc00-c",{"title":1663,"path":1662,"stem":3831},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F03.msc01-c",{"title":3833,"path":3834,"stem":3835},"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":3837,"path":3838,"stem":3839},"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":3841,"path":3842,"stem":3843},"MSC06-C. Beware of compiler optimizations","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F06.msc06-c",{"title":1685,"path":1684,"stem":3845},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F07.msc07-c",{"title":3847,"path":3848,"stem":3849},"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":1842,"path":1841,"stem":3851},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F09.msc11-c",{"title":1853,"path":1852,"stem":3853},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F10.msc12-c",{"title":3855,"path":3856,"stem":3857},"MSC13-C. Detect and remove unused values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F11.msc13-c",{"title":3859,"path":3860,"stem":3861},"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":3863,"path":3864,"stem":3865},"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":3867,"path":3868,"stem":3869},"MSC17-C. Finish every set of statements associated with a case label with a break statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F14.msc17-c",{"title":1864,"path":1863,"stem":3871},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F15.msc18-c",{"title":3873,"path":3874,"stem":3875},"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":1875,"path":1874,"stem":3877},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F17.msc20-c",{"title":1886,"path":1885,"stem":3879},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F18.msc21-c",{"title":3881,"path":3882,"stem":3883},"MSC22-C. Use the setjmp(), longjmp() facility securely","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc22-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F19.msc22-c",{"title":3885,"path":3886,"stem":3887},"MSC23-C. Beware of vendor-specific library and language differences","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc23-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F20.msc23-c",{"title":1897,"path":1896,"stem":3889},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F21.msc24-c",{"title":1235,"path":1234,"stem":3891},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F22.msc25-c",{"title":3893,"path":1830,"stem":3894},"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":2827,"path":3896,"stem":3897,"children":3898},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F1.index",[3899,3900,3902,3906,3910],{"title":2827,"path":3896,"stem":3897},{"title":2168,"path":2167,"stem":3901},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F2.pos01-c",{"title":3903,"path":3904,"stem":3905},"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":3907,"path":3908,"stem":3909},"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":3911,"path":3912,"stem":3913},"POS05-C. Limit access to files by creating a jail","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F5.pos05-c",{"title":2895,"path":3915,"stem":3916,"children":3917},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F01.index",[3918,3919,3923,3927,3931,3933,3937,3941,3945,3949,3953,3957,3961,3965],{"title":2895,"path":3915,"stem":3916},{"title":3920,"path":3921,"stem":3922},"PRE00-C. Prefer inline or static functions to function-like macros","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F02.pre00-c",{"title":3924,"path":3925,"stem":3926},"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":3928,"path":3929,"stem":3930},"PRE02-C. Macro replacement lists should be parenthesized","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F04.pre02-c",{"title":2190,"path":2189,"stem":3932},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F05.pre04-c",{"title":3934,"path":3935,"stem":3936},"PRE05-C. Understand macro replacement when concatenating tokens or performing stringification","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F06.pre05-c",{"title":3938,"path":3939,"stem":3940},"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":3942,"path":3943,"stem":3944},"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":3946,"path":3947,"stem":3948},"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":3950,"path":3951,"stem":3952},"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":3954,"path":3955,"stem":3956},"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":3958,"path":3959,"stem":3960},"PRE11-C. Do not conclude macro definitions with a semicolon","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F12.pre11-c",{"title":3962,"path":3963,"stem":3964},"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":2201,"path":2200,"stem":3966},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F14.pre13-c",{"title":2909,"path":3968,"stem":3969,"children":3970},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F1.index",[3971,3972,3976,3980],{"title":2909,"path":3968,"stem":3969},{"title":3973,"path":3974,"stem":3975},"SIG00-C. Mask signals handled by noninterruptible signal handlers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F2.sig00-c",{"title":3977,"path":3978,"stem":3979},"SIG01-C. Understand implementation-specific details regarding signal handler persistence","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F3.sig01-c",{"title":3981,"path":3982,"stem":3983},"SIG02-C. Avoid using signals to implement normal functionality","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F4.sig02-c",{"title":3985,"path":3986,"stem":3987},"CERT manifest files","\u002Fsei-cert-c-coding-standard\u002Fcert-manifest-files","4.sei-cert-c-coding-standard\u002F09.cert-manifest-files",1775657852258]