![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to utilities.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / px|
Return to utilities.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / px |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2:
3: static char sccsid[] = "@(#)utilities.c 4.2 10/20/80";
4:
5: #include "stdio.h"
6: #include "h00vars.h"
7: #include "h01errs.h"
8: #include "h02opcs.h"
9:
10: /*
11: * allocate a block of storage on the heap
12: */
13: char *palloc(need)
14:
15: long need;
16:
17: {
18: extern char *malloc();
19: register char *memblk, *ptr;
20:
21: memblk = malloc(need);
22: if (memblk == 0)
23: error(EOUTOFMEM);
24: if (memblk == (char *)(-1))
25: error(ETRASHHEAP);
26: for(ptr=memblk; ptr<memblk+need; ptr++)
27: *ptr = 0;
28: return(memblk);
29: }
30:
31:
32:
33: /*
34: * Free a block of storage on the stack
35: */
36: pfree(ptr)
37:
38: char *ptr;
39:
40: {
41: extern long free();
42:
43: if (ptr == 0)
44: error(ENILPTR);
45: else if (free(ptr) == -1)
46: error(ETRASHHEAP);
47: }
48:
49: long _mask[] = {
50: 0xffffffff , 0xfffffffe , 0xfffffffc , 0xfffffff8 ,
51: 0xfffffff0 , 0xffffffe0 , 0xffffffc0 , 0xffffff80 ,
52: 0xffffff00 , 0xfffffe00 , 0xfffffc00 , 0xfffff800 ,
53: 0xfffff000 , 0xffffe000 , 0xffffc000 , 0xffff8000 ,
54: 0xffff0000 , 0xfffe0000 , 0xfffc0000 , 0xfff80000 ,
55: 0xfff00000 , 0xffe00000 , 0xffc00000 , 0xff800000 ,
56: 0xff000000 , 0xfe000000 , 0xfc000000 , 0xf8000000 ,
57: 0xf0000000 , 0xe0000000 , 0xc0000000 , 0x80000000 ,
58: 0x00000000
59: };
60: /*
61: * Constant set constructor
62: */
63:
64: long *
65: cttot(result, lowerbnd, upperbnd, paircnt, singcnt, data)
66:
67: long *result; /* pointer to final set */
68: int lowerbnd; /* lower bound of set */
69: int upperbnd; /* upper - lower of set */
70: int paircnt; /* number of pairs to construct */
71: int singcnt; /* number of singles to construct */
72: int data; /* paircnt plus singcnt sets of data */
73: {
74: register int lower;
75: register int lowerdiv;
76: register int lowermod;
77: register int upper;
78: int upperdiv;
79: int uppermod;
80: register int *dataptr;
81: register long *lp;
82: long *limit;
83: long temp;
84: long cnt;
85:
86: limit = &result[(upperbnd + 1 + BITSPERLONG - 1) / BITSPERLONG];
87: for (lp = result; lp < limit; )
88: *lp++ = 0;
89: dataptr = &data;
90: for (cnt = 0; cnt < paircnt; cnt++) {
91: lower = *dataptr++ - lowerbnd;
92: if (lower < 0 || lower > upperbnd) {
93: error(ECTLWR);
94: return;
95: }
96: upper = *dataptr++ - lowerbnd;
97: if (upper < 0 || upper > upperbnd) {
98: error(ECTUPR);
99: return;
100: }
101: if (lower > upper) {
102: continue;
103: }
104: lowerdiv = lower / BITSPERLONG;
105: lowermod = lower % BITSPERLONG;
106: upperdiv = upper / BITSPERLONG;
107: uppermod = upper % BITSPERLONG;
108: temp = _mask [lowermod];
109: if ( lowerdiv == upperdiv ) {
110: temp &= ~_mask[ uppermod + 1 ];
111: }
112: result[ lowerdiv ] |= temp;
113: limit = &result[ upperdiv-1 ];
114: for ( lp = &result[ lowerdiv+1 ] ; lp <= limit ; lp++ ) {
115: *lp |= ~0;
116: }
117: if ( lowerdiv != upperdiv ) {
118: result[ upperdiv ] |= ~_mask[ uppermod + 1 ];
119: }
120: }
121: for (cnt = 0; cnt < singcnt; cnt++) {
122: lower = *dataptr++ - lowerbnd;
123: if (lower < 0 || lower > upperbnd) {
124: error(ECTSNG);
125: return;
126: }
127: lowerdiv = lower / BITSPERLONG;
128: lowermod = lower % BITSPERLONG;
129: result[ lowerdiv ] |= ( 1 << lowermod );
130: }
131: return(result);
132: }
133:
134: inct(element, paircnt, singcnt, data)
135:
136: register int element; /* element to find */
137: int paircnt; /* number of pairs to check */
138: int singcnt; /* number of singles to check */
139: int data; /* paircnt plus singcnt bounds */
140: {
141: register int *dataptr;
142: register int cnt;
143:
144: dataptr = &data;
145: for (cnt = 0; cnt < paircnt; cnt++) {
146: if (element < *dataptr++) {
147: dataptr++;
148: continue;
149: }
150: if (element <= *dataptr++) {
151: return TRUE;
152: }
153: }
154: for (cnt = 0; cnt < singcnt; cnt++) {
155: if (element == *dataptr++) {
156: return TRUE;
157: }
158: }
159: return FALSE;
160: }
161:
162: char pd_date[] = {
163: 8, 9, 10, 4, 5, 6, 10, 22, 23, 10, 0
164: };
165:
166: char *ctime();
167:
168: pdattim(op, alfap)
169: register char *alfap;
170: {
171: register char *ap, *cp, *dp;
172: long a;
173: int i;
174:
175: time(&a);
176: cp = ctime(&a);
177: ap = alfap;
178: if (op == O_DATE)
179: for (dp = pd_date; *dp; *ap++ = cp[*dp++]);
180: else
181: for (cp = cp + 10, i = 10; i; *ap++ = *cp++, i--);
182: }
183:
184: psexit(code)
185:
186: long code;
187: {
188:
189: pmflush();
190: if (mode == PIX) {
191: fputs("Execution terminated",stderr);
192: if (code)
193: fputs(" abnormally",stderr);
194: fputc('.',stderr);
195: fputc('\n',stderr);
196: }
197: stats();
198: exit(code);
199: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.