[{"data":1,"prerenderedAt":836},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc02-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc02-f":642,"sidebar-sei-cert-fortran-coding-standard":651},[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":636,"meta":637,"navigation":7,"path":638,"seo":639,"stem":640,"__hash__":641},"content\u002F9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F3.prc02-f.md","PRC02-F. Avoid implicit interfaces by using module procedures",{"type":35,"value":36,"toc":629},"minimark",[37,41,45,48,60,73,80,85,98,185,245,249,256,625],[38,39,33],"h1",{"id":40},"prc02-f-avoid-implicit-interfaces-by-using-module-procedures",[42,43,44],"p",{},"Programmers shall encapsulate procedures within modules to ensure they have explicit interfaces.",[42,46,47],{},"In Fortran, a procedure defined externally (an \"external procedure\") has an implicit interface by default, unless an interface block is manually provided in the calling scope. When a procedure has an implicit interface, the compiler cannot verify that the arguments passed in the call match the dummy arguments defined in the procedure. The compiler assumes that the characteristics (types, ranks, etc.) and number of arguments provided by the caller are correct.",[42,49,50,51,55,56,59],{},"If the caller passes arguments that do not match the procedure's definition (e.g., passing a ",[52,53,54],"code",{},"real"," variable to an ",[52,57,58],{},"integer"," argument), the program may experience:",[61,62,63,67,70],"ul",{},[64,65,66],"li",{},"Memory corruption occurs when reading or writing to undefined memory locations due to type size mismatches.",[64,68,69],{},"Incorrect results due to interpreting bit patterns as the wrong data type (e.g., interpreting floating-point bits as integers).",[64,71,72],{},"Runtime instability can lead to unpredictable behavior or crashes.",[42,74,75,76,79],{},"Encapsulating procedures within modules automatically generates an explicit interface for that procedure. When a module is used (through the ",[52,77,78],{},"use"," statement), the compiler has access to the full definition of the procedure and can enforce strict type checking at compile time.",[81,82,84],"h2",{"id":83},"noncompliant-code-example","Noncompliant Code Example",[42,86,87,88,91,92,94,95,97],{},"In this noncompliant example, the subroutine ",[52,89,90],{},"factorial"," is defined as an external procedure (not inside a module). The main program calls it. Because the interface is implicit, the compiler assumes the call is valid. However, the main program passes ",[52,93,54],{}," arguments, while the subroutine expects ",[52,96,58],{}," arguments. This results in undefined behavior (incorrect calculation) at runtime.",[99,100,102],"code-block",{"quality":101},"bad",[103,104,109],"pre",{"className":105,"code":106,"language":107,"meta":108,"style":108},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","! compute_factorial_lib.f90\npure subroutine compute_factorial(n, result)\n    implicit none\n    integer, intent(in) :: n\n    integer, intent(out) :: result\n    integer :: i\n\n    result = 1\n    do i = 2, n\n        result = result * i\n    end do\nend subroutine compute_factorial\n","fortran","",[52,110,111,119,125,131,137,143,149,155,161,167,173,179],{"__ignoreMap":108},[112,113,116],"span",{"class":114,"line":115},"line",1,[112,117,118],{},"! compute_factorial_lib.f90\n",[112,120,122],{"class":114,"line":121},2,[112,123,124],{},"pure subroutine compute_factorial(n, result)\n",[112,126,128],{"class":114,"line":127},3,[112,129,130],{},"    implicit none\n",[112,132,134],{"class":114,"line":133},4,[112,135,136],{},"    integer, intent(in) :: n\n",[112,138,140],{"class":114,"line":139},5,[112,141,142],{},"    integer, intent(out) :: result\n",[112,144,146],{"class":114,"line":145},6,[112,147,148],{},"    integer :: i\n",[112,150,152],{"class":114,"line":151},7,[112,153,154],{"emptyLinePlaceholder":7},"\n",[112,156,158],{"class":114,"line":157},8,[112,159,160],{},"    result = 1\n",[112,162,164],{"class":114,"line":163},9,[112,165,166],{},"    do i = 2, n\n",[112,168,170],{"class":114,"line":169},10,[112,171,172],{},"        result = result * i\n",[112,174,176],{"class":114,"line":175},11,[112,177,178],{},"    end do\n",[112,180,182],{"class":114,"line":181},12,[112,183,184],{},"end subroutine compute_factorial\n",[99,186,187],{"quality":101},[103,188,190],{"className":105,"code":189,"language":107,"meta":108,"style":108},"! main.f90\nprogram test_implicit_interface\n    use iso_fortran_env, only: real32\n    implicit none\n    external :: compute_factorial\n    real(kind=real32) :: number, result\n\n    number = 5\n    call compute_factorial(number, result)\n    print *, \"Factorial of \", number, \"is\", result\nend program test_implicit_interface\n",[52,191,192,197,202,207,211,216,221,225,230,235,240],{"__ignoreMap":108},[112,193,194],{"class":114,"line":115},[112,195,196],{},"! main.f90\n",[112,198,199],{"class":114,"line":121},[112,200,201],{},"program test_implicit_interface\n",[112,203,204],{"class":114,"line":127},[112,205,206],{},"    use iso_fortran_env, only: real32\n",[112,208,209],{"class":114,"line":133},[112,210,130],{},[112,212,213],{"class":114,"line":139},[112,214,215],{},"    external :: compute_factorial\n",[112,217,218],{"class":114,"line":145},[112,219,220],{},"    real(kind=real32) :: number, result\n",[112,222,223],{"class":114,"line":151},[112,224,154],{"emptyLinePlaceholder":7},[112,226,227],{"class":114,"line":157},[112,228,229],{},"    number = 5\n",[112,231,232],{"class":114,"line":163},[112,233,234],{},"    call compute_factorial(number, result)\n",[112,236,237],{"class":114,"line":169},[112,238,239],{},"    print *, \"Factorial of \", number, \"is\", result\n",[112,241,242],{"class":114,"line":175},[112,243,244],{},"end program test_implicit_interface\n",[81,246,248],{"id":247},"compliant-solution","Compliant Solution",[42,250,251,252,255],{},"In this compliant solution, the subroutine is moved inside a ",[52,253,254],{},"module"," . The main program uses the module. This provides an explicit interface, allowing the compiler to detect the type mismatch during compilation. The developer is forced to fix the types in the main program to match the subroutine definition.",[99,257,259,346,349,402,405,408,415,479,483,486,565,568,591,595],{"quality":258},"good",[103,260,262],{"className":105,"code":261,"language":107,"meta":108,"style":108},"! coompute_factorial_lib.f90\nmodule mod_compute_factorial\n    implicit none\ncontains\n    pure subroutine compute_factorial(n, result)\n        implicit none\n        integer, intent(in)  :: n\n        integer, intent(out) :: result\n        integer :: i\n\n        result = 1\n        do i = 2, n\n            result = result * i\n        end do\n    end subroutine compute_factorial\nend module mod_compute_factorial\n",[52,263,264,269,274,278,283,288,293,298,303,308,312,317,322,328,334,340],{"__ignoreMap":108},[112,265,266],{"class":114,"line":115},[112,267,268],{},"! coompute_factorial_lib.f90\n",[112,270,271],{"class":114,"line":121},[112,272,273],{},"module mod_compute_factorial\n",[112,275,276],{"class":114,"line":127},[112,277,130],{},[112,279,280],{"class":114,"line":133},[112,281,282],{},"contains\n",[112,284,285],{"class":114,"line":139},[112,286,287],{},"    pure subroutine compute_factorial(n, result)\n",[112,289,290],{"class":114,"line":145},[112,291,292],{},"        implicit none\n",[112,294,295],{"class":114,"line":151},[112,296,297],{},"        integer, intent(in)  :: n\n",[112,299,300],{"class":114,"line":157},[112,301,302],{},"        integer, intent(out) :: result\n",[112,304,305],{"class":114,"line":163},[112,306,307],{},"        integer :: i\n",[112,309,310],{"class":114,"line":169},[112,311,154],{"emptyLinePlaceholder":7},[112,313,314],{"class":114,"line":175},[112,315,316],{},"        result = 1\n",[112,318,319],{"class":114,"line":181},[112,320,321],{},"        do i = 2, n\n",[112,323,325],{"class":114,"line":324},13,[112,326,327],{},"            result = result * i\n",[112,329,331],{"class":114,"line":330},14,[112,332,333],{},"        end do\n",[112,335,337],{"class":114,"line":336},15,[112,338,339],{},"    end subroutine compute_factorial\n",[112,341,343],{"class":114,"line":342},16,[112,344,345],{},"end module mod_compute_factorial\n",[42,347,348],{},":: ::code-block{quality=\"good\"}",[103,350,352],{"className":105,"code":351,"language":107,"meta":108,"style":108},"! main.f90\nprogram test_explicit_interface\n    use iso_fortran_env, only: real32\n    use mod_compute_factorial, only: compute_factorial\n    implicit none\n    real(kind=real32) :: number, result\n\n    number = 5\n    call compute_factorial(number, result)\n    print *, \"Factorial of\", number, \"is\", result\nend program test_explicit_interface\n",[52,353,354,358,363,367,372,376,380,384,388,392,397],{"__ignoreMap":108},[112,355,356],{"class":114,"line":115},[112,357,196],{},[112,359,360],{"class":114,"line":121},[112,361,362],{},"program test_explicit_interface\n",[112,364,365],{"class":114,"line":127},[112,366,206],{},[112,368,369],{"class":114,"line":133},[112,370,371],{},"    use mod_compute_factorial, only: compute_factorial\n",[112,373,374],{"class":114,"line":139},[112,375,130],{},[112,377,378],{"class":114,"line":145},[112,379,220],{},[112,381,382],{"class":114,"line":151},[112,383,154],{"emptyLinePlaceholder":7},[112,385,386],{"class":114,"line":157},[112,387,229],{},[112,389,390],{"class":114,"line":163},[112,391,234],{},[112,393,394],{"class":114,"line":169},[112,395,396],{},"    print *, \"Factorial of\", number, \"is\", result\n",[112,398,399],{"class":114,"line":175},[112,400,401],{},"end program test_explicit_interface\n",[42,403,404],{},"::",[81,406,84],{"id":407},"noncompliant-code-example-1",[42,409,410,411,414],{},"While it is possible to provide an explicit interface using an ",[52,412,413],{},"interface"," block, this approach is error-prone. If the external procedure definition changes, the interface block in the calling program must be manually updated. If they diverge, the compiler may not detect the error, leading to the same runtime issues as an implicit interface.",[99,416,417],{"quality":101},[103,418,420],{"className":105,"code":419,"language":107,"meta":108,"style":108},"program manual_interface_risk\n    implicit none\n\n    ! Noncompliant: Manually defined interface\n    interface\n        subroutine calc(a)\n            real, intent(in) :: a\n        end subroutine calc\n    end interface\n\n    call calc(5.0)\nend program manual_interface_risk\n",[52,421,422,427,431,435,440,445,450,455,460,465,469,474],{"__ignoreMap":108},[112,423,424],{"class":114,"line":115},[112,425,426],{},"program manual_interface_risk\n",[112,428,429],{"class":114,"line":121},[112,430,130],{},[112,432,433],{"class":114,"line":127},[112,434,154],{"emptyLinePlaceholder":7},[112,436,437],{"class":114,"line":133},[112,438,439],{},"    ! Noncompliant: Manually defined interface\n",[112,441,442],{"class":114,"line":139},[112,443,444],{},"    interface\n",[112,446,447],{"class":114,"line":145},[112,448,449],{},"        subroutine calc(a)\n",[112,451,452],{"class":114,"line":151},[112,453,454],{},"            real, intent(in) :: a\n",[112,456,457],{"class":114,"line":157},[112,458,459],{},"        end subroutine calc\n",[112,461,462],{"class":114,"line":163},[112,463,464],{},"    end interface\n",[112,466,467],{"class":114,"line":169},[112,468,154],{"emptyLinePlaceholder":7},[112,470,471],{"class":114,"line":175},[112,472,473],{},"    call calc(5.0)\n",[112,475,476],{"class":114,"line":181},[112,477,478],{},"end program manual_interface_risk\n",[81,480,482],{"id":481},"risk-assessment","Risk Assessment",[42,484,485],{},"Calling procedures with implicit interfaces disables the compiler's ability to verify that arguments match the procedure's definition. This can lead to undefined behavior, including memory corruption, incorrect results, runtime instability, or crashes. The risk is not limited to mixed-type arithmetic: any mismatch in argument characteristics can cause errors that are undetectable at compile time.",[487,488,489,510],"table",{},[490,491,492],"thead",{},[493,494,495,498,500,502,504,506,508],"tr",{},[496,497],"th",{},[496,499],{},[496,501],{},[496,503],{},[496,505],{},[496,507],{},[496,509],{},[511,512,513,537],"tbody",{},[493,514,515,519,522,525,528,531,534],{},[516,517,518],"td",{},"Recommendation",[516,520,521],{},"Severity",[516,523,524],{},"Likelihood",[516,526,527],{},"Detectable",[516,529,530],{},"Repairable",[516,532,533],{},"Priority",[516,535,536],{},"Level",[493,538,539,542,545,548,551,554,560],{},[516,540,541],{},"PRC02-F",[516,543,544],{},"High",[516,546,547],{},"Probable",[516,549,550],{},"Yes",[516,552,553],{},"No",[516,555,556],{},[557,558,559],"strong",{},"P12",[516,561,562],{},[557,563,564],{},"L1",[566,567],"hr",{},[42,569,570,578,579,578,585],{},[571,572,574],"a",{"href":573},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[575,576],"img",{"src":577},"attachments\u002F629047322\u002F638779547.png"," ",[571,580,582],{"href":581},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[575,583],{"src":584},"attachments\u002F629047322\u002F638779548.png",[571,586,588],{"href":587},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[575,589],{"src":590},"attachments\u002F629047322\u002F638779549.png",[81,592,594],{"id":593},"attachments","Attachments:",[596,597,601],"div",{"className":598,"align":600},[599],"greybox","left",[42,602,603,578,606,609,610,613,578,615,609,618,620,578,622,609],{},[575,604],{"alt":108,"src":605},"images\u002Ficons\u002Fbullet_blue.gif",[571,607,608],{"href":577},"button_arrow_left.png"," (image\u002Fpng)",[611,612],"br",{},[575,614],{"alt":108,"src":605},[571,616,617],{"href":584},"button_arrow_up.png",[611,619],{},[575,621],{"alt":108,"src":605},[571,623,624],{"href":590},"button_arrow_right.png",[626,627,628],"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":108,"searchDepth":121,"depth":121,"links":630},[631,632,633,634,635],{"id":83,"depth":121,"text":84},{"id":247,"depth":121,"text":248},{"id":407,"depth":121,"text":84},{"id":481,"depth":121,"text":482},{"id":593,"depth":121,"text":594},"md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc02-f",{"title":33,"description":44},"9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F3.prc02-f","OjwfvG4VDhE0JI-jsLfr7S8uybZ-4vXSXysS9FK-d_0",[643,647],{"title":644,"path":645,"stem":646,"children":-1},"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":648,"path":649,"stem":650,"children":-1},"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",[652],{"title":653,"path":654,"stem":655,"children":656},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[657,660,682,696,722,732,736,746,750,754,758,762,780,789,793,811,832],{"title":658,"path":654,"stem":659},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":661,"path":662,"stem":663,"children":664},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[665,666,670,674,678],{"title":661,"path":662,"stem":663},{"title":667,"path":668,"stem":669},"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":671,"path":672,"stem":673},"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":675,"path":676,"stem":677},"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":679,"path":680,"stem":681},"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":683,"path":684,"stem":685,"children":686},"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",[687,688,692],{"title":683,"path":684,"stem":685},{"title":689,"path":690,"stem":691},"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":693,"path":694,"stem":695},"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":697,"path":698,"stem":699,"children":700},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[701,702,706,710,714,718],{"title":697,"path":698,"stem":699},{"title":703,"path":704,"stem":705},"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":707,"path":708,"stem":709},"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":711,"path":712,"stem":713},"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":715,"path":716,"stem":717},"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":719,"path":720,"stem":721},"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":723,"path":724,"stem":725,"children":726},"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",[727,728],{"title":723,"path":724,"stem":725},{"title":729,"path":730,"stem":731},"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":733,"path":734,"stem":735},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":737,"path":738,"stem":739,"children":740},"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",[741,742],{"title":737,"path":738,"stem":739},{"title":743,"path":744,"stem":745},"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":747,"path":748,"stem":749},"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":751,"path":752,"stem":753},"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":755,"path":756,"stem":757},"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":759,"path":760,"stem":761},"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":763,"path":764,"stem":765,"children":766},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[767,768,772,776],{"title":763,"path":764,"stem":765},{"title":769,"path":770,"stem":771},"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":773,"path":774,"stem":775},"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":777,"path":778,"stem":779},"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":781,"path":782,"stem":783,"children":784},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[785,786,787,788],{"title":781,"path":782,"stem":783},{"title":644,"path":645,"stem":646},{"title":33,"path":638,"stem":640},{"title":648,"path":649,"stem":650},{"title":790,"path":791,"stem":792},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":794,"path":795,"stem":796,"children":797},"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",[798,799,803,807],{"title":794,"path":795,"stem":796},{"title":800,"path":801,"stem":802},"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":804,"path":805,"stem":806},"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":808,"path":809,"stem":810},"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":812,"path":813,"stem":814,"children":815},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[816,817,820,824,828],{"title":812,"path":813,"stem":814},{"title":818,"path":587,"stem":819},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":821,"path":822,"stem":823},"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":825,"path":826,"stem":827},"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":829,"path":830,"stem":831},"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":833,"path":834,"stem":835},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320167743]