Replace fclassname with fortranclassname for consistency with other languages

Author: sethrj

Doc/Manual/src/Fortran.md

@@ -1689,15 +1689,16 @@ Fortran compiler), `release` should be called on every proxy class instance.
 SWIG's default Fortran type (the `ftype` typemap) for generic types such as
 classes (`SWIGTYPE`) is:
 ```swig
-%typemap(ftype) SWIGTYPE "type($fclassname)"
+%typemap(ftype) SWIGTYPE "type($fortranclassname)"
 ```
-The special symbol `$fclassname` is replaced by the symbolic name of the class
-that matches the typemap. For example, if `std::vector<double>` is
+The special symbol `$fortranclassname` is replaced by the symbolic name (i.e. the Fortran
+identifier in the proxy code) of the class that matches the typemap.
+For example, if `std::vector<double>` is
 instantiated:
 ```swig
 %template(Vec_Dbl) std::vector<double>;
 ```
-then `Vec_Dbl`, the name of the derived type, will replace `$fclassname`.
+then `Vec_Dbl`, the name of the derived type, will replace `$fortranclassname`.
 
 If a class has *not* been wrapped but is encountered (e.g. in a function
 argument or return value), a warning will be emitted: no Fortran

Lib/fortran/bindc.swg

@@ -3,8 +3,8 @@
  * ------------------------------------------------------------------------- */
 
 // Declare a generic `FORTRAN_STRUCT_TYPE` as a native type.
-// Rather than being an intrinsic type `integer(C_INT)` it's a derived type `type($fclassname)`
-%fortran_intrinsic(FORTRAN_STRUCT_TYPE, type($fclassname))
+// Rather than being an intrinsic type `integer(C_INT)` it's a derived type `type($fortranclassname)`
+%fortran_intrinsic(FORTRAN_STRUCT_TYPE, type($fortranclassname))
 // Avoid 'C99 forbids casting nonscalar type 'XY' to the same type'
 %typemap(in) FORTRAN_STRUCT_TYPE "$1 = *$input;"
 %typemap(out) FORTRAN_STRUCT_TYPE "$result = $1;"

Lib/fortran/boost_shared_ptr.i

@@ -62,7 +62,7 @@
  * SP-owned copy of the obtained value.
  * ------------------------------------------------------------------------- */
 %typemap(in, noblock=1, fragment="SWIG_check_sp_nonnull") CONST TYPE ($&1_type argp = 0) {
-  SWIG_check_sp_nonnull($input->cptr, "$1_ltype", "$fclassname", "$decl", return $null)
+  SWIG_check_sp_nonnull($input->cptr, "$1_ltype", "$fortranclassname", "$decl", return $null)
   argp = static_cast<SWIGSP__*>($input->cptr)->get();
   $1 = *argp;
 }
@@ -102,7 +102,7 @@
  * Original class by reference. Add null checks.
  * ------------------------------------------------------------------------- */
 %typemap(in, noblock=1, fragment="SWIG_check_sp_nonnull") CONST TYPE & {
-  SWIG_check_sp_nonnull($input->cptr, "$1_ltype", "$fclassname", "$decl", return $null)
+  SWIG_check_sp_nonnull($input->cptr, "$1_ltype", "$fortranclassname", "$decl", return $null)
   $1 = (TYPE*)static_cast<SWIGSP__*>($input->cptr)->get();
 }
 

Lib/fortran/classes.swg

