![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to llib-lpsap 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 / psap|
Return to llib-lpsap CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap |
1.1 root 1: /* llib-lpsap - lint library for -lpsap */
2:
3: /*
4: * $Header: /f/osi/psap/RCS/llib-lpsap,v 7.4 90/07/27 08:47:27 mrose Exp $
5: *
6: *
7: * $Log: llib-lpsap,v $
8: * Revision 7.4 90/07/27 08:47:27 mrose
9: * update
10: *
11: * Revision 7.3 90/07/09 14:43:39 mrose
12: * sync
13: *
14: * Revision 7.2 90/05/08 08:54:58 mrose
15: * touch-up
16: *
17: * Revision 7.1 90/03/23 11:05:50 mrose
18: * typo
19: *
20: * Revision 7.0 89/11/23 22:12:42 mrose
21: * Release 6.0
22: *
23: */
24:
25: /*
26: * NOTICE
27: *
28: * Acquisition, use, and distribution of this module and related
29: * materials are subject to the restrictions of a license agreement.
30: * Consult the Preface in the User's Manual for the full terms of
31: * this agreement.
32: *
33: */
34:
35:
36: /* LINTLIBRARY */
37:
38: #include <stdio.h>
39: #include "psap.h"
40: #include "ssap.h"
41: #include "logger.h"
42:
43: /* Primitives (Built-in Types) <-> Data */
44:
45: int prim2flag (pe)
46: PE pe;
47: {
48: return prim2flag (pe);
49: }
50:
51:
52: PE flag2prim (b, class, id)
53: int b;
54: PElementClass class;
55: PElementID id;
56: {
57: return flag2prim (b, class, id);
58: }
59:
60:
61: integer prim2num (pe)
62: PE pe;
63: {
64: return prim2num (pe);
65: }
66:
67:
68: PE num2prim (i, class, id)
69: integer i;
70: PElementClass class;
71: PElementID id;
72: {
73: return num2prim (i, class, id);
74: }
75:
76:
77: double prim2real (pe)
78: PE pe;
79: {
80: return prim2real (pe);
81: }
82:
83:
84: PE real2prim (d, class, id)
85: double d;
86: PElementClass class;
87: PElementID id;
88: {
89: return real2prim (d, class, id);
90: }
91:
92:
93: char *prim2str (pe, len)
94: PE pe;
95: int *len;
96: {
97: return prim2str (pe, len);
98: }
99:
100:
101: PE str2prim (s, len, class, id)
102: char *s;
103: int len;
104: PElementClass class;
105: PElementID id;
106: {
107: return str2prim (s, len, class, id);
108: }
109:
110:
111: struct qbuf *prim2qb (pe)
112: PE pe;
113: {
114: return prim2qb (pe);
115: }
116:
117:
118: PE qb2prim_aux (qb, class, id, in_line)
119: struct qbuf *qb;
120: PElementClass class;
121: PElementID id;
122: int in_line;
123: {
124: return qb2prim_aux (qb, class, id, in_line);
125: }
126:
127: /* BITSTRING manipulation */
128:
129: PE prim2bit (pe)
130: PE pe;
131: {
132: return prim2bit (pe);
133: }
134:
135:
136: PE bit2prim (pe)
137: PE pe;
138: {
139: return bit2prim (pe);
140: }
141:
142:
143: int bit_on (pe, i)
144: PE pe;
145: int i;
146: {
147: return bit_on (pe, i);
148: }
149:
150:
151: int bit_off (pe, i)
152: PE pe;
153: int i;
154: {
155: return bit_off (pe, i);
156: }
157:
158:
159: int bit_test (pe, i)
160: PE pe;
161: int i;
162: {
163: return bit_test (pe, i);
164: }
165:
166: /* Routines for pepy */
167:
168: char *int2strb (n, len)
169: int n,
170: len;
171: {
172: return int2strb (n, len);
173: }
174:
175:
176: int strb2int (cp, len)
177: char *cp;
178: int len;
179: {
180: return strb2int (cp, len);
181: }
182:
183:
184: PE strb2bitstr (cp, len, class, id)
185: char *cp;
186: int len;
187: PElementClass class;
188: PElementID id;
189: {
190: return strb2bitstr (cp, len, class, id);
191: }
192:
193:
194: char *bitstr2strb (pe, len)
195: PE pe;
196: int *len;
197: {
198: return bitstr2strb (pe, len);
199: }
200:
201:
202: /* Primitives (Defined Types) <-> Data */
203:
204: OID prim2oid (pe)
205: PE pe;
206: {
207: return prim2oid (pe);
208: }
209:
210:
211: PE obj2prim (o, class, id)
212: OID o;
213: PElementClass class;
214: PElementID id;
215: {
216: return obj2prim (o, class, id);
217: }
218:
219:
220: UTC prim2time (pe, generalized)
221: PE pe;
222: int generalized;
223: {
224: return prim2time (pe, generalized);
225: }
226:
227:
228: PE time2prim (u, generalized, class, id)
229: UTC u;
230: int generalized;
231: PElementClass class;
232: PElementID id;
233: {
234: return time2prim (u, generalized, class, id);
235: }
236:
237:
238: char *time2str (u, generalized)
239: UTC u;
240: int generalized;
241: {
242: return time2str (u, generalized);
243: }
244:
245:
246: UTC str2utct (cp, len)
247: char *cp;
248: int len;
249: {
250: return str2utct (cp, len);
251: }
252:
253:
254: UTC str2gent (cp, len)
255: char *cp;
256: int len;
257: {
258: return str2gent (cp, len);
259: }
260:
261: /* LIST manipulation */
262:
263: PE prim2set (pe)
264: PE pe;
265: {
266: return prim2set (pe);
267: }
268:
269:
270: int set_add (pe, r)
271: PE pe,
272: r;
273: {
274: return set_add (pe, r);
275: }
276:
277:
278: int set_del (pe, class, id)
279: PE pe;
280: PElementClass class;
281: PElementID id;
282: {
283: return set_del (pe, class, id);
284: }
285:
286:
287: PE set_find (pe, class, id)
288: PE pe;
289: PElementClass class;
290: PElementID id;
291: {
292: return set_find (pe, class, id);
293: }
294:
295:
296: int seq_add (pe, r, i)
297: PE pe,
298: r;
299: int i;
300: {
301: return seq_add (pe, r, i);
302: }
303:
304:
305: int seq_del (pe, i)
306: PE pe;
307: int i;
308: {
309: return seq_del (pe, i);
310: }
311:
312:
313: PE seq_find (pe, i)
314: PE pe;
315: int i;
316: {
317: return seq_find (pe, i);
318: }
319:
320: /* PElement manipulation */
321:
322: PE pe_alloc (class, form, id)
323: PElementClass class;
324: PElementForm form;
325: PElementID id;
326: {
327: return pe_alloc (class, form, id);
328: }
329:
330:
331: int pe_free (pe)
332: PE pe;
333: {
334: (void) pe_free (pe);
335: }
336:
337:
338: int pe_cmp (p, q)
339: PE p,
340: q;
341: {
342: return pe_cmp (p, q);
343: }
344:
345:
346: PE pe_cpy (pe)
347: PE pe;
348: {
349: return pe_cpy (pe);
350: }
351:
352:
353: int pe_pullup (pe)
354: PE pe;
355: {
356: return pe_pullup (pe);
357: }
358:
359:
360: PE pe_expunge (pe, r)
361: PE pe,
362: r;
363: {
364: return pe_expunge (pe, r);
365: }
366:
367:
368: int pe_extract (pe, r)
369: PE pe,
370: r;
371: {
372: return pe_extract (pe, r);
373: }
374:
375:
376: PE str2pe (s, len, advance, result)
377: char *s;
378: int len,
379: *advance,
380: *result;
381: {
382: return str2pe (s, len, advance, result);
383: }
384:
385:
386: PE qb2pe (qb, len, depth, result)
387: struct qbuf *qb;
388: int len,
389: depth,
390: *result;
391: {
392: return qb2pe (qb, len, depth, result);
393: }
394:
395:
396: /* PStream manipulation */
397:
398: PS ps_alloc (io)
399: IFP io;
400: {
401: return ps_alloc (io);
402: }
403:
404:
405: void ps_free (ps)
406: PS ps;
407: {
408: ps_free (ps);
409: }
410:
411: /* PStream I/O */
412:
413: int ps_io (ps, io, data, n, in_line)
414: PS ps;
415: IFP io;
416: PElementData data;
417: PElementLen n;
418: int in_line;
419: {
420: return ps_io (ps, io, data, n, in_line);
421: }
422:
423:
424: int ps_flush (ps)
425: PS ps;
426: {
427: return ps_flush (ps);
428: }
429:
430:
431: int ps_prime (ps)
432: PS ps;
433: {
434: return ps_prime (ps);
435: }
436:
437:
438: int std_open (ps)
439: PS ps;
440: {
441: return std_open (ps);
442: }
443:
444:
445: int str_open (ps)
446: PS ps;
447: {
448: return str_open (ps);
449: }
450:
451:
452: int str_setup (ps, cp, cc, in_line)
453: PS ps;
454: char *cp;
455: int cc,
456: in_line;
457: {
458: return str_setup (ps, cp, cc, in_line);
459: }
460:
461:
462: int dg_open (ps)
463: PS ps;
464: {
465: return df_open (ps);
466: }
467:
468:
469: int dg_setup (ps, fd, size, rfx, wfx)
470: PS ps;
471: int fd,
472: size;
473: IFP rfx,
474: wfx;
475: {
476: return dg_setup (ps, fd, size, rfx, wfx);
477: }
478:
479: int fdx_open (ps)
480: PS ps;
481: {
482: return fdx_open (ps);
483: }
484:
485:
486: int fdx_setup (ps, fd)
487: PS ps;
488: int fd;
489: {
490: return fdx_setup (ps, fd);
491: }
492:
493:
494: int qbuf_open (ps)
495: PS ps;
496: {
497: return qbuf_open (ps);
498: }
499:
500:
501: int uvec_open (ps)
502: PS ps;
503: {
504: return uvec_open (ps);
505: }
506:
507:
508: int uvec_setup (ps, len)
509: PS ps;
510: int len;
511: {
512: return uvec_setup (ps, len);
513: }
514:
515: /* PStream <-> PElement */
516:
517: PE ps2pe_aux (ps, top, all)
518: PS ps;
519: int top,
520: all;
521: {
522: return ps2pe_aux (ps, top, all);
523: }
524:
525:
526: int pe2ps_aux (ps, pe, eval)
527: PS ps;
528: PE pe;
529: int eval;
530: {
531: return pe2ps_aux (ps, pe, eval);
532: }
533:
534: /* PList <-> PElement */
535:
536: PE pl2pe (ps)
537: PS ps;
538: {
539: return pl2pe (ps);
540: }
541:
542:
543: int pe2pl (ps, pe)
544: PS ps;
545: PE pe;
546: {
547: return pe2pl (ps, pe);
548: }
549:
550:
551: int ps_get_abs (pe)
552: PE pe;
553: {
554: return ps_get_abs (pe);
555: }
556:
557: /* Diagnostics */
558:
559: char *pe_error (c)
560: int c;
561: {
562: return pe_error (c);
563: }
564:
565: char *ps_error (c)
566: int c;
567: {
568: return ps_error (c);
569: }
570:
571: /* Object IDentifiers */
572:
573: OID ode2oid (descriptor)
574: char *descriptor;
575: {
576: return ode2oid (descriptor);
577: }
578:
579:
580: int oid_cmp (p, q)
581: OID p,
582: q;
583: {
584: return oid_cmp (p, q);
585: }
586:
587:
588: int elem_cmp (ip, i, jp, j)
589: int i,
590: j;
591: unsigned int *ip,
592: *jp;
593: {
594: return elem_cmp (ip, i, jp, j);
595: }
596:
597:
598: OID oid_cpy (oid)
599: OID oid;
600: {
601: return oid_cpy (oid);
602: }
603:
604: int oid_free (oid)
605: OID oid;
606: {
607: (void) oid_free (oid);
608: }
609:
610: char *oid2ode_aux (oid, quoted)
611: OID oid;
612: int quoted;
613: {
614: return oid2ode_aux (oid, quoted);
615: }
616:
617: char *sprintoid (oid)
618: OID oid;
619: {
620: return sprintoid (oid);
621: }
622:
623: OID str2oid (s)
624: char *s;
625: {
626: return str2oid (s);
627: }
628:
629: /* */
630:
631: PE qbuf2pe (qb, len, result)
632: struct qbuf *qb;
633: int len;
634: int *result;
635: {
636: return qbuf2pe (qb, len, result);
637: }
638:
639: char *qb2str (q)
640: struct qbuf *q;
641: {
642: return qb2str (q);
643: }
644:
645: struct qbuf *str2qb (s, len, head)
646: char *s;
647: int len,
648: head;
649: {
650: return str2qb (s, len, head);
651: }
652:
653: int qb_pullup (qb)
654: struct qbuf *qb;
655: {
656: return qb_pullup (qb);
657: }
658:
659: int qb_free (qb)
660: struct qbuf *qb;
661: {
662: (void) qb_free (qb);
663: }
664:
665: int pe2ssdu (pe, base, len)
666: PE pe;
667: char **base;
668: int *len;
669: {
670: return pe2ssdu (pe, base, len);
671: }
672:
673: PE ssdu2pe (base, len, realbase, result)
674: char *base,
675: *realbase;
676: int len;
677: int *result;
678: {
679: return ssdu2pe (base, len, realbase, result);
680: }
681:
682: void pe2text (lp, pe, rw, cc)
683: LLog *lp;
684: PE pe;
685: int rw,
686: cc;
687: {
688: pe2text (lp, pe, rw, cc);
689: }
690:
691: int pe2uvec (pe, uv)
692: PE pe;
693: struct udvec **uv;
694: {
695: return pe2uvec (pe, uv);
696: }
697:
698: /* */
699:
700: long gtime (tm)
701: struct tm *tm;
702: {
703: return gtime (tm);
704: }
705:
706: struct tm *ut2tm (ut)
707: UTC ut;
708: {
709: return ut2tm (ut);
710: }
711:
712: void tm2ut (tm, ut)
713: struct tm *tm;
714: UTC ut;
715: {
716: tm2ut (tm, ut);
717: }
718:
719: struct SSAPref *addr2ref (addr)
720: char *addr;
721: {
722: return addr2ref (addr);
723: }
724:
725: char *sprintref (sr)
726: struct SSAPref *sr;
727: {
728: return sprintref (sr);
729: }
730:
731:
732: /* these really belong in llib-lpepsy (which doesn't exist!) */
733:
734: /* VARARGS */
735:
736: void PY_advise (what, fmt)
737: char *what,
738: *fmt;
739: {
740: PY_advise (what, fmt);
741: }
742:
743:
744: char *bit2str (pe, s)
745: PE pe;
746: char *s;
747: {
748: return bit2str (pe, s);
749: }
750:
751:
752: /* VARARGS1 */
753:
754: vprint (fmt)
755: char *fmt;
756: {
757: vprint (fmt);
758: }
759:
760:
761: #undef vunknown
762: vunknown (pe)
763: PE pe;
764: {
765: vunknown (pe);
766: }
767:
768:
769: vsetfp (fp, s)
770: FILE *fp;
771: char *s;
772: {
773: vsetfp (fp, s);
774: }
775:
776:
777: vpushfp (fp, pe, s, rw)
778: FILE *fp;
779: PE pe;
780: char *s;
781: int rw;
782: {
783: vpushfp (fp, pe, s, rw);
784: }
785:
786:
787: vpopfp ()
788: {}
789:
790:
791: vpushstr (cp)
792: char *cp;
793: {
794: vpushstr (cp);
795: }
796:
797:
798: vpopstr ()
799: {}
800:
801:
802: vpushpp (pv, pfnx, pe, text, rw)
803: caddr_t pv;
804: IFP pfnx;
805: register PE pe;
806: char *text;
807: int rw;
808: {
809: vpushpp (pv, pfnx, pe, text, rw);
810: }
811:
812:
813: vpopp ()
814: {}
815:
816:
817: vpushquipu (ps)
818: PS ps;
819: {
820: vpushquipu (ps);
821: }
822:
823: vpopquipu ()
824: {}
825:
826:
827: _vpdu (lp, fnx, pe, text, rw)
828: LLog *lp;
829: IFP fnx;
830: PE pe;
831: char *text;
832: int rw;
833: {
834: _vpdu (lp, fnx, pe, text, rw);
835: }
836:
837:
838: #include "pepsy.h"
839:
840: int enc_f (typ, mod, pe, explicit, len, buf, parm)
841: int typ;
842: modtyp *mod;
843: PE *pe;
844: int explicit;
845: int len;
846: char *buf;
847: char *parm;
848: {
849: return enc_f (typ, mod, pe, explicit, len, buf, parm);
850: }
851:
852:
853: int dec_f (typ, mod, pe, explicit, len, buf, parm)
854: int typ;
855: modtyp *mod;
856: PE pe;
857: int explicit;
858: int *len;
859: char **buf;
860: char **parm;
861: {
862: return dec_f (typ, mod, pe, explicit, len, buf, parm);
863: }
864:
865:
866: int fre_obj (parm, p, mod)
867: modtyp *mod;
868: tpe *p;
869: char *parm;
870: {
871: return fre_obj (parm, p, mod);
872: }
873:
874:
875: pvpdu (lp, ind, mod, pe, text, rw)
876: LLog *lp;
877: int ind;
878: modtyp *mod;
879: PE pe;
880: char *text;
881: int rw;
882: {
883: pvpdu (lp, ind, mod, pe, text, rw);
884: }
885:
886:
887: /* these really belong in llib-lpepy (which doesn't exist!) */
888:
889: int PY_pp (argc, argv, envp, pfx)
890: int argc;
891: char **argv,
892: **envp;
893: IFP pfx;
894: {
895: return PY_pp (argc, argv, envp, pfx);
896: }
897:
898:
899: int testdebug (pe, s)
900: PE pe;
901: char *s;
902: {
903: return testdebug (pe, s);
904: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.