Distinguishing between a variable and a constant - fortran

Question

Okay, before I start: I know this is really bad. I'm asking for a hack for a situation that wouldn't have eventuated if there had been a design agreement that everyone followed. But here is my problem.
I have an enormous Fortran code base with an error reporting routine. The error reporting routine is only called if something weird happened, and it has an integer input: ErrorCode. Positive values mean errors and abort, negative values mean warnings and continue.
Here's my problem:
Some people have taken to call the error reporting function like this:
ErrorCode = -5
call error_report(ErrorCode)
if (ErrorCode /= 0) stop "Hey, you were supposed to reset ErrorCode"
I don't know whether there is any call to that error_report that actually expects a negative ErrorCode to be reset to 0. All I know is that the current implementation of error_report does this, and I don't want to change any functionality.
And other people make it easier on themselves:
call error_report(-5)
At the moment, in the routine, ErrorCode is not declared with any INTENT, just so that the code compiles. But of course this only means that whenever a warning is called in the second way, instead of displaying the warning and keeping working, the program segfaults.
I have neither the time nor the authority at the moment to clean up the code properly (normally I'd just set it to INTENT(INOUT) and then let the compiler tell me where I need to make changes. But this is not an option at the moment for a variety of reasons.)
Is there any way in which I could write a routine error_report that would satisfy both versions? Procedure Overloading? Some method to distinguish between a variable and a constant? Anything?

Answer 1

Here is an idea that should work on any *nix system... The main idea is that constant literals are compiled into the binary as symbols, whereas variables are not.
So if you are using ld for linking, it will insert a symbol _end at the final position (for both static and dynamic linking).
This you can (ab)use to check whether a given dummy argument has an address before or after _end. In case of a lower address, the actual argument is a constant, otherwise it is a (temporary) variable.
This, however requires some C code:
addr.c
int isConstant(int *x){
extern void *_end;
if ( (void *)x > (void *)&_end ) {
return 1; // Variable
} else {
return 0; // Constant
}
}
test.F90
program test
use,intrinsic :: ISO_C_Binding
interface
integer(C_INT) function isConstant(a) bind(C, name="isConstant")
use,intrinsic :: ISO_C_Binding
integer(C_INT), intent(in) :: a
end function
end interface
integer :: i
integer,parameter :: ii=2
i = 1
print *,isConstant(i)
print *,isConstant(1)
print *,isConstant((i))
print *,isConstant(ii)
end program
Compile it as
gfortran -Wall -Wextra test.F90 addr.c
It will give you:
./a.out
1
0
1
0
Note that I did not test this with Windows Tested on Windows using mingw. Use at your own risk.
Please note that the constant expression (i) is not definable as per Standard. However, it is created at runtime, and therefore not a symbol. This is apparent in the output.
However, in the context of the OP, I did not get a segfault when trying to assign it a value.