⟦daa4cd362⟧

TextFile

/* llib-lcommon - lint library for QUIPU-common */

/*
 * $Header: /f/osi/dsap/common/RCS/llib-lcommon,v 6.0 89/03/18 23:27:38 mrose Rel $
 *
 *
 * $Log:	llib-lcommon,v $
# Revision 6.0  89/03/18  23:27:38  mrose
# Release 5.0
# 
 */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/common.h"
#include "quipu/dsargument.h"
#include "quipu/list.h"     
#include "quipu/ds_search.h"

struct common_args      * get_ca_ref(dsarg)
struct DSArgument       * dsarg;
{
return (get_ca_ref(dsarg) );
}

int	cha_loodetected(cha)
struct chain_arg       * cha;
{
return (cha_loopdetected(cha) );
}

acl_free (aclptr)
register struct acl * aclptr;
{
        (void) acl_free (aclptr);
}

acl_attr_free (aclptr)
register struct acl * aclptr;
{
        (void) acl_attr_free (aclptr);
}

acl_info_free (aclptr)
register struct acl_info * aclptr;
{
        (void) acl_info_free (aclptr);
}

struct acl_info * acl_info_new (x,y,z)
register int x,y;
struct dn_seq * z;
{
        return (acl_info_new (x,y,z));
}

struct acl * acl_cpy (aclptr)
register struct acl * aclptr;
{
return(acl_cpy (aclptr));
}

acl_decode (aclptr)
register struct acl * aclptr;
{
(void) acl_decode(aclptr);
}

struct acl_attr * acl_attr_cpy (aclptr)
struct acl_attr * aclptr;
{
        return (acl_attr_cpy (aclptr));
}


acl_attr_decode (aclptr)
struct acl_attr * aclptr;
{
(void) acl_attr_decode (aclptr);
}


struct acl_info * acl_info_cpy (aclptr)
struct acl_info * aclptr;
{
return (acl_info_cpy (aclptr));
}

acl_info_decode (aclptr)
struct acl_info * aclptr;
{
(void) acl_info_decode (aclptr);
}


struct acl_info * acl_default ()
{
        return (acl_default());
}

get_default_acl ()
{
(void) get_default_acl ();
}

set_default_acl (ai_ptr)
struct acl_info * ai_ptr;
{
(void) set_default_acl (ai_ptr) ;
}

test_acl_default (a)
struct acl_info * a;
{
(void) test_acl_default (a);
}

acl_info_comp_print (ps,aclptr,format)
register PS ps;
register struct acl_info * aclptr;
register int format;
{
(void) acl_info_comp_print (ps,aclptr,format);
}

acl_info_print (ps,aclptr,format,acl_type,oidseq)
register PS ps;
struct   acl_info * aclptr;
register int format;
char * acl_type;
struct oid_seq *oidseq;
{
(void) acl_info_print (ps,aclptr,format,acl_type,oidseq);
}

acl_print (ps,aclptr,format)
register PS ps;
struct   acl * aclptr;
register int format;
{
(void) acl_print (ps,aclptr,format);
}


as_comp_free (as)
Attr_Sequence as;
{
(void) as_comp_free (as) ;
}

as_free (as)
Attr_Sequence as;
{
(void) as_free (as);
}

Attr_Sequence  as_comp_new (at,as,acl)
AttributeType  at;
AV_Sequence    as;
struct acl_info * acl;
{
return (as_comp_new (at,as,acl));
}

as_decode (x)
Attr_Sequence x;
{
(void) as_decode (x);
}


Attr_Sequence as_merge (a,b)
Attr_Sequence a,b;
{
return (as_merge (a,b));
}

as_delnext (as)
Attr_Sequence  as;
{
(void) as_delnext (as);
}

Attr_Sequence  as_comp_cpy (as)
Attr_Sequence  as;
{
return (as_comp_cpy (as));
}

Attr_Sequence  as_cpy (as)
Attr_Sequence  as;
{
return (as_cpy (as));
}

as_cmp_comp (a,b)
Attr_Sequence  a,b;
{
return (as_cmp_comp (a,b));
}

as_cmp (a,b)
Attr_Sequence  a,b;
{
return (as_cmp (a,b));
}

Attr_Sequence as_find_type (a,b)
Attr_Sequence a;
AttributeType b;
{
return (as_find_type (a,b));
}


as_comp_print (ps,as,format)
PS   ps;
Attr_Sequence  as;
int  format;
{
(void) as_comp_print (ps,as,format) ;
}

as_print (ps,as,format)
Attr_Sequence  as;
PS   ps;
int  format;
{
(void) as_print (ps,as,format);
}

