int32_t tmpint32;
        int rc;
        slap_callback cb = {0};
-       SlapReply rs = {REP_RESULT};
        char dnc[1024];
        char uidc[32];
        char svcc[256];
 
        void *thrctx;
 
        Modifications mod;
-       SlapReply rsm = { 0 };
        slap_callback cb = {0};
        char intbuf[64];
        struct berval bv[2];
 
        struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
        Entry           *e = NULL;
        EntryInfo       *ei;
-       Attribute       *a;
        int             manageDSAit = get_manageDSAit( op );
 
        DB_TXN          *rtxn;
 
        DB *db = bdb->bi_dn2id->bdi_db;
        char            *buf;
        DBT             key;
-       DB_LOCK lock;
        struct berval   pdn, ptr;
        int             rc;
 
        int rc;
        ID      nid;
        unsigned char dlen[2];
-       DB_LOCK lock;
 
        Debug( LDAP_DEBUG_TRACE, "=> hdb_dn2id_delete 0x%lx: \"%s\"\n",
                e->e_id, e->e_ndn, 0 );
 
 } ContinuationReference_t;
 #define        CR_INIT         { NULL, BER_BVNULL, LDAP_DP_RT_UNKNOWN, BER_BVNULL, LDAP_DP_SS_UNKNOWN, NULL, BER_BVNULL }
 
+#ifdef unused
 static struct berval   bv2rt[] = {
        BER_BVC( "superior" ),
        BER_BVC( "subordinate" ),
        ber_str2bv( s, 0, 0, &bv );
        return ldap_distproc_bv2ss( &bv );
 }
+#endif /* unused */
 
 /*
  * NOTE: this overlay assumes that the chainingBehavior control
 #define        ldap_distproc_db_close_one(be)          (0)
 #define        ldap_distproc_db_destroy_one(be, ca)    (lback)->bi_db_destroy( (be), (ca) )
 
-static int
-ldap_distproc_parse_ctrl(
-       Operation       *op,
-       SlapReply       *rs,
-       LDAPControl     *ctrl );
-
 static int
 ldap_distproc_uri_cmp( const void *c1, const void *c2 )
 {
 
 {
        monitor_info_t  *mi = ( monitor_info_t * ) op->o_bd->be_private;
        Entry           *e, *matched = NULL;
-       Attribute       *a;
        int             rc;
 
        /* get entry with reader lock */
        }
 
        rs->sr_err = slap_compare_entry( op, e, op->orc_ava );
-
-return_results:;
        rc = rs->sr_err;
        switch ( rc ) {
        case LDAP_COMPARE_FALSE:
        case LDAP_COMPARE_TRUE:
                rc = LDAP_SUCCESS;
                break;
-
-       default:
-               break;
        }
                
        send_ldap_result( op, rs );
 
 
                ma = attr_find( op->ora_e->e_attrs, mo->mo_ad_memberof );
                if ( ma != NULL ) {
-                       char relax = op->o_relax;
-
                        /* relax is required to allow to add
                         * a non-existing member */
                        op->o_relax = SLAP_CONTROL_CRITICAL;
 
 {
        int i, len = 0;
        struct berval *vals, pres = BER_BVC("*");
-       char *p1, *p2, *t1;
+       char *p1, *p2;
        Attribute *a;
 
        vals = op->o_tmpalloc( temp->bindnattrs * sizeof( struct berval ),
 {
        if ( rs->sr_type == REP_SEARCH ) {
                refresh_info *ri = op->o_callback->sc_private;
-               BackendDB *be = op->o_bd;
                Entry *e;
                dnlist *dnl;
                slap_callback *ocb;
 
        ObjectClass *oc, AttributeDescription *at, int rw, Entry **ep )
 {
        slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
-       struct ldaprwmap        *rwmap = 
-                       (struct ldaprwmap *)on->on_bi.bi_private;
-
        int                     rc;
-       dncookie                dc;
-
        BackendDB               db;
        Operation               op2;
        SlapReply               rs = { REP_SEARCH };
        return rwm_bva_add( &rwmap->rwm_bva_rewrite, idx, argv );
 }
 
+#ifdef unused
 static int
 rwm_bva_map_add(
        struct ldaprwmap        *rwmap,
 {
        return rwm_bva_add( &rwmap->rwm_bva_map, idx, argv );
 }
+#endif /* unused */
 
 static int
 rwm_info_init( struct rewrite_info ** rwm_rw )
 
 static int
 syncprov_sendresp( Operation *op, opcookie *opc, syncops *so, int mode )
 {
-       slap_overinst *on = opc->son;
-
        SlapReply rs = { REP_SEARCH };
        LDAPControl *ctrls[2];
        struct berval cookie = BER_BVNULL, csns[2];
 {
        slap_overinst *on = LDAP_SLIST_FIRST(&so->s_op->o_extra)->oe_key;
        syncres *sr;
-       Entry *e;
        opcookie opc;
        int rc = 0;
 
        slap_overinst *on = opc->son;
        syncprov_info_t         *si = on->on_bi.bi_private;
        syncmatches *sm, *snext;
-       modtarget *mt, mtdummy;
+       modtarget *mt;
 
        ldap_pvt_thread_mutex_lock( &si->si_ops_mutex );
        if ( si->si_active )
 
 }
 
 static int translucent_exop(Operation *op, SlapReply *rs) {
-       SlapReply nrs = { REP_RESULT };
-
        slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;
        translucent_info *ov = on->on_bi.bi_private;
        const struct berval bv_exop_pwmod = BER_BVC(LDAP_EXOP_MODIFY_PASSWD);
 
                         * in the provider are always propagated.
                         */
                        if ( dni->new_entry ) {
-                               Modifications **modtail, **ml;
                                Attribute *old, *new;
                                struct berval old_rdn, new_rdn;
                                struct berval old_p, new_p;