[{"data":1,"prerenderedAt":960},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl03-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl03-f":743,"sidebar-sei-cert-fortran-coding-standard":752},[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":44,"extension":737,"meta":738,"navigation":7,"path":739,"seo":740,"stem":741,"__hash__":742},"content\u002F9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl03-f.md","DCL03-F. Avoid undefined behavior due to uninitialized variables",{"type":35,"value":36,"toc":727},"minimark",[37,41,45,48,56,59,62,82,87,90,255,269,274,287,319,329,359,363,366,388,395,398,419,425,468,471,481,523,526,532,554,561,582,586,589,666,689,693,723],[38,39,33],"h1",{"id":40},"dcl03-f-avoid-undefined-behavior-due-to-uninitialized-variables",[42,43,44],"p",{},"Accessing an uninitialized variable can lead to undefined behavior due to its\nindeterminate value.",[42,46,47],{},"Always initialize variables before using them, helping ensure deterministic\nbehavior and prevent bugs in the code.",[42,49,50,51,55],{},"Some programming languages automatically initialize variables to default\nvalues, but Fortran, C, and C++ often do not. Consequently, variables left\nuninitialized contain unpredictable data until they are explicitly set by the\nprogrammer. In ",[52,53,54],"strong",{},"Fortran",", reading any variable that has not been explicitly initialized\nresults in undefined behavior.",[42,57,58],{},"Since uninitialized variables may contain any arbitrary values, reading and\nusing them can lead to undefined behavior, potentially causing incorrect\nresults, crashes, or other unintended outcomes. Compilers are not required to\nwarn about these issues and, even if they do, they typically still allow the\ncode to compile and run.",[42,60,61],{},"Some compilers may appear to \"help\" by zero-initializing variables under\ncertain conditions (e.g., specific compilation flags). While this can make\ntechnically incorrect code run as originally intended, relying on such\nincidental behavior creates a false sense of security and masks underlying\nlogical errors. Ultimately, this can vanish under different compilation\nsettings and can vary between compilers.",[42,63,64,65,69,70,73,74,77,78,81],{},"Lastly, while some compilers provide options to automatically initialize\ncertain data types (e.g., ",[66,67,68],"code",{},"gfortran","'s ",[66,71,72],{},"-finit-integer=\u003Cvalue>"," or ",[66,75,76],{},"gcc","'s\n",[66,79,80],{},"-ftrivial-auto-var-init=\u003Cvalue>","), these features reduce portability to other\ndevelopment environments and hide problems in the code rather than addressing\nthem.",[83,84,86],"h2",{"id":85},"noncompliant-code-example","Noncompliant Code Example",[42,88,89],{},"Consider the following code, which aims to sum the elements of an array:",[91,92,94],"code-block",{"quality":93},"bad",[95,96,101],"pre",{"className":97,"code":98,"language":99,"meta":100,"style":100},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","! example_array.f90\nprogram main\n  use iso_fortran_env, only: real32\n  implicit none\n\n  real(kind=real32) :: array(5)\n  array = [0.24, 0.33, 0.17, 0.89, 0.05]\n\n  print *, \"Sum is:\", sum_array(array)\n\ncontains\n\n  pure real(kind=real32) function sum_array(array)\n    implicit none\n    real(kind=real32), intent(in) :: array(:)\n    real(kind=real32) :: sum\n    integer :: i\n\n    do i = 1, size(array, 1)\n      sum = sum + array(i)\n    end do\n\n    sum_array = sum\n  end function sum_array\n\nend program main\n","fortran","",[66,102,103,111,117,123,129,135,141,147,152,158,163,169,174,180,186,192,198,204,209,215,221,227,232,238,244,249],{"__ignoreMap":100},[104,105,108],"span",{"class":106,"line":107},"line",1,[104,109,110],{},"! example_array.f90\n",[104,112,114],{"class":106,"line":113},2,[104,115,116],{},"program main\n",[104,118,120],{"class":106,"line":119},3,[104,121,122],{},"  use iso_fortran_env, only: real32\n",[104,124,126],{"class":106,"line":125},4,[104,127,128],{},"  implicit none\n",[104,130,132],{"class":106,"line":131},5,[104,133,134],{"emptyLinePlaceholder":7},"\n",[104,136,138],{"class":106,"line":137},6,[104,139,140],{},"  real(kind=real32) :: array(5)\n",[104,142,144],{"class":106,"line":143},7,[104,145,146],{},"  array = [0.24, 0.33, 0.17, 0.89, 0.05]\n",[104,148,150],{"class":106,"line":149},8,[104,151,134],{"emptyLinePlaceholder":7},[104,153,155],{"class":106,"line":154},9,[104,156,157],{},"  print *, \"Sum is:\", sum_array(array)\n",[104,159,161],{"class":106,"line":160},10,[104,162,134],{"emptyLinePlaceholder":7},[104,164,166],{"class":106,"line":165},11,[104,167,168],{},"contains\n",[104,170,172],{"class":106,"line":171},12,[104,173,134],{"emptyLinePlaceholder":7},[104,175,177],{"class":106,"line":176},13,[104,178,179],{},"  pure real(kind=real32) function sum_array(array)\n",[104,181,183],{"class":106,"line":182},14,[104,184,185],{},"    implicit none\n",[104,187,189],{"class":106,"line":188},15,[104,190,191],{},"    real(kind=real32), intent(in) :: array(:)\n",[104,193,195],{"class":106,"line":194},16,[104,196,197],{},"    real(kind=real32) :: sum\n",[104,199,201],{"class":106,"line":200},17,[104,202,203],{},"    integer :: i\n",[104,205,207],{"class":106,"line":206},18,[104,208,134],{"emptyLinePlaceholder":7},[104,210,212],{"class":106,"line":211},19,[104,213,214],{},"    do i = 1, size(array, 1)\n",[104,216,218],{"class":106,"line":217},20,[104,219,220],{},"      sum = sum + array(i)\n",[104,222,224],{"class":106,"line":223},21,[104,225,226],{},"    end do\n",[104,228,230],{"class":106,"line":229},22,[104,231,134],{"emptyLinePlaceholder":7},[104,233,235],{"class":106,"line":234},23,[104,236,237],{},"    sum_array = sum\n",[104,239,241],{"class":106,"line":240},24,[104,242,243],{},"  end function sum_array\n",[104,245,247],{"class":106,"line":246},25,[104,248,134],{"emptyLinePlaceholder":7},[104,250,252],{"class":106,"line":251},26,[104,253,254],{},"end program main\n",[42,256,257,258,261,262,265,266,268],{},"Note how ",[66,259,260],{},"sum"," is never explicitly initialized. Although it might seem like it\n\"should\" logically start at ",[66,263,264],{},"0",", the Fortran standard does not guarantee this.\nThus, the initial value of ",[66,267,260],{}," is indeterminate, leading to different\noutcomes depending on the compiler settings.",[270,271,273],"h3",{"id":272},"implementation-details-unix","Implementation Details (Unix)",[42,275,276,277,280,281,283,284,286],{},"Consider the following compiler settings that produce different results. For instance, ",[66,278,279],{},"gfortran -O2"," appears to start ",[66,282,260],{}," at ",[66,285,264],{},", allowing the\nprogram to work as intended:",[95,288,292],{"className":289,"code":290,"language":291,"meta":100,"style":100},"language-txt shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","$ gfortran --version\nGNU Fortran (Debian 14.2.0-8) 14.2.0\n$ gfortran -O2 example_array.f90 -o example_array_gfortran\n$ .\u002Fexample_array_gfortran \n Sum is:   1.67999995\n","txt",[66,293,294,299,304,309,314],{"__ignoreMap":100},[104,295,296],{"class":106,"line":107},[104,297,298],{},"$ gfortran --version\n",[104,300,301],{"class":106,"line":113},[104,302,303],{},"GNU Fortran (Debian 14.2.0-8) 14.2.0\n",[104,305,306],{"class":106,"line":119},[104,307,308],{},"$ gfortran -O2 example_array.f90 -o example_array_gfortran\n",[104,310,311],{"class":106,"line":125},[104,312,313],{},"$ .\u002Fexample_array_gfortran \n",[104,315,316],{"class":106,"line":131},[104,317,318],{}," Sum is:   1.67999995\n",[42,320,321,322,325,326,328],{},"However, with ",[66,323,324],{},"flang -O2",", ",[66,327,260],{}," appears to contain arbitrary data, leading\nto incorrect results:",[95,330,332],{"className":289,"code":331,"language":291,"meta":100,"style":100},"$ flang-new --version\nDebian flang-new version 19.1.5 (1)\n$ flang-new -O2 example_array.f90 -o example_array_flang\n$ .\u002Fexample_array_flang \n Sum is: NaN\n",[66,333,334,339,344,349,354],{"__ignoreMap":100},[104,335,336],{"class":106,"line":107},[104,337,338],{},"$ flang-new --version\n",[104,340,341],{"class":106,"line":113},[104,342,343],{},"Debian flang-new version 19.1.5 (1)\n",[104,345,346],{"class":106,"line":119},[104,347,348],{},"$ flang-new -O2 example_array.f90 -o example_array_flang\n",[104,350,351],{"class":106,"line":125},[104,352,353],{},"$ .\u002Fexample_array_flang \n",[104,355,356],{"class":106,"line":131},[104,357,358],{}," Sum is: NaN\n",[83,360,362],{"id":361},"compliant-solution","Compliant Solution",[42,364,365],{},"The solution is straightforward, always initialize variables before using them:",[91,367,369],{"quality":368},"good",[95,370,372],{"className":97,"code":371,"language":99,"meta":100,"style":100},"real(kind=real32) :: sum\n\nsum = 0\n",[66,373,374,379,383],{"__ignoreMap":100},[104,375,376],{"class":106,"line":107},[104,377,378],{},"real(kind=real32) :: sum\n",[104,380,381],{"class":106,"line":113},[104,382,134],{"emptyLinePlaceholder":7},[104,384,385],{"class":106,"line":119},[104,386,387],{},"sum = 0\n",[42,389,390,391,394],{},"This principle applies to all variable types, including other elemental types\nlike ",[66,392,393],{},"integer",", derived types, and arrays.",[83,396,86],{"id":397},"noncompliant-code-example-1",[42,399,400,401,404,405,408,409,411,412,414,415,418],{},"Arrays are a critical part of simulation codes. For managing dynamic,\nn-dimensional arrays in Fortran, both ",[66,402,403],{},"pointer"," and ",[66,406,407],{},"allocatable"," variables are\navailable. The latter, introduced in Fortran 2003, are generally safer and more\nrobust. Unlike ",[66,410,403],{},", variables with the ",[66,413,407],{}," attribute\nautomatically free their memory and are always set by default to the\n",[66,416,417],{},"unallocated"," state.",[42,420,421,422,424],{},"For example, the following code technically leads to undefined behavior because\na ",[66,423,403],{}," is used without explicit initialization:",[91,426,427],{"quality":93},[95,428,430],{"className":97,"code":429,"language":99,"meta":100,"style":100},"program main\n  implicit none\n  integer, pointer :: array(:)\n\n  if (.not. associated(array)) then\n    print *, \"Undefined behavior\"\n  end if\nend program main\n",[66,431,432,436,440,445,449,454,459,464],{"__ignoreMap":100},[104,433,434],{"class":106,"line":107},[104,435,116],{},[104,437,438],{"class":106,"line":113},[104,439,128],{},[104,441,442],{"class":106,"line":119},[104,443,444],{},"  integer, pointer :: array(:)\n",[104,446,447],{"class":106,"line":125},[104,448,134],{"emptyLinePlaceholder":7},[104,450,451],{"class":106,"line":131},[104,452,453],{},"  if (.not. associated(array)) then\n",[104,455,456],{"class":106,"line":137},[104,457,458],{},"    print *, \"Undefined behavior\"\n",[104,460,461],{"class":106,"line":143},[104,462,463],{},"  end if\n",[104,465,466],{"class":106,"line":149},[104,467,254],{},[83,469,362],{"id":470},"compliant-solution-1",[42,472,473,474,476,477,480],{},"In contrast, an ",[66,475,407],{}," array can always be safely checked using the\n",[66,478,479],{},"allocated"," function, even when not explicitly initialized:",[91,482,483],{"quality":368},[95,484,486],{"className":97,"code":485,"language":99,"meta":100,"style":100},"program main\n  implicit none\n  integer, allocatable :: array(:)\n\n  if (.not. allocated(array)) then\n    print *, \"Defined behavior\"\n  end if\nend program main\n",[66,487,488,492,496,501,505,510,515,519],{"__ignoreMap":100},[104,489,490],{"class":106,"line":107},[104,491,116],{},[104,493,494],{"class":106,"line":113},[104,495,128],{},[104,497,498],{"class":106,"line":119},[104,499,500],{},"  integer, allocatable :: array(:)\n",[104,502,503],{"class":106,"line":125},[104,504,134],{"emptyLinePlaceholder":7},[104,506,507],{"class":106,"line":131},[104,508,509],{},"  if (.not. allocated(array)) then\n",[104,511,512],{"class":106,"line":137},[104,513,514],{},"    print *, \"Defined behavior\"\n",[104,516,517],{"class":106,"line":143},[104,518,463],{},[104,520,521],{"class":106,"line":149},[104,522,254],{},[42,524,525],{},"While these examples may seem trivial, these types of issues can arise in\nlarge, complex codebases where variables traverse multiple procedures and are\nsubject to intricate conditional logic.",[42,527,528,529,531],{},"If, for any reason, you still need to use ",[66,530,403],{}," variables, it's a good\npractice to nullify them as early as possible for additional safety. For module\nvariables and derived type initializations, you can nullify right at the point\nof declaration:",[91,533,534],{"quality":368},[95,535,537],{"className":97,"code":536,"language":99,"meta":100,"style":100},"type :: t\n  integer, pointer :: array(:) => null()\nend type\n",[66,538,539,544,549],{"__ignoreMap":100},[104,540,541],{"class":106,"line":107},[104,542,543],{},"type :: t\n",[104,545,546],{"class":106,"line":113},[104,547,548],{},"  integer, pointer :: array(:) => null()\n",[104,550,551],{"class":106,"line":119},[104,552,553],{},"end type\n",[42,555,556,557,560],{},"But within procedures, it's best to declare the pointer variable first and then\nnullify it. This avoids inadvertently introducing an implicit ",[66,558,559],{},"save"," behavior:",[91,562,563],{"quality":368},[95,564,566],{"className":97,"code":565,"language":99,"meta":100,"style":100},"integer, pointer :: array(:)\n\nnullify(array)\n",[66,567,568,573,577],{"__ignoreMap":100},[104,569,570],{"class":106,"line":107},[104,571,572],{},"integer, pointer :: array(:)\n",[104,574,575],{"class":106,"line":113},[104,576,134],{"emptyLinePlaceholder":7},[104,578,579],{"class":106,"line":119},[104,580,581],{},"nullify(array)\n",[83,583,585],{"id":584},"risk-assessment","Risk Assessment",[42,587,588],{},"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.",[590,591,592,613],"table",{},[593,594,595],"thead",{},[596,597,598,601,603,605,607,609,611],"tr",{},[599,600],"th",{},[599,602],{},[599,604],{},[599,606],{},[599,608],{},[599,610],{},[599,612],{},[614,615,616,640],"tbody",{},[596,617,618,622,625,628,631,634,637],{},[619,620,621],"td",{},"Recommendation",[619,623,624],{},"Severity",[619,626,627],{},"Likelihood",[619,629,630],{},"Detectable",[619,632,633],{},"Repairable",[619,635,636],{},"Priority",[619,638,639],{},"Level",[596,641,642,645,648,651,654,656,661],{},[619,643,644],{},"DCL03-F",[619,646,647],{},"High",[619,649,650],{},"Likely",[619,652,653],{},"Yes",[619,655,653],{},[619,657,658],{},[52,659,660],{},"P27",[619,662,663],{},[52,664,665],{},"L1",[42,667,668,676,677,676,683],{},[669,670,672],"a",{"href":671},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[673,674],"img",{"src":675},"attachments\u002F629047330\u002F638779511.png"," ",[669,678,680],{"href":679},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[673,681],{"src":682},"attachments\u002F629047330\u002F638779512.png",[669,684,686],{"href":685},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[673,687],{"src":688},"attachments\u002F629047330\u002F638779513.png",[83,690,692],{"id":691},"attachments","Attachments:",[694,695,699],"div",{"className":696,"align":698},[697],"greybox","left",[42,700,701,676,704,707,708,711,676,713,707,716,718,676,720,707],{},[673,702],{"alt":100,"src":703},"images\u002Ficons\u002Fbullet_blue.gif",[669,705,706],{"href":675},"button_arrow_left.png"," (image\u002Fpng)",[709,710],"br",{},[673,712],{"alt":100,"src":703},[669,714,715],{"href":682},"button_arrow_up.png",[709,717],{},[673,719],{"alt":100,"src":703},[669,721,722],{"href":688},"button_arrow_right.png",[724,725,726],"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":100,"searchDepth":113,"depth":113,"links":728},[729,732,733,734,735,736],{"id":85,"depth":113,"text":86,"children":730},[731],{"id":272,"depth":119,"text":273},{"id":361,"depth":113,"text":362},{"id":397,"depth":113,"text":86},{"id":470,"depth":113,"text":362},{"id":584,"depth":113,"text":585},{"id":691,"depth":113,"text":692},"md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl03-f",{"title":33,"description":44},"9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl03-f","VqVIdcPN7Le5Ck8Lgjp6nayNckKlhshvBCr9COX6pOo",[744,748],{"title":745,"path":746,"stem":747,"children":-1},"DCL02-F. Explicitly declare the 'save' attribute or split the variable initialization to prevent unintended behavior","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fdeclarations-and-initialization-dcl\u002Fdcl02-f","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F03.declarations-and-initialization-dcl\u002F2.dcl02-f",{"title":749,"path":750,"stem":751,"children":-1},"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",[753],{"title":754,"path":755,"stem":756,"children":757},"SEI CERT Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard\u002F01.index",[758,759,771,938,956],{"title":754,"path":755,"stem":756},{"title":760,"path":761,"stem":762,"children":763},"Front Matter","\u002Fsei-cert-fortran-coding-standard\u002Ffront-matter","9.sei-cert-fortran-coding-standard\u002F02.front-matter\u002F1.index",[764,765],{"title":760,"path":761,"stem":762},{"title":766,"path":767,"stem":768,"children":769},"Introduction","\u002Fsei-cert-fortran-coding-standard\u002Ffront-matter\u002Fintroduction","9.sei-cert-fortran-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[770],{"title":766,"path":767,"stem":768},{"title":772,"path":773,"stem":774,"children":775},"Guidelines","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F01.index",[776,777,799,816,842,852,862,880,898,916],{"title":772,"path":773,"stem":774},{"title":778,"path":779,"stem":780,"children":781},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F02.arrays-arr\u002F1.index",[782,783,787,791,795],{"title":778,"path":779,"stem":780},{"title":784,"path":785,"stem":786},"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":788,"path":789,"stem":790},"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":792,"path":793,"stem":794},"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":796,"path":797,"stem":798},"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":800,"path":801,"stem":802,"children":803},"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",[804,805,809,810,811,812],{"title":800,"path":801,"stem":802},{"title":806,"path":807,"stem":808},"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":745,"path":746,"stem":747},{"title":33,"path":739,"stem":741},{"title":749,"path":750,"stem":751},{"title":813,"path":814,"stem":815},"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":817,"path":818,"stem":819,"children":820},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F04.concurrency-con\u002F1.index",[821,822,826,830,834,838],{"title":817,"path":818,"stem":819},{"title":823,"path":824,"stem":825},"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":827,"path":828,"stem":829},"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":831,"path":832,"stem":833},"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":835,"path":836,"stem":837},"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":839,"path":840,"stem":841},"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":843,"path":844,"stem":845,"children":846},"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",[847,848],{"title":843,"path":844,"stem":845},{"title":849,"path":850,"stem":851},"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":853,"path":854,"stem":855,"children":856},"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",[857,858],{"title":853,"path":854,"stem":855},{"title":859,"path":860,"stem":861},"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":863,"path":864,"stem":865,"children":866},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F12.miscellaneous-msc\u002F1.index",[867,868,872,876],{"title":863,"path":864,"stem":865},{"title":869,"path":870,"stem":871},"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":873,"path":874,"stem":875},"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":877,"path":878,"stem":879},"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":881,"path":882,"stem":883,"children":884},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F13.procedures-prc\u002F1.index",[885,886,890,894],{"title":881,"path":882,"stem":883},{"title":887,"path":888,"stem":889},"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":891,"path":892,"stem":893},"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":895,"path":896,"stem":897},"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":899,"path":900,"stem":901,"children":902},"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",[903,904,908,912],{"title":899,"path":900,"stem":901},{"title":905,"path":906,"stem":907},"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":909,"path":910,"stem":911},"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":913,"path":914,"stem":915},"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":917,"path":918,"stem":919,"children":920},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Fguidelines\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F04.guidelines\u002F16.types-typ\u002F1.index",[921,922,926,930,934],{"title":917,"path":918,"stem":919},{"title":923,"path":924,"stem":925},"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":927,"path":928,"stem":929},"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":931,"path":932,"stem":933},"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":935,"path":936,"stem":937},"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":939,"path":940,"stem":941,"children":942},"Back Matter","\u002Fsei-cert-fortran-coding-standard\u002Fback-matter","9.sei-cert-fortran-coding-standard\u002F05.back-matter\u002F1.index",[943,944,948,952],{"title":939,"path":940,"stem":941},{"title":945,"path":946,"stem":947},"AA. Bibliography","\u002Fsei-cert-fortran-coding-standard\u002Fback-matter\u002Faa-bibliography","9.sei-cert-fortran-coding-standard\u002F05.back-matter\u002F2.aa-bibliography",{"title":949,"path":950,"stem":951},"BB. Definitions","\u002Fsei-cert-fortran-coding-standard\u002Fback-matter\u002Fbb-definitions","9.sei-cert-fortran-coding-standard\u002F05.back-matter\u002F3.bb-definitions",{"title":953,"path":954,"stem":955},"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":957,"path":958,"stem":959},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1785439591517]