Merge pull request #14 from dbroemmel/master

some minor changes

Author: pseewald

fortran_tests/after/another_example.f90

@@ -0,0 +1,57 @@
+module a_mod
+   integer :: a_variable, another_variable
+
+   private :: a_variable, &
+              another_variable
+contains
+
+   subroutine test_type(bohoo)
+      class(*), intent(in) :: bohoo
+
+      select type (bohoo)
+      type is (real)
+         write (*, *) 'T'
+      type is (integer)
+         write (*, *) 'F'
+      class default
+      end select
+
+      return
+
+   end subroutine test_type
+
+end module a_mod
+
+program test
+   use a_mod
+
+   integer :: block_test = 2, block = 2
+   real :: res, factor = 2.81
+
+   namelist /test_nml/ block, block_test, res, factor
+
+   block = 5
+
+   block
+      real :: another_real
+      another_real = 4.5
+   end block
+
+   call test_type(block)
+
+   block ! have more vars
+      real :: block
+      call test_type(block)
+   end block
+
+   block = block*5/block_test + 1
+   ! whitespace 2
+!  res = factor*5/block_test + 1
+   res = factor*5/block_test + 1
+   ! whitespace 3
+!  res = factor * 5 / block_test + 1
+   res = factor*5/block_test + 1
+
+   stop
+
+end program test

fortran_tests/before/another_example.f90

@@ -0,0 +1,57 @@
+module a_mod
+integer :: a_variable, another_variable
+
+  private :: a_variable, &
+                   another_variable
+   contains
+
+   subroutine test_type(bohoo)
+   class(*), intent(in) :: bohoo
+
+     select type(bohoo)
+     type is(real)
+     write(*,*) 'T'
+    type is(integer)
+       write(*,*) 'F'
+    class default
+   end select
+
+    return
+
+      end subroutine test_type
+
+   end module a_mod
+
+program test
+   use a_mod
+
+      integer :: block_test=2, block =    2
+   real :: res, factor    = 2.81
+
+namelist/test_nml/block, block_test, res, factor
+
+      block = 5
+
+         block
+            real :: another_real
+            another_real = 4.5
+            end block
+
+   call test_type(block)
+
+            block ! have more vars
+       real :: block
+          call test_type(block)
+                              end block
+
+                              block = block*5/block_test+1
+     ! whitespace 2
+!  res = factor*5/block_test + 1
+   res = factor*5/block_test + 1
+    ! whitespace 3
+!  res = factor * 5 / block_test + 1
+      res = factor * 5 / block_test + 1
+
+         stop
+
+      end program test

fortran_tests/test_results/expected_results

@@ -1917,15 +1917,15 @@ RosettaCodeData/Task/Accumulator-factory/Fortran/accumulator-factory-2.f : 06ff1
 RosettaCodeData/Task/Arithmetic-Rational/Fortran/arithmetic-rational-1.f : d9798ac7d48984a81e6066f955431b6b1147c4a23676e2ce9161d6491a36c234
 RosettaCodeData/Task/Classes/Fortran/classes.f : ab23f3823fb82e0ffff96b869f2aca7c2515db18add95104f4be86c881692d74
 RosettaCodeData/Task/Constrained-genericity/Fortran/constrained-genericity.f : a2ddcb9eefef24be8475b19015a323a09a5245b7a0325faab6f14cd5d8c99232
-RosettaCodeData/Task/Define-a-primitive-data-type/Fortran/define-a-primitive-data-type-1.f : a61ce7b5d3641ca7f223a03229a31cc8feb6d8aa473d827df5bf0a85baea6af7
+RosettaCodeData/Task/Define-a-primitive-data-type/Fortran/define-a-primitive-data-type-1.f : 615b5f17286283068720f211d282558d186b9a7af06076739fea0a4e90898f18
 RosettaCodeData/Task/Exponentiation-operator/Fortran/exponentiation-operator.f : 9dd247f51e19e4c445522b7577368fe009003524bec66ed3f2efbfb58d8e8fed
 RosettaCodeData/Task/Fibonacci-sequence/Fortran/fibonacci-sequence-4.f : 758c9f5caeed8b02a4b54ec8c207c8bc70f2a92065455c76978b487d1fa8566d
 RosettaCodeData/Task/Grayscale-image/Fortran/grayscale-image-3.f : ed4d53de1d0437d3fbc830ac7b75a48dd373f181183cbb35dc0c1fa2b23569cd
 RosettaCodeData/Task/LU-decomposition/Fortran/lu-decomposition.f : 900a20c9ca96f7b3e019496fcda8396138061c6c28e796174eb08d7f86d9c80e
 RosettaCodeData/Task/Long-multiplication/Fortran/long-multiplication-1.f : acbc61418d79d708837c1dd7780007bca8de3390e5474c5c3de7c4e6abf04f2e
 RosettaCodeData/Task/Matrix-exponentiation-operator/Fortran/matrix-exponentiation-operator.f : a45ce9e65278545613d72f1cea16406f5484ec12ad5e721fdc4e9ab83c1f27ce
 RosettaCodeData/Task/Polymorphic-copy/Fortran/polymorphic-copy.f : a5a9a5568a06157d085f5f1879a6b91bd1d102a0a63951ba451bda00fe2d702c
