![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bit_ops.c 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 bit_ops.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap |
1.1 root 1: /* bit_opts.c - operations on bit strings */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/psap/RCS/bit_ops.c,v 7.0 89/11/23 22:12:32 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/psap/RCS/bit_ops.c,v 7.0 89/11/23 22:12:32 mrose Rel $
9: *
10: *
11: * $Log: bit_ops.c,v $
12: * Revision 7.0 89/11/23 22:12:32 mrose
13: * Release 6.0
14: *
15: */
16:
17: /*
18: * NOTICE
19: *
20: * Acquisition, use, and distribution of this module and related
21: * materials are subject to the restrictions of a license agreement.
22: * Consult the Preface in the User's Manual for the full terms of
23: * this agreement.
24: *
25: */
26:
27:
28: /* LINTLIBRARY */
29:
30: #include <stdio.h>
31: #include "psap.h"
32:
33:
34: /* the first octet indicates how many unused bits are in the last octet --
35:
36: prim2bit - presentation element to bit string
37: bit2prim - bit string to presentation element
38: bit_on - turn a bit ON
39: bit_off - turn a bit OFF
40: bit_test - test a bit
41: */
42:
43:
44: PElementData ffb (), ffb_aux ();
45: PE ffb_pe ();
46:
47: /* */
48:
49: int bit_on (pe, i)
50: register PE pe;
51: register int i;
52: {
53: int mask;
54: register PElementData bp;
55:
56: if ((bp = ffb (pe, i, &mask, 1)) == NULLPED)
57: return pe_seterr (pe, PE_ERR_NMEM, NOTOK);
58:
59: *bp |= mask;
60:
61: return OK;
62: }
63:
64: /* */
65:
66: int bit_off (pe, i)
67: register PE pe;
68: register int i;
69: {
70: int mask;
71: register PElementData bp;
72:
73: if ((bp = ffb (pe, i, &mask, 1)) == NULLPED)
74: return pe_seterr (pe, PE_ERR_NMEM, NOTOK);
75:
76: *bp &= ~mask;
77:
78: return OK;
79: }
80:
81: /* */
82:
83: int bit_test (pe, i)
84: register PE pe;
85: register int i;
86: {
87: int mask;
88: register PElementData bp;
89:
90: if ((bp = ffb (pe, i, &mask, 0)) == NULLPED)
91: return pe_seterr (pe, PE_ERR_BIT, NOTOK);
92:
93: return (*bp & mask ? 1 : 0);
94: }
95:
96: /* */
97:
98: static PElementData ffb (pe, n, mask, xtnd)
99: register PE pe;
100: register int n,
101: *mask,
102: xtnd;
103: {
104: register int len,
105: i;
106: int j;
107: register PElementData bp;
108: register PE *p,
109: q,
110: r;
111:
112: i = (j = n) / 8 + 1;
113: if ((bp = ffb_aux (pe, &j, mask)) != NULLPED || !xtnd)
114: return bp;
115:
116: if (pe -> pe_form == PE_FORM_CONS)
117: pe = ffb_pe (pe);
118:
119: switch (pe -> pe_form) {
120: case PE_FORM_PRIM:
121: if (pe -> pe_len < (PElementLen) (len = i + 1)) {
122: if ((bp = PEDalloc (len)) == NULLPED)
123: return NULLPED;
124: bzero ((char *) bp, len);
125: if (pe -> pe_prim) {
126: PEDcpy (pe -> pe_prim, bp, pe -> pe_len);
127: if (pe -> pe_inline)
128: pe -> pe_inline = 0;
129: else
130: PEDfree (pe -> pe_prim);
131: }
132: pe -> pe_prim = bp, pe -> pe_len = len;
133: }
134: pe -> pe_nbits = n + 1;
135: *mask = 1 << (7 - (n % 8));
136: return (pe -> pe_prim + i);
137:
138: case PE_FORM_CONS:
139: if ((r = pe_alloc (pe -> pe_class, PE_FORM_PRIM, pe -> pe_id))
140: == NULLPE)
141: return NULLPED;
142: if ((r -> pe_prim = PEDalloc (len = r -> pe_len = j / 8 + 2))
143: == NULLPED) {
144: pe_free (r);
145: return NULLPED;
146: }
147: bzero ((char *) r -> pe_prim, len);
148: r -> pe_nbits = j + 1;
149: *mask = 1 << (7 - (j % 8));
150: for (p = &pe -> pe_cons; q = *p; p = &q -> pe_next)
151: continue;
152: *p = r;
153: return (r -> pe_prim + len - 1);
154:
155: default:
156: return NULLPED;
157: }
158: }
159:
160: /* */
161:
162: static PElementData ffb_aux (pe, n, mask)
163: register PE pe;
164: register int *n,
165: *mask;
166: {
167: register int i,
168: nbits;
169: register PElementData bp;
170: register PE p;
171:
172: switch (pe -> pe_form) {
173: case PE_FORM_PRIM:
174: if ((nbits = pe -> pe_nbits) > (i = *n)) {
175: *mask = 1 << (7 - (i % 8));
176: return (pe -> pe_prim + i / 8 + 1);
177: }
178: *n -= nbits;
179: break;
180:
181: case PE_FORM_CONS:
182: for (p = pe -> pe_cons; p; p = p -> pe_next)
183: if ((bp = ffb_aux (p, n, mask)) != NULLPED)
184: return bp;
185: break;
186: }
187:
188: return NULLPED;
189: }
190:
191: /* */
192:
193: static PE ffb_pe (pe)
194: register PE pe;
195: {
196: register PE p,
197: q;
198:
199: for (p = pe -> pe_cons, q = NULLPE; p; q = p, p = p -> pe_next)
200: continue;
201:
202: if (q != NULLPE)
203: switch (q -> pe_form) {
204: case PE_FORM_PRIM:
205: return q;
206:
207: case PE_FORM_CONS:
208: return ffb_pe (q);
209: }
210:
211: return pe;
212: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.