Tribblix: manual page: lfcompile64.7

LFCOMPILE64(7) Standards, Environments, and Macros LFCOMPILE64(7)

NAME

lfcompile64 - transitional compilation environment

DESCRIPTION

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

EXAMPLES

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

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