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

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
Intro(3)                                                              Intro(3)

NAME
       Intro, intro - introduction to functions and libraries

       This section describes functions found in various Solaris libraries,
       other than those functions described in Section 2 of this manual that
       directly invoke UNIX system primitives. Function declarations can be
       obtained from the #include files indicated on each page. Pages are
       grouped by library and are identified by the library name (or an
       abbreviation of the library name) after the section number. Collections
       of related libraries are grouped into six volumes as described below. A
       seventh volume (listed first) contains pages describing the contents of
       each shared library and each header used by the functions, macros, and
       external variables described in the remaining five volumes.

   Library Interfaces and Headers
       This volume describes the contents of each shared library and each
       header used by functions, macros, and external variables described in
       the remaining six volumes.

       (3LIB)
                       The libraries described in this section are implemented
                       as shared objects.

                       Descriptions of shared objects can include a definition
                       of the global symbols that define the shared objects'
                       public interface, for example SUNW_1.1. Other
                       interfaces can exist within the shared object, for
                       example SUNWprivate.1.1. The public interface provides
                       a stable, committed set of symbols for application
                       development. The private interfaces are for internal
                       use only, and could change at any time.

       (3LIBUCB)
                       The SunOS/BSD Compatibility libraries described in this
                       section are implemented as a shared object. See (3LIB)
                       above.

       (3HEAD)
                       The headers described in this section are used by
                       functions, macros, and external variables. Headers
                       contain function prototypes, definitions of symbolic
                       constants, common structures, preprocessor macros, and
                       defined types. Each function described in the remaining
                       five volumes specifies the headers that an application
                       must include in order to use that function. In most
                       cases only one header is required. These headers are
                       present on an application development system; they do
                       have to be present on the target execution system.

   Basic Library Functions
       The functions described in this volume are the core C library functions
       that are basic to application development.

       (3C)
                       These functions, together with those of Section 2,
                       constitute the standard C library, libc, which is
                       automatically linked by the C compilation system. The
                       standard C library is implemented as a shared object,
                       libc.so.  See libc(3LIB) and the "C Compilation System"
                       chapter of the ANSI C Programmer's Guide for a
                       discussion. Some functions behave differently in
                       standard-conforming environments. This behavior is
                       noted on the individual manual pages. See standards(5).

                       The libpthread and libthread libraries are filter
                       libraries on libc that are used for building
                       multithreaded applications: libpthread implements the
                       POSIX (see standards(5)) threads interface, whereas
                       libthread implements the Solaris threads interface. See
                       MULTITHREADED APPLICATIONS, below.

       (3C_DB)
                       These functions constitute the threads debugging
                       library, libc_db. This library is implemented as a
                       shared object, libc_db.so, but is not automatically
                       linked by the C compilation system. Specify -lc_db on
                       the cc command line to link with this library. See
                       libc_db(3LIB).

       (3MALLOC)
                       These functions constitute the various memory
                       allocation libraries: libmalloc, libbsdmalloc,
                       libmapmalloc, libmtmalloc, and libumem. Each of these
                       libraries is implemented as a shared object
                       (libmalloc.so, libbsdmalloc.so, libmapmalloc.so,
                       libmtmalloc.so, and libumem.so). These libraries are
                       not automatically linked by the C compilation system.
                       Specify -lmalloc, -lbsdmalloc, -lmapmalloc, -lmtmalloc,
                       and -lumem to link with, respectively, libmalloc,
                       libbsdmalloc, libmapmalloc, libmtmalloc, and libumem.
                       See libmalloc(3LIB), libbsdmalloc(3LIB),
                       libmapmalloc(3LIB), libmtmalloc(3LIB), and
                       libumem(3LIB).

       (3UCB)
                       These functions constitute the source compatibility
                       (with BSD functions) library. It is implemented as a
                       shared object, libucb.so, but is not automatically
                       linked by the C compilation system. Specify -lucb on
                       the cc command line to link with this library, which is
                       located in the /usr/ucb subdirectory. Headers for this
                       library are located within /usr/ucbinclude. See
                       libucb(3LIBUCB).

   Networking Library Functions
       The functions described in this volume comprise the various networking
       libraries.

       (3GSS)
                       The functions in this library are the routines that
                       comprise the generic security services API library.
                       This library is implemented as a shared object,
                       libgss.so, but it is not automatically linked by the C
                       compilation system. Specify -lgss on the cc command
                       line to link with this library. See libgss(3LIB).

       (3LDAP)
                       These functions constitute the lightweight directory
                       access protocol library, libldap. This library is
                       implemented as a shared object, libldap.so, but is not
                       automatically linked by the C compilation system.
                       Specify -lldap on the cc command line to link with this
                       library. See ldap(3LDAP).

       (3NSL)
                       These functions constitute the network service library,
                       libnsl. This library is implemented as a shared object,
                       libnsl.so, but is not automatically linked by the C
                       compilation system. Specify -lnsl on the cc command
                       line to link with this library. See libnsl(3LIB).

                       Many base networking functions are also available in
                       the X/Open networking interfaces library, libxnet. See
                       section (3XNET) below for more information on the
                       libxnet interfaces.

       (3RESOLV)
                       These functions constitute the resolver library,
                       libresolv. This library is implemented as a shared
                       object, libresolv.so, but is not automatically linked
                       by the C compilation system. Specify -lresolv on the cc
                       command line to link with this library. See
                       libresolv(3LIB).

       (3RPC)
                       These functions constitute the remote procedure call
                       libraries, librpcsvc and librpcsoc. The latter is
                       provided for compatibility only; new applications
                       should not link to it. Both libraries are implemented
                       as shared objects, librpcsvc.so and librpcsoc.so,
                       respectively. Neither library is automatically linked
                       by the C compilation system. Specify -lrpcsvc or
                       -lrpcsoc on the cc command line to link with these
                       libraries. See librpcsvc(3LIB) and librpcsoc(3LIBUCB).

       (3SASL)
                       These functions constitute the simple authentication
                       and security layer library, libsasl. This library is
                       implemented as a shared object, libsasl.so, but it is
                       not automatically linked by the C compilation system.
                       Specify -lsasl on the cc command line to link with this
                       library. See libsasl(3LIB).

       (3SLP)
                       These functions constitute the service location
                       protocol library, libslp. This library is implemented
                       as a shared object, libslp.so, but it is not
                       automatically linked by the C compilation system.
                       Specify -lslp on the cc command line to link with this
                       library. See libslp(3LIB).

       (3SOCKET)
                       These functions constitute the sockets library,
                       libsocket. This library is implemented as a shared
                       object, libsocket.so, but is not automatically linked
                       by the C compilation system. Specify -lsocket on the cc
                       command line to link with this library. See
                       libsocket(3LIB).

       (3XNET)
                       These functions constitute X/Open networking interfaces
                       which comply with the X/Open CAE Specification,
                       Networking Services, Issue 4 (September, 1994). This
                       library is implemented as a shared object, libxnet.so,
                       but is not automatically linked by the C compilation
                       system. Specify -lxnet on the cc command line to link
                       with this library. See libxnet(3LIB) and standards(5)
                       for compilation information.

       Under all circumstances, the use of the Sockets API is recommended over
       the XTI and TLI APIs. If portability to other XPGV4v2 (see
       standards(5)) systems is a requirement, the application must use the
       libxnet interfaces. If portability is not required, the sockets
       interfaces in libsocket and libnsl are recommended over those in
       libxnet. Between the XTI and TLI APIs, the XTI interfaces (available
       with libxnet) are recommended over the TLI interfaces (available with
       libnsl).

   Curses Library Functions
       The functions described in this volume comprise the libraries that
       provide graphics and character screen updating capabilities.

       (3CURSES)
                       The functions constitute the following libraries:

                       libcurses
                                       These functions constitute the curses
                                       library, libcurses. This library is
                                       implemented as a shared object,
                                       libcurses.so, but is not automatically
                                       linked by the C compilation system.
                                       Specify -lcurses on the cc command line
                                       to link with this library. See
                                       libcurses(3LIB).

                       libform
                                       These functions constitute the forms
                                       library, libform. This library is
                                       implemented as a shared object,
                                       libform.so, but is not automatically
                                       linked by the C compilation system.
                                       Specify -lform on the cc command line
                                       to link with this library. See
                                       libform(3LIB).

                       libmenu
                                       These functions constitute the menus
                                       library, libmenu. This library is
                                       implemented as a shared object,
                                       libmenu.so, but is not automatically
                                       linked by the C compilation system.
                                       Specify -lmenu on the cc command line
                                       to link with this library. See
                                       libmenu(3LIB).

                       libpanel
                                       These functions constitute the panels
                                       library, libpanel. This library is
                                       implemented as a shared object,
                                       libpanel.so, but is not automatically
                                       linked by the C compilation system.
                                       Specify -lpanel on the cc command line
                                       to link with this library. See
                                       libpanel(3LIB).

       (3PLOT)
                       These functions constitute the grapnics library,
                       libplot. This library is implemented as a shared
                       object, libplot.so, but is not automatically linked by
                       the C compilation system. Specify -lplot on the cc
                       command line to link with this library. See
                       libplot(3LIB).

       (3XCURSES)
                       These functions constitute the X/Open curses library,
                       located in /usr/xpg4/lib/libcurses.so. This library
                       provides a set of internationalized functions and
                       macros for creating and modifying input and output to a
                       terminal screen.  Included in this library are
                       functions for creating windows, highlighting text,
                       writing to the screen, reading from user input, and
                       moving the cursor. X/Open Curses is designed to
                       optimize screen update activities. The X/Open Curses
                       library conforms fully with Issue 4 of the X/Open
                       Extended Curses specification.  See
                       libcurses(3XCURSES).

   Realtime Library Functions
       The functions described in this volume constitute the realtime
       libraries.

       (3AIO)
                       These functions constitute the asynchronous I/O
                       library, liaio. This library is implemented as a shared
                       object, libaio.so, but is not automatically linked by
                       the C compilation system. Specify -laio on the cc
                       command line to link with this library. See
                       libaio(3LIB).

       (3RT)
                       These functions constitute the POSIX.4 realtime
                       library, librt. It is implemented as a shared object,
                       librt.so, but is not automatically linked by the C
                       compilation system. Specify -lrt on the cc command line
                       to link with this library. Note that the former name
                       for this library, libposix4, is maintained for backward
                       compatibility but should be avoided. See librt(3LIB).

   Extended Library Functions
       The functions described in this volume comprise various specialized
       libraries that are not limited to the following:

       (3BSM)
                       These functions constitute the basic security library,
                       libbsm. This library is implemented as a shared object,
                       libbsm.so, but is not automatically linked by the C
                       compilation system. Specify -lbsm on the cc command
                       line to link with this library. See libbsm(3LIB).

       (3CFGADM)
                       These functions constitute the configuration
                       administration library, libcfgadm. This library is
                       implemented as a shared object, libcfgadm.so, but is
                       not automatically linked by the C compilation system.
                       Specify -lcfgadm on the cc command line to link with
                       this library. See libcfgadm(3LIB).

       (3CONTRACT)
                       These functions constitute the contract management
                       library, libcontract. This library is implemented as a
                       shared object, libcontract.so, but is not automatically
                       linked by the C compilation system. Specify -lcontract
                       on the cc command line to link with this library. See
                       libcontract(3LIB).

       (3CPC)
                       These functions constitute the CPU performance counter
                       library, libcpc, and the process context library,
                       libpctx. These libraries are implemented as shared
                       objects, libcpc.so and libpctx.so, respectively, but
                       are not automatically linked by the C compilation
                       system. Specify -lcpc or -lpctx on the cc command line
                       to link with these libraries. See libcpc(3LIB) and
                       libpctx(3LIB).

       (3DAT)
                       These functions constitute the direct access transport
                       library, libdat. This library is implemented as a
                       shared object, libdat.so, but is not automatically
                       linked by the C compilation system. Specify -ldat on
                       the cc command line to link with this library. See
                       libdat(3LIB).

       (3DEVID)
                       These functions constitute the device ID library,
                       libdevid. This library is implemented as a shared
                       object, libdevid.so, but is not automatically linked by
                       the C compilation system. Specify -ldevid on the cc
                       command line to link with this library. See
                       libdevid(3LIB).

       (3DEVINFO)
                       These functions constitute the device information
                       library, libdevinfo. This library is implemented as a
                       shared object, libdevinfo.so, but is not automatically
                       linked by the C compilation system. Specify -ldevinfo
                       on the cc command line to link with this library. See
                       libdevinfo(3LIB).

       (3DMI)
                       These functions constitute the DMI libraries, libdmi,
                       libdmici, and libdmimi. These libraries are implemented
                       as shared objects, libdmi.so, libdmici.so, and
                       libdmimi.so, respectively, but are not automatically
                       linked by the C compilation system. Specify -ldmi,
                       -ldmici, or -ldmimi on the cc command line to link with
                       these libraries. See libdmi(3LIB), libdmici(3LIB), and
                       libdmimi(3LIB).

       (3ELF)
                       These functions constitute the ELF access library,
                       libelf, (Extensible Linking Format). This library
                       provides the interface for the creation and analyses of
                       "elf" files; executables, objects, and shared objects.
                       libelf is implemented as a shared object, libelf.so,
                       but is not automatically linked by the C compilation
                       system. Specify -lelf on the cc command line to link
                       with this library. See libelf(3LIB).

       (3EXACCT)
                       These functions constitute the extended accounting
                       access library, libexacct, and the project database
                       access library, libproject. These libraries are
                       implemented as shared objects, libexacct.so and
                       libproject.so, respectively, but are not automatically
                       linked by the C compilation system. Specify -lexacct or
                       -lproject on the cc command line to link with these
                       libraries. See libexacct(3LIB) and libproject(3LIB).

       (3GEN)
                       These functions constitute the string pattern-matching
                       and pathname manipulation library, libgen. This library
                       is implemented as a shared object, libgen.so, but is
                       not automatically linked by the C compilation system.
                       Specify -lgen on the cc command line to link with this
                       library. See libgen(3LIB).

       (3HBAAPI)
                       These functions constitute the common fibre channel HBA
                       information library, libhbaapi. This library is
                       implemented as a shared object, libhbaapi.so, but is
                       not automatically linked by the C compilation system.
                       Specify -lhbaapi on the cc command line to link with
                       this library. See libhbaapi(3LIB).

       (3KSTAT)
                       These functions constitute the kernel statistics
                       library, which is implemented as a shared object,
                       libkstat.so, but is not automatically linked by the C
                       compilation system. Specify -lkstat on the cc command
                       line to link with this library. See libkstat(3LIB).

       (3KVM)
                       These functions allow access to the kernel's virtual
                       memory library, which is implemented as a shared
                       object, libkvm.so, but is not automatically linked by
                       the C compilation system. Specify -lkvm on the cc
                       command line to link with this library. See
                       libkvm(3LIB).

       (3LAYOUT)
                       These functions constitute the layout service library,
                       which is implemented as a shared object, liblayout.so,
                       but is not automatically linked by the C compilation
                       system. Specify -llayout on the cc command line to link
                       with this library. See liblayout(3LIB).

       (3LGRP)
                       These functions constitute the locality group library,
                       which is implemented as a shared object, liblgrp.so,
                       but is not automatically linked by the C compilation
                       system. Specify -llgrp on the cc command line to link
                       with this library. See liblgrp(3LIB).

       (3M)
                       These functions constitute the mathematical library,
                       libm. This library is implemented as a shared object,
                       libm.so, but is not automatically linked by the C
                       compilation system. Specify -lm on the cc command line
                       to link with this library. See libm(3LIB).

       (3MAIL)
                       These functions constitute the user mailbox management
                       library, libmail. This library is implemented as a
                       shared object, libmail.so, but is not automatically
                       linked by the C compilation system. Specify -lmail on
                       the cc command line to link with this library. See
                       libmail(3LIB).

       (3MP)
                       These functions constitute the integer mathematical
                       library, libmp. This library is implemented as a shared
                       object, libmp.so, but is not automatically linked by
                       the C compilation system. Specify -lmp on the cc
                       command line to link with this library. See
                       libmp(3LIB).

       (3MVEC)
                       These functions constitute the vector mathematical
                       library, libmvec. This library is implemented as a
                       shared object, libmvec.so, but is not automatically
                       linked by the C compilation system. Specify -lmvec on
                       the cc command line to link with this library. See
                       libmvec(3LIB).

       (3NVPAIR)
                       These functions constitute the name-value pair library,
                       libnvpair. This library is implemented as a shared
                       object, libnvpair.so, but is not automatically linked
                       by the C compilation system. Specify -lnvpair on the cc
                       command line to link with this library. See
                       libnvpair(3LIB).

       (3PAM)
                       These functions constitute the pluggable uuthentication
                       module library, libpam. This library is implemented as
                       a shared object, libpam.so, but is not automatically
                       linked by the C compilation system. Specify -lpam on
                       the cc command line to link with this library. See
                       libpam(3LIB).

       (3PICL)
                       These functions constitute the PICL library, libpicl.
                       This library is implemented as a shared object,
                       libpicl.so, but is not automatically linked by the C
                       compilation system. Specify -lpicl on the cc command
                       line to link with this library. See libpicl(3LIB) and
                       libpicl(3PICL).

       (3PICLTREE)
                       These functions constitute the PICL plug-in library,
                       libpicltree. This library is implemented as a shared
                       object, libpicltree.so, but is not automatically linked
                       by the C compilation system. Specify -lpicltree on the
                       cc command line to link with this library. See
                       libpicltree(3LIB) and libpicltree(3PICLTREE).

       (3POOL)
                       These functions constitute the pool configuration
                       manipulation library, libpool. This library is
                       implemented as a shared object, libpool.so, but is not
                       automatically linked by the C compilation system.
                       Specify -lpool on the cc command line to link with this
                       library. See libpool(3LIB).

       (3PROJECT)
                       These functions constitute the project database access
                       library, libproject. This library is implemented as a
                       shared object, libproject.so, but is not automatically
                       linked by the C compilation system. Specify -lproject
                       on the cc command line to link with this library. See
                       libproject(3LIB).

       (3RSM)
                       These functions constitute the remote shared memory
                       library, librsm. This library is implemented as a
                       shared object, librsm.so, but is not automatically
                       linked by the C compilation system. Specify -lrsm on
                       the cc command line to link with this library. See
                       librsm(3LIB).

       (3SCF)
                       These functions constitute the object-caching memory
                       allocation library, libscf. This library is implemented
                       as a shared object, libscf.so, but is not automatically
                       linked by the C compilation system. Specify -lscf on
                       the cc command line to link with this library. See
                       libscf(3LIB).

       (3SEC)
                       These functions constitute the file access control
                       library, libsec. This library is implemented as a
                       shared object, libsec.so, but is not automatically
                       linked by the C compilation system. Specify -lsec on
                       the cc command line to link with this library. See
                       libsec(3LIB).

       (3SECDB)
                       These functions constitute the security attributes
                       database library, libsecdb. This library is implemented
                       as a shared object, libsecdb.so, but is not
                       automatically linked by the C compilation system.
                       Specify -lsecdb on the cc command line to link with
                       this library. See libsecdb(3LIB).

       (3SMARTCARD)
                       These functions constitute the smartcard library,
                       libsmartcard. This library is implemented as a shared
                       object, libsmartcard.so, but is not automatically
                       linked by the C compilation system. Specify -lsmartcard
                       on the cc command line to link with this library. See
                       libsmartcard(3LIB).

       (3SNMP)
                       These functions constitute the SNMP libraries,
                       libssagent and libssasnmp. These libraries are
                       implemented as shared objects, libssagent.so and
                       libssasnmp.so, respectively, but are not automatically
                       linked by the C compilation system. Specify -lssagent
                       or -lssasnmp on the cc command line to link with these
                       libraries. See libssagent(3LIB) and libssasnmp(3LIB).

       (3SYSEVENT)
                       These functions constitute the system event library,
                       libsysevent. This library is implemented as a shared
                       object, libsysevent.so, but is not automatically linked
                       by the C compilation system. Specify -lsysevent on the
                       cc command line to link with this library. See
                       libsysevent(3LIB).

       (3TECLA)
                       These functions constitute the interactive command-line
                       input library, libtecla. This library is implemented as
                       a shared object, libtecla.so, but is not automatically
                       linked by the C compilation system. Specify -ltecla on
                       the cc command line to link with this library. See
                       libtecla(3LIB).

       (3TNF)
                       These functions constitute the TNF libraries, libtnf,
                       libtnfctl, and libtnfprobe. These libraries are
                       implemented as shared objects, libtnf.so, libtnfctl.so,
                       and libtnfprobe.so, respectively, but are not
                       automatically linked by the C compilation system.
                       Specify -ltnf, -ltnfctl, or -ltnfprobe on the cc
                       command line to link with these libraries. See
                       libtnfctl(3TNF) and libtnfctl(3LIB).

       (3UUID)
                       These functions constitute the universally unique
                       identifier library, libuuid. This library is
                       implemented as a shared object, libuuid.so, but is not
                       automatically linked by the C compilation system.
                       Specify -luuid on the cc command line to link with this
                       library. See libuuid(3LIB).

       (3VOLMGT)
                       These functions constitute the volume management
                       library, libvolmgt. This library is implemented as a
                       shared object, libvolmgt.so, but is not automatically
                       linked by the C compilation system. Specify -lvolmgt on
                       the cc command line to link with this library. See
                       libvolmgt(3LIB).

       (3WSREG)
                       These functions constitute the product install registry
                       library, libwsreg. This library is implemented as a
                       shared object, libwsreg.so, but is not automatically
                       linked by the C compilation system. Specify -lwsreg on
                       the cc command line to link with this library. See
                       libwsreg(3LIB).

   Multimedia Library Functions
       (3MLIB)
                       These functions constitute the mediaLib library,
                       libmlib. This library is implemented as a shared
                       object, libmlib.so, but is not automatically linked by
                       the C compilation system. Specify -lmlib on the cc
                       command line to link with this library. See
                       libmlib(3LIB).

