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