lfcompile64 man page on SmartOS

Man page or keyword search:  
man Server   16655 pages
apropos Keyword Search (all sections)
Output format
SmartOS logo
[printable version]


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

       │   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
       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), lf64(5), standards(5)

				 Jan 26, 1998			LFCOMPILE64(5)

List of man pages available for SmartOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net