DEFINITIONS
       A character is any bit pattern able to fit into a byte on the machine.
       In some international languages, however, a "character" might require
       more than one byte, and is represented in multi-bytes.

       The null character is a character with value 0, conventionally
       represented in the C language as \0. A character array is a sequence of
       characters. A null-terminated character array (a string) is a sequence
       of characters, the last of which is the null character. The null string
       is a character array containing only the terminating null character. A
       null pointer is the value that is obtained by casting 0 into a pointer.
       C guarantees that this value will not match that of any legitimate
       pointer, so many functions that return pointers return NULL to indicate
       an error. The macro NULL is defined in <stdio.h>. Types of the form
       size_t are defined in the appropriate headers.

MULTITHREADED APPLICATIONS
       Both POSIX threads and Solaris threads can be used within the same
       application. Their implementations are completely compatible with each
       other; however, only POSIX threads guarantee portability to other
       POSIX-conforming environments.

       The libpthread(3LIB) and libthread(3LIB) libraries are implemented as
       filters on libc(3LIB).

       When compiling a multithreaded application, the -mt option must be
       specified on the command line.

       There is no need for a multithreaded application to link with -lthread.
       An application must link with -lpthread only when POSIX semantics for
       fork(2) are desired. When an application is linked with -lpthread, a
       call to fork() assumes the behavior fork1(2) rather than the default
       behavior that forks all threads.

       When compiling a POSIX-conforming application, either the
       _POSIX_C_SOURCE or _POSIX_PTHREAD_SEMANTICS option must be specified on
       the command line. For POSIX.1c-conforming applications, define the
       _POSIX_C_SOURCE flag to be >= 199506L:

       cc -mt [ flag... ] file... -D_POSIX_C_SOURCE=199506L -lpthread

       For POSIX behavior with the Solaris fork() and fork1() distinction,
       compile as follows:

       cc -mt [ flag... ] file... -D_POSIX_PTHREAD_SEMANTICS

       For Solaris threads behavior, compile as follows:

       cc -mt [ flag... ] file...

       Unsafe interfaces should be called only from the main thread to ensure
       the application's safety.

       MT-Safe interfaces are denoted in the ATTRIBUTES section of the
       functions and libraries manual pages (see attributes(5)). If a manual
       page does not state explicitly that an interface is MT-Safe, the user
       should assume that the interface is unsafe.

