{"id":15295,"date":"2014-04-08T14:13:22","date_gmt":"2014-04-08T14:13:22","guid":{"rendered":"https:\/\/fortran.uk\/?p=15295"},"modified":"2023-12-04T00:19:52","modified_gmt":"2023-12-04T00:19:52","slug":"spag-fortran-code-restructuring","status":"publish","type":"page","link":"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/","title":{"rendered":"SPAG Version 8 &#8211; Re-engineering Fortran Source Code"},"content":{"rendered":"<h2>Re-Structuring Legacy Code &#8211; No more GOTOs!<\/h2>\n<p>SPAG, the <em>plus<\/em><strong>FORT<\/strong> restructuring tool, can unscramble ancient spaghetti Fortran code, and convert it to modern structured Fortran 95.\u00a0 It does this by reorganising code using a number of structured templates:<\/p>\n<ul>\n<li>block IFs<\/li>\n<li>named DO loops with CYCLE and EXIT<\/li>\n<li>replication of individual statements<\/li>\n<li>Internal subprograms (<em><span style=\"color: #ff6600;\">new<\/span> in Version 8<\/em>)<\/li>\n<li>Dispatch loop (<em><span style=\"color: #ff6600;\">new<\/span> in Version 8<\/em>)<\/li>\n<\/ul>\n<p>Version 8, with two new templates, can now eliminate <span style=\"color: #ff6600;\"><em>all<\/em> <span style=\"color: #000000;\">GOTOs from even the most convoluted legacy code.\u00a0 \u00a0<\/span><\/span><\/p>\n<p>SPAG does not change the meaning of a program, or even the order in which statements are executed; it does change the way the program logic is written down, making it much easier to understand and maintain. Blocks of code are reordered so that logically related sections are physically close, and jumps in control flow are minimised. SPAG may also replicate small code fragments where this improves the re-structured code.<\/p>\n<h2>Upgrade Declarations<\/h2>\n<ul>\n<li>SPAG allows you to switch programs to explicit typing by adding declarations for implicitly defined variables, and adding IMPLICIT NONE. Explicit typing allows your compiler to detect errors which might otherwise remain undetected for years.\u00a0 This option leaves existing declarations unchanged (apart from re-formatting)<\/li>\n<li>Alternatively, SPAG can rewrite the entire declaration section from scratch using Fortran 95 syntax. In this mode, SPAG can:\n<ul>\n<li>\u00a0Include new declarations for implicitly typed variables, and add an IMPLICIT NONE statement.<\/li>\n<li>Add INTENT qualifiers to dummy arguments based on how the argument is used.<\/li>\n<li>Convert non-standard REAL*8, INTEGER*1 and similar declarations to standard Fortran using KIND definitions in the standard ISO_FORTRAN_ENV module.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<h2>Modularization<\/h2>\n<p>SPAG can:<\/p>\n<ul>\n<li>Convert INCLUDE files and COMMON blocks to MODULEs, and insert USE statements as required.<\/li>\n<li>Create MODULEs containing explicit interfaces for all subprograms and insert USE statements as required.<\/li>\n<li style=\"text-align: left;\">SPAG generates symbol tables\u00a0 which are used by <a href=\"https:\/\/fortran.uk\/plusfort-quality-assurance\/#gxchk\">GXCHK<\/a> to examine the large scale calling structure and data usage within a program.\u00a0 GXCHK produces reports showing how subprograms and data can be moved into higher level subprograms or MODULEs (see below).<\/li>\n<\/ul>\n<p><img src=\"https:\/\/fortran.uk\/plusfortmanual\/Internalization.png\" alt=\"Internalization Report\" \/><\/p>\n<p><img src=\"https:\/\/fortran.uk\/plusfortmanual\/ClusterAnalysis.png\" alt=\"Cluster Analysis\" \/><\/p>\n<h2>Code Re-formatting<\/h2>\n<p>SPAG contains a powerful code beautifier, with dozens of options controlling spacing, case, labels, indentation, use of CONTINUE etc. You can use SPAG to switch back and forth between the F77 and F95 source forms. But SPAG goes much further:<\/p>\n<ul>\n<li>Convert back and forth between old and new source forms, or write output in a style which is compatible with both.<\/li>\n<li>SPAG identifies, and optionally removes dead code (statements which could never be executed) and clutter (variables or PARAMETERs which are declared but never used).<\/li>\n<li>SPAG provides a simple and safe method for systematically changing the names of symbols within a program.<\/li>\n<li>SPAG allows you to specify how upper and lower case should be used to distinguish different types of symbol. For example, local variables may be lower case, PARAMETERs upper case, dummy arguments capitalised etc. (e.g. local , PARAM , Dummyarg, COMmonvar).<\/li>\n<li>SPAG can convert between old and new style relational operators.<\/li>\n<li>User may insert !-ANCHOR and !-ASIS directives in source code to guide SPAG restructuring and formatting.<\/li>\n<\/ul>\n<p>There are over 100 configuration options which allow you to customise SPAG output to local conventions and requirements. <a name=\"egmenu\"><\/a><\/p>\n<p><a href=\"#top\">Top<\/a><\/p>\n<hr \/>\n<h2>Examples<\/h2>\n<p><a href=\"https:\/\/fortran.uk\/spag-fortran-code-restructuring\/#eg1before\">Example 1 &#8211; Before<\/a><br \/>\n<a href=\"https:\/\/fortran.uk\/spag-fortran-code-restructuring\/#eg1after\">Example 1 &#8211; After<\/a><\/p>\n<p><a href=\"https:\/\/fortran.uk\/spag-fortran-code-restructuring\/#eg2f66\">Example 2 &#8211; Fortran 66<\/a><br \/>\n<a href=\"https:\/\/fortran.uk\/spag-fortran-code-restructuring\/#eg2f77\">Example 2 &#8211; Fortran 77<\/a><\/p>\n<p><a href=\"https:\/\/fortran.uk\/spag-fortran-code-restructuring\/#eg3before\">Example 3 &#8211; Before<\/a><br \/>\n<a href=\"https:\/\/fortran.uk\/spag-fortran-code-restructuring\/#eg3after\">Example 3 &#8211; After<\/a><\/p>\n<p><a name=\"eg1before\"><\/a><a name=\"top\"><\/a>Top<\/p>\n<hr \/>\n<h2>Example 1 &#8211; Original Spaghetti Code<\/h2>\n<pre>      IBON=0\r\n      IF(KON)35,19,35\r\n   19 IF(NSQ-56)24,22,24\r\n   22 IF(LSQ-46)5,28,5\r\n   24 IF(NSQ-55)29,27,29\r\n   27 IF(LSQ-45)5,28,5\r\n   28 IBON=2\r\n      GO TO 5\r\n   29 IF(LSQ-32)30,31,30\r\n   30 IF(LSQ-39)39,31,39\r\n   31 IBON=-5\r\n      GO TO 5\r\n   39 IF(LSQ-35)52,51,52\r\n   52 IF(LSQ-36)5,51,5\r\n   51 IBON=10\r\n      GO TO 5\r\n   35 IF(MARK(NMOVE))36,37,37\r\n   36 IBON=-5\r\n      GO TO 5\r\n   37 IBON=5\r\n    5 end<\/pre>\n<p><a name=\"eg1after\"><\/a><a href=\"#egmenu\">Top<\/a><\/p>\n<p>&nbsp;<\/p>\n<hr \/>\n<h2>Example 1 &#8211; After Processing by SPAG<\/h2>\n<pre>      ibon = 0\r\n      IF ( kon.NE.0 ) THEN\r\n         IF ( mark(nmove).LT.0 ) THEN\r\n            ibon = -5\r\n         ELSE\r\n            ibon = 5\r\n         ENDIF\r\n      ELSEIF ( nsq.NE.56 ) THEN\r\n         IF ( nsq.NE.55 ) THEN\r\n            IF ( lsq.EQ.32 ) THEN\r\n               ibon = -5\r\n            ELSEIF ( lsq.EQ.39 ) THEN\r\n               ibon = -5\r\n            ELSEIF ( lsq.EQ.35 ) THEN\r\n               ibon = 10\r\n            ELSEIF ( lsq.EQ.36 ) THEN\r\n               ibon = 10\r\n            ENDIF\r\n         ELSEIF ( lsq.EQ.45 ) THEN\r\n            ibon = 2\r\n         ENDIF\r\n      ELSEIF ( lsq.EQ.46 ) THEN\r\n         ibon = 2\r\n      ENDIF\r\n      END<\/pre>\n<p><a name=\"eg2f66\"><\/a><a href=\"#egmenu\">Top<\/a><\/p>\n<hr \/>\n<h2>Example 2 &#8211; Original Fortran 66.<\/h2>\n<p>This subroutine picks off digits from an integer and branches depending on their value.<\/p>\n<pre>      SUBROUTINE OBACT(TODO)\r\n      INTEGER TODO,DONE,IP,BASE\r\n      COMMON \/EG1\/N,L,DONE\r\n      PARAMETER (BASE=10)\r\n   13 IF(TODO.EQ.0) GO TO 12\r\n      I=MOD(TODO,BASE)\r\n      TODO=TODO\/BASE\r\n      GO TO(62,42,43,62,404,45,62,62,62),I\r\n      GO TO 13\r\n   42 CALL COPY\r\n      GO TO 127\r\n   43 CALL MOVE\r\n      GO TO 144\r\n  404 N=-N\r\n   44 CALL DELETE\r\n      GO TO 127\r\n   45 CALL PRINT\r\n      GO TO 144\r\n   62 CALL BADACT(I)\r\n      GO TO 12\r\n  127 L=L+N\r\n  144 DONE=DONE+1\r\n      CALL RESYNC\r\n      GO TO 13\r\n   12 RETURN\r\n      END<\/pre>\n<p><a name=\"eg2f77\"><\/a><a href=\"https:\/\/fortran.uk\/spag-fortran-code-restructuring\/#egmenu\">Top<\/a><\/p>\n<hr \/>\n<h2>Example 2 &#8211; Fortran 77 Version.<\/h2>\n<p>In addition to restructuring, SPAG has renamed some variables, removed the unused variable IP, inserted declarations, and used upper and lower case to destinguish different types of variable.<\/p>\n<pre>      SUBROUTINE OBACT(Todo)\r\n      IMPLICIT NONE\r\nC*** Start of declarations inserted by SPAG\r\n      INTEGER act , LENgth , NCHar\r\nC*** End of declarations inserted by SPAG\r\n      INTEGER Todo , DONe , BASE\r\n      COMMON \/EG1   \/ NCHar , LENgth , DONe\r\n      PARAMETER (BASE=10)\r\n 100  IF ( Todo.NE.0 ) THEN\r\n         act = MOD(Todo,BASE)\r\n         Todo = Todo\/BASE\r\n         IF ( act.EQ.1 .OR. act.EQ.4 .OR.\r\n     &amp;        act.EQ.7 .OR. act.EQ.8 .OR.\r\n     &amp;        act.EQ.9 ) THEN\r\n            CALL BADACT(act)\r\n            GOTO 200\r\n         ELSEIF ( act.EQ.2 ) THEN\r\n            CALL COPY\r\n            LENgth = LENgth + NCHar\r\n         ELSEIF ( act.EQ.3 ) THEN\r\n            CALL MOVE\r\n         ELSEIF ( act.EQ.5 ) THEN\r\n            NCHar = -NCHar\r\n            CALL DELETE\r\n            LENgth = LENgth + NCHar\r\n         ELSEIF ( act.EQ.6 ) THEN\r\n            CALL PRINT\r\n         ELSE\r\n            GOTO 100\r\n         ENDIF\r\n         DONe = DONe + 1\r\n         CALL RESYNC\r\n         GOTO 100\r\n      ENDIF\r\n 200  RETURN\r\n      END\r\n<\/pre>\n<p><a name=\"eg2f90\"><\/a><a href=\"#egmenu\">Top<\/a><\/p>\n<hr \/>\n<h2>Example 2 &#8211; Fortran 95.<\/h2>\n<p>SPAG has used DO WHILE, SELECT CASE, EXIT and CYCLE. No GOTOs or labels remain. The COMMON block has been replaced by a MODULE, and all declarations rewritten using Fortran 95 syntax.<\/p>\n<pre>      SUBROUTINE OBACT(Todo)\r\n      USE C_EG1\r\n      IMPLICIT NONE\r\n!\r\n!*** Start of declarations rewritten by SPAG\r\n!\r\n! PARAMETER definitions\r\n!\r\n      INTEGER , PARAMETER :: BASE = 10\r\n!\r\n! Dummy arguments\r\n!\r\n      INTEGER,INTENT(INOUT) :: Todo\r\n!\r\n! Local variables\r\n!\r\n      INTEGER :: act\r\n!\r\n!*** End of declarations rewritten by SPAG\r\n!\r\n      DO WHILE ( Todo\/=0 )\r\n         act = MOD(Todo,BASE)\r\n         Todo = Todo\/BASE\r\n         SELECT CASE (act)\r\n         CASE (1,4,7,8,9)\r\n            CALL BADACT(act)\r\n            EXIT\r\n         CASE (2)\r\n            CALL COPY\r\n            LENgth = LENgth + NCHar\r\n         CASE (3)\r\n            CALL MOVE\r\n         CASE (5)\r\n            NCHar = -NCHar\r\n            CALL DELETE\r\n            LENgth = LENgth + NCHar\r\n         CASE (6)\r\n            CALL PRINT\r\n         CASE DEFAULT\r\n            CYCLE\r\n         END SELECT\r\n         DONe = DONe + 1\r\n         CALL RESYNC\r\n      ENDDO\r\n      END SUBROUTINE OBACT<\/pre>\n<p>&nbsp;<\/p>\n<h2>Example 3 &#8211; Dispatch Loops and Internal SUBROUTINES<\/h2>\n<p><a name=\"eg3before\"><\/a><a href=\"#egmenu\">Top<\/a><\/p>\n<p>&nbsp;<\/p>\n<table border=\"1\" cellspacing=\"1\" cellpadding=\"4\">\n<tbody>\n<tr valign=\"top\">\n<th>Before Restructuring<\/th>\n<\/tr>\n<tr valign=\"top\">\n<td>\n<pre>      FUNCTION IUNITS(JDIF,KDIF,JU,KU,IP)\r\n      INTEGER IP,IUNITS,JDIF,JU,KDIF,KU\r\n      IUNITS=1\r\n      IF(JDIF)20,30,40\r\n20    JU=-1\r\n      IF(KDIF)50,60,70\r\n30    JU=0\r\n      KU=KDIF\/IABS(KDIF)\r\n      IP=4\r\n      RETURN\r\n40    JU=1\r\n      IF(KDIF)70,60,50\r\n50    IF(JDIF-KDIF)100,51,100\r\n51    KU=JU\r\n      IP=3\r\n      RETURN\r\n60    KU=0\r\n      IP=4\r\n      RETURN\r\n70    IF(JDIF+KDIF)100,71,100\r\n71     KU=-JU\r\n      IP=3\r\n      RETURN\r\n100   IUNITS=0\r\n      RETURN\r\n    END<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><a name=\"eg3after\"><\/a><a href=\"#egmenu\">Top<\/a><\/p>\n<p>&nbsp;<\/p>\n<table border=\"1\" cellspacing=\"1\" cellpadding=\"4\">\n<tbody>\n<tr valign=\"top\">\n<th>spag iunits.for 31=1 (Dispatch Loops)<\/th>\n<th>spag iunits.for 31=2 (Internal Subroutines)<\/th>\n<\/tr>\n<tr valign=\"top\">\n<td>\n<pre>   FUNCTION iunits(Jdif,Kdif,Ju,Ku,Ip)\r\n      IMPLICIT NONE\r\n      INTEGER Ip , iunits , Jdif , Ju , Kdif , Ku\r\n      INTEGER :: spag_nextblock_1\r\n      spag_nextblock_1 = 1\r\n      SPAG_DispatchLoop_1: DO\r\n         SELECT CASE (spag_nextblock_1)\r\n         CASE (1)\r\n            iunits = 1\r\n            IF ( Jdif&lt;0 ) THEN\r\n               Ju = -1\r\n               IF ( Kdif&lt;0 ) THEN\r\n               ELSEIF ( Kdif==0 ) THEN\r\n                  spag_nextblock_1 = 2\r\n                  CYCLE SPAG_DispatchLoop_1\r\n               ELSE\r\n                  spag_nextblock_1 = 3\r\n                  CYCLE SPAG_DispatchLoop_1\r\n               ENDIF\r\n            ELSEIF ( Jdif==0 ) THEN\r\n               Ju = 0\r\n               Ku = Kdif\/iabs(Kdif)\r\n               Ip = 4\r\n               RETURN\r\n            ELSE\r\n               Ju = 1\r\n               IF ( Kdif&lt;0 ) THEN\r\n                  spag_nextblock_1 = 3\r\n                  CYCLE SPAG_DispatchLoop_1\r\n               ENDIF\r\n               IF ( Kdif==0 ) THEN\r\n                  spag_nextblock_1 = 2\r\n                  CYCLE SPAG_DispatchLoop_1\r\n               ENDIF\r\n            ENDIF\r\n            IF ( Jdif\/=Kdif ) THEN\r\n               iunits = 0\r\n               RETURN\r\n            ELSE\r\n               Ku = Ju\r\n               Ip = 3\r\n               RETURN\r\n            ENDIF\r\n         CASE (2)\r\n            Ku = 0\r\n            Ip = 4\r\n            RETURN\r\n         CASE (3)\r\n            IF ( Jdif+Kdif\/=0 ) THEN\r\n               iunits = 0\r\n            ELSE\r\n               Ku = -Ju\r\n               Ip = 3\r\n               RETURN\r\n            ENDIF\r\n            EXIT SPAG_DispatchLoop_1\r\n         END SELECT\r\n      ENDDO SPAG_DispatchLoop_1\r\n   END FUNCTION iunits\r\n<\/pre>\n<\/td>\n<td>\n<pre>   FUNCTION iunits(Jdif,Kdif,Ju,Ku,Ip)\r\n      IMPLICIT NONE\r\n      INTEGER Ip , iunits , Jdif , Ju , Kdif , Ku\r\n      iunits = 1\r\n      IF ( Jdif&lt;0 ) THEN\r\n         Ju = -1\r\n         IF ( Kdif&lt;0 ) THEN\r\n         ELSEIF ( Kdif==0 ) THEN\r\n            CALL spag_block_1\r\n            RETURN\r\n         ELSE\r\n            CALL spag_block_2\r\n            RETURN\r\n         ENDIF\r\n      ELSEIF ( Jdif==0 ) THEN\r\n         Ju = 0\r\n         Ku = Kdif\/iabs(Kdif)\r\n         Ip = 4\r\n         RETURN\r\n      ELSE\r\n         Ju = 1\r\n         IF ( Kdif&lt;0 ) THEN\r\n            CALL spag_block_2\r\n            RETURN\r\n         ENDIF\r\n         IF ( Kdif==0 ) THEN\r\n            CALL spag_block_1\r\n            RETURN\r\n         ENDIF\r\n      ENDIF\r\n      IF ( Jdif\/=Kdif ) THEN\r\n         iunits = 0\r\n         RETURN\r\n      ELSE\r\n         Ku = Ju\r\n         Ip = 3\r\n         RETURN\r\n      ENDIF\r\n   CONTAINS\r\n      SUBROUTINE spag_block_1\r\n         Ku = 0\r\n         Ip = 4\r\n         RETURN\r\n      END SUBROUTINE spag_block_1\r\n      SUBROUTINE spag_block_2\r\n         IF ( Jdif+Kdif\/=0 ) THEN\r\n            iunits = 0\r\n         ELSE\r\n            Ku = -Ju\r\n            Ip = 3\r\n            RETURN\r\n         ENDIF\r\n      END SUBROUTINE spag_block_2\r\n   END FUNCTION iunits<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><a href=\"#top\">Top<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Re-Structuring Legacy Code &#8211; No more GOTOs! SPAG, the plusFORT restructuring tool, can unscramble ancient spaghetti Fortran code, and convert it to modern structured Fortran 95.\u00a0 It does this by reorganising code using a number of structured templates: block IFs named DO loops with CYCLE and EXIT replication of individual statements Internal subprograms (new in [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":17477,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v20.6 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>SPAG Version 8 - Re-engineering Fortran Source Code - Fortran UK<\/title>\n<meta name=\"description\" content=\"SPAG, the plusFORT restructuring tool, can unscramble spaghetti Fortran 66 or Fortran 77 code, and convert it to modern structured Fortran 95.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/\" \/>\n<meta property=\"og:locale\" content=\"en_GB\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"SPAG Version 8 - Re-engineering Fortran Source Code - Fortran UK\" \/>\n<meta property=\"og:description\" content=\"SPAG, the plusFORT restructuring tool, can unscramble spaghetti Fortran 66 or Fortran 77 code, and convert it to modern structured Fortran 95.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/\" \/>\n<meta property=\"og:site_name\" content=\"Fortran UK\" \/>\n<meta property=\"article:modified_time\" content=\"2023-12-04T00:19:52+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fortran.uk\/plusfortmanual\/Internalization.png\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Estimated reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/\",\"url\":\"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/\",\"name\":\"SPAG Version 8 - Re-engineering Fortran Source Code - Fortran UK\",\"isPartOf\":{\"@id\":\"https:\/\/fortran.uk\/#website\"},\"datePublished\":\"2014-04-08T14:13:22+00:00\",\"dateModified\":\"2023-12-04T00:19:52+00:00\",\"description\":\"SPAG, the plusFORT restructuring tool, can unscramble spaghetti Fortran 66 or Fortran 77 code, and convert it to modern structured Fortran 95.\",\"breadcrumb\":{\"@id\":\"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/#breadcrumb\"},\"inLanguage\":\"en-GB\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/fortran.uk\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Fortran Analysis &#038; Refactoring with plusFORT V8\",\"item\":\"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"SPAG Version 8 &#8211; Re-engineering Fortran Source Code\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/fortran.uk\/#website\",\"url\":\"https:\/\/fortran.uk\/\",\"name\":\"Fortran UK\",\"description\":\"All things Fortran\",\"publisher\":{\"@id\":\"https:\/\/fortran.uk\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/fortran.uk\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-GB\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/fortran.uk\/#organization\",\"name\":\"Polyhedron Solutions Ltd.\",\"url\":\"https:\/\/fortran.uk\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/fortran.uk\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/fortran.uk\/wp-content\/uploads\/2018\/03\/Web-logoPolySol.png\",\"contentUrl\":\"https:\/\/fortran.uk\/wp-content\/uploads\/2018\/03\/Web-logoPolySol.png\",\"width\":203,\"height\":113,\"caption\":\"Polyhedron Solutions Ltd.\"},\"image\":{\"@id\":\"https:\/\/fortran.uk\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.youtube.com\/@polyhedronsolutions1405\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"SPAG Version 8 - Re-engineering Fortran Source Code - Fortran UK","description":"SPAG, the plusFORT restructuring tool, can unscramble spaghetti Fortran 66 or Fortran 77 code, and convert it to modern structured Fortran 95.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/","og_locale":"en_GB","og_type":"article","og_title":"SPAG Version 8 - Re-engineering Fortran Source Code - Fortran UK","og_description":"SPAG, the plusFORT restructuring tool, can unscramble spaghetti Fortran 66 or Fortran 77 code, and convert it to modern structured Fortran 95.","og_url":"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/","og_site_name":"Fortran UK","article_modified_time":"2023-12-04T00:19:52+00:00","og_image":[{"url":"https:\/\/fortran.uk\/plusfortmanual\/Internalization.png"}],"twitter_card":"summary_large_image","twitter_misc":{"Estimated reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/","url":"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/","name":"SPAG Version 8 - Re-engineering Fortran Source Code - Fortran UK","isPartOf":{"@id":"https:\/\/fortran.uk\/#website"},"datePublished":"2014-04-08T14:13:22+00:00","dateModified":"2023-12-04T00:19:52+00:00","description":"SPAG, the plusFORT restructuring tool, can unscramble spaghetti Fortran 66 or Fortran 77 code, and convert it to modern structured Fortran 95.","breadcrumb":{"@id":"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/#breadcrumb"},"inLanguage":"en-GB","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/spag-fortran-code-restructuring\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fortran.uk\/"},{"@type":"ListItem","position":2,"name":"Fortran Analysis &#038; Refactoring with plusFORT V8","item":"https:\/\/fortran.uk\/fortran-analysis-and-refactoring-with-plusfort\/"},{"@type":"ListItem","position":3,"name":"SPAG Version 8 &#8211; Re-engineering Fortran Source Code"}]},{"@type":"WebSite","@id":"https:\/\/fortran.uk\/#website","url":"https:\/\/fortran.uk\/","name":"Fortran UK","description":"All things Fortran","publisher":{"@id":"https:\/\/fortran.uk\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/fortran.uk\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-GB"},{"@type":"Organization","@id":"https:\/\/fortran.uk\/#organization","name":"Polyhedron Solutions Ltd.","url":"https:\/\/fortran.uk\/","logo":{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/fortran.uk\/#\/schema\/logo\/image\/","url":"https:\/\/fortran.uk\/wp-content\/uploads\/2018\/03\/Web-logoPolySol.png","contentUrl":"https:\/\/fortran.uk\/wp-content\/uploads\/2018\/03\/Web-logoPolySol.png","width":203,"height":113,"caption":"Polyhedron Solutions Ltd."},"image":{"@id":"https:\/\/fortran.uk\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.youtube.com\/@polyhedronsolutions1405"]}]}},"_links":{"self":[{"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages\/15295"}],"collection":[{"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/comments?post=15295"}],"version-history":[{"count":13,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages\/15295\/revisions"}],"predecessor-version":[{"id":20114,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages\/15295\/revisions\/20114"}],"up":[{"embeddable":true,"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/pages\/17477"}],"wp:attachment":[{"href":"https:\/\/fortran.uk\/wp-json\/wp\/v2\/media?parent=15295"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}