![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to llib-lcommon CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common|
Return to llib-lcommon CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common |
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.