REALTIME APPLICATIONS
       The environment variable LD_BIND_NOW must be set to a non-null value to
       enable early binding. Refer to the "When Relocations are Processed"
       chapter in  for additional information.

       INCDIR
                               usually /usr/include

       LIBDIR
                               usually either /lib or /usr/lib (32-bit) or
                               either /lib/64 or /usr/lib/64 (64-bit)

       LIBDIR/*.so
                               shared libraries

       ar(1), cc(1B), ld(1), fork(2), stdio(3C), attributes (5), standards(5)

       ANSI C Programmer's Guide

       For functions that return floating-point values, error handling varies
       according to compilation mode. Under the -Xt (default) option to cc,
       these functions return the conventional values 0, +-HUGE, or NaN when
       the function is undefined for the given arguments or when the value is
       not representable. In the -Xa and -Xc compilation modes, +-HUGE_VAL is
       returned instead of +-HUGE. (HUGE_VAL and HUGE are defined in math.h to
       be infinity and the largest-magnitude single-precision number,
       respectively.)

       None of the functions, external variables, or macros should be
       redefined in the user's programs. Any other name can be redefined
       without affecting the behavior of other library functions, but such
       redefinition might conflict with a declaration in an included header.

       The headers in INCDIR provide function prototypes (function
       declarations including the types of arguments) for most of the
       functions listed in this manual. Function prototypes allow the compiler
       to check for correct usage of these functions in the user's program.
       The lint program checker can also be used and will report discrepancies
       even if the headers are not included with #include statements.
       Definitions for Sections 2 and 3C are checked automatically. Other
       definitions can be included by using the -l option to lint. (For
       example, -lm includes definitions for libm.) Use of lint is highly
       recommended. See the lint chapter in Performance .

       Users should carefully note the difference between STREAMS and stream.
       STREAMS is a set of kernel mechanisms that support the development of
       network services and data communication drivers. It is composed of
       utility routines, kernel facilities, and a set of data structures.  A
       stream is a file with its associated buffering. It is declared to be a
       pointer to a type FILE defined in <stdio.h>.

       In detailed definitions of components, it is sometimes necessary to
       refer to symbolic names that are implementation-specific, but which are
       not necessarily expected to be accessible to an application program.
       Many of these symbolic names describe boundary conditions and system
       limits.

       In this section, for readability, these implementation-specific values
       are given symbolic names. These names always appear enclosed in curly
       brackets to distinguish them from symbolic names of other
       implementation-specific constants that are accessible to application
       programs by headers. These names are not necessarily accessible to an
       application program through a header, although they can be defined in
       the documentation for a particular system.

       In general, a portable application program should not refer to these
       symbolic names in its code. For example, an application program would
       not be expected to test the length of an argument list given to a
       routine to determine if it was greater than {ARG_MAX}.

                                  19 Jul 2005                         Intro(3)

NAME | DEFINITIONS | MULTITHREADED APPLICATIONS | REALTIME APPLICATIONS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=intro&sektion=3&manpath=SunOS+5.10>

home | help