[{"data":1,"prerenderedAt":1563},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc01-f":31,"surround-\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc01-f":1369,"sidebar-sei-cert-fortran-coding-standard":1378},[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":1363,"meta":1364,"navigation":7,"path":1365,"seo":1366,"stem":1367,"__hash__":1368},"content\u002F9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F2.msc01-f.md","MSC01-F. Avoid using legacy or obsolescent Fortran constructs",{"type":35,"value":36,"toc":1352},"minimark",[37,41,45,48,78,81,86,89,155,159,162,270,275,281,519,523,529,650,653,656,885,888,895,1168,1172,1188,1258,1262,1289,1292,1314,1318,1348],[38,39,33],"h1",{"id":40},"msc01-f-avoid-using-legacy-or-obsolescent-fortran-constructs",[42,43,44],"p",{},"Programmers shall avoid using features identified as \"deleted\" or \"obsolescent\" by the Fortran standard, as well as legacy constructs that reduce clarity, maintainability, or compiler optimization potential.",[42,46,47],{},"Modern Fortran standard classifies legacy features into two categories:",[49,50,51,64],"ol",{},[52,53,54,55,59,60,63],"li",{},"Deleted features. Redundant or removed constructs that are no longer standard-conforming (e.g., ",[56,57,58],"code",{},"PAUSE"," , ",[56,61,62],{},"ASSIGN"," ).",[52,65,66,67,70,71,74,75,63],{},"Obsolescent features. Redundant constructs for which safer or clearer alternatives exist (e.g., ",[56,68,69],{},"COMMON"," blocks, ",[56,72,73],{},"EQUIVALENCE"," , Arithmetic ",[56,76,77],{},"IF",[42,79,80],{},"Relying on these features increases the risk of errors, reduces portability, and can inhibit compiler optimizations.",[82,83,85],"h3",{"id":84},"deleted-features","Deleted Features",[42,87,88],{},"These constructs are no longer part of the Fortran standard and are not permitted in strictly conforming modern code:",[90,91,92,109,115,124,129,135,141,148],"ul",{},[52,93,94,95,98,99,101,102,105,106,63],{},"Non-block ",[56,96,97],{},"DO"," loops (implicit ",[56,100,97],{}," without ",[56,103,104],{},"   END DO  ","or",[56,107,108],{},"   CONTINUE  ",[52,110,111,112,114],{},"Arithmetic ",[56,113,77],{}," .",[52,116,117,119,120,123],{},[56,118,62],{}," and assigned ",[56,121,122],{},"   GO TO  "," statements.",[52,125,126,128],{},[56,127,58],{}," statement.",[52,130,131,134],{},[56,132,133],{},"H"," edit descriptor.",[52,136,137,138,140],{},"Real and double precision ",[56,139,97],{}," loop control variables.",[52,142,143,144,147],{},"Branching to ",[56,145,146],{},"   END IF  "," from outside its block.",[52,149,150,151,154],{},"Assigned ",[56,152,153],{},"FORMAT"," specifier.",[82,156,158],{"id":157},"obsolescent-features","Obsolescent Features",[42,160,161],{},"These constructs are still supported by many compilers for backward compatibility, but are considered outdated and should be replaced with modern alternatives:",[90,163,164,185,199,216,236],{},[52,165,166,167],{},"Control flow\n",[90,168,169,176,182],{},[52,170,171,172,175],{},"Alternate return ( ",[56,173,174],{},"     CALL sub(arg, 10, 20, ...)    "," with numerical labels embedded).",[52,177,178,179,123],{},"Computed ",[56,180,181],{},"GOTO",[52,183,184],{},"Statement functions.",[52,186,187,188],{},"Data and data sharing\n",[90,189,190,195],{},[52,191,192,194],{},[56,193,69],{}," blocks.",[52,196,197,123],{},[56,198,73],{},[52,200,201,202],{},"Program structure\n",[90,203,204,210],{},[52,205,206,209],{},[56,207,208],{},"ENTRY"," statement for multiple entry points.",[52,211,212,215],{},[56,213,214],{},"     BLOCK DATA    "," program units.",[52,217,218,219],{},"Looping and branching\n",[90,220,221,230],{},[52,222,223,224,226,227,63],{},"Labeled ",[56,225,97],{}," loops (using numeric labels instead of structured ",[56,228,229],{},"     END DO    ",[52,231,232,235],{},[56,233,234],{},"FORALL"," construct and statement.",[52,237,238,239],{},"Legacy syntax and definitions\n",[90,240,241,251,257,260,263],{},[52,242,243,244,247,248,63],{},"Specific names for intrinsic procedures that duplicate generic functionality (e.g., ",[56,245,246],{},"DSIN"," vs ",[56,249,250],{},"SIN",[52,252,253,256],{},[56,254,255],{},"DATA"," statements interspersed within executable code (considered obsolescent; use initialization in declarations instead).",[52,258,259],{},"Assumed-length character functions (deprecated approach; prefer explicit length or modern procedures).",[52,261,262],{},"Fixed source form (classic column-based formatting).",[52,264,265,266,269],{},"The ",[56,267,268],{},"CHARACTER*length"," declaration syntax.",[271,272,274],"h2",{"id":273},"noncompliant-code-example","Noncompliant Code Example",[42,276,277,278,280],{},"The arithmetic ",[56,279,77],{}," statement branches to one of three labels depending on whether an expression is negative, zero, or positive. This construct, common in early Fortran, obscures the control flow and makes the code difficult to read and maintain",[282,283,285],"code-block",{"quality":284},"bad",[286,287,292],"pre",{"className":288,"code":289,"language":290,"meta":291,"style":291},"language-java shiki shiki-themes github-light-high-contrast github-dark-high-contrast monokai","program arithmetic_if\n  implicit none\n  integer :: i, x(10)\n    \n  i = 1\n  ! Noncompliant: Labeled loop with Arithmetic IF\n10 continue\n  x(i) = i * 10\n  i = i + 1\n  if (i - 11) 10, 20, 30\n\n20 continue\n  print *, \"Final X:\", x\n  stop\n\n30 continue\n  print *, \"Error: out of bounds\"\nend program arithmetic_if\n","java","",[56,293,294,303,309,336,342,354,379,387,407,421,452,458,465,482,488,493,501,513],{"__ignoreMap":291},[295,296,299],"span",{"class":297,"line":298},"line",1,[295,300,302],{"class":301},"sgGSh","program arithmetic_if\n",[295,304,306],{"class":297,"line":305},2,[295,307,308],{"class":301},"  implicit none\n",[295,310,312,315,319,322,326,329,333],{"class":297,"line":311},3,[295,313,314],{"class":301},"  integer ",[295,316,318],{"class":317},"sDW38","::",[295,320,321],{"class":301}," i, ",[295,323,325],{"class":324},"sx5EZ","x",[295,327,328],{"class":301},"(",[295,330,332],{"class":331},"sFRm2","10",[295,334,335],{"class":301},")\n",[295,337,339],{"class":297,"line":338},4,[295,340,341],{"class":301},"    \n",[295,343,345,348,351],{"class":297,"line":344},5,[295,346,347],{"class":301},"  i ",[295,349,350],{"class":317},"=",[295,352,353],{"class":331}," 1\n",[295,355,357,360,363,366,370,373,376],{"class":297,"line":356},6,[295,358,359],{"class":317},"  !",[295,361,362],{"class":301}," Noncompliant",[295,364,365],{"class":317},":",[295,367,369],{"class":368},"shSoG"," Labeled",[295,371,372],{"class":301}," loop with ",[295,374,375],{"class":368},"Arithmetic",[295,377,378],{"class":368}," IF\n",[295,380,382,384],{"class":297,"line":381},7,[295,383,332],{"class":331},[295,385,386],{"class":317}," continue\n",[295,388,390,393,396,398,401,404],{"class":297,"line":389},8,[295,391,392],{"class":324},"  x",[295,394,395],{"class":301},"(i) ",[295,397,350],{"class":317},[295,399,400],{"class":301}," i ",[295,402,403],{"class":317},"*",[295,405,406],{"class":331}," 10\n",[295,408,410,412,414,416,419],{"class":297,"line":409},9,[295,411,347],{"class":301},[295,413,350],{"class":317},[295,415,400],{"class":301},[295,417,418],{"class":317},"+",[295,420,353],{"class":331},[295,422,424,427,430,433,436,439,441,444,447,449],{"class":297,"line":423},10,[295,425,426],{"class":317},"  if",[295,428,429],{"class":301}," (i ",[295,431,432],{"class":317},"-",[295,434,435],{"class":331}," 11",[295,437,438],{"class":301},") ",[295,440,332],{"class":331},[295,442,443],{"class":301},", ",[295,445,446],{"class":331},"20",[295,448,443],{"class":301},[295,450,451],{"class":331},"30\n",[295,453,455],{"class":297,"line":454},11,[295,456,457],{"emptyLinePlaceholder":7},"\n",[295,459,461,463],{"class":297,"line":460},12,[295,462,446],{"class":331},[295,464,386],{"class":317},[295,466,468,471,473,475,479],{"class":297,"line":467},13,[295,469,470],{"class":301},"  print ",[295,472,403],{"class":317},[295,474,443],{"class":301},[295,476,478],{"class":477},"sQ5S0","\"Final X:\"",[295,480,481],{"class":301},", x\n",[295,483,485],{"class":297,"line":484},14,[295,486,487],{"class":301},"  stop\n",[295,489,491],{"class":297,"line":490},15,[295,492,457],{"emptyLinePlaceholder":7},[295,494,496,499],{"class":297,"line":495},16,[295,497,498],{"class":331},"30",[295,500,386],{"class":317},[295,502,504,506,508,510],{"class":297,"line":503},17,[295,505,470],{"class":301},[295,507,403],{"class":317},[295,509,443],{"class":301},[295,511,512],{"class":477},"\"Error: out of bounds\"\n",[295,514,516],{"class":297,"line":515},18,[295,517,518],{"class":301},"end program arithmetic_if\n",[271,520,522],{"id":521},"compliant-solution","Compliant Solution",[42,524,525,526,528],{},"This compliant solution demonstrates a bounded ",[56,527,97],{}," loop accessing an array strictly within its declared limits. The loop iteration space matches the array bounds, ensuring no out-of-range subscripting occurs and preserving defined program behavior.",[282,530,532],{"quality":531},"good",[286,533,535],{"className":288,"code":534,"language":290,"meta":291,"style":291},"program compliant_arithmetic_if\n  implicit none\n  integer :: i, x(10)\n\n  ! Compliant: Modern DO loop with block IF logic implicit in bounds\n  do i = 1, 10\n    x(i) = i * 10\n  end do\n\n  print *, \"Final X:\", x\nend program compliant_arithmetic_if\n",[56,536,537,542,546,562,566,589,606,621,629,633,645],{"__ignoreMap":291},[295,538,539],{"class":297,"line":298},[295,540,541],{"class":301},"program compliant_arithmetic_if\n",[295,543,544],{"class":297,"line":305},[295,545,308],{"class":301},[295,547,548,550,552,554,556,558,560],{"class":297,"line":311},[295,549,314],{"class":301},[295,551,318],{"class":317},[295,553,321],{"class":301},[295,555,325],{"class":324},[295,557,328],{"class":301},[295,559,332],{"class":331},[295,561,335],{"class":301},[295,563,564],{"class":297,"line":338},[295,565,457],{"emptyLinePlaceholder":7},[295,567,568,570,573,575,578,581,584,586],{"class":297,"line":344},[295,569,359],{"class":317},[295,571,572],{"class":301}," Compliant",[295,574,365],{"class":317},[295,576,577],{"class":368}," Modern",[295,579,580],{"class":368}," DO",[295,582,583],{"class":301}," loop with block ",[295,585,77],{"class":368},[295,587,588],{"class":301}," logic implicit in bounds\n",[295,590,591,594,596,598,601,603],{"class":297,"line":356},[295,592,593],{"class":317},"  do",[295,595,400],{"class":301},[295,597,350],{"class":317},[295,599,600],{"class":331}," 1",[295,602,443],{"class":301},[295,604,605],{"class":331},"10\n",[295,607,608,611,613,615,617,619],{"class":297,"line":381},[295,609,610],{"class":324},"    x",[295,612,395],{"class":301},[295,614,350],{"class":317},[295,616,400],{"class":301},[295,618,403],{"class":317},[295,620,406],{"class":331},[295,622,623,626],{"class":297,"line":389},[295,624,625],{"class":301},"  end ",[295,627,628],{"class":317},"do\n",[295,630,631],{"class":297,"line":409},[295,632,457],{"emptyLinePlaceholder":7},[295,634,635,637,639,641,643],{"class":297,"line":423},[295,636,470],{"class":301},[295,638,403],{"class":317},[295,640,443],{"class":301},[295,642,478],{"class":477},[295,644,481],{"class":301},[295,646,647],{"class":297,"line":454},[295,648,649],{"class":301},"end program compliant_arithmetic_if\n",[271,651,274],{"id":652},"noncompliant-code-example-1",[42,654,655],{},"Alternate returns allow a subroutine to control the execution flow of the calling program by branching to labels passed as arguments. This is an obsolete feature that results in unstructured control flow.",[282,657,658],{"quality":284},[286,659,661],{"className":288,"code":660,"language":290,"meta":291,"style":291},"subroutine check_status(val, *, *)\n  integer, intent(in) :: val\n  if (val \u003C 0) return 1\n  if (val == 0) return 2\nend subroutine check_status\n\nprogram alternate_return\n    integer :: v = -1\n    ! Noncompliant: Passing labels (*10, *20) as arguments\n    call check_status(v, *10, *20)\n    print *, \"Positive\"\n    goto 30\n10  print * , \"Negative\"\n    goto 30\n20  print *, \"Zero\"\n30  continue\nend program alternate_return\n",[56,662,663,682,698,718,736,741,745,750,768,799,821,833,841,854,860,873,880],{"__ignoreMap":291},[295,664,665,668,671,674,676,678,680],{"class":297,"line":298},[295,666,667],{"class":301},"subroutine ",[295,669,670],{"class":324},"check_status",[295,672,673],{"class":301},"(val, ",[295,675,403],{"class":317},[295,677,443],{"class":301},[295,679,403],{"class":317},[295,681,335],{"class":301},[295,683,684,687,690,693,695],{"class":297,"line":305},[295,685,686],{"class":301},"  integer, ",[295,688,689],{"class":324},"intent",[295,691,692],{"class":301},"(in) ",[295,694,318],{"class":317},[295,696,697],{"class":301}," val\n",[295,699,700,702,705,708,711,713,716],{"class":297,"line":311},[295,701,426],{"class":317},[295,703,704],{"class":301}," (val ",[295,706,707],{"class":317},"\u003C",[295,709,710],{"class":331}," 0",[295,712,438],{"class":301},[295,714,715],{"class":317},"return",[295,717,353],{"class":331},[295,719,720,722,724,727,729,731,733],{"class":297,"line":338},[295,721,426],{"class":317},[295,723,704],{"class":301},[295,725,726],{"class":317},"==",[295,728,710],{"class":331},[295,730,438],{"class":301},[295,732,715],{"class":317},[295,734,735],{"class":331}," 2\n",[295,737,738],{"class":297,"line":344},[295,739,740],{"class":301},"end subroutine check_status\n",[295,742,743],{"class":297,"line":356},[295,744,457],{"emptyLinePlaceholder":7},[295,746,747],{"class":297,"line":381},[295,748,749],{"class":301},"program alternate_return\n",[295,751,752,755,757,760,762,765],{"class":297,"line":389},[295,753,754],{"class":301},"    integer ",[295,756,318],{"class":317},[295,758,759],{"class":301}," v ",[295,761,350],{"class":317},[295,763,764],{"class":317}," -",[295,766,767],{"class":331},"1\n",[295,769,770,773,775,777,780,783,786,788,790,792,794,796],{"class":297,"line":409},[295,771,772],{"class":317},"    !",[295,774,362],{"class":301},[295,776,365],{"class":317},[295,778,779],{"class":368}," Passing",[295,781,782],{"class":324}," labels",[295,784,785],{"class":301}," (",[295,787,403],{"class":317},[295,789,332],{"class":331},[295,791,443],{"class":301},[295,793,403],{"class":317},[295,795,446],{"class":331},[295,797,798],{"class":301},") as arguments\n",[295,800,801,804,806,809,811,813,815,817,819],{"class":297,"line":423},[295,802,803],{"class":301},"    call ",[295,805,670],{"class":324},[295,807,808],{"class":301},"(v, ",[295,810,403],{"class":317},[295,812,332],{"class":331},[295,814,443],{"class":301},[295,816,403],{"class":317},[295,818,446],{"class":331},[295,820,335],{"class":301},[295,822,823,826,828,830],{"class":297,"line":454},[295,824,825],{"class":301},"    print ",[295,827,403],{"class":317},[295,829,443],{"class":301},[295,831,832],{"class":477},"\"Positive\"\n",[295,834,835,838],{"class":297,"line":460},[295,836,837],{"class":317},"    goto",[295,839,840],{"class":331}," 30\n",[295,842,843,845,847,849,851],{"class":297,"line":467},[295,844,332],{"class":331},[295,846,470],{"class":301},[295,848,403],{"class":317},[295,850,59],{"class":301},[295,852,853],{"class":477},"\"Negative\"\n",[295,855,856,858],{"class":297,"line":484},[295,857,837],{"class":317},[295,859,840],{"class":331},[295,861,862,864,866,868,870],{"class":297,"line":490},[295,863,446],{"class":331},[295,865,470],{"class":301},[295,867,403],{"class":317},[295,869,443],{"class":301},[295,871,872],{"class":477},"\"Zero\"\n",[295,874,875,877],{"class":297,"line":495},[295,876,498],{"class":331},[295,878,879],{"class":317},"  continue\n",[295,881,882],{"class":297,"line":503},[295,883,884],{"class":301},"end program alternate_return\n",[271,886,522],{"id":887},"compliant-solution-1",[42,889,890,891,894],{},"The compliant solution returns an integer status code, and the calling program uses a ",[56,892,893],{},"  SELECT CASE "," construct to handle control flow. This decouples the subroutine from the caller's line numbers and keeps the control flow logic within the caller.",[282,896,897],{"quality":531},[286,898,900],{"className":288,"code":899,"language":290,"meta":291,"style":291},"subroutine check_status(val, status)\n  integer, intent(in) :: val\n  integer, intent(out) :: status\n\n  if (val \u003C 0) then\n    status = 1\n  else if (val == 0) then\n    status = 2 \n  else\n    status = 0\n end if\nend subroutine check_status\n\nprogram alternate_return\n  integer :: v = -1, code\n\n  call check_status(v, code)\n\n  ! Compliant: Structured handling of return status\n  select case (code)\n  case (1)\n    print *, \"Negative\"\n  case (2)\n    print *, \"Zero\"\n  case default\n    print *, \"Positive\"\n  end select\nend program alternate_return\n",[56,901,902,911,923,937,941,954,963,979,991,996,1005,1013,1017,1021,1025,1043,1047,1057,1061,1080,1092,1104,1115,1127,1138,1146,1157,1163],{"__ignoreMap":291},[295,903,904,906,908],{"class":297,"line":298},[295,905,667],{"class":301},[295,907,670],{"class":324},[295,909,910],{"class":301},"(val, status)\n",[295,912,913,915,917,919,921],{"class":297,"line":305},[295,914,686],{"class":301},[295,916,689],{"class":324},[295,918,692],{"class":301},[295,920,318],{"class":317},[295,922,697],{"class":301},[295,924,925,927,929,932,934],{"class":297,"line":311},[295,926,686],{"class":301},[295,928,689],{"class":324},[295,930,931],{"class":301},"(out) ",[295,933,318],{"class":317},[295,935,936],{"class":301}," status\n",[295,938,939],{"class":297,"line":338},[295,940,457],{"emptyLinePlaceholder":7},[295,942,943,945,947,949,951],{"class":297,"line":344},[295,944,426],{"class":317},[295,946,704],{"class":301},[295,948,707],{"class":317},[295,950,710],{"class":331},[295,952,953],{"class":301},") then\n",[295,955,956,959,961],{"class":297,"line":356},[295,957,958],{"class":301},"    status ",[295,960,350],{"class":317},[295,962,353],{"class":331},[295,964,965,968,971,973,975,977],{"class":297,"line":381},[295,966,967],{"class":317},"  else",[295,969,970],{"class":317}," if",[295,972,704],{"class":301},[295,974,726],{"class":317},[295,976,710],{"class":331},[295,978,953],{"class":301},[295,980,981,983,985,988],{"class":297,"line":389},[295,982,958],{"class":301},[295,984,350],{"class":317},[295,986,987],{"class":331}," 2",[295,989,990],{"class":301}," \n",[295,992,993],{"class":297,"line":409},[295,994,995],{"class":317},"  else\n",[295,997,998,1000,1002],{"class":297,"line":423},[295,999,958],{"class":301},[295,1001,350],{"class":317},[295,1003,1004],{"class":331}," 0\n",[295,1006,1007,1010],{"class":297,"line":454},[295,1008,1009],{"class":301}," end ",[295,1011,1012],{"class":317},"if\n",[295,1014,1015],{"class":297,"line":460},[295,1016,740],{"class":301},[295,1018,1019],{"class":297,"line":467},[295,1020,457],{"emptyLinePlaceholder":7},[295,1022,1023],{"class":297,"line":484},[295,1024,749],{"class":301},[295,1026,1027,1029,1031,1033,1035,1037,1040],{"class":297,"line":490},[295,1028,314],{"class":301},[295,1030,318],{"class":317},[295,1032,759],{"class":301},[295,1034,350],{"class":317},[295,1036,764],{"class":317},[295,1038,1039],{"class":331},"1",[295,1041,1042],{"class":301},", code\n",[295,1044,1045],{"class":297,"line":495},[295,1046,457],{"emptyLinePlaceholder":7},[295,1048,1049,1052,1054],{"class":297,"line":503},[295,1050,1051],{"class":301},"  call ",[295,1053,670],{"class":324},[295,1055,1056],{"class":301},"(v, code)\n",[295,1058,1059],{"class":297,"line":515},[295,1060,457],{"emptyLinePlaceholder":7},[295,1062,1064,1066,1068,1070,1073,1076,1078],{"class":297,"line":1063},19,[295,1065,359],{"class":317},[295,1067,572],{"class":301},[295,1069,365],{"class":317},[295,1071,1072],{"class":368}," Structured",[295,1074,1075],{"class":301}," handling of ",[295,1077,715],{"class":317},[295,1079,936],{"class":301},[295,1081,1083,1086,1089],{"class":297,"line":1082},20,[295,1084,1085],{"class":301},"  select ",[295,1087,1088],{"class":317},"case",[295,1090,1091],{"class":301}," (code)\n",[295,1093,1095,1098,1100,1102],{"class":297,"line":1094},21,[295,1096,1097],{"class":317},"  case",[295,1099,785],{"class":301},[295,1101,1039],{"class":331},[295,1103,335],{"class":301},[295,1105,1107,1109,1111,1113],{"class":297,"line":1106},22,[295,1108,825],{"class":301},[295,1110,403],{"class":317},[295,1112,443],{"class":301},[295,1114,853],{"class":477},[295,1116,1118,1120,1122,1125],{"class":297,"line":1117},23,[295,1119,1097],{"class":317},[295,1121,785],{"class":301},[295,1123,1124],{"class":331},"2",[295,1126,335],{"class":301},[295,1128,1130,1132,1134,1136],{"class":297,"line":1129},24,[295,1131,825],{"class":301},[295,1133,403],{"class":317},[295,1135,443],{"class":301},[295,1137,872],{"class":477},[295,1139,1141,1143],{"class":297,"line":1140},25,[295,1142,1097],{"class":317},[295,1144,1145],{"class":317}," default\n",[295,1147,1149,1151,1153,1155],{"class":297,"line":1148},26,[295,1150,825],{"class":301},[295,1152,403],{"class":317},[295,1154,443],{"class":301},[295,1156,832],{"class":477},[295,1158,1160],{"class":297,"line":1159},27,[295,1161,1162],{"class":301},"  end select\n",[295,1164,1166],{"class":297,"line":1165},28,[295,1167,884],{"class":301},[271,1169,1171],{"id":1170},"risk-assessment","Risk Assessment",[42,1173,1174,1175,1178,1179,1181,1182,74,1185,1187],{},"Legacy constructs often rely on implicit behaviors (like storage association in ",[56,1176,1177],{},"EQUIVALENTE"," and ",[56,1180,69],{}," ) or unstructured jumps ( ",[56,1183,1184],{},"  GO TO ",[56,1186,77],{}," ). These features prevent modern compilers from performing rigorous type checking, vectorization, and parallelization. They also significantly increase the cognitive load required to maintain the software.",[1189,1190,1191,1210],"table",{},[1192,1193,1194],"thead",{},[1195,1196,1197,1200,1202,1204,1206,1208],"tr",{},[1198,1199],"th",{},[1198,1201],{},[1198,1203],{},[1198,1205],{},[1198,1207],{},[1198,1209],{},[1211,1212,1213,1234],"tbody",{},[1195,1214,1215,1219,1222,1225,1228,1231],{},[1216,1217,1218],"td",{},"Rule",[1216,1220,1221],{},"Severity",[1216,1223,1224],{},"Likelihood",[1216,1226,1227],{},"Remediation Cost",[1216,1229,1230],{},"Priority",[1216,1232,1233],{},"Level",[1195,1235,1236,1239,1242,1245,1247,1253],{},[1216,1237,1238],{},"MSC01-F",[1216,1240,1241],{},"Medium",[1216,1243,1244],{},"likely",[1216,1246,1241],{},[1216,1248,1249],{},[1250,1251,1252],"strong",{},"P12",[1216,1254,1255],{},[1250,1256,1257],{},"L1",[271,1259,1261],{"id":1260},"bibliography","Bibliography",[1189,1263,1264,1272],{},[1192,1265,1266],{},[1195,1267,1268,1270],{},[1198,1269],{},[1198,1271],{},[1211,1273,1274],{},[1195,1275,1276,1287],{},[1216,1277,1278,1279,1286],{},"[ ",[1280,1281,1285],"a",{"href":1282,"rel":1283},"https:\u002F\u002Fwww.intel.com\u002Fcontent\u002Fwww\u002Fus\u002Fen\u002Fdocs\u002Ffortran-compiler\u002Fdeveloper-guide-reference\u002F2025-3\u002Fdeleted-and-obsolescent-language-features.html",[1284],"nofollow","Intel Fortran Compiler"," ]",[1216,1288],{},[1290,1291],"hr",{},[42,1293,1294,1301,1302,1301,1308],{},[1280,1295,1297],{"href":1296},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c",[1298,1299],"img",{"src":1300},"attachments\u002F629047320\u002F638779631.png"," ",[1280,1303,1305],{"href":1304},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002F",[1298,1306],{"src":1307},"attachments\u002F629047320\u002F638779632.png",[1280,1309,1311],{"href":1310},"\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ\u002Ftyp01-f",[1298,1312],{"src":1313},"attachments\u002F629047320\u002F638779633.png",[271,1315,1317],{"id":1316},"attachments","Attachments:",[1319,1320,1324],"div",{"className":1321,"align":1323},[1322],"greybox","left",[42,1325,1326,1301,1329,1332,1333,1336,1301,1338,1332,1341,1343,1301,1345,1332],{},[1298,1327],{"alt":291,"src":1328},"images\u002Ficons\u002Fbullet_blue.gif",[1280,1330,1331],{"href":1300},"button_arrow_left.png"," (image\u002Fpng)",[1334,1335],"br",{},[1298,1337],{"alt":291,"src":1328},[1280,1339,1340],{"href":1307},"button_arrow_up.png",[1334,1342],{},[1298,1344],{"alt":291,"src":1328},[1280,1346,1347],{"href":1313},"button_arrow_right.png",[1349,1350,1351],"style",{},"html pre.shiki code .sgGSh, html code.shiki .sgGSh{--shiki-default:#0E1116;--shiki-dark:#F0F3F6;--shiki-sepia:#F8F8F2}html pre.shiki code .sDW38, html code.shiki .sDW38{--shiki-default:#A0111F;--shiki-dark:#FF9492;--shiki-sepia:#F92672}html pre.shiki code .sx5EZ, html code.shiki .sx5EZ{--shiki-default:#622CBC;--shiki-dark:#DBB7FF;--shiki-sepia:#A6E22E}html pre.shiki code .sFRm2, html code.shiki .sFRm2{--shiki-default:#023B95;--shiki-dark:#91CBFF;--shiki-sepia:#AE81FF}html pre.shiki code .shSoG, html code.shiki .shSoG{--shiki-default:#0E1116;--shiki-default-font-style:inherit;--shiki-dark:#F0F3F6;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .sQ5S0, html code.shiki .sQ5S0{--shiki-default:#032563;--shiki-dark:#ADDCFF;--shiki-sepia:#E6DB74}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":291,"searchDepth":305,"depth":305,"links":1353},[1354,1355,1356,1357,1358,1359,1360,1361,1362],{"id":84,"depth":311,"text":85},{"id":157,"depth":311,"text":158},{"id":273,"depth":305,"text":274},{"id":521,"depth":305,"text":522},{"id":652,"depth":305,"text":274},{"id":887,"depth":305,"text":522},{"id":1170,"depth":305,"text":1171},{"id":1260,"depth":305,"text":1261},{"id":1316,"depth":305,"text":1317},"md",{},"\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc\u002Fmsc01-f",{"title":33,"description":44},"9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F2.msc01-f","VR0mUl9utpw2YwjHhyAue2vIv9uVrkdTRBB3ofsnhdg",[1370,1374],{"title":1371,"path":1372,"stem":1373,"children":-1},"Miscellaneous (MSC)","\u002Fsei-cert-fortran-coding-standard\u002Fmiscellaneous-msc","9.sei-cert-fortran-coding-standard\u002F12.miscellaneous-msc\u002F1.index",{"title":1375,"path":1376,"stem":1377,"children":-1},"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",[1379],{"title":1380,"path":1381,"stem":1382,"children":1383},"Sei Cert Fortran Coding Standard","\u002Fsei-cert-fortran-coding-standard","9.sei-cert-fortran-coding-standard",[1384,1387,1409,1423,1449,1459,1463,1473,1477,1481,1485,1489,1498,1516,1520,1538,1559],{"title":1385,"path":1381,"stem":1386},"SEI CERT Fortran Coding Standard","9.sei-cert-fortran-coding-standard\u002F1.index",{"title":1388,"path":1389,"stem":1390,"children":1391},"Arrays (ARR)","\u002Fsei-cert-fortran-coding-standard\u002Farrays-arr","9.sei-cert-fortran-coding-standard\u002F02.arrays-arr\u002F1.index",[1392,1393,1397,1401,1405],{"title":1388,"path":1389,"stem":1390},{"title":1394,"path":1395,"stem":1396},"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":1398,"path":1399,"stem":1400},"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":1402,"path":1403,"stem":1404},"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":1406,"path":1407,"stem":1408},"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":1410,"path":1411,"stem":1412,"children":1413},"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",[1414,1415,1419],{"title":1410,"path":1411,"stem":1412},{"title":1416,"path":1417,"stem":1418},"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":1420,"path":1421,"stem":1422},"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":1424,"path":1425,"stem":1426,"children":1427},"Concurrency (CON)","\u002Fsei-cert-fortran-coding-standard\u002Fconcurrency-con","9.sei-cert-fortran-coding-standard\u002F04.concurrency-con\u002F1.index",[1428,1429,1433,1437,1441,1445],{"title":1424,"path":1425,"stem":1426},{"title":1430,"path":1431,"stem":1432},"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":1434,"path":1435,"stem":1436},"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":1438,"path":1439,"stem":1440},"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":1442,"path":1443,"stem":1444},"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":1446,"path":1447,"stem":1448},"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":1450,"path":1451,"stem":1452,"children":1453},"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",[1454,1455],{"title":1450,"path":1451,"stem":1452},{"title":1456,"path":1457,"stem":1458},"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":1460,"path":1461,"stem":1462},"Execution Control (EXC)","\u002Fsei-cert-fortran-coding-standard\u002Fexecution-control-exc","9.sei-cert-fortran-coding-standard\u002F06.execution-control-exc",{"title":1464,"path":1465,"stem":1466,"children":1467},"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",[1468,1469],{"title":1464,"path":1465,"stem":1466},{"title":1470,"path":1471,"stem":1472},"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":1474,"path":1475,"stem":1476},"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":1478,"path":1479,"stem":1480},"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":1482,"path":1483,"stem":1484},"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":1486,"path":1487,"stem":1488},"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":1371,"path":1372,"stem":1373,"children":1490},[1491,1492,1493,1494],{"title":1371,"path":1372,"stem":1373},{"title":33,"path":1365,"stem":1367},{"title":1375,"path":1376,"stem":1377},{"title":1495,"path":1496,"stem":1497},"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":1499,"path":1500,"stem":1501,"children":1502},"Procedures (PRC)","\u002Fsei-cert-fortran-coding-standard\u002Fprocedures-prc","9.sei-cert-fortran-coding-standard\u002F13.procedures-prc\u002F1.index",[1503,1504,1508,1512],{"title":1499,"path":1500,"stem":1501},{"title":1505,"path":1506,"stem":1507},"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":1509,"path":1510,"stem":1511},"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":1513,"path":1514,"stem":1515},"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":1517,"path":1518,"stem":1519},"Program Units (PRU)","\u002Fsei-cert-fortran-coding-standard\u002Fprogram-units-pru","9.sei-cert-fortran-coding-standard\u002F14.program-units-pru",{"title":1521,"path":1522,"stem":1523,"children":1524},"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",[1525,1526,1530,1534],{"title":1521,"path":1522,"stem":1523},{"title":1527,"path":1528,"stem":1529},"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":1531,"path":1532,"stem":1533},"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":1535,"path":1536,"stem":1537},"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":1539,"path":1540,"stem":1541,"children":1542},"Types (TYP)","\u002Fsei-cert-fortran-coding-standard\u002Ftypes-typ","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F1.index",[1543,1544,1547,1551,1555],{"title":1539,"path":1540,"stem":1541},{"title":1545,"path":1310,"stem":1546},"TYP01-F. Use Intrinsic Assignment for Character Entities","9.sei-cert-fortran-coding-standard\u002F16.types-typ\u002F2.typ01-f",{"title":1548,"path":1549,"stem":1550},"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":1552,"path":1553,"stem":1554},"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":1556,"path":1557,"stem":1558},"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":1560,"path":1561,"stem":1562},"Acknowledgments","\u002Fsei-cert-fortran-coding-standard\u002Facknowledgements","9.sei-cert-fortran-coding-standard\u002Facknowledgements",1780320168390]