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