![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to maskbits.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mfb|
Return to maskbits.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mfb |
1.1 root 1: /* $Header: maskbits.c,v 1.2 87/09/07 19:04:44 rws Exp $ */
2: /***********************************************************
3: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
4: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
5:
6: All Rights Reserved
7:
8: Permission to use, copy, modify, and distribute this software and its
9: documentation for any purpose and without fee is hereby granted,
10: provided that the above copyright notice appear in all copies and that
11: both that copyright notice and this permission notice appear in
12: supporting documentation, and that the names of Digital or MIT not be
13: used in advertising or publicity pertaining to distribution of the
14: software without specific, written prior permission.
15:
16: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
17: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
18: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
19: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
21: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
22: SOFTWARE.
23:
24: ******************************************************************/
25: #include "maskbits.h"
26: #include "servermd.h"
27:
28: /*
29: these tables are used by several macros in the mfb code.
30:
31: the vax numbers everything left to right, so bit indices on the
32: screen match bit indices in longwords. the pc-rt and Sun number
33: bits on the screen the way they would be written on paper,
34: (i.e. msb to the left), and so a bit index n on the screen is
35: bit index 32-n in a longword
36:
37: see also maskbits.h
38: */
39:
40: #if (BITMAP_BIT_ORDER == MSBFirst)
41: /* NOTE:
42: the first element in starttab could be 0xffffffff. making it 0
43: lets us deal with a full first word in the middle loop, rather
44: than having to do the multiple reads and masks that we'd
45: have to do if we thought it was partial.
46: */
47: int starttab[32] =
48: {
49: 0x00000000,
50: 0x7FFFFFFF,
51: 0x3FFFFFFF,
52: 0x1FFFFFFF,
53: 0x0FFFFFFF,
54: 0x07FFFFFF,
55: 0x03FFFFFF,
56: 0x01FFFFFF,
57: 0x00FFFFFF,
58: 0x007FFFFF,
59: 0x003FFFFF,
60: 0x001FFFFF,
61: 0x000FFFFF,
62: 0x0007FFFF,
63: 0x0003FFFF,
64: 0x0001FFFF,
65: 0x0000FFFF,
66: 0x00007FFF,
67: 0x00003FFF,
68: 0x00001FFF,
69: 0x00000FFF,
70: 0x000007FF,
71: 0x000003FF,
72: 0x000001FF,
73: 0x000000FF,
74: 0x0000007F,
75: 0x0000003F,
76: 0x0000001F,
77: 0x0000000F,
78: 0x00000007,
79: 0x00000003,
80: 0x00000001
81: };
82:
83: int endtab[32] =
84: {
85: 0x00000000,
86: 0x80000000,
87: 0xC0000000,
88: 0xE0000000,
89: 0xF0000000,
90: 0xF8000000,
91: 0xFC000000,
92: 0xFE000000,
93: 0xFF000000,
94: 0xFF800000,
95: 0xFFC00000,
96: 0xFFE00000,
97: 0xFFF00000,
98: 0xFFF80000,
99: 0xFFFC0000,
100: 0xFFFE0000,
101: 0xFFFF0000,
102: 0xFFFF8000,
103: 0xFFFFC000,
104: 0xFFFFE000,
105: 0xFFFFF000,
106: 0xFFFFF800,
107: 0xFFFFFC00,
108: 0xFFFFFE00,
109: 0xFFFFFF00,
110: 0xFFFFFF80,
111: 0xFFFFFFC0,
112: 0xFFFFFFE0,
113: 0xFFFFFFF0,
114: 0xFFFFFFF8,
115: 0xFFFFFFFC,
116: 0xFFFFFFFE
117: };
118:
119: /* a hack, for now, since the entries for 0 need to be all
120: 1 bits, not all zeros.
121: this means the code DOES NOT WORK for segments of length
122: 0 (which is only a problem in the horizontal line code.)
123: */
124: int startpartial[32] =
125: {
126: 0xFFFFFFFF,
127: 0x7FFFFFFF,
128: 0x3FFFFFFF,
129: 0x1FFFFFFF,
130: 0x0FFFFFFF,
131: 0x07FFFFFF,
132: 0x03FFFFFF,
133: 0x01FFFFFF,
134: 0x00FFFFFF,
135: 0x007FFFFF,
136: 0x003FFFFF,
137: 0x001FFFFF,
138: 0x000FFFFF,
139: 0x0007FFFF,
140: 0x0003FFFF,
141: 0x0001FFFF,
142: 0x0000FFFF,
143: 0x00007FFF,
144: 0x00003FFF,
145: 0x00001FFF,
146: 0x00000FFF,
147: 0x000007FF,
148: 0x000003FF,
149: 0x000001FF,
150: 0x000000FF,
151: 0x0000007F,
152: 0x0000003F,
153: 0x0000001F,
154: 0x0000000F,
155: 0x00000007,
156: 0x00000003,
157: 0x00000001
158: };
159:
160: int endpartial[32] =
161: {
162: 0xFFFFFFFF,
163: 0x80000000,
164: 0xC0000000,
165: 0xE0000000,
166: 0xF0000000,
167: 0xF8000000,
168: 0xFC000000,
169: 0xFE000000,
170: 0xFF000000,
171: 0xFF800000,
172: 0xFFC00000,
173: 0xFFE00000,
174: 0xFFF00000,
175: 0xFFF80000,
176: 0xFFFC0000,
177: 0xFFFE0000,
178: 0xFFFF0000,
179: 0xFFFF8000,
180: 0xFFFFC000,
181: 0xFFFFE000,
182: 0xFFFFF000,
183: 0xFFFFF800,
184: 0xFFFFFC00,
185: 0xFFFFFE00,
186: 0xFFFFFF00,
187: 0xFFFFFF80,
188: 0xFFFFFFC0,
189: 0xFFFFFFE0,
190: 0xFFFFFFF0,
191: 0xFFFFFFF8,
192: 0xFFFFFFFC,
193: 0xFFFFFFFE
194: };
195: #else /* LSBFirst */
196: /* NOTE:
197: the first element in starttab could be 0xffffffff. making it 0
198: lets us deal with a full first word in the middle loop, rather
199: than having to do the multiple reads and masks that we'd
200: have to do if we thought it was partial.
201: */
202: int starttab[32] =
203: {
204: 0x00000000,
205: 0xFFFFFFFE,
206: 0xFFFFFFFC,
207: 0xFFFFFFF8,
208: 0xFFFFFFF0,
209: 0xFFFFFFE0,
210: 0xFFFFFFC0,
211: 0xFFFFFF80,
212: 0xFFFFFF00,
213: 0xFFFFFE00,
214: 0xFFFFFC00,
215: 0xFFFFF800,
216: 0xFFFFF000,
217: 0xFFFFE000,
218: 0xFFFFC000,
219: 0xFFFF8000,
220: 0xFFFF0000,
221: 0xFFFE0000,
222: 0xFFFC0000,
223: 0xFFF80000,
224: 0xFFF00000,
225: 0xFFE00000,
226: 0xFFC00000,
227: 0xFF800000,
228: 0xFF000000,
229: 0xFE000000,
230: 0xFC000000,
231: 0xF8000000,
232: 0xF0000000,
233: 0xE0000000,
234: 0xC0000000,
235: 0x80000000
236: };
237:
238: int endtab[32] =
239: {
240: 0x00000000,
241: 0x00000001,
242: 0x00000003,
243: 0x00000007,
244: 0x0000000F,
245: 0x0000001F,
246: 0x0000003F,
247: 0x0000007F,
248: 0x000000FF,
249: 0x000001FF,
250: 0x000003FF,
251: 0x000007FF,
252: 0x00000FFF,
253: 0x00001FFF,
254: 0x00003FFF,
255: 0x00007FFF,
256: 0x0000FFFF,
257: 0x0001FFFF,
258: 0x0003FFFF,
259: 0x0007FFFF,
260: 0x000FFFFF,
261: 0x001FFFFF,
262: 0x003FFFFF,
263: 0x007FFFFF,
264: 0x00FFFFFF,
265: 0x01FFFFFF,
266: 0x03FFFFFF,
267: 0x07FFFFFF,
268: 0x0FFFFFFF,
269: 0x1FFFFFFF,
270: 0x3FFFFFFF,
271: 0x7FFFFFFF
272: };
273:
274: /* a hack, for now, since the entries for 0 need to be all
275: 1 bits, not all zeros.
276: this means the code DOES NOT WORK for segments of length
277: 0 (which is only a problem in the horizontal line code.)
278: */
279: int startpartial[32] =
280: {
281: 0xFFFFFFFF,
282: 0xFFFFFFFE,
283: 0xFFFFFFFC,
284: 0xFFFFFFF8,
285: 0xFFFFFFF0,
286: 0xFFFFFFE0,
287: 0xFFFFFFC0,
288: 0xFFFFFF80,
289: 0xFFFFFF00,
290: 0xFFFFFE00,
291: 0xFFFFFC00,
292: 0xFFFFF800,
293: 0xFFFFF000,
294: 0xFFFFE000,
295: 0xFFFFC000,
296: 0xFFFF8000,
297: 0xFFFF0000,
298: 0xFFFE0000,
299: 0xFFFC0000,
300: 0xFFF80000,
301: 0xFFF00000,
302: 0xFFE00000,
303: 0xFFC00000,
304: 0xFF800000,
305: 0xFF000000,
306: 0xFE000000,
307: 0xFC000000,
308: 0xF8000000,
309: 0xF0000000,
310: 0xE0000000,
311: 0xC0000000,
312: 0x80000000
313: };
314:
315: int endpartial[32] =
316: {
317: 0xFFFFFFFF,
318: 0x00000001,
319: 0x00000003,
320: 0x00000007,
321: 0x0000000F,
322: 0x0000001F,
323: 0x0000003F,
324: 0x0000007F,
325: 0x000000FF,
326: 0x000001FF,
327: 0x000003FF,
328: 0x000007FF,
329: 0x00000FFF,
330: 0x00001FFF,
331: 0x00003FFF,
332: 0x00007FFF,
333: 0x0000FFFF,
334: 0x0001FFFF,
335: 0x0003FFFF,
336: 0x0007FFFF,
337: 0x000FFFFF,
338: 0x001FFFFF,
339: 0x003FFFFF,
340: 0x007FFFFF,
341: 0x00FFFFFF,
342: 0x01FFFFFF,
343: 0x03FFFFFF,
344: 0x07FFFFFF,
345: 0x0FFFFFFF,
346: 0x1FFFFFFF,
347: 0x3FFFFFFF,
348: 0x7FFFFFFF
349: };
350: #endif
351:
352:
353: /* used for masking bits in bresenham lines
354: mask[n] is used to mask out all but bit n in a longword (n is a
355: screen position).
356: rmask[n] is used to mask out the single bit at position n (n
357: is a screen posiotion.)
358: */
359:
360: #if (BITMAP_BIT_ORDER == MSBFirst)
361: int mask[] =
362: {
363: 1<<31, 1<<30, 1<<29, 1<<28, 1<<27, 1<<26, 1<<25, 1<<24,
364: 1<<23, 1<<22, 1<<21, 1<<20, 1<<19, 1<<18, 1<<17, 1<<16,
365: 1<<15, 1<<14, 1<<13, 1<<12, 1<<11, 1<<10, 1<<9, 1<<8,
366: 1<<7, 1<<6, 1<<5, 1<<4, 1<<3, 1<<2, 1<<1, 1<<0
367: };
368: int rmask[] =
369: {
370: 0xffffffff ^ (1<<31), 0xffffffff ^ (1<<30), 0xffffffff ^ (1<<29),
371: 0xffffffff ^ (1<<28), 0xffffffff ^ (1<<27), 0xffffffff ^ (1<<26),
372: 0xffffffff ^ (1<<25), 0xffffffff ^ (1<<24), 0xffffffff ^ (1<<23),
373: 0xffffffff ^ (1<<22), 0xffffffff ^ (1<<21), 0xffffffff ^ (1<<20),
374: 0xffffffff ^ (1<<19), 0xffffffff ^ (1<<18), 0xffffffff ^ (1<<17),
375: 0xffffffff ^ (1<<16), 0xffffffff ^ (1<<15), 0xffffffff ^ (1<<14),
376: 0xffffffff ^ (1<<13), 0xffffffff ^ (1<<12), 0xffffffff ^ (1<<11),
377: 0xffffffff ^ (1<<10), 0xffffffff ^ (1<<9), 0xffffffff ^ (1<<8),
378: 0xffffffff ^ (1<<7), 0xffffffff ^ (1<<6), 0xffffffff ^ (1<<5),
379: 0xffffffff ^ (1<<4), 0xffffffff ^ (1<<3), 0xffffffff ^ (1<<2),
380: 0xffffffff ^ (1<<1), 0xffffffff ^ (1<<0)
381: };
382: #else /* LSBFirst */
383: int mask[] =
384: {
385: 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
386: 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
387: 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
388: 1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30, 1<<31
389: };
390: int rmask[] =
391: {
392: 0xffffffff ^ (1<<0), 0xffffffff ^ (1<<1), 0xffffffff ^ (1<<2),
393: 0xffffffff ^ (1<<3), 0xffffffff ^ (1<<4), 0xffffffff ^ (1<<5),
394: 0xffffffff ^ (1<<6), 0xffffffff ^ (1<<7), 0xffffffff ^ (1<<8),
395: 0xffffffff ^ (1<<9), 0xffffffff ^ (1<<10), 0xffffffff ^ (1<<11),
396: 0xffffffff ^ (1<<12), 0xffffffff ^ (1<<13), 0xffffffff ^ (1<<14),
397: 0xffffffff ^ (1<<15), 0xffffffff ^ (1<<16), 0xffffffff ^ (1<<17),
398: 0xffffffff ^ (1<<18), 0xffffffff ^ (1<<19), 0xffffffff ^ (1<<20),
399: 0xffffffff ^ (1<<21), 0xffffffff ^ (1<<22), 0xffffffff ^ (1<<23),
400: 0xffffffff ^ (1<<24), 0xffffffff ^ (1<<25), 0xffffffff ^ (1<<26),
401: 0xffffffff ^ (1<<27), 0xffffffff ^ (1<<28), 0xffffffff ^ (1<<29),
402: 0xffffffff ^ (1<<30), 0xffffffff ^ (1<<31)
403: };
404: #endif
405:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.