Return to llib-lx500as CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/dsap/x500as/llib-lx500as, revision 1.1

1.1     ! root        1: /* llib-lx500as - lint library for QUIPU x500 abstract syntax */
        !             2: 
        !             3: /* 
        !             4:  * $Header: /f/osi/dsap/x500as/RCS/llib-lx500as,v 7.0 89/11/23 21:50:43 mrose Rel $
        !             5:  *
        !             6:  *
        !             7:  * $Log:       llib-lx500as,v $
        !             8:  * Revision 7.0  89/11/23  21:50:43  mrose
        !             9:  * Release 6.0
        !            10:  * 
        !            11:  */
        !            12: 
        !            13: /*
        !            14:  *                               NOTICE
        !            15:  *
        !            16:  *    Acquisition, use, and distribution of this module and related
        !            17:  *    materials are subject to the restrictions of a license agreement.
        !            18:  *    Consult the Preface in the User's Manual for the full terms of
        !            19:  *    this agreement.
        !            20:  *
        !            21:  */
        !            22: 
        !            23: 
        !            24: /* LINTLIBRARY */
        !            25: 
        !            26: #include "quipu/util.h"
        !            27: #include "quipu/common.h"
        !            28: #include "quipu/entry.h"
        !            29: #include "quipu/dsargument.h"
        !            30: 
        !            31: void ds_advise (what, fmt) 
        !            32: char *what, 
        !            33: *fmt; 
        !            34: {
        !            35:        ds_advise (what, fmt);
        !            36: } 
        !            37: 
        !            38: 
        !            39: eis_def(eis_p) 
        !            40: EntryInfoSelection *eis_p; 
        !            41: {
        !            42:        (void) eis_def(eis_p);
        !            43: } 
        !            44: 
        !            45: svc_def(svc_p) 
        !            46: ServiceControl *svc_p; 
        !            47: {
        !            48:        (void) svc_def(svc_p);
        !            49: } 
        !            50: 
        !            51: flt_def(flt) 
        !            52: Filter * flt; 
        !            53: {
        !            54:        (void) flt_def(flt);
        !            55: } 
        !            56: 
        !            57: subords_free(subp) 
        !            58: struct subordinate *subp; 
        !            59: {
        !            60:        (void) subords_free(subp);
        !            61: } 
        !            62: 
        !            63: ems_free(emp) 
        !            64: struct entrymod *emp; 
        !            65: {
        !            66:        (void) ems_free(emp);
        !            67: } 
        !            68: 
        !            69: aps_free(app) 
        !            70: struct access_point *app; 
        !            71: {
        !            72:        (void) aps_free(app);
        !            73: } 
        !            74: 
        !            75: crefs_free(crefp) 
        !            76: ContinuationRef crefp; 
        !            77: {
        !            78:        (void) crefs_free(crefp);
        !            79: } 
        !            80: 
        !            81: 
        !            82: int decode_OPArgument(dsp, pe, type, arg) 
        !            83: int dsp; 
        !            84: PE pe; 
        !            85: int type; 
        !            86: struct ds_op_arg *arg; 
        !            87: {
        !            88:        return decode_OPArgument(dsp, pe, type, arg);
        !            89: } 
        !            90: 
        !            91: int decode_DAPArgument(pe,type,arg) 
        !            92: PE pe; 
        !            93: int type; 
        !            94: struct DSArgument *arg; 
        !            95: {
        !            96:        return decode_DAPArgument(pe,type,arg);
        !            97: } 
        !            98: 
        !            99: int decode_DSPArgument(pe,type,arg) 
        !           100: PE pe; 
        !           101: int type; 
        !           102: struct ds_op_arg *arg; 
        !           103: {
        !           104:        return decode_DSPArgument(pe,type,arg);
        !           105: } 
        !           106: 
        !           107: 
        !           108: int encode_OPArgument(dsp, pep, typep, arg) 
        !           109: int dsp; 
        !           110: PE *pep; 
        !           111: int *typep; 
        !           112: struct ds_op_arg *arg; 
        !           113: {
        !           114:        return encode_OPArgument(dsp, pep, typep, arg) ;
        !           115: } 
        !           116: 
        !           117: int encode_DAPArgument(pep,typep,arg) 
        !           118: PE * pep; 
        !           119: int * typep; 
        !           120: struct DSArgument *arg; 
        !           121: {
        !           122:        return encode_DAPArgument(pep,typep,arg);
        !           123: } 
        !           124: 
        !           125: int encode_DSPArgument(pep,typep,arg) 
        !           126: PE *pep; 
        !           127: int *typep; 
        !           128: struct ds_op_arg *arg; 
        !           129: {
        !           130:        return encode_DSPArgument(pep,typep,arg);
        !           131: } 
        !           132: 
        !           133: 
        !           134: int print_OPArgument(dsp, pe, type) 
        !           135: int dsp; 
        !           136: PE pe; 
        !           137: int type; 
        !           138: {
        !           139:        return print_OPArgument(dsp, pe, type) ;
        !           140: } 
        !           141: 
        !           142: int print_DAPArgument(pe,type) 
        !           143: PE pe; 
        !           144: int type; 
        !           145: {
        !           146:        return print_DAPArgument(pe,type) ;
        !           147: } 
        !           148: 
        !           149: int print_DSPArgument(pe,type) 
        !           150: PE pe; 
        !           151: int type; 
        !           152: {
        !           153:        return print_DSPArgument(pe,type) ;
        !           154: } 
        !           155: 
        !           156: 
        !           157: int decode_OPError(pe, type, err) 
        !           158: PE pe; 
        !           159: int type; 
        !           160: struct DSError *err; 
        !           161: {
        !           162:        return decode_OPError(pe, type, err) ;
        !           163: } 
        !           164: 
        !           165: 
        !           166: int encode_OPError(pep, typep, err) 
        !           167: PE *pep; 
        !           168: int *typep; 
        !           169: struct DSError *err; 
        !           170: {
        !           171:        return encode_OPError(pep, typep, err) ;
        !           172: } 
        !           173: 
        !           174: 
        !           175: int print_OPError(pe, type) 
        !           176: PE pe; 
        !           177: int type; 
        !           178: {
        !           179:        return print_OPError(pe, type) ;
        !           180: } 
        !           181: 
        !           182: 
        !           183: int decode_OPResult(dsp, pe, type, res) 
        !           184: int dsp; 
        !           185: PE pe; 
        !           186: int type; 
        !           187: struct ds_op_res *res; 
        !           188: {
        !           189:        return decode_OPResult(dsp, pe, type, res) ;
        !           190: } 
        !           191: 
        !           192: int decode_DAPResult(pe,type,res) 
        !           193: PE pe; 
        !           194: int type; 
        !           195: struct DSResult *res; 
        !           196: {
        !           197:        return decode_DAPResult(pe,type,res) ;
        !           198: } 
        !           199: 
        !           200: int decode_DSPResult(pe,type,res) 
        !           201: PE pe; 
        !           202: int type; 
        !           203: struct ds_op_res *res; 
        !           204: {
        !           205:        return decode_DSPResult(pe,type,res) ;
        !           206: } 
        !           207: 
        !           208: 
        !           209: int encode_OPResult(dsp, pep, typep, res) 
        !           210: int dsp; 
        !           211: PE *pep; 
        !           212: int *typep; 
        !           213: struct ds_op_res *res; 
        !           214: {
        !           215:        return encode_OPResult(dsp, pep, typep, res) ;
        !           216: } 
        !           217: 
        !           218: int encode_DAPResult(pep,typep,res) 
        !           219: PE * pep; 
        !           220: int * typep; 
        !           221: struct DSResult *res; 
        !           222: {
        !           223:        return encode_DAPResult(pep,typep,res) ;
        !           224: } 
        !           225: 
        !           226: int encode_DSPResult(pep,typep,res) 
        !           227: PE *pep; 
        !           228: int *typep; 
        !           229: struct ds_op_res *res; 
        !           230: {
        !           231:        return encode_DSPResult(pep,typep,res) ;
        !           232: } 
        !           233: 
        !           234: 
        !           235: int print_OPResult(dsp, pe, type) 
        !           236: int dsp; 
        !           237: PE pe; 
        !           238: int type; 
        !           239: {
        !           240:        return print_OPResult(dsp, pe, type) ;
        !           241: } 
        !           242: 
        !           243: int print_DAPResult(pe,type) 
        !           244: PE pe; 
        !           245: int type; 
        !           246: {
        !           247:        return print_DAPResult(pe,type) ;
        !           248: } 
        !           249: 
        !           250: int print_DSPResult(pe,type) 
        !           251: PE pe; 
        !           252: int type; 
        !           253: {
        !           254:        return print_DSPResult(pe,type) ;
        !           255: } 
        !           256: 
        !           257: 

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