[{"data":1,"prerenderedAt":869},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads01-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads01-f":675,"sidebar-sei-cert-fortran-coding-standard":684},[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":668,"extension":669,"meta":670,"navigation":7,"path":671,"seo":672,"stem":673,"__hash__":674},"content\u002F9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads01-f.md","ADS01-F. Explicitly declare pure procedures",{"type":35,"value":36,"toc":659},"minimark",[37,41,54,65,94,104,109,119,216,220,237,303,306,319,392,395,407,471,475,487,564,568,596,599,621,625,655],[38,39,33],"h1",{"id":40},"ads01-f-explicitly-declare-pure-procedures",[42,43,44,45,49,50,53],"p",{},"Procedures that do not produce side effects shall be explicitly declared with the ",[46,47,48],"code",{},"pure"," prefix. From Fortran 2018 onwards, procedures that are side-effect-free and do not reference external data may additionally be declared ",[46,51,52],{},"simple"," .",[42,55,56,57,61,62,64],{},"A ",[58,59,60],"strong",{},"pure procedure"," is guaranteed by the compiler to be free from side effects. According to the Fortran standard, a pure procedure must not modify any variable accessed by a host or use association, nor can it perform external input\u002Foutput operations. Explicitly declaring a procedure as ",[46,63,48],{},":",[66,67,68,80,91],"ul",{},[69,70,71,72,75,76,79],"li",{},"Enforces data flow discipline. It requires that all dummy arguments of a function have ",[46,73,74],{},"intent(in)"," (or ",[46,77,78],{},"value"," ) and that subroutines have explicit intents for all arguments, reducing the risk or unintended data modifications.",[69,81,82,83,86,87,90],{},"Enables parallel safety. Pure procedures are required for use within ",[46,84,85],{},"do concurrent"," constructs and ",[46,88,89],{},"forall"," statements because their lack of side effects prevents race conditions in unordered execution segments.",[69,92,93],{},"Facilitates scoping analysis. It provides the compiler and the developer with valuable hints regarding data scoping, which is critical for avoiding pitfalls like race conditions in parallel programming.",[42,95,96,97,100,101,103],{},"From Fortran 2018 onwards, the standard introduced ",[58,98,99],{},"simple procedures"," . A ",[46,102,52],{}," procedure is a stricter form of a pure procedure. In addition to having no side effects, a simple procedure must not reference any variable accessed by use or host association. A simple procedure depends solely on its arguments, meaning its return value is determined entirely by its inputs, ensuring referential transparency.",[105,106,108],"h2",{"id":107},"noncompliant-code-example","Noncompliant Code Example",[42,110,111,112,115,116,118],{},"In this noncompliant example, the function ",[46,113,114],{},"calculate_circle_area()"," has no side effects, but because it is not declared ",[46,117,48],{}," . Without this attribute, its side-effect-free behavior is not explicitly stated in the interface, and the compiler cannot enforce the semantic constraints associated with pure procedures.",[120,121,123],"code-block",{"quality":122},"bad",[124,125,130],"pre",{"className":126,"code":127,"language":128,"meta":129,"style":129},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","module geometry_mod\n  implicit none\n  real, parameter :: PI = 3.14159\n\ncontains \n\n  ! Noncompliant: Effectively pure procedure but not declared as such\n  function calculate_circle_area(radius) result(area)\n    real, intent(in) :: radius\n    real             :: area\n    area = PI * radius**2\n  end function calculate_circle_area\n\nend module geometry_mod\n","fortran","",[46,131,132,140,146,152,158,164,169,175,181,187,193,199,205,210],{"__ignoreMap":129},[133,134,137],"span",{"class":135,"line":136},"line",1,[133,138,139],{},"module geometry_mod\n",[133,141,143],{"class":135,"line":142},2,[133,144,145],{},"  implicit none\n",[133,147,149],{"class":135,"line":148},3,[133,150,151],{},"  real, parameter :: PI = 3.14159\n",[133,153,155],{"class":135,"line":154},4,[133,156,157],{"emptyLinePlaceholder":7},"\n",[133,159,161],{"class":135,"line":160},5,[133,162,163],{},"contains \n",[133,165,167],{"class":135,"line":166},6,[133,168,157],{"emptyLinePlaceholder":7},[133,170,172],{"class":135,"line":171},7,[133,173,174],{},"  ! Noncompliant: Effectively pure procedure but not declared as such\n",[133,176,178],{"class":135,"line":177},8,[133,179,180],{},"  function calculate_circle_area(radius) result(area)\n",[133,182,184],{"class":135,"line":183},9,[133,185,186],{},"    real, intent(in) :: radius\n",[133,188,190],{"class":135,"line":189},10,[133,191,192],{},"    real             :: area\n",[133,194,196],{"class":135,"line":195},11,[133,197,198],{},"    area = PI * radius**2\n",[133,200,202],{"class":135,"line":201},12,[133,203,204],{},"  end function calculate_circle_area\n",[133,206,208],{"class":135,"line":207},13,[133,209,157],{"emptyLinePlaceholder":7},[133,211,213],{"class":135,"line":212},14,[133,214,215],{},"end module geometry_mod\n",[105,217,219],{"id":218},"compliant-solution","Compliant Solution",[42,221,222,223,225,226,228,229,232,233,236],{},"In this compliant solution, the programmer explicitly states that the function has no side effects by adding the ",[46,224,48],{}," attribute. The compiler verifies this contract, enforcing restrictions such as requiring ",[46,227,74],{}," on the dummy argument ",[46,230,231],{},"radius"," and preventing modification of module data like ",[46,234,235],{},"PI"," . This makes the procedure's behavior explicit and verifiable.",[120,238,240],{"quality":239},"good",[124,241,243],{"className":126,"code":242,"language":128,"meta":129,"style":129},"module geometry_mod\n  implicit none\n  real, parameter :: PI = 3.14159\n\ncontains \n\n  ! Compliant: Procedure declared pure explicitly\n  pure function calculate_circle_area(radius) result(area)\n    real, intent(in) :: radius\n    real             :: area\n    area = PI * radius**2\n  end function calculate_circle_area\n\nend module geometry_mod\n",[46,244,245,249,253,257,261,265,269,274,279,283,287,291,295,299],{"__ignoreMap":129},[133,246,247],{"class":135,"line":136},[133,248,139],{},[133,250,251],{"class":135,"line":142},[133,252,145],{},[133,254,255],{"class":135,"line":148},[133,256,151],{},[133,258,259],{"class":135,"line":154},[133,260,157],{"emptyLinePlaceholder":7},[133,262,263],{"class":135,"line":160},[133,264,163],{},[133,266,267],{"class":135,"line":166},[133,268,157],{"emptyLinePlaceholder":7},[133,270,271],{"class":135,"line":171},[133,272,273],{},"  ! Compliant: Procedure declared pure explicitly\n",[133,275,276],{"class":135,"line":177},[133,277,278],{},"  pure function calculate_circle_area(radius) result(area)\n",[133,280,281],{"class":135,"line":183},[133,282,186],{},[133,284,285],{"class":135,"line":189},[133,286,192],{},[133,288,289],{"class":135,"line":195},[133,290,198],{},[133,292,293],{"class":135,"line":201},[133,294,204],{},[133,296,297],{"class":135,"line":207},[133,298,157],{"emptyLinePlaceholder":7},[133,300,301],{"class":135,"line":212},[133,302,215],{},[105,304,108],{"id":305},"noncompliant-code-example-1",[42,307,111,308,311,312,315,316,318],{},[46,309,310],{},"apply_scaling()"," reads the module variable ",[46,313,314],{},"scale_factor"," . Although the code does not modify it, the absence ot the ",[46,317,48],{}," attribute means this property is not formally declared or checked. The procedure's side-effect behavior is therefore implicit rather than enforced.",[120,320,321],{"quality":122},[124,322,324],{"className":126,"code":323,"language":128,"meta":129,"style":129},"module scaling_mod\n  implicit none\n  real :: scale_factor = 2.5\n\ncontains\n\n  ! Noncompliant: Effectively pure procedure as reading global state without modification is allowed\n  function apply_scaling(val) result(res)\n    real, intent(in) :: val\n    real             :: res\n    res = val * scale_factor\n  end function apply_scaling\n\nend module scaling_mod\n",[46,325,326,331,335,340,344,349,353,358,363,368,373,378,383,387],{"__ignoreMap":129},[133,327,328],{"class":135,"line":136},[133,329,330],{},"module scaling_mod\n",[133,332,333],{"class":135,"line":142},[133,334,145],{},[133,336,337],{"class":135,"line":148},[133,338,339],{},"  real :: scale_factor = 2.5\n",[133,341,342],{"class":135,"line":154},[133,343,157],{"emptyLinePlaceholder":7},[133,345,346],{"class":135,"line":160},[133,347,348],{},"contains\n",[133,350,351],{"class":135,"line":166},[133,352,157],{"emptyLinePlaceholder":7},[133,354,355],{"class":135,"line":171},[133,356,357],{},"  ! Noncompliant: Effectively pure procedure as reading global state without modification is allowed\n",[133,359,360],{"class":135,"line":177},[133,361,362],{},"  function apply_scaling(val) result(res)\n",[133,364,365],{"class":135,"line":183},[133,366,367],{},"    real, intent(in) :: val\n",[133,369,370],{"class":135,"line":189},[133,371,372],{},"    real             :: res\n",[133,374,375],{"class":135,"line":195},[133,376,377],{},"    res = val * scale_factor\n",[133,379,380],{"class":135,"line":201},[133,381,382],{},"  end function apply_scaling\n",[133,384,385],{"class":135,"line":207},[133,386,157],{"emptyLinePlaceholder":7},[133,388,389],{"class":135,"line":212},[133,390,391],{},"end module scaling_mod\n",[105,393,219],{"id":394},"compliant-solution-1",[42,396,397,398,400,401,403,404,406],{},"In this compliant solution, declaring ",[46,399,310],{}," as ",[46,402,48],{}," makes the absence of side effects part of the procedure's interface contract. The compiler enforces that ",[46,405,314],{}," is not modified, and that the function adheres to the restrictions required for pure procedures, ensuring consistent and well-defined behavior.",[120,408,409],{"quality":239},[124,410,412],{"className":126,"code":411,"language":128,"meta":129,"style":129},"module scaling_mod\n  implicit none\n  real :: scale_factor = 2.5\n\ncontains\n\n  ! Compliant: Procedure declared pure explicitly\n  pure function apply_scaling(val) result(res)\n    real, intent(in) :: val\n    real             :: res\n    res = val * scale_factor\n  end function apply_scaling\n\nend module scaling_mod\n",[46,413,414,418,422,426,430,434,438,442,447,451,455,459,463,467],{"__ignoreMap":129},[133,415,416],{"class":135,"line":136},[133,417,330],{},[133,419,420],{"class":135,"line":142},[133,421,145],{},[133,423,424],{"class":135,"line":148},[133,425,339],{},[133,427,428],{"class":135,"line":154},[133,429,157],{"emptyLinePlaceholder":7},[133,431,432],{"class":135,"line":160},[133,433,348],{},[133,435,436],{"class":135,"line":166},[133,437,157],{"emptyLinePlaceholder":7},[133,439,440],{"class":135,"line":171},[133,441,273],{},[133,443,444],{"class":135,"line":177},[133,445,446],{},"  pure function apply_scaling(val) result(res)\n",[133,448,449],{"class":135,"line":183},[133,450,367],{},[133,452,453],{"class":135,"line":189},[133,454,372],{},[133,456,457],{"class":135,"line":195},[133,458,377],{},[133,460,461],{"class":135,"line":201},[133,462,382],{},[133,464,465],{"class":135,"line":207},[133,466,157],{"emptyLinePlaceholder":7},[133,468,469],{"class":135,"line":212},[133,470,391],{},[105,472,474],{"id":473},"risk-assessment","Risk Assessment",[42,476,477,478,480,481,483,484,486],{},"Failing to declare side-effect-free procedures as ",[46,479,48],{}," or ",[46,482,52],{}," deprives the compiler and developers of essential guarantees regarding data independence. This omission prevents the compiler from enforcing read-only constraints on global data, increasing the likelihood of unintended state modification and hidden data coupling. Furthermore, without these attributes, the compiler cannot verify thread safety, potentially leading to data races and undefined behavior if the procedure is used in parallel constructs like ",[46,485,85],{}," . This obscures the data flow, making the codebase significantly harder to audit for correctness and security vulnerabilities.",[488,489,490,511],"table",{},[491,492,493],"thead",{},[494,495,496,499,501,503,505,507,509],"tr",{},[497,498],"th",{},[497,500],{},[497,502],{},[497,504],{},[497,506],{},[497,508],{},[497,510],{},[512,513,514,538],"tbody",{},[494,515,516,520,523,526,529,532,535],{},[517,518,519],"td",{},"Recommendation",[517,521,522],{},"Severity",[517,524,525],{},"Likelihood",[517,527,528],{},"Detectable",[517,530,531],{},"Repairable",[517,533,534],{},"Priority",[517,536,537],{},"Level",[494,539,540,543,546,549,552,554,559],{},[517,541,542],{},"ADS01-F",[517,544,545],{},"Low",[517,547,548],{},"Unlikely",[517,550,551],{},"Yes",[517,553,551],{},[517,555,556],{},[58,557,558],{},"P3",[517,560,561],{},[58,562,563],{},"L3",[105,565,567],{"id":566},"bibliography","Bibliography",[488,569,570,578],{},[491,571,572],{},[494,573,574,576],{},[497,575],{},[497,577],{},[512,579,580],{},[494,581,582,593],{},[517,583,584,585,592],{},"[ ",[586,587,591],"a",{"href":588,"rel":589},"https:\u002F\u002Fj3-fortran.org\u002Fdoc\u002Fyear\u002F24\u002F24-007.pdf",[590],"nofollow","Fortran 2023 Interpretation Document"," ]",[517,594,595],{},"Sections: 15.7 and 15.8",[597,598],"hr",{},[42,600,601,608,609,608,615],{},[586,602,604],{"href":603},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[605,606],"img",{"src":607},"attachments\u002F629047299\u002F638779507.png"," ",[586,610,612],{"href":611},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[605,613],{"src":614},"attachments\u002F629047299\u002F638779508.png",[586,616,618],{"href":617},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[605,619],{"src":620},"attachments\u002F629047299\u002F638779509.png",[105,622,624],{"id":623},"attachments","Attachments:",[626,627,631],"div",{"className":628,"align":630},[629],"greybox","left",[42,632,633,608,636,639,640,643,608,645,639,648,650,608,652,639],{},[605,634],{"alt":129,"src":635},"images\u002Ficons\u002Fbullet_blue.gif",[586,637,638],{"href":607},"button_arrow_left.png"," (image\u002Fpng)",[641,642],"br",{},[605,644],{"alt":129,"src":635},[586,646,647],{"href":614},"button_arrow_up.png",[641,649],{},[605,651],{"alt":129,"src":635},[586,653,654],{"href":620},"button_arrow_right.png",[656,657,658],"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":129,"searchDepth":142,"depth":142,"links":660},[661,662,663,664,665,666,667],{"id":107,"depth":142,"text":108},{"id":218,"depth":142,"text":219},{"id":305,"depth":142,"text":108},{"id":394,"depth":142,"text":219},{"id":473,"depth":142,"text":474},{"id":566,"depth":142,"text":567},{"id":623,"depth":142,"text":624},"Procedures that do not produce side effects shall be explicitly declared with the pure prefix. From Fortran 2018 onwards, procedures that are side-effect-free and do not reference external data may additionally be declared simple .","md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads01-f",{"title":33,"description":668},"9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads01-f","kNLPaBELGbaFWtLEZu66HA3zSHJZXwHw_hrsCsO93gE",[676,680],{"title":677,"path":678,"stem":679,"children":-1},"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",{"title":681,"path":682,"stem":683,"children":-1},"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",[685],{"title":686,"path":687,"stem":688,"children":689},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[690,693,715,720,746,756,760,770,774,778,782,786,804,822,826,844,865],{"title":691,"path":687,"stem":692},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":694,"path":695,"stem":696,"children":697},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[698,699,703,707,711],{"title":694,"path":695,"stem":696},{"title":700,"path":701,"stem":702},"ARR01-F. Do not use out-of-bounds arrays subscripts","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr\u002Farr01-f","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F2.arr01-f",{"title":704,"path":705,"stem":706},"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",{"title":708,"path":709,"stem":710},"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":712,"path":713,"stem":714},"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":677,"path":678,"stem":679,"children":716},[717,718,719],{"title":677,"path":678,"stem":679},{"title":33,"path":671,"stem":673},{"title":681,"path":682,"stem":683},{"title":721,"path":722,"stem":723,"children":724},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[725,726,730,734,738,742],{"title":721,"path":722,"stem":723},{"title":727,"path":728,"stem":729},"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":731,"path":732,"stem":733},"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":735,"path":736,"stem":737},"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":739,"path":740,"stem":741},"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":743,"path":744,"stem":745},"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":747,"path":748,"stem":749,"children":750},"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",[751,752],{"title":747,"path":748,"stem":749},{"title":753,"path":754,"stem":755},"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":757,"path":758,"stem":759},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":761,"path":762,"stem":763,"children":764},"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",[765,766],{"title":761,"path":762,"stem":763},{"title":767,"path":768,"stem":769},"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":771,"path":772,"stem":773},"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":775,"path":776,"stem":777},"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":779,"path":780,"stem":781},"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":783,"path":784,"stem":785},"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":787,"path":788,"stem":789,"children":790},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[791,792,796,800],{"title":787,"path":788,"stem":789},{"title":793,"path":794,"stem":795},"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":797,"path":798,"stem":799},"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":801,"path":802,"stem":803},"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":805,"path":806,"stem":807,"children":808},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[809,810,814,818],{"title":805,"path":806,"stem":807},{"title":811,"path":812,"stem":813},"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":815,"path":816,"stem":817},"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":819,"path":820,"stem":821},"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":823,"path":824,"stem":825},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":827,"path":828,"stem":829,"children":830},"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",[831,832,836,840],{"title":827,"path":828,"stem":829},{"title":833,"path":834,"stem":835},"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":837,"path":838,"stem":839},"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":841,"path":842,"stem":843},"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":845,"path":846,"stem":847,"children":848},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[849,850,853,857,861],{"title":845,"path":846,"stem":847},{"title":851,"path":617,"stem":852},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":854,"path":855,"stem":856},"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":858,"path":859,"stem":860},"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":862,"path":863,"stem":864},"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":866,"path":867,"stem":868},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320167206]