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