Fix reference to out-of-scope data for reflexive string reference

The contrived test case here is the only possible time this would happen
so in practice this is unlikely to be neceessary, but this way is the safest
and the only penalty is an extra allocation/string copy/free.

Author: sethrj

Examples/test-suite/fortran/li_std_string_runme.F90

@@ -0,0 +1,25 @@
+! File : li_std_string_runme.f90
+
+#include "fassert.h"
+
+program li_std_string_runme
+  use li_std_string
+  use ISO_C_BINDING
+  implicit none
+  character(kind=C_CHAR, len=*), parameter :: mystring = "howdy!"
+  character(kind=C_CHAR, len=:), allocatable :: actual
+  type(swigtype_p_std__string) :: anonymous_string
+
+  allocate(actual, source=test_value(mystring))
+  ASSERT(actual == mystring)
+  deallocate(actual)
+
+  actual = test_const_reference(mystring)
+  ASSERT(actual == mystring)
+  deallocate(actual)
+
+  call test_pointer(anonymous_string)
+
+  anonymous_string = test_pointer_out()
+end program
+

Lib/fortran/std_string.i

@@ -30,45 +30,12 @@ namespace std {
 class string;
 }
 
-/* ---- CONST REFERENCE: NATIVE STRING ---- */
-
-%clear const std::string &;
-%typemap(ctype) const std::string & = char*;
-%typemap(imtype) const std::string & = char*;
-%typemap(ftype) const std::string & = char*;
-
-// C input translation typemaps: $1 is std::string*, $input is SwigArrayWrapper
-%typemap(in, noblock=1) const std::string & (std::string tempstr) {
-  tempstr = std::string(static_cast<char *>($input->data), $input->size);
-  $1 = &tempstr;
-}
-
-// C output translation typemaps: $1 is string*, $input is SwigArrayWrapper
-%typemap(out, noblock=1) const std::string & {
-  $result.data = ($1->empty() ? NULL : &(*$1->begin()));
-  $result.size = $1->size();
-}
-
-// Fortran proxy translation code: convert from char array to Fortran string
-%typemap(fin) const std::string & = char*;
-// Unlike char* code, we never delete the return value!
-%typemap(fout, noblock=1, fragment="SWIG_fout"{char*}) const std::string & {
-  call %fortrantm(fout, char*)($1, $result)
-}
-
 /* ---- VALUE: NATIVE STRING ---- */
 
 %clear std::string;
-%apply const std::string & { std::string };
 
-%typemap(globalin) std::string {
-   $1 = *$input;
-}
-%typemap(memberin) std::string {
-   $1 = *$input;
-}
+%typemap(ctype) std::string = char*;
 
-// Copy input data to local string
 %typemap(in, noblock=1) std::string {
   $1.assign(static_cast<char *>($input->data), $input->size);
 }
@@ -84,9 +51,37 @@ class string;
   }
 }
 
+%typemap(imtype) std::string = char*;
+%typemap(ftype) std::string = char*;
+
+// Fortran proxy translation code: convert from char array to Fortran string
+%typemap(fin) std::string = char*;
+
 // Fortran proxy translation code: convert from char array to Fortran string
 %typemap(fout, noblock=1,
          fragment="SWIG_free_f", fragment="SWIG_fout"{char*}) std::string {
   call %fortrantm(fout, char*)($1, $result)
   call SWIG_free($1%data)
 }
+
+/* ---- CONST REFERENCE: NATIVE STRING ---- */
+
+// Use the same
+%clear const std::string &;
+%apply std::string { const std::string & };
+
+// Construct a temporary string from the Fortran character array
+%typemap(in, noblock=1) const std::string & (std::string tempstr) {
+  tempstr = std::string(static_cast<char *>($input->data), $input->size);
+  $1 = &tempstr;
+}
+
+%typemap(out, noblock=1, fragment="<stdlib.h>", fragment="<string.h>") const std::string & {
+  $result.size = $1->size();
+  if ($result.size > 0) {
+    $result.data = malloc($result.size);
+    memcpy($result.data, $1->c_str(), $result.size);
+  } else {
+    $result.data = NULL;
+  }
+}