AttrT_free (x)
AttributeType x;
{
(void) AttrT_free (x);
}

AttributeType AttrT_new (name)
register char * name;
{
return (AttrT_new (name));
}

AttrT_decode (x)
register AttributeType x;
{
(void) AttrT_decode (x);
}

AttributeType AttrT_cpy (x)
register AttributeType x;
{
return (AttrT_cpy (x));
}

AttrT_cmp (x,y)
register AttributeType x,y;
{
return (AttrT_cmp (x,y));
}

AttrT_print (ps,x,format)
register PS ps;
register AttributeType x;
register int format;
{
(void) AttrT_print (ps,x,format);
}

AttrV_free (x)
register AttributeValue x;
{
(void) AttrV_free (x);
}

AttributeValue str2AttrV (str,match)
register char * str;
register int match;
{
return (str2AttrV (str,match));
}

AttributeValue AttrV_cpy (x)
register AttributeValue x;
{
return (AttrV_cpy (x)) ;
}


AttrV_cmp (x,y,error)
register AttributeValue x,y;
struct DSError * error;
{
return (AttrV_cmp (x,y,error) );
}

AttrV_print (ps,x,format)
register PS ps;
register AttributeValue x;
register int format;
{
(void) AttrV_print (ps,x,format);
}


avs_comp_free (avs)
AV_Sequence avs;
{
(void) avs_comp_free (avs);
}

avs_free (avs)
AV_Sequence avs;
{
(void) avs_free (avs);
}

AV_Sequence  avs_comp_new (pe)
AttributeValue pe;
{
return (avs_comp_new (pe));
}

avs_decode (x,y)
AttributeType x;
AV_Sequence y;
{
(void) avs_decode (x,y);
}

AV_Sequence avs_merge (a,b)
AV_Sequence a,b;
{
return (avs_merge (a,b));
}


avs_delnext (avs)
AV_Sequence  avs;
{
(void) avs_delnext (avs);
}

AV_Sequence  avs_comp_cpy (avs)
AV_Sequence  avs;
{
return (avs_comp_cpy (avs));
}

AV_Sequence  avs_cpy (avs)
AV_Sequence  avs;
{
return (avs_cpy (avs));
}


avs_cmp (a,b)
AV_Sequence  a,b;
{
return (avs_cmp (a,b));
}

avs_comp_print (ps,avs,format)
AV_Sequence  avs;
PS   ps;
int  format;
{
(void) avs_comp_print (ps,avs,format);
}

avs_print (ps,avs,format)
AV_Sequence  avs;
PS   ps;
int  format;
{
(void) avs_print (ps,avs,format) ;
}

dn_comp_free (dn)
DN dn;
{
(void) dn_comp_free (dn);
}

dn_free (dn)
DN dn;
{
(void) dn_free (dn);
}

DN  dn_comp_new (rdn)
RDN rdn;
{
return (  dn_comp_new (rdn) );
}

dn_decode (x)
DN x;
{
(void) dn_decode (x);
}

dn_append (a,b)
DN a,b;
{
(void) dn_append (a,b) ;
}

DN  dn_comp_cpy (dn)
register DN  dn;
{
return (dn_comp_cpy (dn));
}

DN  dn_cpy (dn)
register DN  dn;
{
return (dn_cpy (dn));
}


dn_cmp (a,b)
register DN  a,b;
{
return (dn_cmp (a,b));
}

dn_cmp_prefix (a,b)
register DN  a,b;
{
return (dn_cmp_prefix (a,b));
}

dn_print (ps,dn,format)
DN  dn;
PS   ps;
int  format;
{
(void) dn_print (ps,dn,format);
}


DN str2dn (str)
register char * str;
{
return (str2dn (str));
}


dn_seq_free (dnseq)
struct dn_seq * dnseq;
{
(void) dn_seq_free (dnseq);
}

struct dn_seq * dn_seq_cpy (dnseq)
struct dn_seq * dnseq;
{
return (dn_seq_cpy (dnseq));
}

dn_seq_decode (dnseq)
struct dn_seq * dnseq;
{
(void) dn_seq_decode (dnseq) ;
}

dn_seq_cmp (a,b)
struct dn_seq * a, * b;
{
return (dn_seq_cmp (a,b));
}


check_dnseq (dnseq,who)
struct dn_seq * dnseq;
DN who;
{
return (check_dnseq (dnseq,who) );
}

check_dnseq_prefix (dnseq,who)
struct dn_seq * dnseq;
DN who;
{
return (check_dnseq_prefix (dnseq,who) );
}

dn_seq_print (ps,dnseq,format)
PS ps;
struct dn_seq * dnseq;
int format;
{
(void) dn_seq_print (ps,dnseq,format) ;
}