@@ -323,11 +323,11 @@ SWIGINTERN void SWIG_assign(SwigClassWrapper* self, SwigClassWrapper other) {
 %typemap(imtype, fragment="SwigClassWrapper_f")
     SWIGTYPE
   "type(SwigClassWrapper)"
-%typemap(ftype, in="type($&fclassname), intent(in)", nofortransubroutine=1) SWIGTYPE
-  "type($&fclassname)"
+%typemap(ftype, in="type($&fortranclassname), intent(in)", nofortransubroutine=1) SWIGTYPE
+  "type($&fortranclassname)"
 
 %typemap(in, noblock=1, fragment="SWIG_check_nonnull") SWIGTYPE {
-  SWIG_check_nonnull(*$input, "$1_ltype", "$&fclassname", "$decl", return $null);
+  SWIG_check_nonnull(*$input, "$1_ltype", "$&fortranclassname", "$decl", return $null);
   $1 = *(($&1_ltype)($input->cptr));
 }
 
@@ -352,8 +352,8 @@ SWIGINTERN void SWIG_assign(SwigClassWrapper* self, SwigClassWrapper other) {
 // Raw pointers act mostly like value types, but they don't have to accept the exact type (polymorphic input, non-polymorphic output). Intent is 'in' because
 // we're not modifying the pointer or memory status.
 %apply SWIGTYPE { SWIGTYPE* };
-%typemap(ftype, in="class($fclassname), intent(in)", nofortransubroutine=1) SWIGTYPE*
-  "type($fclassname)"
+%typemap(ftype, in="class($fortranclassname), intent(in)", nofortransubroutine=1) SWIGTYPE*
+  "type($fortranclassname)"
 %typemap(in, noblock=1) SWIGTYPE* {
   $1 = ($1_ltype)$input->cptr;
 }
@@ -373,7 +373,7 @@ SWIGINTERN void SWIG_assign(SwigClassWrapper* self, SwigClassWrapper other) {
 // Check for non-null reference inputs
 %apply SWIGTYPE* { SWIGTYPE& };
 %typemap(in, noblock=1, fragment="SWIG_check_nonnull") SWIGTYPE& {
-  SWIG_check_nonnull(*$input, "$1_type", "$fclassname", "$decl", return $null);
+  SWIG_check_nonnull(*$input, "$1_type", "$fortranclassname", "$decl", return $null);
   $1 = ($1_ltype)$input->cptr;
 }
 
@@ -397,15 +397,15 @@ SWIGINTERN void SWIG_assign(SwigClassWrapper* self, SwigClassWrapper other) {
 
 // Check for non-null class input "self"
 %typemap(in, noblock=1, fragment="SWIG_check_nonnull") SWIGTYPE *self {
-  SWIG_check_nonnull(*$input, "$1_type", "$*fclassname", "$decl", return $null);
+  SWIG_check_nonnull(*$input, "$1_type", "$*fortranclassname", "$decl", return $null);
   $1 = ($1_ltype)$input->cptr;
 }
 
 // On assignment, copy pointer to input wrapper class
 %typemap(imtype, in="type(SwigClassWrapper), intent(inout)", fragment="SwigClassWrapper_f") SWIGTYPE *ASSIGNMENT_SELF
   "type(SwigClassWrapper)"
-%typemap(ftype, in="class($fclassname), intent(inout)", nofortransubroutine=1) SWIGTYPE *ASSIGNMENT_SELF
-  "type($fclassname)"
+%typemap(ftype, in="class($fortranclassname), intent(inout)", nofortransubroutine=1) SWIGTYPE *ASSIGNMENT_SELF
+  "type($fortranclassname)"
 
 // Assignment operates directly on $input, not $1
 %typemap(in) SWIGTYPE *ASSIGNMENT_SELF "(void)sizeof($1);";
@@ -414,8 +414,8 @@ SWIGINTERN void SWIG_assign(SwigClassWrapper* self, SwigClassWrapper other) {
 }
 
 // Prevent ambiguous overloads by requiring the RHS to be the exact type
-%typemap(ftype, in="type($fclassname), intent(in)", nofortransubroutine=1) SWIGTYPE &ASSIGNMENT_OTHER
-  "type($fclassname)"
+%typemap(ftype, in="type($fortranclassname), intent(in)", nofortransubroutine=1) SWIGTYPE &ASSIGNMENT_OTHER
+  "type($fortranclassname)"
 %typemap(in) SWIGTYPE &ASSIGNMENT_OTHER = SWIGTYPE *ASSIGNMENT_SELF;
 
 %apply SWIGTYPE *ASSIGNMENT_SELF { SWIGTYPE *DESTRUCTOR_SELF };

Lib/fortran/enums.swg

@@ -11,17 +11,17 @@
 // integer pointers)
 %fortran_unsigned(int, enum SWIGTYPE)
 
-%typemap(ftype, in="integer($fclassname), intent(in)") enum SWIGTYPE
-  "integer($fclassname)"
+%typemap(ftype, in="integer($fortranclassname), intent(in)") enum SWIGTYPE
+  "integer($fortranclassname)"
 %typemap(out, noblock=1) enum SWIGTYPE {
   $result = (int)($1);
 }
 %typemap(out, noblock=1) const enum SWIGTYPE& {
   $result = (int)(*$1);
 }
 
-%typemap(ftype, in="integer($*fclassname), intent(in)") const enum SWIGTYPE&
-  "integer($*fclassname)"
+%typemap(ftype, in="integer($*fortranclassname), intent(in)") const enum SWIGTYPE&
+  "integer($*fortranclassname)"
 %typemap(imtype) const enum SWIGTYPE& = enum SWIGTYPE;
 %typemap(fin)    const enum SWIGTYPE& = enum SWIGTYPE;
 %typemap(fout)   const enum SWIGTYPE& = enum SWIGTYPE;

Source/Modules/fortran.cxx

@@ -266,7 +266,7 @@ bool return_type_needs_typedef(String *s) {
  * \brief Construct any necessary 'import' identifier.
  *
  * When the `imtype` is an actual `type(Foo)`, it's necessary to import the identifier Foo from the module definition scope. This function examines the
- * evaluated `imtype` (could be `imtype:in`, probably has $fclassname replaced)
+ * evaluated `imtype` (could be `imtype:in`, probably has $fortranclassname replaced)
  */
 String *make_import_string(String *imtype) {
   char *start = Strstr(imtype, "type(");
@@ -1672,7 +1672,7 @@ Wrapper *FORTRAN::proxyfuncWrapper(Node *n) {
   // Check whether the Fortran proxy routine returns a variable, and whether
   // the actual C function does
 
-  // Replace any instance of $fclassname in return type
+  // Replace any instance of $fortranclassname in return type
   SwigType *return_cpptype = Getattr(n, "type");
   this->replace_fclassname(return_cpptype, return_ftype);
   this->replace_fclassname(return_cpptype, return_imtype);
@@ -2948,7 +2948,7 @@ int FORTRAN::constantWrapper(Node *n) {
       wname = Copy(symname);
     }
 
-    // Replace fclassname if needed
+    // Replace fortranclass if needed
     this->replace_fclassname(c_return_type, bindc_typestr);
 
     // Add bound variable to interfaces
@@ -2975,26 +2975,26 @@ void FORTRAN::replace_fclassname(SwigType *intype, String *tm) {
   SwigType *resolvedtype = SwigType_typedef_resolve_all(intype);
   SwigType *strippedtype = SwigType_strip_qualifiers(resolvedtype);
 
-  if (Strstr(tm, "$fclassname")) {
+  if (Strstr(tm, "$fortranclassname")) {
     if (String *repl = this->get_proxyname(strippedtype)) {
-      Replaceall(tm, "$fclassname", repl);
+      Replaceall(tm, "$fortranclassname", repl);
     }
   }
-  if (Strstr(tm, "$*fclassname")) {
+  if (Strstr(tm, "$*fortranclassname")) {
     String *repltype = Copy(strippedtype);
     Delete(SwigType_pop(repltype));
     if (Len(repltype) > 0) {
       if (String *repl = this->get_proxyname(repltype)) {
-        Replaceall(tm, "$*fclassname", repl);
+        Replaceall(tm, "$*fortranclassname", repl);
       }
     }
     Delete(repltype);
   }
-  if (Strstr(tm, "$&fclassname")) {
+  if (Strstr(tm, "$&fortranclassname")) {
     String *repltype = Copy(strippedtype);
     SwigType_add_pointer(repltype);
     if (String *repl = this->get_proxyname(repltype)) {
-      Replaceall(tm, "$&fclassname", repl);
+      Replaceall(tm, "$&fortranclassname", repl);
     }
     Delete(repltype);
   }
@@ -3034,22 +3034,22 @@ String *FORTRAN::get_fsymname(Node *n, String *symname) {
 
 /* ------------------------------------------------------------------------- */
 
-String *FORTRAN::get_proxyname(SwigType *classnametype) {
+String *FORTRAN::get_proxyname(SwigType *basetype) {
   Node *n = NULL;
 
-  bool is_enum = SwigType_isenum(classnametype);
+  bool is_enum = SwigType_isenum(basetype);
   if (is_enum) {
-    n = this->enumLookup(classnametype);
+    n = this->enumLookup(basetype);
   } else {
-    n = this->classLookup(classnametype);
+    n = this->classLookup(basetype);
   }
 
   if (n && (!is_enum || is_wrapped_enum(n))) {
     // Class node or enum with already-generated wrapper
     return this->get_fsymname(n);
   }
 
-  String *replacementname = create_mangled_fname(classnametype);
+  String *replacementname = create_mangled_fname(basetype);
   if (Getattr(d_emitted_mangled, replacementname)) {
     // Mangled type has already been emitted
     return replacementname;
@@ -3059,7 +3059,7 @@ String *FORTRAN::get_proxyname(SwigType *classnametype) {
   // Create a node so we can insert into the fortran symbol table
   n = NewHash();
   set_nodeType(n, (is_enum ? "enumforward" : "classforward"));
-  Setattr(n, "name", classnametype);
+  Setattr(n, "name", basetype);
   if (this->add_fsymbol(replacementname, n) == SWIG_NOWRAP) {
     ASSERT_OR_PRINT_NODE(false, n);
     return NULL;
@@ -3083,12 +3083,12 @@ String *FORTRAN::get_proxyname(SwigType *classnametype) {
 
 /* ------------------------------------------------------------------------- */
 
-bool FORTRAN::is_wrapped_type(SwigType *classnametype) {
-  if (SwigType_isenum(classnametype)) {
-    Node *n = this->enumLookup(classnametype);
+bool FORTRAN::is_wrapped_type(SwigType *basetype) {
+  if (SwigType_isenum(basetype)) {
+    Node *n = this->enumLookup(basetype);
     return n && is_wrapped_enum(n);
   } else {
-    return this->classLookup(classnametype) != NULL;
+    return this->classLookup(basetype) != NULL;
   }
 }
 
@@ -3118,12 +3118,12 @@ bool FORTRAN::is_wrapped_class(Node *n) {
   if (!tm) {
     // Somehow there's no ftype; allow it to be wrapped so the error is handled later
     result = true;
-  } else if (Strstr(tm, "$fclassname")) {
+  } else if (Strstr(tm, "$fortranclassname")) {
     result = this->is_wrapped_type(strippedtype);
-  } else if (Strstr(tm, "$*fclassname")) {
+  } else if (Strstr(tm, "$*fortranclassname")) {
     SwigType_pop(strippedtype);
     result = this->is_wrapped_type(strippedtype);
-  } else if (Strstr(tm, "$&fclassname")) {
+  } else if (Strstr(tm, "$&fortranclassname")) {
     SwigType_add_pointer(strippedtype);
     result = this->is_wrapped_type(strippedtype);
   } else {