lfcompile64(5)                                          Standards, Environments, and Macros                                         lfcompile64(5)

NAME

       lfcompile64 - transitional compilation environment

DESCRIPTION

       All 64-bit applications can manipulate large files by default. The transitional interfaces described on this page can be used by 32-bit and
       64-bit applications to manipulate large files.

       In the transitional compilation environment, explicit 64-bit functions, structures, and types are added to  the   API.  Compiling  in  this
       environment allows both 32-bit and 64-bit applications to access files whose size is greater than or equal to 2 Gbyte ( 2**31 bytes).

       The transitional compilation environment exports all the explicit 64-bit functions (xxx64()) and types in addition to all the regular func-
       tions (xxx()) and types. Both xxx() and xxx64() functions are available to the program source.  A 32-bit application must use  the  xxx64()
       functions in order to access large files. See the lf64(5) manual page for a complete listing of the 64-bit transitional interfaces.

       The  transitional  compilation environment differs from the large file compilation environment, wherein the underlying interfaces are bound
       to 64-bit functions, structures, and types. An application compiled in the large file compilation environment is  able  to  use  the  xxx()
       source  interfaces  to access both large and small files, rather than having to explicitly utilize the transitional xxx64() interface calls
       to access large files. See the lfcompile(5) manual page for more information regarding the large file compilation environment.

       Applications may combine objects produced in the large file compilation environment with objects produced in the  transitional  compilation
       environment,  but  must be careful with respect to interoperability between those objects. Applications should not declare global variables
       of types whose sizes change between  compilation environments.

       For applications that do not wish to conform to the POSIX or X/Open specifications, the 64-bit transitional  interfaces  are  available  by
       default.  No compile-time flags need to be set.

   Access to Additional Large File Interfaces
       Applications  that wish to access the transitional interfaces as well as the POSIX or X/Open specification-conforming interfaces should use
       the following compilation methods and set whichever feature test macros are appropriate  to  obtain  the  desired  environment  (see  stan-
       dards(5)).

         o  Set the compile-time flag _LARGEFILE64_SOURCE to 1 before including any headers.

         o  Use the getconf(1) command with one or more of the following arguments:

       +------------------+----------------------------------------+
       |    argument      |                purpose                 |
       |LFS64_CFLAGS      | obtain  compilation flags necessary to |
       |                  | enable  the  transitional  compilation |
       |                  | environment                            |
       |LFS64_LDFLAGS     | obtain link editor options             |
       |LFS64_LIBS        | obtain link library names              |
       |LFS64_LINTFLAGS   | obtain lint options                    |
       +------------------+----------------------------------------+

EXAMPLES

       In  the  following examples, the transitional compilation environment is accessed by invoking the getconf utility with one of the arguments
       listed in the table above. The additional large file interfaces are accessed either by specifying -D_LARGEFILE64_SOURCE or by invoking  the
       getconf utility with the arguments listed above.

       The  example that uses the form of command substitution specifying the command within parentheses preceded by a dollar sign can be executed
       only in a POSIX-conforming shell such as the Korn Shell (see ksh(1)). In a shell that is not POSIX-conforming, such  as  the  Bourne  Shell
       (see sh(1)) and the C Shell (see csh(1)), the command must be enclosed within grave accent marks.

       Example 1: An example of compiling a program using transitional  interfaces such as lseek64() and fopen64():

       $ c89 -D_LARGEFILE64_SOURCE        
             $(getconf LFS64_CFLAGS) a.c  
             $(getconf LFS64_LDFLAGS)     
             $(getconf LFS64_LIBS)

       Example 2: An example of running lint on a program using transitional interfaces:

       % lint -D_LARGEFILE64_SOURCE        
             `getconf LFS64_LINTFLAGS` ... 
             `getconf LFS64_LIBS`

SEE ALSO

       getconf(1), lseek(2), fopen(3C), lf64(5), standards(5)

SunOS 5.10                                                          26 Jan 1998                                                     lfcompile64(5)