-RosettaCodeData/Task/Quaternion-type/Fortran/quaternion-type.f : 734e5c5479150979cd2a48874dcde06903b708434cd81dcb9cdba3eda9f064e6
+RosettaCodeData/Task/Quaternion-type/Fortran/quaternion-type.f : a331a9ff10e9cbc8b2d5fbdbbd56e2540a555a029aac61425250bed548fc28ab
 FLAP/src/lib/flap.f90 : d8c91241624cf28e1cf1d5c2ba70b775a7bcfd3221d81e8697baf55532375f51
 FLAP/src/lib/flap_command_line_argument_t.F90 : 763c6a6142ba8383518e84f5d088796c6cf3818d1ed97d11060957b11bfee767
 FLAP/src/lib/flap_command_line_arguments_group_t.f90 : b0dec2d7c0174753bb2047bcf63e1e0392cbf929c9c6dade8a5cd63e70338420
@@ -1939,3 +1939,4 @@ FLAP/src/tests/test_hidden.f90 : 1fecd3c5a4844898f4fb5019c37a81f7bb1ef5340e79e02
 FLAP/src/tests/test_minimal.f90 : 9ba58554d1e477b40ea311497e95099d064d4b46b9df6ff2ddbbc5f9fcaed885
 FLAP/src/tests/test_nested.f90 : e6adb6a29770988006c6c83d0eb6572433882724a0bae51f47778899afc3e508
 FLAP/src/tests/test_string.f90 : 7e1bce103b0997861d072ab1a506bf70db9eb29b7ab8867ff415b855aadf1f54
+another_example.f90 : 90257fe1108c8689002b470e2e2620c2a0652ca6465ba1a5bbbd6667e2339be0

fprettify/__init__.py

@@ -107,12 +107,15 @@
 SELCASE_RE = re.compile(
     SOL_STR + r"SELECT\s*(CASE|TYPE)\s*\(.+\)" + EOL_STR, RE_FLAGS)
 CASE_RE = re.compile(
-    SOL_STR + r"(CASE|TYPE\s+IS|CLASS\s+IS)\s*(\(.+\)|DEFAULT)" + EOL_STR, RE_FLAGS)
+    SOL_STR + r"((CASE|TYPE\s+IS|CLASS\s+IS)\s*(\(.+\)|DEFAULT)|CLASS\s+DEFAULT)" + EOL_STR, RE_FLAGS)
 ENDSEL_RE = re.compile(SOL_STR + r"END\s*SELECT" + EOL_STR, RE_FLAGS)
 
 ASSOCIATE_RE = re.compile(SOL_STR + r"ASSOCIATE\s*\(.+\)" + EOL_STR, RE_FLAGS)
 ENDASSOCIATE_RE = re.compile(SOL_STR + r"END\s*ASSOCIATE" + EOL_STR, RE_FLAGS)
 
