![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vlrt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / libc / 68020|
Return to vlrt.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / libc / 68020 |
1.1 root 1: typedef unsigned long ulong;
2: typedef unsigned char uchar;
3: typedef unsigned short ushort;
4: typedef signed char schar;
5:
6: #define SIGN(n) (1UL<<(n-1))
7:
8: typedef struct Vlong Vlong;
9: struct Vlong
10: {
11: union
12: {
13: struct
14: {
15: ulong hi;
16: ulong lo;
17: };
18: struct
19: {
20: ushort hims;
21: ushort hils;
22: ushort loms;
23: ushort lols;
24: };
25: };
26: };
27:
28: void abort(void);
29:
30: void
31: _addv(Vlong *r, Vlong a, Vlong b)
32: {
33: ulong lo, hi;
34:
35: lo = a.lo + b.lo;
36: hi = a.hi + b.hi;
37: if(lo < a.lo)
38: hi++;
39: r->lo = lo;
40: r->hi = hi;
41: }
42:
43: void
44: _subv(Vlong *r, Vlong a, Vlong b)
45: {
46: ulong lo, hi;
47:
48: lo = a.lo - b.lo;
49: hi = a.hi - b.hi;
50: if(lo > a.lo)
51: hi--;
52: r->lo = lo;
53: r->hi = hi;
54: }
55:
56: void
57: _d2v(Vlong *y, double d)
58: {
59: union { double d; struct Vlong; } x;
60: ulong xhi, xlo, ylo, yhi;
61: int sh;
62:
63: x.d = d;
64:
65: xhi = (x.hi & 0xfffff) | 0x100000;
66: xlo = x.lo;
67: sh = 1075 - ((x.hi >> 20) & 0x7ff);
68:
69: ylo = 0;
70: yhi = 0;
71: if(sh >= 0) {
72: /* v = (hi||lo) >> sh */
73: if(sh < 32) {
74: if(sh == 0) {
75: ylo = xlo;
76: yhi = xhi;
77: } else {
78: ylo = (xlo >> sh) | (xhi << (32-sh));
79: yhi = xhi >> sh;
80: }
81: } else {
82: if(sh == 32) {
83: ylo = xhi;
84: } else
85: if(sh < 64) {
86: ylo = xhi >> (sh-32);
87: }
88: }
89: } else {
90: /* v = (hi||lo) << -sh */
91: sh = -sh;
92: if(sh <= 10) {
93: ylo = xlo << sh;
94: yhi = (xhi << sh) | (xlo >> (32-sh));
95: } else {
96: /* overflow */
97: yhi = d; /* causes something awful */
98: }
99: }
100: if(x.hi & 0x80000000) {
101: if(ylo != 0) {
102: ylo = -ylo;
103: yhi = ~yhi;
104: } else
105: yhi = -yhi;
106: }
107:
108: y->hi = yhi;
109: y->lo = ylo;
110: }
111:
112: void
113: _f2v(Vlong *y, float f)
114: {
115:
116: _d2v(y, f);
117: }
118:
119: double
120: _v2d(Vlong x)
121: {
122: if(x.hi & 0x80000000) {
123: if(x.lo) {
124: x.lo = -x.lo;
125: x.hi = ~x.hi;
126: } else
127: x.hi = -x.hi;
128: return -((long)x.hi*4294967296. + x.lo);
129: }
130: return (long)x.hi*4294967296. + x.lo;
131: }
132:
133: float
134: _v2f(Vlong x)
135: {
136: return _v2d(x);
137: }
138:
139: static void
140: dodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
141: {
142: ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
143: int i;
144:
145: numhi = num.hi;
146: numlo = num.lo;
147: denhi = den.hi;
148: denlo = den.lo;
149:
150: /*
151: * get a divide by zero
152: */
153: if(denlo==0 && denhi==0) {
154: numlo = numlo / denlo;
155: }
156:
157: /*
158: * set up the divisor and find the number of iterations needed
159: */
160: if(numhi >= SIGN(32)) {
161: quohi = SIGN(32);
162: quolo = 0;
163: } else {
164: quohi = numhi;
165: quolo = numlo;
166: }
167: i = 0;
168: while(denhi < quohi || (denhi == quohi && denlo < quolo)) {
169: denhi = (denhi<<1) | (denlo>>31);
170: denlo <<= 1;
171: i++;
172: }
173:
174: quohi = 0;
175: quolo = 0;
176: for(; i >= 0; i--) {
177: quohi = (quohi<<1) | (quolo>>31);
178: quolo <<= 1;
179: if(numhi > denhi || (numhi == denhi && numlo >= denlo)) {
180: t = numlo;
181: numlo -= denlo;
182: if(numlo > t)
183: numhi--;
184: numhi -= denhi;
185: quolo |= 1;
186: }
187: denlo = (denlo>>1) | (denhi<<31);
188: denhi >>= 1;
189: }
190:
191: if(q) {
192: q->lo = quolo;
193: q->hi = quohi;
194: }
195: if(r) {
196: r->lo = numlo;
197: r->hi = numhi;
198: }
199: }
200:
201: void
202: _divvu(Vlong *q, Vlong n, Vlong d)
203: {
204:
205: if(n.hi == 0 && d.hi == 0) {
206: q->hi = 0;
207: q->lo = n.lo / d.lo;
208: return;
209: }
210: dodiv(n, d, q, 0);
211: }
212:
213: void
214: _modvu(Vlong *r, Vlong n, Vlong d)
215: {
216:
217: if(n.hi == 0 && d.hi == 0) {
218: r->hi = 0;
219: r->lo = n.lo % d.lo;
220: return;
221: }
222: dodiv(n, d, 0, r);
223: }
224:
225: static void
226: vneg(Vlong *v)
227: {
228:
229: if(v->lo == 0) {
230: v->hi = -v->hi;
231: return;
232: }
233: v->lo = -v->lo;
234: v->hi = ~v->hi;
235: }
236:
237: void
238: _divv(Vlong *q, Vlong n, Vlong d)
239: {
240: long nneg, dneg;
241:
242: if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
243: q->lo = (long)n.lo / (long)d.lo;
244: q->hi = ((long)q->lo) >> 31;
245: return;
246: }
247: nneg = n.hi >> 31;
248: if(nneg)
249: vneg(&n);
250: dneg = d.hi >> 31;
251: if(dneg)
252: vneg(&d);
253: dodiv(n, d, q, 0);
254: if(nneg != dneg)
255: vneg(q);
256: }
257:
258: void
259: _modv(Vlong *r, Vlong n, Vlong d)
260: {
261: long nneg, dneg;
262:
263: if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
264: r->lo = (long)n.lo % (long)d.lo;
265: r->hi = ((long)r->lo) >> 31;
266: return;
267: }
268: nneg = n.hi >> 31;
269: if(nneg)
270: vneg(&n);
271: dneg = d.hi >> 31;
272: if(dneg)
273: vneg(&d);
274: dodiv(n, d, 0, r);
275: if(nneg)
276: vneg(r);
277: }
278:
279: void
280: _rshav(Vlong *r, Vlong a, int b)
281: {
282: long t;
283:
284: t = a.hi;
285: if(b >= 32) {
286: r->hi = t>>31;
287: if(b >= 64) {
288: /* this is illegal re C standard */
289: r->lo = t>>31;
290: return;
291: }
292: r->lo = t >> (b-32);
293: return;
294: }
295: if(b <= 0) {
296: r->hi = t;
297: r->lo = a.lo;
298: return;
299: }
300: r->hi = t >> b;
301: r->lo = (t << (32-b)) | (a.lo >> b);
302: }
303:
304: void
305: _rshlv(Vlong *r, Vlong a, int b)
306: {
307: ulong t;
308:
309: t = a.hi;
310: if(b >= 32) {
311: r->hi = 0;
312: if(b >= 64) {
313: /* this is illegal re C standard */
314: r->lo = 0;
315: return;
316: }
317: r->lo = t >> (b-32);
318: return;
319: }
320: if(b <= 0) {
321: r->hi = t;
322: r->lo = a.lo;
323: return;
324: }
325: r->hi = t >> b;
326: r->lo = (t << (32-b)) | (a.lo >> b);
327: }
328:
329: void
330: _lshv(Vlong *r, Vlong a, int b)
331: {
332: ulong t;
333:
334: t = a.lo;
335: if(b >= 32) {
336: r->lo = 0;
337: if(b >= 64) {
338: /* this is illegal re C standard */
339: r->hi = 0;
340: return;
341: }
342: r->hi = t << (b-32);
343: return;
344: }
345: if(b <= 0) {
346: r->lo = t;
347: r->hi = a.hi;
348: return;
349: }
350: r->lo = t << b;
351: r->hi = (t >> (32-b)) | (a.hi << b);
352: }
353:
354: void
355: _andv(Vlong *r, Vlong a, Vlong b)
356: {
357: r->hi = a.hi & b.hi;
358: r->lo = a.lo & b.lo;
359: }
360:
361: void
362: _orv(Vlong *r, Vlong a, Vlong b)
363: {
364: r->hi = a.hi | b.hi;
365: r->lo = a.lo | b.lo;
366: }
367:
368: void
369: _xorv(Vlong *r, Vlong a, Vlong b)
370: {
371: r->hi = a.hi ^ b.hi;
372: r->lo = a.lo ^ b.lo;
373: }
374:
375: void
376: _negv(Vlong *r, Vlong a)
377: {
378: if(a.lo == 0) {
379: r->hi = -a.hi;
380: r->lo = 0;
381: return;
382: }
383: r->hi = ~a.hi;
384: r->lo = -a.lo;
385: }
386:
387: void
388: _vpp(Vlong *l, Vlong *r)
389: {
390:
391: l->hi = r->hi;
392: l->lo = r->lo;
393: r->lo++;
394: if(r->lo == 0)
395: r->hi++;
396: }
397:
398: void
399: _vmm(Vlong *l, Vlong *r)
400: {
401:
402: l->hi = r->hi;
403: l->lo = r->lo;
404: if(r->lo == 0)
405: r->hi--;
406: r->lo--;
407: }
408:
409: void
410: _ppv(Vlong *l, Vlong *r)
411: {
412:
413: r->lo++;
414: if(r->lo == 0)
415: r->hi++;
416: l->hi = r->hi;
417: l->lo = r->lo;
418: }
419:
420: void
421: _mmv(Vlong *l, Vlong *r)
422: {
423:
424: if(r->lo == 0)
425: r->hi--;
426: r->lo--;
427: l->hi = r->hi;
428: l->lo = r->lo;
429: }
430:
431: void
432: _vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
433: {
434: Vlong t;
435:
436: switch(type) {
437: default:
438: abort();
439: break;
440:
441: case 1: /* schar */
442: t.lo = *(schar*)lv;
443: t.hi = t.lo >> 31;
444: fn(ret, t, rv);
445: *(schar*)lv = ret->lo;
446: break;
447:
448: case 2: /* uchar */
449: t.lo = *(uchar*)lv;
450: t.hi = 0;
451: fn(ret, t, rv);
452: *(uchar*)lv = ret->lo;
453: break;
454:
455: case 3: /* short */
456: t.lo = *(short*)lv;
457: t.hi = t.lo >> 31;
458: fn(ret, t, rv);
459: *(short*)lv = ret->lo;
460: break;
461:
462: case 4: /* ushort */
463: t.lo = *(ushort*)lv;
464: t.hi = 0;
465: fn(ret, t, rv);
466: *(ushort*)lv = ret->lo;
467: break;
468:
469: case 5: /* long */
470: t.lo = *(long*)lv;
471: t.hi = t.lo >> 31;
472: fn(ret, t, rv);
473: *(long*)lv = ret->lo;
474: break;
475:
476: case 6: /* ulong */
477: t.lo = *(ulong*)lv;
478: t.hi = 0;
479: fn(ret, t, rv);
480: *(ulong*)lv = ret->lo;
481: break;
482:
483: case 7: /* vlong */
484: case 8: /* uvlong */
485: fn(ret, *(Vlong*)lv, rv);
486: *(Vlong*)lv = *ret;
487: break;
488: }
489: }
490:
491: void
492: _sl2v(Vlong *ret, long sl)
493: {
494: long t;
495:
496: t = sl;
497: ret->lo = t;
498: ret->hi = t >> 31;
499: }
500:
501: void
502: _ul2v(Vlong *ret, ulong ul)
503: {
504: long t;
505:
506: t = ul;
507: ret->lo = t;
508: ret->hi = 0;
509: }
510:
511: void
512: _sh2v(Vlong *ret, long sh)
513: {
514: long t;
515:
516: t = (sh << 16) >> 16;
517: ret->lo = t;
518: ret->hi = t >> 31;
519: }
520:
521: void
522: _uh2v(Vlong *ret, ulong ul)
523: {
524: long t;
525:
526: t = ul & 0xffff;
527: ret->lo = t;
528: ret->hi = 0;
529: }
530:
531: void
532: _sc2v(Vlong *ret, long uc)
533: {
534: long t;
535:
536: t = (uc << 24) >> 24;
537: ret->lo = t;
538: ret->hi = t >> 31;
539: }
540:
541: void
542: _uc2v(Vlong *ret, ulong ul)
543: {
544: long t;
545:
546: t = ul & 0xff;
547: ret->lo = t;
548: ret->hi = 0;
549: }
550:
551: long
552: _v2sc(Vlong rv)
553: {
554: long t;
555:
556: t = rv.lo & 0xff;
557: return (t << 24) >> 24;
558: }
559:
560: long
561: _v2uc(Vlong rv)
562: {
563:
564: return rv.lo & 0xff;
565: }
566:
567: long
568: _v2sh(Vlong rv)
569: {
570: long t;
571:
572: t = rv.lo & 0xffff;
573: return (t << 16) >> 16;
574: }
575:
576: long
577: _v2uh(Vlong rv)
578: {
579:
580: return rv.lo & 0xffff;
581: }
582:
583: long
584: _v2sl(Vlong rv)
585: {
586:
587: return rv.lo;
588: }
589:
590: long
591: _v2ul(Vlong rv)
592: {
593:
594: return rv.lo;
595: }
596:
597: int
598: _testv(Vlong rv)
599: {
600: return rv.lo || rv.hi;
601: }
602:
603: int
604: _eqv(Vlong lv, Vlong rv)
605: {
606: return lv.lo == rv.lo && lv.hi == rv.hi;
607: }
608:
609: int
610: _nev(Vlong lv, Vlong rv)
611: {
612: return lv.lo != rv.lo || lv.hi != rv.hi;
613: }
614:
615: int
616: _ltv(Vlong lv, Vlong rv)
617: {
618: return (long)lv.hi < (long)rv.hi ||
619: (lv.hi == rv.hi && lv.lo < rv.lo);
620: }
621:
622: int
623: _lev(Vlong lv, Vlong rv)
624: {
625: return (long)lv.hi < (long)rv.hi ||
626: (lv.hi == rv.hi && lv.lo <= rv.lo);
627: }
628:
629: int
630: _gtv(Vlong lv, Vlong rv)
631: {
632: return (long)lv.hi > (long)rv.hi ||
633: (lv.hi == rv.hi && lv.lo > rv.lo);
634: }
635:
636: int
637: _gev(Vlong lv, Vlong rv)
638: {
639: return (long)lv.hi > (long)rv.hi ||
640: (lv.hi == rv.hi && lv.lo >= rv.lo);
641: }
642:
643: int
644: _lov(Vlong lv, Vlong rv)
645: {
646: return lv.hi < rv.hi ||
647: (lv.hi == rv.hi && lv.lo < rv.lo);
648: }
649:
650: int
651: _lsv(Vlong lv, Vlong rv)
652: {
653: return lv.hi < rv.hi ||
654: (lv.hi == rv.hi && lv.lo <= rv.lo);
655: }
656:
657: int
658: _hiv(Vlong lv, Vlong rv)
659: {
660: return lv.hi > rv.hi ||
661: (lv.hi == rv.hi && lv.lo > rv.lo);
662: }
663:
664: int
665: _hsv(Vlong lv, Vlong rv)
666: {
667: return lv.hi > rv.hi ||
668: (lv.hi == rv.hi && lv.lo >= rv.lo);
669: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.