lint refactor

Author: scivision

README.md

@@ -19,7 +19,7 @@ Demonstrate linking of
 * C and C++ program calling Fortran libraries
 * Fortran program calling C and C++ libraries
 
-We assume the compilers are C++11 and Fortran 2018 capable.
+We assume the compilers are C++20 and Fortran 2018 capable.
 
 This repo's examples are also known to work with:
 
@@ -155,6 +155,7 @@ For arrays of struct, compiler
 [pragma may be needed](https://stackoverflow.com/questions/53161673/data-alignment-inside-a-structure-in-intel-fortran).
 
 Valgrind needed suppression to avoid memory alignment (uninitialized memory) warnings for C struct input to nanosleep.
+
 ### MacOS
 
 For MacOS with Apple's Clang and Homebrew GCC,

src/bool/logbool.cpp

@@ -2,7 +2,7 @@
 
 #include "my_bool.h"
 
-bool logical_not(bool a)
+bool logical_not(const bool a)
 {
   std::cout << "c++ input boolean: " << a << " size " << sizeof(a) << "\n";
 

src/bool/my_bool.h

@@ -2,7 +2,7 @@
 extern "C" {
 #endif
 
-bool logical_not(bool);
+bool logical_not(const bool);
 
 bool bool_true();
 bool bool_false();

test/allocate/README.md

@@ -2,7 +2,15 @@
 
 Deallocating arrays in a Fortran procedure that were allocated in another Fortran procedure, both called from a C/C++ main program is defined in a compiler vendor-dependent way.
 The Intel oneAPI compiler works with the "fancy_allocate" demo, while GCC Gfortran works with all the allocate examples.
-Cray Fortran ftn compiler currently doesn't work with the allocate in Fortran from C/C++ main program examples.
 
-To be more compiler vendor independent, the general recommendation when using a C/C++ main program is to allocate the memory in C/C++ e.g. via `malloc()` or in C++ via `new`, `vector` or `array` and then pass back and forth to Fortran.
+
+To be more compiler vendor independent, the general recommendation when using a C/C++ main program is to allocate the memory in:
+
+* C `malloc()`
+* C++ `std::vector`
+* C++ `std::array`
+* C++ `std::make_unique`
+
+and then pass back and forth to Fortran.
+
 This allows memory to be managed fully, particularly with regard to freeing memory when no longer used to avoid memory leaks in long-running programs.

test/iso_fortran_binding/sampling.cpp

@@ -91,17 +91,17 @@ namespace stdr = std::ranges;
 // [in]        n: the number of samples
 // [out] samples: an array of (x,y) values, shape [n,2]
 //
-extern "C" void draw_random_samples(int n, CFI_cdesc_t *samples);
+extern "C" void draw_random_samples(const int n, CFI_cdesc_t *samples);
 
 // Same procedure as the one below, but implemented in Fortran
-extern "C" double f_estimate_pi(int n);
+extern "C" double f_estimate_pi(const int n);
 
 /* Calculate pi using the Monte-Carlo method.
  *
  * Random numbers are generated in Fortran just for the
  * sake of testing the F2018 enhanced C interoperability.
  */
-double estimate_pi(int n)
+double estimate_pi(const int n)
 {
     CFI_CDESC_T(2) samples_;
     const auto samples = (CFI_cdesc_t *) &samples_;
@@ -111,7 +111,7 @@ double estimate_pi(int n)
                              CFI_attribute_allocatable,
                              CFI_type_double,
                              0 /* ignored */,
-                             (CFI_rank_t) 2,
+                             static_cast<CFI_rank_t>(2),
                              nullptr /* ignored */) );
 
     // Make sure we don't forget to deallocate
@@ -127,8 +127,8 @@ double estimate_pi(int n)
     {
         // <!> Pointer arithmetic <!>
 
-        const double x = *( (double *) samples->base_addr + i);
-        const double y = *( (double *) samples->base_addr + i + n);
+        const double x = *( static_cast<double*>(samples->base_addr) + i);
+        const double y = *( static_cast<double*>(samples->base_addr) + i + n);
 
         return x*x + y*y < 1;
     };
@@ -151,16 +151,14 @@ double estimate_pi(int n)
     int ncircle = count_if( iota(0,n-1), inside_of_circle );
 #endif
 
-    return 4.0 * ((double) ncircle) / n;
+    return 4.0 * (static_cast<double>(ncircle)) / n;
 
 } // dealloc called here
 
 int main(int argc, char const *argv[])
 {
 
-    int N = 1000;
-    if (argc > 1)
-      N = atoi(argv[1]);
+    const int N = (argc > 1) ? atoi(argv[1]) : 1000;
 
     std::cout << "pi = " <<   estimate_pi( N ) << '\n';
     std::cout << "pi = " << f_estimate_pi( N ) << '\n';

test/iso_fortran_binding/string_array.cpp

@@ -23,15 +23,17 @@ int main()
    // Use macro from ISO_Fortran_binding to set aside an address to "description" of string data
    CFI_CDESC_T(1) names;
 
-  CFI_establish((CFI_cdesc_t *)&names, nullptr,
+   CFI_establish(static_cast<CFI_cdesc_t*>(&names), nullptr,
                     CFI_attribute_pointer,
                     CFI_type_char, 0, (CFI_rank_t)1, nullptr);
 
    // Call the Fortran procedure for string manipulation
-   get_names((CFI_cdesc_t *)&names);
+   get_names(static_cast<CFI_cdesc_t*>(&names));
 
    for (int i = 0; i < names.dim[0].extent; i++) {
-       vs.push_back(std::string_view((char *)names.base_addr).substr(i * names.elem_len, names.elem_len));
+       vs.push_back(std::string_view(
+        static_cast<char*>(names.base_addr)).substr(
+            i * names.elem_len, names.elem_len));
    }
    for (int i = 0; i < names.dim[0].extent; i++) {
        std::cout << vs[i] << "\n";

test/iso_fortran_binding/string_view.cpp

@@ -8,7 +8,9 @@
 extern "C" {
    void echo_c( const CFI_cdesc_t* Fstr )
    {
-      auto view = std::string_view((char *)Fstr->base_addr).substr(0, Fstr->elem_len);
+      auto view = std::string_view(
+         static_cast<char*>(Fstr->base_addr)).substr(
+            0, Fstr->elem_len);
       std::cout << view << "\n";
    }
 }

test/malloc/main.c

@@ -28,7 +28,7 @@ int main(void)
   free(x);
   free(x2);
 
-  printf("OK: C malloc new\n");
+  printf("OK: C malloc\n");
 
   return EXIT_SUCCESS;
 }