+BLK_RE = re.compile(SOL_STR + r"(\w+\s*:)?\s*BLOCK" + EOL_STR, RE_FLAGS)
+ENDBLK_RE = re.compile(SOL_STR + r"END\s*BLOCK(\s+\w+)?" + EOL_STR, RE_FLAGS)
+
 SUBR_RE = re.compile(
     r"^([^\"'!]* )?SUBROUTINE\s+\w+\s*(\(.*\))?" + EOL_STR, RE_FLAGS)
 ENDSUBR_RE = re.compile(
@@ -151,6 +154,7 @@
 
 ENDANY_RE = re.compile(SOL_STR + r"END" + EOL_STR, RE_FLAGS)
 
+PRIVATE_RE = re.compile(SOL_STR + r"PRIVATE\s*::", RE_FLAGS)
 PUBLIC_RE = re.compile(SOL_STR + r"PUBLIC\s*::", RE_FLAGS)
 
 # intrinsic statements with parenthesis notation that are not functions
@@ -165,6 +169,9 @@
 # Note: +/- in real literals and sign operator is ignored
 PLUSMINUS_RE = re.compile(
     r"(?<=[\w\)\]])(?<![\d\.]\w)\s*(\+|-)\s*", RE_FLAGS)
+# Note: ** or // (or any multiples of * or /) are ignored
+MULTDIV_RE = re.compile(
+    r"(?<=[\w\)\]])\s*((?<!\*)\*(?!\*)|(?<!/)/(?!/))(?=[\s\w\(])", RE_FLAGS)
 REL_OP_RE = re.compile(
     r"(?<!\()\s*(\.(?:EQ|NE|LT|LE|GT|GE)\.|(?:==|\/=|<(?!=)|<=|(?<!=)>(?!=)|>=))\s*(?!\))",
     RE_FLAGS)
@@ -181,7 +188,7 @@
 EMPTY_RE = re.compile(SOL_STR + r"([!#].*)?$", RE_FLAGS)
 
 # two-sided operators
-LR_OPS_RE = [REL_OP_RE, LOG_OP_RE, PLUSMINUS_RE, PRINT_RE]
+LR_OPS_RE = [REL_OP_RE, LOG_OP_RE, PLUSMINUS_RE, MULTDIV_RE, PRINT_RE]
 
 USE_RE = re.compile(
     SOL_STR + "USE(\s+|(,.+?)?::\s*)\w+?((,.+?=>.+?)+|,\s*only\s*:.+?)?$" + EOL_STR, RE_FLAGS)
@@ -191,12 +198,17 @@
 
 # combine regex that define subunits
 NEW_SCOPE_RE = [IF_RE, DO_RE, SELCASE_RE, SUBR_RE,
-                FCT_RE, MOD_RE, PROG_RE, INTERFACE_RE, TYPE_RE, ENUM_RE, ASSOCIATE_RE, None]
+                FCT_RE, MOD_RE, PROG_RE, INTERFACE_RE, TYPE_RE, ENUM_RE, ASSOCIATE_RE, None, BLK_RE]
 CONTINUE_SCOPE_RE = [ELSE_RE, None, CASE_RE, CONTAINS_RE,
-                     CONTAINS_RE, CONTAINS_RE, CONTAINS_RE, None, CONTAINS_RE, None, None, None]
+                     CONTAINS_RE, CONTAINS_RE, CONTAINS_RE, None, CONTAINS_RE, None, None, None, None]
 END_SCOPE_RE = [ENDIF_RE, ENDDO_RE, ENDSEL_RE, ENDSUBR_RE,
-                ENDFCT_RE, ENDMOD_RE, ENDPROG_RE, ENDINTERFACE_RE, ENDTYPE_RE, ENDENUM_RE, ENDASSOCIATE_RE, ENDANY_RE]
+                ENDFCT_RE, ENDMOD_RE, ENDPROG_RE, ENDINTERFACE_RE, ENDTYPE_RE, ENDENUM_RE, ENDASSOCIATE_RE, ENDANY_RE, ENDBLK_RE]
 
+# match namelist names
+NML_RE = re.compile(r"(/\w+/)", RE_FLAGS)
+# find namelists and data statements
+NML_STMT_RE = re.compile(SOL_STR + r"NAMELIST.*/.*/", RE_FLAGS)
+DATA_STMT_RE = re.compile(SOL_STR + r"DATA\s+\w", RE_FLAGS)
 
 class F90Indenter(object):
     """
@@ -394,7 +406,7 @@ def process_lines_of_fline(self, f_line, lines, rel_ind, line_nr):
 
         self.__init_line(line_nr)
 
-        is_decl = VAR_DECL_RE.search(f_line) or PUBLIC_RE.search(f_line)
+        is_decl = VAR_DECL_RE.search(f_line) or PUBLIC_RE.search(f_line) or PRIVATE_RE.match(f_line)
         for pos, line in enumerate(lines):
             self.__align_line_continuations(
                 line, is_decl, rel_ind, self._line_nr + pos)
@@ -566,7 +578,7 @@ def format_single_fline(f_line, whitespace, linebreak_pos, ampersand_sep,
     separating whitespace characters before ampersand (`ampersand_sep`).
     `filename` and `line_nr` just for error messages.
     The higher `whitespace`, the more white space characters inserted -
-    whitespace = 0, 1, 2 are currently supported.
+    whitespace = 0, 1, 2, 3 are currently supported.
     auto formatting can be turned off by setting `auto_format` to False.
     """
 
