Return to llib-lcommon CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/dsap/common/llib-lcommon, revision 1.1

1.1     ! root        1: /* llib-lcommon - lint library for QUIPU-common */
        !             2: 
        !             3: /*
        !             4:  * $Header: /f/osi/dsap/common/RCS/llib-lcommon,v 7.3 90/07/09 14:34:35 mrose Exp $
        !             5:  *
        !             6:  *
        !             7:  * $Log:       llib-lcommon,v $
        !             8: # Revision 7.3  90/07/09  14:34:35  mrose
        !             9: # sync
        !            10: # 
        !            11: # Revision 7.2  90/03/15  11:17:35  mrose
        !            12: # quipu-sync
        !            13: # 
        !            14: # Revision 7.1  89/12/19  16:19:22  mrose
        !            15: # sync
        !            16: # 
        !            17: # Revision 7.0  89/11/23  21:42:20  mrose
        !            18: # Release 6.0
        !            19: # 
        !            20:  */
        !            21: 
        !            22: /*
        !            23:  *                                NOTICE
        !            24:  *
        !            25:  *    Acquisition, use, and distribution of this module and related
        !            26:  *    materials are subject to the restrictions of a license agreement.
        !            27:  *    Consult the Preface in the User's Manual for the full terms of
        !            28:  *    this agreement.
        !            29:  *
        !            30:  */
        !            31: 
        !            32: 
        !            33: /* LINTLIBRARY */
        !            34: 
        !            35: #include <signal.h>
        !            36: #include "quipu/util.h"
        !            37: #include "quipu/entry.h"
        !            38: #include "quipu/common.h"
        !            39: #include "quipu/dsargument.h"
        !            40: #include "quipu/list.h"     
        !            41: #include "quipu/ds_search.h"
        !            42: #include "quipu/ufn.h"
        !            43: 
        !            44: struct acl_info * acl_info_new (x,y,z) 
        !            45: register int x,y; 
        !            46: struct dn_seq * z; 
        !            47: {
        !            48:        return (acl_info_new(x,y,z));
        !            49: } 
        !            50: 
        !            51: struct acl_info * acl_default () 
        !            52: {
        !            53:        return (acl_default());
        !            54: } 
        !            55: 
        !            56: int      acl_cmp (acl1, acl2)
        !            57: struct acl     * acl1;
        !            58: struct acl     * acl2;
        !            59: {
        !            60:        return (acl_cmp(acl1,acl2));
        !            61: }
        !            62: 
        !            63: get_default_acl () 
        !            64: {
        !            65:        (void) get_default_acl();
        !            66: } 
        !            67: 
        !            68: set_default_acl (ai_ptr) 
        !            69: struct acl_info * ai_ptr; 
        !            70: {
        !            71:        (void) set_default_acl(ai_ptr);
        !            72: } 
        !            73: 
        !            74: test_acl_default (a)
        !            75: struct acl_info * a;
        !            76: {
        !            77:        return (test_acl_default (a));
        !            78: }
        !            79: 
        !            80: acl_syntax ()
        !            81: {
        !            82:        (void) (acl_syntax ());
        !            83: }
        !            84: 
        !            85: as_cmp_comp (a,b) 
        !            86: Attr_Sequence a,b; 
        !            87: {
        !            88:        return (as_cmp_comp(a,b));
        !            89: } 
        !            90: 
        !            91: as_cmp (a,b) 
        !            92: Attr_Sequence a,b; 
        !            93: {
        !            94:        return (as_cmp(a,b));
        !            95: } 
        !            96: 
        !            97: 
        !            98: Attr_Sequence as_comp_cpy (as) 
        !            99: Attr_Sequence as; 
        !           100: {
        !           101:        return (as_comp_cpy(as));
        !           102: } 
        !           103: 
        !           104: Attr_Sequence as_cpy (as) 
        !           105: Attr_Sequence as; 
        !           106: {
        !           107:        return (as_cpy(as));
        !           108: } 
        !           109: 
        !           110: 
        !           111: as_delnext (as) 
        !           112: Attr_Sequence as; 
        !           113: {
        !           114:        (void) as_delnext(as);
        !           115: } 
        !           116: 
        !           117: 
        !           118: Attr_Sequence as_find_type (a,b) 
        !           119: Attr_Sequence a; 
        !           120: AttributeType b; 
        !           121: {
        !           122:        return (as_find_type(a,b));
        !           123: } 
        !           124: 
        !           125: 
        !           126: as_comp_free (as) 
        !           127: Attr_Sequence as; 
        !           128: {
        !           129:        (void) as_comp_free(as);
        !           130: } 
        !           131: 
        !           132: as_free (as) 
        !           133: Attr_Sequence as; 
        !           134: {
        !           135:        (void) as_free(as);
        !           136: } 
        !           137: 
        !           138: Attr_Sequence as_merge_aux (a,b) 
        !           139: Attr_Sequence a,b; 
        !           140: {
        !           141:        return (as_merge_aux (a,b));
        !           142: } 
        !           143: 
        !           144: Attr_Sequence as_merge (a,b) 
        !           145: Attr_Sequence a,b; 
        !           146: {
        !           147:        return (as_merge(a,b));
        !           148: } 
        !           149: 
        !           150: 
        !           151: Attr_Sequence as_comp_new (at,as,acl) 
        !           152: AttributeType at; 
        !           153: AV_Sequence as; 
        !           154: struct acl_info * acl; 
        !           155: {
        !           156:        return (as_comp_new(at,as,acl));
        !           157: } 
        !           158: 
        !           159: 
        !           160: as_comp_print (ps,as,format) 
        !           161: PS ps; 
        !           162: Attr_Sequence as; 
        !           163: int format; 
        !           164: {
        !           165:        (void) as_comp_print(ps,as,format);
        !           166: } 
        !           167: 
        !           168: as_print (ps,as,format) 
        !           169: Attr_Sequence as; 
        !           170: PS ps; 
        !           171: int format; 
        !           172: {
        !           173:        (void) as_print(ps,as,format);
        !           174: } 
        !           175: 
        !           176: 
        !           177: Attr_Sequence str2as (str) 
        !           178: register char * str; 
        !           179: {
        !           180:        return (str2as(str));
        !           181: } 
        !           182: 
        !           183: Attr_Sequence as_combine (as,str) 
        !           184: Attr_Sequence as; 
        !           185: register char * str; 
        !           186: {
        !           187:        return (as_combine(as,str));
        !           188: } 
        !           189: 
        !           190: oid_table_attr * AttrT_new_aux (name) 
        !           191: register char * name; 
        !           192: {
        !           193:        return (AttrT_new_aux(name));
        !           194: } 
        !           195: 
        !           196: AttributeType AttrT_new (name) 
        !           197: register char * name; 
        !           198: {
        !           199:        return (AttrT_new(name));
        !           200: } 
        !           201: 
        !           202: 
        !           203: AttrT_print (ps,x,format) 
        !           204: register PS ps; 
        !           205: register AttributeType x; 
        !           206: register int format; 
        !           207: {
        !           208:        (void) AttrT_print(ps,x,format);
        !           209: } 
        !           210: 
        !           211: short add_attribute_syntax (sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline) 
        !           212: char * sntx; 
        !           213: IFP enc,dec,parse,print,cpy,cmp,sfree,approx; 
        !           214: char * print_pe; 
        !           215: char multiline; 
        !           216: {
        !           217:        return (add_attribute_syntax(sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline));
        !           218: } 
        !           219: 
        !           220: set_attribute_syntax (sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline) 
        !           221: short sntx; 
        !           222: IFP enc,dec,parse,print,cpy,cmp,sfree,approx; 
        !           223: char * print_pe; 
        !           224: char multiline; 
        !           225: {
        !           226:        (void) set_attribute_syntax(sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline);
        !           227: } 
        !           228: 
        !           229: set_av_pe_print (sntx,print_pe) 
        !           230: short sntx; 
        !           231: char * print_pe; 
        !           232: {
        !           233:        (void) set_av_pe_print(sntx,print_pe);
        !           234: } 
        !           235: 
        !           236: split_attr (as) 
        !           237: Attr_Sequence as; 
        !           238: {
        !           239:        return (split_attr(as));
        !           240: } 
        !           241: 
        !           242: IFP approxfn (x) 
        !           243: int x; 
        !           244: {
        !           245:        return (approxfn(x));
        !           246: } 
        !           247: 
        !           248: char * syntax2str (sntx) 
        !           249: int sntx; 
        !           250: {
        !           251:        return (syntax2str(sntx));
        !           252: } 
        !           253: 
        !           254: short str2syntax (str) 
        !           255: char * str; 
        !           256: {
        !           257:        return (str2syntax(str));
        !           258: } 
        !           259: 
        !           260: sntx_table * get_syntax_table (x) 
        !           261: short x; 
        !           262: {
        !           263:        return (get_syntax_table(x));
        !           264: } 
        !           265: 
        !           266: AttrV_free (x) 
        !           267: register AttributeValue x; 
        !           268: {
        !           269:        (void) AttrV_free(x);
        !           270: } 
        !           271: 
        !           272: AttrV_free_aux (x) 
        !           273: register AttributeValue x; 
        !           274: {
        !           275:        (void) AttrV_free_aux(x);
        !           276: } 
        !           277: 
        !           278: PE grab_pe(av) 
        !           279: AttributeValue av; 
        !           280: {
        !           281:        return (grab_pe(av));
        !           282: } 
        !           283: 
        !           284: AttrV_decode(x,y) 
        !           285: register AttributeType x; 
        !           286: register AttributeValue y; 
        !           287: {
        !           288:        return (AttrV_decode(x,y));
        !           289: } 
        !           290: 
        !           291: 
        !           292: str_at2AttrV_aux (str,at,rav)
        !           293: char * str;
        !           294: AttributeType at;
        !           295: AttributeValue rav;
        !           296: {
        !           297:        return str_at2AttrV_aux (str,at,rav);
        !           298: }
        !           299: 
        !           300: AttributeValue str_at2AttrV (str,at)
        !           301: char * str;
        !           302: AttributeType at;
        !           303: {
        !           304:        return str_at2AttrV (str,at);
        !           305: }
        !           306: 
        !           307: AttributeValue str2AttrV (str,syntax)
        !           308: register char * str;
        !           309: short syntax;
        !           310: {
        !           311:        return (str2AttrV (str,syntax));
        !           312: }
        !           313: 
        !           314: str2AttrV_aux (str,syntax,x)
        !           315: register char * str;
        !           316: short syntax;
        !           317: AttributeValue x;
        !           318: {
        !           319:        return str2AttrV_aux(str,syntax,x);
        !           320: }
        !           321: 
        !           322: AttributeValue AttrV_cpy (x)
        !           323: register AttributeValue x;
        !           324: {
        !           325:        return ( AttrV_cpy (x));
        !           326: }
        !           327: 
        !           328: AttrV_cpy_aux (x,y)
        !           329: register AttributeValue x;
        !           330: register AttributeValue y;
        !           331: {
        !           332:        (void) AttrV_cpy_aux (x,y);
        !           333: }
        !           334: 
        !           335: AttrV_cmp (x,y)
        !           336: register AttributeValue x,y;
        !           337: {
        !           338:        return AttrV_cmp (x,y);
        !           339: }
        !           340: 
        !           341: IFP av_cmp_fn (syntax)
        !           342: int syntax;
        !           343: {
        !           344:        return av_cmp_fn (syntax);
        !           345: }
        !           346: 
        !           347: AttrV_print (ps,x,format)
        !           348: register PS ps;
        !           349: register AttributeValue x;
        !           350: register int format;
        !           351: {
        !           352:        (void) AttrV_print (ps,x,format);
        !           353: }
        !           354: 
        !           355: avs_cmp (a,b) 
        !           356: AV_Sequence a,b; 
        !           357: {
        !           358:        return (avs_cmp(a,b));
        !           359: } 
        !           360: 
        !           361: AV_Sequence avs_comp_cpy (avs) 
        !           362: AV_Sequence avs; 
        !           363: {
        !           364:        return (avs_comp_cpy(avs));
        !           365: } 
        !           366: 
        !           367: AV_Sequence avs_cpy (avs) 
        !           368: AV_Sequence avs; 
        !           369: {
        !           370:        return (avs_cpy(avs));
        !           371: } 
        !           372: 
        !           373: 
        !           374: avs_delnext (avs) 
        !           375: AV_Sequence avs; 
        !           376: {
        !           377:        (void) avs_delnext(avs);
        !           378: } 
        !           379: 
        !           380: 
        !           381: avs_comp_free (avs) 
        !           382: AV_Sequence avs; 
        !           383: {
        !           384:        (void) avs_comp_free(avs);
        !           385: } 
        !           386: 
        !           387: avs_free (avs) 
        !           388: AV_Sequence avs; 
        !           389: {
        !           390:        (void) avs_free(avs);
        !           391: } 
        !           392: 
        !           393: AV_Sequence avs_merge (a,b) 
        !           394: AV_Sequence a,b; 
        !           395: {
        !           396:        return (avs_merge(a,b));
        !           397: } 
        !           398: 
        !           399: 
        !           400: avs_comp_fill (ptr,pe) 
        !           401: AV_Sequence ptr; 
        !           402: AttributeValue pe; 
        !           403: {
        !           404:        (void) avs_comp_fill(ptr,pe);
        !           405: } 
        !           406: 
        !           407: AV_Sequence avs_comp_new (pe) 
        !           408: AttributeValue pe; 
        !           409: {
        !           410:        return (avs_comp_new(pe));
        !           411: } 
        !           412: 
        !           413: avs_comp_print (ps,avs,format) 
        !           414: AV_Sequence avs; 
        !           415: PS ps; 
        !           416: int format; 
        !           417: {
        !           418:        (void) avs_comp_print(ps,avs,format);
        !           419: } 
        !           420: 
        !           421: avs_print (ps,avs,format) 
        !           422: AV_Sequence avs; 
        !           423: PS ps; 
        !           424: int format; 
        !           425: {
        !           426:        (void) avs_print(ps,avs,format);
        !           427: } 
        !           428: 
        !           429: avs_print_aux (ps,avs,format,sep) 
        !           430: AV_Sequence avs; 
        !           431: PS ps; 
        !           432: int format; 
        !           433: char * sep;
        !           434: {
        !           435:        (void) avs_print_aux(ps,avs,format,sep);
        !           436: } 
        !           437: 
        !           438: 
        !           439: AV_Sequence str2avs (str,at) 
        !           440: char * str; 
        !           441: AttributeType at; 
        !           442: {
        !           443:        return (str2avs(str,at));
        !           444: } 
        !           445: 
        !           446: boolean_syntax () 
        !           447: {
        !           448:        (void) boolean_syntax();
        !           449: } 
        !           450: 
        !           451: 
        !           452: struct common_args * get_ca_ref(dsarg) 
        !           453: struct ds_op_arg * dsarg; 
        !           454: {
        !           455:        return get_ca_ref(dsarg);
        !           456: } 
        !           457: 
        !           458: cha_loopdetected(cha) 
        !           459: struct chain_arg * cha; 
        !           460: {
        !           461:        return cha_loopdetected(cha);
        !           462: } 
        !           463: 
        !           464: ti_is_elem(ti, ti_list) 
        !           465: struct trace_info * ti; 
        !           466: struct trace_info * ti_list; 
        !           467: {
        !           468:        return ti_is_elem(ti,ti_list);
        !           469: } 
        !           470: 
        !           471: struct trace_info * ti_cpy(ti) 
        !           472: struct trace_info * ti; 
        !           473: {
        !           474:        return ti_cpy(ti);
        !           475: } 
        !           476: 
        !           477: 
        !           478: correlate_search_results(sr_res) 
        !           479: struct ds_search_result * sr_res; 
        !           480: {
        !           481:        (void) correlate_search_results(sr_res);
        !           482: } 
        !           483: 
        !           484: merge_search_results(sr_res, sr_tmp) 
        !           485: struct ds_search_result * sr_res; 
        !           486: struct ds_search_result * sr_tmp; 
        !           487: {
        !           488:        (void) merge_search_results(sr_res,sr_tmp);
        !           489: } 
        !           490: 
        !           491: search_result_free(arg) 
        !           492: struct ds_search_result * arg; 
        !           493: {
        !           494:        (void) search_result_free(arg);
        !           495: } 
        !           496: 
        !           497: 
        !           498: dn_append (a,b) 
        !           499: DN a,b; 
        !           500: {
        !           501:        (void) dn_append(a,b);
        !           502: } 
        !           503: 
        !           504: 
        !           505: dn_cmp (a,b) 
        !           506: register DN a,b; 
        !           507: {
        !           508:        return (dn_cmp(a,b));
        !           509: } 
        !           510: 
        !           511: dn_cmp_prefix (a,b) 
        !           512: register DN a,b; 
        !           513: {
        !           514:        return (dn_cmp_prefix(a,b));
        !           515: } 
        !           516: 
        !           517: 
        !           518: DN dn_comp_cpy (dn) 
        !           519: register DN dn; 
        !           520: {
        !           521:        return (dn_comp_cpy(dn));
        !           522: } 
        !           523: 
        !           524: DN dn_cpy (dn) 
        !           525: register DN dn; 
        !           526: {
        !           527:        return (dn_cpy(dn));
        !           528: } 
        !           529: 
        !           530: 
        !           531: dn_comp_free (dn) 
        !           532: DN dn; 
        !           533: {
        !           534:        (void) dn_comp_free(dn);
        !           535: } 
        !           536: dn_free (dn) 
        !           537: DN dn; 
        !           538: {
        !           539:        (void) dn_free(dn);
        !           540: } 
        !           541: 
        !           542: 
        !           543: DN dn_comp_new (rdn) 
        !           544: RDN rdn; 
        !           545: {
        !           546:        return (dn_comp_new(rdn));
        !           547: } 
        !           548: 
        !           549: 
        !           550: dn_print (ps,dn,format) 
        !           551: DN dn; 
        !           552: PS ps; 
        !           553: int format; 
        !           554: {
        !           555:        (void) dn_print(ps,dn,format);
        !           556: } 
        !           557: 
        !           558: ufn_dn_print (ps,dn,multiline)
        !           559: PS  ps;
        !           560: DN  dn;
        !           561: char multiline;
        !           562: {
        !           563:        (void) ufn_dn_print (ps,dn,multiline);
        !           564: }
        !           565: 
        !           566: ufn_dn_print_aux (ps,dn,marker,multiline)
        !           567: PS  ps;
        !           568: DN  dn;
        !           569: DN marker;
        !           570: int    multiline;
        !           571: {
        !           572:        (void) ufn_dn_print_aux (ps,dn,marker,multiline);
        !           573: } 
        !           574: 
        !           575: ufn_rdn_print (ps,rdn)
        !           576: RDN  rdn;
        !           577: PS   ps;
        !           578: {      
        !           579:        (void) ufn_rdn_print (ps,rdn);
        !           580: }
        !           581: char * dn2str(dn)
        !           582: DN dn;
        !           583: {
        !           584:        return dn2str(dn);
        !           585: }
        !           586: char * dn2ufn(dn,multiline)
        !           587: DN dn;
        !           588: char multiline;
        !           589: {
        !           590:        return dn2ufn(dn,multiline);
        !           591: }
        !           592: 
        !           593: dn_seq_free (dnseq) 
        !           594: struct dn_seq * dnseq; 
        !           595: {
        !           596:        (void) dn_seq_free(dnseq);
        !           597: } 
        !           598: 
        !           599: struct dn_seq * dn_seq_cpy (dnseq) 
        !           600: struct dn_seq * dnseq; 
        !           601: {
        !           602:        return (dn_seq_cpy(dnseq));
        !           603: } 
        !           604: 
        !           605: check_dnseq (dnseq,who) 
        !           606: struct dn_seq * dnseq; 
        !           607: DN who; 
        !           608: {
        !           609:        return (check_dnseq(dnseq,who));
        !           610: } 
        !           611: 
        !           612: dn_seq_cmp (a,b) 
        !           613: struct dn_seq * a, * b; 
        !           614: {
        !           615:        return (dn_seq_cmp(a,b));
        !           616: } 
        !           617: 
        !           618: check_dnseq_prefix (dnseq,who) 
        !           619: struct dn_seq * dnseq; 
        !           620: DN who; 
        !           621: {
        !           622:        return (check_dnseq_prefix(dnseq,who));
        !           623: } 
        !           624: 
        !           625: dn_seq_print (ps,dnseq,format) 
        !           626: PS ps; 
        !           627: struct dn_seq * dnseq; 
        !           628: int format; 
        !           629: {
        !           630:        (void) dn_seq_print(ps,dnseq,format);
        !           631: } 
        !           632: 
        !           633: struct dn_seq * str2dnseq (str) 
        !           634: register char * str; 
        !           635: {
        !           636:        return (str2dnseq(str));
        !           637: } 
        !           638: 
        !           639: int       dn_in_dnseq(dn, dnseq)
        !           640: DN                dn;
        !           641: struct dn_seq   * dnseq;
        !           642: {
        !           643:        return (dn_in_dnseq(dn, dnseq));
        !           644: }
        !           645: 
        !           646: struct dn_seq   * dn_seq_push(dn,dnseq)
        !           647: DN                dn;
        !           648: struct dn_seq   * dnseq;
        !           649: {
        !           650:        return dn_seq_push(dn,dnseq);
        !           651: }
        !           652: 
        !           653: struct dn_seq   * dn_seq_pop(dnseq)
        !           654: struct dn_seq   * dnseq;
        !           655: {
        !           656:        return dn_seq_pop(dnseq);
        !           657: }
        !           658: 
        !           659: DN str2dn (str) 
        !           660: register char * str; 
        !           661: {
        !           662:        return (str2dn(str));
        !           663: } 
        !           664: 
        !           665: DN str2dn_aux (str,alias) 
        !           666: char * str; 
        !           667: char *alias; 
        !           668: {
        !           669:        return (str2dn_aux(str,alias));
        !           670: } 
        !           671: 
        !           672: DN str2dnX (str) 
        !           673: register char * str; 
        !           674: {
        !           675:        return (str2dnX(str));
        !           676: } 
        !           677: 
        !           678: DN dn_dec (pe)
        !           679: PE pe;
        !           680: {
        !           681:        return dn_dec (pe);
        !           682: }
        !           683: 
        !           684: PE dn_enc (dn)
        !           685: DN dn;
        !           686: {
        !           687:        return dn_enc (dn);
        !           688: }
        !           689: 
        !           690: dn_syntax ()
        !           691: {
        !           692:        (void) dn_syntax ();
        !           693: }
        !           694: 
        !           695: DN dq2dn (designator, qualifier) 
        !           696: char *designator, 
        !           697: *qualifier; 
        !           698: {
        !           699:        return (dq2dn(designator,qualifier));
        !           700: } 
        !           701: 
        !           702: edbinfo_syntax ()
        !           703: {
        !           704:        (void) edbinfo_syntax ();
        !           705: }
        !           706: 
        !           707: entryinfo_comp_free (a,state) 
        !           708: register EntryInfo *a; 
        !           709: int state; 
        !           710: {
        !           711:        (void) entryinfo_comp_free(a,state);
        !           712: } 
        !           713: 
        !           714: entryinfo_free (a,state) 
        !           715: register EntryInfo * a; 
        !           716: register int state; 
        !           717: {
        !           718:        (void) entryinfo_free(a,state);
        !           719: } 
        !           720: 
        !           721: entryinfo_cpy (a,b) 
        !           722: register EntryInfo *a; 
        !           723: register EntryInfo *b; 
        !           724: {
        !           725:        (void) entryinfo_cpy(a,b);
        !           726: } 
        !           727: 
        !           728: entryinfo_append (a,b) 
        !           729: register EntryInfo *a,*b; 
        !           730: {
        !           731:        (void) entryinfo_append(a,b);
        !           732: } 
        !           733: 
        !           734: entryinfo_merge (a,b) 
        !           735: EntryInfo *a,*b; 
        !           736: {
        !           737:        (void) entryinfo_merge(a,b);
        !           738: } 
        !           739: 
        !           740: entryinfo_print (ps,entryinfo,format) 
        !           741: PS ps; 
        !           742: EntryInfo *entryinfo; 
        !           743: int format; 
        !           744: {
        !           745:        (void) entryinfo_print(ps,entryinfo,format);
        !           746: } 
        !           747: 
        !           748: fax_syntax ()
        !           749: {
        !           750:        (void) fax_syntax ();
        !           751: }
        !           752: 
        !           753: struct file_syntax * fileattr_cpy (fs) 
        !           754: struct file_syntax * fs; 
        !           755: {
        !           756:        return (fileattr_cpy(fs));
        !           757: } 
        !           758: 
        !           759: file_cmp (a,b) 
        !           760: struct file_syntax *a, *b; 
        !           761: {
        !           762:        return (file_cmp(a,b));
        !           763: } 
        !           764: 
        !           765: PE grab_filepe (av) 
        !           766: AttributeValue av; 
        !           767: {
        !           768:        return (grab_filepe(av));
        !           769: }
        !           770: 
        !           771: 
        !           772: file_decode (x)
        !           773: AttributeValue x;
        !           774: {
        !           775:        (void) file_decode (x);
        !           776: }
        !           777: 
        !           778: #ifndef SYS5
        !           779: /* ARGSUSED */
        !           780: #endif
        !           781: int dflt_attr_file (at,x,full) 
        !           782: AttributeType at; 
        !           783: AttributeValue x; 
        !           784: char full;
        !           785: {
        !           786:        return (dflt_attr_file(at,x,full));
        !           787: } 
        !           788: 
        !           789: fileattr_print (ps,y,format) 
        !           790: PS ps; 
        !           791: AttributeValue y; 
        !           792: int format; 
        !           793: {
        !           794:        (void) fileattr_print(ps,y,format);
        !           795: } 
        !           796: 
        !           797: 
        !           798: str2file_aux (str,at,x) 
        !           799: char * str; 
        !           800: AttributeType at; 
        !           801: AttributeValue x; 
        !           802: {
        !           803:        return (str2file_aux(str,at,x));
        !           804: } 
        !           805: 
        !           806: AttributeValue str2file (str,at) 
        !           807: char * str; 
        !           808: AttributeType at; 
        !           809: {
        !           810:        return (str2file(str,at));
        !           811: } 
        !           812: 
        !           813: file_free (fs) 
        !           814: struct file_syntax * fs; 
        !           815: {
        !           816:        (void) file_free(fs);
        !           817: } 
        !           818: 
        !           819: filter_free (filt) 
        !           820: Filter filt; 
        !           821: {
        !           822:        (void) filter_free(filt);
        !           823: } 
        !           824: 
        !           825: filter_append (a,b) 
        !           826: Filter a,b; 
        !           827: {
        !           828:        (void) filter_append(a,b);
        !           829: } 
        !           830: 
        !           831: Filter strfilter (at,s,type)
        !           832: AttributeType at;
        !           833: char * s;
        !           834: char type;
        !           835: {
        !           836:        return strfilter (at,s,type);
        !           837: }
        !           838: 
        !           839: Filter ocfilter (s)
        !           840: char * s;
        !           841: {
        !           842:        return ocfilter (s);
        !           843: }
        !           844: 
        !           845: Filter joinfilter (f, type)
        !           846: Filter f;
        !           847: char type;
        !           848: {
        !           849:        return joinfilter (f, type);
        !           850: }
        !           851: 
        !           852: print_filter (nps, fi, level)
        !           853: PS nps;
        !           854: register Filter fi;
        !           855: int     level;
        !           856: {
        !           857:        (void) print_filter (nps, fi, level);
        !           858: }
        !           859: 
        !           860: guide_syntax ()
        !           861: {
        !           862:        (void) guide_syntax ();
        !           863: }
        !           864: 
        !           865: integer_syntax () 
        !           866: {
        !           867:        (void) integer_syntax();
        !           868: } 
        !           869: 
        !           870: mailbox_syntax () 
        !           871: {
        !           872:        (void) mailbox_syntax();
        !           873: } 
        !           874: 
        !           875: objectclass * oc_add (oid) 
        !           876: OID oid; 
        !           877: {
        !           878:        return (oc_add(oid));
        !           879: } 
        !           880: 
        !           881: objclass_cmp (a,b)
        !           882: objectclass *a, *b;
        !           883: {
        !           884:        return objclass_cmp (a,b);
        !           885: }
        !           886: 
        !           887: check_in_oc (oid,avs) 
        !           888: OID oid; 
        !           889: AV_Sequence avs; 
        !           890: {
        !           891:        return (check_in_oc(oid,avs));
        !           892: } 
        !           893: 
        !           894: oc_print (ps,oc,format)
        !           895: PS ps;
        !           896: objectclass * oc;
        !           897: int format;
        !           898: {
        !           899:        (void) oc_print (ps,oc,format);
        !           900: }
        !           901: 
        !           902: objectclass_syntax () 
        !           903: {
        !           904:        (void) objectclass_syntax();
        !           905: } 
        !           906: 
        !           907: load_oid_table (table) 
        !           908: char * table; 
        !           909: {
        !           910:        (void) load_oid_table(table);
        !           911: } 
        !           912: 
        !           913: add_entry_aux (a,b,c,d) 
        !           914: char * a; 
        !           915: caddr_t b; 
        !           916: int c; 
        !           917: char * d; 
        !           918: {
        !           919:        (void) add_entry_aux(a,b,c,d);
        !           920: } 
        !           921: 
        !           922: char * get_oid (str) 
        !           923: char * str; 
        !           924: {
        !           925:        return (get_oid(str));
        !           926: } 
        !           927: 
        !           928: oid_table_attr *name2attr(nodename) 
        !           929: char * nodename; 
        !           930: {
        !           931:        return (name2attr(nodename));
        !           932: } 
        !           933: 
        !           934: set_heap (x) 
        !           935: AttributeType x; 
        !           936: {
        !           937:        return (set_heap(x));
        !           938: } 
        !           939: 
        !           940: oid_table_attr *oid2attr(oid) 
        !           941: OID oid; 
        !           942: {
        !           943:        return (oid2attr(oid));
        !           944: } 
        !           945: 
        !           946: objectclass *name2oc(nodename) 
        !           947: register char * nodename; 
        !           948: {
        !           949:        return (name2oc(nodename));
        !           950: } 
        !           951: 
        !           952: objectclass *oid2oc(oid) 
        !           953: OID oid; 
        !           954: {
        !           955:        return (oid2oc(oid));
        !           956: } 
        !           957: 
        !           958: char *attr2name_aux (oa) 
        !           959: register oid_table_attr *oa; 
        !           960: {
        !           961:        return (attr2name_aux(oa));
        !           962: } 
        !           963: 
        !           964: char *attr2name(oa,format) 
        !           965: register oid_table_attr *oa; 
        !           966: int format; 
        !           967: {
        !           968:        return (attr2name(oa,format));
        !           969: } 
        !           970: 
        !           971: char *oc2name(oc,format) 
        !           972: register objectclass *oc; 
        !           973: int format; 
        !           974: {
        !           975:        return (oc2name(oc,format));
        !           976: } 
        !           977: 
        !           978: char *oid2name(oid,format) 
        !           979: OID oid; 
        !           980: int format; 
        !           981: {
        !           982:        return (oid2name(oid,format));
        !           983: } 
        !           984: 
        !           985: OID name2oid (str) 
        !           986: register char * str; 
        !           987: {
        !           988:        return (name2oid(str));
        !           989: } 
        !           990: 
        !           991: PE oid2pe (o) 
        !           992: OID o; 
        !           993: {
        !           994:        return (oid2pe(o));
        !           995: } 
        !           996: 
        !           997: oidprint (ps,o,format) 
        !           998: PS ps; 
        !           999: OID o; 
        !          1000: int format; 
        !          1001: {
        !          1002:        (void) oidprint(ps,o,format);
        !          1003: } 
        !          1004: 
        !          1005: OID dup_prim2oid (pe) 
        !          1006: PE pe; 
        !          1007: {
        !          1008:        return (dup_prim2oid(pe));
        !          1009: } 
        !          1010: 
        !          1011: oid_syntax () 
        !          1012: {
        !          1013:        (void) oid_syntax();
        !          1014: } 
        !          1015: 
        !          1016: want_oc_hierarchy () 
        !          1017: {
        !          1018:        (void) want_oc_hierarchy();
        !          1019: } 
        !          1020: 
        !          1021: load_obj_hier (sep,newname) 
        !          1022: char * sep; 
        !          1023: char * newname; 
        !          1024: {
        !          1025:        return load_obj_hier(sep,newname);
        !          1026: } 
        !          1027: 
        !          1028: void dumpalloid () 
        !          1029: {
        !          1030:        dumpalloid();
        !          1031: } 
        !          1032: 
        !          1033: objectclass * str2oc (str)
        !          1034: char * str;
        !          1035: {
        !          1036:        return (str2oc (str));
        !          1037: }
        !          1038: 
        !          1039: add_oc_macro (buf,ptr) 
        !          1040: char * buf, *ptr; 
        !          1041: {
        !          1042:        (void) add_oc_macro(buf,ptr);
        !          1043: } 
        !          1044: 
        !          1045: oid_seq_free (ptr) 
        !          1046: struct oid_seq * ptr; 
        !          1047: {
        !          1048:        (void) oid_seq_free(ptr);
        !          1049: } 
        !          1050: 
        !          1051: struct oid_seq *oid_seq_merge (a,b) 
        !          1052: struct oid_seq *a; 
        !          1053: struct oid_seq *b; 
        !          1054: {
        !          1055:        return (oid_seq_merge(a,b));
        !          1056: } 
        !          1057: 
        !          1058: oid_seq_cmp (a,b) 
        !          1059: struct oid_seq *a, *b; 
        !          1060: {
        !          1061:        return (oid_seq_cmp(a,b));
        !          1062: } 
        !          1063: 
        !          1064: struct oid_seq * oid_seq_cpy (a) 
        !          1065: struct oid_seq * a; 
        !          1066: {
        !          1067:        return (oid_seq_cpy(a));
        !          1068: } 
        !          1069: 
        !          1070: oid_seq_print (ps,ptr,format) 
        !          1071: PS ps; 
        !          1072: register struct oid_seq * ptr; 
        !          1073: int format; 
        !          1074: {
        !          1075:        (void) oid_seq_print(ps,ptr,format);
        !          1076: } 
        !          1077: 
        !          1078: struct oid_seq * str2oidseq (str) 
        !          1079: char * str; 
        !          1080: {
        !          1081:        return (str2oidseq(str));
        !          1082: } 
        !          1083: 
        !          1084: parse_error (a,b) 
        !          1085: char *a, *b; 
        !          1086: {
        !          1087:        (void) parse_error(a,b);
        !          1088: } 
        !          1089: 
        !          1090: pref_deliv_syntax ()
        !          1091: {
        !          1092:        (void) pref_deliv_syntax ();
        !          1093: }
        !          1094: 
        !          1095: pe_print (ps, pe, format) 
        !          1096: register PS ps; 
        !          1097: register PE pe; 
        !          1098: int format; 
        !          1099: {
        !          1100:        (void) pe_print (ps,pe,format);
        !          1101: } 
        !          1102: 
        !          1103: PE asn2pe (str) 
        !          1104: char * str; 
        !          1105: {
        !          1106:        return (asn2pe(str));
        !          1107: } 
        !          1108: 
        !          1109: char * show_picture (picture,picture_process,len) 
        !          1110: char *picture; 
        !          1111: char *picture_process; 
        !          1112: int len; 
        !          1113: {
        !          1114:        return (show_picture(picture,picture_process,len));
        !          1115: } 
        !          1116: 
        !          1117: exec_print (ps,av,proc) 
        !          1118: PS ps; 
        !          1119: AttributeValue av; 
        !          1120: char * proc; 
        !          1121: {
        !          1122:        (void) exec_print(ps,av,proc);
        !          1123: } 
        !          1124: 
        !          1125: hide_picture () 
        !          1126: {
        !          1127:        (void) hide_picture();
        !          1128: } 
        !          1129: 
        !          1130: picture_print (ps,pe,format) 
        !          1131: PS ps; 
        !          1132: PE pe; 
        !          1133: int format; 
        !          1134: {
        !          1135:        (void) picture_print(ps,pe,format);
        !          1136: } 
        !          1137: 
        !          1138: photo_syntax () 
        !          1139: {
        !          1140:        (void) photo_syntax();
        !          1141: } 
        !          1142: 
        !          1143: post_syntax () 
        !          1144: {
        !          1145:        (void) post_syntax();
        !          1146: } 
        !          1147: 
        !          1148: 
        !          1149: psap_free (psap) 
        !          1150: struct PSAPaddr * psap; 
        !          1151: {
        !          1152:        (void) psap_free(psap);
        !          1153: } 
        !          1154: 
        !          1155: struct PSAPaddr * psap_cpy (a) 
        !          1156: struct PSAPaddr * a; 
        !          1157: {
        !          1158:        return (psap_cpy(a));
        !          1159: } 
        !          1160: 
        !          1161: psap_dup (r,a) 
        !          1162: struct PSAPaddr * r, * a; 
        !          1163: {
        !          1164:        (void) psap_dup(r,a);
        !          1165: } 
        !          1166: 
        !          1167: psap_syntax () 
        !          1168: {
        !          1169:        (void) psap_syntax();
        !          1170: } 
        !          1171: 
        !          1172: quipu_syntaxes () 
        !          1173: {
        !          1174:        (void) quipu_syntaxes();
        !          1175: } 
        !          1176: 
        !          1177: rdn_cmp_comp (a,b) 
        !          1178: RDN a,b; 
        !          1179: {
        !          1180:        return (rdn_cmp_comp(a,b));
        !          1181: } 
        !          1182: 
        !          1183: rdn_cmp (a,b) 
        !          1184: register RDN a,b; 
        !          1185: {
        !          1186:        return (rdn_cmp(a,b));
        !          1187: } 
        !          1188: 
        !          1189: 
        !          1190: RDN rdn_comp_cpy (rdn) 
        !          1191: RDN rdn; 
        !          1192: {
        !          1193:        return (rdn_comp_cpy(rdn));
        !          1194: } 
        !          1195: 
        !          1196: RDN rdn_cpy (rdn) 
        !          1197: RDN rdn; 
        !          1198: {
        !          1199:        return (rdn_cpy(rdn));
        !          1200: } 
        !          1201: 
        !          1202: 
        !          1203: rdn_comp_free (rdn) 
        !          1204: RDN rdn; 
        !          1205: {
        !          1206:        (void) rdn_comp_free(rdn);
        !          1207: } 
        !          1208: 
        !          1209: rdn_free (rdn) 
        !          1210: RDN rdn; 
        !          1211: {
        !          1212:        (void) rdn_free(rdn);
        !          1213: } 
        !          1214: 
        !          1215: 
        !          1216: RDN rdn_merge (a,b) 
        !          1217: RDN a,b; 
        !          1218: {
        !          1219:        return (rdn_merge(a,b));
        !          1220: } 
        !          1221: 
        !          1222: 
        !          1223: RDN rdn_comp_new (at,av) 
        !          1224: AttributeType at; 
        !          1225: AttributeValue av; 
        !          1226: {
        !          1227:        return (rdn_comp_new(at,av));
        !          1228: } 
        !          1229: 
        !          1230: 
        !          1231: rdn_comp_print (ps,rdn,format) 
        !          1232: PS ps; 
        !          1233: RDN rdn; 
        !          1234: int format; 
        !          1235: {
        !          1236:        (void) rdn_comp_print(ps,rdn,format);
        !          1237: } 
        !          1238: 
        !          1239: rdn_print (ps,rdn,format) 
        !          1240: RDN rdn; 
        !          1241: PS ps; 
        !          1242: int format; 
        !          1243: {
        !          1244:        (void) rdn_print(ps,rdn,format);
        !          1245: } 
        !          1246: 
        !          1247: 
        !          1248: RDN str2rdn_aux (str) 
        !          1249: char * str; 
        !          1250: {
        !          1251:        return (str2rdn_aux(str));
        !          1252: } 
        !          1253: 
        !          1254: RDN str2rdn (str) 
        !          1255: char * str; 
        !          1256: {
        !          1257:        return (str2rdn(str));
        !          1258: } 
        !          1259: 
        !          1260: stop_listeners () 
        !          1261: {
        !          1262:        (void) stop_listeners();
        !          1263: } 
        !          1264: 
        !          1265: soundex_cmp (a,b)
        !          1266: register char * a;
        !          1267: register char * b;
        !          1268: {
        !          1269:        return (soundex_cmp (a,b));
        !          1270: }
        !          1271: 
        !          1272: soundex_match (fitem,avs) 
        !          1273: register struct filter_item *fitem; 
        !          1274: register AV_Sequence avs; 
        !          1275: {
        !          1276:        return (soundex_match(fitem,avs));
        !          1277: } 
        !          1278: 
        !          1279: standard_syntaxes () 
        !          1280: {
        !          1281:        (void) standard_syntaxes();
        !          1282: } 
        !          1283: 
        !          1284: char * octparse (str) 
        !          1285: char * str; 
        !          1286: {
        !          1287:        return (octparse(str));
        !          1288: } 
        !          1289: 
        !          1290: char * prtparse (str) 
        !          1291: char * str; 
        !          1292: {
        !          1293:        return (prtparse(str));
        !          1294: } 
        !          1295: 
        !          1296: sfree (x) 
        !          1297: char *x; 
        !          1298: {
        !          1299:        (void) sfree(x);
        !          1300: } 
        !          1301: 
        !          1302: pstrcmp (a,b)
        !          1303: char * a, *b;
        !          1304: {
        !          1305:        return pstrcmp (a,b);
        !          1306: }
        !          1307: 
        !          1308: telcmp (a, b) 
        !          1309: char *a, 
        !          1310: *b; 
        !          1311: {
        !          1312:        return (telcmp(a,b));
        !          1313: } 
        !          1314: 
        !          1315: strprint (ps,str,format) 
        !          1316: PS ps; 
        !          1317: char * str; 
        !          1318: int format; 
        !          1319: {
        !          1320:        (void) strprint(ps,str,format);
        !          1321: } 
        !          1322: 
        !          1323: octprint (ps,str,format) 
        !          1324: PS ps; 
        !          1325: char * str; 
        !          1326: int format; 
        !          1327: {
        !          1328:        (void) octprint(ps,str,format);
        !          1329: } 
        !          1330: 
        !          1331: case_exact_match (sntx) 
        !          1332: short sntx; 
        !          1333: {
        !          1334:        return (case_exact_match(sntx));
        !          1335: } 
        !          1336: 
        !          1337: approx_string (sntx) 
        !          1338: short sntx; 
        !          1339: {
        !          1340:        return (approx_string(sntx));
        !          1341: } 
        !          1342: 
        !          1343: sub_string (sntx) 
        !          1344: short sntx; 
        !          1345: {
        !          1346:        return (sub_string(sntx));
        !          1347: } 
        !          1348: 
        !          1349: string_syntaxes () 
        !          1350: {
        !          1351:        (void) string_syntaxes();
        !          1352: } 
        !          1353: 
        !          1354: 
        !          1355: teletex_syntax () 
        !          1356: {
        !          1357:        (void) teletex_syntax();
        !          1358: } 
        !          1359: 
        !          1360: telex_syntax () 
        !          1361: {
        !          1362:        (void) telex_syntax();
        !          1363: } 
        !          1364: 
        !          1365: utcprint (ps,time,format)
        !          1366: PS ps;
        !          1367: char *time;
        !          1368: int format;
        !          1369: {
        !          1370:        (void) utcprint (ps,time,format);
        !          1371: }
        !          1372: 
        !          1373: time_syntax () 
        !          1374: {
        !          1375:        (void) time_syntax();
        !          1376: } 
        !          1377: 
        !          1378: schema_syntax () 
        !          1379: {
        !          1380:        (void) schema_syntax();
        !          1381: } 
        !          1382: 
        !          1383: char * SkipSpace (ptr) 
        !          1384: register char * ptr; 
        !          1385: {
        !          1386:        return (SkipSpace(ptr));
        !          1387: } 
        !          1388: 
        !          1389: void StripSpace (b) 
        !          1390: register char *b; 
        !          1391: {
        !          1392:        StripSpace (b);
        !          1393: } 
        !          1394: 
        !          1395: void StripSpace2 (b) 
        !          1396: register char *b; 
        !          1397: {
        !          1398:        StripSpace2 (b);
        !          1399: } 
        !          1400: 
        !          1401: char * TidyString (a) 
        !          1402: register char * a; 
        !          1403: {
        !          1404:        return (TidyString(a));
        !          1405: } 
        !          1406: 
        !          1407: test_prim_pe (pe,class,id) 
        !          1408: PE pe; 
        !          1409: PElementClass class; 
        !          1410: PElementID id; 
        !          1411: {
        !          1412:        return (test_prim_pe(pe,class,id));
        !          1413: } 
        !          1414: 
        !          1415: /* VARARGS2 */
        !          1416: ps_printf (ps,fmt) 
        !          1417: PS ps; 
        !          1418: char * fmt; 
        !          1419: {
        !          1420:        (void) ps_printf(ps,fmt);
        !          1421: } 
        !          1422: 
        !          1423: fatal (code,fmt) 
        !          1424: int code; 
        !          1425: char *fmt; 
        !          1426: {
        !          1427:        (void) fatal(code,fmt);
        !          1428: } 
        !          1429: 
        !          1430: pslog (lp,event,str,func,ptr) 
        !          1431: LLog * lp; 
        !          1432: int event; 
        !          1433: char * str; 
        !          1434: int (*func) (); 
        !          1435: caddr_t ptr; 
        !          1436: {
        !          1437:        (void) pslog(lp,event,str,func,ptr);
        !          1438: } 
        !          1439: 
        !          1440: quipu_pe_cmp (a,b) 
        !          1441: register PE a,b; 
        !          1442: {
        !          1443:        return (quipu_pe_cmp(a,b));
        !          1444: } 
        !          1445: 
        !          1446: struct acl_info * acl_dflt () 
        !          1447: {
        !          1448:        return (acl_dflt());
        !          1449: } 
        !          1450: 
        !          1451: /* VARARGS2 */
        !          1452: dsap_init(acptr,avptr)
        !          1453: int *acptr;
        !          1454: char *** avptr;
        !          1455: {
        !          1456:         (void) dsap_init(acptr,avptr);
        !          1457: }
        !          1458: 
        !          1459: dsap_tai (argc, argv)
        !          1460: char    **argv;
        !          1461: {
        !          1462:         return (dsap_tai (argc, argv));
        !          1463: }
        !          1464: 
        !          1465: tai_args (acptr,avptr)
        !          1466: int *acptr;
        !          1467: char ***avptr;
        !          1468: {
        !          1469:         (void) tai_args (acptr,avptr);
        !          1470: }
        !          1471: 
        !          1472: dsap_tai_init()
        !          1473: {
        !          1474:         return (dsap_tai_init());
        !          1475: }
        !          1476: 
        !          1477: 
        !          1478: tai_string (str)
        !          1479: char * str;
        !          1480: {
        !          1481:         return (tai_string (str));
        !          1482: }
        !          1483: 
        !          1484: ds_error (ps,err)
        !          1485: PS ps;
        !          1486: struct DSError *err;
        !          1487: {
        !          1488:        (void) ds_error (ps,err);
        !          1489: }
        !          1490: 
        !          1491: log_ds_error (err)
        !          1492: struct DSError *err;
        !          1493: {
        !          1494:        (void) log_ds_error (err);
        !          1495: }
        !          1496: 
        !          1497: ds_error_free (err)
        !          1498: struct DSError * err;
        !          1499: {
        !          1500:        (void) ds_error_free (err);
        !          1501: }
        !          1502: 
        !          1503: struct subordinate * subord_cpy (x) 
        !          1504: struct subordinate * x; 
        !          1505: {
        !          1506:        return (subord_cpy(x));
        !          1507: } 
        !          1508: 
        !          1509: cache_list (ptr, prob,dn,sizelimit) 
        !          1510: struct subordinate *ptr; 
        !          1511: int prob; 
        !          1512: DN dn; 
        !          1513: int sizelimit; 
        !          1514: {
        !          1515:        (void) cache_list (ptr,prob,dn,sizelimit);
        !          1516: } 
        !          1517: 
        !          1518: delete_list_cache (adn)
        !          1519: DN adn;
        !          1520: {
        !          1521:        (void) delete_list_cache (adn);
        !          1522: }
        !          1523: 
        !          1524: struct list_cache *find_list_cache (dn,sizelimit) 
        !          1525: DN dn; 
        !          1526: int sizelimit; 
        !          1527: {
        !          1528:        return (find_list_cache(dn,sizelimit));
        !          1529: } 
        !          1530: 
        !          1531: cache_entry (ptr, complete, vals) 
        !          1532: EntryInfo *ptr; 
        !          1533: char complete; 
        !          1534: char vals; 
        !          1535: {
        !          1536:        (void) cache_entry (ptr, complete, vals);
        !          1537: } 
        !          1538: 
        !          1539: delete_cache (adn) 
        !          1540: DN adn; 
        !          1541: {
        !          1542:        (void) delete_cache(adn);
        !          1543: } 
        !          1544: 
        !          1545: Entry local_find_entry (object,deref) 
        !          1546: DN object; 
        !          1547: char deref; 
        !          1548: {
        !          1549:        return (local_find_entry(object,deref));
        !          1550: } 
        !          1551: 
        !          1552: DN get_copy_dn (entryptr) 
        !          1553: Entry entryptr; 
        !          1554: {
        !          1555:        return (get_copy_dn(entryptr));
        !          1556: } 
        !          1557: 
        !          1558: unravel_attribute (eptr,error,decode) 
        !          1559: Entry eptr; 
        !          1560: struct DSError * error; 
        !          1561: char decode; 
        !          1562: {
        !          1563:        return (unravel_attribute(eptr,error,decode));
        !          1564: } 
        !          1565: 
        !          1566: check_schema (eptr,as,error,decode) 
        !          1567: Entry eptr; 
        !          1568: Attr_Sequence as; 
        !          1569: struct DSError * error; 
        !          1570: char decode; 
        !          1571: {
        !          1572:        return (check_schema(eptr,as,error,decode));
        !          1573: } 
        !          1574: 
        !          1575: char * new_version ()
        !          1576: {
        !          1577:        return new_version();
        !          1578: }
        !          1579: 
        !          1580: directory_free (directory) 
        !          1581: Entry directory; 
        !          1582: {
        !          1583:        (void) directory_free(directory);
        !          1584: } 
        !          1585: 
        !          1586: entry_free (entryptr) 
        !          1587: Entry entryptr; 
        !          1588: {
        !          1589:        (void) entry_free(entryptr);
        !          1590: } 
        !          1591: 
        !          1592: Entry entry_cpy (entryptr) 
        !          1593: register Entry entryptr; 
        !          1594: {
        !          1595:        return (entry_cpy(entryptr));
        !          1596: } 
        !          1597: 
        !          1598: Entry get_default_entry (parent) 
        !          1599: Entry parent; 
        !          1600: {
        !          1601:        return (get_default_entry(parent));
        !          1602: } 
        !          1603: 
        !          1604: check_known_oids () 
        !          1605: {
        !          1606:        (void) check_known_oids();
        !          1607: } 
        !          1608: 
        !          1609: char * getline (file)
        !          1610: FILE * file;
        !          1611: {
        !          1612:        return getline (file);
        !          1613: }
        !          1614: 
        !          1615: Attr_Sequence get_attributes_aux (file) 
        !          1616: FILE * file; 
        !          1617: {
        !          1618:        return (get_attributes_aux(file));
        !          1619: } 
        !          1620: 
        !          1621: Attr_Sequence get_attributes (file) 
        !          1622: FILE * file; 
        !          1623: {
        !          1624:        return (get_attributes(file));
        !          1625: } 
        !          1626: 
        !          1627: Entry get_entry_aux (file,parent,dtype) 
        !          1628: FILE * file; 
        !          1629: Entry parent; 
        !          1630: int dtype; 
        !          1631: {
        !          1632:        return (get_entry_aux(file,parent,dtype));
        !          1633: } 
        !          1634: 
        !          1635: Entry get_entry (file,parent,dtype) 
        !          1636: FILE * file; 
        !          1637: Entry parent; 
        !          1638: int dtype; 
        !          1639: {
        !          1640:        return (get_entry(file,parent,dtype));
        !          1641: } 
        !          1642: 
        !          1643: Entry new_constructor (parent) 
        !          1644: Entry parent; 
        !          1645: {
        !          1646:        return (new_constructor(parent));
        !          1647: } 
        !          1648: 
        !          1649: Entry make_path (dn) 
        !          1650: DN dn; 
        !          1651: {
        !          1652:        return (make_path(dn));
        !          1653: } 
        !          1654: 
        !          1655: 
        !          1656: DNS DNS_append (a,b)
        !          1657: DNS a, b;
        !          1658: {
        !          1659:        return DNS_append (a,b);
        !          1660: }
        !          1661: 
        !          1662: dnSelect (s,dlist,interact,el)
        !          1663: char * s;
        !          1664: DNS *dlist;
        !          1665: DNS (* interact) ();
        !          1666: DNS el;
        !          1667: {
        !          1668:        return dnSelect (s,dlist,interact,el);
        !          1669: }
        !          1670: 
        !          1671: ufn_search (base, subtree, filt, res, s, interact, el)
        !          1672: DN base;
        !          1673: char subtree;
        !          1674: Filter filt;
        !          1675: DNS * res;
        !          1676: char * s;
        !          1677: DNS (* interact) ();
        !          1678: DNS el;
        !          1679: {
        !          1680:        return ufn_search (base, subtree, filt, res, s, interact, el);
        !          1681: }
        !          1682: 
        !          1683: envlist read_envlist()
        !          1684: {
        !          1685:        return read_envlist();
        !          1686: }
        !          1687: 
        !          1688: ufn_match (c,v,interact,result,el)
        !          1689: int c;
        !          1690: char ** v;
        !          1691: DNS (* interact) ();
        !          1692: DNS * result;
        !          1693: envlist el;
        !          1694: {
        !          1695:        return ufn_match (c,v,interact,result,el);
        !          1696: }
        !          1697: 
        !          1698: 
        !          1699: ufn_init ()
        !          1700: {
        !          1701:        return ufn_init ();
        !          1702: }
        !          1703: 
        !          1704: 
        !          1705: aet_match (c,v,interact,result,el,context)
        !          1706: int c;
        !          1707: char ** v;
        !          1708: DNS *result;
        !          1709: DNS (* interact) ();
        !          1710: envlist el;
        !          1711: char * context;
        !          1712: {
        !          1713:        return aet_match (c,v,interact,result,el,context);
        !          1714: }
        !          1715: 
        !          1716: set_lookup_ufn (flag)
        !          1717: char   flag;
        !          1718: {
        !          1719:     return set_lookup_ufn (flag);
        !          1720: }
        !          1721: 
        !          1722: set_lookup_dap (flag)
        !          1723: char flag;
        !          1724: {
        !          1725:        return set_lookup_dap (flag);
        !          1726: }

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