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