Question

I am a dummy in Fortran 77 and have always been a C++ coder, but I have to modify a code from years long ago…
I want to create a variable size array of strings and I cannot find online how to do this in Fortran 77.
Ideally, it should be array with both dimensions variable but if it is not possible, length of the string I can fix, but I need to have variable number of strings.

I tried this:

CHARACTER*32 STR1*(VAR1)
...
WRITE(6,*) STR1(10)

But this does not work…

Answer 1

Apparently FORTRAN 77 does not support dynamic memory allocation .
You could try allocating memory in a c program and passing the result back to the FORTRAN routine.

As done here
http://owen.sj.ca.us/~rk/howto/FandC/FandC.mem.html

Or more clearly – using some kind of an Interop to call a c method

from fortran.

The Unix portable Fortran-77 compiler (‘f77’) is written almost
entirely in C. The second pass of the compiler is the same one used by
the C compiler, and most ‘f77’ library routines are simply interfaces
to corresponding C library routines. However, since Fortran does not
support data structures like those used in C, you may not be able to
take advantage of all the functionality that the ‘curses’ library
offers. Manipulating windows with ‘curses’ is especially difficult. If
you are interested in using routines involving data structures, you
should probably use C instead of Fortran.

To call C routines from a Fortran program, you will have to write some
C code. Fortran passes arguments by reference or address, so the C
function has to be prepared to accept the variable as an address. This
means that you will have to write functions in C that are called from
Fortran that set up the arguments properly before calling the library
function. Schematically, this might be something like:

Note underscore ( _ ) in name of routine.

In the C source file:

foo_(bar) /* Note underscore */ int bar; / Note variables are
passed by address */

{ : }

In the Fortran source file:

call foo(baz) /* Assuming that “baz” is an integer. */ { : }

The underscore is important because Fortran uses the character to keep
its symbols straight. If you are compiling on an RS6000 this is not
default behavior, but compiling with the -qextname option on the
RS6000 will cause it to perform identical to the other platforms.

Calling C From Fortran

Note the Fortran example below and how it calls C routines:

call initscr() call clear() . . . call move(x, y) . . . call
refresh() call endwin() end

…where x and y are integers specifying the new coordinates.

Calling Curses from Fortran

If you were calling the ‘curses’ routine ‘move()’, you might do
something like this:

The C source file contains the interface routine to the ‘curses’
library function ‘move()’, along with the other C functions that
provide an interface to the some other ‘curses’ functions:

#include

initscr_() { initscr(); }

clear_() { clear(); }

move_(x, y) int *x, y; / These are pointers */ { move(*x,
*y); }

refresh_() { refresh(); }

endwin_() { endwin(); }

The routines are compiled by using these commands:

cc -c curses.c f77 test.f curses.o -lcurses -ltermcap

If you are using macros defined in /usr/include/curses.h in your
Fortran file, be warned that they assume conventions of the C
language. Be aware that this may affect the results you obtain when
using them in Fortran.

from
https://engineering.purdue.edu/ECN/Support/KB/Docs/CallingCFromFortran