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