Net2/usr/src/contrib/isode/psap/llib-lpsap
/* llib-lpsap - lint library for -lpsap */
/*
* $Header: /f/osi/psap/RCS/llib-lpsap,v 7.10 91/02/22 09:35:45 mrose Interim $
*
*
* $Log: llib-lpsap,v $
* Revision 7.10 91/02/22 09:35:45 mrose
* Interim 6.8
*
* Revision 7.9 91/01/07 12:40:29 mrose
* update
*
* Revision 7.8 90/12/23 18:44:01 mrose
* update
*
* Revision 7.7 90/11/11 10:01:24 mrose
* touch-up
*
* Revision 7.6 90/11/04 19:17:57 mrose
* update
*
* Revision 7.5 90/08/08 14:13:41 mrose
* stuff
*
* Revision 7.4 90/07/27 08:47:27 mrose
* update
*
* Revision 7.3 90/07/09 14:43:39 mrose
* sync
*
* Revision 7.2 90/05/08 08:54:58 mrose
* touch-up
*
* Revision 7.1 90/03/23 11:05:50 mrose
* typo
*
* Revision 7.0 89/11/23 22:12:42 mrose
* Release 6.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 <stdio.h>
#include "psap.h"
#include "ssap.h"
#include "logger.h"
/* Primitives (Built-in Types) <-> Data */
int prim2flag (pe)
PE pe;
{
return prim2flag (pe);
}
PE flag2prim (b, class, id)
int b;
PElementClass class;
PElementID id;
{
return flag2prim (b, class, id);
}
integer prim2num (pe)
PE pe;
{
return prim2num (pe);
}
PE num2prim (i, class, id)
integer i;
PElementClass class;
PElementID id;
{
return num2prim (i, class, id);
}
double prim2real (pe)
PE pe;
{
return prim2real (pe);
}
PE real2prim (d, class, id)
double d;
PElementClass class;
PElementID id;
{
return real2prim (d, class, id);
}
char *prim2str (pe, len)
PE pe;
int *len;
{
return prim2str (pe, len);
}
PE str2prim (s, len, class, id)
char *s;
int len;
PElementClass class;
PElementID id;
{
return str2prim (s, len, class, id);
}
struct qbuf *prim2qb (pe)
PE pe;
{
return prim2qb (pe);
}
PE qb2prim_aux (qb, class, id, in_line)
struct qbuf *qb;
PElementClass class;
PElementID id;
int in_line;
{
return qb2prim_aux (qb, class, id, in_line);
}
/* BITSTRING manipulation */
PE prim2bit (pe)
PE pe;
{
return prim2bit (pe);
}
PE bit2prim (pe)
PE pe;
{
return bit2prim (pe);
}
int bit_on (pe, i)
PE pe;
int i;
{
return bit_on (pe, i);
}
int bit_off (pe, i)
PE pe;
int i;
{
return bit_off (pe, i);
}
int bit_test (pe, i)
PE pe;
int i;
{
return bit_test (pe, i);
}
/* Routines for pepy */
char *int2strb (n, len)
int n,
len;
{
return int2strb (n, len);
}
int strb2int (cp, len)
char *cp;
int len;
{
return strb2int (cp, len);
}
PE strb2bitstr (cp, len, class, id)
char *cp;
int len;
PElementClass class;
PElementID id;
{
return strb2bitstr (cp, len, class, id);
}
char *bitstr2strb (pe, len)
PE pe;
int *len;
{
return bitstr2strb (pe, len);
}
/* Primitives (Defined Types) <-> Data */
OID prim2oid (pe)
PE pe;
{
return prim2oid (pe);
}
PE obj2prim (o, class, id)
OID o;
PElementClass class;
PElementID id;
{
return obj2prim (o, class, id);
}
UTC prim2time (pe, generalized)
PE pe;
int generalized;
{
return prim2time (pe, generalized);
}
PE time2prim (u, generalized, class, id)
UTC u;
int generalized;
PElementClass class;
PElementID id;
{
return time2prim (u, generalized, class, id);
}
char *time2str (u, generalized)
UTC u;
int generalized;
{
return time2str (u, generalized);
}
UTC str2utct (cp, len)
char *cp;
int len;
{
return str2utct (cp, len);
}
UTC str2gent (cp, len)
char *cp;
int len;
{
return str2gent (cp, len);
}
/* LIST manipulation */
PE prim2set (pe)
PE pe;
{
return prim2set (pe);
}
int set_add (pe, r)
PE pe,
r;
{
return set_add (pe, r);
}
int set_del (pe, class, id)
PE pe;
PElementClass class;
PElementID id;
{
return set_del (pe, class, id);
}
PE set_find (pe, class, id)
PE pe;
PElementClass class;
PElementID id;
{
return set_find (pe, class, id);
}
int seq_add (pe, r, i)
PE pe,
r;
int i;
{
return seq_add (pe, r, i);
}
int seq_del (pe, i)
PE pe;
int i;
{
return seq_del (pe, i);
}
PE seq_find (pe, i)
PE pe;
int i;
{
return seq_find (pe, i);
}
/* PElement manipulation */
PE pe_alloc (class, form, id)
PElementClass class;
PElementForm form;
PElementID id;
{
return pe_alloc (class, form, id);
}
int pe_free (pe)
PE pe;
{
(void) pe_free (pe);
}
int pe_cmp (p, q)
PE p,
q;
{
return pe_cmp (p, q);
}
PE pe_cpy (pe)
PE pe;
{
return pe_cpy (pe);
}
int pe_pullup (pe)
PE pe;
{
return pe_pullup (pe);
}
PE pe_expunge (pe, r)
PE pe,
r;
{
return pe_expunge (pe, r);
}
int pe_extract (pe, r)
PE pe,
r;
{
return pe_extract (pe, r);
}
PE str2pe (s, len, advance, result)
char *s;
int len,
*advance,
*result;
{
return str2pe (s, len, advance, result);
}
PE qb2pe (qb, len, depth, result)
struct qbuf *qb;
int len,
depth,
*result;
{
return qb2pe (qb, len, depth, result);
}
/* PStream manipulation */
PS ps_alloc (io)
IFP io;
{
return ps_alloc (io);
}
void ps_free (ps)
PS ps;
{
ps_free (ps);
}
/* PStream I/O */
int ps_io (ps, io, data, n, in_line)
PS ps;
IFP io;
PElementData data;
PElementLen n;
int in_line;
{
return ps_io (ps, io, data, n, in_line);
}
int ps_flush (ps)
PS ps;
{
return ps_flush (ps);
}
int ps_prime (ps, waiting)
PS ps;
int waiting;
{
return ps_prime (ps, waiting);
}
int std_open (ps)
PS ps;
{
return std_open (ps);
}
int str_open (ps)
PS ps;
{
return str_open (ps);
}
int str_setup (ps, cp, cc, in_line)
PS ps;
char *cp;
int cc,
in_line;
{
return str_setup (ps, cp, cc, in_line);
}
int dg_open (ps)
PS ps;
{
return df_open (ps);
}
int dg_setup (ps, fd, size, rfx, wfx, cfx)
PS ps;
int fd,
size;
IFP rfx,
wfx,
cfx;
{
return dg_setup (ps, fd, size, rfx, wfx, cfx);
}
int fdx_open (ps)
PS ps;
{
return fdx_open (ps);
}
int fdx_setup (ps, fd)
PS ps;
int fd;
{
return fdx_setup (ps, fd);
}
int qbuf_open (ps)
PS ps;
{
return qbuf_open (ps);
}
int uvec_open (ps)
PS ps;
{
return uvec_open (ps);
}
int uvec_setup (ps, len)
PS ps;
int len;
{
return uvec_setup (ps, len);
}
/* PStream <-> PElement */
PE ps2pe_aux (ps, top, all)
PS ps;
int top,
all;
{
return ps2pe_aux (ps, top, all);
}
int pe2ps_aux (ps, pe, eval)
PS ps;
PE pe;
int eval;
{
return pe2ps_aux (ps, pe, eval);
}
/* PList <-> PElement */
PE pl2pe (ps)
PS ps;
{
return pl2pe (ps);
}
int pe2pl (ps, pe)
PS ps;
PE pe;
{
return pe2pl (ps, pe);
}
int ps_get_abs (pe)
PE pe;
{
return ps_get_abs (pe);
}
/* Diagnostics */
char *pe_error (c)
int c;
{
return pe_error (c);
}
char *ps_error (c)
int c;
{
return ps_error (c);
}
/* Object IDentifiers */
OID ode2oid (descriptor)
char *descriptor;
{
return ode2oid (descriptor);
}
int oid_cmp (p, q)
OID p,
q;
{
return oid_cmp (p, q);
}
int elem_cmp (ip, i, jp, j)
int i,
j;
unsigned int *ip,
*jp;
{
return elem_cmp (ip, i, jp, j);
}
OID oid_cpy (oid)
OID oid;
{
return oid_cpy (oid);
}
int oid_free (oid)
OID oid;
{
(void) oid_free (oid);
}
char *oid2ode_aux (oid, quoted)
OID oid;
int quoted;
{
return oid2ode_aux (oid, quoted);
}
char *sprintoid (oid)
OID oid;
{
return sprintoid (oid);
}
OID str2oid (s)
char *s;
{
return str2oid (s);
}
/* */
int pe2qb_f (pe)
PE pe;
{
return pe2qb_f (pe);
}
PE qbuf2pe_f (result)
int *result;
{
return qbuf2pe_f (result);
}
#undef qbuf2pe
PE qbuf2pe (qb, len, result)
struct qbuf *qb;
int len;
int *result;
{
return qbuf2pe (qb, len, result);
}
char *qb2str (q)
struct qbuf *q;
{
return qb2str (q);
}
struct qbuf *str2qb (s, len, head)
char *s;
int len,
head;
{
return str2qb (s, len, head);
}
int qb_pullup (qb)
struct qbuf *qb;
{
return qb_pullup (qb);
}
int qb_free (qb)
struct qbuf *qb;
{
(void) qb_free (qb);
}
int pe2ssdu (pe, base, len)
PE pe;
char **base;
int *len;
{
return pe2ssdu (pe, base, len);
}
PE ssdu2pe (base, len, realbase, result)
char *base,
*realbase;
int len;
int *result;
{
return ssdu2pe (base, len, realbase, result);
}
void pe2text (lp, pe, rw, cc)
LLog *lp;
PE pe;
int rw,
cc;
{
pe2text (lp, pe, rw, cc);
}
int pe2uvec (pe, uv)
PE pe;
struct udvec **uv;
{
return pe2uvec (pe, uv);
}
/* */
long gtime (tm)
struct tm *tm;
{
return gtime (tm);
}
struct tm *ut2tm (ut)
UTC ut;
{
return ut2tm (ut);
}
void tm2ut (tm, ut)
struct tm *tm;
UTC ut;
{
tm2ut (tm, ut);
}
struct SSAPref *addr2ref (addr)
char *addr;
{
return addr2ref (addr);
}
char *sprintref (sr)
struct SSAPref *sr;
{
return sprintref (sr);
}
/* these really belong in llib-lpepsy (which doesn't exist!) */
/* VARARGS */
void PY_advise (what, fmt)
char *what,
*fmt;
{
PY_advise (what, fmt);
}
char *bit2str (pe, s)
PE pe;
char *s;
{
return bit2str (pe, s);
}
/* VARARGS1 */
vprint (fmt)
char *fmt;
{
vprint (fmt);
}
#undef vunknown
vunknown (pe)
PE pe;
{
vunknown (pe);
}
vsetfp (fp, s)
FILE *fp;
char *s;
{
vsetfp (fp, s);
}
vpushfp (fp, pe, s, rw)
FILE *fp;
PE pe;
char *s;
int rw;
{
vpushfp (fp, pe, s, rw);
}
vpopfp ()
{}
vpushstr (cp)
char *cp;
{
vpushstr (cp);
}
vpopstr ()
{}
vpushpp (pv, pfnx, pe, text, rw)
caddr_t pv;
IFP pfnx;
register PE pe;
char *text;
int rw;
{
vpushpp (pv, pfnx, pe, text, rw);
}
vpopp ()
{}
vpushquipu (ps)
PS ps;
{
vpushquipu (ps);
}
vpopquipu ()
{}
_vpdu (lp, fnx, pe, text, rw)
LLog *lp;
IFP fnx;
PE pe;
char *text;
int rw;
{
_vpdu (lp, fnx, pe, text, rw);
}
#include "pepsy.h"
int enc_f (typ, mod, pe, explicit, len, buf, parm)
int typ;
modtyp *mod;
PE *pe;
int explicit;
int len;
char *buf;
char *parm;
{
return enc_f (typ, mod, pe, explicit, len, buf, parm);
}
int dec_f (typ, mod, pe, explicit, len, buf, parm)
int typ;
modtyp *mod;
PE pe;
int explicit;
int *len;
char **buf;
char **parm;
{
return dec_f (typ, mod, pe, explicit, len, buf, parm);
}
int fre_obj (parm, p, mod, dofree)
modtyp *mod;
tpe *p;
char *parm;
{
return fre_obj (parm, p, mod, dofree);
}
#undef pvpdu
pvpdu (lp, ind, mod, pe, text, rw)
LLog *lp;
int ind;
modtyp *mod;
PE pe;
char *text;
int rw;
{
pvpdu (lp, ind, mod, pe, text, rw);
}
_pvpdu (lp, pe, text, rw)
LLog *lp;
PE pe;
char *text;
int rw;
{
_pvpdu (lp, pe, text, rw);
}
/* these really belong in llib-lpepy (which doesn't exist!) */
int PY_pp (argc, argv, envp, pfx)
int argc;
char **argv,
**envp;
IFP pfx;
{
return PY_pp (argc, argv, envp, pfx);
}
int testdebug (pe, s)
PE pe;
char *s;
{
return testdebug (pe, s);
}