Alberto Águeda Maté writes:

 > I am looking for a (as much as possible) generic and portable way
 > to make system calls in whichever platform and using whichever
 > compiler.

There ain't no such animal. The best you can do is to isolate the
functionality to a small module that you can then port to various
systems. Most compilers have something, but the details do vary.

Hmm. On first reading, I was thinking you were talking about
just acessing a system shell. But on rereading, I think you are
talking about general system calls. Heck, it isn't even standardized
what system calls exist, much less how to access them from Fortran.

There is a standard (several of them :-)) for what system calls exist.
One such standard is the Posix one. But just because something is
standardized doesn't necessarily make it particularly portable. The
number of platforms and compilers where you can actually use the
Posix system calls from Fortran is not impressively high....in fact,
it is pretty low. (I'm including only cases where it is safe to
assume that the necessary libraries are actually installed on most
systems, not cases where it would in theory be possible for a user
to build and install the necessary libraries - that's not usually
very helpful if you are trying to ship a Fortran application to
users.)

For example, if you assume Posix, you just ruled out Windows systems,
which last time I checked had a pretty significant market share. :-)
Perhaps your apps don't need to port to Windows, but when someone
says they want portability, my first assumption is that they mean it.
If you want portability within a restricted set of platforms, that
can be a very different matter.

 > System calls are standarized for Tru64 Unix and Linux...

No, they are not. This kind of thing depends on the particular
compiler. It is *NOT* just a function of the platform. For
example, there are many Fortran compilers for linux and they do *NOT*
all do it the same way. There are probably a lot fewer options
for Tru64, though I think the number is probably still > 1.

Note that the C interop feature of f2k should greatly improve the
ability to call C functions (including C system functions) from
Fortran, but

1. F2k is still in the future...and quite a ways in the future until
   it is available on pretty much all platforms. Some people
   seriously question whether it will ever be that widely available;
   I hope so, but nobody really yet knows for sure.

2. In any case, that still won't solve the problem of the system
   functions themselves varying from one system to another.

 > In any case, would there be any standard way in F90 to ask for the
 > platform under which it is running and the compiler that was used
 > for its compilation?

No. Nothing even close for that one. You'd find it a *LOT* easier
to just embed the information in your build process, even if by
manually entering it into some small include file or preprocessor
macro, rather than trying to work out anything even half portable
in terms of a run-time query. Any such run-time query is likely
to require a lot of customization to particular systems, which sort
of defeats the point.

--
Richard Maine | Good judgment comes from experience;
[log in to unmask] | experience comes from bad judgment.
                             | -- Mark Twain