[{"data":1,"prerenderedAt":796},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc03-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc03-f":602,"sidebar-sei-cert-fortran-coding-standard":611},[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":595,"extension":596,"meta":597,"navigation":7,"path":598,"seo":599,"stem":600,"__hash__":601},"content\u002F9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F4.prc03-f.md","PRC03-F. Declare the intent for all dummy arguments",{"type":35,"value":36,"toc":586},"minimark",[37,41,50,56,78,87,92,95,210,214,223,298,301,307,352,355,361,403,407,413,491,495,523,526,548,552,582],[38,39,33],"h1",{"id":40},"prc03-f-declare-the-intent-for-all-dummy-arguments",[42,43,44,45,49],"p",{},"All dummy arguments in a procedure (function or subroutine) shall have their ",[46,47,48],"code",{},"intent"," attribute explicitly declared.",[42,51,52,53,55],{},"The ",[46,54,48],{}," attribute specifies how a dummy argument is used within a procedure:",[57,58,59,66,72],"ul",{},[60,61,62,65],"li",{},[46,63,64],{},"intent(in)"," : The argument is used only to pass data into the procedure and shall not be modified.",[60,67,68,71],{},[46,69,70],{},"intent(out)"," : The argument is used to return data from the procedure; its initial value is undefined on entry.",[60,73,74,77],{},[46,75,76],{},"intent(inout)"," : The argument is used to pass data in, modify it, and return the modified value.",[42,79,80,81,83,84,86],{},"If ",[46,82,48],{}," is not specified, a dummy argument is implicitly treated as modifiable. This weakens the compiler's ability to detect programming errors and prevents the enforcement of read-only semantics. Explicitly declaring ",[46,85,48],{}," improves correctness checking, documents procedure interfaces, and enables reliable data-flow analysis.",[88,89,91],"h2",{"id":90},"noncompliant-code-example","Noncompliant Code Example",[42,93,94],{},"In this noncompliant example, the intent of the dummy arguments is not declared. As a result, the input argument n is unintentionally modified. Because the compiler cannot determine whether the actual argument is definable, passing a constant or expression could lead to runtime errors or undefined behavior.",[96,97,99],"code-block",{"quality":98},"bad",[100,101,106],"pre",{"className":102,"code":103,"language":104,"meta":105,"style":105},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","program test_square\n  implicit none\n  integer :: val = 5\n  integer :: res\n\n  call square(val, res)\n  print *, \"Val (expected 5): \", val\n\ncontains\n  subroutine square(n, result)\n    integer :: n ! Noncompliant: Implicit intent\n    integer :: result ! Noncompliant: Implicit intent\n\n    n = n * n\n    result = n\n  end subroutine square\nend program test_square\n","fortran","",[46,107,108,116,122,128,134,140,146,152,157,163,169,175,181,186,192,198,204],{"__ignoreMap":105},[109,110,113],"span",{"class":111,"line":112},"line",1,[109,114,115],{},"program test_square\n",[109,117,119],{"class":111,"line":118},2,[109,120,121],{},"  implicit none\n",[109,123,125],{"class":111,"line":124},3,[109,126,127],{},"  integer :: val = 5\n",[109,129,131],{"class":111,"line":130},4,[109,132,133],{},"  integer :: res\n",[109,135,137],{"class":111,"line":136},5,[109,138,139],{"emptyLinePlaceholder":7},"\n",[109,141,143],{"class":111,"line":142},6,[109,144,145],{},"  call square(val, res)\n",[109,147,149],{"class":111,"line":148},7,[109,150,151],{},"  print *, \"Val (expected 5): \", val\n",[109,153,155],{"class":111,"line":154},8,[109,156,139],{"emptyLinePlaceholder":7},[109,158,160],{"class":111,"line":159},9,[109,161,162],{},"contains\n",[109,164,166],{"class":111,"line":165},10,[109,167,168],{},"  subroutine square(n, result)\n",[109,170,172],{"class":111,"line":171},11,[109,173,174],{},"    integer :: n ! Noncompliant: Implicit intent\n",[109,176,178],{"class":111,"line":177},12,[109,179,180],{},"    integer :: result ! Noncompliant: Implicit intent\n",[109,182,184],{"class":111,"line":183},13,[109,185,139],{"emptyLinePlaceholder":7},[109,187,189],{"class":111,"line":188},14,[109,190,191],{},"    n = n * n\n",[109,193,195],{"class":111,"line":194},15,[109,196,197],{},"    result = n\n",[109,199,201],{"class":111,"line":200},16,[109,202,203],{},"  end subroutine square\n",[109,205,207],{"class":111,"line":206},17,[109,208,209],{},"end program test_square\n",[88,211,213],{"id":212},"compliant-solution","Compliant Solution",[42,215,216,217,219,220,222],{},"By explicitly declaring ",[46,218,48],{}," , the compiler can enforce correct usage. Attempting to modify an ",[46,221,64],{}," argument will result in a compile-time error, preventing accidental side effects.",[96,224,226],{"quality":225},"good",[100,227,229],{"className":102,"code":228,"language":104,"meta":105,"style":105},"program test_square\n  implicit none\n  integer :: val = 5\n  integer :: res\n\n  call square(val, res)\n  print *, \"Val (expected 5): \", val\n\ncontains\n  subroutine square(n, result)\n    integer, intent(in)  :: n\n    integer, intent(out) :: result\n\n    result = n * n\n  end subroutine square\nend program test_square\n",[46,230,231,235,239,243,247,251,255,259,263,267,271,276,281,285,290,294],{"__ignoreMap":105},[109,232,233],{"class":111,"line":112},[109,234,115],{},[109,236,237],{"class":111,"line":118},[109,238,121],{},[109,240,241],{"class":111,"line":124},[109,242,127],{},[109,244,245],{"class":111,"line":130},[109,246,133],{},[109,248,249],{"class":111,"line":136},[109,250,139],{"emptyLinePlaceholder":7},[109,252,253],{"class":111,"line":142},[109,254,145],{},[109,256,257],{"class":111,"line":148},[109,258,151],{},[109,260,261],{"class":111,"line":154},[109,262,139],{"emptyLinePlaceholder":7},[109,264,265],{"class":111,"line":159},[109,266,162],{},[109,268,269],{"class":111,"line":165},[109,270,168],{},[109,272,273],{"class":111,"line":171},[109,274,275],{},"    integer, intent(in)  :: n\n",[109,277,278],{"class":111,"line":177},[109,279,280],{},"    integer, intent(out) :: result\n",[109,282,283],{"class":111,"line":183},[109,284,139],{"emptyLinePlaceholder":7},[109,286,287],{"class":111,"line":188},[109,288,289],{},"    result = n * n\n",[109,291,292],{"class":111,"line":194},[109,293,203],{},[109,295,296],{"class":111,"line":200},[109,297,209],{},[88,299,91],{"id":300},"noncompliant-code-example-1",[42,302,303,304,306],{},"Without explicit ",[46,305,48],{}," , the compiler must assume that all arguments may be modified. This obscures the procedure's contract and makes it unsafe to pass constants or expressions. If the procedure modifies such arguments, memory corruption or runtime failures may occur.",[96,308,309],{"quality":98},[100,310,312],{"className":102,"code":311,"language":104,"meta":105,"style":105},"subroutine add_arrays(n, vec_a, vec_b)\n  implicit none\n  integer :: n\n  real    :: vec_a(n) ! Noncompliant: Implicit INOUT\n  real    :: vec_b(n) ! Noncompliant: Implicit INOUT\n\n  vec_b = vec_a + 1.0\nend subroutine add_arrays\n",[46,313,314,319,323,328,333,338,342,347],{"__ignoreMap":105},[109,315,316],{"class":111,"line":112},[109,317,318],{},"subroutine add_arrays(n, vec_a, vec_b)\n",[109,320,321],{"class":111,"line":118},[109,322,121],{},[109,324,325],{"class":111,"line":124},[109,326,327],{},"  integer :: n\n",[109,329,330],{"class":111,"line":130},[109,331,332],{},"  real    :: vec_a(n) ! Noncompliant: Implicit INOUT\n",[109,334,335],{"class":111,"line":136},[109,336,337],{},"  real    :: vec_b(n) ! Noncompliant: Implicit INOUT\n",[109,339,340],{"class":111,"line":142},[109,341,139],{"emptyLinePlaceholder":7},[109,343,344],{"class":111,"line":148},[109,345,346],{},"  vec_b = vec_a + 1.0\n",[109,348,349],{"class":111,"line":154},[109,350,351],{},"end subroutine add_arrays\n",[88,353,213],{"id":354},"compliant-solution-1",[42,356,357,358,360],{},"Explicit ",[46,359,48],{}," declarations clearly define which arguments are read-only and which are outputs. This prevents accidental modification of inputs and allows the compiler to enforce interface correctness.",[96,362,363],{"quality":225},[100,364,366],{"className":102,"code":365,"language":104,"meta":105,"style":105},"subroutine add_arrays(n, vec_a, vec_b)\n  implicit none\n  integer, intent(in)  :: n\n  real,    intent(in)  :: vec_a(n)\n  real,    intent(out) :: vec_b(n)\n\n  vec_b = vec_a + 1.0\nend subroutine add_arrays\n",[46,367,368,372,376,381,386,391,395,399],{"__ignoreMap":105},[109,369,370],{"class":111,"line":112},[109,371,318],{},[109,373,374],{"class":111,"line":118},[109,375,121],{},[109,377,378],{"class":111,"line":124},[109,379,380],{},"  integer, intent(in)  :: n\n",[109,382,383],{"class":111,"line":130},[109,384,385],{},"  real,    intent(in)  :: vec_a(n)\n",[109,387,388],{"class":111,"line":136},[109,389,390],{},"  real,    intent(out) :: vec_b(n)\n",[109,392,393],{"class":111,"line":142},[109,394,139],{"emptyLinePlaceholder":7},[109,396,397],{"class":111,"line":148},[109,398,346],{},[109,400,401],{"class":111,"line":154},[109,402,351],{},[88,404,406],{"id":405},"risk-assessment","Risk Assessment",[42,408,409,410,412],{},"Failing to declare ",[46,411,48],{}," obscures the intended data flow of procedures and allows accidental modification of input arguments. This can lead to subtle logic errors, unsafe argument passing (e.g., constants or expressions), and undefined behavior that is difficult to detect through testing alone.",[414,415,416,437],"table",{},[417,418,419],"thead",{},[420,421,422,425,427,429,431,433,435],"tr",{},[423,424],"th",{},[423,426],{},[423,428],{},[423,430],{},[423,432],{},[423,434],{},[423,436],{},[438,439,440,464],"tbody",{},[420,441,442,446,449,452,455,458,461],{},[443,444,445],"td",{},"Recommendation",[443,447,448],{},"Severity",[443,450,451],{},"Likelihood",[443,453,454],{},"Detectable",[443,456,457],{},"Repairable",[443,459,460],{},"Priority",[443,462,463],{},"Level",[420,465,466,469,472,475,478,480,486],{},[443,467,468],{},"PRC03-F",[443,470,471],{},"High",[443,473,474],{},"Unlikely",[443,476,477],{},"Yes",[443,479,477],{},[443,481,482],{},[483,484,485],"strong",{},"P9",[443,487,488],{},[483,489,490],{},"L2",[88,492,494],{"id":493},"bibliography","Bibliography",[414,496,497,505],{},[417,498,499],{},[420,500,501,503],{},[423,502],{},[423,504],{},[438,506,507],{},[420,508,509,520],{},[443,510,511,512,519],{},"[ ",[513,514,518],"a",{"href":515,"rel":516},"https:\u002F\u002Fj3-fortran.org\u002Fdoc\u002Fyear\u002F24\u002F24-007.pdf",[517],"nofollow","Fortran 2023 Interpretation Document"," ]",[443,521,522],{},"Section 8.5.10",[524,525],"hr",{},[42,527,528,535,536,535,542],{},[513,529,531],{"href":530},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[532,533],"img",{"src":534},"attachments\u002F637173792\u002F638779551.png"," ",[513,537,539],{"href":538},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[532,540],{"src":541},"attachments\u002F637173792\u002F638779552.png",[513,543,545],{"href":544},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[532,546],{"src":547},"attachments\u002F637173792\u002F638779553.png",[88,549,551],{"id":550},"attachments","Attachments:",[553,554,558],"div",{"className":555,"align":557},[556],"greybox","left",[42,559,560,535,563,566,567,570,535,572,566,575,577,535,579,566],{},[532,561],{"alt":105,"src":562},"images\u002Ficons\u002Fbullet_blue.gif",[513,564,565],{"href":534},"button_arrow_left.png"," (image\u002Fpng)",[568,569],"br",{},[532,571],{"alt":105,"src":562},[513,573,574],{"href":541},"button_arrow_up.png",[568,576],{},[532,578],{"alt":105,"src":562},[513,580,581],{"href":547},"button_arrow_right.png",[583,584,585],"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":105,"searchDepth":118,"depth":118,"links":587},[588,589,590,591,592,593,594],{"id":90,"depth":118,"text":91},{"id":212,"depth":118,"text":213},{"id":300,"depth":118,"text":91},{"id":354,"depth":118,"text":213},{"id":405,"depth":118,"text":406},{"id":493,"depth":118,"text":494},{"id":550,"depth":118,"text":551},"All dummy arguments in a procedure (function or subroutine) shall have their intent attribute explicitly declared.","md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc\u002Fprc03-f",{"title":33,"description":595},"9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F4.prc03-f","69vFRXUn-pIBA500c5WWol62IbT_neH02lRrIAdgzRU",[603,607],{"title":604,"path":605,"stem":606,"children":-1},"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":608,"path":609,"stem":610,"children":-1},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",[612],{"title":613,"path":614,"stem":615,"children":616},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[617,620,642,656,682,692,696,706,710,714,718,722,740,752,753,771,792],{"title":618,"path":614,"stem":619},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":621,"path":622,"stem":623,"children":624},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[625,626,630,634,638],{"title":621,"path":622,"stem":623},{"title":627,"path":628,"stem":629},"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":631,"path":632,"stem":633},"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":635,"path":636,"stem":637},"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":639,"path":640,"stem":641},"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":643,"path":644,"stem":645,"children":646},"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",[647,648,652],{"title":643,"path":644,"stem":645},{"title":649,"path":650,"stem":651},"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":653,"path":654,"stem":655},"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":657,"path":658,"stem":659,"children":660},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[661,662,666,670,674,678],{"title":657,"path":658,"stem":659},{"title":663,"path":664,"stem":665},"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":667,"path":668,"stem":669},"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":671,"path":672,"stem":673},"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":675,"path":676,"stem":677},"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":679,"path":680,"stem":681},"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":683,"path":684,"stem":685,"children":686},"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",[687,688],{"title":683,"path":684,"stem":685},{"title":689,"path":690,"stem":691},"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":693,"path":694,"stem":695},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":697,"path":698,"stem":699,"children":700},"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",[701,702],{"title":697,"path":698,"stem":699},{"title":703,"path":704,"stem":705},"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":707,"path":708,"stem":709},"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":711,"path":712,"stem":713},"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":715,"path":716,"stem":717},"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":719,"path":720,"stem":721},"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":723,"path":724,"stem":725,"children":726},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[727,728,732,736],{"title":723,"path":724,"stem":725},{"title":729,"path":730,"stem":731},"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":733,"path":734,"stem":735},"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":737,"path":738,"stem":739},"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":741,"path":742,"stem":743,"children":744},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[745,746,750,751],{"title":741,"path":742,"stem":743},{"title":747,"path":748,"stem":749},"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":604,"path":605,"stem":606},{"title":33,"path":598,"stem":600},{"title":608,"path":609,"stem":610},{"title":754,"path":755,"stem":756,"children":757},"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",[758,759,763,767],{"title":754,"path":755,"stem":756},{"title":760,"path":761,"stem":762},"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":764,"path":765,"stem":766},"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":768,"path":769,"stem":770},"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":772,"path":773,"stem":774,"children":775},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[776,777,780,784,788],{"title":772,"path":773,"stem":774},{"title":778,"path":544,"stem":779},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":781,"path":782,"stem":783},"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":785,"path":786,"stem":787},"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":789,"path":790,"stem":791},"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":793,"path":794,"stem":795},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320167739]