DataMuseum.dk

top - metrics - download

    Length: 9031 (0x2347)
    Types: TextFile
    Names: »llib-lpsap«

└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
    └─⟦35176feda⟧ »EurOpenD22/isode/isode-6.tar.Z« 
        └─⟦de7628f85⟧ 
            └─⟦this⟧ »isode-6.0/psap/llib-lpsap« 

TextFile

/* llib-lpsap - lint library for -lpsap */

/* 
 * $Header: /f/osi/psap/RCS/llib-lpsap,v 7.0 89/11/23 22:12:42 mrose Rel $
 *
 *
 * $Log:	llib-lpsap,v $
 * 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"

/* \f

   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 (qb, class, id)
struct qbuf *qb;
PElementClass	class;
PElementID	id;
{
    return qb2prim (qb, class, id);
}

/* \f

   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);
}

/* \f

   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);
}


/* \f

   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);
}

/* \f

   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);
}

/* \f

   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);
}


/* \f

   PStream manipulation */

PS	ps_alloc (io)
IFP	io;
{
    return ps_alloc (io);
}


void	ps_free (ps)
PS	ps;
{
    ps_free (ps);
}

/* \f

   PStream I/O */

int     ps_io (ps, io, data, n, inline)
PS	ps;
IFP	io;
PElementData data;
PElementLen n;
int	inline;
{
    return ps_io (ps, io, data, n, inline);
}


int	ps_flush (ps)
PS	ps;
{
    return ps_flush (ps);
}


int	ps_prime (ps)
PS	ps;
{
    return ps_prime (ps);
}


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, inline)
PS	ps;
char   *cp;
int	cc,
	inline;
{
    return str_setup (ps, cp, cc, inline);
}


int	dg_open (ps)
PS	ps;
{
    return df_open (ps);
}


int	dg_setup (ps, fd, size, rfx, wfx)
PS	ps;
int	fd,
	size;
IFP	rfx,
	wfx;
{
    return dg_setup (ps, fd, size, rfx, wfx);
}

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);
}

/* \f

   PStream <-> PElement */

PE	ps2pe_aux (ps, top)
PS	ps;
int     top;
{
    return ps2pe_aux (ps, top);
}


int     pe2ps_aux (ps, pe, eval)
PS	ps;
PE	pe;
int	eval;
{
    return pe2ps_aux (ps, pe, eval);
}

/* \f

   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);
}

/* \f

   Diagnostics */

char   *pe_error (c)
int     c;
{
    return pe_error (c);
}

char   *ps_error (c)
int     c;
{
    return ps_error (c);
}

/* \f

   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 (oid)
OID	oid;
{
    return oid2ode (oid);
}

char   *sprintoid (oid)
OID	oid;
{
    return sprintoid (oid);
}

OID	str2oid (s)
char   *s;
{
    return str2oid (s);
}

/* \f

 */

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);
}

/* \f

 */

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-lpepy (which doesn't exist!) */

/* VARARGS */

void	PY_advise (what, fmt)
char   *what,
       *fmt;
{
    PY_advise (what, fmt);
}


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);
}


/* VARARGS1 */

vprint (fmt)
char   *fmt;
{
    vprint (fmt);
}


char *bit2str (pe, s)
PE	pe;
char   *s;
{
    return bit2str (pe, 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 ()
{
}

_vpdu (lp, fnx, pe, text, rw)
LLog   *lp;
IFP	fnx;
PE	pe;
char   *text;
int	rw;
{
    _vpdu (lp, fnx, pe, text, rw);
}