lfcompile64 - transitional compilation environment


     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. Com-
     piling 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 functions (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

     Applications may combine objects produced in the large  file
     compilation environment with objects produced in the transi-
     tional compilation environment, but  must  be  careful  with
     respect  to interoperability between those objects. Applica-
     tions 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

  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 standards(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                   |


     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  addi-
     tional large file interfaces are accessed either by specify-
     ing -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 dol-
     lar 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  transi-
     tional  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`


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

Man(1) output converted with man2html