Home Man
Today's Posts

Linux & Unix Commands - Search Man Pages

OpenSolaris 2009.06 - man page for lfcompile64 (opensolaris section 5)

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

       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

       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 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 environ-
       ment, 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  envi-

       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

   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 head-

	   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  invok-
       ing  the  getconf  utility  with one of the arguments listed in the table above. The addi-
       tional 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`

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

SunOS 5.11				   26 Jan 1998				   lfcompile64(5)

All times are GMT -4. The time now is 05:19 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
Show Password