Click above to get retro games delivered to your door ever month!

 _fortran                Fortran Calling Sequence Modifier

    MS-Fortran uses a different calling sequence than MS-C. MS-Fortran
    passes function arguments left to right, and does not allow variable-
    length argument lists. The called function has the responsibility for
    removing the arguments from the stack, rather than having the caller
    do so when control returns.

    The Fortran calling sequence can be generated from C functions in two
    ways:  use the compile-time switch /Gc, which makes the Fortran
    sequence the default for all enclosed calls and function definitions;
    or explicitly override the standard C calling sequence by using the
    _fortran keyword on specific function declarations or definitions.

    When C generates a function call, by default, it adds a leading
    underscore to the function name and declares that function as an
    external.  It also preserves the casing of the name.  When the
    _fortran keyword is used, the underscore is not added and the name is
    converted to all uppercase to be compatible with MS-Fortran compiler
    code generation. The same occurs when _fortran is used with external
    variables.

      Notes:    If a C function calls an MS-Fortran routine, the
                declaration of the Fortran function must include the
                _fortran keyword (or /Gc must be in effect) so that the C
                compiler does not clean up the call stack on return from
                the Fortran routine.  If the _fortran keyword is omitted
                (and the /Gc is not used either), both the caller and the
                callee will pop the stack, handing you an error.  On the
                other hand, to ensure that an MS-C function being called
                from MS-Fortran cleans up its own call stack, you must
                use the _fortran keyword in the MS-C function's definition
                (or use the /Gc switch).

                If /Gc has been used and you wish to call a C function,
                you must declare that function using _cdecl. Note that
                when extended keyword recognition is enabled, all of the
                standard headers declare their library routines to have
                the _cdecl attribute, so it is not necessary for you to do
                this (provided you #include the appropriate header before
                calling the library function).

                Since the MS-Fortran and MS-Pascal calling/return
                sequences are identical, the _fortran and pascal keywords
                can be interchanged.  Logically, however, it makes sense
                to use _fortran when you are calling an MS-Fortran routine
                and pascal when you are calling MS-Pascal code.

                It is possible to generate MS-Fortran style calls and
                never call or be called by a Fortran routine.  The
                advantage of this is that such calls are generally more
                efficient than C calls. This is because stack cleanup is
                only done in one place--the called routine--rather than
                every place from which the function is called.

   -------------------------------- Example ---------------------------------

           int _fortran fp(a, b, c)
           int a;
           long b;
           double c;
           {
                ...
           }

           int _fortran table[100];

           main()
           {
                extern int _fortran fp();
                int i;

                i = fp(1, 2L, 1.2);
           }