lfcompile64(7) 맨 페이지 - 윈디하나의 솔라나라


맨 페이지 이름


Standards, Environments, Macros, Character Sets, and miscellany

       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. Compiling in this  environ‐
       ment  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(7)  man‐
       ual 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(7)  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 envi‐
       ronment, 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 standards(7)).

           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

                  tab()  box;  cw(1.67i) |cw(3.83i) lw(1.67i) |lw(3.83i) argu‐
                  mentpurpose _ LFS64_CFLAGST{ obtain compilation flags neces‐
                  sary  to  enable the transitional compilation environment T}
                  LFS64_LDFLAGSobtain  link  editor  options  LFS64_LIBSobtain
                  link library names LFS64_LINTFLAGSobtain 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 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   inter‐
       faces 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

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

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

Oracle Solaris 11.4               27 Jun 2012                   lfcompile64(7)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.