[{"data":1,"prerenderedAt":733},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads02-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads02-f":539,"sidebar-sei-cert-fortran-coding-standard":548},[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":532,"extension":533,"meta":534,"navigation":7,"path":535,"seo":536,"stem":537,"__hash__":538},"content\u002F9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads02-f.md","ADS02-F. Separate initialization from declaration to avoid implicit variable persistence",{"type":35,"value":36,"toc":524},"minimark",[37,41,50,60,66,72,85,90,104,146,215,219,225,287,290,296,341,345,351,429,433,461,464,486,490,520],[38,39,33],"h1",{"id":40},"ads02-f-separate-initialization-from-declaration-to-avoid-implicit-variable-persistence",[42,43,44,45,49],"p",{},"Programmers should separate the initialization of a local variable from its declaration to ensure the variable is reinitialized on each invocation. If a variable is intended to retain its value across procedure calls, the ",[46,47,48],"code",{},"save"," attribute should be explicitly declared.",[42,51,52,53,56,57,59],{},"In Fortran, a variable initialized in its type declaration (e.g., ",[46,54,55],{},"integer :: i = 0"," ) implicitly acquires the ",[46,58,48],{}," attribute. This makes the variable static: it is allocated once at program start and retains its value across multiple calls to the procedure.",[42,61,62,63,65],{},"This behavior differs from languages like C, C++, or Java, where local variables initialized in a declaration are re-initialized on every scope entry. Failing to account for implicit ",[46,64,48],{}," can lead to subtle logic errors, as the variable's value depends on previous calls.",[42,67,68,69,71],{},"Relying on implicit persistence creates ambiguity regarding the programmer's intent. Explicitly declaring the ",[46,70,48],{}," attribute when persistence is required serves as documentation, distinguishing a deliberate design choice from an accidental initialization error. Conversely, separating initialization from declaration ensures the variable behaves as a standard local variable, improving the readability and maintainability of the code.",[42,73,74,75,78,79,81,82,84],{},"Additionally, local variables in ",[46,76,77],{},"pure"," procedures cannot have the ",[46,80,48],{}," attribute, so initializing a local variable in its declaration can prevent the procedure from being declared ",[46,83,77],{}," .",[86,87,89],"h2",{"id":88},"noncompliant-code-example","Noncompliant Code Example",[42,91,92,93,96,97,100,101,103],{},"In this noncompliant example, the programmer intends for ",[46,94,95],{},"counter"," to be a local temporary variable that starts at ",[46,98,99],{},"0"," every time the subroutine is called. However, because it is initialized in the declaration statement, it implicitly has the ",[46,102,48],{}," attribute.",[42,105,106,107,109,110,112,113,116,117,120,121,124,125,127,128,131,132,134,135,137,138,140,141,127,143,145],{},"The variable ",[46,108,95],{}," retains its value between calls due to the implicit ",[46,111,48],{}," . If the subroutine ",[46,114,115],{},"process_data()"," is called twice with the dummy argument ",[46,118,119],{},"val"," set to the contanst value ",[46,122,123],{},"5"," , then the printed outputs will be ",[46,126,123],{}," and ",[46,129,130],{},"10",". Without the ",[46,133,48],{}," attribute, ",[46,136,95],{},"would be set to ",[46,139,99],{}," in each subroutine call and the printed output would be ",[46,142,123],{},[46,144,123],{},".",[147,148,150],"code-block",{"quality":149},"bad",[151,152,157],"pre",{"className":153,"code":154,"language":155,"meta":156,"style":156},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","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","fortran","",[46,158,159,167,173,179,185,191,197,203,209],{"__ignoreMap":156},[160,161,164],"span",{"class":162,"line":163},"line",1,[160,165,166],{},"subroutine process_data(val)\n",[160,168,170],{"class":162,"line":169},2,[160,171,172],{},"  implicit none\n",[160,174,176],{"class":162,"line":175},3,[160,177,178],{},"  integer, intent(in) :: val\n",[160,180,182],{"class":162,"line":181},4,[160,183,184],{},"  ! Noncompliant: The variable implicitly has the save attribute\n",[160,186,188],{"class":162,"line":187},5,[160,189,190],{},"  integer             :: counter = 0\n",[160,192,194],{"class":162,"line":193},6,[160,195,196],{"emptyLinePlaceholder":7},"\n",[160,198,200],{"class":162,"line":199},7,[160,201,202],{},"  counter = counter + val\n",[160,204,206],{"class":162,"line":205},8,[160,207,208],{},"  print *, \"Cumulative internal value:\", counter\n",[160,210,212],{"class":162,"line":211},9,[160,213,214],{},"end subroutine process_data\n",[86,216,218],{"id":217},"compliant-solution","Compliant Solution",[42,220,221,222,224],{},"In this compliant solution, the programmer intends for the variable to be local and re-initialized to ",[46,223,99],{}," in each subroutine call. Thus the initialization is moved to the execution statement, away from the declaration statement.",[147,226,228],{"quality":227},"good",[151,229,231],{"className":153,"code":230,"language":155,"meta":156,"style":156},"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,232,233,238,242,247,252,257,261,266,271,276,282],{"__ignoreMap":156},[160,234,235],{"class":162,"line":163},[160,236,237],{},"subroutine process_data(val, result)\n",[160,239,240],{"class":162,"line":169},[160,241,172],{},[160,243,244],{"class":162,"line":175},[160,245,246],{},"  integer, intent(in)  :: val\n",[160,248,249],{"class":162,"line":181},[160,250,251],{},"  integer, intent(out) :: result\n",[160,253,254],{"class":162,"line":187},[160,255,256],{},"  integer              :: temp_val\n",[160,258,259],{"class":162,"line":193},[160,260,196],{"emptyLinePlaceholder":7},[160,262,263],{"class":162,"line":199},[160,264,265],{},"  ! Compliant: The variable is not initialized in the declaration statement\n",[160,267,268],{"class":162,"line":205},[160,269,270],{},"  temp_val = 0\n",[160,272,273],{"class":162,"line":211},[160,274,275],{},"  temp_val = temp_val + val\n",[160,277,279],{"class":162,"line":278},10,[160,280,281],{},"  result = temp_val\n",[160,283,285],{"class":162,"line":284},11,[160,286,214],{},[86,288,218],{"id":289},"compliant-solution-1",[42,291,292,293,295],{},"In this compliant solution, the programmer intends for the variable to be persistent (a \"static\" counter). Thus, the ",[46,294,48],{}," attribute is explicitly declared to make the program logic clear to the reader.",[147,297,298],{"quality":227},[151,299,301],{"className":153,"code":300,"language":155,"meta":156,"style":156},"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,302,303,307,311,315,320,325,329,333,337],{"__ignoreMap":156},[160,304,305],{"class":162,"line":163},[160,306,166],{},[160,308,309],{"class":162,"line":169},[160,310,172],{},[160,312,313],{"class":162,"line":175},[160,314,178],{},[160,316,317],{"class":162,"line":181},[160,318,319],{},"  ! Compliant: The variable has the save attribute explicitly\n",[160,321,322],{"class":162,"line":187},[160,323,324],{},"  integer, save       :: counter = 0\n",[160,326,327],{"class":162,"line":193},[160,328,196],{"emptyLinePlaceholder":7},[160,330,331],{"class":162,"line":199},[160,332,202],{},[160,334,335],{"class":162,"line":205},[160,336,208],{},[160,338,339],{"class":162,"line":211},[160,340,214],{},[86,342,344],{"id":343},"risk-assessment","Risk Assessment",[42,346,347,348,350],{},"Implicit ",[46,349,48],{}," attributes can cause unintended persistence, introducing hidden side effects. This may lead to incorrect results, non-deterministic behavior in parallel or multi-threaded environments (e.g., OpenMP, Coarrays), and subtle logic errors that are difficult to detect during code reviews.",[352,353,354,375],"table",{},[355,356,357],"thead",{},[358,359,360,363,365,367,369,371,373],"tr",{},[361,362],"th",{},[361,364],{},[361,366],{},[361,368],{},[361,370],{},[361,372],{},[361,374],{},[376,377,378,402],"tbody",{},[358,379,380,384,387,390,393,396,399],{},[381,382,383],"td",{},"Recommendation",[381,385,386],{},"Severity",[381,388,389],{},"Likelihood",[381,391,392],{},"Detectable",[381,394,395],{},"Repairable",[381,397,398],{},"Priority",[381,400,401],{},"Level",[358,403,404,407,410,413,416,418,424],{},[381,405,406],{},"ADS02-F",[381,408,409],{},"High",[381,411,412],{},"Likely",[381,414,415],{},"Yes",[381,417,415],{},[381,419,420],{},[421,422,423],"strong",{},"P27",[381,425,426],{},[421,427,428],{},"L1",[86,430,432],{"id":431},"bibliography","Bibliography",[352,434,435,443],{},[355,436,437],{},[358,438,439,441],{},[361,440],{},[361,442],{},[376,444,445],{},[358,446,447,458],{},[381,448,449,450,457],{},"[ ",[451,452,456],"a",{"href":453,"rel":454},"https:\u002F\u002Fj3-fortran.org\u002Fdoc\u002Fyear\u002F24\u002F24-007.pdf",[455],"nofollow","Fortran 2023 Interpretation Document"," ]",[381,459,460],{},"Section 8.4 and 8.5.16",[462,463],"hr",{},[42,465,466,473,474,473,480],{},[451,467,469],{"href":468},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[470,471],"img",{"src":472},"attachments\u002F629047330\u002F638779511.png"," ",[451,475,477],{"href":476},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[470,478],{"src":479},"attachments\u002F629047330\u002F638779512.png",[451,481,483],{"href":482},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[470,484],{"src":485},"attachments\u002F629047330\u002F638779513.png",[86,487,489],{"id":488},"attachments","Attachments:",[491,492,496],"div",{"className":493,"align":495},[494],"greybox","left",[42,497,498,473,501,504,505,508,473,510,504,513,515,473,517,504],{},[470,499],{"alt":156,"src":500},"images\u002Ficons\u002Fbullet_blue.gif",[451,502,503],{"href":472},"button_arrow_left.png"," (image\u002Fpng)",[506,507],"br",{},[470,509],{"alt":156,"src":500},[451,511,512],{"href":479},"button_arrow_up.png",[506,514],{},[470,516],{"alt":156,"src":500},[451,518,519],{"href":485},"button_arrow_right.png",[521,522,523],"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":156,"searchDepth":169,"depth":169,"links":525},[526,527,528,529,530,531],{"id":88,"depth":169,"text":89},{"id":217,"depth":169,"text":218},{"id":289,"depth":169,"text":218},{"id":343,"depth":169,"text":344},{"id":431,"depth":169,"text":432},{"id":488,"depth":169,"text":489},"Programmers should separate the initialization of a local variable from its declaration to ensure the variable is reinitialized on each invocation. If a variable is intended to retain its value across procedure calls, the save attribute should be explicitly declared.","md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fattribute-declarations-and-specifications-ads\u002Fads02-f",{"title":33,"description":532},"9.sei-cert-fortran-coding-standard\u002F03.attribute-declarations-and-specifications-ads\u002F2.ads02-f","rjqVAmZUjpKzsVoSlWPQ0NIFqniF77e81C-iO-HIq3A",[540,544],{"title":541,"path":542,"stem":543,"children":-1},"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":545,"path":546,"stem":547,"children":-1},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[549],{"title":550,"path":551,"stem":552,"children":553},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[554,557,579,587,610,620,624,634,638,642,646,650,668,686,690,708,729],{"title":555,"path":551,"stem":556},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":558,"path":559,"stem":560,"children":561},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[562,563,567,571,575],{"title":558,"path":559,"stem":560},{"title":564,"path":565,"stem":566},"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":568,"path":569,"stem":570},"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":572,"path":573,"stem":574},"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":576,"path":577,"stem":578},"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":580,"path":581,"stem":582,"children":583},"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",[584,585,586],{"title":580,"path":581,"stem":582},{"title":541,"path":542,"stem":543},{"title":33,"path":535,"stem":537},{"title":545,"path":546,"stem":547,"children":588},[589,590,594,598,602,606],{"title":545,"path":546,"stem":547},{"title":591,"path":592,"stem":593},"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":595,"path":596,"stem":597},"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":599,"path":600,"stem":601},"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":603,"path":604,"stem":605},"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":607,"path":608,"stem":609},"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":611,"path":612,"stem":613,"children":614},"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",[615,616],{"title":611,"path":612,"stem":613},{"title":617,"path":618,"stem":619},"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":621,"path":622,"stem":623},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":625,"path":626,"stem":627,"children":628},"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",[629,630],{"title":625,"path":626,"stem":627},{"title":631,"path":632,"stem":633},"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":635,"path":636,"stem":637},"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":639,"path":640,"stem":641},"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":643,"path":644,"stem":645},"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":647,"path":648,"stem":649},"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":651,"path":652,"stem":653,"children":654},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[655,656,660,664],{"title":651,"path":652,"stem":653},{"title":657,"path":658,"stem":659},"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":661,"path":662,"stem":663},"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":665,"path":666,"stem":667},"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":669,"path":670,"stem":671,"children":672},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[673,674,678,682],{"title":669,"path":670,"stem":671},{"title":675,"path":676,"stem":677},"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":679,"path":680,"stem":681},"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":683,"path":684,"stem":685},"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":687,"path":688,"stem":689},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":691,"path":692,"stem":693,"children":694},"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",[695,696,700,704],{"title":691,"path":692,"stem":693},{"title":697,"path":698,"stem":699},"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":701,"path":702,"stem":703},"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":705,"path":706,"stem":707},"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":709,"path":710,"stem":711,"children":712},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[713,714,717,721,725],{"title":709,"path":710,"stem":711},{"title":715,"path":482,"stem":716},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":718,"path":719,"stem":720},"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":722,"path":723,"stem":724},"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":726,"path":727,"stem":728},"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":730,"path":731,"stem":732},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320167207]