DN       dq2dn (designator, qualifier)
char    *designator,
        *qualifier;

{
return (dq2dn (designator, qualifier));
}

ds_error (ps,err)
PS ps;
struct DSError *err;
{
(void) ds_error (ps,err) ;
}

log_ds_error (err)
struct DSError *err;
{
(void) log_ds_error (err) ;
}


ds_error_free (err)
struct DSError * err;
{
(void) ds_error_free (err);
}


edb_info_comp_free (edb)
struct edb_info * edb;
{
(void) edb_info_comp_free (edb) ;
}


edb_info_free (edb)
struct edb_info * edb;
{
(void) edb_info_free (edb) ;
}

dsa_info_free (dsa)
struct dsa_info * dsa;
{
(void) dsa_info_free (dsa) ;
}

struct edb_info * edb_info_cpy (a)
struct edb_info * a;
{
return (edb_info_cpy (a));
}

edb_info_decode (a)
struct edb_info * a;
{
(void) edb_info_decode (a) ;
}

struct dsa_info * dsa_info_cpy (a)
struct dsa_info * a;
{
return (dsa_info_cpy (a));
}

edb_info_print (ps,edb,format)
PS ps;
struct edb_info * edb;
int format;
{
(void) edb_info_print (ps,edb,format);
}


entryinfo_comp_free (a,state)
register EntryInfo *a;
int state;
{
(void) entryinfo_comp_free (a,state) ;
}

entryinfo_free (a,state)
register EntryInfo * a;
register int state;
{
(void) entryinfo_free (a,state) ;
}

entryinfo_cpy (a,b)
register EntryInfo *a;
register EntryInfo *b;
{
(void) entryinfo_cpy (a,b) ;
}

entryinfo_append (a,b)
register EntryInfo *a,*b;
{
(void) entryinfo_append (a,b) ;
}

entryinfo_print (ps,entryinfo,format)
PS  ps;
EntryInfo *entryinfo;
int format;
{
(void) entryinfo_print (ps,entryinfo,format);
}

filter_free (filt)
Filter filt;
{
(void) filter_free (filt);
}

filter_append (a,b)
Filter a,b;
{
(void) filter_append (a,b) ;
}

load_oid_table (table)
char * table;
{
(void) load_oid_table (table) ;
}


oid_table_attr *name2attr(nodename)
char * nodename;
{
return (name2attr(nodename) );
}


oid_table_attr *oid2attr(oid)
OID oid;
{
return (oid2attr(oid) );
}

objectclass *name2oc(nodename)
register char * nodename;
{
return (name2oc(nodename) );
}


objectclass *oid2oc(oid)
OID oid;
{
return (oid2oc(oid) );
}


char *attr2name(oa,format)
register oid_table_attr *oa;
int format;
{
return (attr2name(oa,format) );
}


char *oc2name(oc,format)
register objectclass *oc;
int format;
{
return (oc2name(oc,format) );
}

char *oid2name(oid,format)
OID oid;
int format;
{
return (oid2name(oid,format) );
}

OID name2oid (str)
register char * str;
{
return ( name2oid (str) );
}

pe_print (ps, pe, format)
register PS     ps;
register PE     pe;
int     format;
{
(void) pe_print (ps, pe, format) ;
}

PE asn2pe (str)
char * str;
{
return (asn2pe (str) );
}

psap_free (psap)
struct PSAPaddr * psap;
{
(void) psap_free (psap) ;
}

struct PSAPaddr * psap_cpy (a)
struct PSAPaddr * a;
{
return (psap_cpy (a) );
}

psap_dup (r,a)
struct PSAPaddr * r, * a;
{
(void) psap_dup (r,a) ;
}

psap_cmp (r,a)
struct PSAPaddr *r, *a;
{
(void) psap_cmp (r,a) ;
}

rdn_comp_free (rdn)
RDN rdn;
{
(void) rdn_comp_free (rdn) ;
}

rdn_free (rdn)
RDN rdn;
{
(void) rdn_free (rdn) ;
}

RDN  rdn_comp_new (at,av)
AttributeType  at;
AttributeValue av;
{
return (rdn_comp_new (at,av) );
}

rdn_decode (x)
RDN x;
{
(void) rdn_decode (x) ;
}

RDN rdn_merge (a,b)
RDN a,b;
{
return (rdn_merge (a,b) );
}

RDN  rdn_comp_cpy (rdn)
RDN  rdn;
{
return (rdn_comp_cpy (rdn) );
}

RDN  rdn_cpy (rdn)
RDN  rdn;
{
return (rdn_cpy (rdn) );
}


