ag/cpython-source-deps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import BSDDB 4.7.25 (as of svn r89086)

Browse Source
This commit is contained in:
Zachary Ware
2017-09-04 13:40:25 -05:00
parent 4b29e0458f
commit 8f590873d0
4781 changed files with 2241032 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

393
rep/rep_stub.c Normal file
View File

@@ -0,0 +1,393 @@
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1996,2008 Oracle. All rights reserved.
*
* $Id: rep_stub.c 63573 2008-05-23 21:43:21Z trent.nelson $
*/
#ifndef HAVE_REPLICATION
#include "db_config.h"
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_am.h"
/*
* If the library wasn't compiled with replication support, various routines
* aren't available. Stub them here, returning an appropriate error.
*/
static int __db_norep __P((ENV *));
/*
* __db_norep --
* Error when a Berkeley DB build doesn't include replication support.
*/
static int
__db_norep(env)
ENV *env;
{
__db_errx(env,
"library build did not include support for replication");
return (DB_OPNOTSUP);
}
int
__db_rep_enter(dbp, checkgen, checklock, return_now)
DB *dbp;
int checkgen, checklock, return_now;
{
COMPQUIET(checkgen, 0);
COMPQUIET(checklock, 0);
COMPQUIET(return_now, 0);
return (__db_norep(dbp->env));
}
int
__env_rep_enter(env, checklock)
ENV *env;
int checklock;
{
COMPQUIET(checklock, 0);
return (__db_norep(env));
}
int
__env_db_rep_exit(env)
ENV *env;
{
return (__db_norep(env));
}
int
__op_rep_enter(env)
ENV *env;
{
return (__db_norep(env));
}
int
__op_rep_exit(env)
ENV *env;
{
return (__db_norep(env));
}
int
__rep_bulk_message(env, bulkp, repth, lsnp, dbt, flags)
ENV *env;
REP_BULK *bulkp;
REP_THROTTLE *repth;
DB_LSN *lsnp;
const DBT *dbt;
u_int32_t flags;
{
COMPQUIET(bulkp, NULL);
COMPQUIET(repth, NULL);
COMPQUIET(lsnp, NULL);
COMPQUIET(dbt, NULL);
COMPQUIET(flags, 0);
return (__db_norep(env));
}
int
__rep_env_refresh(env)
ENV *env;
{
COMPQUIET(env, NULL);
return (0);
}
int
__rep_elect(dbenv, nsites, nvotes, flags)
DB_ENV *dbenv;
u_int32_t nsites, nvotes;
u_int32_t flags;
{
COMPQUIET(nsites, 0);
COMPQUIET(nvotes, 0);
COMPQUIET(flags, 0);
return (__db_norep(dbenv->env));
}
int
__rep_flush(dbenv)
DB_ENV *dbenv;
{
return (__db_norep(dbenv->env));
}
int
__rep_lease_check(env, refresh)
ENV *env;
int refresh;
{
COMPQUIET(refresh, 0);
return (__db_norep(env));
}
int
__rep_lease_expire(env, locked)
ENV *env;
int locked;
{
COMPQUIET(locked, 0);
return (__db_norep(env));
}
int
__rep_get_clockskew(dbenv, fast_clockp, slow_clockp)
DB_ENV *dbenv;
u_int32_t *fast_clockp, *slow_clockp;
{
COMPQUIET(fast_clockp, NULL);
COMPQUIET(slow_clockp, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_set_clockskew(dbenv, fast_clock, slow_clock)
DB_ENV *dbenv;
u_int32_t fast_clock, slow_clock;
{
COMPQUIET(fast_clock, 0);
COMPQUIET(slow_clock, 0);
return (__db_norep(dbenv->env));
}
int
__rep_set_nsites(dbenv, n)
DB_ENV *dbenv;
u_int32_t n;
{
COMPQUIET(n, 0);
return (__db_norep(dbenv->env));
}
int
__rep_get_nsites(dbenv, n)
DB_ENV *dbenv;
u_int32_t *n;
{
COMPQUIET(n, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_set_priority(dbenv, priority)
DB_ENV *dbenv;
u_int32_t priority;
{
COMPQUIET(priority, 0);
return (__db_norep(dbenv->env));
}
int
__rep_get_priority(dbenv, priority)
DB_ENV *dbenv;
u_int32_t *priority;
{
COMPQUIET(priority, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_set_timeout(dbenv, which, timeout)
DB_ENV *dbenv;
int which;
db_timeout_t timeout;
{
COMPQUIET(which, 0);
COMPQUIET(timeout, 0);
return (__db_norep(dbenv->env));
}
int
__rep_get_timeout(dbenv, which, timeout)
DB_ENV *dbenv;
int which;
db_timeout_t *timeout;
{
COMPQUIET(which, 0);
COMPQUIET(timeout, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_get_config(dbenv, which, onp)
DB_ENV *dbenv;
u_int32_t which;
int *onp;
{
COMPQUIET(which, 0);
COMPQUIET(onp, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_set_config(dbenv, which, on)
DB_ENV *dbenv;
u_int32_t which;
int on;
{
COMPQUIET(which, 0);
COMPQUIET(on, 0);
return (__db_norep(dbenv->env));
}
int
__rep_get_limit(dbenv, gbytesp, bytesp)
DB_ENV *dbenv;
u_int32_t *gbytesp, *bytesp;
{
COMPQUIET(gbytesp, NULL);
COMPQUIET(bytesp, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_noarchive(env)
ENV *env;
{
COMPQUIET(env, NULL);
return (0);
}
int
__rep_open(env)
ENV *env;
{
COMPQUIET(env, NULL);
return (0);
}
int
__rep_preclose(env)
ENV *env;
{
return (__db_norep(env));
}
int
__rep_process_message(dbenv, control, rec, eid, ret_lsnp)
DB_ENV *dbenv;
DBT *control, *rec;
int eid;
DB_LSN *ret_lsnp;
{
COMPQUIET(control, NULL);
COMPQUIET(rec, NULL);
COMPQUIET(eid, 0);
COMPQUIET(ret_lsnp, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_send_message(env, eid, rtype, lsnp, dbtp, logflags, repflags)
ENV *env;
int eid;
u_int32_t rtype;
DB_LSN *lsnp;
const DBT *dbtp;
u_int32_t logflags, repflags;
{
COMPQUIET(eid, 0);
COMPQUIET(rtype, 0);
COMPQUIET(lsnp, NULL);
COMPQUIET(dbtp, NULL);
COMPQUIET(logflags, 0);
COMPQUIET(repflags, 0);
return (__db_norep(env));
}
int
__rep_set_limit(dbenv, gbytes, bytes)
DB_ENV *dbenv;
u_int32_t gbytes, bytes;
{
COMPQUIET(gbytes, 0);
COMPQUIET(bytes, 0);
return (__db_norep(dbenv->env));
}
int
__rep_set_transport(dbenv, eid, f_send)
DB_ENV *dbenv;
int eid;
int (*f_send) __P((DB_ENV *, const DBT *, const DBT *, const DB_LSN *,
int, u_int32_t));
{
COMPQUIET(eid, 0);
COMPQUIET(f_send, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_set_request(dbenv, min, max)
DB_ENV *dbenv;
u_int32_t min, max;
{
COMPQUIET(min, 0);
COMPQUIET(max, 0);
return (__db_norep(dbenv->env));
}
int
__rep_get_request(dbenv, minp, maxp)
DB_ENV *dbenv;
u_int32_t *minp, *maxp;
{
COMPQUIET(minp, NULL);
COMPQUIET(maxp, NULL);
return (__db_norep(dbenv->env));
}
int
__rep_start(dbenv, dbt, flags)
DB_ENV *dbenv;
DBT *dbt;
u_int32_t flags;
{
COMPQUIET(dbt, NULL);
COMPQUIET(flags, 0);
return (__db_norep(dbenv->env));
}
int
__rep_stat_pp(dbenv, statp, flags)
DB_ENV *dbenv;
DB_REP_STAT **statp;
u_int32_t flags;
{
COMPQUIET(statp, NULL);
COMPQUIET(flags, 0);
return (__db_norep(dbenv->env));
}
int
__rep_stat_print_pp(dbenv, flags)
DB_ENV *dbenv;
u_int32_t flags;
{
COMPQUIET(flags, 0);
return (__db_norep(dbenv->env));
}
int
__rep_stat_print(env, flags)
ENV *env;
u_int32_t flags;
{
COMPQUIET(flags, 0);
return (__db_norep(env));
}
int
__rep_sync(dbenv, flags)
DB_ENV *dbenv;
u_int32_t flags;
{
COMPQUIET(flags, 0);
return (__db_norep(dbenv->env));
}
#endif /* !HAVE_REPLICATION */