Import BSDDB 4.7.25 (as of svn r89086)
This commit is contained in:
Zachary Ware
532
docs_src/m4/m4.db
Normal file
532
docs_src/m4/m4.db
Normal file
@@ -0,0 +1,532 @@
|
||||
dnl $Id: m4.db,v 10.194 2008/01/23 21:15:45 sarette Exp $
|
||||
|
||||
include(m4/m4.init)
|
||||
include(m4/m4.html)
|
||||
include(m4/m4.flags)
|
||||
include(m4/m4.err)
|
||||
include(m4/m4.ret)
|
||||
ifelse(M4PRODUCT, XML, [include(m4/m4.xml)])
|
||||
include(m4/m4.links)
|
||||
ifelse(M4PRODUCT, XML, [include(m4/m4.xmllinks)])
|
||||
|
||||
dnl Product names
|
||||
define(m4_am, m4_db Data Store)
|
||||
define(m4_cam, m4_db Concurrent Data Store)
|
||||
define(m4_ha, m4_db High Availability)
|
||||
define(m4_tam, m4_db Transactional Data Store)
|
||||
define(m4_xml, m4_db XML)
|
||||
define(m4_sxml, BDB XML)
|
||||
|
||||
dnl Standards
|
||||
define(m4_ansic_name, [ANSI C X3.159-1989 (ANSI C)])
|
||||
define(m4_posix1_name, [IEEE/ANSI Std 1003.1 (POSIX)])
|
||||
|
||||
dnl m4_incextra --
|
||||
dnl API "includes". C/C++ have standard includes (although the
|
||||
dnl XML's header file includes the standard C++ header for you).
|
||||
dnl
|
||||
dnl $1: "XML" use the XML include rather than the C++ one.
|
||||
dnl else, if it's C/C++ it's a leading #define, it comes first.
|
||||
define(m4_incextra, [dnl
|
||||
ifelse(M4API, CXX_API, [dnl
|
||||
ifelse($1, XML, [m4_include(DbXml.hpp)], [$1
|
||||
m4_include(db_cxx.h)])],
|
||||
[$1
|
||||
m4_include(db.h)])])
|
||||
|
||||
dnl Build the reference, and append the word "method".
|
||||
dnl $1: name
|
||||
define(m4_refT, [m4_ref($1) method])
|
||||
|
||||
dnl Build the reference, and append the correct word "structure" or "object".
|
||||
dnl $1: name
|
||||
define(m4_refO, [m4_ref($1) ifelse(M4API, CXX_API, object, structure)])
|
||||
|
||||
dnl Some methods aren't available in C++.
|
||||
dnl $1: method
|
||||
define(m4_no_such_method, [dnl
|
||||
m4_p([The m4_refT($1) is not included in the m4_db C++ API.])
|
||||
m4_page_footer
|
||||
m4exit])
|
||||
define(m4_no_such_class, [dnl
|
||||
m4_p([The $1 class is not included in the m4_db C++ API.])
|
||||
m4_page_footer
|
||||
m4exit])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl OBJECT-IN-ALLOCATED MEMORY MACRO:
|
||||
dnl #1: the allocated object
|
||||
dnl ###################################################################
|
||||
define(m4_alloc, [m4_p([dnl
|
||||
$1 are stored in allocated memory. If application-specific allocation
|
||||
routines have been declared (see m4_ref(dbenv_set_alloc) for more
|
||||
information), they are used to allocate the memory; otherwise, the
|
||||
standard C library m4_manref(malloc, 3) is used. The caller is
|
||||
responsible for deallocating the memory. To deallocate the memory, free
|
||||
the memory reference; references inside the returned memory need not be
|
||||
individually freed.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl BULK GET MEMORY
|
||||
dnl ###################################################################
|
||||
define(m4_bulk_mem, [dnl
|
||||
The buffer to which the m4_arg(data) parameter refers must be provided
|
||||
from user memory (see m4_ref(DB_DBT_USERMEM)). The buffer must be at
|
||||
least as large as the page size of the underlying database, aligned for
|
||||
unsigned integer access, and be a multiple of 1024 bytes in size. If
|
||||
the buffer size is insufficient, then upon return from the call the size
|
||||
field of the m4_arg(data) parameter will have been set to an estimated
|
||||
buffer size, m4_err_mem_insufficient. (The size is an estimate as the
|
||||
exact size needed may not be known until all entries are read. It is
|
||||
best to initially provide a relatively large buffer, but applications
|
||||
should be prepared to resize the buffer as necessary and repeatedly call
|
||||
the method.)])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl DB_HOME/set_data_dir
|
||||
dnl #1: the function name
|
||||
dnl #2: "0" if DB_ENV function, "1" if DB function.
|
||||
dnl
|
||||
dnl Several DB_ENV/DB functions are affected by DB_HOME and the data
|
||||
dnl directory value.
|
||||
dnl ###################################################################
|
||||
define(m4_data_location, [m4_p([ifelse([$2], 0, [The ], [dnl
|
||||
If the database was opened within a database environment, the])
|
||||
environment variable m4_envvar(DB_HOME) may be used as the path of the
|
||||
database environment home.])
|
||||
m4_p([m4_ref($1) is affected by any database directory specified using
|
||||
the m4_refT(dbenv_set_data_dir), or by setting the "set_data_dir" string
|
||||
in the environment's m4_ref(DB_CONFIG) file.])])
|
||||
|
||||
dnl When the method has a corresponding DB_CONFIG file entry.
|
||||
dnl #1: method
|
||||
dnl #2: value
|
||||
dnl #3: matching string
|
||||
dnl #4: syntax
|
||||
dnl #5: "no" if doesn't overrule other configuration.
|
||||
define(m4_env_config, [m4_p([dnl
|
||||
The database environment's $2 may also be configured using the
|
||||
environment's m4_ref(DB_CONFIG) file. The syntax of the entry in that
|
||||
file is a single line with the string "$3", one or more whitespace
|
||||
characters, and $4.
|
||||
ifelse([$5], no,, [dnl
|
||||
Because the m4_ref(DB_CONFIG) file is read when the database environment
|
||||
is opened, it will silently overrule configuration done before that
|
||||
time.])])])
|
||||
|
||||
define(m4_env_flags, [dnl
|
||||
m4_idefz([use @environment constants in naming])
|
||||
m4_tag(m4_idef(DB_USE_ENVIRON), [dnl
|
||||
The m4_db process' environment may be permitted to specify information
|
||||
to be used when naming files; see m4_link(M4RELDIR/ref/env/naming,
|
||||
[m4_db File Naming]). Because permitting users to specify which files
|
||||
are used can create security problems, environment information will be
|
||||
used in file naming for all users only if the DB_USE_ENVIRON
|
||||
flag is set.])
|
||||
m4_tag(m4_idef(DB_USE_ENVIRON_ROOT), [dnl
|
||||
The m4_db process' environment may be permitted to specify information
|
||||
to be used when naming files; see m4_link(M4RELDIR/ref/env/naming,
|
||||
[m4_db File Naming]). Because permitting users to specify which files
|
||||
are used can create security problems, if the
|
||||
DB_USE_ENVIRON_ROOT flag is set, environment information will
|
||||
be used for file naming only for users with appropriate permissions (for
|
||||
example, users with a user-ID of 0 on UNIX systems).])])
|
||||
|
||||
define(m4_env_flags_any, [m4_p([dnl
|
||||
The m4_ref($1) flag may be used to configure m4_db at any time during
|
||||
the life of the application.])])
|
||||
|
||||
define(m4_env_flags_open, [m4_p([dnl
|
||||
The m4_ref($1) flag may be used to configure m4_db only $2 the
|
||||
m4_refT(dbenv_open) is called.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl DOCUMENT AN UNDERLYING FUNCTION:
|
||||
dnl m4_underfunc --
|
||||
dnl #1 function name
|
||||
dnl #2 underlying function name
|
||||
dnl #3 utility name
|
||||
dnl ###################################################################
|
||||
define(m4_underfunc, [dnl
|
||||
ifelse(M4API, C_API, [m4_p([dnl
|
||||
The m4_refT($1) is the underlying method used by the m4_ref($3) utility.
|
||||
See the m4_ref($3) utility source code for an example of using m4_ref($2)
|
||||
in a m4_posix1_name environment.])])
|
||||
ifelse(M4API, UTILITY, [m4_p([dnl
|
||||
The m4_refT($1) is the underlying method used by the m4_ref($3) utility.
|
||||
See the m4_ref($3) utility source code for an example of using m4_ref($2)
|
||||
in a m4_posix1_name environment.])])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl METHOD MODIFIES DB_ENV, NOT DB
|
||||
dnl m4_really_dbenv --
|
||||
dnl #1 DB function name
|
||||
dnl #2 DB_ENV function name
|
||||
dnl ###################################################################
|
||||
define(m4_really_dbenv, [m4_p([dnl
|
||||
For m4_ref(Db) handles opened inside of m4_db environments, calling the
|
||||
m4_refT($1) affects the entire environment and is equivalent to calling
|
||||
the m4_refT($2).])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Jump functions
|
||||
dnl m4_ansi_func ANSI C function replacement.
|
||||
dnl m4_posix_func POSIX standard
|
||||
dnl m4_ret_internal Return value.
|
||||
dnl #1: function name
|
||||
dnl ###################################################################
|
||||
define(m4_ansi_func, [m4_p([dnl
|
||||
Replace m4_db calls to the ANSI C X3.159-1989 (ANSI C) standard
|
||||
m4_bold($1) function with m4_arg(func_$1), which must conform to the
|
||||
standard interface specification.])])
|
||||
|
||||
define(m4_posix_func, [m4_p([dnl
|
||||
Replace m4_db calls to the m4_posix1_name m4_bold($1) function with
|
||||
m4_arg(func_$1), which must conform to the standard interface
|
||||
specification.])])
|
||||
|
||||
define(m4_ret_internal, [m4_p([dnl
|
||||
The m4_arg($1) function must return the value of m4_envvar(errno) on
|
||||
failure and 0 on success.])])
|
||||
|
||||
define(m4_param_replace, [dnl
|
||||
m4_parambegin
|
||||
m4_param([$1], [dnl
|
||||
The m4_arg([$1]) parameter is the replacement function. It must conform
|
||||
to the standard interface specification.])
|
||||
m4_paramend])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Stat print functions
|
||||
dnl #1: function
|
||||
dnl #2: type of statistics
|
||||
dnl #3: stat function that lists the default fields
|
||||
dnl #4: "no" if m4_pf_description call isn't needed
|
||||
dnl ###################################################################
|
||||
define(m4_stat_print, [dnl
|
||||
ifelse($4, no,, m4_pf_description(m4_ref($1)))
|
||||
m4_p([dnl
|
||||
The m4_refT($1) displays the
|
||||
ifelse($2,, [default statistical information.],
|
||||
[$2 statistical information, as described for the m4_refT($3).])
|
||||
The information is printed to a specified output channel (see the
|
||||
m4_refT(dbenv_set_msgfile) for more information), or passed to an
|
||||
application callback function (see the m4_refT(dbenv_set_msgcall) for
|
||||
more information).])
|
||||
ifelse($1, dbh_stat_print,
|
||||
m4_when($1, before, dbh_open), m4_when($1, before, dbenv_open))
|
||||
m4_return($1, std)
|
||||
m4_parambegin
|
||||
m4_param(flags, [dnl
|
||||
m4_sf_or_may(0)
|
||||
m4_tagbegin
|
||||
ifelse($1, dbh_stat_print, [dnl
|
||||
m4_tag(m4_idef(DB_FAST_STAT), [dnl
|
||||
Return only the values which do not require traversal of the database.
|
||||
Among other things, this flag makes it possible for applications to
|
||||
request key and record counts without incurring the performance penalty
|
||||
of traversing the entire database.])])
|
||||
m4_tag(m4_idef(DB_STAT_ALL), [dnl
|
||||
Display all available information.])
|
||||
ifelse($1, dbh_stat_print,, [dnl
|
||||
m4_tag(m4_idef(DB_STAT_CLEAR), [dnl
|
||||
Reset statistics after displaying their values.])])
|
||||
ifelse($1, lock_stat_print, [dnl
|
||||
m4_tag(m4_idef(DB_STAT_LOCK_CONF), [dnl
|
||||
Display the lock conflict matrix.])
|
||||
m4_tag(m4_idef(DB_STAT_LOCK_LOCKERS), [dnl
|
||||
Display the lockers within hash chains.])
|
||||
m4_tag(m4_idef(DB_STAT_LOCK_OBJECTS), [dnl
|
||||
Display the lock objects within hash chains.])
|
||||
m4_tag(m4_idef(DB_STAT_LOCK_PARAMS), [dnl
|
||||
Display the locking subsystem parameters.])])
|
||||
ifelse($1, memp_stat_print, [dnl
|
||||
m4_tag(m4_idef(DB_STAT_MEMP_HASH), [dnl
|
||||
Display the buffers with hash chains.])])
|
||||
ifelse($1, dbenv_stat_print, [dnl
|
||||
m4_tag(m4_idef(DB_STAT_SUBSYSTEM), [dnl
|
||||
Display information for all configured subsystems.])])
|
||||
m4_tagend])
|
||||
m4_paramend])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Common destructor language.
|
||||
dnl #1: handle
|
||||
dnl #2: method
|
||||
dnl ###################################################################
|
||||
define(m4_destructor, [m4_p([dnl
|
||||
The m4_ref($1) handle may not be accessed again after m4_ref($2) is
|
||||
called, regardless of its return.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl The scope of the configuration method.
|
||||
dnl #1: method
|
||||
dnl ###################################################################
|
||||
define(m4_scope_process, [m4_p([dnl
|
||||
The m4_refT($1) configures all operations performed by a process and
|
||||
all of its threads of control, not operations confined to a single
|
||||
database environment.])])
|
||||
define(m4_scope_dbenv, [m4_p([dnl
|
||||
The m4_refT($1) configures operations performed using the specified
|
||||
m4_ref(DbEnv) handle, not all operations performed on the underlying
|
||||
database environment.])])
|
||||
define(m4_scope_env, [m4_p([dnl
|
||||
The m4_refT($1) configures a database environment, not only operations
|
||||
performed using the specified m4_ref(DbEnv) handle.])])
|
||||
define(m4_scope_env_flags, [m4_p([dnl
|
||||
Calling m4_ref($1) with the m4_ref($2) flag affects the
|
||||
database environment, including all threads of control accessing the
|
||||
database environment.])])
|
||||
define(m4_scope_dbenv_flags, [m4_p([dnl
|
||||
Calling m4_ref($1) with the m4_ref($2) flag only affects
|
||||
the specified m4_ref(DbEnv) handle (and any other m4_db handles opened
|
||||
within the scope of that handle).
|
||||
ifelse($3, config, [dnl
|
||||
For consistent behavior across the environment, all m4_ref(DbEnv)
|
||||
handles opened in the environment must either set the m4_ref($2) flag
|
||||
or the flag should be specified in the m4_ref(DB_CONFIG) configuration
|
||||
file.])])])
|
||||
define(m4_scope_mpf, [m4_p([dnl
|
||||
The m4_refT($1) configures a file in the memory pool, not only
|
||||
operations performed using the specified m4_ref(DbMpoolFile) handle.])])
|
||||
define(m4_scope_mpf_flags, [m4_p([dnl
|
||||
The m4_ref($1) flag configures a file in the memory pool, not only
|
||||
operations performed using the specified m4_ref(DbMpoolFile) handle.])])
|
||||
define(m4_scope_db, [m4_p([dnl
|
||||
The m4_refT($1) configures a database, not only operations performed
|
||||
using the specified m4_ref(Db) handle.])])
|
||||
define(m4_scope_dbh, [m4_p([dnl
|
||||
The m4_refT($1) configures operations performed using the specified
|
||||
m4_ref(Db) handle, not all operations performed on the underlying
|
||||
database.])])
|
||||
define(m4_scope_tx, [m4_p([dnl
|
||||
The m4_refT($1) configures operations performed on the underlying
|
||||
transaction, not only operations performed using the specified
|
||||
m4_ref(DbTxn) handle.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl When methods can be called -- general purpose.
|
||||
dnl #1: our method name
|
||||
dnl #2: before/after
|
||||
dnl #3: method name we're scheduling against.
|
||||
dnl ###################################################################
|
||||
define(m4_when, [m4_p([dnl
|
||||
The m4_refT($1) may not be called $2 the m4_refT($3) is called.])])
|
||||
define(m4_when_two, [m4_p([dnl
|
||||
The m4_refT($1) may not be called $2 the m4_ref($3) or m4_refT($4)s are
|
||||
called.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl When methods can be called -- specific.
|
||||
dnl #1: method
|
||||
dnl #2: what happens if config info doesn't match existing object.
|
||||
dnl (error, ignored, corrupt, overwrite)
|
||||
dnl ###################################################################
|
||||
define(m4_when_any, [m4_p([dnl
|
||||
The m4_refT($1) may be called at any time during the life of the
|
||||
application.])])
|
||||
|
||||
define(m4_when_init, [m4_p([dnl
|
||||
Although the m4_refT($1) may be called at any time during the life of
|
||||
the application, it should normally be called before making calls to the
|
||||
m4_ref(dbenv_create) or m4_refT(dbh_create)s.])])
|
||||
|
||||
define(m4_when_envopen, [m4_p([dnl
|
||||
The m4_refT($1) may not be called after the m4_refT(dbenv_open) is
|
||||
called.
|
||||
ifelse($2, error, [If the database environment already exists when
|
||||
m4_ref(dbenv_open) is called, the information specified to m4_ref($1)
|
||||
must be consistent with the existing environment or an error will be
|
||||
returned.])
|
||||
ifelse($2, ignored, [If the database environment already exists when
|
||||
m4_ref(dbenv_open) is called, the information specified to m4_ref($1)
|
||||
will be ignored.])
|
||||
ifelse($2, corrupt, [If the database environment already exists when
|
||||
m4_ref(dbenv_open) is called, the information specified to m4_ref($1)
|
||||
must be consistent with the existing environment or corruption can
|
||||
occur.])])])
|
||||
|
||||
define(m4_when_mpfopen, [m4_p([dnl
|
||||
The m4_refT($1) may not be called after the m4_refT(memp_fopen) is
|
||||
called.
|
||||
ifelse($2, error, [If the file is already open in the memory pool when
|
||||
m4_ref(memp_fopen) is called, the information specified to m4_ref($1)
|
||||
must be consistent with the existing file or an error will be
|
||||
returned.])
|
||||
ifelse($2, overwrite, [If the file is already open in the memory pool when
|
||||
m4_ref(memp_fopen) is called, the information specified to m4_ref($1)
|
||||
will replace the existing information.])])])
|
||||
|
||||
define(m4_when_dbopen, [m4_p([dnl
|
||||
The m4_refT($1) may not be called after the m4_refT(dbh_open) is called.
|
||||
ifelse($2, ignored, [If the database already exists when
|
||||
m4_ref(dbh_open) is called, the information specified to m4_ref($1) will
|
||||
be ignored.])
|
||||
ifelse($2, corrupt, [If the database already exists when
|
||||
m4_ref(dbh_open) is called, the information specified to m4_ref($1) must
|
||||
be the same as that historically used to create the database or
|
||||
corruption can occur.])])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Common getter language.
|
||||
dnl #1 method name
|
||||
dnl #2 method description
|
||||
dnl #3 text description for the variable (empty if same as #2)
|
||||
dnl #4 C/C++ variable name
|
||||
dnl #5 "reference" if it's a reference to an object, not a value
|
||||
dnl ###################################################################
|
||||
define(m4_pf_getter, [dnl
|
||||
m4_pf_description(m4_ref($1))
|
||||
m4_getter([$1], [$2], [$3], [$4], [$5])])
|
||||
|
||||
define(m4_getter, [dnl
|
||||
m4_p([The m4_refT($1) returns the [$2].])
|
||||
ifelse(
|
||||
[$1], dbenv_get_open_flags, m4_when([$1], before, dbenv_open),
|
||||
[$1], dbh_get_open_flags, m4_when([$1], before, dbh_open), m4_when_any($1))
|
||||
ifelse([$4],,, [dnl
|
||||
ifelse([$1], dbh_getenv,, [m4_return($1, std)])
|
||||
m4_parambegin
|
||||
m4_param([$4],
|
||||
[The m4_refT($1) returns ifelse([$5], reference, a reference to) the
|
||||
ifelse([$3],, [$2], [$3]) in m4_arg([$4]).])
|
||||
m4_paramend])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Stat fields.
|
||||
dnl #1 C/C++ type
|
||||
dnl #2 field name
|
||||
dnl #3 description
|
||||
dnl ###################################################################
|
||||
define(m4_field, [m4_tag([$1] [$2];, [$3])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Parameters:
|
||||
dnl
|
||||
dnl m4_parambegin/end
|
||||
dnl m4_param
|
||||
dnl #1 C/C++ argument name
|
||||
dnl #2 description
|
||||
dnl ###################################################################
|
||||
define(m4_parambegin, [m4_section(Parameters) m4_tagbegin])
|
||||
define(m4_param, [define([__paramname], [$1]) m4_tag(__paramname, [$2])])
|
||||
define(m4_paramend, m4_tagend)
|
||||
|
||||
dnl ###################################################################
|
||||
dnl File/Directory parameters get standard Windows UTF-8 language.
|
||||
dnl #1: argument name
|
||||
dnl #2: argument text
|
||||
dnl ###################################################################
|
||||
define(m4_param_utf8, [dnl
|
||||
m4_param([$1], [$2])
|
||||
m4_p([dnl
|
||||
When using a Unicode build on Windows (the default), the m4_arg([$1])
|
||||
argument will be interpreted as a UTF-8 string, which is equivalent to
|
||||
ASCII for Latin characters.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Standard copy-out language.
|
||||
dnl
|
||||
dnl m4_param_co --
|
||||
dnl #1: argument
|
||||
dnl #2: copied thing
|
||||
dnl #3: REF, if it's a reference to the object.
|
||||
dnl #4: additional text
|
||||
dnl ###################################################################
|
||||
define(m4_param_co, [m4_param([$1], [dnl
|
||||
The m4_arg([$1]) parameter references memory into which
|
||||
ifelse([$3], REF, a pointer to) the $2 is copied.]) $4])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Standard not reentrant language.
|
||||
dnl ###################################################################
|
||||
define(m4_not_reentrant, [m4_p([dnl
|
||||
m4_db is not re-entrant. Callback functions should not attempt to make
|
||||
library calls (for example, to release locks or close open handles).
|
||||
Re-entering m4_db is not guaranteed to work correctly, and the results
|
||||
are undefined.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl The key/data argument language.
|
||||
dnl ###################################################################
|
||||
define(m4_param_key, [m4_param(key, [The key m4_ref(Dbt) operated on.])])
|
||||
define(m4_param_data, [m4_param(data, [The data m4_ref(Dbt) operated on.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl The filesystem mode argument language.
|
||||
dnl #1: the subsystem name.
|
||||
dnl ###################################################################
|
||||
define(m4_param_filemode, [dnl
|
||||
m4_param(mode, [dnl
|
||||
On Windows systems, the mode parameter is ignored.
|
||||
m4_p([dnl
|
||||
On UNIX systems or in m4_posix1_name environments, files created by $1
|
||||
are created with mode m4_arg(mode) (as described in m4_manref(chmod, 2))
|
||||
and modified by the process' umask value at the time of creation (see
|
||||
m4_manref(umask, 2)). Created files are owned by the process owner; the
|
||||
group ownership of created files is based on the system and directory
|
||||
defaults, and is not further specified by m4_db. System shared memory
|
||||
segments created by $1 are created with mode m4_arg(mode), unmodified
|
||||
by the process' umask value. If m4_arg(mode) is 0, $1 will use a
|
||||
default mode of readable and writable by both owner and group.])])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Transaction ID arguments.
|
||||
dnl
|
||||
dnl m4_param_txn --
|
||||
dnl #1: method
|
||||
dnl #2: "auto" if there's an auto-commit flag.
|
||||
dnl #2: "env" if an environment operation.
|
||||
dnl #2: "ro" if a read-only operation
|
||||
dnl #3: additional wording
|
||||
dnl ###################################################################
|
||||
define(m4_param_txn,
|
||||
[m4_param(txnid, [dnl
|
||||
If the operation is part of an application-specified transaction, the
|
||||
m4_arg(txnid) parameter is a transaction handle returned from
|
||||
m4_ref(txn_begin); if the operation is part of a m4_cam group, the
|
||||
m4_arg(txnid) parameter is a handle returned from
|
||||
m4_ref(cdsgroup_begin); otherwise NULL.
|
||||
ifelse([$2], ro,, [dnl
|
||||
If no transaction handle is
|
||||
specified, but the
|
||||
ifelse([$2], auto, [DB_AUTO_COMMIT flag is specified],
|
||||
[operation occurs in a transactional
|
||||
ifelse([$2], env, database environment, database)]),
|
||||
the operation will be implicitly transaction protected.])
|
||||
$3])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Replication lower-level API wording.
|
||||
dnl
|
||||
dnl m4_repl_lower --
|
||||
dnl #1: method
|
||||
dnl ###################################################################
|
||||
define(m4_repl_lower,
|
||||
[m4_p([The m4_ref($1) method is not called by most replication
|
||||
applications. It should only be called by applications implementing
|
||||
their own network transport layer, explicitly holding replication group
|
||||
elections and handling replication messages outside of the replication
|
||||
manager framework.])])
|
||||
|
||||
dnl #################################################################
|
||||
dnl m4_linkjavadoc and supporting macros:
|
||||
dnl Link to specific javadoc location in any page.
|
||||
dnl #1: package
|
||||
dnl #2: class (optional)
|
||||
dnl #3: method (optional)
|
||||
dnl #################################################################
|
||||
dnl __m4_javasrcref
|
||||
dnl #1: package
|
||||
define(__m4_javasrcref, [dnl
|
||||
ifelse(index($1, com.sleepycat), 0, dnl
|
||||
[../../java/translit($1, ., /)], dnl
|
||||
ifelse(index($1, java), 0, dnl
|
||||
[http://java.sun.com/j2se/1.5.0/docs/api/translit($1, ., /)], $1))])
|
||||
|
||||
define(m4_linkjavadoc, [dnl
|
||||
ifelse($#, 3,dnl
|
||||
[<a href="__m4_javasrcref($1)/$2.html__OCT__[pathsubst($3, ' ', '%20')]">$2.$3</a>],dnl
|
||||
$#, 2,dnl
|
||||
[<a href="__m4_javasrcref($1)/$2.html">$2</a>],dnl
|
||||
[<a href="__m4_javasrcref($1)/package-summary.html">$1</a>])])
|
||||
256
docs_src/m4/m4.err
Normal file
256
docs_src/m4/m4.err
Normal file
@@ -0,0 +1,256 @@
|
||||
dnl $Id: m4.err,v 10.146 2007/10/24 16:06:07 bostic Exp $
|
||||
dnl
|
||||
dnl ###################################################################
|
||||
dnl m4_err_mem_insufficient --
|
||||
dnl Inline error for insufficient memory to return a key/data pair.
|
||||
dnl ###################################################################
|
||||
define(m4_err_mem_insufficient, [dnl
|
||||
ifelse(M4EXCEPT, except_only,
|
||||
[and a m4_ref(DbMemoryException) is thrown],
|
||||
[and the error DB_BUFFER_SMALL is returned])])
|
||||
dnl ###################################################################
|
||||
dnl General errors:
|
||||
dnl
|
||||
dnl There are 3 cases: the C API, which just returns errors, the C++ API
|
||||
dnl which either throws exceptions or returns errors, and the XML API which
|
||||
dnl just throws exceptions.
|
||||
dnl
|
||||
dnl #1: API name
|
||||
dnl #2: Variadic list of errors.
|
||||
dnl
|
||||
dnl Some errors are well-known, and can either throw an exception or be
|
||||
dnl a normal return: buffersmall, deadlock, filenotfound, memory. In this
|
||||
dnl case, we immediately output the error for C, and save up the output for
|
||||
dnl C++, because we list exceptions after the laundry list of error returns.
|
||||
dnl
|
||||
dnl If the error isn't well-known, it's expected to be in pairs: the error
|
||||
dnl followed by the string associated with it.
|
||||
dnl ###################################################################
|
||||
define(m4_err, [dnl
|
||||
define([__m4_errapi], [m4_refT($1)])
|
||||
define([__m4_errneedheader], yes)
|
||||
m4_header(Errors)
|
||||
__m4_errloop(shift($@))
|
||||
undivert(1)])
|
||||
define(m4_errstr, [dnl
|
||||
define([__m4_errapi], [$1])
|
||||
define([__m4_errneedheader], yes)
|
||||
m4_header(Errors)
|
||||
__m4_errloop(shift($@))
|
||||
undivert(1)])
|
||||
dnl
|
||||
dnl ###################################################################
|
||||
dnl __m4_errheader
|
||||
dnl If we need header text, output it, but only once.
|
||||
dnl ###################################################################
|
||||
define(__m4_errheader, [ifelse(__m4_errneedheader, yes, [m4_p([dnl
|
||||
The __m4_errapi
|
||||
ifelse(M4EXCEPT, except_return,
|
||||
[may fail and throw
|
||||
ifelse(M4PRODUCT, XML, m4_ref(XmlException)[,], m4_ref(DbException)[,])
|
||||
encapsulating one of the following non-zero errors, or return one of
|
||||
the following non-zero errors:],
|
||||
M4EXCEPT, except_only,
|
||||
[may fail and throw
|
||||
ifelse(M4PRODUCT, XML, m4_ref(XmlException)[,], m4_ref(DbException)[,])
|
||||
encapsulating one of the following non-zero errors:],
|
||||
[may fail and return one of the following non-zero errors:])])
|
||||
define([__m4_errneedheader], no)])])
|
||||
dnl
|
||||
dnl ###################################################################
|
||||
dnl __m4_errloop
|
||||
dnl Helper macro: loop through exception list.
|
||||
dnl ###################################################################
|
||||
define(__m4_errloop, [dnl
|
||||
ifelse([$1],,,
|
||||
dnl ###################################################################
|
||||
dnl Buffer Small
|
||||
dnl Requires subsequent argument which is the reason for the failure.
|
||||
dnl ###################################################################
|
||||
[$1], buffersmall, [dnl
|
||||
ifelse(M4EXCEPT, return_only, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(DB_BUFFER_SMALL, [The [$2].])
|
||||
m4_tagend],[dnl
|
||||
divert(1)
|
||||
m4_p([If the [$2], the __m4_errapi will fail and
|
||||
ifelse(M4EXCEPT, except_return, [either return DB_BUFFER_SMALL or])
|
||||
throw a m4_ref(DbMemoryException) exception.])
|
||||
divert(0)])
|
||||
__m4_errloop(shift(shift($@)))],
|
||||
dnl ###################################################################
|
||||
dnl Deadlock.
|
||||
dnl ###################################################################
|
||||
[$1], deadlock, [dnl
|
||||
ifelse(M4EXCEPT, return_only, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(DB_LOCK_DEADLOCK, [dnl
|
||||
A transactional database environment operation was selected to resolve
|
||||
a deadlock.])
|
||||
m4_tag(DB_LOCK_NOTGRANTED, [dnl
|
||||
A m4_cam database environment configured for lock timeouts was unable
|
||||
to grant a lock in the allowed time.])
|
||||
m4_tagend],[dnl
|
||||
divert(1)
|
||||
m4_p([If a transactional database environment operation was selected to
|
||||
resolve a deadlock, the __m4_errapi will fail and
|
||||
ifelse(M4EXCEPT, except_return, [either return m4_ref(DB_LOCK_DEADLOCK) or])
|
||||
throw a m4_ref(DbDeadlockException) exception.])
|
||||
m4_p([If a m4_cam database environment configured for lock timeouts was unable
|
||||
to grant a lock in the allowed time, the __m4_errapi will fail and
|
||||
ifelse(M4EXCEPT, except_return, [either return m4_ref(DB_LOCK_NOTGRANTED) or])
|
||||
throw a m4_ref(DbLockNotGrantedException) exception.])
|
||||
divert(0)])
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl Filenotfound
|
||||
dnl ###################################################################
|
||||
[$1], filenotfound, [dnl
|
||||
m4_tagbegin
|
||||
m4_tag(ENOENT, [The file or directory does not exist.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl LockNotGranted
|
||||
dnl ###################################################################
|
||||
[$1], locknotgranted, [dnl
|
||||
ifelse(M4EXCEPT, return_only, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(DB_LOCK_NOTGRANTED, [dnl
|
||||
The $2 lock could not be granted before the wait-time expired.])
|
||||
m4_tagend],[dnl
|
||||
divert(1)
|
||||
m4_p([If the $2 lock could not be granted before the wait-time expired,
|
||||
the __m4_errapi will fail and
|
||||
ifelse(M4EXCEPT, except_return, [either return DB_LOCK_NOTGRANTED or])
|
||||
throw a m4_ref(DbLockNotGrantedException) exception.])
|
||||
divert(0)])
|
||||
__m4_errloop(shift(shift($@)))],
|
||||
dnl ###################################################################
|
||||
dnl Memory
|
||||
dnl Requires subsequent argument which is the reason for the failure.
|
||||
dnl ###################################################################
|
||||
[$1], memory, [dnl
|
||||
ifelse(M4EXCEPT, return_only, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(ENOMEM, [The [$2].])
|
||||
m4_tagend],[dnl
|
||||
divert(1)
|
||||
m4_p([If the [$2], the __m4_errapi will fail and
|
||||
ifelse(M4EXCEPT, except_return, [either return ENOMEM or])
|
||||
throw a DbMemoryException.])
|
||||
divert(0)])
|
||||
__m4_errloop(shift(shift($@)))],
|
||||
dnl ###################################################################
|
||||
dnl XML: generic underlying error from the core DB.
|
||||
dnl ###################################################################
|
||||
[$1], dberr, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(DATABASE_ERROR, [dnl
|
||||
An error occurred in an underlying m4_db database. The
|
||||
m4_refT(xmlexception_getdberror) will return the error code for the
|
||||
error.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl EACCESS because the database is read-only.
|
||||
dnl ###################################################################
|
||||
[$1], readonly, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(EACCES, [An attempt was made to modify a read-only database.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl EAGAIN because the region is unavailable.
|
||||
dnl ###################################################################
|
||||
[$1], regionagain, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(EAGAIN, [dnl
|
||||
The shared memory region was locked and (repeatedly) unavailable.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl EINVAL
|
||||
dnl Requires subsequent argument which is empty or a list of may be
|
||||
dnl additional reasons.
|
||||
dnl ###################################################################
|
||||
[$1], einval, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(EINVAL, [dnl
|
||||
ifelse([$2],, An, If [$2]; or if an)
|
||||
invalid flag value or parameter was specified.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift(shift($@)))],
|
||||
dnl ###################################################################
|
||||
dnl DB_REP_HANDLE_DEAD -- replication rolled back a commit record.
|
||||
dnl ###################################################################
|
||||
[$1], rephandle, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(DB_REP_HANDLE_DEAD, [dnl
|
||||
The database handle has been invalidated because a replication election
|
||||
unrolled a committed transaction.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl DB_REP_LOCKOUT -- replication blocked by client/master sync-up.
|
||||
dnl ###################################################################
|
||||
[$1], replockout, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(DB_REP_LOCKOUT, [dnl
|
||||
The operation was blocked by client/master synchronization.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl DB_REP_LEASE_EXPIRED -- replication lease expired
|
||||
dnl ###################################################################
|
||||
[$1], replease, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(DB_REP_LEASE_EXPIRED, [dnl
|
||||
The operation failed because the site's replication master lease has expired.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl EPERM because write operation with read-only CDB cursor.
|
||||
dnl ###################################################################
|
||||
[$1], cdbperm, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(EPERM , [dnl
|
||||
Write attempted on read-only cursor when the m4_ref(DB_INIT_CDB) flag was
|
||||
specified to m4_ref(dbenv_open).])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl Bad secondary.
|
||||
dnl ###################################################################
|
||||
[$1], secondary_bad, [dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag(DB_SECONDARY_BAD, [dnl
|
||||
A secondary index references a nonexistent primary key.])
|
||||
m4_tagend
|
||||
__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl Empty entry (to support ifelse() constructs).
|
||||
dnl ###################################################################
|
||||
[$1], empty, [__m4_errloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl Everything else.
|
||||
dnl ###################################################################
|
||||
[dnl
|
||||
__m4_errheader
|
||||
m4_tagbegin
|
||||
m4_tag([$1], [$2])
|
||||
m4_tagend
|
||||
__m4_errloop(shift(shift($@)))])])
|
||||
138
docs_src/m4/m4.flags
Normal file
138
docs_src/m4/m4.flags
Normal file
@@ -0,0 +1,138 @@
|
||||
dnl $Id: m4.flags,v 10.145 2007/10/26 15:01:32 bostic Exp $
|
||||
dnl ###################################################################
|
||||
dnl FLAGS
|
||||
dnl ###################################################################
|
||||
dnl
|
||||
dnl OR'ing language.
|
||||
dnl
|
||||
define(m4_or, [bitwise inclusively m4_bold(OR)'ing])
|
||||
|
||||
dnl
|
||||
dnl Unused flags.
|
||||
dnl
|
||||
define(m4_unusedflags, [dnl
|
||||
m4_param(flags, [dnl
|
||||
The m4_arg(flags) parameter is currently unused, and must be set to 0.])])
|
||||
|
||||
dnl
|
||||
dnl Flags must be 0 or one of the following OR'd values.
|
||||
dnl
|
||||
define(m4_sf_or_may, [dnl
|
||||
The m4_arg(flags) parameter must be set to 0 or by m4_or together one
|
||||
or more of the following values:])
|
||||
|
||||
dnl
|
||||
dnl Flags must be one of the following OR'd values.
|
||||
dnl
|
||||
define(m4_sf_or_must, [dnl
|
||||
The m4_arg(flags) parameter must be set by m4_or together one or more
|
||||
of the following values:])
|
||||
|
||||
dnl
|
||||
dnl Flags may be added to by OR'ing one of the following values.
|
||||
dnl #1 "0" if a single flag, "1" if multiple flags
|
||||
dnl
|
||||
define(m4_sf_or_add, [dnl
|
||||
In addition, the following ifelse([$1],0, flag, flags) may be set by
|
||||
m4_or ifelse([$1],0, it, them) into the m4_arg(flags) parameter:])
|
||||
|
||||
dnl
|
||||
dnl Flags must be one of the following values.
|
||||
dnl
|
||||
define(m4_sf_must, [dnl
|
||||
The m4_arg(flags) parameter must be set to one of the following values:])
|
||||
|
||||
dnl
|
||||
dnl Flags must be 0 or one of the following values.
|
||||
dnl #1 "0" if a single flag, "1" if multiple flags
|
||||
dnl
|
||||
define(m4_sf_zmust, [dnl
|
||||
The m4_arg(flags) parameter must be set to 0 or
|
||||
ifelse([$1],0, the following value:, one of the following values:)])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Additional flags: DB_AUTO_COMMIT
|
||||
dnl #1 method
|
||||
dnl ###################################################################
|
||||
define(m4_autocommit_flag, [dnl
|
||||
m4_tag(m4_idef(DB_AUTO_COMMIT), [dnl
|
||||
Enclose the m4_ref($1) call within a transaction. If the call succeeds,
|
||||
changes made by the operation will be recoverable. If the call fails,
|
||||
the operation will have made no changes.])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Additional flags: RMW
|
||||
dnl #1 additional text
|
||||
dnl ###################################################################
|
||||
define(m4_rmw_flag, [dnl
|
||||
m4_tag(m4_idef(DB_RMW), [dnl
|
||||
Acquire write locks instead of read locks when doing the read, if
|
||||
locking is configured. Setting this flag can eliminate deadlock during
|
||||
a read-modify-write cycle by acquiring the write lock during the read
|
||||
part of the cycle so that another thread of control acquiring a read
|
||||
lock for the same item, in its own read-modify-write cycle, will not
|
||||
result in deadlock.
|
||||
ifelse([$1],,, [m4_p([$1])])])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl lock_detect, set_lk_detect flags.
|
||||
dnl ###################################################################
|
||||
define(m4_lk_detect_flags, [dnl
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_LOCK_DEFAULT), [dnl
|
||||
Use whatever lock policy was specified when the database environment
|
||||
was created. If no lock policy has yet been specified, set the lock
|
||||
policy to DB_LOCK_RANDOM.])
|
||||
m4_tag(m4_idef(DB_LOCK_EXPIRE), [dnl
|
||||
Reject lock requests which have timed out. No other deadlock detection
|
||||
is performed.])
|
||||
m4_tag(m4_idef(DB_LOCK_MAXLOCKS), [dnl
|
||||
Reject the lock request for the locker ID with the most locks.])
|
||||
m4_tag(m4_idef(DB_LOCK_MAXWRITE), [dnl
|
||||
Reject the lock request for the locker ID with the most write locks.])
|
||||
m4_tag(m4_idef(DB_LOCK_MINLOCKS), [dnl
|
||||
Reject the lock request for the locker ID with the fewest locks.])
|
||||
m4_tag(m4_idef(DB_LOCK_MINWRITE), [dnl
|
||||
Reject the lock request for the locker ID with the fewest write locks.])
|
||||
m4_tag(m4_idef(DB_LOCK_OLDEST), [dnl
|
||||
Reject the lock request for the locker ID with the oldest lock.])
|
||||
m4_tag(m4_idef(DB_LOCK_RANDOM), [dnl
|
||||
Reject the lock request for a random locker ID.])
|
||||
m4_tag(m4_idef(DB_LOCK_YOUNGEST), [dnl
|
||||
Reject the lock request for the locker ID with the youngest lock.])
|
||||
m4_tagend])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Cache priority.
|
||||
dnl #1 method
|
||||
dnl ###################################################################
|
||||
define(m4_cache_priority_explain, [m4_p([dnl
|
||||
The priority of a page biases the replacement algorithm to be more or
|
||||
less likely to discard a page when space is needed in the buffer pool.
|
||||
The bias is temporary, and pages will eventually be discarded if they
|
||||
are not referenced again. The m4_refT($1) is only advisory, and does
|
||||
not guarantee pages will be treated in a specific way.])])
|
||||
|
||||
define(m4_cache_priority_parameter, [dnl
|
||||
m4_param(priority, [dnl
|
||||
The m4_arg(priority) parameter must be set to one of the following
|
||||
values:
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_PRIORITY_VERY_LOW), [dnl
|
||||
The lowest priority: pages are the most likely to be discarded.])
|
||||
m4_tag(m4_idef(DB_PRIORITY_LOW), [The next lowest priority.])
|
||||
m4_tag(m4_idef(DB_PRIORITY_DEFAULT), [The default priority.])
|
||||
m4_tag(m4_idef(DB_PRIORITY_HIGH), [The next highest priority.])
|
||||
m4_tag(m4_idef(DB_PRIORITY_VERY_HIGH), [dnl
|
||||
The highest priority: pages are the least likely to be discarded.])
|
||||
m4_tagend])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Stat flags:
|
||||
dnl ###################################################################
|
||||
define(m4_stat_flags, [dnl
|
||||
m4_sf_zmust(0)
|
||||
m4_tagbegin
|
||||
m4_tag(m4_idef(DB_STAT_CLEAR), [dnl
|
||||
Reset statistics after returning their values.])
|
||||
m4_tagend])
|
||||
380
docs_src/m4/m4.html
Normal file
380
docs_src/m4/m4.html
Normal file
@@ -0,0 +1,380 @@
|
||||
dnl $Id: m4.html 63573 2008-05-23 21:43:21Z trent.nelson $
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Fonts.
|
||||
dnl ###################################################################
|
||||
dnl Bold font
|
||||
define(m4_bold, <b>$1</b>)
|
||||
|
||||
dnl Constant width bold font -- same as m4_bold in HTML
|
||||
define(m4_cbold, <b>$1</b>)
|
||||
|
||||
dnl Italic font
|
||||
define(m4_italic, <i>$1</i>)
|
||||
|
||||
dnl Environmental variable.
|
||||
dnl #1: variable
|
||||
define(m4_envvar, <b>$1</b>)
|
||||
|
||||
dnl Pathname.
|
||||
dnl #1: path
|
||||
define(m4_path, <b>$1</b>)
|
||||
|
||||
dnl Function argument.
|
||||
dnl #1: argument name
|
||||
define(m4_arg, <b>$1</b>)
|
||||
|
||||
dnl Utility option/flag.
|
||||
define(m4_option, <b>-$1</b>)
|
||||
|
||||
dnl Utility argument
|
||||
define(m4_utilarg, __LB__<b>-$1</b>__RB__)
|
||||
|
||||
dnl UNIX manual reference.
|
||||
dnl #1: man page name
|
||||
dnl #2: section
|
||||
define(m4_manref, [<b>$1</b>($2)])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Special Characters, Escapes.
|
||||
dnl ###################################################################
|
||||
dnl Superimposed
|
||||
define(m4_sup, [$1<sup>$2</sup>])
|
||||
|
||||
dnl Backslash preceded string.
|
||||
dnl #1: characters after the backslash
|
||||
define(m4_backslash, [\$1])
|
||||
|
||||
dnl Angle-bracket quoted string.
|
||||
define(m4_htmlquote, [<$1>])
|
||||
|
||||
dnl C include file
|
||||
dnl #1: include file name
|
||||
define(m4_include, [__OCT__include <$1>])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Miscellaneous.
|
||||
dnl ###################################################################
|
||||
dnl Berkeley DB
|
||||
define(m4_db, [Berkeley DB])
|
||||
|
||||
dnl Comment
|
||||
define(m4_comment, <!--$1-->)
|
||||
|
||||
dnl Copyright strings.
|
||||
define(m4_copyright_source, [dnl
|
||||
<!--Copyright (c) 1997,2008 Oracle. All rights reserved.-->
|
||||
<!--See the file LICENSE for redistribution information.-->])
|
||||
|
||||
define(m4_copyright_footer, [dnl
|
||||
<p><font size=1>Copyright (c) 1996,2008 Oracle. All rights reserved.</font>])
|
||||
|
||||
dnl M4_meta definition moved to html.sed to prevent line breaks
|
||||
define(m4_meta, __M4_META__)
|
||||
|
||||
dnl Just discard.
|
||||
define(m4_ignore,)
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Layout: basic.
|
||||
dnl ###################################################################
|
||||
dnl Header
|
||||
define(m4_header, <br><b>$1</b>)
|
||||
|
||||
dnl Section
|
||||
define(m4_section, <b>$1</b>)
|
||||
|
||||
dnl Subsection
|
||||
define(m4_subsection, <h4>$1</h4>)
|
||||
|
||||
dnl Paragraph
|
||||
define(m4_p, [<p>$1</p>])
|
||||
|
||||
dnl Horizontal line.
|
||||
define(m4_hl, [<hr size=1 noshade>])
|
||||
|
||||
dnl Single blank line.
|
||||
define(m4_blank, [<p>])
|
||||
|
||||
dnl Literal text block.
|
||||
dnl #1: string
|
||||
define(m4_literal, <pre>$1</pre>)
|
||||
|
||||
dnl Indent literal text block.
|
||||
dnl #1: string
|
||||
define(m4_indent, <blockquote><pre>$1</pre></blockquote>)
|
||||
|
||||
dnl Indent text block.
|
||||
dnl #1: string
|
||||
define(m4_indentv, <blockquote>$1</blockquote>)
|
||||
|
||||
dnl PicGif display - Pic for ROFF/Gif for HTML
|
||||
dnl #1: align, e.g., center
|
||||
dnl #2: img src, e.g., M4RELDIR/ref/xxx
|
||||
dnl #3: alternate string
|
||||
define(m4_picgif, [<p align=$1><img src="$2.gif" alt="$3">])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Layout: headers, titles and page bottoms.
|
||||
dnl ###################################################################
|
||||
dnl Reference Guide page leader.
|
||||
dnl #1: section
|
||||
dnl #2: page name
|
||||
dnl #3: index entries
|
||||
dnl #4,#5: prev, next
|
||||
define(m4_ref_title, [dnl
|
||||
ifelse($#, 5, , [errprint([$0: arg mismatch
|
||||
])])
|
||||
define(__m4_pagename, [$2])
|
||||
m4_copyright_source
|
||||
<html>
|
||||
<head>
|
||||
<title>ifelse(M4PRODUCT, XML, m4_xml, m4_db) Reference Guide: $2</title>
|
||||
m4_meta
|
||||
</head>
|
||||
<body bgcolor=white>
|
||||
m4_idefz($3)
|
||||
<table width="100%"><tr valign=top>
|
||||
<td><b><dl><dt>ifelse(M4PRODUCT, XML, m4_xml, m4_db) Reference Guide:<dd>$1</dl></b></td>
|
||||
<td align=right>dnl
|
||||
ifelse($4,,,
|
||||
<a href="../$4.html"><img src="M4RELDIR/images/prev.gif" alt="Prev"></a>)dnl
|
||||
<a href="../toc.html">dnl
|
||||
<img src="M4RELDIR/images/ref.gif" alt="Ref"></a>dnl
|
||||
ifelse($5,,,
|
||||
<a href="../$5.html"><img src="M4RELDIR/images/next.gif" alt="Next"></a>)
|
||||
</td></tr></table>
|
||||
<p align=center><b>$2</b></p>
|
||||
define(m4_page_footer, [dnl
|
||||
<table width="100%"><tr><td><br></td><td align=right>dnl
|
||||
ifelse($4,,,
|
||||
<a href="../$4.html"><img src="M4RELDIR/images/prev.gif" alt="Prev"></a>)dnl
|
||||
<a href="../toc.html">dnl
|
||||
<img src="M4RELDIR/images/ref.gif" alt="Ref"></a>dnl
|
||||
ifelse($5,,,
|
||||
<a href="../$5.html"><img src="M4RELDIR/images/next.gif" alt="Next"></a>)
|
||||
</td></tr></table>
|
||||
m4_copyright_footer
|
||||
</body>
|
||||
</html>])])
|
||||
|
||||
dnl General purpose page leader
|
||||
dnl #1: page name
|
||||
define(m4_page_title, [dnl
|
||||
m4_copyright_source
|
||||
<html>
|
||||
<head>
|
||||
<title>ifelse(M4PRODUCT, XML, m4_xml:, m4_db:) $1</title>
|
||||
m4_meta
|
||||
</head>
|
||||
<body bgcolor=white>
|
||||
<p align=center><b>$1</b></p>
|
||||
define(m4_page_footer, [dnl
|
||||
m4_copyright_footer
|
||||
</body>
|
||||
</html>])])
|
||||
|
||||
dnl General purpose page header, included by specific page headers.
|
||||
dnl #1: page title string
|
||||
dnl #2: section header
|
||||
dnl #3: API/Ref links in header/footer {yes, no}
|
||||
define(m4_page_header, [dnl
|
||||
define(__m4_pagename, [$1])
|
||||
m4_copyright_source
|
||||
<html>
|
||||
<head>
|
||||
<title>ifelse(M4PRODUCT, XML, m4_xml:, m4_db:) $1</title>
|
||||
m4_meta
|
||||
</head>
|
||||
<body bgcolor=white>
|
||||
ifelse([$2],,, [dnl
|
||||
<table width="100%"><tr valign=top>
|
||||
<td>
|
||||
<b>[$2]</b>
|
||||
</td>
|
||||
ifelse([$3],,, [dnl
|
||||
<td align=right>
|
||||
<a href="m4_iurl"><img src="M4RELDIR/images/api.gif" alt="API"></a>
|
||||
<a href="M4RELDIR/ifelse(M4PRODUCT,XML,ref_xml,ref)/toc.html">dnl
|
||||
<img src="M4RELDIR/images/ref.gif" alt="Ref"></a></td>])
|
||||
</tr></table>
|
||||
m4_hl])
|
||||
<tt>
|
||||
define(m4_page_footer, [dnl
|
||||
</tt>
|
||||
ifelse([$3],,, [dnl
|
||||
<table width="100%"><tr><td><br></td><td align=right>
|
||||
<a href="m4_iurl"><img src="M4RELDIR/images/api.gif" alt="API"></a>dnl
|
||||
<a href="M4RELDIR/ifelse(M4PRODUCT,XML,ref_xml,ref)/toc.html">dnl
|
||||
<img src="M4RELDIR/images/ref.gif" alt="Ref"></a>
|
||||
</td></tr></table>])
|
||||
m4_copyright_footer
|
||||
</body>
|
||||
</html>])])
|
||||
|
||||
dnl Description header for C/C++ API manual pages.
|
||||
define(m4_pf_description, [dnl
|
||||
m4_hl
|
||||
<b>Description: [$1]</b>])
|
||||
|
||||
dnl Page header for C/C++ API manual pages.
|
||||
dnl #1: function name
|
||||
dnl #2: function declaration
|
||||
dnl #3: extra stuff
|
||||
define(m4_pf_header, [dnl
|
||||
m4_page_header([$1], [$1], yes)
|
||||
<b><pre>
|
||||
m4_incextra([$3])
|
||||
ifelse([$2],,, [dnl
|
||||
<p>
|
||||
$2])
|
||||
</pre></b>
|
||||
m4_pf_description([$1])])
|
||||
|
||||
dnl Page header for Tcl manual pages.
|
||||
dnl #1: tcl command name
|
||||
dnl #2: tcl command name (correctly formatted)
|
||||
dnl #3: utility Synopsis line
|
||||
define(m4_tcl_header, [dnl
|
||||
m4_page_header([$1], [$2], yes)
|
||||
<b><pre>$3</pre></b>
|
||||
<b>Description($1)</b>])
|
||||
|
||||
dnl Page header for utilities.
|
||||
dnl #1: utility name
|
||||
dnl #2: utility Synopsis line
|
||||
define(m4_util_header, [dnl
|
||||
m4_page_header([$1], [$1])
|
||||
<b><pre>$2</pre></b>
|
||||
<b>Description</b>])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl HTML links
|
||||
dnl ###################################################################
|
||||
dnl m4_link
|
||||
dnl Link to titled DB Reference Guide page.
|
||||
dnl #1: page
|
||||
dnl #2: string
|
||||
define(m4_link, [<a href="$1.html">$2</a>])
|
||||
|
||||
dnl m4_linkpage
|
||||
dnl Link to specific address in any HTML page.
|
||||
dnl #1: page
|
||||
dnl #2: address (optional)
|
||||
dnl #2/3: string to display
|
||||
define(m4_linkpage, [dnl
|
||||
ifelse($#, 3, [<a href="$1.html[__OCT__]$2">$3</a>],dnl
|
||||
[<a href="$1.html">$2</a>])])
|
||||
|
||||
dnl m4_linkweb:
|
||||
dnl Link to specific address in any page.
|
||||
dnl #1: page
|
||||
dnl #2: address (optional)
|
||||
dnl #2/3: string to display
|
||||
define(m4_linkweb, [dnl
|
||||
ifelse($#, 3, [<a href="$1.html__OCT__$2">$3</a>],dnl
|
||||
[<a href="$1">$2</a>])])
|
||||
|
||||
dnl m4_mailto
|
||||
dnl Mailto construct.
|
||||
dnl #1: address
|
||||
dnl #2: string
|
||||
define(m4_mailto, [<a href="mailto:$1">$2</a>])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Three forms of lists:
|
||||
dnl - tagged
|
||||
dnl - numbered
|
||||
dnl - bullet item
|
||||
dnl ###################################################################
|
||||
dnl m4_tagbegin
|
||||
define(m4_tagbegin, <br>)
|
||||
dnl m4_tag: standard tag list
|
||||
dnl #1: tag
|
||||
dnl #2: definition
|
||||
define(m4_tag, <b>$1</b><ul compact><li>$2</ul>)
|
||||
dnl m4_tagopt: option tag list
|
||||
dnl #1: option
|
||||
dnl #2: definition
|
||||
define(m4_tagopt, m4_option($1)<ul compact><li>$2</ul>)
|
||||
dnl m4_tagend
|
||||
define(m4_tagend, <br>)
|
||||
|
||||
define(m4_nlistbegin, <ol>)
|
||||
define(m4_nlist, <p><li>$1)
|
||||
define(m4_nlistns, <li>$1)
|
||||
define(m4_nlistend, </ol>)
|
||||
|
||||
define(m4_bulletbegin, <p><ul type=disc>)
|
||||
define(m4_bullet, <li>$1)
|
||||
define(m4_bulletend, </ul>)
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Tables
|
||||
dnl ###################################################################
|
||||
dnl m4_table_begin: a table with N elements.
|
||||
dnl #1: optional title
|
||||
dnl #2: option alignment (_left, _right, _center)
|
||||
dnl
|
||||
dnl m4_table_header: column headers, emboldened
|
||||
dnl
|
||||
dnl m4_table_element: table element
|
||||
dnl #1: optional empty flag (_empty)
|
||||
dnl #1: optional alignment (_left, _right, _center)
|
||||
dnl
|
||||
dnl m4_table_end: table end
|
||||
dnl
|
||||
define(m4_table_begin, [dnl
|
||||
[<table border=1]dnl
|
||||
ifelse([$2],,,
|
||||
[$2], _left, [ align=left],
|
||||
[$2], _center, [ align=center],
|
||||
[$2], _right, [ align=right])>])
|
||||
define(m4_table_end, </table>)
|
||||
define(m4_table_header, [<tr>__m4_table_header($@)</tr>])
|
||||
define(__m4_table_header, [dnl
|
||||
ifelse([$1],,,[$1],_empty,
|
||||
<th><br></th>[__m4_table_header(shift($@))],
|
||||
<th>$1</th>[__m4_table_header(shift($@))])])
|
||||
define(m4_table_element, [<tr>__m4_table_element($@)</tr>])
|
||||
define(__m4_table_element, [dnl
|
||||
ifelse([$1],,,
|
||||
[$1], _left, [dnl
|
||||
ifelse([$2],,,
|
||||
<td align=left>[$2]</td>[__m4_table_element(_left, shift(shift($@)))])],
|
||||
[$1], _center, [dnl
|
||||
ifelse([$2],,,
|
||||
<td align=center>[$2]</td>[__m4_table_element(_center, shift(shift($@)))])],
|
||||
[$1], _right, [dnl
|
||||
ifelse([$2],,,
|
||||
<td align=right>[$2]</td>[__m4_table_element(_right, shift(shift($@)))])],
|
||||
[$1], _empty,
|
||||
<td><br></td>[__m4_table_element(shift($@))],
|
||||
<td>[$1]</td>[__m4_table_element(shift($@))])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Index.
|
||||
dnl ###################################################################
|
||||
dnl __m4_icnt --
|
||||
dnl In HTML land, each index element gets its own unique address that
|
||||
dnl we generate based on an incremented variable, __m4_icnt.
|
||||
define(__m4_icnt, 1)
|
||||
|
||||
dnl m4_idefz --
|
||||
dnl $N string(s) to index
|
||||
define(m4_idefz, [dnl
|
||||
ifelse([$1],,, [dnl
|
||||
m4_idef([<!--meow-->],dnl
|
||||
ifelse(index($1,@),-1,@$1,$1))m4_idefz(shift($@))])])
|
||||
|
||||
dnl m4_idef --
|
||||
dnl Index definition.
|
||||
dnl $1 display text
|
||||
dnl $2 string to index [optional]
|
||||
define(m4_idef, [dnl
|
||||
ifelse($#, 1, [dnl
|
||||
<a name="$1">$1</a>dnl
|
||||
syscmd(echo "__APIREL__/M4PAGEPATH[__OCT__]$1 __m4_pagename@$1" >> _m4_ipath)],[dnl
|
||||
define([__m4_icnt], incr(__m4_icnt))dnl
|
||||
<a name="__m4_icnt">$1</a>dnl
|
||||
syscmd(echo "__APIREL__/M4PAGEPATH[__OCT__]__m4_icnt $2" >> _m4_ipath)])])
|
||||
49
docs_src/m4/m4.init
Normal file
49
docs_src/m4/m4.init
Normal file
@@ -0,0 +1,49 @@
|
||||
dnl $Id: m4.init,v 10.22 2005/10/22 13:08:23 bostic Exp $
|
||||
|
||||
dnl The GNU m4 builtin macro format is recognized even without arguments.
|
||||
dnl This is an m4 bug, hopefully fixed in the next release.
|
||||
undefine(`format')
|
||||
|
||||
dnl Some GNU m4 releases have a builtin macro symbols.
|
||||
undefine(`symbols')
|
||||
|
||||
dnl We use our own quote characters to make things a bit easier.
|
||||
changequote([,])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Paths.
|
||||
dnl
|
||||
dnl _m4_api is the path to any API references. It's set to C++ if building
|
||||
dnl the C++ API, and to C if building the C API or sections shared by all
|
||||
dnl APIs, for example, the Reference Guide.
|
||||
dnl
|
||||
dnl _m4_ipath is the path to the index file we're building. It's set to the
|
||||
dnl real API if we're building one, and to an everything-else file, if we're
|
||||
dnl not.
|
||||
dnl ###################################################################
|
||||
define(_m4_api, [ifelse(M4API, CXX_API, [M4RELDIR/api_cxx], [M4RELDIR/api_c])])
|
||||
|
||||
define(_m4_ipath, [ifelse(dnl
|
||||
M4API, CXX_API, [M4RELDIR/api_cxx/pindex.src],
|
||||
M4API, C_API, [M4RELDIR/api_c/pindex.src],
|
||||
M4API, TCL_API, [M4RELDIR/api_tcl/pindex.src],
|
||||
[M4RELDIR/ref/pindex.src])])
|
||||
|
||||
dnl Set the path of the API index
|
||||
define(m4_iurl, [dnl
|
||||
ifelse(M4PRODUCT, XML, [dnl
|
||||
ifelse(M4API, CXX_API, [M4RELDIR/api_cxx/api_xml.html],
|
||||
M4API, TCL_API, [M4RELDIR/api_tcl/api_tcl.html],
|
||||
[M4RELDIR/api_c/api_xml.html])], [dnl
|
||||
ifelse(M4API, CXX_API, [M4RELDIR/api_cxx/api_core.html],
|
||||
M4API, TCL_API, [M4RELDIR/api_tcl/api_tcl.html],
|
||||
[M4RELDIR/api_c/api_core.html])])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Exception style.
|
||||
dnl
|
||||
dnl The C engine has returns; the C++ core engine has exceptions and return
|
||||
dnl values, but DbXml only has exceptions.
|
||||
dnl ###################################################################
|
||||
define(M4EXCEPT,
|
||||
ifelse(M4PRODUCT, XML, except_only, M4API, CXX_API, except_return, return_only))
|
||||
824
docs_src/m4/m4.links
Normal file
824
docs_src/m4/m4.links
Normal file
@@ -0,0 +1,824 @@
|
||||
dnl $Id: m4.links,v 10.410 2008/01/28 23:59:31 sarette Exp $
|
||||
dnl
|
||||
dnl #################################################################
|
||||
dnl Build a hot link to a structure/class file based on the API.
|
||||
dnl $1: C name
|
||||
dnl $2: C++ name
|
||||
dnl $3: file name
|
||||
dnl #################################################################
|
||||
define(_m4_class, [dnl
|
||||
ifelse(M4API, CXX_API, [m4_link(_m4_api/$3, $2)],
|
||||
$1, NOAPI, UNREF==$1, [m4_link(_m4_api/$3, $1)])])
|
||||
dnl
|
||||
dnl #################################################################
|
||||
dnl Build a name based on the API.
|
||||
dnl $1: C function
|
||||
dnl $2: C++ class
|
||||
dnl $3: C++ name
|
||||
dnl
|
||||
dnl If a non-existent API is referenced from a C page, it's probably a bug,
|
||||
dnl but just reference the C++ version.
|
||||
dnl #################################################################
|
||||
define(_m4_name, [ifelse(dnl
|
||||
M4API, CXX_API, [$2::$3],
|
||||
[$1], NOAPI, [$2::$3], [$1])])
|
||||
dnl
|
||||
dnl #################################################################
|
||||
dnl Build a hot link to a function/method based on the API.
|
||||
dnl $1: C function
|
||||
dnl $2: C++ class
|
||||
dnl $3: C++ name
|
||||
dnl $4: file name
|
||||
dnl
|
||||
dnl If a non-existent API is referenced from a C page, it's probably a bug,
|
||||
dnl but just reference the C++ version. There are C APIs referenced
|
||||
dnl from C++ legitimately, so if there's no C++ API, just reference the C API.
|
||||
dnl #################################################################
|
||||
define(_m4_ref, [dnl
|
||||
ifelse(M4API, CXX_API,dnl
|
||||
[ifelse($3, NOAPI,dnl
|
||||
[m4_link(M4RELDIR/api_c/$4, $1)], [m4_link(_m4_api/$4, $2::$3)])],dnl
|
||||
[ifelse($1, NOAPI,dnl
|
||||
[m4_link(M4RELDIR/api_cxx/$4, $2::$3)], [m4_link(_m4_api/$4, $1)])])])
|
||||
dnl
|
||||
dnl #################################################################
|
||||
dnl Build a hot link to a name based on the API.
|
||||
dnl $1: string to display
|
||||
dnl $2: address string in the HTML
|
||||
dnl $3: file name
|
||||
dnl
|
||||
dnl If a non-existent file is referenced from a C page, it's probably a bug,
|
||||
dnl but just reference the C++ version. There are C APIs referenced
|
||||
dnl from C++ legitimately, so if there's no C++ API, just reference the C API.
|
||||
dnl #################################################################
|
||||
define(_m4_nref, [m4_linkpage(_m4_api/$3, $2, $1)])
|
||||
dnl
|
||||
dnl #################################################################
|
||||
dnl List of possible references.
|
||||
dnl $1: name
|
||||
dnl #################################################################
|
||||
define(m4_ref, [_m4_lref([$1], M4PAGELOCAL)])
|
||||
dnl
|
||||
dnl #################################################################
|
||||
dnl If $1 matches a string in the M4PAGELOCAL define, format the name,
|
||||
dnl and don't bother with the link. We don't want to duplicate the
|
||||
dnl entire table for name translation, so we push new definitions of
|
||||
dnl the interesting macros onto a stack.
|
||||
dnl #################################################################
|
||||
define(_m4_lref, [dnl
|
||||
ifelse($2,, _m4_list($1), $2, $1, [dnl
|
||||
pushdef([_m4_ref], [_m4_name]($[1], $[2], $[3]))dnl
|
||||
pushdef([_m4_class],ifelse(M4API, C_API, $[1], $[2]))dnl
|
||||
pushdef([m4_link],$[2])dnl
|
||||
pushdef([m4_linkpage],$[3])dnl
|
||||
pushdef([_m4_nref],$[1])dnl
|
||||
_m4_list($1)[]dnl
|
||||
popdef([_m4_ref])dnl
|
||||
popdef([_m4_class])dnl
|
||||
popdef([m4_link])dnl
|
||||
popdef([m4_linkpage])dnl
|
||||
popdef([_m4_nref])],dnl
|
||||
[_m4_lref($1, shift(shift($@)))])])
|
||||
dnl #################################################################
|
||||
dnl List of references.
|
||||
dnl $1: name
|
||||
dnl #################################################################
|
||||
define(_m4_list, [ifelse(dnl
|
||||
dnl #################################################################
|
||||
dnl Environment
|
||||
dnl #################################################################
|
||||
$1, DbEnv, _m4_class(DB_ENV, DbEnv, env_class),
|
||||
$1, dbenv_close, _m4_ref(DB_ENV-__GT__close, DbEnv, close, env_close),
|
||||
$1, dbenv_create, _m4_ref(db_env_create, NOAPI, NOAPI, env_class),
|
||||
$1, dbenv_dbremove, _m4_ref(DB_ENV-__GT__dbremove, DbEnv, dbremove, env_dbremove),
|
||||
$1, dbenv_dbrename, _m4_ref(DB_ENV-__GT__dbrename, DbEnv, dbrename, env_dbrename),
|
||||
$1, dbenv_err, _m4_ref(DB_ENV-__GT__err, DbEnv, err, env_err),
|
||||
$1, dbenv_errx, _m4_ref(DB_ENV-__GT__errx, DbEnv, errx, env_err),
|
||||
$1, dbenv_failchk, _m4_ref(DB_ENV-__GT__failchk, DbEnv, failchk, env_failchk),
|
||||
$1, dbenv_fileid_reset, _m4_ref(DB_ENV-__GT__fileid_reset, DbEnv, fileid_reset, env_fileid_reset),
|
||||
$1, dbenv_get_cachesize, _m4_ref(DB_ENV-__GT__get_cachesize, DbEnv, get_cachesize, env_set_cachesize),
|
||||
$1, dbenv_get_cache_max, _m4_ref(DB_ENV-__GT__get_cache_max, DbEnv, get_cache_max, env_set_cache_max),
|
||||
$1, dbenv_get_data_dirs, _m4_ref(DB_ENV-__GT__get_data_dirs, DbEnv, get_data_dirs, env_set_data_dir),
|
||||
$1, dbenv_get_encrypt_flags, _m4_ref(DB_ENV-__GT__get_encrypt_flags, DbEnv, get_encrypt_flags, env_set_encrypt),
|
||||
$1, dbenv_get_errfile, _m4_ref(DB_ENV-__GT__get_errfile, DbEnv, get_errfile, env_set_errfile),
|
||||
$1, dbenv_get_errpfx, _m4_ref(DB_ENV-__GT__get_errpfx, DbEnv, get_errpfx, env_set_errpfx),
|
||||
$1, dbenv_get_flags, _m4_ref(DB_ENV-__GT__get_flags, DbEnv, get_flags, env_set_flag),
|
||||
$1, dbenv_get_home, _m4_ref(DB_ENV-__GT__get_home, DbEnv, get_home, env_open),
|
||||
$1, dbenv_get_intermediate_dir_mode, _m4_ref(DB_ENV-__GT__get_intermediate_dir_mode, DbEnv, get_intermediate_dir_mode, env_set_intermediate_dir_mode),
|
||||
$1, dbenv_get_lg_bsize, _m4_ref(DB_ENV-__GT__get_lg_bsize, DbEnv, get_lg_bsize, env_set_lg_bsize),
|
||||
$1, dbenv_get_lg_dir, _m4_ref(DB_ENV-__GT__get_lg_dir, DbEnv, get_lg_dir, env_set_lg_dir),
|
||||
$1, dbenv_get_lg_filemode, _m4_ref(DB_ENV-__GT__set_lg_filemode, DbEnv, set_lg_filemode, env_set_lg_mode),
|
||||
$1, dbenv_get_lg_max, _m4_ref(DB_ENV-__GT__get_lg_max, DbEnv, get_lg_max, env_set_lg_max),
|
||||
$1, dbenv_get_lg_regionmax, _m4_ref(DB_ENV-__GT__get_lg_regionmax, DbEnv, get_lg_regionmax, env_set_lg_regionmax),
|
||||
$1, dbenv_get_lk_conflicts, _m4_ref(DB_ENV-__GT__get_lk_conflicts, DbEnv, get_lk_conflicts, env_set_lk_conflicts),
|
||||
$1, dbenv_get_lk_detect, _m4_ref(DB_ENV-__GT__get_lk_detect, DbEnv, get_lk_detect, env_set_lk_detect),
|
||||
$1, dbenv_get_lk_max_lockers, _m4_ref(DB_ENV-__GT__get_lk_max_lockers, DbEnv, get_lk_max_lockers, env_set_lk_max_lockers),
|
||||
$1, dbenv_get_lk_max_locks, _m4_ref(DB_ENV-__GT__get_lk_max_locks, DbEnv, get_lk_max_locks, env_set_lk_max_locks),
|
||||
$1, dbenv_get_lk_max_objects, _m4_ref(DB_ENV-__GT__get_lk_max_objects, DbEnv, get_lk_max_objects, env_set_lk_max_objects),
|
||||
$1, dbenv_get_lk_partitions, _m4_ref(DB_ENV-__GT__get_lk_partitions, DbEnv, get_lk_partitions, env_set_lk_partitions),
|
||||
$1, dbenv_get_mp_mmapsize, _m4_ref(DB_ENV-__GT__get_mp_mmapsize, DbEnv, get_mp_mmapsize, env_set_mp_mmapsize),
|
||||
$1, dbenv_get_msgfile, _m4_ref(DB_ENV-__GT__get_msgfile, DbEnv, get_msgfile, env_get_msgfile),
|
||||
$1, dbenv_get_open_flags, _m4_ref(DB_ENV-__GT__get_open_flags, DbEnv, get_open_flags, env_open),
|
||||
$1, dbenv_get_shm_key, _m4_ref(DB_ENV-__GT__get_shm_key, DbEnv, get_shm_key, env_set_shm_key),
|
||||
$1, dbenv_get_thread_count, _m4_ref(DB_ENV-__GT__get_thread_count, DbEnv, get_thread_count, env_set_thread_count),
|
||||
$1, dbenv_get_timeout, _m4_ref(DB_ENV-__GT__get_timeout, DbEnv, get_timeout, env_set_timeout),
|
||||
$1, dbenv_get_tmp_dir, _m4_ref(DB_ENV-__GT__get_tmp_dir, DbEnv, get_tmp_dir, env_set_tmp_dir),
|
||||
$1, dbenv_get_tx_max, _m4_ref(DB_ENV-__GT__get_tx_max, DbEnv, get_tx_max, env_set_tx_max),
|
||||
$1, dbenv_get_tx_timestamp, _m4_ref(DB_ENV-__GT__get_tx_timestamp, DbEnv, get_tx_timestamp, env_set_tx_timestamp),
|
||||
$1, dbenv_get_verbose, _m4_ref(DB_ENV-__GT__get_verbose, DbEnv, get_verbose, env_set_verbose),
|
||||
$1, dbenv_get_version_major, _m4_ref(NOAPI, DbEnv, get_version_major, env_version),
|
||||
$1, dbenv_get_version_minor, _m4_ref(NOAPI, DbEnv, get_version_minor, env_version),
|
||||
$1, dbenv_get_version_patch, _m4_ref(NOAPI, DbEnv, get_version_patch, env_version),
|
||||
$1, dbenv_get_version_string, _m4_ref(NOAPI, DbEnv, get_version_string, env_version),
|
||||
$1, dbenv_log_get_config, _m4_ref(DB_ENV-__GT__log_get_config, DbEnv, log_get_config, env_log_set_config),
|
||||
$1, dbenv_log_set_config, _m4_ref(DB_ENV-__GT__log_set_config, DbEnv, log_set_config, env_log_set_config),
|
||||
$1, dbenv_lsn_reset, _m4_ref(DB_ENV-__GT__lsn_reset, DbEnv, lsn_reset, env_lsn_reset),
|
||||
$1, dbenv_open, _m4_ref(DB_ENV-__GT__open, DbEnv, open, env_open),
|
||||
$1, dbenv_remove, _m4_ref(DB_ENV-__GT__remove, DbEnv, remove, env_remove),
|
||||
$1, dbenv_set_alloc, _m4_ref(DB_ENV-__GT__set_alloc, DbEnv, set_alloc, env_set_alloc),
|
||||
$1, dbenv_set_app_dispatch, _m4_ref(DB_ENV-__GT__set_app_dispatch, DbEnv, set_app_dispatch, env_set_app_dispatch),
|
||||
$1, dbenv_set_cachesize, _m4_ref(DB_ENV-__GT__set_cachesize, DbEnv, set_cachesize, env_set_cachesize),
|
||||
$1, dbenv_set_cache_max, _m4_ref(DB_ENV-__GT__set_cache_max, DbEnv, set_cache_max, env_set_cache_max),
|
||||
$1, dbenv_set_data_dir, _m4_ref(DB_ENV-__GT__set_data_dir, DbEnv, set_data_dir, env_set_data_dir),
|
||||
$1, dbenv_set_encrypt, _m4_ref(DB_ENV-__GT__set_encrypt, DbEnv, set_encrypt, env_set_encrypt),
|
||||
$1, dbenv_set_errcall, _m4_ref(DB_ENV-__GT__set_errcall, DbEnv, set_errcall, env_set_errcall),
|
||||
$1, dbenv_set_errfile, _m4_ref(DB_ENV-__GT__set_errfile, DbEnv, set_errfile, env_set_errfile),
|
||||
$1, dbenv_set_error_stream, _m4_ref(NOAPI, DbEnv, set_error_stream, env_set_error_stream),
|
||||
$1, dbenv_set_errpfx, _m4_ref(DB_ENV-__GT__set_errpfx, DbEnv, set_errpfx, env_set_errpfx),
|
||||
$1, dbenv_set_event_notify, _m4_ref(DB_ENV-__GT__set_event_notify, DbEnv, set_event_notify, env_event_notify),
|
||||
$1, dbenv_set_feedback, _m4_ref(DB_ENV-__GT__set_feedback, DbEnv, set_feedback, env_set_feedback),
|
||||
$1, dbenv_set_flags, _m4_ref(DB_ENV-__GT__set_flags, DbEnv, set_flags, env_set_flags),
|
||||
$1, dbenv_set_intermediate_dir_mode, _m4_ref(DB_ENV-__GT__set_intermediate_dir_mode, DbEnv, set_intermediate_dir_mode, env_set_intermediate_dir_mode),
|
||||
$1, dbenv_set_isalive, _m4_ref(DB_ENV-__GT__set_isalive, DbEnv, set_isalive, env_set_isalive),
|
||||
$1, dbenv_set_lg_bsize, _m4_ref(DB_ENV-__GT__set_lg_bsize, DbEnv, set_lg_bsize, env_set_lg_bsize),
|
||||
$1, dbenv_set_lg_dir, _m4_ref(DB_ENV-__GT__set_lg_dir, DbEnv, set_lg_dir, env_set_lg_dir),
|
||||
$1, dbenv_set_lg_filemode, _m4_ref(DB_ENV-__GT__set_lg_filemode, DbEnv, set_lg_filemode, env_set_lg_mode),
|
||||
$1, dbenv_set_lg_max, _m4_ref(DB_ENV-__GT__set_lg_max, DbEnv, set_lg_max, env_set_lg_max),
|
||||
$1, dbenv_set_lg_regionmax, _m4_ref(DB_ENV-__GT__set_lg_regionmax, DbEnv, set_lg_regionmax, env_set_lg_regionmax),
|
||||
$1, dbenv_set_lk_conflicts, _m4_ref(DB_ENV-__GT__set_lk_conflicts, DbEnv, set_lk_conflicts, env_set_lk_conflicts),
|
||||
$1, dbenv_set_lk_detect, _m4_ref(DB_ENV-__GT__set_lk_detect, DbEnv, set_lk_detect, env_set_lk_detect),
|
||||
$1, dbenv_set_lk_max_lockers, _m4_ref(DB_ENV-__GT__set_lk_max_lockers, DbEnv, set_lk_max_lockers, env_set_lk_max_lockers),
|
||||
$1, dbenv_set_lk_max_locks, _m4_ref(DB_ENV-__GT__set_lk_max_locks, DbEnv, set_lk_max_locks, env_set_lk_max_locks),
|
||||
$1, dbenv_set_lk_max_objects, _m4_ref(DB_ENV-__GT__set_lk_max_objects, DbEnv, set_lk_max_objects, env_set_lk_max_objects),
|
||||
$1, dbenv_set_lk_partitions, _m4_ref(DB_ENV-__GT__set_lk_partitions, DbEnv, set_lk_partitions, env_set_lk_partitions),
|
||||
$1, dbenv_set_message_stream, _m4_ref(NOAPI, DbEnv, set_message_stream, env_set_msg_stream),
|
||||
$1, dbenv_set_mp_mmapsize, _m4_ref(DB_ENV-__GT__set_mp_mmapsize, DbEnv, set_mp_mmapsize, env_set_mp_mmapsize),
|
||||
$1, dbenv_set_msgcall, _m4_ref(DB_ENV-__GT__set_msgcall, DbEnv, set_msgcall, env_set_msgcall),
|
||||
$1, dbenv_set_msgfile, _m4_ref(DB_ENV-__GT__set_msgfile, DbEnv, set_msgfile, env_set_msgfile),
|
||||
$1, dbenv_set_rpc_server, _m4_ref(DB_ENV-__GT__set_rpc_server, DbEnv, set_rpc_server, env_set_rpc_server),
|
||||
$1, dbenv_set_shm_key, _m4_ref(DB_ENV-__GT__set_shm_key, DbEnv, set_shm_key, env_set_shm_key),
|
||||
$1, dbenv_set_thread_count, _m4_ref(DB_ENV-__GT__set_thread_count, DbEnv, set_thread_count, env_set_thread_count),
|
||||
$1, dbenv_set_thread_id, _m4_ref(DB_ENV-__GT__set_thread_id, DbEnv, set_thread_id, env_set_thread_id),
|
||||
$1, dbenv_set_thread_id_string, _m4_ref(DB_ENV-__GT__set_thread_id_string, DbEnv, set_thread_id_string, env_set_thread_id_string),
|
||||
$1, dbenv_set_timeout, _m4_ref(DB_ENV-__GT__set_timeout, DbEnv, set_timeout, env_set_timeout),
|
||||
$1, dbenv_set_tmp_dir, _m4_ref(DB_ENV-__GT__set_tmp_dir, DbEnv, set_tmp_dir, env_set_tmp_dir),
|
||||
$1, dbenv_set_tx_max, _m4_ref(DB_ENV-__GT__set_tx_max, DbEnv, set_tx_max, env_set_tx_max),
|
||||
$1, dbenv_set_tx_timestamp, _m4_ref(DB_ENV-__GT__set_tx_timestamp, DbEnv, set_tx_timestamp, env_set_tx_timestamp),
|
||||
$1, dbenv_set_verbose, _m4_ref(DB_ENV-__GT__set_verbose, DbEnv, set_verbose, env_set_verbose),
|
||||
$1, dbenv_stat_print, _m4_ref(DB_ENV-__GT__stat_print, DbEnv, stat_print, env_stat),
|
||||
$1, dbenv_strerror, _m4_ref(db_strerror, DbEnv, strerror, env_strerror),
|
||||
$1, dbenv_version, _m4_ref(db_version, DbEnv, version, env_version),
|
||||
dnl #################################################################
|
||||
dnl Db
|
||||
dnl #################################################################
|
||||
$1, Db, _m4_class(DB, Db, db_class),
|
||||
$1, dbh_associate, _m4_ref(DB-__GT__associate, Db, associate, db_associate),
|
||||
$1, dbh_close, _m4_ref(DB-__GT__close, Db, close, db_close),
|
||||
$1, dbh_compact, _m4_ref(DB-__GT__compact, Db, compact, db_compact),
|
||||
$1, dbh_create, _m4_ref(db_create, NOAPI, NOAPI, db_class),
|
||||
$1, dbh_del, _m4_ref(DB-__GT__del, Db, del, db_del),
|
||||
$1, dbh_err, _m4_ref(DB-__GT__err, Db, err, db_err),
|
||||
$1, dbh_errx, _m4_ref(DB-__GT__errx, Db, errx, db_err),
|
||||
$1, dbh_exists, _m4_ref(DB-__GT__exists, Db, exists, db_exists),
|
||||
$1, dbh_fd, _m4_ref(DB-__GT__fd, Db, fd, db_fd),
|
||||
$1, dbh_get, _m4_ref(DB-__GT__get, Db, get, db_get),
|
||||
$1, dbh_get_bt_minkey, _m4_ref(DB-__GT__get_bt_minkey, Db, get_bt_minkey, db_set_bt_minkey),
|
||||
$1, dbh_get_byteswapped, _m4_ref(DB-__GT__get_byteswapped, Db, get_byteswapped, db_get_byteswapped),
|
||||
$1, dbh_get_cachesize, _m4_ref(DB-__GT__get_cachesize, Db, get_cachesize, db_set_cachesize),
|
||||
$1, dbh_get_dbname, _m4_ref(DB-__GT__get_dbname, Db, get_dbname, db_open),
|
||||
$1, dbh_get_encrypt_flags, _m4_ref(DB-__GT__get_encrypt_flags, Db, get_encrypt_flags, db_set_encrypt),
|
||||
$1, dbh_get_errfile, _m4_ref(DB-__GT__get_errfile, Db, get_errfile, db_set_errfile),
|
||||
$1, dbh_get_errpfx, _m4_ref(DB-__GT__get_errpfx, Db, get_errpfx, db_set_errpfx),
|
||||
$1, dbh_get_file, _m4_ref(DB-__GT__get_file, Db, get_file, db_open),
|
||||
$1, dbh_get_flags, _m4_ref(DB-__GT__get_flags, Db, get_flags, db_set_flags),
|
||||
$1, dbh_get_h_ffactor, _m4_ref(DB-__GT__get_h_ffactor, Db, get_h_ffactor, db_set_h_ffactor),
|
||||
$1, dbh_get_h_nelem, _m4_ref(DB-__GT__get_h_nelem, Db, get_h_nelem, db_set_h_nelem),
|
||||
$1, dbh_get_lorder, _m4_ref(DB-__GT__get_lorder, Db, get_lorder, db_set_lorder),
|
||||
$1, dbh_get_mpf, _m4_ref(DB-__GT__get_mpf, Db, get_mpf, db_get_mpf),
|
||||
$1, dbh_get_msgfile, _m4_ref(DB-__GT__get_msgfile, Db, get_msgfile, db_get_msgfile),
|
||||
$1, dbh_get_multiple, _m4_ref(DB-__GT__get_multiple, Db, get_multiple, db_open),
|
||||
$1, dbh_get_open_flags, _m4_ref(DB-__GT__get_open_flags, Db, get_open_flags, db_set_open_flags),
|
||||
$1, dbh_get_pagesize, _m4_ref(DB-__GT__get_pagesize, Db, get_pagesize, db_set_pagesize),
|
||||
$1, dbh_get_priority, _m4_ref(DB-__GT__get_priority, Db, get_priority, db_set_priority),
|
||||
$1, dbh_get_q_extentsize, _m4_ref(DB-__GT__get_q_extentsize, Db, get_q_extentsize, db_set_q_extentsize),
|
||||
$1, dbh_get_re_delim, _m4_ref(DB-__GT__get_re_delim, Db, get_re_delim, db_set_re_delim),
|
||||
$1, dbh_get_re_len, _m4_ref(DB-__GT__get_re_len, Db, get_re_len, db_set_re_len),
|
||||
$1, dbh_get_re_pad, _m4_ref(DB-__GT__get_re_pad, Db, get_re_pad, db_set_re_pad),
|
||||
$1, dbh_get_re_source, _m4_ref(DB-__GT__get_re_source, Db, get_re_source, db_set_re_source),
|
||||
$1, dbh_get_transactional, _m4_ref(DB-__GT__get_transactional, Db, get_transactional, db_open),
|
||||
$1, dbh_get_type, _m4_ref(DB-__GT__get_type, Db, get_type, db_get_type),
|
||||
$1, dbh_getenv, _m4_ref(DB-__GT__get_env, Db, getenv, db_getenv),
|
||||
$1, dbh_is_encrypted, _m4_ref(NOAPI, Db, is_encrypted, db_set_encrypt),
|
||||
$1, dbh_join, _m4_ref(DB-__GT__join, Db, join, db_join),
|
||||
$1, dbh_key_range, _m4_ref(DB-__GT__key_range, Db, key_range, db_key_range),
|
||||
$1, dbh_open, _m4_ref(DB-__GT__open, Db, open, db_open),
|
||||
$1, dbh_pget, _m4_ref(DB-__GT__pget, Db, pget, db_get),
|
||||
$1, dbh_put, _m4_ref(DB-__GT__put, Db, put, db_put),
|
||||
$1, dbh_remove, _m4_ref(DB-__GT__remove, Db, remove, db_remove),
|
||||
$1, dbh_rename, _m4_ref(DB-__GT__rename, Db, rename, db_rename),
|
||||
$1, dbh_set_alloc, _m4_ref(DB-__GT__set_alloc, Db, set_alloc, db_set_alloc),
|
||||
$1, dbh_set_append_recno, _m4_ref(DB-__GT__set_append_recno, Db, set_append_recno, db_set_append_recno),
|
||||
$1, dbh_set_bt_compare, _m4_ref(DB-__GT__set_bt_compare, Db, set_bt_compare, db_set_bt_compare),
|
||||
$1, dbh_set_bt_minkey, _m4_ref(DB-__GT__set_bt_minkey, Db, set_bt_minkey, db_set_bt_minkey),
|
||||
$1, dbh_set_bt_prefix, _m4_ref(DB-__GT__set_bt_prefix, Db, set_bt_prefix, db_set_bt_prefix),
|
||||
$1, dbh_set_cachesize, _m4_ref(DB-__GT__set_cachesize, Db, set_cachesize, db_set_cachesize),
|
||||
$1, dbh_set_dup_compare, _m4_ref(DB-__GT__set_dup_compare, Db, set_dup_compare, db_set_dup_compare),
|
||||
$1, dbh_set_encrypt, _m4_ref(DB-__GT__set_encrypt, Db, set_encrypt, db_set_encrypt),
|
||||
$1, dbh_set_errcall, _m4_ref(DB-__GT__set_errcall, Db, set_errcall, db_set_errcall),
|
||||
$1, dbh_set_errfile, _m4_ref(DB-__GT__set_errfile, Db, set_errfile, db_set_errfile),
|
||||
$1, dbh_set_error_stream, _m4_ref(NOAPI, Db, set_error_stream, db_set_error_stream),
|
||||
$1, dbh_set_errpfx, _m4_ref(DB-__GT__set_errpfx, Db, set_errpfx, db_set_errpfx),
|
||||
$1, dbh_set_feedback, _m4_ref(DB-__GT__set_feedback, Db, set_feedback, db_set_feedback),
|
||||
$1, dbh_set_flags, _m4_ref(DB-__GT__set_flags, Db, set_flags, db_set_flags),
|
||||
$1, dbh_set_h_compare, _m4_ref(DB-__GT__set_h_compare, Db, set_h_compare, db_set_h_compare),
|
||||
$1, dbh_set_h_ffactor, _m4_ref(DB-__GT__set_h_ffactor, Db, set_h_ffactor, db_set_h_ffactor),
|
||||
$1, dbh_set_h_hash, _m4_ref(DB-__GT__set_h_hash, Db, set_h_hash, db_set_h_hash),
|
||||
$1, dbh_set_h_nelem, _m4_ref(DB-__GT__set_h_nelem, Db, set_h_nelem, db_set_h_nelem),
|
||||
$1, dbh_set_lorder, _m4_ref(DB-__GT__set_lorder, Db, set_lorder, db_set_lorder),
|
||||
$1, dbh_set_message_stream, _m4_ref(NOAPI, Db, set_message_stream, db_set_msg_stream),
|
||||
$1, dbh_set_msgcall, _m4_ref(DB-__GT__set_msgcall, Db, set_msgcall, db_set_msgcall),
|
||||
$1, dbh_set_msgfile, _m4_ref(DB-__GT__set_msgfile, Db, set_msgfile, db_set_msgfile),
|
||||
$1, dbh_set_pagesize, _m4_ref(DB-__GT__set_pagesize, Db, set_pagesize, db_set_pagesize),
|
||||
$1, dbh_set_priority, _m4_ref(DB-__GT__set_priority, Db, set_priority, db_set_priority),
|
||||
$1, dbh_set_q_extentsize, _m4_ref(DB-__GT__set_q_extentsize, Db, set_q_extentsize, db_set_q_extentsize),
|
||||
$1, dbh_set_re_delim, _m4_ref(DB-__GT__set_re_delim, Db, set_re_delim, db_set_re_delim),
|
||||
$1, dbh_set_re_len, _m4_ref(DB-__GT__set_re_len, Db, set_re_len, db_set_re_len),
|
||||
$1, dbh_set_re_pad, _m4_ref(DB-__GT__set_re_pad, Db, set_re_pad, db_set_re_pad),
|
||||
$1, dbh_set_re_source, _m4_ref(DB-__GT__set_re_source, Db, set_re_source, db_set_re_source),
|
||||
$1, dbh_stat, _m4_ref(DB-__GT__stat, Db, stat, db_stat),
|
||||
$1, dbh_stat_print, _m4_ref(DB-__GT__stat_print, Db, stat_print, db_stat),
|
||||
$1, dbh_sync, _m4_ref(DB-__GT__sync, Db, sync, db_sync),
|
||||
$1, dbh_truncate, _m4_ref(DB-__GT__truncate, Db, truncate, db_truncate),
|
||||
$1, dbh_upgrade, _m4_ref(DB-__GT__upgrade, Db, upgrade, db_upgrade),
|
||||
$1, dbh_verify, _m4_ref(DB-__GT__verify, Db, verify, db_verify),
|
||||
dnl #################################################################
|
||||
dnl Dbc.
|
||||
dnl #################################################################
|
||||
$1, Dbc, _m4_class(DBC, Dbc, dbc_class),
|
||||
$1, dbh_cursor, _m4_ref(DB-__GT__cursor, Db, cursor, db_cursor),
|
||||
$1, dbc_close, _m4_ref(DBcursor-__GT__close, Dbc, close, dbc_close),
|
||||
$1, dbc_count, _m4_ref(DBcursor-__GT__count, Dbc, count, dbc_count),
|
||||
$1, dbc_del, _m4_ref(DBcursor-__GT__del, Dbc, del, dbc_del),
|
||||
$1, dbc_dup, _m4_ref(DBcursor-__GT__dup, Dbc, dup, dbc_dup),
|
||||
$1, dbc_get, _m4_ref(DBcursor-__GT__get, Dbc, get, dbc_get),
|
||||
$1, dbc_get_priority, _m4_ref(DBcursor-__GT__get_priority, Dbc, get_priority, dbc_set_priority),
|
||||
$1, dbc_pget, _m4_ref(DBcursor-__GT__pget, Dbc, pget, dbc_get),
|
||||
$1, dbc_put, _m4_ref(DBcursor-__GT__put, Dbc, put, dbc_put),
|
||||
$1, dbc_set_priority, _m4_ref(DBcursor-__GT__set_priority, Dbc, set_priority, dbc_set_priority),
|
||||
dnl #################################################################
|
||||
dnl Exception classes.
|
||||
dnl #################################################################
|
||||
$1, DbDeadlockException, _m4_class(NOAPI, DbDeadlockException, deadlock_class),
|
||||
$1, DbException, _m4_class(NOAPI, DbException, except_class),
|
||||
$1, DbLockNotGrantedException, _m4_class(NOAPI, DbLockNotGrantedException, lockng_class),
|
||||
$1, DbMemoryException, _m4_class(NOAPI, DbMemoryException, memp_class),
|
||||
$1, DbRunRecoveryException, _m4_class(NOAPI, DbRunRecoveryException, runrec_class),
|
||||
$1, except_get_errno, _m4_ref(NOAPI, DbException, get_errno, except_class),
|
||||
$1, except_what, _m4_ref(NOAPI, DbException, what, except_class),
|
||||
$1, except_get_env, _m4_ref(NOAPI, DbException, get_env, except_class),
|
||||
dnl #################################################################
|
||||
dnl Locking.
|
||||
dnl #################################################################
|
||||
$1, DbLock, _m4_class(DB_LOCK, DbLock, lock_class),
|
||||
$1, DbLockRequest, DB_LOCKREQ,
|
||||
$1, lock_detect, _m4_ref(DB_ENV-__GT__lock_detect, DbEnv, lock_detect, lock_detect),
|
||||
$1, lock_get, _m4_ref(DB_ENV-__GT__lock_get, DbEnv, lock_get, lock_get),
|
||||
$1, lock_id, _m4_ref(DB_ENV-__GT__lock_id, DbEnv, lock_id, lock_id),
|
||||
$1, lock_id_free, _m4_ref(DB_ENV-__GT__lock_id_free, DbEnv, lock_id_free, lock_id_free),
|
||||
$1, lock_put, _m4_ref(DB_ENV-__GT__lock_put, DbEnv, lock_put, lock_put),
|
||||
$1, lock_stat, _m4_ref(DB_ENV-__GT__lock_stat, DbEnv, lock_stat, lock_stat),
|
||||
$1, lock_stat_print, _m4_ref(DB_ENV-__GT__lock_stat_print, DbEnv, lock_stat_print, lock_stat),
|
||||
$1, lock_vec, _m4_ref(DB_ENV-__GT__lock_vec, DbEnv, lock_vec, lock_vec),
|
||||
$1, cdsgroup_begin, _m4_ref(DB_ENV-__GT__cdsgroup_begin, DbEnv, cdsgroup_begin, env_cdsgroup_begin),
|
||||
dnl #################################################################
|
||||
dnl Logging.
|
||||
dnl #################################################################
|
||||
$1, DbLogc, _m4_class(DB_LOGC, DbLogc, logc_class),
|
||||
$1, DbLsn, _m4_class(DB_LSN, DbLsn, lsn_class),
|
||||
$1, log_archive, _m4_ref(DB_ENV-__GT__log_archive, DbEnv, log_archive, log_archive),
|
||||
$1, log_compare, _m4_ref(log_compare, DbEnv, log_compare, log_compare),
|
||||
$1, log_cursor, _m4_ref(DB_ENV-__GT__log_cursor, DbEnv, log_cursor, log_cursor),
|
||||
$1, log_file, _m4_ref(DB_ENV-__GT__log_file, DbEnv, log_file, log_file),
|
||||
$1, log_flush, _m4_ref(DB_ENV-__GT__log_flush, DbEnv, log_flush, log_flush),
|
||||
$1, log_printf, _m4_ref(DB_ENV-__GT__log_printf, DbEnv, log_printf, log_printf),
|
||||
$1, log_put, _m4_ref(DB_ENV-__GT__log_put, DbEnv, log_put, log_put),
|
||||
$1, log_stat, _m4_ref(DB_ENV-__GT__log_stat, DbEnv, log_stat, log_stat),
|
||||
$1, log_stat_print, _m4_ref(DB_ENV-__GT__log_stat_print, DbEnv, log_stat_print, log_stat),
|
||||
$1, logc_close, _m4_ref(DB_LOGC-__GT__close, DbLogc, close, logc_close),
|
||||
$1, logc_get, _m4_ref(DB_LOGC-__GT__get, DbLogc, get, logc_get),
|
||||
dnl #################################################################
|
||||
dnl Memory Pool.
|
||||
dnl #################################################################
|
||||
$1, DbMpoolFile, _m4_class(DB_MPOOLFILE, DbMpoolFile, mempfile_class),
|
||||
$1, memp_fclose, _m4_ref(DB_MPOOLFILE-__GT__close, DbMpoolFile, close, memp_fclose),
|
||||
$1, memp_fcreate, _m4_ref(DB_ENV-__GT__memp_fcreate, DbEnv, memp_fcreate, memp_fcreate),
|
||||
$1, memp_fget, _m4_ref(DB_MPOOLFILE-__GT__get, DbMpoolFile, get, memp_fget),
|
||||
$1, memp_fopen, _m4_ref(DB_MPOOLFILE-__GT__open, DbMpoolFile, open, memp_fopen),
|
||||
$1, memp_fput, _m4_ref(DB_MPOOLFILE-__GT__put, DbMpoolFile, put, memp_fput),
|
||||
$1, memp_fstat, _m4_ref(NOAPI, DbEnv, memp_fstat, memp_stat),
|
||||
$1, memp_fsync, _m4_ref(DB_MPOOLFILE-__GT__sync, DbMpoolFile, sync, memp_fsync),
|
||||
$1, memp_get_clear_len, _m4_ref(DB_MPOOLFILE-__GT__get_clear_len, DbMpoolFile, get_clear_len, memp_set_clear_len),
|
||||
$1, memp_get_fileid, _m4_ref(DB_MPOOLFILE-__GT__get_fileid, DbMpoolFile, get_fileid, memp_set_fileid),
|
||||
$1, memp_get_flags, _m4_ref(DB_MPOOLFILE-__GT__get_flags, DbMpoolFile, get_flags, memp_set_flags),
|
||||
$1, memp_get_ftype, _m4_ref(DB_MPOOLFILE-__GT__get_ftype, DbMpoolFile, get_ftype, memp_set_ftype),
|
||||
$1, memp_get_lsn_offset, _m4_ref(DB_MPOOLFILE-__GT__get_lsn_offset, DbMpoolFile, get_lsn_offset, memp_set_lsn_offset),
|
||||
$1, memp_get_max_openfd, _m4_ref(DB_ENV-__GT__get_mp_max_openfd, DbEnv, get_mp_max_openfd, memp_openfd),
|
||||
$1, memp_get_max_write, _m4_ref(DB_ENV-__GT__get_mp_max_write, DbEnv, get_mp_max_write, memp_maxwrite),
|
||||
$1, memp_get_maxsize, _m4_ref(DB_MPOOLFILE-__GT__get_maxsize, DbMpoolFile, get_maxsize, memp_set_maxsize),
|
||||
$1, memp_get_pgcookie, _m4_ref(DB_MPOOLFILE-__GT__get_pgcookie, DbMpoolFile, get_pgcookie, memp_set_pgcookie),
|
||||
$1, memp_get_priority, _m4_ref(DB_MPOOLFILE-__GT__get_priority, DbMpoolFile, get_priority, memp_set_priority),
|
||||
$1, memp_register, _m4_ref(DB_ENV-__GT__memp_register, DbEnv, memp_register, memp_register),
|
||||
$1, memp_set_clear_len, _m4_ref(DB_MPOOLFILE-__GT__set_clear_len, DbMpoolFile, set_clear_len, memp_set_clear_len),
|
||||
$1, memp_set_fileid, _m4_ref(DB_MPOOLFILE-__GT__set_fileid, DbMpoolFile, set_fileid, memp_set_fileid),
|
||||
$1, memp_set_flags, _m4_ref(DB_MPOOLFILE-__GT__set_flags, DbMpoolFile, set_flags, memp_set_flags),
|
||||
$1, memp_set_ftype, _m4_ref(DB_MPOOLFILE-__GT__set_ftype, DbMpoolFile, set_ftype, memp_set_ftype),
|
||||
$1, memp_set_lsn_offset, _m4_ref(DB_MPOOLFILE-__GT__set_lsn_offset, DbMpoolFile, set_lsn_offset, memp_set_lsn_offset),
|
||||
$1, memp_set_max_openfd, _m4_ref(DB_ENV-__GT__set_mp_max_openfd, DbEnv, set_mp_max_openfd, memp_openfd),
|
||||
$1, memp_set_max_write, _m4_ref(DB_ENV-__GT__set_mp_max_write, DbEnv, set_mp_max_write, memp_maxwrite),
|
||||
$1, memp_set_maxsize, _m4_ref(DB_MPOOLFILE-__GT__set_maxsize, DbMpoolFile, set_maxsize, memp_set_maxsize),
|
||||
$1, memp_set_pgcookie, _m4_ref(DB_MPOOLFILE-__GT__set_pgcookie, DbMpoolFile, set_pgcookie, memp_set_pgcookie),
|
||||
$1, memp_set_priority, _m4_ref(DB_MPOOLFILE-__GT__set_priority, DbMpoolFile, set_priority, memp_set_priority),
|
||||
$1, memp_stat, _m4_ref(DB_ENV-__GT__memp_stat, DbEnv, memp_stat, memp_stat),
|
||||
$1, memp_stat_print, _m4_ref(DB_ENV-__GT__memp_stat_print, DbEnv, memp_stat_print, memp_stat),
|
||||
$1, memp_sync, _m4_ref(DB_ENV-__GT__memp_sync, DbEnv, memp_sync, memp_sync),
|
||||
$1, memp_trickle, _m4_ref(DB_ENV-__GT__memp_trickle, DbEnv, memp_trickle, memp_trickle),
|
||||
dnl #################################################################
|
||||
dnl Mutex.
|
||||
dnl #################################################################
|
||||
$1, mutex_alloc, _m4_ref(DB_ENV-__GT__mutex_alloc, DbEnv, mutex_alloc, mutex_alloc),
|
||||
$1, mutex_free, _m4_ref(DB_ENV-__GT__mutex_free, DbEnv, mutex_free, mutex_free),
|
||||
$1, mutex_get_align, _m4_ref(DB_ENV-__GT__mutex_get_align, DbEnv, mutex_get_align, mutex_set_align),
|
||||
$1, mutex_get_increment, _m4_ref(DB_ENV-__GT__mutex_get_increment, DbEnv, mutex_get_increment, mutex_set_max),
|
||||
$1, mutex_get_max, _m4_ref(DB_ENV-__GT__mutex_get_max, DbEnv, mutex_get_max, mutex_set_max),
|
||||
$1, mutex_get_tas_spins, _m4_ref(DB_ENV-__GT__mutex_get_tas_spins, DbEnv, mutex_get_tas_spins, mutex_set_tas_spins),
|
||||
$1, mutex_lock, _m4_ref(DB_ENV-__GT__mutex_lock, DbEnv, mutex_lock, mutex_lock),
|
||||
$1, mutex_set_align, _m4_ref(DB_ENV-__GT__mutex_set_align, DbEnv, mutex_set_align, mutex_set_align),
|
||||
$1, mutex_set_increment, _m4_ref(DB_ENV-__GT__mutex_set_increment, DbEnv, mutex_set_increment, mutex_set_max),
|
||||
$1, mutex_set_max, _m4_ref(DB_ENV-__GT__mutex_set_max, DbEnv, mutex_set_max, mutex_set_max),
|
||||
$1, mutex_set_tas_spins, _m4_ref(DB_ENV-__GT__mutex_set_tas_spins, DbEnv, mutex_set_tas_spins, mutex_set_tas_spins),
|
||||
$1, mutex_stat, _m4_ref(DB_ENV-__GT__mutex_stat, DbEnv, mutex_stat, mutex_stat),
|
||||
$1, mutex_stat_print, _m4_ref(DB_ENV-__GT__mutex_stat_print, DbEnv, mutex_stat_print, mutex_stat),
|
||||
$1, mutex_unlock, _m4_ref(DB_ENV-__GT__mutex_unlock, DbEnv, mutex_unlock, mutex_unlock),
|
||||
dnl #################################################################
|
||||
dnl Replication.
|
||||
dnl #################################################################
|
||||
$1, rep_elect, _m4_ref(DB_ENV-__GT__rep_elect, DbEnv, rep_elect, rep_elect),
|
||||
$1, rep_get_config, _m4_ref(DB_ENV-__GT__rep_get_config, DbEnv, rep_get_config, rep_get_config),
|
||||
$1, rep_get_clockskew, _m4_ref(DB_ENV-__GT__rep_get_clockskew, DbEnv, rep_get_clockskew, rep_clockskew),
|
||||
$1, rep_get_limit, _m4_ref(DB_ENV-__GT__rep_get_limit, DbEnv, rep_get_limit, rep_limit),
|
||||
$1, rep_get_nsites, _m4_ref(DB_ENV-__GT__rep_get_nsites, DbEnv, rep_get_nsites, rep_nsites),
|
||||
$1, rep_get_priority, _m4_ref(DB_ENV-__GT__rep_get_priority, DbEnv, rep_get_priority, rep_priority),
|
||||
$1, rep_get_request, _m4_ref(DB_ENV-__GT__rep_get_request, DbEnv, rep_get_request, rep_request),
|
||||
$1, rep_get_timeout, _m4_ref(DB_ENV-__GT__rep_get_timeout, DbEnv, rep_get_timeout, rep_timeout),
|
||||
$1, rep_message, _m4_ref(DB_ENV-__GT__rep_process_message, DbEnv, rep_process_message, rep_message),
|
||||
$1, rep_set_config, _m4_ref(DB_ENV-__GT__rep_set_config, DbEnv, rep_set_config, rep_config),
|
||||
$1, rep_set_clockskew, _m4_ref(DB_ENV-__GT__rep_set_clockskew, DbEnv, rep_set_clockskew, rep_clockskew),
|
||||
$1, rep_set_limit, _m4_ref(DB_ENV-__GT__rep_set_limit, DbEnv, rep_set_limit, rep_limit),
|
||||
$1, rep_set_nsites, _m4_ref(DB_ENV-__GT__rep_set_nsites, DbEnv, rep_set_nsites, rep_nsites),
|
||||
$1, rep_set_priority, _m4_ref(DB_ENV-__GT__rep_set_priority, DbEnv, rep_set_priority, rep_priority),
|
||||
$1, rep_set_request, _m4_ref(DB_ENV-__GT__rep_set_request, DbEnv, rep_set_request, rep_request),
|
||||
$1, rep_set_timeout, _m4_ref(DB_ENV-__GT__rep_set_timeout, DbEnv, rep_set_timeout, rep_timeout),
|
||||
$1, rep_set_transport, _m4_ref(DB_ENV-__GT__rep_set_transport, DbEnv, rep_set_transport, rep_transport),
|
||||
$1, rep_start, _m4_ref(DB_ENV-__GT__rep_start, DbEnv, rep_start, rep_start),
|
||||
$1, rep_stat, _m4_ref(DB_ENV-__GT__rep_stat, DbEnv, rep_stat, rep_stat),
|
||||
$1, rep_stat_print, _m4_ref(DB_ENV-__GT__rep_stat_print, DbEnv, rep_stat_print, rep_stat),
|
||||
$1, rep_sync, _m4_ref(DB_ENV-__GT__rep_sync, DbEnv, rep_sync, rep_sync),
|
||||
$1, repmgr_add_remote_site, _m4_ref(DB_ENV-__GT__repmgr_add_remote_site, DbEnv, repmgr_add_remote_site, repmgr_remote_site),
|
||||
$1, repmgr_get_ack_policy, _m4_ref(DB_ENV-__GT__repmgr_get_ack_policy, DbEnv, repmgr_get_ack_policy, repmgr_ack_policy),
|
||||
$1, repmgr_set_ack_policy, _m4_ref(DB_ENV-__GT__repmgr_set_ack_policy, DbEnv, repmgr_set_ack_policy, repmgr_ack_policy),
|
||||
$1, repmgr_set_local_site, _m4_ref(DB_ENV-__GT__repmgr_set_local_site, DbEnv, repmgr_set_local_site, repmgr_local_site),
|
||||
$1, repmgr_site_list, _m4_ref(DB_ENV-__GT__repmgr_site_list, DbEnv, repmgr_site_list, repmgr_site_list),
|
||||
$1, repmgr_start, _m4_ref(DB_ENV-__GT__repmgr_start, DbEnv, repmgr_start, repmgr_start),
|
||||
$1, repmgr_stat, _m4_ref(DB_ENV-__GT__repmgr_stat, DbEnv, repmgr_stat, repmgr_stat),
|
||||
$1, repmgr_stat_print, _m4_ref(DB_ENV-__GT__repmgr_stat_print, DbEnv, repmgr_stat_print, repmgr_stat),
|
||||
dnl #################################################################
|
||||
dnl Sequences.
|
||||
dnl #################################################################
|
||||
$1, DbSequence, _m4_class(DB_SEQUENCE, DbSequence, seq_class),
|
||||
$1, seq_close, _m4_ref(DB_SEQUENCE-__GT__close, DbSequence, close, seq_close),
|
||||
$1, seq_create, _m4_ref(db_sequence_create, NOAPI, NOAPI, seq_class),
|
||||
$1, seq_get, _m4_ref(DB_SEQUENCE-__GT__get, DbSequence, get, seq_get),
|
||||
$1, seq_get_cachesize, _m4_ref(DB_SEQUENCE-__GT__get_cachesize, DbSequence, get_cachesize, seq_set_cachesize),
|
||||
$1, seq_get_dbp, _m4_ref(DB_SEQUENCE-__GT__get_dbp, DbSequence, get_dbp, seq_open),
|
||||
$1, seq_get_flags, _m4_ref(DB_SEQUENCE-__GT__get_flags, DbSequence, get_flags, seq_set_flags),
|
||||
$1, seq_get_key, _m4_ref(DB_SEQUENCE-__GT__get_key, DbSequence, get_key, seq_open),
|
||||
$1, seq_get_range, _m4_ref(DB_SEQUENCE-__GT__get_range, DbSequence, get_range, seq_set_range),
|
||||
$1, seq_initial_value, _m4_ref(DB_SEQUENCE-__GT__initial_value, DbSequence, initial_value, seq_initial_value),
|
||||
$1, seq_open, _m4_ref(DB_SEQUENCE-__GT__open, DbSequence, open, seq_open),
|
||||
$1, seq_remove, _m4_ref(DB_SEQUENCE-__GT__remove, DbSequence, remove, seq_remove),
|
||||
$1, seq_set_cachesize, _m4_ref(DB_SEQUENCE-__GT__set_cachesize, DbSequence, set_cachesize, seq_set_cachesize),
|
||||
$1, seq_set_flags, _m4_ref(DB_SEQUENCE-__GT__set_flags, DbSequence, set_flags, seq_set_flags),
|
||||
$1, seq_set_range, _m4_ref(DB_SEQUENCE-__GT__set_range, DbSequence, set_range, seq_set_range),
|
||||
$1, seq_stat, _m4_ref(DB_SEQUENCE-__GT__stat, DbSequence, stat, seq_stat),
|
||||
$1, seq_stat_print, _m4_ref(DB_SEQUENCE-__GT__stat_print, DbSequence, stat_print, seq_stat),
|
||||
dnl #################################################################
|
||||
dnl Transactions.
|
||||
dnl #################################################################
|
||||
$1, DbTxn, _m4_class(DB_TXN, DbTxn, txn_class),
|
||||
$1, txn_abort, _m4_ref(DB_TXN-__GT__abort, DbTxn, abort, txn_abort),
|
||||
$1, txn_begin, _m4_ref(DB_ENV-__GT__txn_begin, DbEnv, txn_begin, txn_begin),
|
||||
$1, txn_checkpoint, _m4_ref(DB_ENV-__GT__txn_checkpoint, DbEnv, txn_checkpoint, txn_checkpoint),
|
||||
$1, txn_commit, _m4_ref(DB_TXN-__GT__commit, DbTxn, commit, txn_commit),
|
||||
$1, txn_discard, _m4_ref(DB_TXN-__GT__discard, DbTxn, discard, txn_discard),
|
||||
$1, txn_get_name, _m4_ref(DB_TXN-__GT__get_name, DbTxn, get_name, txn_get_name),
|
||||
$1, txn_id, _m4_ref(DB_TXN-__GT__id, DbTxn, id, txn_id),
|
||||
$1, txn_prepare, _m4_ref(DB_TXN-__GT__prepare, DbTxn, prepare, txn_prepare),
|
||||
$1, txn_recover, _m4_ref(DB_ENV-__GT__txn_recover, DbEnv, txn_recover, txn_recover),
|
||||
$1, txn_set_name, _m4_ref(DB_TXN-__GT__set_name, DbTxn, set_name, txn_set_name),
|
||||
$1, txn_set_timeout, _m4_ref(DB_TXN-__GT__set_timeout, DbTxn, set_timeout, txn_set_timeout),
|
||||
$1, txn_stat, _m4_ref(DB_ENV-__GT__txn_stat, DbEnv, txn_stat, txn_stat),
|
||||
$1, txn_stat_print, _m4_ref(DB_ENV-__GT__txn_stat_print, DbEnv, txn_stat_print, txn_stat),
|
||||
dnl #################################################################
|
||||
dnl Dbt
|
||||
dnl #################################################################
|
||||
$1, DbMultipleDataIterator, _m4_class(NOAPI, DbMultipleDataIterator, dbt_bulk_class),
|
||||
$1, DbMultipleIterator, _m4_class(NOAPI, DbMultipleIterator, dbt_bulk_class),
|
||||
$1, DbMultipleKeyDataIterator, _m4_class(NOAPI, DbMultipleKeyDataIterator, dbt_bulk_class),
|
||||
$1, DbMultipleRecnoDataIterator, _m4_class(NOAPI, DbMultipleRecnoDataIterator, dbt_bulk_class),
|
||||
$1, Dbt, _m4_class(DBT, Dbt, dbt_class),
|
||||
$1, dbt_get_data, _m4_ref(NOAPI, Dbt, get_data, dbt_class),
|
||||
$1, dbt_get_dlen, _m4_ref(NOAPI, Dbt, get_dlen, dbt_class),
|
||||
$1, dbt_get_doff, _m4_ref(NOAPI, Dbt, get_doff, dbt_class),
|
||||
$1, dbt_get_flags, _m4_ref(NOAPI, Dbt, get_flags, dbt_class),
|
||||
$1, dbt_get_offset, _m4_ref(NOAPI, Dbt, get_offset, dbt_class),
|
||||
$1, dbt_get_recno_key_data, _m4_ref(NOAPI, Dbt, get_recno_key_data, dbt_class),
|
||||
$1, dbt_get_size, _m4_ref(NOAPI, Dbt, get_size, dbt_class),
|
||||
$1, dbt_get_ulen, _m4_ref(NOAPI, Dbt, get_ulen, dbt_class),
|
||||
$1, dbt_set_data, _m4_ref(NOAPI, Dbt, set_data, dbt_class),
|
||||
$1, dbt_set_dlen, _m4_ref(NOAPI, Dbt, set_dlen, dbt_class),
|
||||
$1, dbt_set_doff, _m4_ref(NOAPI, Dbt, set_doff, dbt_class),
|
||||
$1, dbt_set_flags, _m4_ref(NOAPI, Dbt, set_flags, dbt_class),
|
||||
$1, dbt_set_offset, _m4_ref(NOAPI, Dbt, set_offset, dbt_class),
|
||||
$1, dbt_set_recno_key_data, _m4_ref(NOAPI, Dbt, set_recno_key_data, dbt_class),
|
||||
$1, dbt_set_size, _m4_ref(NOAPI, Dbt, set_size, dbt_class),
|
||||
$1, dbt_set_ulen, _m4_ref(NOAPI, Dbt, set_ulen, dbt_class),
|
||||
dnl #################################################################
|
||||
dnl Configuration
|
||||
dnl #################################################################
|
||||
$1, dbenv_set_func_close, _m4_ref(db_env_set_func_close, NOAPI, NOAPI, set_func_close),
|
||||
$1, dbenv_set_func_dirfree, _m4_ref(db_env_set_func_dirfree, NOAPI, NOAPI, set_func_dirfree),
|
||||
$1, dbenv_set_func_dirlist, _m4_ref(db_env_set_func_dirlist, NOAPI, NOAPI, set_func_dirlist),
|
||||
$1, dbenv_set_func_exists, _m4_ref(db_env_set_func_exists, NOAPI, NOAPI, set_func_exists),
|
||||
$1, dbenv_set_func_free, _m4_ref(db_env_set_func_free, NOAPI, NOAPI, set_func_free),
|
||||
$1, dbenv_set_func_fsync, _m4_ref(db_env_set_func_fsync, NOAPI, NOAPI, set_func_fsync),
|
||||
$1, dbenv_set_func_ftruncate, _m4_ref(db_env_set_func_ftruncate, NOAPI, NOAPI, set_func_ftruncate),
|
||||
$1, dbenv_set_func_ioinfo, _m4_ref(db_env_set_func_ioinfo, NOAPI, NOAPI, set_func_ioinfo),
|
||||
$1, dbenv_set_func_malloc, _m4_ref(db_env_set_func_malloc, NOAPI, NOAPI, set_func_malloc),
|
||||
$1, dbenv_set_func_file_map, _m4_ref(db_env_set_func_file_map, NOAPI, NOAPI, set_func_file_map),
|
||||
$1, dbenv_set_func_region_map, _m4_ref(db_env_set_func_region_map, NOAPI, NOAPI, set_func_region_map),
|
||||
$1, dbenv_set_func_open, _m4_ref(db_env_set_func_open, NOAPI, NOAPI, set_func_open),
|
||||
$1, dbenv_set_func_pread, _m4_ref(db_env_set_func_pread, NOAPI, NOAPI, set_func_pread),
|
||||
$1, dbenv_set_func_pwrite, _m4_ref(db_env_set_func_pwrite, NOAPI, NOAPI, set_func_pwrite),
|
||||
$1, dbenv_set_func_read, _m4_ref(db_env_set_func_read, NOAPI, NOAPI, set_func_read),
|
||||
$1, dbenv_set_func_realloc, _m4_ref(db_env_set_func_realloc, NOAPI, NOAPI, set_func_realloc),
|
||||
$1, dbenv_set_func_rename, _m4_ref(db_env_set_func_rename, NOAPI, NOAPI, set_func_rename),
|
||||
$1, dbenv_set_func_seek, _m4_ref(db_env_set_func_seek, NOAPI, NOAPI, set_func_seek),
|
||||
$1, dbenv_set_func_unlink, _m4_ref(db_env_set_func_unlink, NOAPI, NOAPI, set_func_unlink),
|
||||
$1, dbenv_set_func_write, _m4_ref(db_env_set_func_write, NOAPI, NOAPI, set_func_write),
|
||||
$1, dbenv_set_func_yield, _m4_ref(db_env_set_func_yield, NOAPI, NOAPI, set_func_yield),
|
||||
dnl #################################################################
|
||||
dnl Utilities
|
||||
dnl #################################################################
|
||||
$1, berkeley_db_svc, m4_link(M4RELDIR/utility/berkeley_db_svc, berkeley_db_svc),
|
||||
$1, db_archive, m4_link(M4RELDIR/utility/db_archive, db_archive),
|
||||
$1, db_checkpoint, m4_link(M4RELDIR/utility/db_checkpoint, db_checkpoint),
|
||||
$1, db_codegen, m4_link(M4RELDIR/utility/db_codegen, db_codegen),
|
||||
$1, db_deadlock, m4_link(M4RELDIR/utility/db_deadlock, db_deadlock),
|
||||
$1, db_dump, m4_link(M4RELDIR/utility/db_dump, db_dump),
|
||||
$1, db_dump185, m4_link(M4RELDIR/utility/db_dump, db_dump185),
|
||||
$1, db_hotbackup, m4_link(M4RELDIR/utility/db_hotbackup, db_hotbackup),
|
||||
$1, db_load, m4_link(M4RELDIR/utility/db_load, db_load),
|
||||
$1, db_printlog, m4_link(M4RELDIR/utility/db_printlog, db_printlog),
|
||||
$1, db_recover, m4_link(M4RELDIR/utility/db_recover, db_recover),
|
||||
$1, db_stat, m4_link(M4RELDIR/utility/db_stat, db_stat),
|
||||
$1, db_upgrade, m4_link(M4RELDIR/utility/db_upgrade, db_upgrade),
|
||||
$1, db_verify, m4_link(M4RELDIR/utility/db_verify, db_verify),
|
||||
dnl #################################################################
|
||||
dnl Dbm
|
||||
dnl #################################################################
|
||||
$1, dbm, _m4_ref(dbm, historic, NOAPI, dbm),
|
||||
$1, dbm/ndbm, _m4_ref(dbm/ndbm, historic, NOAPI, dbm),
|
||||
$1, dbm_clearerr, _m4_ref(dbm_close, historic, NOAPI, dbm),
|
||||
$1, dbm_close, _m4_ref(dbm_close, historic, NOAPI, dbm),
|
||||
$1, dbm_delete, _m4_ref(dbm_delete, historic, NOAPI, dbm),
|
||||
$1, dbm_dirfno, _m4_ref(dbm_dirfno, historic, NOAPI, dbm),
|
||||
$1, dbm_error, _m4_ref(dbm_close, historic, NOAPI, dbm),
|
||||
$1, dbm_fetch, _m4_ref(dbm_fetch, historic, NOAPI, dbm),
|
||||
$1, dbm_firstkey, _m4_ref(dbm_firstkey, historic, NOAPI, dbm),
|
||||
$1, dbm_nextkey, _m4_ref(dbm_nextkey, historic, NOAPI, dbm),
|
||||
$1, dbm_open, _m4_ref(dbm_open, historic, NOAPI, dbm),
|
||||
$1, dbm_pagfno, _m4_ref(dbm_pagfno, historic, NOAPI, dbm),
|
||||
$1, dbm_store, _m4_ref(dbm_store, historic, NOAPI, dbm),
|
||||
$1, dbmclose, _m4_ref(dbmclose, historic, NOAPI, dbm),
|
||||
$1, dbminit, _m4_ref(dbminit, historic, NOAPI, dbm),
|
||||
$1, delete, _m4_ref(delete, historic, NOAPI, dbm),
|
||||
$1, fetch, _m4_ref(fetch, historic, NOAPI, dbm),
|
||||
$1, firstkey, _m4_ref(firstkey, historic, NOAPI, dbm),
|
||||
$1, ndbm, _m4_ref(ndbm, historic, NOAPI, dbm),
|
||||
$1, nextkey, _m4_ref(nextkey, historic, NOAPI, dbm),
|
||||
$1, store, _m4_ref(store, historic, NOAPI, dbm),
|
||||
dnl #################################################################
|
||||
dnl Hsearch
|
||||
dnl #################################################################
|
||||
$1, hcreate, _m4_ref(hcreate, historic, NOAPI, hsearch),
|
||||
$1, hsearch, _m4_ref(hsearch, historic, NOAPI, hsearch),
|
||||
dnl #################################################################
|
||||
dnl Flags, types, environment variables.
|
||||
dnl #################################################################
|
||||
$1, DB_AFTER, [_m4_nref($1, $1, dbc_put)],
|
||||
$1, DB_AGGRESSIVE, [_m4_nref($1, $1, db_verify)],
|
||||
$1, DB_APPEND, [_m4_nref($1, $1, db_put)],
|
||||
$1, DB_ARCH_ABS, [_m4_nref($1, $1, log_archive)],
|
||||
$1, DB_ARCH_DATA, [_m4_nref($1, $1, log_archive)],
|
||||
$1, DB_ARCH_LOG, [_m4_nref($1, $1, log_archive)],
|
||||
$1, DB_ARCH_REMOVE, [_m4_nref($1, $1, log_archive)],
|
||||
$1, DB_AUTO_COMMIT, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_BEFORE, [_m4_nref($1, $1, dbc_put)],
|
||||
$1, DB_BTREE, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_CDB_ALLDB, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_CHKSUM, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_CONFIG, [m4_linkpage(M4RELDIR/ref/env/db_config, $1, $1)],
|
||||
$1, DB_CONSUME, [_m4_nref($1, $1, db_get)],
|
||||
$1, DB_CONSUME_WAIT, [_m4_nref($1, $1, db_get)],
|
||||
$1, DB_CREATE, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_CURRENT, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_CXX_NO_EXCEPTIONS, [_m4_nref($1, $1, env_class)],
|
||||
$1, DB_DBT_APPMALLOC, [_m4_nref($1, $1, dbt_class)],
|
||||
$1, DB_DBT_MALLOC, [_m4_nref($1, $1, dbt_class)],
|
||||
$1, DB_DBT_MULTIPLE, [_m4_nref($1, $1, db_associate)],
|
||||
$1, DB_DBT_PARTIAL, [_m4_nref($1, $1, dbt_class)],
|
||||
$1, DB_DBT_REALLOC, [_m4_nref($1, $1, dbt_class)],
|
||||
$1, DB_DBT_USERMEM, [_m4_nref($1, $1, dbt_class)],
|
||||
$1, DB_DIRECT, [_m4_nref($1, $1, memp_fopen)],
|
||||
$1, DB_DIRECT_DB, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_DSYNC_DB, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_DUP, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_DUPSORT, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_EID_BROADCAST, [_m4_nref($1, $1, rep_transport)],
|
||||
$1, DB_EID_INVALID, [m4_linkpage(M4RELDIR/ref/rep/id, $1, $1)],
|
||||
$1, DB_ENCRYPT, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_ENCRYPT_AES, [_m4_nref($1, $1, env_set_encrypt)],
|
||||
$1, DB_EVENT_PANIC, [_m4_nref($1, $1, env_event_notify)],
|
||||
$1, DB_EVENT_REP_CLIENT, [_m4_nref($1, $1, env_event_notify)],
|
||||
$1, DB_EVENT_REP_ELECTED, [_m4_nref($1, $1, env_event_notify)],
|
||||
$1, DB_EVENT_REP_MASTER, [_m4_nref($1, $1, env_event_notify)],
|
||||
$1, DB_EVENT_REP_NEWMASTER, [_m4_nref($1, $1, env_event_notify)],
|
||||
$1, DB_EVENT_REP_PERM_FAILED, [_m4_nref($1, $1, env_event_notify)],
|
||||
$1, DB_EVENT_REP_STARTUPDONE, [_m4_nref($1, $1, env_event_notify)],
|
||||
$1, DB_EVENT_WRITE_FAILED, [_m4_nref($1, $1, env_event_notify)],
|
||||
$1, DB_EXCL, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_FAST_STAT, [_m4_nref($1, $1, db_stat)],
|
||||
$1, DB_FIRST, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_FLUSH, [_m4_nref($1, $1, log_put)],
|
||||
$1, DB_FORCE, [_m4_nref($1, $1, env_remove)],
|
||||
$1, DB_FREELIST_ONLY, [_m4_nref($1, $1, dbh_compact)],
|
||||
$1, DB_FREE_SPACE, [_m4_nref($1, $1, dbh_compact)],
|
||||
$1, DB_GET_BOTH, [_m4_nref($1, $1, db_get)],
|
||||
$1, DB_GET_BOTH_RANGE, [_m4_nref($1, $1, db_get)],
|
||||
$1, DB_GET_RECNO, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_HASH, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_HOME, [m4_linkpage(M4RELDIR/ref/env/naming, $1, $1)],
|
||||
$1, DB_IGNORE_LEASE, [_m4_nref($1, $1, db_get)],
|
||||
$1, DB_IMMUTABLE_KEY, [_m4_nref($1, $1, dbh_associate)],
|
||||
$1, DB_INIT_CDB, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_INIT_LOCK, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_INIT_LOG, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_INIT_MPOOL, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_INIT_REP, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_INIT_TXN, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_INORDER, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_JOIN_ITEM, [_m4_nref($1, $1, db_join)],
|
||||
$1, DB_JOIN_NOSORT, [_m4_nref($1, $1, db_join)],
|
||||
$1, DB_KEYFIRST, [_m4_nref($1, $1, dbc_put)],
|
||||
$1, DB_KEYLAST, [_m4_nref($1, $1, dbc_put)],
|
||||
$1, DB_LAST, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_LOCKDOWN, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_LOCK_DEFAULT, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOCK_EXPIRE, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOCK_GET, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_GET_TIMEOUT, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_IREAD, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_IWR, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_IWRITE, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_MAXLOCKS, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOCK_MAXWRITE, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOCK_MINLOCKS, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOCK_MINWRITE, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOCK_NOWAIT, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_OLDEST, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOCK_PUT, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_PUT_ALL, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_PUT_OBJ, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_RANDOM, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOCK_READ, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_TIMEOUT, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_WRITE, [_m4_nref($1, $1, lock_vec)],
|
||||
$1, DB_LOCK_YOUNGEST, [_m4_nref($1, $1, env_set_lk_detect)],
|
||||
$1, DB_LOG_AUTO_REMOVE, [_m4_nref($1, $1, env_log_set_config)],
|
||||
$1, DB_LOG_BUFFER_FULL, [_m4_nref($1, $1, env_log_set_config)],
|
||||
$1, DB_LOG_DIRECT, [_m4_nref($1, $1, env_log_set_config)],
|
||||
$1, DB_LOG_DSYNC, [_m4_nref($1, $1, env_log_set_config)],
|
||||
$1, DB_LOG_IN_MEMORY, [_m4_nref($1, $1, env_log_set_config)],
|
||||
$1, DB_LOG_ZERO, [_m4_nref($1, $1, env_log_set_config)],
|
||||
$1, DB_MPOOL_CREATE, [_m4_nref($1, $1, memp_fget)],
|
||||
$1, DB_MPOOL_DIRTY, [_m4_nref($1, $1, memp_fget)],
|
||||
$1, DB_MPOOL_EDIT, [_m4_nref($1, $1, memp_fget)],
|
||||
$1, DB_MPOOL_LAST, [_m4_nref($1, $1, memp_fget)],
|
||||
$1, DB_MPOOL_NEW, [_m4_nref($1, $1, memp_fget)],
|
||||
$1, DB_MPOOL_NOFILE, [_m4_nref($1, $1, memp_set_flags)],
|
||||
$1, DB_MPOOL_UNLINK, [_m4_nref($1, $1, memp_set_flags)],
|
||||
$1, DB_MULTIPLE, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_MULTIPLE_INIT, [_m4_nref($1, $1, dbt_bulk)],
|
||||
$1, DB_MULTIPLE_KEY, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_MULTIPLE_KEY_NEXT, [_m4_nref($1, $1, dbt_bulk)],
|
||||
$1, DB_MULTIPLE_NEXT, [_m4_nref($1, $1, dbt_bulk)],
|
||||
$1, DB_MULTIPLE_RECNO_NEXT, [_m4_nref($1, $1, dbt_bulk)],
|
||||
$1, DB_MULTIVERSION, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_MUTEX_PROCESS_ONLY, [_m4_nref($1, $1, env_set_isalive)],
|
||||
$1, DB_MUTEX_SELF_BLOCK, [_m4_nref($1, $1, mutex_alloc)],
|
||||
$1, DB_NEXT, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_NEXT_DUP, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_NEXT_NODUP, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_NODUPDATA, [_m4_nref($1, $1, db_put)],
|
||||
$1, DB_NOLOCKING, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_NOMMAP, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_NOORDERCHK, [_m4_nref($1, $1, db_verify)],
|
||||
$1, DB_NOOVERWRITE, [_m4_nref($1, $1, db_put)],
|
||||
$1, DB_NOPANIC, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_NOSYNC, [_m4_nref($1, $1, db_close)],
|
||||
$1, DB_ODDFILESIZE, [_m4_nref($1, $1, memp_fopen)],
|
||||
$1, DB_ORDERCHKONLY, [_m4_nref($1, $1, db_verify)],
|
||||
$1, DB_OVERWRITE, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_PANIC_ENVIRONMENT, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_POSITION, [_m4_nref($1, $1, dbc_dup)],
|
||||
$1, DB_PREV, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_PREV_DUP, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_PREV_NODUP, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_PRINTABLE, [_m4_nref($1, $1, db_verify)],
|
||||
$1, DB_PRIORITY_DEFAULT, [_m4_nref($1, $1, dbc_set_priority)],
|
||||
$1, DB_PRIORITY_HIGH, [_m4_nref($1, $1, dbc_set_priority)],
|
||||
$1, DB_PRIORITY_LOW, [_m4_nref($1, $1, dbc_set_priority)],
|
||||
$1, DB_PRIORITY_UNCHANGED, [_m4_nref($1, $1, memp_fput)],
|
||||
$1, DB_PRIORITY_VERY_HIGH, [_m4_nref($1, $1, dbc_set_priority)],
|
||||
$1, DB_PRIORITY_VERY_LOW, [_m4_nref($1, $1, dbc_set_priority)],
|
||||
$1, DB_PRIVATE, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_QUEUE, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_RDONLY, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_READ_COMMITTED, [_m4_nref($1, $1, db_cursor)],
|
||||
$1, DB_READ_UNCOMMITTED, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_RECNO, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_RECNUM, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_RECOVER, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_RECOVER_FATAL, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_REGION_INIT, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_REGISTER, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_RENUMBER, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_REPMGR_ACKS_ALL, [_m4_nref($1, $1, repmgr_ack_policy)],
|
||||
$1, DB_REPMGR_ACKS_ALL_PEERS, [_m4_nref($1, $1, repmgr_ack_policy)],
|
||||
$1, DB_REPMGR_ACKS_NONE, [_m4_nref($1, $1, repmgr_ack_policy)],
|
||||
$1, DB_REPMGR_ACKS_ONE, [_m4_nref($1, $1, repmgr_ack_policy)],
|
||||
$1, DB_REPMGR_ACKS_ONE_PEER, [_m4_nref($1, $1, repmgr_ack_policy)],
|
||||
$1, DB_REPMGR_ACKS_QUORUM, [_m4_nref($1, $1, repmgr_ack_policy)],
|
||||
$1, DB_REPMGR_CONF_2SITE_STRICT, [_m4_nref($1, $1, rep_config)],
|
||||
$1, DB_REPMGR_CONNECTED, [_m4_nref($1, $1, repmgr_site_list)],
|
||||
$1, DB_REPMGR_DISCONNECTED, [_m4_nref($1, $1, repmgr_site_list)],
|
||||
$1, DB_REP_ACK_TIMEOUT, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_ANYWHERE, [_m4_nref($1, $1, rep_transport)],
|
||||
$1, DB_REP_CHECKPOINT_DELAY, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_CLIENT, [_m4_nref($1, $1, repmgr_start)],
|
||||
$1, DB_REP_CONF_BULK, [_m4_nref($1, $1, rep_config)],
|
||||
$1, DB_REP_CONF_DELAYCLIENT, [_m4_nref($1, $1, rep_config)],
|
||||
$1, DB_REP_CONF_LEASE, [_m4_nref($1, $1, rep_config)],
|
||||
$1, DB_REP_CONF_NOAUTOINIT, [_m4_nref($1, $1, rep_config)],
|
||||
$1, DB_REP_CONF_NOWAIT, [_m4_nref($1, $1, rep_config)],
|
||||
$1, DB_REP_CONNECTION_RETRY, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_ELECTION, [_m4_nref($1, $1, repmgr_start)],
|
||||
$1, DB_REP_ELECTION_RETRY, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_ELECTION_TIMEOUT, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_FULL_ELECTION_TIMEOUT, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_HANDLE_DEAD, [_m4_nref($1, $1, db_put)],
|
||||
$1, DB_REP_HEARTBEAT_MONITOR, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_HEARTBEAT_SEND, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_LEASE_EXPIRED, [_m4_nref($1, $1, rep_config)],
|
||||
$1, DB_REP_LEASE_TIMEOUT, [_m4_nref($1, $1, rep_timeout)],
|
||||
$1, DB_REP_LOCKOUT, [_m4_nref($1, $1, db_put)],
|
||||
$1, DB_REP_MASTER, [_m4_nref($1, $1, repmgr_start)],
|
||||
$1, DB_REP_NOBUFFER, [_m4_nref($1, $1, rep_transport)],
|
||||
$1, DB_REP_PERMANENT, [_m4_nref($1, $1, rep_transport)],
|
||||
$1, DB_REP_REREQUEST, [_m4_nref($1, $1, rep_transport)],
|
||||
$1, DB_REP_UNAVAIL, [_m4_nref($1, $1, rep_elect)],
|
||||
$1, DB_REVSPLITOFF, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_RMW, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_RPCCLIENT, [_m4_nref($1, $1, env_class)],
|
||||
$1, DB_SALVAGE, [_m4_nref($1, $1, db_verify)],
|
||||
$1, DB_SEQ_DEC, [_m4_nref($1, $1, seq_set_flags)],
|
||||
$1, DB_SEQ_INC, [_m4_nref($1, $1, seq_set_flags)],
|
||||
$1, DB_SEQ_WRAP, [_m4_nref($1, $1, seq_set_flags)],
|
||||
$1, DB_SET, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_SET_LOCK_TIMEOUT, [_m4_nref($1, $1, env_set_timeout)],
|
||||
$1, DB_SET_RANGE, [_m4_nref($1, $1, dbc_get)],
|
||||
$1, DB_SET_RECNO, [_m4_nref($1, $1, db_get)],
|
||||
$1, DB_SET_TXN_TIMEOUT, [_m4_nref($1, $1, env_set_timeout)],
|
||||
$1, DB_SNAPSHOT, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_STAT_ALL, [_m4_nref($1, $1, env_stat)],
|
||||
$1, DB_STAT_CLEAR, [_m4_nref($1, $1, lock_stat)],
|
||||
$1, DB_STAT_LOCK_CONF, [_m4_nref($1, $1, lock_stat_print)],
|
||||
$1, DB_STAT_LOCK_LOCKERS, [_m4_nref($1, $1, lock_stat_print)],
|
||||
$1, DB_STAT_LOCK_OBJECTS, [_m4_nref($1, $1, lock_stat_print)],
|
||||
$1, DB_STAT_LOCK_PARAMS, [_m4_nref($1, $1, lock_stat_print)],
|
||||
$1, DB_STAT_MEMP_HASH, [_m4_nref($1, $1, memp_stat_print)],
|
||||
$1, DB_STAT_SUBSYSTEM, [_m4_nref($1, $1, env_stat)],
|
||||
$1, DB_SYSTEM_MEM, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_THREAD, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_THREADID_STRLEN, [_m4_nref($1, $1, env_set_thread_id_string)],
|
||||
$1, DB_TIME_NOTGRANTED, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_TRUNCATE, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_TXN_ABORT, [_m4_nref($1, $1, env_set_app_dispatch)],
|
||||
$1, DB_TXN_APPLY, [_m4_nref($1, $1, env_set_app_dispatch)],
|
||||
$1, DB_TXN_BACKWARD_ROLL, [_m4_nref($1, $1, env_set_app_dispatch)],
|
||||
$1, DB_TXN_FORWARD_ROLL, [_m4_nref($1, $1, env_set_app_dispatch)],
|
||||
$1, DB_TXN_NOSYNC, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_TXN_NOT_DURABLE, [_m4_nref($1, $1, db_set_flags)],
|
||||
$1, DB_TXN_NOWAIT, [_m4_nref($1, $1, txn_begin)],
|
||||
$1, DB_TXN_PRINT, [_m4_nref($1, $1, env_set_app_dispatch)],
|
||||
$1, DB_TXN_SNAPSHOT, [_m4_nref($1, $1, txn_begin)],
|
||||
$1, DB_TXN_SYNC, [_m4_nref($1, $1, txn_begin)],
|
||||
$1, DB_TXN_WAIT, [_m4_nref($1, $1, txn_begin)],
|
||||
$1, DB_TXN_WRITE_NOSYNC, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, DB_UNKNOWN, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_UPGRADE, [_m4_nref($1, $1, db_set_feedback)],
|
||||
$1, DB_USE_ENVIRON, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_USE_ENVIRON_ROOT, [_m4_nref($1, $1, env_open)],
|
||||
$1, DB_VERB_DEADLOCK, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_FILEOPS, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_FILEOPS_ALL, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_RECOVERY, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REGISTER, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REPLICATION, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REPMGR_CONNFAIL, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REPMGR_MISC, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REP_ELECT, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REP_LEASE, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REP_MISC, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REP_MSGS, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_REP_SYNC, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERB_WAITSFOR, [_m4_nref($1, $1, env_set_verbose)],
|
||||
$1, DB_VERIFY, [_m4_nref($1, $1, db_set_feedback)],
|
||||
$1, DB_WRITECURSOR, [_m4_nref($1, $1, db_cursor)],
|
||||
$1, DB_XA_CREATE, [_m4_nref($1, $1, db_class)],
|
||||
$1, DB_XIDDATASIZE, [_m4_nref($1, $1, txn_prepare)],
|
||||
$1, DB_YIELDCPU, [_m4_nref($1, $1, env_set_flags)],
|
||||
$1, TMPDIR, [m4_linkpage(M4RELDIR/ref/env/naming, $1, $1)],
|
||||
$1, db_recno_t, [_m4_nref($1, $1, dbt_class)],
|
||||
dnl #################################################################
|
||||
dnl Error returns.
|
||||
dnl #################################################################
|
||||
$1, DB_BUFFER_SMALL, [_m4_nref($1, $1, dbt_class)],
|
||||
$1, DB_DONOTINDEX, [_m4_nref($1, $1, dbh_associate)],
|
||||
$1, DB_KEYEMPTY, [m4_linkpage(M4RELDIR/ref/program/errorret, $1, $1)],
|
||||
$1, DB_KEYEXIST, [_m4_nref($1, $1, dbc_put)],
|
||||
$1, DB_LOCK_DEADLOCK, [m4_linkpage(M4RELDIR/ref/program/errorret, $1, $1)],
|
||||
$1, DB_LOCK_NOTGRANTED, [m4_linkpage(M4RELDIR/ref/program/errorret, $1, $1)],
|
||||
$1, DB_NOSERVER, [_m4_nref($1, $1, env_set_rpc_server)],
|
||||
$1, DB_NOSERVER_HOME, [_m4_nref($1, $1, env_set_rpc_server)],
|
||||
$1, DB_NOSERVER_ID, [_m4_nref($1, $1, env_set_rpc_server)],
|
||||
$1, DB_NOTFOUND, [m4_linkpage(M4RELDIR/ref/program/errorret, $1, $1)],
|
||||
$1, DB_OLD_VERSION, [_m4_nref($1, $1, db_open)],
|
||||
$1, DB_PAGE_NOTFOUND, [_m4_nref($1, $1, memp_fget)],
|
||||
$1, DB_REPMGR_PEER, [_m4_nref($1, $1, rep_remote_addr)],
|
||||
$1, DB_REP_DUPMASTER, [_m4_nref($1, $1, rep_message)],
|
||||
$1, DB_REP_HOLDELECTION, [_m4_nref($1, $1, rep_message)],
|
||||
$1, DB_REP_IGNORE, [_m4_nref($1, $1, rep_message)],
|
||||
$1, DB_REP_ISPERM, [_m4_nref($1, $1, rep_message)],
|
||||
$1, DB_REP_JOIN_FAILURE, [_m4_nref($1, $1, rep_message)],
|
||||
$1, DB_REP_NEWSITE, [_m4_nref($1, $1, rep_message)],
|
||||
$1, DB_REP_NOTPERM, [_m4_nref($1, $1, rep_message)],
|
||||
$1, DB_RUNRECOVERY, [m4_linkpage(M4RELDIR/ref/program/errorret, $1, $1)],
|
||||
$1, DB_SECONDARY_BAD, [m4_linkpage(M4RELDIR/ref/program/errorret, $1, $1)],
|
||||
$1, DB_VERIFY_BAD, [m4_linkpage(M4RELDIR/ref/program/errorret, $1, $1)],
|
||||
$1, DB_VERSION_MISMATCH, [_m4_nref($1, $1, env_open)],
|
||||
$1, EINVAL, EINVAL,
|
||||
dnl #################################################################
|
||||
dnl Check XML, or complain if it's a name we don't know.
|
||||
dnl #################################################################
|
||||
ifelse(M4PRODUCT, XML, _m4_xmllist($1), UNREF==$1))])
|
||||
dnl #################################################################
|
||||
dnl Specific API references
|
||||
dnl $1: name
|
||||
dnl
|
||||
dnl XXX
|
||||
dnl Don't remove the empty quotes before the popdef calls, it works
|
||||
dnl around a bug -- the popdef doesn't get expanded for some reason.
|
||||
dnl #################################################################
|
||||
define(m4_refc, [pushdef([M4API], C_API)m4_ref($1)[]popdef([M4API])])
|
||||
define(m4_refcxx, [pushdef([M4API], CXX_API)m4_ref($1)[]popdef([M4API])])
|
||||
68
docs_src/m4/m4.ret
Normal file
68
docs_src/m4/m4.ret
Normal file
@@ -0,0 +1,68 @@
|
||||
dnl $Id: m4.ret,v 10.133 2004/08/13 03:38:58 bostic Exp $
|
||||
dnl
|
||||
dnl ###################################################################
|
||||
dnl RETURN VALUES:
|
||||
dnl m4_return:
|
||||
dnl #1: API name
|
||||
dnl #2: Variadic list of return conditions
|
||||
dnl ###################################################################
|
||||
define(m4_return, [dnl
|
||||
define([__m4_retapi], [$1])
|
||||
m4_p([__m4_retloop(shift($@))])])
|
||||
dnl ###################################################################
|
||||
dnl __m4_common_ret_txt
|
||||
dnl Standard return text.
|
||||
dnl ###################################################################
|
||||
define(__m4_common_ret_txt, [dnl
|
||||
m4_refT(__m4_retapi)
|
||||
ifelse(M4EXCEPT, except_return, [either returns a non-zero error value
|
||||
or throws an exception that encapsulates a non-zero error value on
|
||||
failure, and returns 0 on success.],
|
||||
M4EXCEPT, except_only, [throws an exception that encapsulates a non-zero
|
||||
error value on failure.],[returns a non-zero error value on failure
|
||||
and 0 on success.])])
|
||||
dnl ###################################################################
|
||||
dnl __m4_retloop
|
||||
dnl Helper macro: loop through return list.
|
||||
dnl ###################################################################
|
||||
define(__m4_retloop, [ifelse([$1],,,
|
||||
dnl ###################################################################
|
||||
dnl "std"
|
||||
dnl Returning 0 or errno.
|
||||
dnl ###################################################################
|
||||
[$1], std, [The __m4_common_ret_txt
|
||||
__m4_retloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl "prev"
|
||||
dnl Otherwise, returning 0 or errno.
|
||||
dnl ###################################################################
|
||||
[$1], prev, [Unless otherwise specified, the __m4_common_ret_txt
|
||||
__m4_retloop(shift($@))],
|
||||
dnl ###################################################################
|
||||
dnl "except"
|
||||
dnl Specific return that may be an exception.
|
||||
dnl #2: the condition
|
||||
dnl #3: the return value.
|
||||
dnl ###################################################################
|
||||
[$1], except, [dnl
|
||||
The m4_refT(__m4_retapi)
|
||||
ifelse(M4EXCEPT, except_return, [will either return m4_ref($2) or
|
||||
throw an exception that encapsulates m4_ref($2)],
|
||||
M4EXCEPT, except_only,
|
||||
[will throw an exception that encapsulates m4_ref($2)],
|
||||
[will return m4_ref($2)]) $3.
|
||||
__m4_retloop(shift(shift(shift($@))))],
|
||||
dnl ###################################################################
|
||||
dnl "specific"
|
||||
dnl Specific return that is never an exception
|
||||
dnl #2: the condition
|
||||
dnl #3: the return value.
|
||||
dnl ###################################################################
|
||||
[$1], specific, [dnl
|
||||
The m4_refT(__m4_retapi) will return m4_ref($2) $3.
|
||||
__m4_retloop(shift(shift(shift($@))))],
|
||||
dnl ###################################################################
|
||||
dnl Everything else.
|
||||
dnl ###################################################################
|
||||
[$1
|
||||
__m4_retloop(shift($@))])])
|
||||
52
docs_src/m4/m4.seealso
Normal file
52
docs_src/m4/m4.seealso
Normal file
@@ -0,0 +1,52 @@
|
||||
dnl $Id: m4.seealso,v 10.81 2004/11/03 17:40:06 bostic Exp $
|
||||
|
||||
dnl ###################################################################
|
||||
dnl DbEnv
|
||||
dnl ###################################################################
|
||||
define(m4_seealso, [dnl
|
||||
m4_hl
|
||||
m4_header(Class)
|
||||
ifelse($1, DbEnv, [dnl
|
||||
m4_ref(DbEnv)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/env_list, [Database Environments and Related Methods])],
|
||||
$1, Db, [dnl
|
||||
m4_ref(Db)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/db_list, [Databases and Related Methods])],
|
||||
$1, Dbc, [dnl
|
||||
m4_ref(Dbc)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/dbc_list, [Database Cursors and Related Methods])],
|
||||
$1, DbLock, [dnl
|
||||
m4_ref(DbEnv), m4_ref(DbLock)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/lock_list, [Locking Subsystem and Related Methods])],
|
||||
$1, DbLog, [dnl
|
||||
m4_ref(DbEnv), m4_ref(DbLogc), m4_ref(DbLsn)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/log_list, [Logging Subsystem and Related Methods])],
|
||||
$1, DbMpool, [dnl
|
||||
m4_ref(DbEnv), m4_ref(DbMpoolFile)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/memp_list, [Memory Pools and Related Methods])],
|
||||
$1, DbSequence, [dnl
|
||||
m4_ref(DbSequence)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/seq_list, [Sequences and Related Methods])],
|
||||
$1, Replication, [dnl
|
||||
m4_ref(DbEnv)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/rep_list, [Replication and Related Methods])],
|
||||
$1, DbTxn, [dnl
|
||||
m4_ref(DbEnv), m4_ref(DbTxn)
|
||||
m4_header(See Also)
|
||||
m4_link(_m4_api/txn_list, [Transaction Subsystem and Related Methods])])])
|
||||
|
||||
dnl ###################################################################
|
||||
dnl Run-time configuration
|
||||
dnl ###################################################################
|
||||
define(m4_rtc_seealso, [dnl
|
||||
pushdef([M4PAGELOCAL],)
|
||||
m4_header(See Also)
|
||||
m4_link(M4RELDIR/ref/program/runtime, [Run-time configuration])])
|
||||
66
docs_src/m4/m4.utility
Normal file
66
docs_src/m4/m4.utility
Normal file
@@ -0,0 +1,66 @@
|
||||
dnl $Id: m4.utility,v 10.17 2002/08/24 18:24:55 bostic Exp $
|
||||
|
||||
dnl m4_utilenv --
|
||||
dnl -h environment section
|
||||
dnl #1: utility name
|
||||
define(m4_utilenv, [dnl
|
||||
m4_tagbegin
|
||||
m4_tag(DB_HOME, [dnl
|
||||
If the m4_option(h) option is not specified and the environment variable
|
||||
DB_HOME is set, it is used as the path of the database home, as described
|
||||
in m4_ref(dbenv_open).])
|
||||
m4_tagend])
|
||||
|
||||
define(m4_hflag, [dnl
|
||||
m4_tagopt(h, [Specify a home directory for the database environment; by
|
||||
default, the current working directory is used.])])
|
||||
|
||||
dnl m4_Lflag --
|
||||
dnl Log-the-pid option.
|
||||
dnl #1: utility name
|
||||
define(m4_Lflag, [dnl
|
||||
m4_tagopt(L, [dnl
|
||||
Log the execution of the m4_ref($1) utility to the specified file in the
|
||||
following format, where m4_italic([###]) is the process ID, and the date
|
||||
is the time the utility was started.
|
||||
m4_indent([$1: [###] Wed Jun 15 01:23:45 EDT 1995])
|
||||
This file will be removed if the m4_ref($1) utility exits gracefully.])])
|
||||
|
||||
define(m4_Nflag, [dnl
|
||||
m4_tagopt(N, [dnl
|
||||
Do not acquire shared region mutexes while running. Other problems,
|
||||
such as potentially fatal errors in m4_db, will be ignored as well.
|
||||
This option is intended only for debugging errors, and should not be
|
||||
used under any other circumstances.])])
|
||||
|
||||
define(m4_Pflag, [dnl
|
||||
m4_tagopt(P, [dnl
|
||||
Specify an environment password. Although m4_db utilities overwrite
|
||||
password strings as soon as possible, be aware there may be a window of
|
||||
vulnerability on systems where unprivileged users can see command-line
|
||||
arguments or where utilities are not able to overwrite the memory
|
||||
containing the command-line arguments.])])
|
||||
|
||||
define(m4_Vflag, [dnl
|
||||
m4_tagopt(V, [dnl
|
||||
Write the library version number to the standard output, and exit.])])
|
||||
|
||||
dnl m4_utilexit --
|
||||
dnl Exit macro.
|
||||
dnl #1: utility name
|
||||
define(m4_utilexit, [m4_p([dnl
|
||||
The m4_ref($1) utility exits 0 on success, and __GT__0 if an error occurs.])])
|
||||
|
||||
dnl m4_detach --
|
||||
dnl Detaching from the environment paragraph.
|
||||
dnl #1: utility name
|
||||
dnl #2: "uses" or "may be used with"
|
||||
define(m4_detach, [m4_p([dnl
|
||||
The m4_ref($1) utility $2 a m4_db environment (as described for the
|
||||
m4_option(h) option, the environment variable m4_envvar(DB_HOME), or
|
||||
because the utility was run in a directory containing a m4_db
|
||||
environment). In order to avoid environment corruption when using a
|
||||
m4_db environment, m4_ref($1) should always be given the chance to
|
||||
detach from the environment and exit gracefully. To cause m4_ref($1)
|
||||
to release all environment resources and exit cleanly, send it an
|
||||
interrupt signal (SIGINT).])])
|
||||
Reference in New Issue
Block a user