rdn_cmp_comp (a,b)
RDN  a,b;
{
return (rdn_cmp_comp (a,b) );
}

rdn_cmp (a,b)
register RDN  a,b;
{
return (rdn_cmp (a,b) );
}

rdn_comp_print (ps,rdn,format)
PS   ps;
RDN  rdn;
int  format;
{
(void) rdn_comp_print (ps,rdn,format) ;
}

rdn_print (ps,rdn,format)
RDN  rdn;
PS   ps;
int  format;
{
(void) rdn_print (ps,rdn,format) ;
}

RDN str2rdn (str)
char * str;
{
return (str2rdn (str) );
}

dsap_siginit ()
{
(void) dsap_siginit () ;
}

tree_struct_free (ptr)
struct tree_struct * ptr;
{
(void) tree_struct_free (ptr) ;
}


oid_seq_free (ptr)
struct oid_seq * ptr;
{
(void) oid_seq_free (ptr) ;
}

struct oid_seq *oid_seq_merge (a,b)
struct oid_seq *a;
struct oid_seq *b;
{
return (oid_seq_merge (a,b) );
}

struct oid_seq * oid_seq_cpy (a)
struct oid_seq * a;
{
return (oid_seq_cpy (a) );
}

struct tree_struct * tree_struct_cpy (a)
struct tree_struct * a;
{
return (tree_struct_cpy (a) );
}

tree_struct_print (ps,tree,format)
register PS ps;
struct   tree_struct * tree;
register int format;
{
(void) tree_struct_print (ps,tree,format) ;
}

oid_seq_print (ps,ptr,format)
PS ps;
register struct oid_seq * ptr;
int format;
{
(void) oid_seq_print (ps,ptr,format) ;
}

char * SkipSpace (ptr)
register char * ptr;
{
return (SkipSpace (ptr) );
}

void StripSpace (b)
register char *b;
{
StripSpace (b) ;
}

void StripSpace2 (b)
register char *b;
{
StripSpace2 (b) ;
}

char * TidyString (a)
register char * a;
{
return (TidyString (a)) ;
}

/* VARARGS2 */
ps_printf (ps,fmt)
PS ps;
char * fmt;
{
(void) ps_printf (ps,fmt);
}

fatal (code,fmt)
int  code;
char *fmt;
{
(void) fatal (code,fmt);
}

pslog (lp,event,str,func,ptr)
LLog * lp;
int event;
char * str;
int (* func) ();
caddr_t ptr;
{
(void) pslog (lp,event,str,func,ptr);
}

quipu_oid_cmp (p,q)
OID p,q;
{
return (quipu_oid_cmp (p,q) );
}

quipu_pe_cmp (a,b)
register PE a,b;
{
return (quipu_pe_cmp (a,b) );
}


ava_decode (purported)
ava *purported;
{
(void) ava_decode (purported);
}

struct oid_seq * str2oidseq (str)
char * str;
{
	return (str2oidseq(str));
}

struct acl_info * str2acl_info (strptr)
char ** strptr;
{
return (str2acl_info(strptr));
}

struct acl * str2acl (str)
char * str;
{
	return (str2acl(str));
}

struct dn_seq * str2dnseq (str)
char * str;
{
	return (str2dnseq(str));
}


struct edb_info * str2update (str)
char * str;
{
	return (str2update(str));
}

struct tree_struct * str2schema (str)
char * str;
{
	return (str2schema(str));
}


parse_error (a,b)
char *a, *b;
{
	(void) parse_error (a,b);
}

AttributeValue str_at2AttrV (str,at)
char * str;
AttributeType at;
{
	return (str_at2AttrV (str,at));
}

Attr_Sequence str2as (str)
char * str;
{
	return (str2as(str));
}

AV_Sequence str2avs (str,at)
char * str;
AttributeType at;
{
	return (str2avs(str,at));
}

AV_Sequence acl_merge (a,b)
AV_Sequence a,b;
{
	return (acl_merge(a,b));
}

AV_Sequence schema_merge (a,b)
AV_Sequence a,b;
{
	return (schema_merge(a,b));
}

AV_Sequence edb_info_merge (a,b)
AV_Sequence a,b;
{
	return (acl_merge(a,b));
}

correlate_search_results(sr_res)
struct ds_search_result	* sr_res;
{
(void) correlate_search_results(sr_res);
}

merge_search_results(sr_res, sr_tmp)
struct ds_search_result	* sr_res;
struct ds_search_result	* sr_tmp;
{
(void) merge_search_results(sr_res, sr_tmp);
}

search_result_free(arg)
struct ds_search_result	* arg;
{
(void) search_result_free(arg);
}
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦daa4cd362⟧ TextFile

Derivation

TextFile
