Return to llib-lx500as CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / x500as

BSD 4.3reno

/* llib-lx500as - lint library for QUIPU x500 abstract syntax */

/* 
 * $Header: /var/lib/cvsd/repos/CSRG/43BSDReno/contrib/isode-beta/dsap/x500as/llib-lx500as,v 1.1.1.1 2018/04/24 16:12:56 root Exp $
 *
 *
 * $Log: llib-lx500as,v $
 * Revision 1.1.1.1  2018/04/24 16:12:56  root
 * BSD 4.3reno
 *
 * Revision 7.0  89/11/23  21:50:43  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 "quipu/util.h"
#include "quipu/common.h"
#include "quipu/entry.h"
#include "quipu/dsargument.h"

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


eis_def(eis_p) 
EntryInfoSelection *eis_p; 
{
	(void) eis_def(eis_p);
} 

svc_def(svc_p) 
ServiceControl *svc_p; 
{
	(void) svc_def(svc_p);
} 

flt_def(flt) 
Filter * flt; 
{
	(void) flt_def(flt);
} 

subords_free(subp) 
struct subordinate *subp; 
{
	(void) subords_free(subp);
} 

ems_free(emp) 
struct entrymod *emp; 
{
	(void) ems_free(emp);
} 

aps_free(app) 
struct access_point *app; 
{
	(void) aps_free(app);
} 

crefs_free(crefp) 
ContinuationRef crefp; 
{
	(void) crefs_free(crefp);
} 


int decode_OPArgument(dsp, pe, type, arg) 
int dsp; 
PE pe; 
int type; 
struct ds_op_arg *arg; 
{
	return decode_OPArgument(dsp, pe, type, arg);
} 

int decode_DAPArgument(pe,type,arg) 
PE pe; 
int type; 
struct DSArgument *arg; 
{
	return decode_DAPArgument(pe,type,arg);
} 

int decode_DSPArgument(pe,type,arg) 
PE pe; 
int type; 
struct ds_op_arg *arg; 
{
	return decode_DSPArgument(pe,type,arg);
} 


int encode_OPArgument(dsp, pep, typep, arg) 
int dsp; 
PE *pep; 
int *typep; 
struct ds_op_arg *arg; 
{
	return encode_OPArgument(dsp, pep, typep, arg) ;
} 

int encode_DAPArgument(pep,typep,arg) 
PE * pep; 
int * typep; 
struct DSArgument *arg; 
{
	return encode_DAPArgument(pep,typep,arg);
} 

int encode_DSPArgument(pep,typep,arg) 
PE *pep; 
int *typep; 
struct ds_op_arg *arg; 
{
	return encode_DSPArgument(pep,typep,arg);
} 


int print_OPArgument(dsp, pe, type) 
int dsp; 
PE pe; 
int type; 
{
	return print_OPArgument(dsp, pe, type) ;
} 

int print_DAPArgument(pe,type) 
PE pe; 
int type; 
{
	return print_DAPArgument(pe,type) ;
} 

int print_DSPArgument(pe,type) 
PE pe; 
int type; 
{
	return print_DSPArgument(pe,type) ;
} 


int decode_OPError(pe, type, err) 
PE pe; 
int type; 
struct DSError *err; 
{
	return decode_OPError(pe, type, err) ;
} 


int encode_OPError(pep, typep, err) 
PE *pep; 
int *typep; 
struct DSError *err; 
{
	return encode_OPError(pep, typep, err) ;
} 


int print_OPError(pe, type) 
PE pe; 
int type; 
{
	return print_OPError(pe, type) ;
} 


int decode_OPResult(dsp, pe, type, res) 
int dsp; 
PE pe; 
int type; 
struct ds_op_res *res; 
{
	return decode_OPResult(dsp, pe, type, res) ;
} 

int decode_DAPResult(pe,type,res) 
PE pe; 
int type; 
struct DSResult *res; 
{
	return decode_DAPResult(pe,type,res) ;
} 

int decode_DSPResult(pe,type,res) 
PE pe; 
int type; 
struct ds_op_res *res; 
{
	return decode_DSPResult(pe,type,res) ;
} 


int encode_OPResult(dsp, pep, typep, res) 
int dsp; 
PE *pep; 
int *typep; 
struct ds_op_res *res; 
{
	return encode_OPResult(dsp, pep, typep, res) ;
} 

int encode_DAPResult(pep,typep,res) 
PE * pep; 
int * typep; 
struct DSResult *res; 
{
	return encode_DAPResult(pep,typep,res) ;
} 

int encode_DSPResult(pep,typep,res) 
PE *pep; 
int *typep; 
struct ds_op_res *res; 
{
	return encode_DSPResult(pep,typep,res) ;
} 


int print_OPResult(dsp, pe, type) 
int dsp; 
PE pe; 
int type; 
{
	return print_OPResult(dsp, pe, type) ;
} 

int print_DAPResult(pe,type) 
PE pe; 
int type; 
{
	return print_DAPResult(pe,type) ;
} 

int print_DSPResult(pe,type) 
PE pe; 
int type; 
{
	return print_DSPResult(pe,type) ;
} 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.