[{"data":1,"prerenderedAt":1095},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl02-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl02-f":878,"sidebar-sei-cert-fortran-coding-standard":887},[4,8],{"title":5,"path":6,"_path":6,"fromAppConfig":7},"Home","\u002F",true,{"title":9,"path":10,"children":11,"_path":30,"fromAppConfig":7},"Coding Standards","\u002Fcoding-standards\u002F",[12,15,18,21,24,27],{"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},"Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard\u002F",{"title":25,"path":26},"Java Coding Standard","\u002Fsei-cert-oracle-coding-standard-for-java\u002F",{"title":28,"path":29},"Perl Coding Standard","\u002Fsei-cert-perl-coding-standard\u002F","\u002Fcoding-standards",{"id":32,"title":33,"body":34,"description":871,"extension":872,"meta":873,"navigation":7,"path":874,"seo":875,"stem":876,"__hash__":877},"content\u002F9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl02-f.md","DCL02-F. Explicitly declare the 'save' attribute or split the variable initialization to prevent unintended behavior",{"type":35,"value":36,"toc":860},"minimark",[37,41,50,56,72,78,87,90,95,113,283,288,303,340,344,350,484,487,500,542,592,595,601,660,663,669,714,718,721,799,822,826,856],[38,39,33],"h1",{"id":40},"dcl02-f-explicitly-declare-the-save-attribute-or-split-the-variable-initialization-to-prevent-unintended-behavior",[42,43,44,45,49],"p",{},"In Fortran, when a variable is initialized at its declaration, it implicitly\nacquires the ",[46,47,48],"code",{},"save"," attribute. This behavior obscures the program logic and is\noften unintended by the programmer, potentially breaking the program logic.",[42,51,52,53,55],{},"If the ",[46,54,48],{}," behavior is intentional, explicitly add the attribute in the\nvariable declaration to clarify the intent:",[57,58,63],"pre",{"className":59,"code":60,"language":61,"meta":62,"style":62},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","integer, save :: count = 0\n","fortran","",[46,64,65],{"__ignoreMap":62},[66,67,70],"span",{"class":68,"line":69},"line",1,[66,71,60],{},[42,73,74,75,77],{},"Otherwise, split the initialization of the variable from its declaration to\nremove the implicit ",[46,76,48],{}," behavior and prevent unintended effects.",[42,79,80,81,83,84,86],{},"A variable with the ",[46,82,48],{}," attribute retains its value across multiple\ninvocations of the procedure in which it is defined. The implicit ",[46,85,48],{},"\nbehavior can cause debugging difficulties, even when intended, and lead to\nhard-to-diagnose errors in program logic, particularly when working in complex\ncodebases where functions are called multiple times during execution.",[42,88,89],{},"This behavior differs from languages like C, C++, or Java, where local variables initialized in a declaration are re-initialized on every scope entry.",[91,92,94],"h2",{"id":93},"noncompliant-code-example","Noncompliant Code Example",[42,96,97,98,101,102,105,106,109,110,112],{},"Consider the code below, which computes the sum of the elements of various\narrays using the ",[46,99,100],{},"sum_array()"," function. Note how the variable ",[46,103,104],{},"result"," is set\nto ",[46,107,108],{},"0"," at its declaration, implicitly acquiring the ",[46,111,48],{}," behavior:",[114,115,117],"code-block",{"quality":116},"bad",[57,118,120],{"className":59,"code":119,"language":61,"meta":62,"style":62},"! example.f90\nprogram test_implicit_save\n  implicit none\n  integer, dimension(3) :: A = [1, 1, 1], B = [2, 2, 2]\n  integer :: result\n\n  result = sum_array(A)\n  print *, \"Sum of A:\", result ! Expected: 3\n\n  result = sum_array(B)\n  print *, \"Sum of B:\", result ! Expected: 6\n\ncontains\n\n  integer function sum_array(array)\n    implicit none\n    integer, intent(in) :: array(:)\n    integer :: result = 0\n    integer :: i\n\n    do i = 1, size(array)\n      result = result + array(i)\n    end do\n\n    sum_array = result\n  end function sum_array\n\nend program test_implicit_save\n",[46,121,122,127,133,139,145,151,157,163,169,174,180,186,191,197,202,208,214,220,226,232,237,243,249,255,260,266,272,277],{"__ignoreMap":62},[66,123,124],{"class":68,"line":69},[66,125,126],{},"! example.f90\n",[66,128,130],{"class":68,"line":129},2,[66,131,132],{},"program test_implicit_save\n",[66,134,136],{"class":68,"line":135},3,[66,137,138],{},"  implicit none\n",[66,140,142],{"class":68,"line":141},4,[66,143,144],{},"  integer, dimension(3) :: A = [1, 1, 1], B = [2, 2, 2]\n",[66,146,148],{"class":68,"line":147},5,[66,149,150],{},"  integer :: result\n",[66,152,154],{"class":68,"line":153},6,[66,155,156],{"emptyLinePlaceholder":7},"\n",[66,158,160],{"class":68,"line":159},7,[66,161,162],{},"  result = sum_array(A)\n",[66,164,166],{"class":68,"line":165},8,[66,167,168],{},"  print *, \"Sum of A:\", result ! Expected: 3\n",[66,170,172],{"class":68,"line":171},9,[66,173,156],{"emptyLinePlaceholder":7},[66,175,177],{"class":68,"line":176},10,[66,178,179],{},"  result = sum_array(B)\n",[66,181,183],{"class":68,"line":182},11,[66,184,185],{},"  print *, \"Sum of B:\", result ! Expected: 6\n",[66,187,189],{"class":68,"line":188},12,[66,190,156],{"emptyLinePlaceholder":7},[66,192,194],{"class":68,"line":193},13,[66,195,196],{},"contains\n",[66,198,200],{"class":68,"line":199},14,[66,201,156],{"emptyLinePlaceholder":7},[66,203,205],{"class":68,"line":204},15,[66,206,207],{},"  integer function sum_array(array)\n",[66,209,211],{"class":68,"line":210},16,[66,212,213],{},"    implicit none\n",[66,215,217],{"class":68,"line":216},17,[66,218,219],{},"    integer, intent(in) :: array(:)\n",[66,221,223],{"class":68,"line":222},18,[66,224,225],{},"    integer :: result = 0\n",[66,227,229],{"class":68,"line":228},19,[66,230,231],{},"    integer :: i\n",[66,233,235],{"class":68,"line":234},20,[66,236,156],{"emptyLinePlaceholder":7},[66,238,240],{"class":68,"line":239},21,[66,241,242],{},"    do i = 1, size(array)\n",[66,244,246],{"class":68,"line":245},22,[66,247,248],{},"      result = result + array(i)\n",[66,250,252],{"class":68,"line":251},23,[66,253,254],{},"    end do\n",[66,256,258],{"class":68,"line":257},24,[66,259,156],{"emptyLinePlaceholder":7},[66,261,263],{"class":68,"line":262},25,[66,264,265],{},"    sum_array = result\n",[66,267,269],{"class":68,"line":268},26,[66,270,271],{},"  end function sum_array\n",[66,273,275],{"class":68,"line":274},27,[66,276,156],{"emptyLinePlaceholder":7},[66,278,280],{"class":68,"line":279},28,[66,281,282],{},"end program test_implicit_save\n",[284,285,287],"h3",{"id":286},"implementation-details-unix","Implementation Details (Unix)",[42,289,290,291,293,294,296,297,299,300,302],{},"Each time ",[46,292,100],{}," is called, one might expect ",[46,295,104],{}," to be set to ",[46,298,108],{},"\nand then add the elements of the target array. However, ",[46,301,104],{}," retains its\nvalue between calls, breaking the intended logic for the program:",[57,304,308],{"className":305,"code":306,"language":307,"meta":62,"style":62},"language-txt shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","$ gfortran --version\nGNU Fortran (Debian 12.2.0-14) 12.2.0\n$ gfortran example.f90\n$ .\u002Fa.out\n Sum of A:           3\n Sum of B:           9\n","txt",[46,309,310,315,320,325,330,335],{"__ignoreMap":62},[66,311,312],{"class":68,"line":69},[66,313,314],{},"$ gfortran --version\n",[66,316,317],{"class":68,"line":129},[66,318,319],{},"GNU Fortran (Debian 12.2.0-14) 12.2.0\n",[66,321,322],{"class":68,"line":135},[66,323,324],{},"$ gfortran example.f90\n",[66,326,327],{"class":68,"line":141},[66,328,329],{},"$ .\u002Fa.out\n",[66,331,332],{"class":68,"line":147},[66,333,334],{}," Sum of A:           3\n",[66,336,337],{"class":68,"line":153},[66,338,339],{}," Sum of B:           9\n",[91,341,343],{"id":342},"compliant-solution","Compliant Solution",[42,345,346,347,349],{},"While resolving the issue is as simple as splitting the initialization of\n",[46,348,104],{}," to a separate line, this type of bug can be particularly challenging\nto diagnose in complex codebases:",[114,351,353],{"quality":352},"good",[57,354,356],{"className":59,"code":355,"language":61,"meta":62,"style":62},"! solution.f90\nprogram test_implicit_save\n  implicit none\n  integer, dimension(3) :: A = [1, 1, 1], B = [2, 2, 2]\n  integer :: result\n\n  result = sum_array(A)\n  print *, \"Sum of A:\", result ! Expected: 3\n\n  result = sum_array(B)\n  print *, \"Sum of B:\", result ! Expected: 6\n\ncontains\n\n  pure integer function sum_array(array)\n    implicit none\n    integer, intent(in) :: array(:)\n    integer :: result\n    integer :: i\n\n    result = 0\n\n    do i = 1, size(array)\n      result = result + array(i)\n    end do\n\n    sum_array = result\n  end function sum_array\n\nend program test_implicit_save\n",[46,357,358,363,367,371,375,379,383,387,391,395,399,403,407,411,415,420,424,428,433,437,441,446,450,454,458,462,466,470,474,479],{"__ignoreMap":62},[66,359,360],{"class":68,"line":69},[66,361,362],{},"! solution.f90\n",[66,364,365],{"class":68,"line":129},[66,366,132],{},[66,368,369],{"class":68,"line":135},[66,370,138],{},[66,372,373],{"class":68,"line":141},[66,374,144],{},[66,376,377],{"class":68,"line":147},[66,378,150],{},[66,380,381],{"class":68,"line":153},[66,382,156],{"emptyLinePlaceholder":7},[66,384,385],{"class":68,"line":159},[66,386,162],{},[66,388,389],{"class":68,"line":165},[66,390,168],{},[66,392,393],{"class":68,"line":171},[66,394,156],{"emptyLinePlaceholder":7},[66,396,397],{"class":68,"line":176},[66,398,179],{},[66,400,401],{"class":68,"line":182},[66,402,185],{},[66,404,405],{"class":68,"line":188},[66,406,156],{"emptyLinePlaceholder":7},[66,408,409],{"class":68,"line":193},[66,410,196],{},[66,412,413],{"class":68,"line":199},[66,414,156],{"emptyLinePlaceholder":7},[66,416,417],{"class":68,"line":204},[66,418,419],{},"  pure integer function sum_array(array)\n",[66,421,422],{"class":68,"line":210},[66,423,213],{},[66,425,426],{"class":68,"line":216},[66,427,219],{},[66,429,430],{"class":68,"line":222},[66,431,432],{},"    integer :: result\n",[66,434,435],{"class":68,"line":228},[66,436,231],{},[66,438,439],{"class":68,"line":234},[66,440,156],{"emptyLinePlaceholder":7},[66,442,443],{"class":68,"line":239},[66,444,445],{},"    result = 0\n",[66,447,448],{"class":68,"line":245},[66,449,156],{"emptyLinePlaceholder":7},[66,451,452],{"class":68,"line":251},[66,453,242],{},[66,455,456],{"class":68,"line":257},[66,457,248],{},[66,459,460],{"class":68,"line":262},[66,461,254],{},[66,463,464],{"class":68,"line":268},[66,465,156],{"emptyLinePlaceholder":7},[66,467,468],{"class":68,"line":274},[66,469,265],{},[66,471,472],{"class":68,"line":279},[66,473,271],{},[66,475,477],{"class":68,"line":476},29,[66,478,156],{"emptyLinePlaceholder":7},[66,480,482],{"class":68,"line":481},30,[66,483,282],{},[91,485,94],{"id":486},"noncompliant-code-example-1",[42,488,489,490,493,494,496,497,499],{},"In this noncompliant example, the programmer intends for ",[46,491,492],{},"counter"," to be a local temporary variable that starts at ",[46,495,108],{}," every time the subroutine is called. However, because it is initialized in the declaration statement, it implicitly has the ",[46,498,48],{}," attribute.",[42,501,502,503,505,506,508,509,512,513,516,517,520,521,523,524,527,528,530,531,533,534,536,537,523,539,541],{},"The variable ",[46,504,492],{}," retains its value between calls due to the implicit ",[46,507,48],{}," . If the subroutine ",[46,510,511],{},"process_data()"," is called twice with the dummy argument ",[46,514,515],{},"val"," set to the contanst value ",[46,518,519],{},"5"," , then the printed outputs will be ",[46,522,519],{}," and ",[46,525,526],{},"10",". Without the ",[46,529,48],{}," attribute, ",[46,532,492],{},"would be set to ",[46,535,108],{}," in each subroutine call and the printed output would be ",[46,538,519],{},[46,540,519],{},".",[114,543,544],{"quality":116},[57,545,547],{"className":59,"code":546,"language":61,"meta":62,"style":62},"subroutine process_data(val)\n  implicit none\n  integer, intent(in) :: val\n  ! Noncompliant: The variable implicitly has the save attribute\n  integer             :: counter = 0\n\n  counter = counter + val\n  print *, \"Cumulative internal value:\", counter\nend subroutine process_data\n",[46,548,549,554,558,563,568,573,577,582,587],{"__ignoreMap":62},[66,550,551],{"class":68,"line":69},[66,552,553],{},"subroutine process_data(val)\n",[66,555,556],{"class":68,"line":129},[66,557,138],{},[66,559,560],{"class":68,"line":135},[66,561,562],{},"  integer, intent(in) :: val\n",[66,564,565],{"class":68,"line":141},[66,566,567],{},"  ! Noncompliant: The variable implicitly has the save attribute\n",[66,569,570],{"class":68,"line":147},[66,571,572],{},"  integer             :: counter = 0\n",[66,574,575],{"class":68,"line":153},[66,576,156],{"emptyLinePlaceholder":7},[66,578,579],{"class":68,"line":159},[66,580,581],{},"  counter = counter + val\n",[66,583,584],{"class":68,"line":165},[66,585,586],{},"  print *, \"Cumulative internal value:\", counter\n",[66,588,589],{"class":68,"line":171},[66,590,591],{},"end subroutine process_data\n",[91,593,343],{"id":594},"compliant-solution-1",[42,596,597,598,600],{},"In this compliant solution, the programmer intends for the variable to be local and re-initialized to ",[46,599,108],{}," in each subroutine call. Thus the initialization is moved to the execution statement, away from the declaration statement.",[114,602,603],{"quality":352},[57,604,606],{"className":59,"code":605,"language":61,"meta":62,"style":62},"subroutine process_data(val, result)\n  implicit none\n  integer, intent(in)  :: val\n  integer, intent(out) :: result\n  integer              :: temp_val\n\n  ! Compliant: The variable is not initialized in the declaration statement\n  temp_val = 0\n  temp_val = temp_val + val\n  result = temp_val\nend subroutine process_data\n",[46,607,608,613,617,622,627,632,636,641,646,651,656],{"__ignoreMap":62},[66,609,610],{"class":68,"line":69},[66,611,612],{},"subroutine process_data(val, result)\n",[66,614,615],{"class":68,"line":129},[66,616,138],{},[66,618,619],{"class":68,"line":135},[66,620,621],{},"  integer, intent(in)  :: val\n",[66,623,624],{"class":68,"line":141},[66,625,626],{},"  integer, intent(out) :: result\n",[66,628,629],{"class":68,"line":147},[66,630,631],{},"  integer              :: temp_val\n",[66,633,634],{"class":68,"line":153},[66,635,156],{"emptyLinePlaceholder":7},[66,637,638],{"class":68,"line":159},[66,639,640],{},"  ! Compliant: The variable is not initialized in the declaration statement\n",[66,642,643],{"class":68,"line":165},[66,644,645],{},"  temp_val = 0\n",[66,647,648],{"class":68,"line":171},[66,649,650],{},"  temp_val = temp_val + val\n",[66,652,653],{"class":68,"line":176},[66,654,655],{},"  result = temp_val\n",[66,657,658],{"class":68,"line":182},[66,659,591],{},[91,661,343],{"id":662},"compliant-solution-2",[42,664,665,666,668],{},"In this compliant solution, the programmer intends for the variable to be persistent (a \"static\" counter). Thus, the ",[46,667,48],{}," attribute is explicitly declared to make the program logic clear to the reader.",[114,670,671],{"quality":352},[57,672,674],{"className":59,"code":673,"language":61,"meta":62,"style":62},"subroutine process_data(val)\n  implicit none\n  integer, intent(in) :: val\n  ! Compliant: The variable has the save attribute explicitly\n  integer, save       :: counter = 0\n\n  counter = counter + val\n  print *, \"Cumulative internal value:\", counter\nend subroutine process_data\n",[46,675,676,680,684,688,693,698,702,706,710],{"__ignoreMap":62},[66,677,678],{"class":68,"line":69},[66,679,553],{},[66,681,682],{"class":68,"line":129},[66,683,138],{},[66,685,686],{"class":68,"line":135},[66,687,562],{},[66,689,690],{"class":68,"line":141},[66,691,692],{},"  ! Compliant: The variable has the save attribute explicitly\n",[66,694,695],{"class":68,"line":147},[66,696,697],{},"  integer, save       :: counter = 0\n",[66,699,700],{"class":68,"line":153},[66,701,156],{"emptyLinePlaceholder":7},[66,703,704],{"class":68,"line":159},[66,705,581],{},[66,707,708],{"class":68,"line":165},[66,709,586],{},[66,711,712],{"class":68,"line":171},[66,713,591],{},[91,715,717],{"id":716},"risk-assessment","Risk Assessment",[42,719,720],{},"Undefined behavior can produce incorrect results, silent data corruption, crashes, or nondeterministic behavior that varies across compilers or platforms. Programmers should ensure that the code avoids undefined behavior in all cases, including parallel and multi-threaded environments.",[722,723,724,745],"table",{},[725,726,727],"thead",{},[728,729,730,733,735,737,739,741,743],"tr",{},[731,732],"th",{},[731,734],{},[731,736],{},[731,738],{},[731,740],{},[731,742],{},[731,744],{},[746,747,748,772],"tbody",{},[728,749,750,754,757,760,763,766,769],{},[751,752,753],"td",{},"Recommendation",[751,755,756],{},"Severity",[751,758,759],{},"Likelihood",[751,761,762],{},"Detectable",[751,764,765],{},"Repairable",[751,767,768],{},"Priority",[751,770,771],{},"Level",[728,773,774,777,780,783,786,788,794],{},[751,775,776],{},"DCL02-F",[751,778,779],{},"High",[751,781,782],{},"Likely",[751,784,785],{},"Yes",[751,787,785],{},[751,789,790],{},[791,792,793],"strong",{},"P27",[751,795,796],{},[791,797,798],{},"L1",[42,800,801,809,810,809,816],{},[802,803,805],"a",{"href":804},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[806,807],"img",{"src":808},"attachments\u002F629047330\u002F638779511.png"," ",[802,811,813],{"href":812},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[806,814],{"src":815},"attachments\u002F629047330\u002F638779512.png",[802,817,819],{"href":818},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[806,820],{"src":821},"attachments\u002F629047330\u002F638779513.png",[91,823,825],{"id":824},"attachments","Attachments:",[827,828,832],"div",{"className":829,"align":831},[830],"greybox","left",[42,833,834,809,837,840,841,844,809,846,840,849,851,809,853,840],{},[806,835],{"alt":62,"src":836},"images\u002Ficons\u002Fbullet_blue.gif",[802,838,839],{"href":808},"button_arrow_left.png"," (image\u002Fpng)",[842,843],"br",{},[806,845],{"alt":62,"src":836},[802,847,848],{"href":815},"button_arrow_up.png",[842,850],{},[806,852],{"alt":62,"src":836},[802,854,855],{"href":821},"button_arrow_right.png",[857,858,859],"style",{},"html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}",{"title":62,"searchDepth":129,"depth":129,"links":861},[862,865,866,867,868,869,870],{"id":93,"depth":129,"text":94,"children":863},[864],{"id":286,"depth":135,"text":287},{"id":342,"depth":129,"text":343},{"id":486,"depth":129,"text":94},{"id":594,"depth":129,"text":343},{"id":662,"depth":129,"text":343},{"id":716,"depth":129,"text":717},{"id":824,"depth":129,"text":825},"In Fortran, when a variable is initialized at its declaration, it implicitly\nacquires the save attribute. This behavior obscures the program logic and is\noften unintended by the programmer, potentially breaking the program logic.","md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl02-f",{"title":33,"description":871},"9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl02-f","g8vupNknLlQlrxh447fY1QgZoKedkO3l6uXsz2NtIoc",[879,883],{"title":880,"path":881,"stem":882,"children":-1},"DCL01-F. Explicitly declare pure procedures","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl01-f",{"title":884,"path":885,"stem":886,"children":-1},"DCL03-F. Avoid undefined behavior due to uninitialized variables","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl03-f",[888],{"title":889,"path":890,"stem":891,"children":892},"SEI CERT Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard\u002F01.index",[893,894,906,1073,1091],{"title":889,"path":890,"stem":891},{"title":895,"path":896,"stem":897,"children":898},"Front Matter","\u002Fsei-cert-fortran-coding-standard\u002Ffront-matter","9.sei-cert-fortran-coding-standard\u002F02.front-matter\u002F1.index",[899,900],{"title":895,"path":896,"stem":897},{"title":901,"path":902,"stem":903,"children":904},"Introduction","\u002Fsei-cert-fortran-coding-standard\u002Ffront-matter\u002Fintroduction","9.sei-cert-fortran-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[905],{"title":901,"path":902,"stem":903},{"title":907,"path":908,"stem":909,"children":910},"Guidelines","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F01.index",[911,912,934,951,977,987,997,1015,1033,1051],{"title":907,"path":908,"stem":909},{"title":913,"path":914,"stem":915,"children":916},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F1.index",[917,918,922,926,930],{"title":913,"path":914,"stem":915},{"title":919,"path":920,"stem":921},"ARR01-F. Do not use out-of-bounds arrays subscripts","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr\u002Farr01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F2.arr01-f",{"title":923,"path":924,"stem":925},"ARR02-F. Declare array dummy arguments as assumed-shape","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr\u002Farr02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F3.arr02-f",{"title":927,"path":928,"stem":929},"ARR03-F. Specify array bounds when copying data to device memory","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr\u002Farr03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F4.arr03-f",{"title":931,"path":932,"stem":933},"ARR04-F. Ensure arrays ranges mapped to devices cover all accessed elements","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr\u002Farr04-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F5.arr04-f",{"title":935,"path":936,"stem":937,"children":938},"Declarations and Initialization (DCL)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F1.index",[939,940,941,942,943,947],{"title":935,"path":936,"stem":937},{"title":880,"path":881,"stem":882},{"title":33,"path":874,"stem":876},{"title":884,"path":885,"stem":886},{"title":944,"path":945,"stem":946},"DCL04-F. Conditionally initialized variables can lead to undefined behavior","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl04-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl04-f",{"title":948,"path":949,"stem":950},"DCL05-F. Uninitialized output arguments can lead to undefined behavior","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl05-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl05-f",{"title":952,"path":953,"stem":954,"children":955},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F1.index",[956,957,961,965,969,973],{"title":952,"path":953,"stem":954},{"title":958,"path":959,"stem":960},"CON01-F. Explicitly declare OpenMP data-sharing attributes for all variables","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F2.con01-f",{"title":962,"path":963,"stem":964},"CON02-F. Protect reduction variables in multithreaded code","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F3.con02-f",{"title":966,"path":967,"stem":968},"CON03-F. Protect multithreading recurrences to avoid data races","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F4.con03-f",{"title":970,"path":971,"stem":972},"CON04-F. Do not use out-of-dimension subscripts in multithreaded code","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon04-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F5.con04-f",{"title":974,"path":975,"stem":976},"CON05-F. Ensure correct OpenMP datascoping of variables in parallel regions","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con\u002Fcon05-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F6.con05-f",{"title":978,"path":979,"stem":980,"children":981},"Exceptions and IEEE Arithmetic (EIA)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fexceptions-and-ieee-arithmetic-eia","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F05.exceptions-and-ieee-arithmetic-eia\u002F1.index",[982,983],{"title":978,"path":979,"stem":980},{"title":984,"path":985,"stem":986},"EIA01-F. Enforce evaluation order in floating-point expressions","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fexceptions-and-ieee-arithmetic-eia\u002Feia01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F05.exceptions-and-ieee-arithmetic-eia\u002F2.eia01-f",{"title":988,"path":989,"stem":990,"children":991},"Expressions and Assignment (EXA)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fexpressions-and-assignment-exa","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F07.expressions-and-assignment-exa\u002F1.index",[992,993],{"title":988,"path":989,"stem":990},{"title":994,"path":995,"stem":996},"EXA01-F. Do not read uninitialized memory","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fexpressions-and-assignment-exa\u002Fexa01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F07.expressions-and-assignment-exa\u002F2.exa01-f",{"title":998,"path":999,"stem":1000,"children":1001},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F1.index",[1002,1003,1007,1011],{"title":998,"path":999,"stem":1000},{"title":1004,"path":1005,"stem":1006},"MSC01-F. Avoid using legacy or obsolescent Fortran constructs","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc\u002Fmsc01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F2.msc01-f",{"title":1008,"path":1009,"stem":1010},"MSC02-F. Beware of compiler-specific extensions","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc\u002Fmsc02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F3.msc02-f",{"title":1012,"path":1013,"stem":1014},"MSC03-F. Do not depend on undefined behavior","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc\u002Fmsc03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F4.msc03-f",{"title":1016,"path":1017,"stem":1018,"children":1019},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F1.index",[1020,1021,1025,1029],{"title":1016,"path":1017,"stem":1018},{"title":1022,"path":1023,"stem":1024},"PRC01-F. Disable the implicit declaration of procedures","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc\u002Fprc01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F2.prc01-f",{"title":1026,"path":1027,"stem":1028},"PRC02-F. Avoid implicit interfaces by using module procedures","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc\u002Fprc02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F3.prc02-f",{"title":1030,"path":1031,"stem":1032},"PRC03-F. Declare the intent for all dummy arguments","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc\u002Fprc03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F4.prc03-f",{"title":1034,"path":1035,"stem":1036,"children":1037},"Scope, Association, and Definition (SAD)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fscope-association-and-definition-sad","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F15.scope-association-and-definition-sad\u002F1.index",[1038,1039,1043,1047],{"title":1034,"path":1035,"stem":1036},{"title":1040,"path":1041,"stem":1042},"SAD02-F. Minimize imported module entities using the ONLY clause","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fscope-association-and-definition-sad\u002Fsad02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F15.scope-association-and-definition-sad\u002F2.sad02-f",{"title":1044,"path":1045,"stem":1046},"SAD03-F. Replace common block with modules for safer data encapsulation","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fscope-association-and-definition-sad\u002Fsad03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F15.scope-association-and-definition-sad\u002F3.sad03-f",{"title":1048,"path":1049,"stem":1050},"Limit the scope of variables and procedures","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fscope-association-and-definition-sad\u002Flimit-the-scope-of-variables-and-procedures","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F15.scope-association-and-definition-sad\u002F4.limit-the-scope-of-variables-and-procedures",{"title":1052,"path":1053,"stem":1054,"children":1055},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F1.index",[1056,1057,1061,1065,1069],{"title":1052,"path":1053,"stem":1054},{"title":1058,"path":1059,"stem":1060},"TYP01-F. Use Intrinsic Assignment for Character Entities","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ\u002Ftyp01-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F2.typ01-f",{"title":1062,"path":1063,"stem":1064},"TYP02-F. Prohibit implicit typing in all program units","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ\u002Ftyp02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F3.typ02-f",{"title":1066,"path":1067,"stem":1068},"TYP03-F. Ensure intrinsic function arguments match intended precision","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ\u002Ftyp03-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F4.typ03-f",{"title":1070,"path":1071,"stem":1072},"TYP04-F. Centralize kind definitions to ensure consistent precision","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ\u002Ftyp04-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F5.typ04-f",{"title":1074,"path":1075,"stem":1076,"children":1077},"Back Matter","\u002Fsei-cert-fortran-coding-standard\u002Fback-matter","9.sei-cert-fortran-coding-standard\u002F05.back-matter\u002F1.index",[1078,1079,1083,1087],{"title":1074,"path":1075,"stem":1076},{"title":1080,"path":1081,"stem":1082},"AA. Bibliography","\u002Fsei-cert-fortran-coding-standard\u002Fback-matter\u002Faa-bibliography","9.sei-cert-fortran-coding-standard\u002F05.back-matter\u002F2.aa-bibliography",{"title":1084,"path":1085,"stem":1086},"BB. Definitions","\u002Fsei-cert-fortran-coding-standard\u002Fback-matter\u002Fbb-definitions","9.sei-cert-fortran-coding-standard\u002F05.back-matter\u002F3.bb-definitions",{"title":1088,"path":1089,"stem":1090},"CC. Undefined Behavior","\u002Fsei-cert-fortran-coding-standard\u002Fback-matter\u002Fcc-undefined-behavior","9.sei-cert-fortran-coding-standard\u002F05.back-matter\u002F4.cc-undefined-behavior",{"title":1092,"path":1093,"stem":1094},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1785439591516]