@@ -576,14 +588,17 @@ def format_single_fline(f_line, whitespace, linebreak_pos, ampersand_sep,
     # 2: relational operators
     # 3: logical operators
     # 4: arithm. operators plus and minus
-    # 5: print / read statements
+    # 5: arithm. operators multiply and divide
+    # 6: print / read statements
 
     if whitespace == 0:
-        spacey = [0, 0, 0, 0, 0, 0]
+        spacey = [0, 0, 0, 0, 0, 0, 0]
     elif whitespace == 1:
-        spacey = [1, 1, 1, 1, 0, 1]
+        spacey = [1, 1, 1, 1, 0, 0, 1]
     elif whitespace == 2:
-        spacey = [1, 1, 1, 1, 1, 1]
+        spacey = [1, 1, 1, 1, 1, 0, 1]
+    elif whitespace == 3:
+        spacey = [1, 1, 1, 1, 1, 1, 1]
     else:
         raise NotImplementedError("unknown value for whitespace")
 
@@ -668,6 +683,8 @@ def add_whitespace_charwise(line, spacey, filename, line_nr):
                                   line[:pos], RE_FLAGS) or
                         re.search(SOL_STR + r"SELECT\s*TYPE\s*",
                                   line[:pos], RE_FLAGS) or
+                        re.search(SOL_STR + r"CLASS\s*DEFAULT\s*",
+                                  line[:pos], RE_FLAGS) or
                         re.search(SOL_STR + r"(TYPE|CLASS)\s+IS\s*",
                                   line[:pos], RE_FLAGS) or
                         re.search(r"\b" + INTR_STMTS_PAR + r"\s*$",
@@ -764,13 +781,23 @@ def add_whitespace_context(line, spacey):
         if pos == len(line) - 1:
             line_parts.append(line[str_end + 1:])
 
+    # format namelists with spaces around /
+    if NML_STMT_RE.match(line):
+        for pos, part in enumerate(line_parts):
+            # exclude comments, strings:
+            if not re.match(r"['\"!]", part, RE_FLAGS):
+                partsplit = NML_RE.split(part)
+                line_parts[pos] = (' '.join(partsplit))
+
     # Two-sided operators
     for n_op, lr_re in enumerate(LR_OPS_RE):
         for pos, part in enumerate(line_parts):
             # exclude comments, strings:
             if not re.search(r"^['\"!]", part, RE_FLAGS):
-                partsplit = lr_re.split(part)
-                line_parts[pos] = (' ' * spacey[n_op + 2]).join(partsplit)
+                # also exclude / if we see a namelist and data statement
+                if not ( NML_STMT_RE.match(line) or DATA_STMT_RE.match(line) ):
+                    partsplit = lr_re.split(part)
+                    line_parts[pos] = (' ' * spacey[n_op + 2]).join(partsplit)
 
     line = ''.join(line_parts)
 
@@ -1216,7 +1243,7 @@ def run(argv=sys.argv):  # pragma: no cover
     parser.add_argument("-i", "--indent", type=int, default=3,
                         help="relative indentation width")
     parser.add_argument("-w", "--whitespace", type=int,
-                        choices=range(0, 3), default=2, help="Amount of whitespace")
+                        choices=range(0, 4), default=2, help="Amount of whitespace")
     parser.add_argument("-s", "--stdout", action='store_true', default=False,
                         help="Write to stdout instead of formatting inplace")
 

fprettify/tests/__init__.py

@@ -124,10 +124,11 @@ def test_whitespace(self):
         instring = "(/-a-b-(a+b-c)/(-c)*d**e,f[1]%v/)"
         outstring_exp = ["(/-a-b-(a+b-c)/(-c)*d**e,f[1]%v/)",
                          "(/-a-b-(a+b-c)/(-c)*d**e, f[1]%v/)",
-                         "(/-a - b - (a + b - c)/(-c)*d**e, f[1]%v/)"]
+                         "(/-a - b - (a + b - c)/(-c)*d**e, f[1]%v/)",
+                         "(/-a - b - (a + b - c) / (-c) * d**e, f[1]%v/)"]
 
         outstring = []
-        for w, out in zip(range(0, 3), outstring_exp):
+        for w, out in zip(range(0, 4), outstring_exp):
             args = ['-w', str(w)]
             self.assert_fprettify_result(args, instring, out)