[{"data":1,"prerenderedAt":854},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Fsad03-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Fsad03-f":660,"sidebar-sei-cert-fortran-coding-standard":669},[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":653,"extension":654,"meta":655,"navigation":7,"path":656,"seo":657,"stem":658,"__hash__":659},"content\u002F9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F3.sad03-f.md","SAD03-F. Replace common block with modules for safer data encapsulation",{"type":35,"value":36,"toc":645},"minimark",[37,41,50,56,59,72,83,88,106,237,241,250,361,364,375,464,468,471,550,554,582,585,607,611,641],[38,39,33],"h1",{"id":40},"sad03-f-replace-common-block-with-modules-for-safer-data-encapsulation",[42,43,44,45,49],"p",{},"Shared data should be encapsulated in modules rather than using ",[46,47,48],"code",{},"common"," blocks to ensure type safety, consistent naming, and minimal scope.",[42,51,52,53,55],{},"The ",[46,54,48],{}," statement is a legacy Fortran feature that specifies a block of memory shared across program units. The Fortran standard now identifies common blocks as obsolescent, noting that they are error-prone, inhibit maintainability, and can impact performance.",[42,57,58],{},"Relying on common blocks introduces several risks:",[60,61,62,66,69],"ul",{},[63,64,65],"li",{},"Lack of type safety: Different program units can associate conflicting types with the same memory location, potentially causing memory corruption.",[63,67,68],{},"Name inconsistency: Each procedure must redeclare the common block, leading to inconsistent names and difficult-to-audit logic.",[63,70,71],{},"Global scope vulnerabilities: Using a larger scope than necessary makes code less readable and increases the likelihood of referencing unintended variables.",[42,73,74,75,78,79,82],{},"Modules provide a superior alternative by allowing controlled access to data through the ",[46,76,77],{},"use"," statement and the ",[46,80,81],{},"only"," clause, allowing the compiler to enforce type, rank, and scope consistency.",[84,85,87],"h2",{"id":86},"noncompliant-code-example","Noncompliant Code Example",[42,89,90,91,94,95,98,99,102,103,105],{},"In this noncompliant example, the main program shares two variables via a common block. However, the subroutine ",[46,92,93],{},"update_kinetics"," re-defines the common block but omits the first variable ( ",[46,96,97],{},"mass"," ). Consequently, the local variable ",[46,100,101],{},"velocity"," in the subroutine unintentionally references the memory location assigned to ",[46,104,97],{}," in the main program.",[107,108,110],"code-block",{"quality":109},"bad",[111,112,117],"pre",{"className":113,"code":114,"language":115,"meta":116,"style":116},"language-fortran shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","program physics_sim\n  implicit none\n  real :: mass, velocity\n  ! Noncompliant: Global memory shared via common block\n  common \u002Fsim_data\u002F mass, velocity\n\n  mass     = 10.0\n  velocity = 50.0\n\n  call update_kinetics \nend program physics_sim\n\nsubroutine update_kinetics\n  implicit none\n  real :: velocity\n  ! Noncompliant: Re-declaration is missing 'mass'\n  common \u002Fsim_data\u002F velocity\n\n  print *, \"Velocity inside subroutine: \", velocity\nend subroutine update_kinetics\n","fortran","",[46,118,119,127,133,139,145,151,157,163,169,174,180,186,191,197,202,208,214,220,225,231],{"__ignoreMap":116},[120,121,124],"span",{"class":122,"line":123},"line",1,[120,125,126],{},"program physics_sim\n",[120,128,130],{"class":122,"line":129},2,[120,131,132],{},"  implicit none\n",[120,134,136],{"class":122,"line":135},3,[120,137,138],{},"  real :: mass, velocity\n",[120,140,142],{"class":122,"line":141},4,[120,143,144],{},"  ! Noncompliant: Global memory shared via common block\n",[120,146,148],{"class":122,"line":147},5,[120,149,150],{},"  common \u002Fsim_data\u002F mass, velocity\n",[120,152,154],{"class":122,"line":153},6,[120,155,156],{"emptyLinePlaceholder":7},"\n",[120,158,160],{"class":122,"line":159},7,[120,161,162],{},"  mass     = 10.0\n",[120,164,166],{"class":122,"line":165},8,[120,167,168],{},"  velocity = 50.0\n",[120,170,172],{"class":122,"line":171},9,[120,173,156],{"emptyLinePlaceholder":7},[120,175,177],{"class":122,"line":176},10,[120,178,179],{},"  call update_kinetics \n",[120,181,183],{"class":122,"line":182},11,[120,184,185],{},"end program physics_sim\n",[120,187,189],{"class":122,"line":188},12,[120,190,156],{"emptyLinePlaceholder":7},[120,192,194],{"class":122,"line":193},13,[120,195,196],{},"subroutine update_kinetics\n",[120,198,200],{"class":122,"line":199},14,[120,201,132],{},[120,203,205],{"class":122,"line":204},15,[120,206,207],{},"  real :: velocity\n",[120,209,211],{"class":122,"line":210},16,[120,212,213],{},"  ! Noncompliant: Re-declaration is missing 'mass'\n",[120,215,217],{"class":122,"line":216},17,[120,218,219],{},"  common \u002Fsim_data\u002F velocity\n",[120,221,223],{"class":122,"line":222},18,[120,224,156],{"emptyLinePlaceholder":7},[120,226,228],{"class":122,"line":227},19,[120,229,230],{},"  print *, \"Velocity inside subroutine: \", velocity\n",[120,232,234],{"class":122,"line":233},20,[120,235,236],{},"end subroutine update_kinetics\n",[84,238,240],{"id":239},"compliant-solution","Compliant Solution",[42,242,243,244,246,247,249],{},"In this compliant solution, the variables are migrated to a module. This ensures that every programming unit accessing ",[46,245,97],{}," or ",[46,248,101],{}," refers to the same unique identifier and correct data type.",[107,251,253],{"quality":252},"good",[111,254,256],{"className":113,"code":255,"language":115,"meta":116,"style":116},"module physics_data_mod\n  implicit none\n  ! Compliant: Data is encapsulated and type-checked\n  real :: mass, velocity\nend module physics_data_mod\n\nprogram physics_sim\n  use physics_data_mod, only: mass, velocity\n  implicit none\n\n  mass     = 10.0\n  velocity = 50.0\n    \n  call update_kinetics\nend program physics_sim\n\nsubroutine update_kinetics\n  use physics_data_mod, only: velocity\n  implicit none\n\n  ! Compliant: velocity correctly refers to the shared module variable\n  print *, \"Velocity inside subroutine: \", velocity\nend subroutine update_kinetics\n",[46,257,258,263,267,272,276,281,285,289,294,298,302,306,310,315,320,324,328,332,337,341,345,351,356],{"__ignoreMap":116},[120,259,260],{"class":122,"line":123},[120,261,262],{},"module physics_data_mod\n",[120,264,265],{"class":122,"line":129},[120,266,132],{},[120,268,269],{"class":122,"line":135},[120,270,271],{},"  ! Compliant: Data is encapsulated and type-checked\n",[120,273,274],{"class":122,"line":141},[120,275,138],{},[120,277,278],{"class":122,"line":147},[120,279,280],{},"end module physics_data_mod\n",[120,282,283],{"class":122,"line":153},[120,284,156],{"emptyLinePlaceholder":7},[120,286,287],{"class":122,"line":159},[120,288,126],{},[120,290,291],{"class":122,"line":165},[120,292,293],{},"  use physics_data_mod, only: mass, velocity\n",[120,295,296],{"class":122,"line":171},[120,297,132],{},[120,299,300],{"class":122,"line":176},[120,301,156],{"emptyLinePlaceholder":7},[120,303,304],{"class":122,"line":182},[120,305,162],{},[120,307,308],{"class":122,"line":188},[120,309,168],{},[120,311,312],{"class":122,"line":193},[120,313,314],{},"    \n",[120,316,317],{"class":122,"line":199},[120,318,319],{},"  call update_kinetics\n",[120,321,322],{"class":122,"line":204},[120,323,185],{},[120,325,326],{"class":122,"line":210},[120,327,156],{"emptyLinePlaceholder":7},[120,329,330],{"class":122,"line":216},[120,331,196],{},[120,333,334],{"class":122,"line":222},[120,335,336],{},"  use physics_data_mod, only: velocity\n",[120,338,339],{"class":122,"line":227},[120,340,132],{},[120,342,343],{"class":122,"line":233},[120,344,156],{"emptyLinePlaceholder":7},[120,346,348],{"class":122,"line":347},21,[120,349,350],{},"  ! Compliant: velocity correctly refers to the shared module variable\n",[120,352,354],{"class":122,"line":353},22,[120,355,230],{},[120,357,359],{"class":122,"line":358},23,[120,360,236],{},[84,362,240],{"id":363},"compliant-solution-1",[42,365,366,367,370,371,374],{},"For maximum security and encapsulation, module variables should be declared ",[46,368,369],{},"PRIVATE"," , with access managed through ",[46,372,373],{},"PUBLIC"," getter and setter procedures. This follows the principle of minimizing the scope by ensuring variables are only modified through controlled interfaces.",[107,376,377],{"quality":252},[111,378,380],{"className":113,"code":379,"language":115,"meta":116,"style":116},"module kinetics_mod\n  implicit none\n  private\n  real   :: velocity\n  public :: get_velocity, set_velocity\n\ncontains\n  function get_velocity() result(v)\n    real :: v\n    v = velocity\n  end function\n\n  subroutine set_velocity(v)\n    real, intent(in) :: v\n    velocity = v\n  end subroutine\nend module kinetics_mod\n",[46,381,382,387,391,396,401,406,410,415,420,425,430,435,439,444,449,454,459],{"__ignoreMap":116},[120,383,384],{"class":122,"line":123},[120,385,386],{},"module kinetics_mod\n",[120,388,389],{"class":122,"line":129},[120,390,132],{},[120,392,393],{"class":122,"line":135},[120,394,395],{},"  private\n",[120,397,398],{"class":122,"line":141},[120,399,400],{},"  real   :: velocity\n",[120,402,403],{"class":122,"line":147},[120,404,405],{},"  public :: get_velocity, set_velocity\n",[120,407,408],{"class":122,"line":153},[120,409,156],{"emptyLinePlaceholder":7},[120,411,412],{"class":122,"line":159},[120,413,414],{},"contains\n",[120,416,417],{"class":122,"line":165},[120,418,419],{},"  function get_velocity() result(v)\n",[120,421,422],{"class":122,"line":171},[120,423,424],{},"    real :: v\n",[120,426,427],{"class":122,"line":176},[120,428,429],{},"    v = velocity\n",[120,431,432],{"class":122,"line":182},[120,433,434],{},"  end function\n",[120,436,437],{"class":122,"line":188},[120,438,156],{"emptyLinePlaceholder":7},[120,440,441],{"class":122,"line":193},[120,442,443],{},"  subroutine set_velocity(v)\n",[120,445,446],{"class":122,"line":199},[120,447,448],{},"    real, intent(in) :: v\n",[120,450,451],{"class":122,"line":204},[120,452,453],{},"    velocity = v\n",[120,455,456],{"class":122,"line":210},[120,457,458],{},"  end subroutine\n",[120,460,461],{"class":122,"line":216},[120,462,463],{},"end module kinetics_mod\n",[84,465,467],{"id":466},"risk-assessment","Risk Assessment",[42,469,470],{},"Using common blocks bypasses compiler checks and obscures data flow, increasing the likelihood of memory corruption, subtle logic errors, and unpredictable behavior in scientific computations.",[472,473,474,495],"table",{},[475,476,477],"thead",{},[478,479,480,483,485,487,489,491,493],"tr",{},[481,482],"th",{},[481,484],{},[481,486],{},[481,488],{},[481,490],{},[481,492],{},[481,494],{},[496,497,498,522],"tbody",{},[478,499,500,504,507,510,513,516,519],{},[501,502,503],"td",{},"Recommendation",[501,505,506],{},"Severity",[501,508,509],{},"Likelihood",[501,511,512],{},"Detectable",[501,514,515],{},"Repairable",[501,517,518],{},"Priority",[501,520,521],{},"Level",[478,523,524,527,530,533,536,539,545],{},[501,525,526],{},"SAD02-F",[501,528,529],{},"High",[501,531,532],{},"Unlikely",[501,534,535],{},"Yes",[501,537,538],{},"No",[501,540,541],{},[542,543,544],"strong",{},"P6",[501,546,547],{},[542,548,549],{},"L2",[84,551,553],{"id":552},"bibliography","Bibliography",[472,555,556,564],{},[475,557,558],{},[478,559,560,562],{},[481,561],{},[481,563],{},[496,565,566],{},[478,567,568,579],{},[501,569,570,571,578],{},"[ ",[572,573,577],"a",{"href":574,"rel":575},"https:\u002F\u002Fj3-fortran.org\u002Fdoc\u002Fyear\u002F24\u002F24-007.pdf",[576],"nofollow","Fortran 2023 Interpretation Document"," ]",[501,580,581],{},"Section B.3.11, C.10.2.2, 8.10.2, and 14.2.2",[583,584],"hr",{},[42,586,587,594,595,594,601],{},[572,588,590],{"href":589},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[591,592],"img",{"src":593},"attachments\u002F629047332\u002F638779579.png"," ",[572,596,598],{"href":597},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[591,599],{"src":600},"attachments\u002F629047332\u002F638779580.png",[572,602,604],{"href":603},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[591,605],{"src":606},"attachments\u002F629047332\u002F638779581.png",[84,608,610],{"id":609},"attachments","Attachments:",[612,613,617],"div",{"className":614,"align":616},[615],"greybox","left",[42,618,619,594,622,625,626,629,594,631,625,634,636,594,638,625],{},[591,620],{"alt":116,"src":621},"images\u002Ficons\u002Fbullet_blue.gif",[572,623,624],{"href":593},"button_arrow_left.png"," (image\u002Fpng)",[627,628],"br",{},[591,630],{"alt":116,"src":621},[572,632,633],{"href":600},"button_arrow_up.png",[627,635],{},[591,637],{"alt":116,"src":621},[572,639,640],{"href":606},"button_arrow_right.png",[642,643,644],"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":116,"searchDepth":129,"depth":129,"links":646},[647,648,649,650,651,652],{"id":86,"depth":129,"text":87},{"id":239,"depth":129,"text":240},{"id":363,"depth":129,"text":240},{"id":466,"depth":129,"text":467},{"id":552,"depth":129,"text":553},{"id":609,"depth":129,"text":610},"Shared data should be encapsulated in modules rather than using common blocks to ensure type safety, consistent naming, and minimal scope.","md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fscope-association-and-definition-sad\u002Fsad03-f",{"title":33,"description":653},"9.sei-cert-fortran-coding-standard\u002F15.scope-association-and-definition-sad\u002F3.sad03-f","1Ys0Iz1JRQs8thbeAN7Tau9HBo_fg2m3NhOID97xKVo",[661,665],{"title":662,"path":663,"stem":664,"children":-1},"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":666,"path":667,"stem":668,"children":-1},"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",[670],{"title":671,"path":672,"stem":673,"children":674},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[675,678,700,714,740,750,754,764,768,772,776,780,798,816,820,829,850],{"title":676,"path":672,"stem":677},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":679,"path":680,"stem":681,"children":682},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[683,684,688,692,696],{"title":679,"path":680,"stem":681},{"title":685,"path":686,"stem":687},"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":689,"path":690,"stem":691},"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":693,"path":694,"stem":695},"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":697,"path":698,"stem":699},"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":701,"path":702,"stem":703,"children":704},"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",[705,706,710],{"title":701,"path":702,"stem":703},{"title":707,"path":708,"stem":709},"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":711,"path":712,"stem":713},"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":715,"path":716,"stem":717,"children":718},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[719,720,724,728,732,736],{"title":715,"path":716,"stem":717},{"title":721,"path":722,"stem":723},"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":725,"path":726,"stem":727},"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":729,"path":730,"stem":731},"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":733,"path":734,"stem":735},"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":737,"path":738,"stem":739},"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":741,"path":742,"stem":743,"children":744},"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",[745,746],{"title":741,"path":742,"stem":743},{"title":747,"path":748,"stem":749},"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":751,"path":752,"stem":753},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":755,"path":756,"stem":757,"children":758},"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",[759,760],{"title":755,"path":756,"stem":757},{"title":761,"path":762,"stem":763},"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":765,"path":766,"stem":767},"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":769,"path":770,"stem":771},"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":773,"path":774,"stem":775},"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":777,"path":778,"stem":779},"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":781,"path":782,"stem":783,"children":784},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",[785,786,790,794],{"title":781,"path":782,"stem":783},{"title":787,"path":788,"stem":789},"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":791,"path":792,"stem":793},"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":795,"path":796,"stem":797},"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":799,"path":800,"stem":801,"children":802},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[803,804,808,812],{"title":799,"path":800,"stem":801},{"title":805,"path":806,"stem":807},"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":809,"path":810,"stem":811},"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":813,"path":814,"stem":815},"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":817,"path":818,"stem":819},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":821,"path":822,"stem":823,"children":824},"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",[825,826,827,828],{"title":821,"path":822,"stem":823},{"title":662,"path":663,"stem":664},{"title":33,"path":656,"stem":658},{"title":666,"path":667,"stem":668},{"title":830,"path":831,"stem":832,"children":833},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[834,835,838,842,846],{"title":830,"path":831,"stem":832},{"title":836,"path":603,"stem":837},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":839,"path":840,"stem":841},"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":843,"path":844,"stem":845},"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":847,"path":848,"stem":849},"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":851,"path":852,"stem":853},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320168387]