[{"data":1,"prerenderedAt":966},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr01-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr01-f":772,"sidebar-sei-cert-fortran-coding-standard":781},[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":766,"meta":767,"navigation":7,"path":768,"seo":769,"stem":770,"__hash__":771},"content\u002F9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F2.arr01-f.md","ARR01-F. Do not use out-of-bounds arrays subscripts",{"type":35,"value":36,"toc":755},"minimark",[37,41,45,53,56,59,72,77,100,175,179,182,232,235,249,315,318,325,383,386,405,480,483,486,575,579,582,660,664,692,695,717,721,751],[38,39,33],"h1",{"id":40},"arr01-f-do-not-use-out-of-bounds-arrays-subscripts",[42,43,44],"p",{},"Program units shall not reference an array element using a subscript that is outside the declared bounds of that dimension.",[42,46,47,48,52],{},"In Fortran, array bounds strictly define the valid index range for each dimension. By default, arrays are indexed from 1 to ",[49,50,51],"code",{},"size"," , unlike many other programming languages that use zero-based indexing. Even though arrays are stored in column-major order, relying on memory layout to access elements outside the defined range is non-conforming and produces undefined behavior.",[42,54,55],{},"Accessing an array out of bounds results in undefined behavior, even if the calculated memory address falls within the total allocated storage of the array.",[42,57,58],{},"Violation may lead to:",[60,61,62,66,69],"ol",{},[63,64,65],"li",{},"Memory corruption: writing to an out-of-bounds index may overwrite adjacent variables, return addresses, or internal runtime descriptors.",[63,67,68],{},"Program termination: the operating system may terminate the program with a segmentation fault or access violation.",[63,70,71],{},"Data races: in parallel execution, out-of-bounds access can inadvertently modify data owned by other threads or images, leading to race conditions.",[73,74,76],"h2",{"id":75},"noncompliant-code-example","Noncompliant Code Example",[42,78,79,80,83,84,87,88,91,92,95,96,99],{},"In this noncompliant example, the programmer attempts to initialize a standard 1-based array. However, the loop variable ",[49,81,82],{},"i"," iterates from ",[49,85,86],{},"0"," to ",[49,89,90],{},"10",". The access ",[49,93,94],{},"A(0)"," violates the lower bound of the array (which defaults to ",[49,97,98],{},"1",").",[101,102,104],"code-block",{"quality":103},"bad",[105,106,111],"pre",{"className":107,"code":108,"language":109,"meta":110,"style":110},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","program main\n  implicit none\n  integer :: i\n  real    :: A(10)\n\n  ! Noncompliant: Loop starts at 0, but A has implicit lower bound 1\n  do i = 0, 10\n    A(i) = real(i)\n  end do\nend program main\n","fortran","",[49,112,113,121,127,133,139,145,151,157,163,169],{"__ignoreMap":110},[114,115,118],"span",{"class":116,"line":117},"line",1,[114,119,120],{},"program main\n",[114,122,124],{"class":116,"line":123},2,[114,125,126],{},"  implicit none\n",[114,128,130],{"class":116,"line":129},3,[114,131,132],{},"  integer :: i\n",[114,134,136],{"class":116,"line":135},4,[114,137,138],{},"  real    :: A(10)\n",[114,140,142],{"class":116,"line":141},5,[114,143,144],{"emptyLinePlaceholder":7},"\n",[114,146,148],{"class":116,"line":147},6,[114,149,150],{},"  ! Noncompliant: Loop starts at 0, but A has implicit lower bound 1\n",[114,152,154],{"class":116,"line":153},7,[114,155,156],{},"  do i = 0, 10\n",[114,158,160],{"class":116,"line":159},8,[114,161,162],{},"    A(i) = real(i)\n",[114,164,166],{"class":116,"line":165},9,[114,167,168],{},"  end do\n",[114,170,172],{"class":116,"line":171},10,[114,173,174],{},"end program main\n",[73,176,178],{"id":177},"compliant-solution","Compliant Solution",[42,180,181],{},"In this compliant solution, the loop bounds are adjusted to match the array declaration.",[101,183,185],{"quality":184},"good",[105,186,188],{"className":107,"code":187,"language":109,"meta":110,"style":110},"program main\n  implicit none\n  integer :: i\n  real    :: A(10)\n\n  ! Compliant: Loop iterates from 1 to 10.\n  do i = 1, 10\n    A(i) = real(i)\n  end do\nend program main\n",[49,189,190,194,198,202,206,210,215,220,224,228],{"__ignoreMap":110},[114,191,192],{"class":116,"line":117},[114,193,120],{},[114,195,196],{"class":116,"line":123},[114,197,126],{},[114,199,200],{"class":116,"line":129},[114,201,132],{},[114,203,204],{"class":116,"line":135},[114,205,138],{},[114,207,208],{"class":116,"line":141},[114,209,144],{"emptyLinePlaceholder":7},[114,211,212],{"class":116,"line":147},[114,213,214],{},"  ! Compliant: Loop iterates from 1 to 10.\n",[114,216,217],{"class":116,"line":153},[114,218,219],{},"  do i = 1, 10\n",[114,221,222],{"class":116,"line":159},[114,223,162],{},[114,225,226],{"class":116,"line":165},[114,227,168],{},[114,229,230],{"class":116,"line":171},[114,231,174],{},[73,233,76],{"id":234},"noncompliant-code-example-1",[42,236,237,238,241,242,245,246,248],{},"In this noncompliant example, while ",[49,239,240],{},"matrix(6, 1)"," and ",[49,243,244],{},"matrix(1, 2)"," might occupy adjacent memory addresses in a contiguous storage sequence, the Fortran standard dictates that each subscript must be within its declared bounds. Accessing ",[49,247,240],{}," is a violation of the standard and is unsafe.",[101,250,251],{"quality":103},[105,252,254],{"className":107,"code":253,"language":109,"meta":110,"style":110},"subroutine init_matrix(matrix)\n  implicit none\n  real, intent(out) :: matrix(5, 5)\n  integer           :: i, j\n\n  ! Noncompliant: Inner loop iterates i from 1 to 6.\n  do j = 1, 4\n    do i = 1, 6\n      matrix(i, j) = 0.0\n    end do\n  end do\nend subroutine init_matrix\n",[49,255,256,261,265,270,275,279,284,289,294,299,304,309],{"__ignoreMap":110},[114,257,258],{"class":116,"line":117},[114,259,260],{},"subroutine init_matrix(matrix)\n",[114,262,263],{"class":116,"line":123},[114,264,126],{},[114,266,267],{"class":116,"line":129},[114,268,269],{},"  real, intent(out) :: matrix(5, 5)\n",[114,271,272],{"class":116,"line":135},[114,273,274],{},"  integer           :: i, j\n",[114,276,277],{"class":116,"line":141},[114,278,144],{"emptyLinePlaceholder":7},[114,280,281],{"class":116,"line":147},[114,282,283],{},"  ! Noncompliant: Inner loop iterates i from 1 to 6.\n",[114,285,286],{"class":116,"line":153},[114,287,288],{},"  do j = 1, 4\n",[114,290,291],{"class":116,"line":159},[114,292,293],{},"    do i = 1, 6\n",[114,295,296],{"class":116,"line":165},[114,297,298],{},"      matrix(i, j) = 0.0\n",[114,300,301],{"class":116,"line":171},[114,302,303],{},"    end do\n",[114,305,307],{"class":116,"line":306},11,[114,308,168],{},[114,310,312],{"class":116,"line":311},12,[114,313,314],{},"end subroutine init_matrix\n",[73,316,178],{"id":317},"compliant-solution-1",[42,319,320,321,324],{},"The compliant solution iterates strictly within the defined bounds of each dimension. If the intent is to initialize the memory linearly, the code should treat the array as a whole or use ",[49,322,323],{},"RESHAPE"," , rather than relying on out-of-bounds indexing.",[101,326,327],{"quality":184},[105,328,330],{"className":107,"code":329,"language":109,"meta":110,"style":110},"subroutine init_matrix(matrix)\n  implicit none\n  real, intent(out) :: matrix(5, 5)\n  integer           :: i, j\n\n  ! Compliant: Both indices stay within declared bounds (1:5)\n  do j = 1, 5\n    do i = 1, 5\n      matrix(i, j) = 0.0\n    end do\n  end do\nend subroutine init_matrix\n",[49,331,332,336,340,344,348,352,357,362,367,371,375,379],{"__ignoreMap":110},[114,333,334],{"class":116,"line":117},[114,335,260],{},[114,337,338],{"class":116,"line":123},[114,339,126],{},[114,341,342],{"class":116,"line":129},[114,343,269],{},[114,345,346],{"class":116,"line":135},[114,347,274],{},[114,349,350],{"class":116,"line":141},[114,351,144],{"emptyLinePlaceholder":7},[114,353,354],{"class":116,"line":147},[114,355,356],{},"  ! Compliant: Both indices stay within declared bounds (1:5)\n",[114,358,359],{"class":116,"line":153},[114,360,361],{},"  do j = 1, 5\n",[114,363,364],{"class":116,"line":159},[114,365,366],{},"    do i = 1, 5\n",[114,368,369],{"class":116,"line":165},[114,370,298],{},[114,372,373],{"class":116,"line":171},[114,374,303],{},[114,376,377],{"class":116,"line":306},[114,378,168],{},[114,380,381],{"class":116,"line":311},[114,382,314],{},[73,384,76],{"id":385},"noncompliant-code-example-2",[42,387,388,389,392,393,396,397,400,401,404],{},"Stencil operations are a common source of out-of-bounds errors in scientific computing. In this noncompliant example, the calculation for ",[49,390,391],{},"B(i, j)"," attempts to access ",[49,394,395],{},"A(i, j-1)"," . When ",[49,398,399],{},"j=1"," , this accesses ",[49,402,403],{},"A(i, 0)"," , which is out of bounds.",[101,406,407],{"quality":103},[105,408,410],{"className":107,"code":409,"language":109,"meta":110,"style":110},"subroutine stencil_calc(n, A, B)\n  implicit none\n  integer, intent(in) :: n\n  real, intent(in)    :: A(n, n)\n  real, intent(out)   :: B(n, n)\n  integer             :: i, j\n\n  do j = 1, n\n    do i = 1, n\n      ! Noncompliant: When j=1, A(i, j-1) becomes A(i, 0).\n      B(i, j) = A(i, j) + A(i, j-1)\n    end do\n  end do\nend subroutine stencil_calc\n",[49,411,412,417,421,426,431,436,441,445,450,455,460,465,469,474],{"__ignoreMap":110},[114,413,414],{"class":116,"line":117},[114,415,416],{},"subroutine stencil_calc(n, A, B)\n",[114,418,419],{"class":116,"line":123},[114,420,126],{},[114,422,423],{"class":116,"line":129},[114,424,425],{},"  integer, intent(in) :: n\n",[114,427,428],{"class":116,"line":135},[114,429,430],{},"  real, intent(in)    :: A(n, n)\n",[114,432,433],{"class":116,"line":141},[114,434,435],{},"  real, intent(out)   :: B(n, n)\n",[114,437,438],{"class":116,"line":147},[114,439,440],{},"  integer             :: i, j\n",[114,442,443],{"class":116,"line":153},[114,444,144],{"emptyLinePlaceholder":7},[114,446,447],{"class":116,"line":159},[114,448,449],{},"  do j = 1, n\n",[114,451,452],{"class":116,"line":165},[114,453,454],{},"    do i = 1, n\n",[114,456,457],{"class":116,"line":171},[114,458,459],{},"      ! Noncompliant: When j=1, A(i, j-1) becomes A(i, 0).\n",[114,461,462],{"class":116,"line":306},[114,463,464],{},"      B(i, j) = A(i, j) + A(i, j-1)\n",[114,466,467],{"class":116,"line":311},[114,468,303],{},[114,470,472],{"class":116,"line":471},13,[114,473,168],{},[114,475,477],{"class":116,"line":476},14,[114,478,479],{},"end subroutine stencil_calc\n",[73,481,178],{"id":482},"compliant-solution-2",[42,484,485],{},"The compliant solution handles the boundary condition explicitly.",[101,487,488],{"quality":184},[105,489,491],{"className":107,"code":490,"language":109,"meta":110,"style":110},"subroutine stencil_calc(n, A, B)\n  implicit none\n  integer, intent(in) :: n\n  real, intent(in)    :: A(n, n)\n  real, intent(out)   :: B(n, n)\n  integer             :: i, j\n\n  do j = 1, n\n    do i = 1, n\n      if (j > 1) then\n        ! Compliant: Access is guarded by check.\n        B(i, j) = A(i, j) + A(i, j-1)\n      else\n        B(i,j) = A(i, j)\n      end if\n    end do\n  end do\nend subroutine stencil_calc\n",[49,492,493,497,501,505,509,513,517,521,525,529,534,539,544,549,554,560,565,570],{"__ignoreMap":110},[114,494,495],{"class":116,"line":117},[114,496,416],{},[114,498,499],{"class":116,"line":123},[114,500,126],{},[114,502,503],{"class":116,"line":129},[114,504,425],{},[114,506,507],{"class":116,"line":135},[114,508,430],{},[114,510,511],{"class":116,"line":141},[114,512,435],{},[114,514,515],{"class":116,"line":147},[114,516,440],{},[114,518,519],{"class":116,"line":153},[114,520,144],{"emptyLinePlaceholder":7},[114,522,523],{"class":116,"line":159},[114,524,449],{},[114,526,527],{"class":116,"line":165},[114,528,454],{},[114,530,531],{"class":116,"line":171},[114,532,533],{},"      if (j > 1) then\n",[114,535,536],{"class":116,"line":306},[114,537,538],{},"        ! Compliant: Access is guarded by check.\n",[114,540,541],{"class":116,"line":311},[114,542,543],{},"        B(i, j) = A(i, j) + A(i, j-1)\n",[114,545,546],{"class":116,"line":471},[114,547,548],{},"      else\n",[114,550,551],{"class":116,"line":476},[114,552,553],{},"        B(i,j) = A(i, j)\n",[114,555,557],{"class":116,"line":556},15,[114,558,559],{},"      end if\n",[114,561,563],{"class":116,"line":562},16,[114,564,303],{},[114,566,568],{"class":116,"line":567},17,[114,569,168],{},[114,571,573],{"class":116,"line":572},18,[114,574,479],{},[73,576,578],{"id":577},"risk-assessment","Risk Assessment",[42,580,581],{},"Reading or writing array elements outside their defined bounds is a critical vulnerability. It defeats memory safety mechanisms and can lead to the execution of arbitrary code if control structures or return addresses are overwritten.",[583,584,585,606],"table",{},[586,587,588],"thead",{},[589,590,591,594,596,598,600,602,604],"tr",{},[592,593],"th",{},[592,595],{},[592,597],{},[592,599],{},[592,601],{},[592,603],{},[592,605],{},[607,608,609,633],"tbody",{},[589,610,611,615,618,621,624,627,630],{},[612,613,614],"td",{},"Recommendation",[612,616,617],{},"Severity",[612,619,620],{},"Likelihood",[612,622,623],{},"Detectable",[612,625,626],{},"Repairable",[612,628,629],{},"Priority",[612,631,632],{},"Level",[589,634,635,638,641,644,647,649,655],{},[612,636,637],{},"ARR01-F",[612,639,640],{},"High",[612,642,643],{},"Likely",[612,645,646],{},"Yes",[612,648,646],{},[612,650,651],{},[652,653,654],"strong",{},"P27",[612,656,657],{},[652,658,659],{},"L1",[73,661,663],{"id":662},"bibliography","Bibliography",[583,665,666,674],{},[586,667,668],{},[589,669,670,672],{},[592,671],{},[592,673],{},[607,675,676],{},[589,677,678,689],{},[612,679,680,681,688],{},"[ ",[682,683,687],"a",{"href":684,"rel":685},"https:\u002F\u002Fj3-fortran.org\u002Fdoc\u002Fyear\u002F24\u002F24-007.pdf",[686],"nofollow","Fortran 2023 Interpretation Document"," ]",[612,690,691],{},"Section 9.5.3",[693,694],"hr",{},[42,696,697,704,705,704,711],{},[682,698,700],{"href":699},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[701,702],"img",{"src":703},"attachments\u002F629047314\u002F638779611.png"," ",[682,706,708],{"href":707},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[701,709],{"src":710},"attachments\u002F629047314\u002F638779612.png",[682,712,714],{"href":713},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[701,715],{"src":716},"attachments\u002F629047314\u002F638779613.png",[73,718,720],{"id":719},"attachments","Attachments:",[722,723,727],"div",{"className":724,"align":726},[725],"greybox","left",[42,728,729,704,732,735,736,739,704,741,735,744,746,704,748,735],{},[701,730],{"alt":110,"src":731},"images\u002Ficons\u002Fbullet_blue.gif",[682,733,734],{"href":703},"button_arrow_left.png"," (image\u002Fpng)",[737,738],"br",{},[701,740],{"alt":110,"src":731},[682,742,743],{"href":710},"button_arrow_up.png",[737,745],{},[701,747],{"alt":110,"src":731},[682,749,750],{"href":716},"button_arrow_right.png",[752,753,754],"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":110,"searchDepth":123,"depth":123,"links":756},[757,758,759,760,761,762,763,764,765],{"id":75,"depth":123,"text":76},{"id":177,"depth":123,"text":178},{"id":234,"depth":123,"text":76},{"id":317,"depth":123,"text":178},{"id":385,"depth":123,"text":76},{"id":482,"depth":123,"text":178},{"id":577,"depth":123,"text":578},{"id":662,"depth":123,"text":663},{"id":719,"depth":123,"text":720},"md",{},"\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr01-f",{"title":33,"description":44},"9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F2.arr01-f","J7o8bSz6T2Wt5vmF95fe6tQSB8OFlo3sj4QjyWFCUeY",[773,777],{"title":774,"path":775,"stem":776,"children":-1},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",{"title":778,"path":779,"stem":780,"children":-1},"ARR02-F. Declare array dummy arguments as assumed-shape","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr02-f","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F3.arr02-f",[782],{"title":783,"path":784,"stem":785,"children":786},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[787,790,803,817,843,853,857,867,871,875,879,883,901,919,923,941,962],{"title":788,"path":784,"stem":789},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":774,"path":775,"stem":776,"children":791},[792,793,794,795,799],{"title":774,"path":775,"stem":776},{"title":33,"path":768,"stem":770},{"title":778,"path":779,"stem":780},{"title":796,"path":797,"stem":798},"ARR03-F. Specify array bounds when copying data to device memory","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr03-f","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F4.arr03-f",{"title":800,"path":801,"stem":802},"ARR04-F. Ensure arrays ranges mapped to devices cover all accessed elements","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr04-f","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F5.arr04-f",{"title":804,"path":805,"stem":806,"children":807},"Attribute Declarations and Specifications (ADS)","\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads","9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F1.index",[808,809,813],{"title":804,"path":805,"stem":806},{"title":810,"path":811,"stem":812},"ADS01-F. Explicitly declare pure procedures","\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads01-f","9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads01-f",{"title":814,"path":815,"stem":816},"ADS02-F. Separate initialization from declaration to avoid implicit variable persistence","\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads02-f","9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads02-f",{"title":818,"path":819,"stem":820,"children":821},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[822,823,827,831,835,839],{"title":818,"path":819,"stem":820},{"title":824,"path":825,"stem":826},"CON01-F. Explicitly declare OpenMP data-sharing attributes for all variables","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon01-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F2.con01-f",{"title":828,"path":829,"stem":830},"CON02-F. Protect reduction variables in multithreaded code","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon02-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F3.con02-f",{"title":832,"path":833,"stem":834},"CON03-F. Protect multithreading recurrences to avoid data races","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon03-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F4.con03-f",{"title":836,"path":837,"stem":838},"CON04-F. Do not use out-of-dimension subscripts in multithreaded code","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon04-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F5.con04-f",{"title":840,"path":841,"stem":842},"CON05-F. Ensure correct OpenMP datascoping of variables in parallel regions","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con\u002Fcon05-f","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F6.con05-f",{"title":844,"path":845,"stem":846,"children":847},"Exceptions and IEEE Arithmetic (EIA)","\u002Fsei-cert-fortran-coding-standard\u002Fexceptions-and-ieee-arithmetic-eia","9.sei-cert-fortran-coding-standard\u002F05.exceptions-and-ieee-arithmetic-eia\u002F1.index",[848,849],{"title":844,"path":845,"stem":846},{"title":850,"path":851,"stem":852},"EIA01-F. Enforce evaluation order in floating-point expressions","\u002Fsei-cert-fortran-coding-standard\u002Fexceptions-and-ieee-arithmetic-eia\u002Feia01-f","9.sei-cert-fortran-coding-standard\u002F05.exceptions-and-ieee-arithmetic-eia\u002F2.eia01-f",{"title":854,"path":855,"stem":856},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":858,"path":859,"stem":860,"children":861},"Expressions and Assignment (EXA)","\u002Fsei-cert-fortran-coding-standard\u002Fexpressions-and-assignment-exa","9.sei-cert-fortran-coding-standard\u002F07.expressions-and-assignment-exa\u002F1.index",[862,863],{"title":858,"path":859,"stem":860},{"title":864,"path":865,"stem":866},"EXA01-F. Do not read uninitialized memory","\u002Fsei-cert-fortran-coding-standard\u002Fexpressions-and-assignment-exa\u002Fexa01-f","9.sei-cert-fortran-coding-standard\u002F07.expressions-and-assignment-exa\u002F2.exa01-f",{"title":868,"path":869,"stem":870},"Input and Output Editing (IOE)","\u002Fsei-cert-fortran-coding-standard\u002Finput-and-output-editing-ioe","9.sei-cert-fortran-coding-standard\u002F08.input-and-output-editing-ioe",{"title":872,"path":873,"stem":874},"Input and Output Statements (IOS)","\u002Fsei-cert-fortran-coding-standard\u002Finput-and-output-statements-ios","9.sei-cert-fortran-coding-standard\u002F09.input-and-output-statements-ios",{"title":876,"path":877,"stem":878},"Interoperability with C (IWC)","\u002Fsei-cert-fortran-coding-standard\u002Finteroperability-with-c-iwc","9.sei-cert-fortran-coding-standard\u002F10.interoperability-with-c-iwc",{"title":880,"path":881,"stem":882},"Intrinsic Procedures and Modules (IPM)","\u002Fsei-cert-fortran-coding-standard\u002Fintrinsic-procedures-and-modules-ipm","9.sei-cert-fortran-coding-standard\u002F11.intrinsic-procedures-and-modules-ipm",{"title":884,"path":885,"stem":886,"children":887},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[888,889,893,897],{"title":884,"path":885,"stem":886},{"title":890,"path":891,"stem":892},"MSC01-F. Avoid using legacy or obsolescent Fortran constructs","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc01-f","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F2.msc01-f",{"title":894,"path":895,"stem":896},"MSC02-F. Beware of compiler-specific extensions","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc02-f","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F3.msc02-f",{"title":898,"path":899,"stem":900},"MSC03-F. Do not depend on undefined behavior","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc03-f","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F4.msc03-f",{"title":902,"path":903,"stem":904,"children":905},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[906,907,911,915],{"title":902,"path":903,"stem":904},{"title":908,"path":909,"stem":910},"PRC01-F. Disable the implicit declaration of procedures","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc01-f","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F2.prc01-f",{"title":912,"path":913,"stem":914},"PRC02-F. Avoid implicit interfaces by using module procedures","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc02-f","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F3.prc02-f",{"title":916,"path":917,"stem":918},"PRC03-F. Declare the intent for all dummy arguments","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc03-f","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F4.prc03-f",{"title":920,"path":921,"stem":922},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":924,"path":925,"stem":926,"children":927},"Scope, Association, and Definition (SAD)","\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad","9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F1.index",[928,929,933,937],{"title":924,"path":925,"stem":926},{"title":930,"path":931,"stem":932},"SAD02-F. Minimize imported module entities using the ONLY clause","\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Fsad02-f","9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F2.sad02-f",{"title":934,"path":935,"stem":936},"SAD03-F. Replace common block with modules for safer data encapsulation","\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Fsad03-f","9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F3.sad03-f",{"title":938,"path":939,"stem":940},"Limit the scope of variables and procedures","\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Flimit-the-scope-of-variables-and-procedures","9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F4.limit-the-scope-of-variables-and-procedures",{"title":942,"path":943,"stem":944,"children":945},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[946,947,950,954,958],{"title":942,"path":943,"stem":944},{"title":948,"path":713,"stem":949},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":951,"path":952,"stem":953},"TYP02-F. Prohibit implicit typing in all program units","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp02-f","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F3.typ02-f",{"title":955,"path":956,"stem":957},"TYP03-F. Ensure intrinsic function arguments match intended precision","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp03-f","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F4.typ03-f",{"title":959,"path":960,"stem":961},"TYP04-F. Centralize kind definitions to ensure consistent precision","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp04-f","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F5.typ04-f",{"title":963,"path":964,"stem":965},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320167194]