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