Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
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 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(5)  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  in-
       terfaces	 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 re-
       garding 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 de-
       fault.  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(5)).

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

	 o  Use	the getconf(1) command with one	or more	of the following argu-

       |    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 additional large file interfaces are ac-
       cessed 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),	lf64(5), standards(5)

SunOS 5.10			  26 Jan 1998			lfcompile64(5)


Want to link to this manual page? Use this URL:

home | help