[{"data":1,"prerenderedAt":3896},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre13-c":28,"surround-\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre13-c":2097,"sidebar-sei-cert-c-coding-standard":2105},[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":2085,"extension":2086,"meta":2087,"navigation":7,"path":2093,"seo":2094,"stem":2095,"__hash__":2096},"content\u002F4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F14.pre13-c.md","PRE13-C. Use the Standard predefined macros to test for versions and features.",{"type":32,"value":33,"toc":2072},"minimark",[34,38,53,56,260,265,268,394,397,627,630,675,680,683,836,840,846,989,993,1000,1243,1247,1260,1516,1519,1546,1766,1770,1780,1841,1846,1848,1982,1986,1999,2003,2044,2047,2068],[35,36,30],"h1",{"id":37},"pre13-c-use-the-standard-predefined-macros-to-test-for-versions-and-features",[39,40,41,42,47,48,52],"p",{},"The C S tandard defines a set of predefined macros (see subclause 6.10.8) to help the user determine if the ",[43,44,46],"a",{"href":45},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-implementation","implementation"," being used is a ",[43,49,51],{"href":50},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-conforming","conforming"," implementation, and if so, to which version of the C Standard it conforms. These macros can also help the user to determine which of the standard features are implemented.",[39,54,55],{},"The following tables list these macros and indicate in which version of the C Standard they were introduced. The following macros are required:",[57,58,62,75],"table",{"className":59,"style":61},[60],"wrapped","margin-left: 30.0px;",[63,64,65,69,71,73],"colgroup",{},[66,67],"col",{"style":68},"width: 25%",[66,70],{"style":68},[66,72],{"style":68},[66,74],{"style":68},[76,77,78,96,122,148,172,194,216,238],"tbody",{},[79,80,83,87,90,93],"tr",{"className":81},[82],"header",[84,85,86],"th",{},"Macro Name",[84,88,89],{},"C90",[84,91,92],{},"C99",[84,94,95],{},"C11",[79,97,100,109,114,118],{"className":98},[99],"odd",[101,102,103],"td",{},[39,104,105],{},[106,107,108],"code",{},"       __STDC__      ",[101,110,111],{},[39,112,113],{},"✓",[101,115,116],{},[39,117,113],{},[101,119,120],{},[39,121,113],{},[79,123,126,133,140,144],{"className":124},[125],"even",[101,127,128],{},[39,129,130],{},[106,131,132],{},"       __STDC_HOSTED__      ",[101,134,135],{},[39,136,137],{},[138,139],"br",{},[101,141,142],{},[39,143,113],{},[101,145,146],{},[39,147,113],{},[79,149,151,158,164,168],{"className":150},[99],[101,152,153],{},[39,154,155],{},[106,156,157],{},"       __STDC_VERSION__               1             ",[101,159,160],{},[39,161,162],{},[138,163],{},[101,165,166],{},[39,167,113],{},[101,169,170],{},[39,171,113],{},[79,173,175,182,186,190],{"className":174},[125],[101,176,177],{},[39,178,179],{},[106,180,181],{},"       __DATE__      ",[101,183,184],{},[39,185,113],{},[101,187,188],{},[39,189,113],{},[101,191,192],{},[39,193,113],{},[79,195,197,204,208,212],{"className":196},[99],[101,198,199],{},[39,200,201],{},[106,202,203],{},"       __FILE__      ",[101,205,206],{},[39,207,113],{},[101,209,210],{},[39,211,113],{},[101,213,214],{},[39,215,113],{},[79,217,219,226,230,234],{"className":218},[125],[101,220,221],{},[39,222,223],{},[106,224,225],{},"       __LINE__      ",[101,227,228],{},[39,229,113],{},[101,231,232],{},[39,233,113],{},[101,235,236],{},[39,237,113],{},[79,239,241,248,252,256],{"className":240},[99],[101,242,243],{},[39,244,245],{},[106,246,247],{},"       __TIME__      ",[101,249,250],{},[39,251,113],{},[101,253,254],{},[39,255,113],{},[101,257,258],{},[39,259,113],{},[261,262,264],"h6",{"id":263},"_1-__stdc_version__-was-introduced-by-an-amendment-to-c90-this-version-of-the-c-standard-is-commonly-call-c94","1) __STDC_VERSION__ was introduced by an Amendment to C90, this version of the C Standard is commonly call C94",[39,266,267],{},"The following are optional environment macros:",[57,269,271,281],{"className":270,"style":61},[60],[63,272,273,275,277,279],{},[66,274],{"style":68},[66,276],{"style":68},[66,278],{"style":68},[66,280],{"style":68},[76,282,283,294,318,342,368],{},[79,284,286,288,290,292],{"className":285},[82],[84,287,86],{},[84,289,89],{},[84,291,92],{},[84,293,95],{},[79,295,297,304,310,314],{"className":296},[99],[101,298,299],{},[39,300,301],{},[106,302,303],{},"       __STDC_ISO_10646__      ",[101,305,306],{},[39,307,308],{},[138,309],{},[101,311,312],{},[39,313,113],{},[101,315,316],{},[39,317,113],{},[79,319,321,328,334,338],{"className":320},[125],[101,322,323],{},[39,324,325],{},[106,326,327],{},"       __STDC_MB_MIGHT_NEQ_WC__      ",[101,329,330],{},[39,331,332],{},[138,333],{},[101,335,336],{},[39,337,113],{},[101,339,340],{},[39,341,113],{},[79,343,345,352,358,364],{"className":344},[99],[101,346,347],{},[39,348,349],{},[106,350,351],{},"       __STDC_UTF_16__      ",[101,353,354],{},[39,355,356],{},[138,357],{},[101,359,360],{},[39,361,362],{},[138,363],{},[101,365,366],{},[39,367,113],{},[79,369,371,378,384,390],{"className":370},[125],[101,372,373],{},[39,374,375],{},[106,376,377],{},"       __STDC_UTF_32__      ",[101,379,380],{},[39,381,382],{},[138,383],{},[101,385,386],{},[39,387,388],{},[138,389],{},[101,391,392],{},[39,393,113],{},[39,395,396],{},"The following are optional feature macros:",[57,398,400,410],{"className":399,"style":61},[60],[63,401,402,404,406,408],{},[66,403],{"style":68},[66,405],{"style":68},[66,407],{"style":68},[66,409],{"style":68},[76,411,412,423,449,473,497,523,549,575,601],{},[79,413,415,417,419,421],{"className":414},[82],[84,416,86],{},[84,418,89],{},[84,420,92],{},[84,422,95],{},[79,424,426,433,439,445],{"className":425},[99],[101,427,428],{},[39,429,430],{},[106,431,432],{},"       __STDC_ANALYZABLE__      ",[101,434,435],{},[39,436,437],{},[138,438],{},[101,440,441],{},[39,442,443],{},[138,444],{},[101,446,447],{},[39,448,113],{},[79,450,452,459,465,469],{"className":451},[125],[101,453,454],{},[39,455,456],{},[106,457,458],{},"       __STDC_IEC_559__      ",[101,460,461],{},[39,462,463],{},[138,464],{},[101,466,467],{},[39,468,113],{},[101,470,471],{},[39,472,113],{},[79,474,476,483,489,493],{"className":475},[99],[101,477,478],{},[39,479,480],{},[106,481,482],{},"       __STDC_IEC_559_COMPLEX__      ",[101,484,485],{},[39,486,487],{},[138,488],{},[101,490,491],{},[39,492,113],{},[101,494,495],{},[39,496,113],{},[79,498,500,507,513,519],{"className":499},[125],[101,501,502],{},[39,503,504],{},[106,505,506],{},"       __STDC_LIB_EXT1__      ",[101,508,509],{},[39,510,511],{},[138,512],{},[101,514,515],{},[39,516,517],{},[138,518],{},[101,520,521],{},[39,522,113],{},[79,524,526,533,539,545],{"className":525},[99],[101,527,528],{},[39,529,530],{},[106,531,532],{},"       __STDC_NO_ATOMICS__      ",[101,534,535],{},[39,536,537],{},[138,538],{},[101,540,541],{},[39,542,543],{},[138,544],{},[101,546,547],{},[39,548,113],{},[79,550,552,559,565,571],{"className":551},[125],[101,553,554],{},[39,555,556],{},[106,557,558],{},"       __STDC_NO_COMPLEX__      ",[101,560,561],{},[39,562,563],{},[138,564],{},[101,566,567],{},[39,568,569],{},[138,570],{},[101,572,573],{},[39,574,113],{},[79,576,578,585,591,597],{"className":577},[99],[101,579,580],{},[39,581,582],{},[106,583,584],{},"       __STDC_NO_THREADS__      ",[101,586,587],{},[39,588,589],{},[138,590],{},[101,592,593],{},[39,594,595],{},[138,596],{},[101,598,599],{},[39,600,113],{},[79,602,604,611,617,623],{"className":603},[125],[101,605,606],{},[39,607,608],{},[106,609,610],{},"       __STDC_NO_VLA__      ",[101,612,613],{},[39,614,615],{},[138,616],{},[101,618,619],{},[39,620,621],{},[138,622],{},[101,624,625],{},[39,626,113],{},[39,628,629],{},"The following is optional and is defined by the user:",[57,631,633,643],{"className":632,"style":61},[60],[63,634,635,637,639,641],{},[66,636],{"style":68},[66,638],{"style":68},[66,640],{"style":68},[66,642],{"style":68},[76,644,645,656],{"style":61},[79,646,648,650,652,654],{"className":647,"style":61},[82],[84,649,86],{},[84,651,89],{},[84,653,92],{},[84,655,95],{},[79,657,659,664,668,672],{"className":658,"style":61},[99],[101,660,661],{},[106,662,663],{},"      __STDC_WANT_LIB_EXT1__     ",[101,665,666],{},[138,667],{},[101,669,670],{},[138,671],{},[101,673,113],{"style":674},"text-align: center;",[676,677,679],"h2",{"id":678},"noncompliant-code-example-checking-value-of-predefined-macro","Noncompliant Code Example (Checking Value of Predefined Macro)",[39,681,682],{},"C Standard predefined macros should never be tested for a value before the macro is tested for definition, as shown in this noncompliant code example:",[684,685,687],"code-block",{"quality":686},"bad",[688,689,694],"pre",{"className":690,"code":691,"language":692,"meta":693,"style":693},"language-c shiki shiki-themes github-light github-dark monokai","#include \u003Cstdio.h>\n\nint main(void) {\n  #if (__STDC__ == 1)\n    printf(\"Implementation is ISO-conforming.\\n\");\n  #else\n    printf(\"Implementation is not ISO-conforming.\\n\");\n  #endif\n  \u002F* ... *\u002F\n\n  return 0;\n}\n","c","",[106,695,696,709,715,736,758,778,784,800,806,813,818,830],{"__ignoreMap":693},[697,698,701,705],"span",{"class":699,"line":700},"line",1,[697,702,704],{"class":703},"sC2Qs","#include",[697,706,708],{"class":707},"sstjo"," \u003Cstdio.h>\n",[697,710,712],{"class":699,"line":711},2,[697,713,714],{"emptyLinePlaceholder":7},"\n",[697,716,718,722,726,730,733],{"class":699,"line":717},3,[697,719,721],{"class":720},"sq6CD","int",[697,723,725],{"class":724},"srTi1"," main",[697,727,729],{"class":728},"sMOD_","(",[697,731,732],{"class":720},"void",[697,734,735],{"class":728},") {\n",[697,737,739,742,745,748,751,755],{"class":699,"line":738},4,[697,740,741],{"class":703},"  #if",[697,743,744],{"class":728}," (",[697,746,747],{"class":724},"__STDC__",[697,749,750],{"class":703}," ==",[697,752,754],{"class":753},"s7F3e"," 1",[697,756,757],{"class":728},")\n",[697,759,761,764,766,769,772,775],{"class":699,"line":760},5,[697,762,763],{"class":724},"    printf",[697,765,729],{"class":728},[697,767,768],{"class":707},"\"Implementation is ISO-conforming.",[697,770,771],{"class":753},"\\n",[697,773,774],{"class":707},"\"",[697,776,777],{"class":728},");\n",[697,779,781],{"class":699,"line":780},6,[697,782,783],{"class":703},"  #else\n",[697,785,787,789,791,794,796,798],{"class":699,"line":786},7,[697,788,763],{"class":724},[697,790,729],{"class":728},[697,792,793],{"class":707},"\"Implementation is not ISO-conforming.",[697,795,771],{"class":753},[697,797,774],{"class":707},[697,799,777],{"class":728},[697,801,803],{"class":699,"line":802},8,[697,804,805],{"class":703},"  #endif\n",[697,807,809],{"class":699,"line":808},9,[697,810,812],{"class":811},"s8-w5","  \u002F* ... *\u002F\n",[697,814,816],{"class":699,"line":815},10,[697,817,714],{"emptyLinePlaceholder":7},[697,819,821,824,827],{"class":699,"line":820},11,[697,822,823],{"class":703},"  return",[697,825,826],{"class":753}," 0",[697,828,829],{"class":728},";\n",[697,831,833],{"class":699,"line":832},12,[697,834,835],{"class":728},"}\n",[676,837,839],{"id":838},"compliant-solution-testing-for-definition-of-macro","Compliant Solution (Testing for Definition of Macro)",[39,841,842,843,845],{},"In this compliant solution, the definition of the predefined macro ",[106,844,747],{}," is tested before the value of the macro is tested:",[684,847,849],{"quality":848},"good",[688,850,852],{"className":690,"code":851,"language":692,"meta":693,"style":693},"#include \u003Cstdio.h>\n\nint main(void) {\n  #if defined(__STDC__)\n    #if (__STDC__ == 1)\n      printf(\"Implementation is ISO-conforming.\\n\");\n    #else\n      printf(\"Implementation is not ISO-conforming.\\n\");\n    #endif\n  #else   \u002F* !defined(__STDC__) *\u002F\n    printf(\"__STDC__ is not defined.\\n\");\n  #endif\n  \u002F* ... *\u002F\n  return 0;\n}\n",[106,853,854,860,864,876,889,904,919,924,938,943,951,966,970,975,984],{"__ignoreMap":693},[697,855,856,858],{"class":699,"line":700},[697,857,704],{"class":703},[697,859,708],{"class":707},[697,861,862],{"class":699,"line":711},[697,863,714],{"emptyLinePlaceholder":7},[697,865,866,868,870,872,874],{"class":699,"line":717},[697,867,721],{"class":720},[697,869,725],{"class":724},[697,871,729],{"class":728},[697,873,732],{"class":720},[697,875,735],{"class":728},[697,877,878,880,883,885,887],{"class":699,"line":738},[697,879,741],{"class":703},[697,881,882],{"class":703}," defined",[697,884,729],{"class":728},[697,886,747],{"class":724},[697,888,757],{"class":728},[697,890,891,894,896,898,900,902],{"class":699,"line":760},[697,892,893],{"class":703},"    #if",[697,895,744],{"class":728},[697,897,747],{"class":724},[697,899,750],{"class":703},[697,901,754],{"class":753},[697,903,757],{"class":728},[697,905,906,909,911,913,915,917],{"class":699,"line":780},[697,907,908],{"class":724},"      printf",[697,910,729],{"class":728},[697,912,768],{"class":707},[697,914,771],{"class":753},[697,916,774],{"class":707},[697,918,777],{"class":728},[697,920,921],{"class":699,"line":786},[697,922,923],{"class":703},"    #else\n",[697,925,926,928,930,932,934,936],{"class":699,"line":802},[697,927,908],{"class":724},[697,929,729],{"class":728},[697,931,793],{"class":707},[697,933,771],{"class":753},[697,935,774],{"class":707},[697,937,777],{"class":728},[697,939,940],{"class":699,"line":808},[697,941,942],{"class":703},"    #endif\n",[697,944,945,948],{"class":699,"line":815},[697,946,947],{"class":703},"  #else",[697,949,950],{"class":811},"   \u002F* !defined(__STDC__) *\u002F\n",[697,952,953,955,957,960,962,964],{"class":699,"line":820},[697,954,763],{"class":724},[697,956,729],{"class":728},[697,958,959],{"class":707},"\"__STDC__ is not defined.",[697,961,771],{"class":753},[697,963,774],{"class":707},[697,965,777],{"class":728},[697,967,968],{"class":699,"line":832},[697,969,805],{"class":703},[697,971,973],{"class":699,"line":972},13,[697,974,812],{"class":811},[697,976,978,980,982],{"class":699,"line":977},14,[697,979,823],{"class":703},[697,981,826],{"class":753},[697,983,829],{"class":728},[697,985,987],{"class":699,"line":986},15,[697,988,835],{"class":728},[676,990,992],{"id":991},"compliant-solution-test-for-optional-feature","Compliant Solution (Test for Optional Feature)",[39,994,995,996,999],{},"This compliant solution tests to see if the C11 predefined macro ",[106,997,998],{},"__STDC_ANALYZABLE__"," is defined and what value the implementation has given the macro:",[684,1001,1002],{"quality":848},[688,1003,1005],{"className":690,"code":1004,"language":692,"meta":693,"style":693},"#include \u003Cstdio.h>\n \nint main(void) {\n  #if defined (__STDC__)\n    #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)  \u002F* C11 *\u002F\n      #if defined(__STDC_ANALYZABLE__)\n        #if (__STDC_ANALYZABLE__ == 1)\n          printf(\"Compiler conforms to Annex L (Analyzability).\\n\");\n        #else\n          printf(\"Compiler does not support Annex L (Analyzability).\\n\");\n        #endif\n      #else\n        printf(\"__STDC_ANALYZABLE__ is not defined.\\n\");\n      #endif\n    #else\n      printf(\"Compiler not C11.\\n\");\n    #endif\n  #else\n    printf(\"Compiler not Standard C.\\n\");\n  #endif\n \n  return 0;\n}\n",[106,1006,1007,1013,1018,1030,1042,1078,1091,1106,1122,1127,1142,1147,1152,1168,1173,1177,1193,1198,1203,1219,1224,1229,1238],{"__ignoreMap":693},[697,1008,1009,1011],{"class":699,"line":700},[697,1010,704],{"class":703},[697,1012,708],{"class":707},[697,1014,1015],{"class":699,"line":711},[697,1016,1017],{"class":728}," \n",[697,1019,1020,1022,1024,1026,1028],{"class":699,"line":717},[697,1021,721],{"class":720},[697,1023,725],{"class":724},[697,1025,729],{"class":728},[697,1027,732],{"class":720},[697,1029,735],{"class":728},[697,1031,1032,1034,1036,1038,1040],{"class":699,"line":738},[697,1033,741],{"class":703},[697,1035,882],{"class":703},[697,1037,744],{"class":728},[697,1039,747],{"class":724},[697,1041,757],{"class":728},[697,1043,1044,1046,1048,1050,1053,1056,1059,1061,1063,1066,1069,1072,1075],{"class":699,"line":760},[697,1045,893],{"class":703},[697,1047,882],{"class":703},[697,1049,729],{"class":728},[697,1051,1052],{"class":724},"__STDC_VERSION__",[697,1054,1055],{"class":728},") ",[697,1057,1058],{"class":703},"&&",[697,1060,744],{"class":728},[697,1062,1052],{"class":724},[697,1064,1065],{"class":703}," >=",[697,1067,1068],{"class":753}," 201112",[697,1070,1071],{"class":703},"L",[697,1073,1074],{"class":728},")",[697,1076,1077],{"class":811},"  \u002F* C11 *\u002F\n",[697,1079,1080,1083,1085,1087,1089],{"class":699,"line":780},[697,1081,1082],{"class":703},"      #if",[697,1084,882],{"class":703},[697,1086,729],{"class":728},[697,1088,998],{"class":724},[697,1090,757],{"class":728},[697,1092,1093,1096,1098,1100,1102,1104],{"class":699,"line":786},[697,1094,1095],{"class":703},"        #if",[697,1097,744],{"class":728},[697,1099,998],{"class":724},[697,1101,750],{"class":703},[697,1103,754],{"class":753},[697,1105,757],{"class":728},[697,1107,1108,1111,1113,1116,1118,1120],{"class":699,"line":802},[697,1109,1110],{"class":724},"          printf",[697,1112,729],{"class":728},[697,1114,1115],{"class":707},"\"Compiler conforms to Annex L (Analyzability).",[697,1117,771],{"class":753},[697,1119,774],{"class":707},[697,1121,777],{"class":728},[697,1123,1124],{"class":699,"line":808},[697,1125,1126],{"class":703},"        #else\n",[697,1128,1129,1131,1133,1136,1138,1140],{"class":699,"line":815},[697,1130,1110],{"class":724},[697,1132,729],{"class":728},[697,1134,1135],{"class":707},"\"Compiler does not support Annex L (Analyzability).",[697,1137,771],{"class":753},[697,1139,774],{"class":707},[697,1141,777],{"class":728},[697,1143,1144],{"class":699,"line":820},[697,1145,1146],{"class":703},"        #endif\n",[697,1148,1149],{"class":699,"line":832},[697,1150,1151],{"class":703},"      #else\n",[697,1153,1154,1157,1159,1162,1164,1166],{"class":699,"line":972},[697,1155,1156],{"class":724},"        printf",[697,1158,729],{"class":728},[697,1160,1161],{"class":707},"\"__STDC_ANALYZABLE__ is not defined.",[697,1163,771],{"class":753},[697,1165,774],{"class":707},[697,1167,777],{"class":728},[697,1169,1170],{"class":699,"line":977},[697,1171,1172],{"class":703},"      #endif\n",[697,1174,1175],{"class":699,"line":986},[697,1176,923],{"class":703},[697,1178,1180,1182,1184,1187,1189,1191],{"class":699,"line":1179},16,[697,1181,908],{"class":724},[697,1183,729],{"class":728},[697,1185,1186],{"class":707},"\"Compiler not C11.",[697,1188,771],{"class":753},[697,1190,774],{"class":707},[697,1192,777],{"class":728},[697,1194,1196],{"class":699,"line":1195},17,[697,1197,942],{"class":703},[697,1199,1201],{"class":699,"line":1200},18,[697,1202,783],{"class":703},[697,1204,1206,1208,1210,1213,1215,1217],{"class":699,"line":1205},19,[697,1207,763],{"class":724},[697,1209,729],{"class":728},[697,1211,1212],{"class":707},"\"Compiler not Standard C.",[697,1214,771],{"class":753},[697,1216,774],{"class":707},[697,1218,777],{"class":728},[697,1220,1222],{"class":699,"line":1221},20,[697,1223,805],{"class":703},[697,1225,1227],{"class":699,"line":1226},21,[697,1228,1017],{"class":728},[697,1230,1232,1234,1236],{"class":699,"line":1231},22,[697,1233,823],{"class":703},[697,1235,826],{"class":753},[697,1237,829],{"class":728},[697,1239,1241],{"class":699,"line":1240},23,[697,1242,835],{"class":728},[676,1244,1246],{"id":1245},"compliant-solution-optional-language-features","Compliant Solution (Optional Language Features)",[39,1248,1249,1250,1254,1255,1259],{},"This compliant solution checks for the C11 optional language features in Annex K. If Annex K is supported by the implementation, the functions defined in Annex K are used; if Annex K is not supported, then the standard library functions are used. (See ",[43,1251,1253],{"href":1252},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl09-c","DCL09-C. Declare functions that return errno with a return type of errno_t"," ",[43,1256,1258],{"href":1257},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc14-c","."," )",[684,1261,1262],{"quality":848},[688,1263,1265],{"className":690,"code":1264,"language":692,"meta":693,"style":693},"#if defined(__STDC_LIB_EXT1__)\n  #if (__STDC_LIB_EXT1__ >= 201112L)\n    #define USE_EXT1 1\n    #define __STDC_WANT_LIB_EXT1__ 1 \u002F* Want the ext1 functions *\u002F\n  #endif\n#endif\n \n#include \u003Cstring.h>\n#include \u003Cstdlib.h>\n \nint main(void) {\n  char source_msg[] = \"This is a test.\";\n  char *msg = malloc(sizeof(source_msg) + 1);\n \n  if (msg != NULL) {\n    #if defined(USE_EXT1)\n      strcpy_s(msg, sizeof msg, source_msg);\n    #else\n      strcpy(msg, source_msg);\n    #endif\n  } \n  else {\n    return EXIT_FAILURE;\n  }\n  return 0;\n}\n",[106,1266,1267,1281,1297,1308,1320,1324,1329,1333,1340,1347,1351,1363,1382,1413,1417,1433,1446,1459,1463,1471,1475,1480,1488,1496,1502,1511],{"__ignoreMap":693},[697,1268,1269,1272,1274,1276,1279],{"class":699,"line":700},[697,1270,1271],{"class":703},"#if",[697,1273,882],{"class":703},[697,1275,729],{"class":728},[697,1277,1278],{"class":724},"__STDC_LIB_EXT1__",[697,1280,757],{"class":728},[697,1282,1283,1285,1287,1289,1291,1293,1295],{"class":699,"line":711},[697,1284,741],{"class":703},[697,1286,744],{"class":728},[697,1288,1278],{"class":724},[697,1290,1065],{"class":703},[697,1292,1068],{"class":753},[697,1294,1071],{"class":703},[697,1296,757],{"class":728},[697,1298,1299,1302,1305],{"class":699,"line":717},[697,1300,1301],{"class":703},"    #define",[697,1303,1304],{"class":724}," USE_EXT1",[697,1306,1307],{"class":753}," 1\n",[697,1309,1310,1312,1315,1317],{"class":699,"line":738},[697,1311,1301],{"class":703},[697,1313,1314],{"class":724}," __STDC_WANT_LIB_EXT1__",[697,1316,754],{"class":753},[697,1318,1319],{"class":811}," \u002F* Want the ext1 functions *\u002F\n",[697,1321,1322],{"class":699,"line":760},[697,1323,805],{"class":703},[697,1325,1326],{"class":699,"line":780},[697,1327,1328],{"class":703},"#endif\n",[697,1330,1331],{"class":699,"line":786},[697,1332,1017],{"class":728},[697,1334,1335,1337],{"class":699,"line":802},[697,1336,704],{"class":703},[697,1338,1339],{"class":707}," \u003Cstring.h>\n",[697,1341,1342,1344],{"class":699,"line":808},[697,1343,704],{"class":703},[697,1345,1346],{"class":707}," \u003Cstdlib.h>\n",[697,1348,1349],{"class":699,"line":815},[697,1350,1017],{"class":728},[697,1352,1353,1355,1357,1359,1361],{"class":699,"line":820},[697,1354,721],{"class":720},[697,1356,725],{"class":724},[697,1358,729],{"class":728},[697,1360,732],{"class":720},[697,1362,735],{"class":728},[697,1364,1365,1368,1371,1374,1377,1380],{"class":699,"line":832},[697,1366,1367],{"class":720},"  char",[697,1369,1370],{"class":728}," source_msg",[697,1372,1373],{"class":703},"[]",[697,1375,1376],{"class":703}," =",[697,1378,1379],{"class":707}," \"This is a test.\"",[697,1381,829],{"class":728},[697,1383,1384,1386,1389,1392,1395,1398,1400,1403,1406,1409,1411],{"class":699,"line":972},[697,1385,1367],{"class":720},[697,1387,1388],{"class":703}," *",[697,1390,1391],{"class":728},"msg ",[697,1393,1394],{"class":703},"=",[697,1396,1397],{"class":724}," malloc",[697,1399,729],{"class":728},[697,1401,1402],{"class":703},"sizeof",[697,1404,1405],{"class":728},"(source_msg) ",[697,1407,1408],{"class":703},"+",[697,1410,754],{"class":753},[697,1412,777],{"class":728},[697,1414,1415],{"class":699,"line":977},[697,1416,1017],{"class":728},[697,1418,1419,1422,1425,1428,1431],{"class":699,"line":986},[697,1420,1421],{"class":703},"  if",[697,1423,1424],{"class":728}," (msg ",[697,1426,1427],{"class":703},"!=",[697,1429,1430],{"class":753}," NULL",[697,1432,735],{"class":728},[697,1434,1435,1437,1439,1441,1444],{"class":699,"line":1179},[697,1436,893],{"class":703},[697,1438,882],{"class":703},[697,1440,729],{"class":728},[697,1442,1443],{"class":724},"USE_EXT1",[697,1445,757],{"class":728},[697,1447,1448,1451,1454,1456],{"class":699,"line":1195},[697,1449,1450],{"class":724},"      strcpy_s",[697,1452,1453],{"class":728},"(msg, ",[697,1455,1402],{"class":703},[697,1457,1458],{"class":728}," msg, source_msg);\n",[697,1460,1461],{"class":699,"line":1200},[697,1462,923],{"class":703},[697,1464,1465,1468],{"class":699,"line":1205},[697,1466,1467],{"class":724},"      strcpy",[697,1469,1470],{"class":728},"(msg, source_msg);\n",[697,1472,1473],{"class":699,"line":1221},[697,1474,942],{"class":703},[697,1476,1477],{"class":699,"line":1226},[697,1478,1479],{"class":728},"  } \n",[697,1481,1482,1485],{"class":699,"line":1231},[697,1483,1484],{"class":703},"  else",[697,1486,1487],{"class":728}," {\n",[697,1489,1490,1493],{"class":699,"line":1240},[697,1491,1492],{"class":703},"    return",[697,1494,1495],{"class":728}," EXIT_FAILURE;\n",[697,1497,1499],{"class":699,"line":1498},24,[697,1500,1501],{"class":728},"  }\n",[697,1503,1505,1507,1509],{"class":699,"line":1504},25,[697,1506,823],{"class":703},[697,1508,826],{"class":753},[697,1510,829],{"class":728},[697,1512,1514],{"class":699,"line":1513},26,[697,1515,835],{"class":728},[676,1517,1246],{"id":1518},"compliant-solution-optional-language-features-1",[39,1520,1521,1522,1528,1529,1532,1533,1536,1537,1539,1540,1545],{},"The previous compliant solution comes close to violating ",[43,1523,1527],{"href":1524,"rel":1525},"https:\u002F\u002Fwww.securecoding.cert.org\u002Fconfluence\u002Fdisplay\u002Fseccode\u002FPRE09-C.+Do+not+replace+secure+functions+with+deprecated+or+obsolescent+functions",[1526],"nofollow","PRE09-C. Do not replace secure functions with deprecated or obsolescent functions"," , and would if a function-like macro were defined which called either ",[106,1530,1531],{},"strcpy_s()"," or ",[106,1534,1535],{},"strcpy()"," depending on if ",[106,1538,1443],{}," were defined.  This compliant solution solves the problem by including a custom library that implements the optional language feature, which in this case is the Safe C Library available from ",[43,1541,1544],{"href":1542,"rel":1543},"http:\u002F\u002Fsafeclib.sourceforge.net\u002F",[1526],"SourceForge"," .",[684,1547,1548],{"quality":848},[688,1549,1551],{"className":690,"code":1550,"language":692,"meta":693,"style":693},"#if defined(__STDC_LIB_EXT1__)\n  #if (__STDC_LIB_EXT1__ >= 201112L)\n    #define USE_EXT1 1\n    #define __STDC_WANT_LIB_EXT1__ 1 \u002F* Want the ext1 functions *\u002F\n  #endif\n#endif\n \n#include \u003Cstring.h>\n#include \u003Cstdlib.h>\n\n#if !defined(USE_EXT1)\n  #include \"safe_str_lib.h\"\n#endif\n  \nint main(void) {\n  char source_msg[] = \"This is a test.\";\n  char *msg = malloc(sizeof(source_msg) + 1);\n \n  if (msg != NULL) {\n    strcpy_s(msg, sizeof msg, source_msg);\n  } \n  else {\n    return EXIT_FAILURE;\n  }\n  return 0;\n}\n",[106,1552,1553,1565,1581,1589,1599,1603,1607,1611,1617,1623,1627,1640,1648,1652,1657,1669,1683,1707,1711,1723,1734,1738,1744,1750,1754,1762],{"__ignoreMap":693},[697,1554,1555,1557,1559,1561,1563],{"class":699,"line":700},[697,1556,1271],{"class":703},[697,1558,882],{"class":703},[697,1560,729],{"class":728},[697,1562,1278],{"class":724},[697,1564,757],{"class":728},[697,1566,1567,1569,1571,1573,1575,1577,1579],{"class":699,"line":711},[697,1568,741],{"class":703},[697,1570,744],{"class":728},[697,1572,1278],{"class":724},[697,1574,1065],{"class":703},[697,1576,1068],{"class":753},[697,1578,1071],{"class":703},[697,1580,757],{"class":728},[697,1582,1583,1585,1587],{"class":699,"line":717},[697,1584,1301],{"class":703},[697,1586,1304],{"class":724},[697,1588,1307],{"class":753},[697,1590,1591,1593,1595,1597],{"class":699,"line":738},[697,1592,1301],{"class":703},[697,1594,1314],{"class":724},[697,1596,754],{"class":753},[697,1598,1319],{"class":811},[697,1600,1601],{"class":699,"line":760},[697,1602,805],{"class":703},[697,1604,1605],{"class":699,"line":780},[697,1606,1328],{"class":703},[697,1608,1609],{"class":699,"line":786},[697,1610,1017],{"class":728},[697,1612,1613,1615],{"class":699,"line":802},[697,1614,704],{"class":703},[697,1616,1339],{"class":707},[697,1618,1619,1621],{"class":699,"line":808},[697,1620,704],{"class":703},[697,1622,1346],{"class":707},[697,1624,1625],{"class":699,"line":815},[697,1626,714],{"emptyLinePlaceholder":7},[697,1628,1629,1631,1634,1636,1638],{"class":699,"line":820},[697,1630,1271],{"class":703},[697,1632,1633],{"class":703}," !defined",[697,1635,729],{"class":728},[697,1637,1443],{"class":724},[697,1639,757],{"class":728},[697,1641,1642,1645],{"class":699,"line":832},[697,1643,1644],{"class":703},"  #include",[697,1646,1647],{"class":707}," \"safe_str_lib.h\"\n",[697,1649,1650],{"class":699,"line":972},[697,1651,1328],{"class":703},[697,1653,1654],{"class":699,"line":977},[697,1655,1656],{"class":728},"  \n",[697,1658,1659,1661,1663,1665,1667],{"class":699,"line":986},[697,1660,721],{"class":720},[697,1662,725],{"class":724},[697,1664,729],{"class":728},[697,1666,732],{"class":720},[697,1668,735],{"class":728},[697,1670,1671,1673,1675,1677,1679,1681],{"class":699,"line":1179},[697,1672,1367],{"class":720},[697,1674,1370],{"class":728},[697,1676,1373],{"class":703},[697,1678,1376],{"class":703},[697,1680,1379],{"class":707},[697,1682,829],{"class":728},[697,1684,1685,1687,1689,1691,1693,1695,1697,1699,1701,1703,1705],{"class":699,"line":1195},[697,1686,1367],{"class":720},[697,1688,1388],{"class":703},[697,1690,1391],{"class":728},[697,1692,1394],{"class":703},[697,1694,1397],{"class":724},[697,1696,729],{"class":728},[697,1698,1402],{"class":703},[697,1700,1405],{"class":728},[697,1702,1408],{"class":703},[697,1704,754],{"class":753},[697,1706,777],{"class":728},[697,1708,1709],{"class":699,"line":1200},[697,1710,1017],{"class":728},[697,1712,1713,1715,1717,1719,1721],{"class":699,"line":1205},[697,1714,1421],{"class":703},[697,1716,1424],{"class":728},[697,1718,1427],{"class":703},[697,1720,1430],{"class":753},[697,1722,735],{"class":728},[697,1724,1725,1728,1730,1732],{"class":699,"line":1221},[697,1726,1727],{"class":724},"    strcpy_s",[697,1729,1453],{"class":728},[697,1731,1402],{"class":703},[697,1733,1458],{"class":728},[697,1735,1736],{"class":699,"line":1226},[697,1737,1479],{"class":728},[697,1739,1740,1742],{"class":699,"line":1231},[697,1741,1484],{"class":703},[697,1743,1487],{"class":728},[697,1745,1746,1748],{"class":699,"line":1240},[697,1747,1492],{"class":703},[697,1749,1495],{"class":728},[697,1751,1752],{"class":699,"line":1498},[697,1753,1501],{"class":728},[697,1755,1756,1758,1760],{"class":699,"line":1504},[697,1757,823],{"class":703},[697,1759,826],{"class":753},[697,1761,829],{"class":728},[697,1763,1764],{"class":699,"line":1513},[697,1765,835],{"class":728},[676,1767,1769],{"id":1768},"risk-assessment","Risk Assessment",[39,1771,1772,1773,1775,1776,1545],{},"Not testing for language features or the version of the ",[43,1774,46],{"href":45}," being used can lead to unexpected or ",[43,1777,1779],{"href":1778},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-undefinedbehavior","undefined program behavior",[57,1781,1782,1783,1782,1811],{},"\n  ",[1784,1785,1786,1787,1782],"thead",{},"\n    ",[79,1788,1789,1790,1789,1793,1789,1796,1789,1799,1789,1802,1789,1805,1789,1808,1786],{},"\n      ",[84,1791,1792],{},"Rule",[84,1794,1795],{},"Severity",[84,1797,1798],{},"Likelihood",[84,1800,1801],{},"Detectable",[84,1803,1804],{},"Repairable",[84,1806,1807],{},"Priority",[84,1809,1810],{},"Level",[76,1812,1786,1813,1782],{},[79,1814,1789,1815,1789,1818,1789,1821,1789,1824,1789,1827,1789,1829,1789,1836,1786],{},[101,1816,1817],{},"PRE13-C",[101,1819,1820],{},"Low",[101,1822,1823],{},"Probable",[101,1825,1826],{},"No",[101,1828,1826],{},[101,1830,1832],{"style":1831},"color: #27ae60;",[1833,1834,1835],"b",{},"P2",[101,1837,1838],{"style":1831},[1833,1839,1840],{},"L3",[1842,1843,1845],"h3",{"id":1844},"automated-detection","Automated Detection",[1842,1847],{"id":693},[57,1849,1851],{"className":1850},[60],[76,1852,1853,1876,1905,1931,1957],{},[79,1854,1856,1861,1866,1871],{"className":1855},[82],[84,1857,1858],{},[39,1859,1860],{},"Tool",[84,1862,1863],{},[39,1864,1865],{},"Version",[84,1867,1868],{},[39,1869,1870],{},"Checker",[84,1872,1873],{},[39,1874,1875],{},"Description",[79,1877,1879,1885,1895,1901],{"className":1878},[99],[101,1880,1881],{},[43,1882,1884],{"href":1883},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Faxivion-bauhaus-suite","Axivion Bauhaus Suite",[101,1886,1887],{},[1888,1889,1892],"div",{"className":1890},[1891],"content-wrapper",[39,1893,1894],{},"7.2.0",[101,1896,1897],{},[1898,1899,1900],"strong",{},"CertC-PRE13",[101,1902,1903],{},[138,1904],{},[79,1906,1908,1914,1922,1927],{"className":1907},[125],[101,1909,1910],{},[43,1911,1913],{"href":1912},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fhelix-qac","Helix QAC",[101,1915,1916],{},[1888,1917,1919],{"className":1918},[1891],[39,1920,1921],{},"2025.2",[101,1923,1924],{},[1898,1925,1926],{},"C3336",[101,1928,1929],{},[138,1930],{},[79,1932,1934,1940,1946,1952],{"className":1933},[99],[101,1935,1936],{},[43,1937,1939],{"href":1938},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fldra","LDRA tool suite",[101,1941,1942],{},[1888,1943,1945],{"className":1944},[1891],"9.7.1",[101,1947,1948],{},[39,1949,1950],{},[1898,1951],{},[101,1953,1954],{},[39,1955,1956],{},"Partially implemented",[79,1958,1960,1966,1974,1979],{"className":1959},[125],[101,1961,1962],{},[43,1963,1965],{"href":1964},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer","Security Reviewer - Static Reviewer",[101,1967,1968],{},[1888,1969,1971],{"className":1970},[1891],[39,1972,1973],{},"6.02",[101,1975,1976],{},[1898,1977,1978],{},"RTOS_26",[101,1980,1981],{},"Fully implemented",[1842,1983,1985],{"id":1984},"related-vulnerabilities","Related Vulnerabilities",[39,1987,1988,1989,1993,1994,1545],{},"Search for ",[43,1990,1992],{"href":1991},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerabilities"," resulting from the violation of this rule on the ",[43,1995,1998],{"href":1996,"rel":1997},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+PRE33-C",[1526],"CERT website",[676,2000,2002],{"id":2001},"related-guidelines","Related Guidelines",[57,2004,2006,2013],{"className":2005},[60],[63,2007,2008,2011],{},[66,2009],{"style":2010},"width: 50%",[66,2012],{"style":2010},[76,2014,2015,2027],{},[79,2016,2018,2024],{"className":2017},[99],[101,2019,2020],{},[43,2021,2023],{"href":2022},"https:\u002F\u002Fwww.securecoding.cert.org\u002Fconfluence\u002Fdisplay\u002Fseccode\u002FAA.+Bibliography#AA.Bibliography-ISO%2FIECTR24772-2013","ISO\u002FIEC TR 24772:2013",[101,2025,2026],{},"Pre-processor Directives [NMP]",[79,2028,2030,2036],{"className":2029},[125],[101,2031,2032],{},[43,2033,2035],{"href":2034},"https:\u002F\u002Fwww.securecoding.cert.org\u002Fconfluence\u002Fdisplay\u002Fseccode\u002FAA.+Bibliography#AA.Bibliography-ISO%2FIEC9899-2011","ISO\u002FIEC 9899:2011",[101,2037,2038,2041],{},[39,2039,2040],{},"6.10.8, \"Predefined macro names\"",[39,2042,2043],{},"K.3.7.1, \"Copying functions\"",[2045,2046],"hr",{},[39,2048,2049,1254,2056,1254,2062],{},[43,2050,2052],{"href":2051},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre12-c",[2053,2054],"img",{"src":2055},"\u002Fattachments\u002F87152044\u002F88034188.png",[43,2057,2059],{"href":2058},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002F",[2053,2060],{"src":2061},"\u002Fattachments\u002F87152044\u002F88034190.png",[43,2063,2065],{"href":2064},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002F",[2053,2066],{"src":2067},"\u002Fattachments\u002F87152044\u002F88034189.png",[2069,2070,2071],"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 .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 .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}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);}",{"title":693,"searchDepth":711,"depth":711,"links":2073},[2074,2075,2076,2077,2078,2079,2084],{"id":678,"depth":711,"text":679},{"id":838,"depth":711,"text":839},{"id":991,"depth":711,"text":992},{"id":1245,"depth":711,"text":1246},{"id":1518,"depth":711,"text":1246},{"id":1768,"depth":711,"text":1769,"children":2080},[2081,2082,2083],{"id":1844,"depth":717,"text":1845},{"id":693,"depth":717,"text":693},{"id":1984,"depth":717,"text":1985},{"id":2001,"depth":711,"text":2002},"The C S tandard defines a set of predefined macros (see subclause 6.10.8) to help the user determine if the implementation being used is a conforming implementation, and if so, to which version of the C Standard it conforms. These macros can also help the user to determine which of the standard features are implemented.","md",{"tags":2088},[2089,2090,688,2091,2092],"recommendation","review","rose-na-macros","review-ajb","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre13-c",{"title":30,"description":2085},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F14.pre13-c","Cmi-z3o6aWuHbevdM0rNHsELeDJwTX92_QESAHmXwME",[2098,2101],{"title":2099,"path":2051,"stem":2100,"children":-1},"PRE12-C. Do not define unsafe macros","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F13.pre12-c",{"title":2102,"path":2103,"stem":2104,"children":-1},"Signals (SIG)","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F1.index",[2106],{"title":2107,"path":2108,"stem":2109,"children":2110},"SEI CERT C Coding Standard","\u002Fsei-cert-c-coding-standard","4.sei-cert-c-coding-standard\u002F01.index",[2111,2112,2184,2773,3063,3077,3081,3085,3089,3892],{"title":2107,"path":2108,"stem":2109},{"title":2113,"path":2114,"stem":2115,"children":2116},"Front Matter","\u002Fsei-cert-c-coding-standard\u002Ffront-matter","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F1.index",[2117,2118],{"title":2113,"path":2114,"stem":2115},{"title":2119,"path":2120,"stem":2121,"children":2122},"Introduction","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[2123,2124,2128,2132,2136,2140,2144,2148,2152,2156,2160,2164,2168,2172,2176,2180],{"title":2119,"path":2120,"stem":2121},{"title":2125,"path":2126,"stem":2127},"Scope","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.scope",{"title":2129,"path":2130,"stem":2131},"Audience","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F02.audience",{"title":2133,"path":2134,"stem":2135},"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":2137,"path":2138,"stem":2139},"History","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhistory","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F04.history",{"title":2141,"path":2142,"stem":2143},"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":2145,"path":2146,"stem":2147},"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":2149,"path":2150,"stem":2151},"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":2153,"path":2154,"stem":2155},"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":2157,"path":2158,"stem":2159},"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":2161,"path":2162,"stem":2163},"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":2165,"path":2166,"stem":2167},"Usage","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F11.usage",{"title":2169,"path":2170,"stem":2171},"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":2173,"path":2174,"stem":2175},"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":2177,"path":2178,"stem":2179},"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":2181,"path":2182,"stem":2183},"Acknowledgments","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F15.acknowledgments",{"title":2185,"path":2186,"stem":2187,"children":2188},"Rules","\u002Fsei-cert-c-coding-standard\u002Frules","4.sei-cert-c-coding-standard\u002F03.rules\u002F01.index",[2189,2190,2194,2224,2254,2316,2354,2380,2402,2468,2494,2552,2586,2616,2626,2664,2734,2752],{"title":2185,"path":2186,"stem":2187},{"title":2191,"path":2192,"stem":2193},"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":2195,"path":2196,"stem":2197,"children":2198},"Arrays (ARR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F1.index",[2199,2200,2204,2208,2212,2216,2220],{"title":2195,"path":2196,"stem":2197},{"title":2201,"path":2202,"stem":2203},"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":2205,"path":2206,"stem":2207},"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":2209,"path":2210,"stem":2211},"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":2213,"path":2214,"stem":2215},"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":2217,"path":2218,"stem":2219},"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":2221,"path":2222,"stem":2223},"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":2225,"path":2226,"stem":2227,"children":2228},"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",[2229,2230,2234,2238,2242,2246,2250],{"title":2225,"path":2226,"stem":2227},{"title":2231,"path":2232,"stem":2233},"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":2235,"path":2236,"stem":2237},"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":2239,"path":2240,"stem":2241},"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":2243,"path":2244,"stem":2245},"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":2247,"path":2248,"stem":2249},"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":2251,"path":2252,"stem":2253},"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":2255,"path":2256,"stem":2257,"children":2258},"Concurrency (CON)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F01.index",[2259,2260,2264,2268,2272,2276,2280,2284,2288,2292,2296,2300,2304,2308,2312],{"title":2255,"path":2256,"stem":2257},{"title":2261,"path":2262,"stem":2263},"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":2265,"path":2266,"stem":2267},"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":2269,"path":2270,"stem":2271},"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":2273,"path":2274,"stem":2275},"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":2277,"path":2278,"stem":2279},"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":2281,"path":2282,"stem":2283},"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":2285,"path":2286,"stem":2287},"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":2289,"path":2290,"stem":2291},"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":2293,"path":2294,"stem":2295},"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":2297,"path":2298,"stem":2299},"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":2301,"path":2302,"stem":2303},"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":2305,"path":2306,"stem":2307},"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":2309,"path":2310,"stem":2311},"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":2313,"path":2314,"stem":2315},"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":2317,"path":2318,"stem":2319,"children":2320},"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",[2321,2322,2326,2330,2334,2338,2342,2346,2350],{"title":2317,"path":2318,"stem":2319},{"title":2323,"path":2324,"stem":2325},"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":2327,"path":2328,"stem":2329},"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":2331,"path":2332,"stem":2333},"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":2335,"path":2336,"stem":2337},"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":2339,"path":2340,"stem":2341},"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":2343,"path":2344,"stem":2345},"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":2347,"path":2348,"stem":2349},"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":2351,"path":2352,"stem":2353},"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":2355,"path":2356,"stem":2357,"children":2358},"Environment (ENV)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F1.index",[2359,2360,2364,2368,2372,2376],{"title":2355,"path":2356,"stem":2357},{"title":2361,"path":2362,"stem":2363},"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":2365,"path":2366,"stem":2367},"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":2369,"path":2370,"stem":2371},"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":2373,"path":2374,"stem":2375},"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":2377,"path":2378,"stem":2379},"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":2381,"path":2382,"stem":2383,"children":2384},"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",[2385,2386,2390,2394,2398],{"title":2381,"path":2382,"stem":2383},{"title":2387,"path":2388,"stem":2389},"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":2391,"path":2392,"stem":2393},"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":2395,"path":2396,"stem":2397},"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":2399,"path":2400,"stem":2401},"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":2403,"path":2404,"stem":2405,"children":2406},"Expressions (EXP)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F01.index",[2407,2408,2412,2416,2420,2424,2428,2432,2436,2440,2444,2448,2452,2456,2460,2464],{"title":2403,"path":2404,"stem":2405},{"title":2409,"path":2410,"stem":2411},"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":2413,"path":2414,"stem":2415},"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":2417,"path":2418,"stem":2419},"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":2421,"path":2422,"stem":2423},"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":2425,"path":2426,"stem":2427},"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":2429,"path":2430,"stem":2431},"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":2433,"path":2434,"stem":2435},"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":2437,"path":2438,"stem":2439},"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":2441,"path":2442,"stem":2443},"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":2445,"path":2446,"stem":2447},"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":2449,"path":2450,"stem":2451},"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":2453,"path":2454,"stem":2455},"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":2457,"path":2458,"stem":2459},"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":2461,"path":2462,"stem":2463},"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":2465,"path":2466,"stem":2467},"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":2469,"path":2470,"stem":2471,"children":2472},"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",[2473,2474,2478,2482,2486,2490],{"title":2469,"path":2470,"stem":2471},{"title":2475,"path":2476,"stem":2477},"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":2479,"path":2480,"stem":2481},"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":2483,"path":2484,"stem":2485},"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":2487,"path":2488,"stem":2489},"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":2491,"path":2492,"stem":2493},"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":2495,"path":2496,"stem":2497,"children":2498},"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",[2499,2500,2504,2508,2512,2516,2520,2524,2528,2532,2536,2540,2544,2548],{"title":2495,"path":2496,"stem":2497},{"title":2501,"path":2502,"stem":2503},"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":2505,"path":2506,"stem":2507},"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":2509,"path":2510,"stem":2511},"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":2513,"path":2514,"stem":2515},"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":2517,"path":2518,"stem":2519},"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":2521,"path":2522,"stem":2523},"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":2525,"path":2526,"stem":2527},"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":2529,"path":2530,"stem":2531},"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":2533,"path":2534,"stem":2535},"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":2537,"path":2538,"stem":2539},"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":2541,"path":2542,"stem":2543},"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":2545,"path":2546,"stem":2547},"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":2549,"path":2550,"stem":2551},"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":2553,"path":2554,"stem":2555,"children":2556},"Integers (INT)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F1.index",[2557,2558,2562,2566,2570,2574,2578,2582],{"title":2553,"path":2554,"stem":2555},{"title":2559,"path":2560,"stem":2561},"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":2563,"path":2564,"stem":2565},"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":2567,"path":2568,"stem":2569},"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":2571,"path":2572,"stem":2573},"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":2575,"path":2576,"stem":2577},"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":2579,"path":2580,"stem":2581},"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":2583,"path":2584,"stem":2585},"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":2587,"path":2588,"stem":2589,"children":2590},"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",[2591,2592,2596,2600,2604,2608,2612],{"title":2587,"path":2588,"stem":2589},{"title":2593,"path":2594,"stem":2595},"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":2597,"path":2598,"stem":2599},"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":2601,"path":2602,"stem":2603},"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":2605,"path":2606,"stem":2607},"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":2609,"path":2610,"stem":2611},"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":2613,"path":2614,"stem":2615},"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":2617,"path":2618,"stem":2619,"children":2620},"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",[2621,2622],{"title":2617,"path":2618,"stem":2619},{"title":2623,"path":2624,"stem":2625},"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":2627,"path":2628,"stem":2629,"children":2630},"Miscellaneous (MSC)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F1.index",[2631,2632,2636,2640,2644,2648,2652,2656,2660],{"title":2627,"path":2628,"stem":2629},{"title":2633,"path":2634,"stem":2635},"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":2637,"path":2638,"stem":2639},"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":2641,"path":2642,"stem":2643},"MSC33-C. Do not pass invalid data to the asctime() function","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F4.msc33-c",{"title":2645,"path":2646,"stem":2647},"MSC37-C. Ensure that control never reaches the end of a non-void function","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F5.msc37-c",{"title":2649,"path":2650,"stem":2651},"MSC38-C. Do not treat a predefined identifier as an object if it might only be implemented as a macro","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F6.msc38-c",{"title":2653,"path":2654,"stem":2655},"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":2657,"path":2658,"stem":2659},"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":2661,"path":2662,"stem":2663},"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":2665,"path":2666,"stem":2667,"children":2668},"POSIX (POS)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F01.index",[2669,2670,2674,2678,2682,2686,2690,2694,2698,2702,2706,2710,2714,2718,2722,2726,2730],{"title":2665,"path":2666,"stem":2667},{"title":2671,"path":2672,"stem":2673},"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":2675,"path":2676,"stem":2677},"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":2679,"path":2680,"stem":2681},"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":2683,"path":2684,"stem":2685},"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":2687,"path":2688,"stem":2689},"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":2691,"path":2692,"stem":2693},"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":2695,"path":2696,"stem":2697},"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":2699,"path":2700,"stem":2701},"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":2703,"path":2704,"stem":2705},"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":2707,"path":2708,"stem":2709},"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":2711,"path":2712,"stem":2713},"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":2715,"path":2716,"stem":2717},"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":2719,"path":2720,"stem":2721},"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":2723,"path":2724,"stem":2725},"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":2727,"path":2728,"stem":2729},"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":2731,"path":2732,"stem":2733},"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":2735,"path":2736,"stem":2737,"children":2738},"Preprocessor (PRE)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F1.index",[2739,2740,2744,2748],{"title":2735,"path":2736,"stem":2737},{"title":2741,"path":2742,"stem":2743},"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":2745,"path":2746,"stem":2747},"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":2749,"path":2750,"stem":2751},"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":2102,"path":2753,"stem":2754,"children":2755},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F1.index",[2756,2757,2761,2765,2769],{"title":2102,"path":2753,"stem":2754},{"title":2758,"path":2759,"stem":2760},"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":2762,"path":2763,"stem":2764},"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":2766,"path":2767,"stem":2768},"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":2770,"path":2771,"stem":2772},"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":2774,"path":2775,"stem":2776,"children":2777},"Back Matter","\u002Fsei-cert-c-coding-standard\u002Fback-matter","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F1.index",[2778,2779,2783,2787,2791,2795,3002,3059],{"title":2774,"path":2775,"stem":2776},{"title":2780,"path":2781,"stem":2782},"AA. Bibliography","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F2.aa-bibliography",{"title":2784,"path":2785,"stem":2786},"BB. Definitions","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F3.bb-definitions",{"title":2788,"path":2789,"stem":2790},"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":2792,"path":2793,"stem":2794},"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":2796,"path":2797,"stem":2798,"children":2799},"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",[2800,2801,2805,2809,2811,2815,2819,2823,2827,2831,2835,2839,2843,2847,2851,2855,2859,2863,2867,2871,2875,2879,2883,2887,2891,2895,2899,2901,2905,2909,2913,2916,2920,2924,2928,2932,2936,2940,2944,2948,2952,2956,2960,2964,2968,2972,2974,2978,2982,2986,2990,2994,2998],{"title":2796,"path":2797,"stem":2798},{"title":2802,"path":2803,"stem":2804},"Astrée","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fastree","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F02.astree",{"title":2806,"path":2807,"stem":2808},"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":1884,"path":1883,"stem":2810},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F04.axivion-bauhaus-suite",{"title":2812,"path":2813,"stem":2814},"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":2816,"path":2817,"stem":2818},"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":2820,"path":2821,"stem":2822},"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":2824,"path":2825,"stem":2826},"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":2828,"path":2829,"stem":2830},"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":2832,"path":2833,"stem":2834},"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":2836,"path":2837,"stem":2838},"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":2840,"path":2841,"stem":2842},"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":2844,"path":2845,"stem":2846},"CodeSonar","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F13.codesonar",{"title":2848,"path":2849,"stem":2850},"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":2852,"path":2853,"stem":2854},"Coverity","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcoverity","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F15.coverity",{"title":2856,"path":2857,"stem":2858},"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":2860,"path":2861,"stem":2862},"Cppcheck","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F17.cppcheck",{"title":2864,"path":2865,"stem":2866},"Cppcheck Premium","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck-premium","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F18.cppcheck-premium",{"title":2868,"path":2869,"stem":2870},"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":2872,"path":2873,"stem":2874},"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":2876,"path":2877,"stem":2878},"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":2880,"path":2881,"stem":2882},"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":2884,"path":2885,"stem":2886},"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":2888,"path":2889,"stem":2890},"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":2892,"path":2893,"stem":2894},"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":2896,"path":2897,"stem":2898},"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":1913,"path":1912,"stem":2900},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F27.helix-qac",{"title":2902,"path":2903,"stem":2904},"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":2906,"path":2907,"stem":2908},"Klocwork","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fklocwork","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F29.klocwork",{"title":2910,"path":2911,"stem":2912},"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":2914,"path":1938,"stem":2915},"LDRA","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F31.ldra",{"title":2917,"path":2918,"stem":2919},"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":2921,"path":2922,"stem":2923},"Parasoft","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fparasoft","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F33.parasoft",{"title":2925,"path":2926,"stem":2927},"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":2929,"path":2930,"stem":2931},"PC-lint Plus","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpc-lint-plus","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F35.pc-lint-plus",{"title":2933,"path":2934,"stem":2935},"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":2937,"path":2938,"stem":2939},"Polyspace Bug Finder","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpolyspace-bug-finder","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F37.polyspace-bug-finder",{"title":2941,"path":2942,"stem":2943},"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":2945,"path":2946,"stem":2947},"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":2949,"path":2950,"stem":2951},"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":2953,"path":2954,"stem":2955},"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":2957,"path":2958,"stem":2959},"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":2961,"path":2962,"stem":2963},"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":2965,"path":2966,"stem":2967},"RuleChecker","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frulechecker","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F44.rulechecker",{"title":2969,"path":2970,"stem":2971},"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":1965,"path":1964,"stem":2973},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F46.security-reviewer-static-reviewer",{"title":2975,"path":2976,"stem":2977},"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":2979,"path":2980,"stem":2981},"SonarQube C\u002FC++ Plugin","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsonarqube-ccpp-plugin","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F48.sonarqube-ccpp-plugin",{"title":2983,"path":2984,"stem":2985},"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":2987,"path":2988,"stem":2989},"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":2991,"path":2992,"stem":2993},"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":2995,"path":2996,"stem":2997},"TrustInSoft Analyzer","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Ftrustinsoft-analyzer","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F52.trustinsoft-analyzer",{"title":2999,"path":3000,"stem":3001},"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":3003,"path":3004,"stem":3005,"children":3006},"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",[3007,3008,3012,3016,3020,3024,3028,3032,3036,3040,3043,3047,3051,3055],{"title":3003,"path":3004,"stem":3005},{"title":3009,"path":3010,"stem":3011},"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":3013,"path":3014,"stem":3015},"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":3017,"path":3018,"stem":3019},"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":3021,"path":3022,"stem":3023},"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":3025,"path":3026,"stem":3027},"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":3029,"path":3030,"stem":3031},"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":3033,"path":3034,"stem":3035},"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":3037,"path":3038,"stem":3039},"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":3037,"path":3041,"stem":3042},"\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":3044,"path":3045,"stem":3046},"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":3048,"path":3049,"stem":3050},"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":3052,"path":3053,"stem":3054},"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":3056,"path":3057,"stem":3058},"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":3060,"path":3061,"stem":3062},"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":3064,"path":3065,"stem":3066,"children":3067},"Admin","\u002Fsei-cert-c-coding-standard\u002Fadmin","4.sei-cert-c-coding-standard\u002F05.admin\u002F1.index",[3068,3069,3073],{"title":3064,"path":3065,"stem":3066},{"title":3070,"path":3071,"stem":3072},"TODO List","\u002Fsei-cert-c-coding-standard\u002Fadmin\u002Ftodo-list","4.sei-cert-c-coding-standard\u002F05.admin\u002F2.todo-list",{"title":3074,"path":3075,"stem":3076},"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":3078,"path":3079,"stem":3080},"Coding Style Guidelines","\u002Fsei-cert-c-coding-standard\u002Fcoding-style-guidelines","4.sei-cert-c-coding-standard\u002F05.coding-style-guidelines",{"title":3082,"path":3083,"stem":3084},"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":3086,"path":3087,"stem":3088},"Wiki Contents","\u002Fsei-cert-c-coding-standard\u002Fwiki-contents","4.sei-cert-c-coding-standard\u002F06.wiki-contents",{"title":3090,"path":3091,"stem":3092,"children":3093},"Recommendations","\u002Fsei-cert-c-coding-standard\u002Frecommendations","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F01.index",[3094,3095,3136,3153,3198,3239,3334,3351,3384,3453,3490,3575,3640,3689,3714,3806,3827,3877],{"title":3090,"path":3091,"stem":3092},{"title":2191,"path":3096,"stem":3097,"children":3098},"\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",[3099,3100,3104,3108,3112,3116,3120,3124,3128,3132],{"title":2191,"path":3096,"stem":3097},{"title":3101,"path":3102,"stem":3103},"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":3105,"path":3106,"stem":3107},"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":3109,"path":3110,"stem":3111},"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":3113,"path":3114,"stem":3115},"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":3117,"path":3118,"stem":3119},"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":3121,"path":3122,"stem":3123},"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":3125,"path":3126,"stem":3127},"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":3129,"path":3130,"stem":3131},"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":3133,"path":3134,"stem":3135},"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":2195,"path":3137,"stem":3138,"children":3139},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F1.index",[3140,3141,3145,3149],{"title":2195,"path":3137,"stem":3138},{"title":3142,"path":3143,"stem":3144},"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":3146,"path":3147,"stem":3148},"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":3150,"path":3151,"stem":3152},"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":2225,"path":3154,"stem":3155,"children":3156},"\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",[3157,3158,3162,3166,3170,3174,3178,3182,3186,3190,3194],{"title":2225,"path":3154,"stem":3155},{"title":3159,"path":3160,"stem":3161},"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":3163,"path":3164,"stem":3165},"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":3167,"path":3168,"stem":3169},"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":3171,"path":3172,"stem":3173},"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":3175,"path":3176,"stem":3177},"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":3179,"path":3180,"stem":3181},"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":3183,"path":3184,"stem":3185},"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":3187,"path":3188,"stem":3189},"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":3191,"path":3192,"stem":3193},"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":3195,"path":3196,"stem":3197},"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":2255,"path":3199,"stem":3200,"children":3201},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F01.index",[3202,3203,3207,3211,3215,3219,3223,3227,3231,3235],{"title":2255,"path":3199,"stem":3200},{"title":3204,"path":3205,"stem":3206},"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":3208,"path":3209,"stem":3210},"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":3212,"path":3213,"stem":3214},"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":3216,"path":3217,"stem":3218},"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":3220,"path":3221,"stem":3222},"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":3224,"path":3225,"stem":3226},"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":3228,"path":3229,"stem":3230},"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":3232,"path":3233,"stem":3234},"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":3236,"path":3237,"stem":3238},"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":2317,"path":3240,"stem":3241,"children":3242},"\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",[3243,3244,3248,3252,3256,3260,3264,3268,3272,3276,3280,3282,3286,3290,3294,3298,3302,3306,3310,3314,3318,3322,3326,3330],{"title":2317,"path":3240,"stem":3241},{"title":3245,"path":3246,"stem":3247},"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":3249,"path":3250,"stem":3251},"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":3253,"path":3254,"stem":3255},"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":3257,"path":3258,"stem":3259},"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":3261,"path":3262,"stem":3263},"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":3265,"path":3266,"stem":3267},"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":3269,"path":3270,"stem":3271},"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":3273,"path":3274,"stem":3275},"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":3277,"path":3278,"stem":3279},"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":1253,"path":1252,"stem":3281},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F11.dcl09-c",{"title":3283,"path":3284,"stem":3285},"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":3287,"path":3288,"stem":3289},"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":3291,"path":3292,"stem":3293},"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":3295,"path":3296,"stem":3297},"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":3299,"path":3300,"stem":3301},"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":3303,"path":3304,"stem":3305},"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":3307,"path":3308,"stem":3309},"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":3311,"path":3312,"stem":3313},"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":3315,"path":3316,"stem":3317},"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":3319,"path":3320,"stem":3321},"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":3323,"path":3324,"stem":3325},"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":3327,"path":3328,"stem":3329},"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":3331,"path":3332,"stem":3333},"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":2355,"path":3335,"stem":3336,"children":3337},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F1.index",[3338,3339,3343,3347],{"title":2355,"path":3335,"stem":3336},{"title":3340,"path":3341,"stem":3342},"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":3344,"path":3345,"stem":3346},"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":3348,"path":3349,"stem":3350},"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":2381,"path":3352,"stem":3353,"children":3354},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F1.index",[3355,3356,3360,3364,3368,3372,3376,3380],{"title":2381,"path":3352,"stem":3353},{"title":3357,"path":3358,"stem":3359},"ERR00-C. Adopt and implement a consistent and comprehensive error-handling policy","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F2.err00-c",{"title":3361,"path":3362,"stem":3363},"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":3365,"path":3366,"stem":3367},"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":3369,"path":3370,"stem":3371},"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":3373,"path":3374,"stem":3375},"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":3377,"path":3378,"stem":3379},"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":3381,"path":3382,"stem":3383},"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":2403,"path":3385,"stem":3386,"children":3387},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F01.index",[3388,3389,3393,3397,3401,3405,3409,3413,3417,3421,3425,3429,3433,3437,3441,3445,3449],{"title":2403,"path":3385,"stem":3386},{"title":3390,"path":3391,"stem":3392},"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":3394,"path":3395,"stem":3396},"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":3398,"path":3399,"stem":3400},"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":3402,"path":3403,"stem":3404},"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":3406,"path":3407,"stem":3408},"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":3410,"path":3411,"stem":3412},"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":3414,"path":3415,"stem":3416},"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":3418,"path":3419,"stem":3420},"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":3422,"path":3423,"stem":3424},"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":3426,"path":3427,"stem":3428},"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":3430,"path":3431,"stem":3432},"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":3434,"path":3435,"stem":3436},"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":3438,"path":3439,"stem":3440},"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":3442,"path":3443,"stem":3444},"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":3446,"path":3447,"stem":3448},"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":3450,"path":3451,"stem":3452},"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":2469,"path":3454,"stem":3455,"children":3456},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F1.index",[3457,3458,3462,3466,3470,3474,3478,3482,3486],{"title":2469,"path":3454,"stem":3455},{"title":3459,"path":3460,"stem":3461},"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":3463,"path":3464,"stem":3465},"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":3467,"path":3468,"stem":3469},"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":3471,"path":3472,"stem":3473},"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":3475,"path":3476,"stem":3477},"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":3479,"path":3480,"stem":3481},"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":3483,"path":3484,"stem":3485},"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":3487,"path":3488,"stem":3489},"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":2495,"path":3491,"stem":3492,"children":3493},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F01.index",[3494,3495,3499,3503,3507,3511,3515,3519,3523,3527,3531,3535,3539,3543,3547,3551,3555,3559,3563,3567,3571],{"title":2495,"path":3491,"stem":3492},{"title":3496,"path":3497,"stem":3498},"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":3500,"path":3501,"stem":3502},"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":3504,"path":3505,"stem":3506},"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":3508,"path":3509,"stem":3510},"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":3512,"path":3513,"stem":3514},"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":3516,"path":3517,"stem":3518},"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":3520,"path":3521,"stem":3522},"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":3524,"path":3525,"stem":3526},"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":3528,"path":3529,"stem":3530},"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":3532,"path":3533,"stem":3534},"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":3536,"path":3537,"stem":3538},"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":3540,"path":3541,"stem":3542},"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":3544,"path":3545,"stem":3546},"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":3548,"path":3549,"stem":3550},"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":3552,"path":3553,"stem":3554},"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":3556,"path":3557,"stem":3558},"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":3560,"path":3561,"stem":3562},"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":3564,"path":3565,"stem":3566},"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":3568,"path":3569,"stem":3570},"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":3572,"path":3573,"stem":3574},"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":2553,"path":3576,"stem":3577,"children":3578},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F01.index",[3579,3580,3584,3588,3592,3596,3600,3604,3608,3612,3616,3620,3624,3628,3632,3636],{"title":2553,"path":3576,"stem":3577},{"title":3581,"path":3582,"stem":3583},"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":3585,"path":3586,"stem":3587},"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":3589,"path":3590,"stem":3591},"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":3593,"path":3594,"stem":3595},"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":3597,"path":3598,"stem":3599},"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":3601,"path":3602,"stem":3603},"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":3605,"path":3606,"stem":3607},"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":3609,"path":3610,"stem":3611},"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":3613,"path":3614,"stem":3615},"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":3617,"path":3618,"stem":3619},"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":3621,"path":3622,"stem":3623},"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":3625,"path":3626,"stem":3627},"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":3629,"path":3630,"stem":3631},"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":3633,"path":3634,"stem":3635},"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":3637,"path":3638,"stem":3639},"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":2587,"path":3641,"stem":3642,"children":3643},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F01.index",[3644,3645,3649,3653,3657,3661,3665,3669,3673,3677,3681,3685],{"title":2587,"path":3641,"stem":3642},{"title":3646,"path":3647,"stem":3648},"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":3650,"path":3651,"stem":3652},"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":3654,"path":3655,"stem":3656},"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":3658,"path":3659,"stem":3660},"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":3662,"path":3663,"stem":3664},"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":3666,"path":3667,"stem":3668},"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":3670,"path":3671,"stem":3672},"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":3674,"path":3675,"stem":3676},"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":3678,"path":3679,"stem":3680},"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":3682,"path":3683,"stem":3684},"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":3686,"path":3687,"stem":3688},"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":2617,"path":3690,"stem":3691,"children":3692},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F1.index",[3693,3694,3698,3702,3706,3710],{"title":2617,"path":3690,"stem":3691},{"title":3695,"path":3696,"stem":3697},"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":3699,"path":3700,"stem":3701},"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":3703,"path":3704,"stem":3705},"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":3707,"path":3708,"stem":3709},"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":3711,"path":3712,"stem":3713},"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":2627,"path":3715,"stem":3716,"children":3717},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F01.index",[3718,3719,3723,3727,3731,3735,3739,3743,3747,3751,3755,3759,3762,3766,3770,3774,3778,3782,3786,3790,3794,3798,3802],{"title":2627,"path":3715,"stem":3716},{"title":3720,"path":3721,"stem":3722},"MSC00-C. Compile cleanly at high warning levels","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F02.msc00-c",{"title":3724,"path":3725,"stem":3726},"MSC01-C. Strive for logical completeness","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F03.msc01-c",{"title":3728,"path":3729,"stem":3730},"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":3732,"path":3733,"stem":3734},"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":3736,"path":3737,"stem":3738},"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":3740,"path":3741,"stem":3742},"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":3744,"path":3745,"stem":3746},"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":3748,"path":3749,"stem":3750},"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":3752,"path":3753,"stem":3754},"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":3756,"path":3757,"stem":3758},"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":3760,"path":1257,"stem":3761},"MSC14-C. Do not introduce unnecessary platform dependencies","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F12.msc14-c",{"title":3763,"path":3764,"stem":3765},"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":3767,"path":3768,"stem":3769},"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":3771,"path":3772,"stem":3773},"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":3775,"path":3776,"stem":3777},"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":3779,"path":3780,"stem":3781},"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":3783,"path":3784,"stem":3785},"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":3787,"path":3788,"stem":3789},"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":3791,"path":3792,"stem":3793},"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":3795,"path":3796,"stem":3797},"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":3799,"path":3800,"stem":3801},"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":3803,"path":3804,"stem":3805},"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":2665,"path":3807,"stem":3808,"children":3809},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F1.index",[3810,3811,3815,3819,3823],{"title":2665,"path":3807,"stem":3808},{"title":3812,"path":3813,"stem":3814},"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":3816,"path":3817,"stem":3818},"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":3820,"path":3821,"stem":3822},"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":3824,"path":3825,"stem":3826},"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":2735,"path":3828,"stem":3829,"children":3830},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F01.index",[3831,3832,3836,3840,3844,3848,3852,3856,3860,3864,3867,3871,3875,3876],{"title":2735,"path":3828,"stem":3829},{"title":3833,"path":3834,"stem":3835},"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":3837,"path":3838,"stem":3839},"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":3841,"path":3842,"stem":3843},"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":3845,"path":3846,"stem":3847},"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":3849,"path":3850,"stem":3851},"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":3853,"path":3854,"stem":3855},"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":3857,"path":3858,"stem":3859},"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":3861,"path":3862,"stem":3863},"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":1527,"path":3865,"stem":3866},"\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":3868,"path":3869,"stem":3870},"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":3872,"path":3873,"stem":3874},"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":2099,"path":2051,"stem":2100},{"title":30,"path":2093,"stem":2095},{"title":2102,"path":2103,"stem":2104,"children":3878},[3879,3880,3884,3888],{"title":2102,"path":2103,"stem":2104},{"title":3881,"path":3882,"stem":3883},"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":3885,"path":3886,"stem":3887},"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":3889,"path":3890,"stem":3891},"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":3893,"path":3894,"stem":3895},"CERT manifest files","\u002Fsei-cert-c-coding-standard\u002Fcert-manifest-files","4.sei-cert-c-coding-standard\u002F09.cert-manifest-files",1775657840727]