[{"data":1,"prerenderedAt":4057},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc37-c":28,"surround-\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc37-c":2284,"sidebar-sei-cert-c-coding-standard":2291},[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":2267,"extension":2268,"meta":2269,"navigation":7,"path":2280,"seo":2281,"stem":2282,"__hash__":2283},"content\u002F4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F5.msc37-c.md","MSC37-C. Ensure that control never reaches the end of a non-void function",{"type":32,"value":33,"toc":2249},"minimark",[34,38,66,71,88,283,290,294,300,443,446,463,685,690,693,929,936,991,1005,1008,1019,1311,1315,1334,1344,1548,1552,1571,1638,1642,1654,1658,2099,2103,2110,2170,2174,2180,2184,2187,2190,2193,2197,2220,2223,2245],[35,36,30],"h1",{"id":37},"msc37-c-ensure-that-control-never-reaches-the-end-of-a-non-void-function",[39,40,41,42,46,47,50,51,54,55,60,61,65],"p",{},"If control reaches the closing curly brace ( ",[43,44,45],"code",{},"}"," ) of a non- ",[43,48,49],{},"void"," function without evaluating a ",[43,52,53],{},"return"," statement, using the return value of the function call is ",[56,57,59],"a",{"href":58},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-undefinedbehavior","undefined behavior."," (See ",[56,62,64],{"href":63},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fcc-undefined-behavior#CC.UndefinedBehavior-ub_86","undefined behavior 86"," .)",[67,68,70],"h2",{"id":69},"noncompliant-code-example","Noncompliant Code Example",[39,72,73,74,77,78,81,82,84,85,87],{},"In this noncompliant code example, control reaches the end of the ",[43,75,76],{},"checkpass()"," function when the two strings passed to ",[43,79,80],{},"strcmp()"," are not equal, resulting in undefined behavior. Many compilers will generate code for the ",[43,83,76],{}," function, returning various values along the execution path where no ",[43,86,53],{}," statement is defined.",[89,90,92],"code-block",{"quality":91},"bad",[93,94,99],"pre",{"className":95,"code":96,"language":97,"meta":98,"style":98},"language-c shiki shiki-themes github-light github-dark monokai","#include \u003Cstring.h>\n#include \u003Cstdio.h>\n \nint checkpass(const char *password) {\n  if (strcmp(password, \"pass\") == 0) {\n    return 1;\n  }\n}\n\nvoid func(const char *userinput) {\n  if (checkpass(userinput)) {\n    printf(\"Success\\n\");\n  }\n}\n","c","",[43,100,101,114,122,129,159,189,201,207,213,219,240,253,273,278],{"__ignoreMap":98},[102,103,106,110],"span",{"class":104,"line":105},"line",1,[102,107,109],{"class":108},"sC2Qs","#include",[102,111,113],{"class":112},"sstjo"," \u003Cstring.h>\n",[102,115,117,119],{"class":104,"line":116},2,[102,118,109],{"class":108},[102,120,121],{"class":112}," \u003Cstdio.h>\n",[102,123,125],{"class":104,"line":124},3,[102,126,128],{"class":127},"sMOD_"," \n",[102,130,132,136,140,143,146,149,152,156],{"class":104,"line":131},4,[102,133,135],{"class":134},"sq6CD","int",[102,137,139],{"class":138},"srTi1"," checkpass",[102,141,142],{"class":127},"(",[102,144,145],{"class":108},"const",[102,147,148],{"class":134}," char",[102,150,151],{"class":108}," *",[102,153,155],{"class":154},"sTHNf","password",[102,157,158],{"class":127},") {\n",[102,160,162,165,168,171,174,177,180,183,187],{"class":104,"line":161},5,[102,163,164],{"class":108},"  if",[102,166,167],{"class":127}," (",[102,169,170],{"class":138},"strcmp",[102,172,173],{"class":127},"(password, ",[102,175,176],{"class":112},"\"pass\"",[102,178,179],{"class":127},") ",[102,181,182],{"class":108},"==",[102,184,186],{"class":185},"s7F3e"," 0",[102,188,158],{"class":127},[102,190,192,195,198],{"class":104,"line":191},6,[102,193,194],{"class":108},"    return",[102,196,197],{"class":185}," 1",[102,199,200],{"class":127},";\n",[102,202,204],{"class":104,"line":203},7,[102,205,206],{"class":127},"  }\n",[102,208,210],{"class":104,"line":209},8,[102,211,212],{"class":127},"}\n",[102,214,216],{"class":104,"line":215},9,[102,217,218],{"emptyLinePlaceholder":7},"\n",[102,220,222,224,227,229,231,233,235,238],{"class":104,"line":221},10,[102,223,49],{"class":134},[102,225,226],{"class":138}," func",[102,228,142],{"class":127},[102,230,145],{"class":108},[102,232,148],{"class":134},[102,234,151],{"class":108},[102,236,237],{"class":154},"userinput",[102,239,158],{"class":127},[102,241,243,245,247,250],{"class":104,"line":242},11,[102,244,164],{"class":108},[102,246,167],{"class":127},[102,248,249],{"class":138},"checkpass",[102,251,252],{"class":127},"(userinput)) {\n",[102,254,256,259,261,264,267,270],{"class":104,"line":255},12,[102,257,258],{"class":138},"    printf",[102,260,142],{"class":127},[102,262,263],{"class":112},"\"Success",[102,265,266],{"class":185},"\\n",[102,268,269],{"class":112},"\"",[102,271,272],{"class":127},");\n",[102,274,276],{"class":104,"line":275},13,[102,277,206],{"class":127},[102,279,281],{"class":104,"line":280},14,[102,282,212],{"class":127},[39,284,285,286,65],{},"This error is frequently diagnosed by compilers. (See ",[56,287,289],{"href":288},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc00-c","MSC00-C. Compile cleanly at high warning levels",[67,291,293],{"id":292},"compliant-solution","Compliant Solution",[39,295,296,297,299],{},"This compliant solution ensures that the ",[43,298,76],{}," function always returns a value:",[89,301,303],{"quality":302},"good",[93,304,306],{"className":95,"code":305,"language":97,"meta":98,"style":98},"#include \u003Cstring.h>\n#include \u003Cstdio.h>\n \nint checkpass(const char *password) {\n  if (strcmp(password, \"pass\") == 0) {\n    return 1;\n  }\n  return 0;\n}\n\nvoid func(const char *userinput) {\n  if (checkpass(userinput)) {\n    printf(\"Success!\\n\");\n  }\n}\n",[43,307,308,314,320,324,342,362,370,374,383,387,391,409,419,434,438],{"__ignoreMap":98},[102,309,310,312],{"class":104,"line":105},[102,311,109],{"class":108},[102,313,113],{"class":112},[102,315,316,318],{"class":104,"line":116},[102,317,109],{"class":108},[102,319,121],{"class":112},[102,321,322],{"class":104,"line":124},[102,323,128],{"class":127},[102,325,326,328,330,332,334,336,338,340],{"class":104,"line":131},[102,327,135],{"class":134},[102,329,139],{"class":138},[102,331,142],{"class":127},[102,333,145],{"class":108},[102,335,148],{"class":134},[102,337,151],{"class":108},[102,339,155],{"class":154},[102,341,158],{"class":127},[102,343,344,346,348,350,352,354,356,358,360],{"class":104,"line":161},[102,345,164],{"class":108},[102,347,167],{"class":127},[102,349,170],{"class":138},[102,351,173],{"class":127},[102,353,176],{"class":112},[102,355,179],{"class":127},[102,357,182],{"class":108},[102,359,186],{"class":185},[102,361,158],{"class":127},[102,363,364,366,368],{"class":104,"line":191},[102,365,194],{"class":108},[102,367,197],{"class":185},[102,369,200],{"class":127},[102,371,372],{"class":104,"line":203},[102,373,206],{"class":127},[102,375,376,379,381],{"class":104,"line":209},[102,377,378],{"class":108},"  return",[102,380,186],{"class":185},[102,382,200],{"class":127},[102,384,385],{"class":104,"line":215},[102,386,212],{"class":127},[102,388,389],{"class":104,"line":221},[102,390,218],{"emptyLinePlaceholder":7},[102,392,393,395,397,399,401,403,405,407],{"class":104,"line":242},[102,394,49],{"class":134},[102,396,226],{"class":138},[102,398,142],{"class":127},[102,400,145],{"class":108},[102,402,148],{"class":134},[102,404,151],{"class":108},[102,406,237],{"class":154},[102,408,158],{"class":127},[102,410,411,413,415,417],{"class":104,"line":255},[102,412,164],{"class":108},[102,414,167],{"class":127},[102,416,249],{"class":138},[102,418,252],{"class":127},[102,420,421,423,425,428,430,432],{"class":104,"line":275},[102,422,258],{"class":138},[102,424,142],{"class":127},[102,426,427],{"class":112},"\"Success!",[102,429,266],{"class":185},[102,431,269],{"class":112},[102,433,272],{"class":127},[102,435,436],{"class":104,"line":280},[102,437,206],{"class":127},[102,439,441],{"class":104,"line":440},15,[102,442,212],{"class":127},[67,444,70],{"id":445},"noncompliant-code-example-1",[39,447,73,448,451,452,455,456,459,460,462],{},[43,449,450],{},"getlen()"," function when ",[43,453,454],{},"input"," does not contain the integer ",[43,457,458],{},"delim"," . Because the potentially undefined return value of ",[43,461,450],{}," is later used as an index into an array, a buffer overflow may occur.",[89,464,465],{"quality":91},[93,466,468],{"className":95,"code":467,"language":97,"meta":98,"style":98},"#include \u003Cstddef.h>\n \nsize_t getlen(const int *input, size_t maxlen, int delim) {\n  for (size_t i = 0; i \u003C maxlen; ++i) {\n    if (input[i] == delim) {\n      return i;\n    }\n  }\n}\n \nvoid func(int userdata) {\n  size_t i;\n  int data[] = { 1, 1, 1 };\n  i = getlen(data, sizeof(data), 0);\n  data[i] = userdata;\n}\n",[43,469,470,477,481,517,549,567,575,580,584,588,592,607,614,645,668,680],{"__ignoreMap":98},[102,471,472,474],{"class":104,"line":105},[102,473,109],{"class":108},[102,475,476],{"class":112}," \u003Cstddef.h>\n",[102,478,479],{"class":104,"line":116},[102,480,128],{"class":127},[102,482,483,486,489,491,493,496,498,500,503,505,508,510,512,515],{"class":104,"line":124},[102,484,485],{"class":134},"size_t",[102,487,488],{"class":138}," getlen",[102,490,142],{"class":127},[102,492,145],{"class":108},[102,494,495],{"class":134}," int",[102,497,151],{"class":108},[102,499,454],{"class":154},[102,501,502],{"class":127},", ",[102,504,485],{"class":134},[102,506,507],{"class":154}," maxlen",[102,509,502],{"class":127},[102,511,135],{"class":134},[102,513,514],{"class":154}," delim",[102,516,158],{"class":127},[102,518,519,522,524,526,529,532,534,537,540,543,546],{"class":104,"line":131},[102,520,521],{"class":108},"  for",[102,523,167],{"class":127},[102,525,485],{"class":134},[102,527,528],{"class":127}," i ",[102,530,531],{"class":108},"=",[102,533,186],{"class":185},[102,535,536],{"class":127},"; i ",[102,538,539],{"class":108},"\u003C",[102,541,542],{"class":127}," maxlen; ",[102,544,545],{"class":108},"++",[102,547,548],{"class":127},"i) {\n",[102,550,551,554,556,559,562,564],{"class":104,"line":161},[102,552,553],{"class":108},"    if",[102,555,167],{"class":127},[102,557,454],{"class":558},"sOrwc",[102,560,561],{"class":127},"[i] ",[102,563,182],{"class":108},[102,565,566],{"class":127}," delim) {\n",[102,568,569,572],{"class":104,"line":191},[102,570,571],{"class":108},"      return",[102,573,574],{"class":127}," i;\n",[102,576,577],{"class":104,"line":203},[102,578,579],{"class":127},"    }\n",[102,581,582],{"class":104,"line":209},[102,583,206],{"class":127},[102,585,586],{"class":104,"line":215},[102,587,212],{"class":127},[102,589,590],{"class":104,"line":221},[102,591,128],{"class":127},[102,593,594,596,598,600,602,605],{"class":104,"line":242},[102,595,49],{"class":134},[102,597,226],{"class":138},[102,599,142],{"class":127},[102,601,135],{"class":134},[102,603,604],{"class":154}," userdata",[102,606,158],{"class":127},[102,608,609,612],{"class":104,"line":255},[102,610,611],{"class":134},"  size_t",[102,613,574],{"class":127},[102,615,616,619,622,625,628,631,634,636,638,640,642],{"class":104,"line":275},[102,617,618],{"class":134},"  int",[102,620,621],{"class":127}," data",[102,623,624],{"class":108},"[]",[102,626,627],{"class":108}," =",[102,629,630],{"class":127}," { ",[102,632,633],{"class":185},"1",[102,635,502],{"class":127},[102,637,633],{"class":185},[102,639,502],{"class":127},[102,641,633],{"class":185},[102,643,644],{"class":127}," };\n",[102,646,647,650,652,654,657,660,663,666],{"class":104,"line":280},[102,648,649],{"class":127},"  i ",[102,651,531],{"class":108},[102,653,488],{"class":138},[102,655,656],{"class":127},"(data, ",[102,658,659],{"class":108},"sizeof",[102,661,662],{"class":127},"(data), ",[102,664,665],{"class":185},"0",[102,667,272],{"class":127},[102,669,670,673,675,677],{"class":104,"line":440},[102,671,672],{"class":558},"  data",[102,674,561],{"class":127},[102,676,531],{"class":108},[102,678,679],{"class":127}," userdata;\n",[102,681,683],{"class":104,"line":682},16,[102,684,212],{"class":127},[686,687,689],"h3",{"id":688},"implementation-details-gcc","Implementation Details (GCC)",[39,691,692],{},"Violating this rule can have unexpected consequences, as in the following example:",[89,694,695],{"quality":91},[93,696,698],{"className":95,"code":697,"language":97,"meta":98,"style":98},"#include \u003Cstdio.h>\n\nsize_t getlen(const int *input, size_t maxlen, int delim) {\n  for (size_t i = 0; i \u003C maxlen; ++i) {\n    if (input[i] == delim) {\n      return i;\n    }\n  }\n}\n\nint main(int argc, char **argv) {\n  size_t i;\n  int data[] = { 1, 1, 1 };\n\n  i = getlen(data, sizeof(data), 0);\n  printf(\"Returned: %zu\\n\", i);\n  data[i] = 0;\n\n  return 0;\n}\n",[43,699,700,706,710,740,764,778,784,788,792,796,800,827,833,857,861,879,897,910,915,924],{"__ignoreMap":98},[102,701,702,704],{"class":104,"line":105},[102,703,109],{"class":108},[102,705,121],{"class":112},[102,707,708],{"class":104,"line":116},[102,709,218],{"emptyLinePlaceholder":7},[102,711,712,714,716,718,720,722,724,726,728,730,732,734,736,738],{"class":104,"line":124},[102,713,485],{"class":134},[102,715,488],{"class":138},[102,717,142],{"class":127},[102,719,145],{"class":108},[102,721,495],{"class":134},[102,723,151],{"class":108},[102,725,454],{"class":154},[102,727,502],{"class":127},[102,729,485],{"class":134},[102,731,507],{"class":154},[102,733,502],{"class":127},[102,735,135],{"class":134},[102,737,514],{"class":154},[102,739,158],{"class":127},[102,741,742,744,746,748,750,752,754,756,758,760,762],{"class":104,"line":131},[102,743,521],{"class":108},[102,745,167],{"class":127},[102,747,485],{"class":134},[102,749,528],{"class":127},[102,751,531],{"class":108},[102,753,186],{"class":185},[102,755,536],{"class":127},[102,757,539],{"class":108},[102,759,542],{"class":127},[102,761,545],{"class":108},[102,763,548],{"class":127},[102,765,766,768,770,772,774,776],{"class":104,"line":161},[102,767,553],{"class":108},[102,769,167],{"class":127},[102,771,454],{"class":558},[102,773,561],{"class":127},[102,775,182],{"class":108},[102,777,566],{"class":127},[102,779,780,782],{"class":104,"line":191},[102,781,571],{"class":108},[102,783,574],{"class":127},[102,785,786],{"class":104,"line":203},[102,787,579],{"class":127},[102,789,790],{"class":104,"line":209},[102,791,206],{"class":127},[102,793,794],{"class":104,"line":215},[102,795,212],{"class":127},[102,797,798],{"class":104,"line":221},[102,799,218],{"emptyLinePlaceholder":7},[102,801,802,804,807,809,811,814,816,819,822,825],{"class":104,"line":242},[102,803,135],{"class":134},[102,805,806],{"class":138}," main",[102,808,142],{"class":127},[102,810,135],{"class":134},[102,812,813],{"class":154}," argc",[102,815,502],{"class":127},[102,817,818],{"class":134},"char",[102,820,821],{"class":108}," **",[102,823,824],{"class":154},"argv",[102,826,158],{"class":127},[102,828,829,831],{"class":104,"line":255},[102,830,611],{"class":134},[102,832,574],{"class":127},[102,834,835,837,839,841,843,845,847,849,851,853,855],{"class":104,"line":275},[102,836,618],{"class":134},[102,838,621],{"class":127},[102,840,624],{"class":108},[102,842,627],{"class":108},[102,844,630],{"class":127},[102,846,633],{"class":185},[102,848,502],{"class":127},[102,850,633],{"class":185},[102,852,502],{"class":127},[102,854,633],{"class":185},[102,856,644],{"class":127},[102,858,859],{"class":104,"line":280},[102,860,218],{"emptyLinePlaceholder":7},[102,862,863,865,867,869,871,873,875,877],{"class":104,"line":440},[102,864,649],{"class":127},[102,866,531],{"class":108},[102,868,488],{"class":138},[102,870,656],{"class":127},[102,872,659],{"class":108},[102,874,662],{"class":127},[102,876,665],{"class":185},[102,878,272],{"class":127},[102,880,881,884,886,889,892,894],{"class":104,"line":682},[102,882,883],{"class":138},"  printf",[102,885,142],{"class":127},[102,887,888],{"class":112},"\"Returned: ",[102,890,891],{"class":185},"%zu\\n",[102,893,269],{"class":112},[102,895,896],{"class":127},", i);\n",[102,898,900,902,904,906,908],{"class":104,"line":899},17,[102,901,672],{"class":558},[102,903,561],{"class":127},[102,905,531],{"class":108},[102,907,186],{"class":185},[102,909,200],{"class":127},[102,911,913],{"class":104,"line":912},18,[102,914,218],{"emptyLinePlaceholder":7},[102,916,918,920,922],{"class":104,"line":917},19,[102,919,378],{"class":108},[102,921,186],{"class":185},[102,923,200],{"class":127},[102,925,927],{"class":104,"line":926},20,[102,928,212],{"class":127},[39,930,931,932,935],{},"When this program is compiled with ",[43,933,934],{},"-Wall"," on most versions of the GCC compiler, the following warning is generated:",[93,937,941],{"className":938,"code":939,"language":940,"meta":98,"style":98},"language-java shiki shiki-themes github-light github-dark monokai","example.c: In function 'getlen':\nexample.c:12: warning: control reaches end of non-void function\n","java",[43,942,943,964],{"__ignoreMap":98},[102,944,945,948,951,955,958,961],{"class":104,"line":105},[102,946,947],{"class":127},"example.c",[102,949,950],{"class":108},":",[102,952,954],{"class":953},"sk8M1"," In",[102,956,957],{"class":127}," function ",[102,959,960],{"class":112},"'getlen'",[102,962,963],{"class":108},":\n",[102,965,966,968,970,973,975,978,980,983,986,988],{"class":104,"line":116},[102,967,947],{"class":127},[102,969,950],{"class":108},[102,971,972],{"class":185},"12",[102,974,950],{"class":108},[102,976,977],{"class":127}," warning",[102,979,950],{"class":108},[102,981,982],{"class":127}," control reaches end of non",[102,984,985],{"class":108},"-",[102,987,49],{"class":134},[102,989,990],{"class":127}," function\n",[39,992,993,994,996,997,1000,1001,1004],{},"None of the inputs to the function equal the delimiter, so when run with GCC 5.3 on Linux, control reaches the end of the ",[43,995,450],{}," function, which is undefined behavior and in this test returns ",[43,998,999],{},"3"," , causing an out-of-bounds write to the ",[43,1002,1003],{},"data"," array.",[67,1006,293],{"id":1007},"compliant-solution-1",[39,1009,1010,1011,1013,1014,1018],{},"This compliant solution changes the interface of ",[43,1012,450],{}," to store the result in a user-provided pointer and returns a status indicator to report success or failure. The best method for handling this type of error is specific to the application and the type of error. (See ",[56,1015,1017],{"href":1016},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr00-c","ERR00-C. Adopt and implement a consistent and comprehensive error-handling policy"," for more on error handling.)",[89,1020,1021],{"quality":302},[93,1022,1024],{"className":95,"code":1023,"language":97,"meta":98,"style":98},"#include \u003Cstddef.h>\n \nint getlen(const int *input, size_t maxlen, int delim,\n           size_t *result) {\n  if (result == NULL) {\n    return -1;\n  }\n  for (size_t i = 0; i \u003C maxlen; ++i) {\n    if (input[i] == delim) {\n      *result = i;\n      return 0;\n    }\n  }\n  return -1;\n}\n\nvoid func(int userdata) {\n  size_t i;\n  int data[] = {1, 1, 1};\n  if (getlen(data, sizeof(data), 0, &i) != 0) {\n    \u002F* Handle error *\u002F\n  } else {\n    data[i] = userdata;\n  }\n}\n",[43,1025,1026,1032,1036,1067,1079,1093,1104,1108,1132,1146,1158,1166,1170,1174,1184,1188,1192,1206,1212,1238,1270,1277,1289,1301,1306],{"__ignoreMap":98},[102,1027,1028,1030],{"class":104,"line":105},[102,1029,109],{"class":108},[102,1031,476],{"class":112},[102,1033,1034],{"class":104,"line":116},[102,1035,128],{"class":127},[102,1037,1038,1040,1042,1044,1046,1048,1050,1052,1054,1056,1058,1060,1062,1064],{"class":104,"line":124},[102,1039,135],{"class":134},[102,1041,488],{"class":138},[102,1043,142],{"class":127},[102,1045,145],{"class":108},[102,1047,495],{"class":134},[102,1049,151],{"class":108},[102,1051,454],{"class":154},[102,1053,502],{"class":127},[102,1055,485],{"class":134},[102,1057,507],{"class":154},[102,1059,502],{"class":127},[102,1061,135],{"class":134},[102,1063,514],{"class":154},[102,1065,1066],{"class":127},",\n",[102,1068,1069,1072,1074,1077],{"class":104,"line":131},[102,1070,1071],{"class":134},"           size_t",[102,1073,151],{"class":108},[102,1075,1076],{"class":154},"result",[102,1078,158],{"class":127},[102,1080,1081,1083,1086,1088,1091],{"class":104,"line":161},[102,1082,164],{"class":108},[102,1084,1085],{"class":127}," (result ",[102,1087,182],{"class":108},[102,1089,1090],{"class":185}," NULL",[102,1092,158],{"class":127},[102,1094,1095,1097,1100,1102],{"class":104,"line":191},[102,1096,194],{"class":108},[102,1098,1099],{"class":108}," -",[102,1101,633],{"class":185},[102,1103,200],{"class":127},[102,1105,1106],{"class":104,"line":203},[102,1107,206],{"class":127},[102,1109,1110,1112,1114,1116,1118,1120,1122,1124,1126,1128,1130],{"class":104,"line":209},[102,1111,521],{"class":108},[102,1113,167],{"class":127},[102,1115,485],{"class":134},[102,1117,528],{"class":127},[102,1119,531],{"class":108},[102,1121,186],{"class":185},[102,1123,536],{"class":127},[102,1125,539],{"class":108},[102,1127,542],{"class":127},[102,1129,545],{"class":108},[102,1131,548],{"class":127},[102,1133,1134,1136,1138,1140,1142,1144],{"class":104,"line":215},[102,1135,553],{"class":108},[102,1137,167],{"class":127},[102,1139,454],{"class":558},[102,1141,561],{"class":127},[102,1143,182],{"class":108},[102,1145,566],{"class":127},[102,1147,1148,1151,1154,1156],{"class":104,"line":221},[102,1149,1150],{"class":108},"      *",[102,1152,1153],{"class":127},"result ",[102,1155,531],{"class":108},[102,1157,574],{"class":127},[102,1159,1160,1162,1164],{"class":104,"line":242},[102,1161,571],{"class":108},[102,1163,186],{"class":185},[102,1165,200],{"class":127},[102,1167,1168],{"class":104,"line":255},[102,1169,579],{"class":127},[102,1171,1172],{"class":104,"line":275},[102,1173,206],{"class":127},[102,1175,1176,1178,1180,1182],{"class":104,"line":280},[102,1177,378],{"class":108},[102,1179,1099],{"class":108},[102,1181,633],{"class":185},[102,1183,200],{"class":127},[102,1185,1186],{"class":104,"line":440},[102,1187,212],{"class":127},[102,1189,1190],{"class":104,"line":682},[102,1191,218],{"emptyLinePlaceholder":7},[102,1193,1194,1196,1198,1200,1202,1204],{"class":104,"line":899},[102,1195,49],{"class":134},[102,1197,226],{"class":138},[102,1199,142],{"class":127},[102,1201,135],{"class":134},[102,1203,604],{"class":154},[102,1205,158],{"class":127},[102,1207,1208,1210],{"class":104,"line":912},[102,1209,611],{"class":134},[102,1211,574],{"class":127},[102,1213,1214,1216,1218,1220,1222,1225,1227,1229,1231,1233,1235],{"class":104,"line":917},[102,1215,618],{"class":134},[102,1217,621],{"class":127},[102,1219,624],{"class":108},[102,1221,627],{"class":108},[102,1223,1224],{"class":127}," {",[102,1226,633],{"class":185},[102,1228,502],{"class":127},[102,1230,633],{"class":185},[102,1232,502],{"class":127},[102,1234,633],{"class":185},[102,1236,1237],{"class":127},"};\n",[102,1239,1240,1242,1244,1247,1249,1251,1253,1255,1257,1260,1263,1266,1268],{"class":104,"line":926},[102,1241,164],{"class":108},[102,1243,167],{"class":127},[102,1245,1246],{"class":138},"getlen",[102,1248,656],{"class":127},[102,1250,659],{"class":108},[102,1252,662],{"class":127},[102,1254,665],{"class":185},[102,1256,502],{"class":127},[102,1258,1259],{"class":108},"&",[102,1261,1262],{"class":127},"i) ",[102,1264,1265],{"class":108},"!=",[102,1267,186],{"class":185},[102,1269,158],{"class":127},[102,1271,1273],{"class":104,"line":1272},21,[102,1274,1276],{"class":1275},"s8-w5","    \u002F* Handle error *\u002F\n",[102,1278,1280,1283,1286],{"class":104,"line":1279},22,[102,1281,1282],{"class":127},"  } ",[102,1284,1285],{"class":108},"else",[102,1287,1288],{"class":127}," {\n",[102,1290,1292,1295,1297,1299],{"class":104,"line":1291},23,[102,1293,1294],{"class":558},"    data",[102,1296,561],{"class":127},[102,1298,531],{"class":108},[102,1300,679],{"class":127},[102,1302,1304],{"class":104,"line":1303},24,[102,1305,206],{"class":127},[102,1307,1309],{"class":104,"line":1308},25,[102,1310,212],{"class":127},[67,1312,1314],{"id":1313},"exceptions","Exceptions",[39,1316,1317,1321,1322,1326,1327,1329,1330,1333],{},[1318,1319,1320],"strong",{},"MSC37-C-EX1:"," According to the C Standard, 5.1.2.3.4, paragraph 1 [ ",[56,1323,1325],{"href":1324},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO-IEC9899-2024","ISO\u002FIEC 9899:2024"," ], \"Reaching the ",[43,1328,45],{}," that terminates the main function returns a value of 0.\" As a result , it is permissible for control to reach the end of the ",[43,1331,1332],{},"main()"," function without executing a return statement.",[39,1335,1336,1339,1340,1343],{},[1318,1337,1338],{},"MSC37-C-EX2:"," It is permissible for a control path to not return a value if that code path is never taken and a function marked ",[43,1341,1342],{},"_Noreturn"," is called as part of that code path. For example:",[89,1345,1346],{"quality":302},[93,1347,1349],{"className":95,"code":1348,"language":97,"meta":98,"style":98},"#include \u003Cstdio.h>\n#include \u003Cstdlib.h>\n \n_Noreturn void unreachable(const char *msg) {\n  printf(\"Unreachable code reached: %s\\n\", msg);\n  exit(1);\n}\n\nenum E {\n  One,\n  Two,\n  Three\n};\n \nint f(enum E e) {\n  switch (e) {\n  case One: return 1;\n  case Two: return 2;\n  case Three: return 3;\n  }\n  unreachable(\"Can never get here\");\n}\n",[43,1350,1351,1357,1364,1369,1392,1409,1420,1424,1428,1436,1441,1446,1451,1455,1459,1478,1486,1500,1514,1528,1532,1544],{"__ignoreMap":98},[102,1352,1353,1355],{"class":104,"line":105},[102,1354,109],{"class":108},[102,1356,121],{"class":112},[102,1358,1359,1361],{"class":104,"line":116},[102,1360,109],{"class":108},[102,1362,1363],{"class":112}," \u003Cstdlib.h>\n",[102,1365,1366],{"class":104,"line":124},[102,1367,1368],{"class":127}," \n",[102,1370,1371,1374,1376,1379,1381,1383,1385,1387,1390],{"class":104,"line":131},[102,1372,1373],{"class":127},"_Noreturn ",[102,1375,49],{"class":134},[102,1377,1378],{"class":138}," unreachable",[102,1380,142],{"class":127},[102,1382,145],{"class":108},[102,1384,148],{"class":134},[102,1386,151],{"class":108},[102,1388,1389],{"class":154},"msg",[102,1391,158],{"class":127},[102,1393,1394,1396,1398,1401,1404,1406],{"class":104,"line":161},[102,1395,883],{"class":138},[102,1397,142],{"class":127},[102,1399,1400],{"class":112},"\"Unreachable code reached: ",[102,1402,1403],{"class":185},"%s\\n",[102,1405,269],{"class":112},[102,1407,1408],{"class":127},", msg);\n",[102,1410,1411,1414,1416,1418],{"class":104,"line":191},[102,1412,1413],{"class":138},"  exit",[102,1415,142],{"class":127},[102,1417,633],{"class":185},[102,1419,272],{"class":127},[102,1421,1422],{"class":104,"line":203},[102,1423,212],{"class":127},[102,1425,1426],{"class":104,"line":209},[102,1427,218],{"emptyLinePlaceholder":7},[102,1429,1430,1433],{"class":104,"line":215},[102,1431,1432],{"class":134},"enum",[102,1434,1435],{"class":127}," E {\n",[102,1437,1438],{"class":104,"line":221},[102,1439,1440],{"class":127},"  One,\n",[102,1442,1443],{"class":104,"line":242},[102,1444,1445],{"class":127},"  Two,\n",[102,1447,1448],{"class":104,"line":255},[102,1449,1450],{"class":127},"  Three\n",[102,1452,1453],{"class":104,"line":275},[102,1454,1237],{"class":127},[102,1456,1457],{"class":104,"line":280},[102,1458,1368],{"class":127},[102,1460,1461,1463,1466,1468,1470,1473,1476],{"class":104,"line":440},[102,1462,135],{"class":134},[102,1464,1465],{"class":138}," f",[102,1467,142],{"class":127},[102,1469,1432],{"class":134},[102,1471,1472],{"class":127}," E ",[102,1474,1475],{"class":154},"e",[102,1477,158],{"class":127},[102,1479,1480,1483],{"class":104,"line":682},[102,1481,1482],{"class":108},"  switch",[102,1484,1485],{"class":127}," (e) {\n",[102,1487,1488,1491,1494,1496,1498],{"class":104,"line":899},[102,1489,1490],{"class":108},"  case",[102,1492,1493],{"class":127}," One: ",[102,1495,53],{"class":108},[102,1497,197],{"class":185},[102,1499,200],{"class":127},[102,1501,1502,1504,1507,1509,1512],{"class":104,"line":912},[102,1503,1490],{"class":108},[102,1505,1506],{"class":127}," Two: ",[102,1508,53],{"class":108},[102,1510,1511],{"class":185}," 2",[102,1513,200],{"class":127},[102,1515,1516,1518,1521,1523,1526],{"class":104,"line":917},[102,1517,1490],{"class":108},[102,1519,1520],{"class":127}," Three: ",[102,1522,53],{"class":108},[102,1524,1525],{"class":185}," 3",[102,1527,200],{"class":127},[102,1529,1530],{"class":104,"line":926},[102,1531,206],{"class":127},[102,1533,1534,1537,1539,1542],{"class":104,"line":1272},[102,1535,1536],{"class":138},"  unreachable",[102,1538,142],{"class":127},[102,1540,1541],{"class":112},"\"Can never get here\"",[102,1543,272],{"class":127},[102,1545,1546],{"class":104,"line":1279},[102,1547,212],{"class":127},[67,1549,1551],{"id":1550},"risk-assessment","Risk Assessment",[39,1553,1554,1555,1557,1558,1560,1561,1565,1566,1570],{},"Using the return value from a non- ",[43,1556,49],{}," function where control reaches the end of the function without evaluating a ",[43,1559,53],{}," statement can lead to buffer overflow ",[56,1562,1564],{"href":1563},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerabilities"," as well as other ",[56,1567,1569],{"href":1568},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-unexpectedbehavior","unexpected program behaviors"," .",[1572,1573,1574,1575,1574,1605],"table",{},"\n  ",[1576,1577,1578,1579,1574],"thead",{},"\n    ",[1580,1581,1582,1583,1582,1587,1582,1590,1582,1593,1582,1596,1582,1599,1582,1602,1578],"tr",{},"\n      ",[1584,1585,1586],"th",{},"Rule",[1584,1588,1589],{},"Severity",[1584,1591,1592],{},"Likelihood",[1584,1594,1595],{},"Detectable",[1584,1597,1598],{},"Repairable",[1584,1600,1601],{},"Priority",[1584,1603,1604],{},"Level",[1606,1607,1578,1608,1574],"tbody",{},[1580,1609,1582,1610,1582,1614,1582,1617,1582,1620,1582,1623,1582,1626,1582,1633,1578],{},[1611,1612,1613],"td",{},"MSC37-C",[1611,1615,1616],{},"High",[1611,1618,1619],{},"Unlikely",[1611,1621,1622],{},"Yes",[1611,1624,1625],{},"No",[1611,1627,1629],{"style":1628},"color: #f1c40f;",[1630,1631,1632],"b",{},"P6",[1611,1634,1635],{"style":1628},[1630,1636,1637],{},"L2",[686,1639,1641],{"id":1640},"related-vulnerabilities","Related Vulnerabilities",[39,1643,1644,1645,1647,1648,1570],{},"Search for ",[56,1646,1564],{"href":1563}," resulting from the violation of this rule on the ",[56,1649,1653],{"href":1650,"rel":1651},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+MSC37-C",[1652],"nofollow","CERT website",[686,1655,1657],{"id":1656},"automated-detection","Automated Detection",[1572,1659,1662],{"className":1660},[1661],"wrapped",[1606,1663,1664,1680,1706,1734,1757,1782,1809,1834,1867,1895,1918,1942,1971,2001,2021,2045,2074],{},[1580,1665,1668,1671,1674,1677],{"className":1666},[1667],"header",[1584,1669,1670],{},"Tool",[1584,1672,1673],{},"Version",[1584,1675,1676],{},"Checker",[1584,1678,1679],{},"Description",[1580,1681,1684,1690,1698,1703],{"className":1682},[1683],"odd",[1611,1685,1686],{},[56,1687,1689],{"href":1688},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fastree","Astrée",[1611,1691,1692],{},[1693,1694,1697],"div",{"className":1695},[1696],"content-wrapper","25.10",[1611,1699,1700],{},[1318,1701,1702],{},"return-implicit",[1611,1704,1705],{},"Fully checked",[1580,1707,1710,1716,1724,1729],{"className":1708},[1709],"even",[1611,1711,1712],{},[56,1713,1715],{"href":1714},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Faxivion-bauhaus-suite","Axivion Bauhaus Suite",[1611,1717,1718],{},[1693,1719,1721],{"className":1720},[1696],[39,1722,1723],{},"7.2.0",[1611,1725,1726],{},[1318,1727,1728],{},"CertC-MSC37",[1611,1730,1731],{},[1732,1733],"br",{},[1580,1735,1737,1743,1749,1754],{"className":1736},[1683],[1611,1738,1739],{},[56,1740,1742],{"href":1741},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar","CodeSonar",[1611,1744,1745],{},[1693,1746,1748],{"className":1747},[1696],"9.1p0",[1611,1750,1751],{},[1318,1752,1753],{},"LANG.STRUCT.MRS",[1611,1755,1756],{},"Missing return statement",[1580,1758,1760,1766,1772,1779],{"className":1759},[1709],[1611,1761,1762],{},[56,1763,1765],{"href":1764},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcoverity","Coverity",[1611,1767,1768],{},[1693,1769,1771],{"className":1770},[1696],"2017.07",[1611,1773,1774],{},[39,1775,1776],{},[1318,1777,1778],{},"MISSING_RETURN",[1611,1780,1781],{},"Implemented",[1580,1783,1785,1792,1800,1805],{"className":1784},[1683],[1611,1786,1788],{"style":1787},"text-align: left;",[56,1789,1791],{"href":1790},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck","Cppcheck",[1611,1793,1794],{"style":1787},[1693,1795,1797],{"className":1796},[1696],[39,1798,1799],{},"2.15",[1611,1801,1802],{},[1318,1803,1804],{},"missingReturn",[1611,1806,1807],{},[1732,1808],{},[1580,1810,1812,1818,1826,1830],{"className":1811},[1709],[1611,1813,1814],{},[56,1815,1817],{"href":1816},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck-premium","Cppcheck Premium",[1611,1819,1820],{},[1693,1821,1823],{"className":1822},[1696],[39,1824,1825],{},"24.11.0",[1611,1827,1828],{},[1318,1829,1804],{},[1611,1831,1832],{},[1732,1833],{},[1580,1835,1837,1843,1851,1863],{"className":1836},[1683],[1611,1838,1839],{},[56,1840,1842],{"href":1841},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fhelix-qac","Helix QAC",[1611,1844,1845],{},[1693,1846,1848],{"className":1847},[1696],[39,1849,1850],{},"2025.2",[1611,1852,1853,1858],{},[39,1854,1855],{},[1318,1856,1857],{},"C++4022",[39,1859,1860],{},[1318,1861,1862],{},"DF2888",[1611,1864,1865],{},[1732,1866],{},[1580,1868,1870,1876,1881,1891],{"className":1869},[1709],[1611,1871,1872],{},[56,1873,1875],{"href":1874},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fklocwork","Klocwork",[1611,1877,1878],{},[1693,1879,1850],{"className":1880},[1696],[1611,1882,1883,1886,1888],{},[1318,1884,1885],{},"FUNCRET.GEN",[1732,1887],{},[1318,1889,1890],{},"FUNCRET.IMPLICIT",[1611,1892,1893],{},[1732,1894],{},[1580,1896,1898,1904,1910,1915],{"className":1897},[1683],[1611,1899,1900],{},[56,1901,1903],{"href":1902},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fldra","LDRA tool suite",[1611,1905,1906],{},[1693,1907,1909],{"className":1908},[1696],"9.7.1",[1611,1911,1912],{},[1318,1913,1914],{},"2 D, 36 S, 66 S",[1611,1916,1917],{},"Fully implemented",[1580,1919,1921,1927,1932,1939],{"className":1920},[1709],[1611,1922,1923],{},[56,1924,1926],{"href":1925},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[1611,1928,1929],{},[1693,1930,1850],{"className":1931},[1696],[1611,1933,1934],{},[39,1935,1936],{},[1318,1937,1938],{},"CERT_C-MSC37-a",[1611,1940,1941],{},"All exit paths from a function, except main(), with non-void return type shall have an explicit return statement with an expression",[1580,1943,1945,1951,1959,1966],{"className":1944},[1683],[1611,1946,1947],{},[56,1948,1950],{"href":1949},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpc-lint-plus","PC-lint Plus",[1611,1952,1953],{},[1693,1954,1956],{"className":1955},[1696],[39,1957,1958],{},"1.4",[1611,1960,1961],{},[39,1962,1963],{},[1318,1964,1965],{},"533",[1611,1967,1968],{},[39,1969,1970],{},"Fully supported",[1580,1972,1974,1980,1988,1994],{"className":1973},[1709],[1611,1975,1976],{},[56,1977,1979],{"href":1978},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[1611,1981,1982],{},[1693,1983,1985],{"className":1984},[1696],[39,1986,1987],{},"R2025b",[1611,1989,1990],{},[56,1991,1993],{"href":1992},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcrulemsc37c.html","CERT C: Rule MSC37-C",[1611,1995,1996,1997],{},"Checks for missing return statement (rule fully covered)",[39,1998,1999],{},[1732,2000],{},[1580,2002,2004,2010,2015,2019],{"className":2003},[1683],[1611,2005,2006],{},[56,2007,2009],{"href":2008},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frulechecker","RuleChecker",[1611,2011,2012],{},[1693,2013,1697],{"className":2014},[1696],[1611,2016,2017],{},[1318,2018,1702],{},[1611,2020,1705],{},[1580,2022,2024,2030,2038,2043],{"className":2023},[1709],[1611,2025,2026],{},[56,2027,2029],{"href":2028},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer","Security Reviewer - Static Reviewer",[1611,2031,2032],{},[1693,2033,2035],{"className":2034},[1696],[39,2036,2037],{},"6.02",[1611,2039,2040],{},[1318,2041,2042],{},"RTOS_09",[1611,2044,1917],{},[1580,2046,2048,2054,2062,2070],{"className":2047},[1683],[1611,2049,2050],{},[56,2051,2053],{"href":2052},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsonarqube-ccpp-plugin","SonarQube C\u002FC++ Plugin",[1611,2055,2056],{},[1693,2057,2059],{"className":2058},[1696],[39,2060,2061],{},"3.11",[1611,2063,2064],{},[1318,2065,2066],{},[56,2067,2069],{"href":2068},"https:\u002F\u002Fwww.sonarsource.com\u002Fproducts\u002Fcodeanalyzers\u002Fsonarcfamilyforcpp\u002Frules-c.html#RSPEC-935","S935",[1611,2071,2072],{},[1732,2073],{},[1580,2075,2077,2083,2091,2096],{"className":2076},[1709],[1611,2078,2079],{},[56,2080,2082],{"href":2081},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Ftrustinsoft-analyzer","TrustInSoft Analyzer",[1611,2084,2085],{},[1693,2086,2088],{"className":2087},[1696],[39,2089,2090],{},"1.38",[1611,2092,2093],{},[1318,2094,2095],{},"Body of function falls-through",[1611,2097,2098],{},"Exhaustively verified.",[67,2100,2102],{"id":2101},"related-guidelines","Related Guidelines",[39,2104,2105,2109],{},[56,2106,2108],{"href":2107},"\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized#HowthisCodingStandardisOrganized-RelatedGuidelines","Key here"," (explains table format and definitions)",[1572,2111,2112,2122],{},[1576,2113,2114],{},[1580,2115,2116,2118,2120],{},[1584,2117],{},[1584,2119],{},[1584,2121],{},[1606,2123,2124,2135,2151],{},[1580,2125,2126,2129,2132],{},[1611,2127,2128],{},"Taxonomy",[1611,2130,2131],{},"Taxonomy item",[1611,2133,2134],{},"Relationship",[1580,2136,2137,2142,2148],{},[1611,2138,2139],{},[56,2140,2141],{"href":17},"CERT C Secure Coding Standard",[1611,2143,2144],{},[56,2145,2147],{"href":2146},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc01-c","MSC01-C. Strive for logical completeness",[1611,2149,2150],{},"Prior to 2018-01-12: CERT: Unspecified Relationship",[1580,2152,2153,2160,2167],{},[1611,2154,2155],{},[56,2156,2159],{"href":2157,"rel":2158},"http:\u002F\u002Fcwe.mitre.org\u002F",[1652],"CWE 2.11",[1611,2161,2162],{},[56,2163,2166],{"href":2164,"rel":2165},"https:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Findex.html758.html",[1652],"CWE-758",[1611,2168,2169],{},"2017-07-07: CERT: Rule subset of CWE",[67,2171,2173],{"id":2172},"cert-cwe-mapping-notes","CERT-CWE Mapping Notes",[39,2175,2176,2179],{},[56,2177,2108],{"href":2178},"\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized#HowthisCodingStandardisOrganized-CERT-CWEMappingNotes"," for mapping notes",[686,2181,2183],{"id":2182},"cwe-758-and-msc37-c","CWE-758 and MSC37-C",[39,2185,2186],{},"Independent( INT34-C, INT36-C, MEM30-C, MSC37-C, FLP32-C, EXP33-C, EXP30-C, ERR34-C, ARR32-C)",[39,2188,2189],{},"CWE-758 = Union( MSC37-C, list) where list =",[39,2191,2192],{},"Undefined behavior that results from anything other than failing to return a value from a function that expects one",[67,2194,2196],{"id":2195},"bibliography","Bibliography",[1572,2198,2199,2207],{},[1576,2200,2201],{},[1580,2202,2203,2205],{},[1584,2204],{},[1584,2206],{},[1606,2208,2209],{},[1580,2210,2211,2217],{},[1611,2212,2213,2214,2216],{},"[ ",[56,2215,1325],{"href":1324}," ]",[1611,2218,2219],{},"5.1.2.3.4, \"Program Termination\"",[2221,2222],"hr",{},[39,2224,2225,2232,2233,2232,2239],{},[56,2226,2228],{"href":2227},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc33-c",[2229,2230],"img",{"src":2231},"\u002Fattachments\u002F87152044\u002F88034188.png"," ",[56,2234,2236],{"href":2235},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002F",[2229,2237],{"src":2238},"\u002Fattachments\u002F87152044\u002F88034190.png",[56,2240,2242],{"href":2241},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc38-c",[2229,2243],{"src":2244},"\u002Fattachments\u002F87152044\u002F88034189.png",[2246,2247,2248],"style",{},"html pre.shiki code .sC2Qs, html code.shiki .sC2Qs{--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .sstjo, html code.shiki .sstjo{--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}html pre.shiki code .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sq6CD, html code.shiki .sq6CD{--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .sTHNf, html code.shiki .sTHNf{--shiki-default:#E36209;--shiki-default-font-style:inherit;--shiki-dark:#FFAB70;--shiki-dark-font-style:inherit;--shiki-sepia:#FD971F;--shiki-sepia-font-style:italic}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html pre.shiki code .sOrwc, html code.shiki .sOrwc{--shiki-default:#E36209;--shiki-dark:#FFAB70;--shiki-sepia:#F8F8F2}html pre.shiki code .sk8M1, html code.shiki .sk8M1{--shiki-default:#24292E;--shiki-default-font-style:inherit;--shiki-dark:#E1E4E8;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}",{"title":98,"searchDepth":116,"depth":116,"links":2250},[2251,2252,2253,2256,2257,2258,2262,2263,2266],{"id":69,"depth":116,"text":70},{"id":292,"depth":116,"text":293},{"id":445,"depth":116,"text":70,"children":2254},[2255],{"id":688,"depth":124,"text":689},{"id":1007,"depth":116,"text":293},{"id":1313,"depth":116,"text":1314},{"id":1550,"depth":116,"text":1551,"children":2259},[2260,2261],{"id":1640,"depth":124,"text":1641},{"id":1656,"depth":124,"text":1657},{"id":2101,"depth":116,"text":2102},{"id":2172,"depth":116,"text":2173,"children":2264},[2265],{"id":2182,"depth":124,"text":2183},{"id":2195,"depth":116,"text":2196},"If control reaches the closing curly brace ( } ) of a non- void function without evaluating a return statement, using the return value of the function call is undefined behavior. (See undefined behavior 86 .)","md",{"tags":2270},[2271,2272,2273,2274,2275,2276,2277,2278,2279],"in-cpp","ptc","review-dms","review-rcs","review","msc","review-ajb","rule","android-applicable","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc37-c",{"title":30,"description":2267},"4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F5.msc37-c","MHIo3jKg4H3AATgEpEY2QO9Xe9a5ejNVXWYbfumloVk",[2285,2288],{"title":2286,"path":2227,"stem":2287,"children":-1},"MSC33-C. Do not pass invalid data to the asctime() function","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F4.msc33-c",{"title":2289,"path":2241,"stem":2290,"children":-1},"MSC38-C. Do not treat a predefined identifier as an object if it might only be implemented as a macro","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F6.msc38-c",[2292],{"title":2293,"path":2294,"stem":2295,"children":2296},"SEI CERT C Coding Standard","\u002Fsei-cert-c-coding-standard","4.sei-cert-c-coding-standard\u002F01.index",[2297,2298,2370,2951,3218,3232,3236,3240,3244,4053],{"title":2293,"path":2294,"stem":2295},{"title":2299,"path":2300,"stem":2301,"children":2302},"Front Matter","\u002Fsei-cert-c-coding-standard\u002Ffront-matter","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F1.index",[2303,2304],{"title":2299,"path":2300,"stem":2301},{"title":2305,"path":2306,"stem":2307,"children":2308},"Introduction","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[2309,2310,2314,2318,2322,2326,2330,2334,2338,2342,2346,2350,2354,2358,2362,2366],{"title":2305,"path":2306,"stem":2307},{"title":2311,"path":2312,"stem":2313},"Scope","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.scope",{"title":2315,"path":2316,"stem":2317},"Audience","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F02.audience",{"title":2319,"path":2320,"stem":2321},"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":2323,"path":2324,"stem":2325},"History","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhistory","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F04.history",{"title":2327,"path":2328,"stem":2329},"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":2331,"path":2332,"stem":2333},"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":2335,"path":2336,"stem":2337},"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":2339,"path":2340,"stem":2341},"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":2343,"path":2344,"stem":2345},"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":2347,"path":2348,"stem":2349},"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":2351,"path":2352,"stem":2353},"Usage","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F11.usage",{"title":2355,"path":2356,"stem":2357},"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":2359,"path":2360,"stem":2361},"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":2363,"path":2364,"stem":2365},"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":2367,"path":2368,"stem":2369},"Acknowledgments","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F15.acknowledgments",{"title":2371,"path":2372,"stem":2373,"children":2374},"Rules","\u002Fsei-cert-c-coding-standard\u002Frules","4.sei-cert-c-coding-standard\u002F03.rules\u002F01.index",[2375,2376,2380,2410,2440,2502,2540,2566,2588,2654,2680,2738,2772,2802,2812,2841,2911,2929],{"title":2371,"path":2372,"stem":2373},{"title":2377,"path":2378,"stem":2379},"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":2381,"path":2382,"stem":2383,"children":2384},"Arrays (ARR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F1.index",[2385,2386,2390,2394,2398,2402,2406],{"title":2381,"path":2382,"stem":2383},{"title":2387,"path":2388,"stem":2389},"ARR30-C. Do not form or use out-of-bounds pointers or array subscripts","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F2.arr30-c",{"title":2391,"path":2392,"stem":2393},"ARR32-C. Ensure size arguments for variable length arrays are in a valid range","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F3.arr32-c",{"title":2395,"path":2396,"stem":2397},"ARR36-C. Do not subtract or compare two pointers that do not refer to the same array","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F4.arr36-c",{"title":2399,"path":2400,"stem":2401},"ARR37-C. Do not add or subtract an integer to a pointer to a non-array object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F5.arr37-c",{"title":2403,"path":2404,"stem":2405},"ARR38-C. Guarantee that library functions do not form invalid pointers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F6.arr38-c",{"title":2407,"path":2408,"stem":2409},"ARR39-C. Do not add or subtract a scaled integer to a pointer","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F7.arr39-c",{"title":2411,"path":2412,"stem":2413,"children":2414},"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",[2415,2416,2420,2424,2428,2432,2436],{"title":2411,"path":2412,"stem":2413},{"title":2417,"path":2418,"stem":2419},"STR30-C. Do not attempt to modify string literals","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F2.str30-c",{"title":2421,"path":2422,"stem":2423},"STR31-C. Guarantee that storage for strings has sufficient space for character data and the null terminator","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F3.str31-c",{"title":2425,"path":2426,"stem":2427},"STR32-C. Do not pass a non-null-terminated character sequence to a library function that expects a string","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F4.str32-c",{"title":2429,"path":2430,"stem":2431},"STR34-C. Cast characters to unsigned char before converting to larger integer sizes","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F5.str34-c",{"title":2433,"path":2434,"stem":2435},"STR37-C. Arguments to character-handling functions must be representable as an unsigned char","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F6.str37-c",{"title":2437,"path":2438,"stem":2439},"STR38-C. Do not confuse narrow and wide character strings and functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F7.str38-c",{"title":2441,"path":2442,"stem":2443,"children":2444},"Concurrency (CON)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F01.index",[2445,2446,2450,2454,2458,2462,2466,2470,2474,2478,2482,2486,2490,2494,2498],{"title":2441,"path":2442,"stem":2443},{"title":2447,"path":2448,"stem":2449},"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":2451,"path":2452,"stem":2453},"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":2455,"path":2456,"stem":2457},"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":2459,"path":2460,"stem":2461},"CON33-C. Avoid race conditions when using library functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F05.con33-c",{"title":2463,"path":2464,"stem":2465},"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":2467,"path":2468,"stem":2469},"CON35-C. Avoid deadlock by locking in a predefined order","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F07.con35-c",{"title":2471,"path":2472,"stem":2473},"CON36-C. Wrap functions that can spuriously wake up in a loop","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F08.con36-c",{"title":2475,"path":2476,"stem":2477},"CON37-C. Do not call signal() in a multithreaded program","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F09.con37-c",{"title":2479,"path":2480,"stem":2481},"CON38-C. Preserve thread safety and liveness when using condition variables","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F10.con38-c",{"title":2483,"path":2484,"stem":2485},"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":2487,"path":2488,"stem":2489},"CON40-C. Do not refer to an atomic variable twice in an expression","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F12.con40-c",{"title":2491,"path":2492,"stem":2493},"CON41-C. Wrap functions that can fail spuriously in a loop","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F13.con41-c",{"title":2495,"path":2496,"stem":2497},"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":2499,"path":2500,"stem":2501},"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":2503,"path":2504,"stem":2505,"children":2506},"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",[2507,2508,2512,2516,2520,2524,2528,2532,2536],{"title":2503,"path":2504,"stem":2505},{"title":2509,"path":2510,"stem":2511},"DCL30-C. Declare objects with appropriate storage durations","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F2.dcl30-c",{"title":2513,"path":2514,"stem":2515},"DCL31-C. Declare identifiers before using them","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F3.dcl31-c",{"title":2517,"path":2518,"stem":2519},"DCL36-C. Do not declare an identifier with conflicting linkage classifications","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F4.dcl36-c",{"title":2521,"path":2522,"stem":2523},"DCL37-C. Do not declare or define a reserved identifier","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F5.dcl37-c",{"title":2525,"path":2526,"stem":2527},"DCL38-C. Use the correct syntax when declaring a flexible array member","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F6.dcl38-c",{"title":2529,"path":2530,"stem":2531},"DCL39-C. Avoid information leakage when passing a structure across a trust boundary","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F7.dcl39-c",{"title":2533,"path":2534,"stem":2535},"DCL40-C. Do not create incompatible declarations of the same function or object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F8.dcl40-c",{"title":2537,"path":2538,"stem":2539},"DCL41-C. Do not declare variables inside a switch statement before the first case label","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F9.dcl41-c",{"title":2541,"path":2542,"stem":2543,"children":2544},"Environment (ENV)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F1.index",[2545,2546,2550,2554,2558,2562],{"title":2541,"path":2542,"stem":2543},{"title":2547,"path":2548,"stem":2549},"ENV30-C. Do not modify the object referenced by the return value of certain functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F2.env30-c",{"title":2551,"path":2552,"stem":2553},"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":2555,"path":2556,"stem":2557},"ENV32-C. All exit handlers must return normally","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F4.env32-c",{"title":2559,"path":2560,"stem":2561},"ENV33-C. Do not call system()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F5.env33-c",{"title":2563,"path":2564,"stem":2565},"ENV34-C. Do not store pointers returned by certain functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F6.env34-c",{"title":2567,"path":2568,"stem":2569,"children":2570},"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",[2571,2572,2576,2580,2584],{"title":2567,"path":2568,"stem":2569},{"title":2573,"path":2574,"stem":2575},"ERR30-C. Take care when reading errno","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F2.err30-c",{"title":2577,"path":2578,"stem":2579},"ERR32-C. Do not rely on indeterminate values of errno","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F3.err32-c",{"title":2581,"path":2582,"stem":2583},"ERR33-C. Detect and handle standard library errors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F4.err33-c",{"title":2585,"path":2586,"stem":2587},"ERR34-C. Detect errors when converting a string to a number","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F5.err34-c",{"title":2589,"path":2590,"stem":2591,"children":2592},"Expressions (EXP)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F01.index",[2593,2594,2598,2602,2606,2610,2614,2618,2622,2626,2630,2634,2638,2642,2646,2650],{"title":2589,"path":2590,"stem":2591},{"title":2595,"path":2596,"stem":2597},"EXP30-C. Do not depend on the order of evaluation for side effects","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F02.exp30-c",{"title":2599,"path":2600,"stem":2601},"EXP32-C. Do not access a volatile object through a nonvolatile reference","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F03.exp32-c",{"title":2603,"path":2604,"stem":2605},"EXP33-C. Do not read uninitialized memory","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F04.exp33-c",{"title":2607,"path":2608,"stem":2609},"EXP34-C. Do not dereference null pointers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F05.exp34-c",{"title":2611,"path":2612,"stem":2613},"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":2615,"path":2616,"stem":2617},"EXP36-C. Do not cast pointers into more strictly aligned pointer types","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F07.exp36-c",{"title":2619,"path":2620,"stem":2621},"EXP37-C. Call functions with the correct number and type of arguments","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F08.exp37-c",{"title":2623,"path":2624,"stem":2625},"EXP39-C. Do not access a variable through a pointer of an incompatible type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F09.exp39-c",{"title":2627,"path":2628,"stem":2629},"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":2631,"path":2632,"stem":2633},"EXP42-C. Do not compare padding data","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp42-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F11.exp42-c",{"title":2635,"path":2636,"stem":2637},"EXP43-C. Avoid undefined behavior when using restrict-qualified pointers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp43-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F12.exp43-c",{"title":2639,"path":2640,"stem":2641},"EXP44-C. Do not rely on side effects in operands to sizeof, _Alignof, or _Generic","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F13.exp44-c",{"title":2643,"path":2644,"stem":2645},"EXP45-C. Do not perform assignments in selection statements","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp45-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F14.exp45-c",{"title":2647,"path":2648,"stem":2649},"EXP46-C. Do not use a bitwise operator with a Boolean-like operand","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp46-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F15.exp46-c",{"title":2651,"path":2652,"stem":2653},"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":2655,"path":2656,"stem":2657,"children":2658},"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",[2659,2660,2664,2668,2672,2676],{"title":2655,"path":2656,"stem":2657},{"title":2661,"path":2662,"stem":2663},"FLP30-C. Do not use floating-point variables as loop counters","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F2.flp30-c",{"title":2665,"path":2666,"stem":2667},"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":2669,"path":2670,"stem":2671},"FLP34-C. Ensure that floating-point conversions are within range of the new type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F4.flp34-c",{"title":2673,"path":2674,"stem":2675},"FLP36-C. Preserve precision when converting integral values to floating-point type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F5.flp36-c",{"title":2677,"path":2678,"stem":2679},"FLP37-C. Do not use object representations to compare floating-point values","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F6.flp37-c",{"title":2681,"path":2682,"stem":2683,"children":2684},"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",[2685,2686,2690,2694,2698,2702,2706,2710,2714,2718,2722,2726,2730,2734],{"title":2681,"path":2682,"stem":2683},{"title":2687,"path":2688,"stem":2689},"FIO30-C. Exclude user input from format strings","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F02.fio30-c",{"title":2691,"path":2692,"stem":2693},"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":2695,"path":2696,"stem":2697},"FIO34-C. Distinguish between characters read from a file and EOF or WEOF","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F04.fio34-c",{"title":2699,"path":2700,"stem":2701},"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":2703,"path":2704,"stem":2705},"FIO38-C. Do not copy a FILE object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F06.fio38-c",{"title":2707,"path":2708,"stem":2709},"FIO39-C. Do not alternately input and output from a stream without an intervening flush or positioning call","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F07.fio39-c",{"title":2711,"path":2712,"stem":2713},"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":2715,"path":2716,"stem":2717},"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":2719,"path":2720,"stem":2721},"FIO42-C. Close files when they are no longer needed","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio42-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F10.fio42-c",{"title":2723,"path":2724,"stem":2725},"FIO44-C. Only use values for fsetpos() that are returned from fgetpos()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F11.fio44-c",{"title":2727,"path":2728,"stem":2729},"FIO45-C. Avoid TOCTOU race conditions while accessing files","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio45-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F12.fio45-c",{"title":2731,"path":2732,"stem":2733},"FIO46-C. Do not access a closed file","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio46-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F13.fio46-c",{"title":2735,"path":2736,"stem":2737},"FIO47-C. Use valid format strings","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio47-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F14.fio47-c",{"title":2739,"path":2740,"stem":2741,"children":2742},"Integers (INT)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F1.index",[2743,2744,2748,2752,2756,2760,2764,2768],{"title":2739,"path":2740,"stem":2741},{"title":2745,"path":2746,"stem":2747},"INT30-C. Ensure that unsigned integer operations do not wrap","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F2.int30-c",{"title":2749,"path":2750,"stem":2751},"INT31-C. Ensure that integer conversions do not result in lost or misinterpreted data","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F3.int31-c",{"title":2753,"path":2754,"stem":2755},"INT32-C. Ensure that operations on signed integers do not result in overflow","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F4.int32-c",{"title":2757,"path":2758,"stem":2759},"INT33-C. Ensure that division and remainder operations do not result in divide-by-zero errors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F5.int33-c",{"title":2761,"path":2762,"stem":2763},"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","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F6.int34-c",{"title":2765,"path":2766,"stem":2767},"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":2769,"path":2770,"stem":2771},"INT36-C. Converting a pointer to integer or integer to pointer","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F8.int36-c",{"title":2773,"path":2774,"stem":2775,"children":2776},"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",[2777,2778,2782,2786,2790,2794,2798],{"title":2773,"path":2774,"stem":2775},{"title":2779,"path":2780,"stem":2781},"MEM30-C. Do not access freed memory","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F2.mem30-c",{"title":2783,"path":2784,"stem":2785},"MEM31-C. Free dynamically allocated memory when no longer needed","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F3.mem31-c",{"title":2787,"path":2788,"stem":2789},"MEM33-C. Allocate and copy structures containing a flexible array member dynamically","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F4.mem33-c",{"title":2791,"path":2792,"stem":2793},"MEM34-C. Only free memory allocated dynamically","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F5.mem34-c",{"title":2795,"path":2796,"stem":2797},"MEM35-C. Allocate sufficient memory for an object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F6.mem35-c",{"title":2799,"path":2800,"stem":2801},"MEM36-C. Do not modify the alignment of objects by calling realloc()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F7.mem36-c",{"title":2803,"path":2804,"stem":2805,"children":2806},"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",[2807,2808],{"title":2803,"path":2804,"stem":2805},{"title":2809,"path":2810,"stem":2811},"WIN30-C. Properly pair allocation and deallocation functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmicrosoft-windows-win\u002Fwin30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F14.microsoft-windows-win\u002F2.win30-c",{"title":2813,"path":2814,"stem":2815,"children":2816},"Miscellaneous (MSC)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F1.index",[2817,2818,2822,2826,2827,2828,2829,2833,2837],{"title":2813,"path":2814,"stem":2815},{"title":2819,"path":2820,"stem":2821},"MSC30-C. Do not use the rand() function for generating pseudorandom numbers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F2.msc30-c",{"title":2823,"path":2824,"stem":2825},"MSC32-C. Properly seed pseudorandom number generators","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F3.msc32-c",{"title":2286,"path":2227,"stem":2287},{"title":30,"path":2280,"stem":2282},{"title":2289,"path":2241,"stem":2290},{"title":2830,"path":2831,"stem":2832},"MSC39-C. Do not call va_arg() on a va_list that has an indeterminate value","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F7.msc39-c",{"title":2834,"path":2835,"stem":2836},"MSC40-C. Do not violate constraints","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F8.msc40-c",{"title":2838,"path":2839,"stem":2840},"MSC41-C. Never hard code sensitive information","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F9.msc41-c",{"title":2842,"path":2843,"stem":2844,"children":2845},"POSIX (POS)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F01.index",[2846,2847,2851,2855,2859,2863,2867,2871,2875,2879,2883,2887,2891,2895,2899,2903,2907],{"title":2842,"path":2843,"stem":2844},{"title":2848,"path":2849,"stem":2850},"POS30-C. Use the readlink() function properly","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F02.pos30-c",{"title":2852,"path":2853,"stem":2854},"POS34-C. Do not call putenv() with a pointer to an automatic variable as the argument","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F03.pos34-c",{"title":2856,"path":2857,"stem":2858},"POS35-C. Avoid race conditions while checking for the existence of a symbolic link","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F04.pos35-c",{"title":2860,"path":2861,"stem":2862},"POS36-C. Observe correct revocation order while relinquishing privileges","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F05.pos36-c",{"title":2864,"path":2865,"stem":2866},"POS37-C. Ensure that privilege relinquishment is successful","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F06.pos37-c",{"title":2868,"path":2869,"stem":2870},"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":2872,"path":2873,"stem":2874},"POS39-C. Use the correct byte ordering when transferring data between systems","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F08.pos39-c",{"title":2876,"path":2877,"stem":2878},"POS44-C. Do not use signals to terminate threads","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F09.pos44-c",{"title":2880,"path":2881,"stem":2882},"POS47-C. Do not use threads that can be canceled asynchronously","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos47-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F10.pos47-c",{"title":2884,"path":2885,"stem":2886},"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":2888,"path":2889,"stem":2890},"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":2892,"path":2893,"stem":2894},"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":2896,"path":2897,"stem":2898},"POS51-C. Avoid deadlock with POSIX threads by locking in predefined order","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos51-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F14.pos51-c",{"title":2900,"path":2901,"stem":2902},"POS52-C. Do not perform operations that can block while holding a POSIX lock","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos52-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F15.pos52-c",{"title":2904,"path":2905,"stem":2906},"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":2908,"path":2909,"stem":2910},"POS54-C. Detect and handle POSIX library errors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos54-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F17.pos54-c",{"title":2912,"path":2913,"stem":2914,"children":2915},"Preprocessor (PRE)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F1.index",[2916,2917,2921,2925],{"title":2912,"path":2913,"stem":2914},{"title":2918,"path":2919,"stem":2920},"PRE30-C. Do not create a universal character name through concatenation","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F2.pre30-c",{"title":2922,"path":2923,"stem":2924},"PRE31-C. Avoid side effects in arguments to unsafe macros","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F3.pre31-c",{"title":2926,"path":2927,"stem":2928},"PRE32-C. Do not use preprocessor directives in invocations of function-like macros","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F4.pre32-c",{"title":2930,"path":2931,"stem":2932,"children":2933},"Signals (SIG)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F1.index",[2934,2935,2939,2943,2947],{"title":2930,"path":2931,"stem":2932},{"title":2936,"path":2937,"stem":2938},"SIG30-C. Call only asynchronous-safe functions within signal handlers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F2.sig30-c",{"title":2940,"path":2941,"stem":2942},"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":2944,"path":2945,"stem":2946},"SIG34-C. Do not call signal() from within interruptible signal handlers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F4.sig34-c",{"title":2948,"path":2949,"stem":2950},"SIG35-C. Do not return from a computational exception signal handler","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F5.sig35-c",{"title":2952,"path":2953,"stem":2954,"children":2955},"Back Matter","\u002Fsei-cert-c-coding-standard\u002Fback-matter","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F1.index",[2956,2957,2961,2965,2969,2973,3157,3214],{"title":2952,"path":2953,"stem":2954},{"title":2958,"path":2959,"stem":2960},"AA. Bibliography","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F2.aa-bibliography",{"title":2962,"path":2963,"stem":2964},"BB. Definitions","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F3.bb-definitions",{"title":2966,"path":2967,"stem":2968},"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":2970,"path":2971,"stem":2972},"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":2974,"path":2975,"stem":2976,"children":2977},"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",[2978,2979,2981,2985,2987,2991,2995,2999,3003,3007,3011,3015,3019,3021,3025,3027,3031,3033,3035,3039,3043,3047,3051,3055,3059,3063,3067,3069,3073,3075,3079,3082,3086,3089,3093,3095,3099,3101,3105,3109,3113,3117,3121,3125,3127,3131,3133,3137,3139,3143,3147,3151,3153],{"title":2974,"path":2975,"stem":2976},{"title":1689,"path":1688,"stem":2980},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F02.astree",{"title":2982,"path":2983,"stem":2984},"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":1715,"path":1714,"stem":2986},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F04.axivion-bauhaus-suite",{"title":2988,"path":2989,"stem":2990},"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":2992,"path":2993,"stem":2994},"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":2996,"path":2997,"stem":2998},"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":3000,"path":3001,"stem":3002},"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":3004,"path":3005,"stem":3006},"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":3008,"path":3009,"stem":3010},"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":3012,"path":3013,"stem":3014},"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":3016,"path":3017,"stem":3018},"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":1742,"path":1741,"stem":3020},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F13.codesonar",{"title":3022,"path":3023,"stem":3024},"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":1765,"path":1764,"stem":3026},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F15.coverity",{"title":3028,"path":3029,"stem":3030},"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":1791,"path":1790,"stem":3032},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F17.cppcheck",{"title":1817,"path":1816,"stem":3034},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F18.cppcheck-premium",{"title":3036,"path":3037,"stem":3038},"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":3040,"path":3041,"stem":3042},"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":3044,"path":3045,"stem":3046},"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":3048,"path":3049,"stem":3050},"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":3052,"path":3053,"stem":3054},"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":3056,"path":3057,"stem":3058},"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":3060,"path":3061,"stem":3062},"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":3064,"path":3065,"stem":3066},"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":1842,"path":1841,"stem":3068},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F27.helix-qac",{"title":3070,"path":3071,"stem":3072},"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":1875,"path":1874,"stem":3074},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F29.klocwork",{"title":3076,"path":3077,"stem":3078},"Klocwork_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fklocwork_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F30.klocwork_v",{"title":3080,"path":1902,"stem":3081},"LDRA","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F31.ldra",{"title":3083,"path":3084,"stem":3085},"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":3087,"path":1925,"stem":3088},"Parasoft","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F33.parasoft",{"title":3090,"path":3091,"stem":3092},"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":1950,"path":1949,"stem":3094},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F35.pc-lint-plus",{"title":3096,"path":3097,"stem":3098},"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":1979,"path":1978,"stem":3100},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F37.polyspace-bug-finder",{"title":3102,"path":3103,"stem":3104},"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":3106,"path":3107,"stem":3108},"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":3110,"path":3111,"stem":3112},"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":3114,"path":3115,"stem":3116},"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":3118,"path":3119,"stem":3120},"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":3122,"path":3123,"stem":3124},"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":2009,"path":2008,"stem":3126},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F44.rulechecker",{"title":3128,"path":3129,"stem":3130},"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":2029,"path":2028,"stem":3132},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F46.security-reviewer-static-reviewer",{"title":3134,"path":3135,"stem":3136},"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":2053,"path":2052,"stem":3138},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F48.sonarqube-ccpp-plugin",{"title":3140,"path":3141,"stem":3142},"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":3144,"path":3145,"stem":3146},"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":3148,"path":3149,"stem":3150},"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":2082,"path":2081,"stem":3152},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F52.trustinsoft-analyzer",{"title":3154,"path":3155,"stem":3156},"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":3158,"path":3159,"stem":3160,"children":3161},"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",[3162,3163,3167,3171,3175,3179,3183,3187,3191,3195,3198,3202,3206,3210],{"title":3158,"path":3159,"stem":3160},{"title":3164,"path":3165,"stem":3166},"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":3168,"path":3169,"stem":3170},"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":3172,"path":3173,"stem":3174},"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":3176,"path":3177,"stem":3178},"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":3180,"path":3181,"stem":3182},"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":3184,"path":3185,"stem":3186},"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":3188,"path":3189,"stem":3190},"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":3192,"path":3193,"stem":3194},"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":3192,"path":3196,"stem":3197},"\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":3199,"path":3200,"stem":3201},"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":3203,"path":3204,"stem":3205},"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":3207,"path":3208,"stem":3209},"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":3211,"path":3212,"stem":3213},"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":3215,"path":3216,"stem":3217},"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":3219,"path":3220,"stem":3221,"children":3222},"Admin","\u002Fsei-cert-c-coding-standard\u002Fadmin","4.sei-cert-c-coding-standard\u002F05.admin\u002F1.index",[3223,3224,3228],{"title":3219,"path":3220,"stem":3221},{"title":3225,"path":3226,"stem":3227},"TODO List","\u002Fsei-cert-c-coding-standard\u002Fadmin\u002Ftodo-list","4.sei-cert-c-coding-standard\u002F05.admin\u002F2.todo-list",{"title":3229,"path":3230,"stem":3231},"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":3233,"path":3234,"stem":3235},"Coding Style Guidelines","\u002Fsei-cert-c-coding-standard\u002Fcoding-style-guidelines","4.sei-cert-c-coding-standard\u002F05.coding-style-guidelines",{"title":3237,"path":3238,"stem":3239},"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":3241,"path":3242,"stem":3243},"Wiki Contents","\u002Fsei-cert-c-coding-standard\u002Fwiki-contents","4.sei-cert-c-coding-standard\u002F06.wiki-contents",{"title":3245,"path":3246,"stem":3247,"children":3248},"Recommendations","\u002Fsei-cert-c-coding-standard\u002Frecommendations","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F01.index",[3249,3250,3291,3308,3353,3394,3491,3508,3539,3608,3645,3730,3795,3844,3869,3958,3979,4036],{"title":3245,"path":3246,"stem":3247},{"title":2377,"path":3251,"stem":3252,"children":3253},"\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",[3254,3255,3259,3263,3267,3271,3275,3279,3283,3287],{"title":2377,"path":3251,"stem":3252},{"title":3256,"path":3257,"stem":3258},"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":3260,"path":3261,"stem":3262},"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":3264,"path":3265,"stem":3266},"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":3268,"path":3269,"stem":3270},"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":3272,"path":3273,"stem":3274},"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":3276,"path":3277,"stem":3278},"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":3280,"path":3281,"stem":3282},"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":3284,"path":3285,"stem":3286},"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":3288,"path":3289,"stem":3290},"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":2381,"path":3292,"stem":3293,"children":3294},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F1.index",[3295,3296,3300,3304],{"title":2381,"path":3292,"stem":3293},{"title":3297,"path":3298,"stem":3299},"ARR00-C. Understand how arrays work","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F2.arr00-c",{"title":3301,"path":3302,"stem":3303},"ARR01-C. Do not apply the sizeof operator to a pointer when taking the size of an array","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F3.arr01-c",{"title":3305,"path":3306,"stem":3307},"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":2411,"path":3309,"stem":3310,"children":3311},"\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",[3312,3313,3317,3321,3325,3329,3333,3337,3341,3345,3349],{"title":2411,"path":3309,"stem":3310},{"title":3314,"path":3315,"stem":3316},"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":3318,"path":3319,"stem":3320},"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":3322,"path":3323,"stem":3324},"STR02-C. Sanitize data passed to complex subsystems","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F04.str02-c",{"title":3326,"path":3327,"stem":3328},"STR03-C. Do not inadvertently truncate a string","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F05.str03-c",{"title":3330,"path":3331,"stem":3332},"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":3334,"path":3335,"stem":3336},"STR05-C. Use pointers to const when referring to string literals","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F07.str05-c",{"title":3338,"path":3339,"stem":3340},"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":3342,"path":3343,"stem":3344},"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":3346,"path":3347,"stem":3348},"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":3350,"path":3351,"stem":3352},"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":2441,"path":3354,"stem":3355,"children":3356},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F01.index",[3357,3358,3362,3366,3370,3374,3378,3382,3386,3390],{"title":2441,"path":3354,"stem":3355},{"title":3359,"path":3360,"stem":3361},"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":3363,"path":3364,"stem":3365},"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":3367,"path":3368,"stem":3369},"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":3371,"path":3372,"stem":3373},"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":3375,"path":3376,"stem":3377},"CON05-C. Do not perform operations that can block while holding a lock","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F06.con05-c",{"title":3379,"path":3380,"stem":3381},"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":3383,"path":3384,"stem":3385},"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":3387,"path":3388,"stem":3389},"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":3391,"path":3392,"stem":3393},"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":2503,"path":3395,"stem":3396,"children":3397},"\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",[3398,3399,3403,3407,3411,3415,3419,3423,3427,3431,3435,3439,3443,3447,3451,3455,3459,3463,3467,3471,3475,3479,3483,3487],{"title":2503,"path":3395,"stem":3396},{"title":3400,"path":3401,"stem":3402},"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":3404,"path":3405,"stem":3406},"DCL01-C. Do not reuse variable names in subscopes","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F03.dcl01-c",{"title":3408,"path":3409,"stem":3410},"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":3412,"path":3413,"stem":3414},"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":3416,"path":3417,"stem":3418},"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":3420,"path":3421,"stem":3422},"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":3424,"path":3425,"stem":3426},"DCL06-C. Use meaningful symbolic constants to represent literal values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F08.dcl06-c",{"title":3428,"path":3429,"stem":3430},"DCL07-C. Include the appropriate type information in function declarators","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F09.dcl07-c",{"title":3432,"path":3433,"stem":3434},"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":3436,"path":3437,"stem":3438},"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":3440,"path":3441,"stem":3442},"DCL10-C. Maintain the contract between the writer and caller of variadic functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F12.dcl10-c",{"title":3444,"path":3445,"stem":3446},"DCL11-C. Understand the type issues associated with variadic functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F13.dcl11-c",{"title":3448,"path":3449,"stem":3450},"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":3452,"path":3453,"stem":3454},"DCL13-C. Declare function parameters that are pointers to values not changed by the function as const","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F15.dcl13-c",{"title":3456,"path":3457,"stem":3458},"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":3460,"path":3461,"stem":3462},"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":3464,"path":3465,"stem":3466},"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":3468,"path":3469,"stem":3470},"DCL18-C. Do not begin integer constants with 0 when specifying a decimal value","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F19.dcl18-c",{"title":3472,"path":3473,"stem":3474},"DCL19-C. Minimize the scope of variables and functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F20.dcl19-c",{"title":3476,"path":3477,"stem":3478},"DCL20-C. Explicitly specify void when a function accepts no arguments","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl20-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F21.dcl20-c",{"title":3480,"path":3481,"stem":3482},"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":3484,"path":3485,"stem":3486},"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":3488,"path":3489,"stem":3490},"DCL23-C. Guarantee that mutually visible identifiers are unique","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl23-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F24.dcl23-c",{"title":2541,"path":3492,"stem":3493,"children":3494},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F1.index",[3495,3496,3500,3504],{"title":2541,"path":3492,"stem":3493},{"title":3497,"path":3498,"stem":3499},"ENV01-C. Do not make assumptions about the size of an environment variable","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env\u002Fenv01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F2.env01-c",{"title":3501,"path":3502,"stem":3503},"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":3505,"path":3506,"stem":3507},"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":2567,"path":3509,"stem":3510,"children":3511},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F1.index",[3512,3513,3515,3519,3523,3527,3531,3535],{"title":2567,"path":3509,"stem":3510},{"title":1017,"path":1016,"stem":3514},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F2.err00-c",{"title":3516,"path":3517,"stem":3518},"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":3520,"path":3521,"stem":3522},"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":3524,"path":3525,"stem":3526},"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":3528,"path":3529,"stem":3530},"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":3532,"path":3533,"stem":3534},"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":3536,"path":3537,"stem":3538},"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":2589,"path":3540,"stem":3541,"children":3542},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F01.index",[3543,3544,3548,3552,3556,3560,3564,3568,3572,3576,3580,3584,3588,3592,3596,3600,3604],{"title":2589,"path":3540,"stem":3541},{"title":3545,"path":3546,"stem":3547},"EXP00-C. Use parentheses for precedence of operation","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F02.exp00-c",{"title":3549,"path":3550,"stem":3551},"EXP02-C. Be aware of the short-circuit behavior of the logical AND and OR operators","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F03.exp02-c",{"title":3553,"path":3554,"stem":3555},"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":3557,"path":3558,"stem":3559},"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":3561,"path":3562,"stem":3563},"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":3565,"path":3566,"stem":3567},"EXP08-C. Ensure pointer arithmetic is used correctly","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F07.exp08-c",{"title":3569,"path":3570,"stem":3571},"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":3573,"path":3574,"stem":3575},"EXP10-C. Do not depend on the order of evaluation of subexpressions or the order in which side effects take place","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F09.exp10-c",{"title":3577,"path":3578,"stem":3579},"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":3581,"path":3582,"stem":3583},"EXP12-C. Do not ignore values returned by functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F11.exp12-c",{"title":3585,"path":3586,"stem":3587},"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":3589,"path":3590,"stem":3591},"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":3593,"path":3594,"stem":3595},"EXP15-C. Do not place a semicolon on the same line as an if, for, or while statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F14.exp15-c",{"title":3597,"path":3598,"stem":3599},"EXP16-C. Do not compare function pointers to constant values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp16-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F15.exp16-c",{"title":3601,"path":3602,"stem":3603},"EXP19-C. Use braces for the body of an if, for, or while statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F16.exp19-c",{"title":3605,"path":3606,"stem":3607},"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":2655,"path":3609,"stem":3610,"children":3611},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F1.index",[3612,3613,3617,3621,3625,3629,3633,3637,3641],{"title":2655,"path":3609,"stem":3610},{"title":3614,"path":3615,"stem":3616},"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":3618,"path":3619,"stem":3620},"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":3622,"path":3623,"stem":3624},"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":3626,"path":3627,"stem":3628},"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":3630,"path":3631,"stem":3632},"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":3634,"path":3635,"stem":3636},"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":3638,"path":3639,"stem":3640},"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":3642,"path":3643,"stem":3644},"FLP07-C. Cast the return value of a function that returns a floating-point type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F9.flp07-c",{"title":2681,"path":3646,"stem":3647,"children":3648},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F01.index",[3649,3650,3654,3658,3662,3666,3670,3674,3678,3682,3686,3690,3694,3698,3702,3706,3710,3714,3718,3722,3726],{"title":2681,"path":3646,"stem":3647},{"title":3651,"path":3652,"stem":3653},"FIO01-C. Be careful using functions that use file names for identification","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F02.fio01-c",{"title":3655,"path":3656,"stem":3657},"FIO02-C. Canonicalize path names originating from tainted sources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F03.fio02-c",{"title":3659,"path":3660,"stem":3661},"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":3663,"path":3664,"stem":3665},"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":3667,"path":3668,"stem":3669},"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":3671,"path":3672,"stem":3673},"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":3675,"path":3676,"stem":3677},"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":3679,"path":3680,"stem":3681},"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":3683,"path":3684,"stem":3685},"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":3687,"path":3688,"stem":3689},"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":3691,"path":3692,"stem":3693},"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":3695,"path":3696,"stem":3697},"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":3699,"path":3700,"stem":3701},"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":3703,"path":3704,"stem":3705},"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":3707,"path":3708,"stem":3709},"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":3711,"path":3712,"stem":3713},"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":3715,"path":3716,"stem":3717},"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":3719,"path":3720,"stem":3721},"FIO22-C. Close files before spawning processes","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio22-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F19.fio22-c",{"title":3723,"path":3724,"stem":3725},"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":3727,"path":3728,"stem":3729},"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":2739,"path":3731,"stem":3732,"children":3733},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F01.index",[3734,3735,3739,3743,3747,3751,3755,3759,3763,3767,3771,3775,3779,3783,3787,3791],{"title":2739,"path":3731,"stem":3732},{"title":3736,"path":3737,"stem":3738},"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":3740,"path":3741,"stem":3742},"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":3744,"path":3745,"stem":3746},"INT04-C. Enforce limits on integer values originating from tainted sources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F05.int04-c",{"title":3748,"path":3749,"stem":3750},"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":3752,"path":3753,"stem":3754},"INT07-C. Use only explicitly signed or unsigned char type for numeric values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F07.int07-c",{"title":3756,"path":3757,"stem":3758},"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":3760,"path":3761,"stem":3762},"INT09-C. Ensure enumeration constants map to unique values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F09.int09-c",{"title":3764,"path":3765,"stem":3766},"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":3768,"path":3769,"stem":3770},"INT12-C. Do not make assumptions about the type of a plain int bit-field when used in an expression","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F11.int12-c",{"title":3772,"path":3773,"stem":3774},"INT13-C. Use bitwise operators only on unsigned operands","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F12.int13-c",{"title":3776,"path":3777,"stem":3778},"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":3780,"path":3781,"stem":3782},"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":3784,"path":3785,"stem":3786},"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":3788,"path":3789,"stem":3790},"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":3792,"path":3793,"stem":3794},"INT18-C. Evaluate integer expressions in a larger size before comparing or assigning to that size","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F17.int18-c",{"title":2773,"path":3796,"stem":3797,"children":3798},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F01.index",[3799,3800,3804,3808,3812,3816,3820,3824,3828,3832,3836,3840],{"title":2773,"path":3796,"stem":3797},{"title":3801,"path":3802,"stem":3803},"MEM00-C. Allocate and free memory in the same module, at the same level of abstraction","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F02.mem00-c",{"title":3805,"path":3806,"stem":3807},"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":3809,"path":3810,"stem":3811},"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":3813,"path":3814,"stem":3815},"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":3817,"path":3818,"stem":3819},"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":3821,"path":3822,"stem":3823},"MEM05-C. Avoid large stack allocations","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F07.mem05-c",{"title":3825,"path":3826,"stem":3827},"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":3829,"path":3830,"stem":3831},"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":3833,"path":3834,"stem":3835},"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":3837,"path":3838,"stem":3839},"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":3841,"path":3842,"stem":3843},"MEM12-C. Consider using a goto chain when leaving a function on error when using and releasing resources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F12.mem12-c",{"title":2803,"path":3845,"stem":3846,"children":3847},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F1.index",[3848,3849,3853,3857,3861,3865],{"title":2803,"path":3845,"stem":3846},{"title":3850,"path":3851,"stem":3852},"WIN00-C. Be specific when dynamically loading libraries","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F2.win00-c",{"title":3854,"path":3855,"stem":3856},"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":3858,"path":3859,"stem":3860},"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":3862,"path":3863,"stem":3864},"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":3866,"path":3867,"stem":3868},"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":2813,"path":3870,"stem":3871,"children":3872},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F01.index",[3873,3874,3876,3878,3882,3886,3890,3894,3898,3902,3906,3910,3914,3918,3922,3926,3930,3934,3938,3942,3946,3950,3954],{"title":2813,"path":3870,"stem":3871},{"title":289,"path":288,"stem":3875},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F02.msc00-c",{"title":2147,"path":2146,"stem":3877},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F03.msc01-c",{"title":3879,"path":3880,"stem":3881},"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":3883,"path":3884,"stem":3885},"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":3887,"path":3888,"stem":3889},"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":3891,"path":3892,"stem":3893},"MSC07-C. Detect and remove dead code","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F07.msc07-c",{"title":3895,"path":3896,"stem":3897},"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":3899,"path":3900,"stem":3901},"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":3903,"path":3904,"stem":3905},"MSC12-C. Detect and remove code that has no effect or is never executed","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F10.msc12-c",{"title":3907,"path":3908,"stem":3909},"MSC13-C. Detect and remove unused values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F11.msc13-c",{"title":3911,"path":3912,"stem":3913},"MSC14-C. Do not introduce unnecessary platform dependencies","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc14-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F12.msc14-c",{"title":3915,"path":3916,"stem":3917},"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":3919,"path":3920,"stem":3921},"MSC17-C. Finish every set of statements associated with a case label with a break statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F14.msc17-c",{"title":3923,"path":3924,"stem":3925},"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":3927,"path":3928,"stem":3929},"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":3931,"path":3932,"stem":3933},"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":3935,"path":3936,"stem":3937},"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":3939,"path":3940,"stem":3941},"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":3943,"path":3944,"stem":3945},"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":3947,"path":3948,"stem":3949},"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":3951,"path":3952,"stem":3953},"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":3955,"path":3956,"stem":3957},"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":2842,"path":3959,"stem":3960,"children":3961},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F1.index",[3962,3963,3967,3971,3975],{"title":2842,"path":3959,"stem":3960},{"title":3964,"path":3965,"stem":3966},"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":3968,"path":3969,"stem":3970},"POS02-C. Follow the principle of least privilege","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F3.pos02-c",{"title":3972,"path":3973,"stem":3974},"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":3976,"path":3977,"stem":3978},"POS05-C. Limit access to files by creating a jail","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F5.pos05-c",{"title":2912,"path":3980,"stem":3981,"children":3982},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F01.index",[3983,3984,3988,3992,3996,4000,4004,4008,4012,4016,4020,4024,4028,4032],{"title":2912,"path":3980,"stem":3981},{"title":3985,"path":3986,"stem":3987},"PRE00-C. Prefer inline or static functions to function-like macros","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F02.pre00-c",{"title":3989,"path":3990,"stem":3991},"PRE01-C. Use parentheses within macros around parameter names","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F03.pre01-c",{"title":3993,"path":3994,"stem":3995},"PRE02-C. Macro replacement lists should be parenthesized","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F04.pre02-c",{"title":3997,"path":3998,"stem":3999},"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":4001,"path":4002,"stem":4003},"PRE05-C. Understand macro replacement when concatenating tokens or performing stringification","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F06.pre05-c",{"title":4005,"path":4006,"stem":4007},"PRE06-C. Enclose header files in an include guard","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F07.pre06-c",{"title":4009,"path":4010,"stem":4011},"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":4013,"path":4014,"stem":4015},"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":4017,"path":4018,"stem":4019},"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":4021,"path":4022,"stem":4023},"PRE10-C. Wrap multistatement macros in a do-while loop","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F11.pre10-c",{"title":4025,"path":4026,"stem":4027},"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":4029,"path":4030,"stem":4031},"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":4033,"path":4034,"stem":4035},"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":2930,"path":4037,"stem":4038,"children":4039},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F1.index",[4040,4041,4045,4049],{"title":2930,"path":4037,"stem":4038},{"title":4042,"path":4043,"stem":4044},"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":4046,"path":4047,"stem":4048},"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":4050,"path":4051,"stem":4052},"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":4054,"path":4055,"stem":4056},"CERT manifest files","\u002Fsei-cert-c-coding-standard\u002Fcert-manifest-files","4.sei-cert-c-coding-standard\u002F09.cert-manifest-files",1775657800427]